Repository: Kozea/WeasyPrint
Branch: main
Commit: 0aea2e12cbfe
Files: 190
Total size: 2.7 MB

Directory structure:
gitextract_594bexrt/

├── .github/
│   ├── FUNDING.yml
│   └── workflows/
│       ├── doconfly.yml
│       ├── exe.yml
│       ├── release.yml
│       ├── test_pdfa.yml
│       ├── test_pdfua.yml
│       ├── test_samples.yml
│       └── tests.yml
├── .gitignore
├── LICENSE
├── README.rst
├── docs/
│   ├── api_reference.rst
│   ├── changelog.rst
│   ├── common_use_cases.rst
│   ├── conf.py
│   ├── contribute.rst
│   ├── first_steps.rst
│   ├── going_further.rst
│   ├── index.rst
│   ├── manpage.rst
│   └── support.rst
├── pyproject.toml
├── tests/
│   ├── __init__.py
│   ├── conftest.py
│   ├── css/
│   │   ├── __init__.py
│   │   ├── test_common.py
│   │   ├── test_counters.py
│   │   ├── test_descriptors.py
│   │   ├── test_errors.py
│   │   ├── test_expanders.py
│   │   ├── test_fonts.py
│   │   ├── test_layers.py
│   │   ├── test_math.py
│   │   ├── test_nesting.py
│   │   ├── test_pages.py
│   │   ├── test_target.py
│   │   ├── test_ua.py
│   │   ├── test_validation.py
│   │   └── test_variables.py
│   ├── draw/
│   │   ├── __init__.py
│   │   ├── svg/
│   │   │   ├── __init__.py
│   │   │   ├── test_bounding_box.py
│   │   │   ├── test_clip.py
│   │   │   ├── test_defs.py
│   │   │   ├── test_gradients.py
│   │   │   ├── test_images.py
│   │   │   ├── test_markers.py
│   │   │   ├── test_opacity.py
│   │   │   ├── test_paths.py
│   │   │   ├── test_patterns.py
│   │   │   ├── test_shapes.py
│   │   │   ├── test_text.py
│   │   │   ├── test_transform.py
│   │   │   ├── test_units.py
│   │   │   └── test_visibility.py
│   │   ├── test_absolute.py
│   │   ├── test_background.py
│   │   ├── test_before_after.py
│   │   ├── test_box.py
│   │   ├── test_cmyk_color_profiles.py
│   │   ├── test_column.py
│   │   ├── test_current_color.py
│   │   ├── test_float.py
│   │   ├── test_footnote.py
│   │   ├── test_footnote_column.py
│   │   ├── test_gradient.py
│   │   ├── test_image.py
│   │   ├── test_leader.py
│   │   ├── test_list.py
│   │   ├── test_opacity.py
│   │   ├── test_overflow.py
│   │   ├── test_page.py
│   │   ├── test_table.py
│   │   ├── test_text.py
│   │   ├── test_transform.py
│   │   ├── test_visibility.py
│   │   └── test_whitespace.py
│   ├── layout/
│   │   ├── __init__.py
│   │   ├── test_block.py
│   │   ├── test_column.py
│   │   ├── test_flex.py
│   │   ├── test_float.py
│   │   ├── test_footnotes.py
│   │   ├── test_grid.py
│   │   ├── test_image.py
│   │   ├── test_inline.py
│   │   ├── test_inline_block.py
│   │   ├── test_list.py
│   │   ├── test_logical.py
│   │   ├── test_page.py
│   │   ├── test_position.py
│   │   ├── test_preferred.py
│   │   └── test_table.py
│   ├── resources/
│   │   ├── acid2-reference.html
│   │   ├── acid2-test.html
│   │   ├── cmyk.icc
│   │   ├── doc1.html
│   │   ├── doc1_UTF-16BE.html
│   │   ├── latin1-test.css
│   │   ├── mini_ua.css
│   │   ├── sheet2.css
│   │   ├── sub_directory/
│   │   │   └── sheet1.css
│   │   ├── tests_ua.css
│   │   ├── user.css
│   │   ├── utf8-test.css
│   │   ├── weasyprint.otb
│   │   └── weasyprint.otf
│   ├── test_acid2.py
│   ├── test_api.py
│   ├── test_boxes.py
│   ├── test_fonts.py
│   ├── test_pdf.py
│   ├── test_presentational_hints.py
│   ├── test_stacking.py
│   ├── test_text.py
│   ├── test_unicode.py
│   ├── test_url.py
│   └── testing_utils.py
└── weasyprint/
    ├── __init__.py
    ├── __main__.py
    ├── anchors.py
    ├── css/
    │   ├── __init__.py
    │   ├── computed_values.py
    │   ├── counters.py
    │   ├── functions.py
    │   ├── html5_ph.css
    │   ├── html5_ua.css
    │   ├── html5_ua_form.css
    │   ├── media_queries.py
    │   ├── properties.py
    │   ├── targets.py
    │   ├── tokens.py
    │   ├── units.py
    │   └── validation/
    │       ├── __init__.py
    │       ├── descriptors.py
    │       ├── expanders.py
    │       └── properties.py
    ├── document.py
    ├── draw/
    │   ├── __init__.py
    │   ├── border.py
    │   ├── color.py
    │   └── text.py
    ├── formatting_structure/
    │   ├── boxes.py
    │   └── build.py
    ├── html.py
    ├── images.py
    ├── layout/
    │   ├── __init__.py
    │   ├── absolute.py
    │   ├── background.py
    │   ├── block.py
    │   ├── column.py
    │   ├── flex.py
    │   ├── float.py
    │   ├── grid.py
    │   ├── inline.py
    │   ├── leader.py
    │   ├── min_max.py
    │   ├── page.py
    │   ├── percent.py
    │   ├── preferred.py
    │   ├── replaced.py
    │   └── table.py
    ├── logger.py
    ├── matrix.py
    ├── pdf/
    │   ├── __init__.py
    │   ├── anchors.py
    │   ├── debug.py
    │   ├── fonts.py
    │   ├── metadata.py
    │   ├── pdfa.py
    │   ├── pdfua.py
    │   ├── pdfx.py
    │   ├── sRGB2014.icc
    │   ├── stream.py
    │   └── tags.py
    ├── stacking.py
    ├── svg/
    │   ├── __init__.py
    │   ├── bounding_box.py
    │   ├── css.py
    │   ├── defs.py
    │   ├── images.py
    │   ├── path.py
    │   ├── shapes.py
    │   ├── text.py
    │   └── utils.py
    ├── text/
    │   ├── constants.py
    │   ├── ffi.py
    │   ├── fonts.py
    │   └── line_break.py
    └── urls.py

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/FUNDING.yml
================================================
# These are supported funding model platforms

open_collective: courtbouillon


================================================
FILE: .github/workflows/doconfly.yml
================================================
name: doconfly
on:
  push:
    branches:
      - main
    tags:
      - "*"

jobs:
  doconfly:
    name: doconfly job
    runs-on: ubuntu-latest
    env:
      PORT: ${{ secrets.PORT }}
      SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}
      TAKOYAKI: ${{ secrets.TAKOYAKI }}
      USER: ${{ secrets.USER }}
      DOCUMENTATION_PATH: ${{ secrets.DOCUMENTATION_PATH }}
      DOCUMENTATION_URL: ${{ secrets.DOCUMENTATION_URL }}
    steps:
      - run: |
          which ssh-agent || ( apt-get update -y && apt-get install openssh-client -y )
          eval $(ssh-agent -s)
          echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add -
          mkdir -p ~/.ssh
          chmod 700 ~/.ssh
          ssh-keyscan -p $PORT $TAKOYAKI >> ~/.ssh/known_hosts
          chmod 644 ~/.ssh/known_hosts
          ssh $USER@$TAKOYAKI -p $PORT "doconfly/doconfly.sh $GITHUB_REPOSITORY $GITHUB_REF $DOCUMENTATION_PATH $DOCUMENTATION_URL"


================================================
FILE: .github/workflows/exe.yml
================================================
name: WeasyPrint’s exe generation
on: [push]

jobs:
  generate:
    name: ${{ matrix.os }}
    runs-on: 'windows-latest'
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.13'
      - name: Use absolute imports and install Pango (Windows)
        run: |
          C:\msys64\usr\bin\bash -lc 'pacman -S mingw-w64-x86_64-pango mingw-w64-x86_64-sed --noconfirm'
          C:\msys64\mingw64\bin\sed -i 's/^from \. /from weasyprint /' weasyprint/__main__.py
          C:\msys64\mingw64\bin\sed  -i 's/^from \./from weasyprint\./' weasyprint/__main__.py
          echo "C:\msys64\mingw64\bin" | Out-File -FilePath $env:GITHUB_PATH
          rm C:\msys64\mingw64\bin\python.exe
      - name: Install requirements
        run: python -m pip install . pyinstaller
      - name: Generate executable
        run: python -m PyInstaller weasyprint/__main__.py -n weasyprint -F
      - name: Test executable
        run: dist/weasyprint --info
      - name: Store executable
        uses: actions/upload-artifact@v4
        with:
          name: weasyprint-windows
          path: |
            dist/weasyprint
            dist/weasyprint.exe
            README.rst
            LICENSE


================================================
FILE: .github/workflows/release.yml
================================================
name: Release new version
on:
  push:
    tags:
      - v*

jobs:
  pypi-publish:
    name: Upload release to PyPI
    runs-on: ubuntu-latest
    environment:
      name: pypi
      url: https://pypi.org/p/weasyprint
    permissions:
      id-token: write
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
      - name: Install requirements
        run: python -m pip install flit
      - name: Build packages
        run: flit build
      - name: Publish package distributions to PyPI
        uses: pypa/gh-action-pypi-publish@release/v1
  add-version:
    name: Add version to GitHub
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Install requirements
        run: sudo apt-get install pandoc
      - name: Generate content
        run: |
          pandoc docs/changelog.rst -f rst -t gfm | csplit - /##/ "{1}" -f .part
          sed -r "s/^([A-Z].*)\:\$/## \1/" .part01 | sed -r "s/^ *//" | sed -rz "s/([^\n])\n([^\n^-])/\1 \2/g" | tail -n +5 > .body
      - name: Create Release
        uses: softprops/action-gh-release@v2
        with:
          body_path: .body


================================================
FILE: .github/workflows/test_pdfa.yml
================================================
name: WeasyPrint's PDF/A tests
on: [push, pull_request]

env:
  PDF_FOLDER: 'pdfs'
  VERA_FOLDER: 'vera'

jobs:
  pdf-ua:
    name: Test PDF/A samples
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install requirements
        run: python -m pip install .
      - name: Create output folders
        run: |
          mkdir ${{env.PDF_FOLDER}}
          mkdir ${{env.VERA_FOLDER}}
      - name: Clone samples repository
        run: git clone https://github.com/CourtBouillon/weasyprint-samples.git
      - name: Generate samples
        run: |
          python -m weasyprint --pdf-variant pdf/a-1a weasyprint-samples/book/book.html -s weasyprint-samples/book/book-classical.css ${{env.PDF_FOLDER}}/book-classical.pdf
          python -m weasyprint --pdf-variant pdf/a-2u weasyprint-samples/book/book.html -s weasyprint-samples/book/book.css -s <(echo '* { image-rendering: crisp-edges }') ${{env.PDF_FOLDER}}/book-fancy.pdf
          python -m weasyprint --pdf-variant pdf/a-2b weasyprint-samples/letter/letter.html -s <(echo '* { image-rendering: crisp-edges }') ${{env.PDF_FOLDER}}/letter.pdf
          python -m weasyprint --pdf-variant pdf/a-3a -s <(echo '* { image-rendering: crisp-edges }') weasyprint-samples/report/report.html ${{env.PDF_FOLDER}}/report.pdf
      - name: Install VeraPDF
        run: |
          wget https://software.verapdf.org/releases/verapdf-installer.zip
          unzip verapdf-installer.zip
          java -DINSTALL_PATH=/tmp -jar verapdf-greenfield-*/verapdf-izpack-installer-*.jar -options-system
      - name: Generate VeraPDF reports
        run: |
          /tmp/verapdf -f 1a --format html ${{env.PDF_FOLDER}}/book-classical.pdf > ${{env.VERA_FOLDER}}/book-classical-verapdf.html
          /tmp/verapdf -f 2u --format html ${{env.PDF_FOLDER}}/book-fancy.pdf > ${{env.VERA_FOLDER}}/book-fancy-verapdf.html
          /tmp/verapdf -f 2b --format html ${{env.PDF_FOLDER}}/letter.pdf > ${{env.VERA_FOLDER}}/letter-verapdf.html
          /tmp/verapdf -f 3a --format html ${{env.PDF_FOLDER}}/report.pdf > ${{env.VERA_FOLDER}}/report-verapdf.html
          /tmp/verapdf --format html ${{env.PDF_FOLDER}}/ > ${{env.VERA_FOLDER}}/summary.html
      - name: Archive generated PDFs
        if: ${{ always() }}
        uses: actions/upload-artifact@v4
        with:
          name: vera-results
          path: |
            ${{env.VERA_FOLDER}}
            ${{env.PDF_FOLDER}}
          retention-days: 1


================================================
FILE: .github/workflows/test_pdfua.yml
================================================
name: WeasyPrint's PDF/UA tests
on: [push, pull_request]

env:
  PDF_FOLDER: 'pdfs'
  VERA_FOLDER: 'vera'

jobs:
  pdf-ua:
    name: Test PDF/UA samples
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install requirements
        run: python -m pip install .
      - name: Create output folders
        run: |
          mkdir ${{env.PDF_FOLDER}}
          mkdir ${{env.VERA_FOLDER}}
      - name: Clone samples repository
        run: git clone https://github.com/CourtBouillon/weasyprint-samples.git
      - name: Generate samples
        run: |
          python -m weasyprint --pdf-variant pdf/ua-1 weasyprint-samples/book/book.html -s weasyprint-samples/book/book-classical.css ${{env.PDF_FOLDER}}/book-classical.pdf
          python -m weasyprint --pdf-variant pdf/ua-1 weasyprint-samples/book/book.html -s weasyprint-samples/book/book.css ${{env.PDF_FOLDER}}/book-fancy.pdf
          python -m weasyprint --pdf-variant pdf/ua-1 weasyprint-samples/letter/letter.html ${{env.PDF_FOLDER}}/letter.pdf
          python -m weasyprint --pdf-variant pdf/ua-1 weasyprint-samples/report/report.html ${{env.PDF_FOLDER}}/report.pdf
      - name: Install VeraPDF
        run: |
          wget https://software.verapdf.org/releases/verapdf-installer.zip
          unzip verapdf-installer.zip
          java -DINSTALL_PATH=/tmp -jar verapdf-greenfield-*/verapdf-izpack-installer-*.jar -options-system
      - name: Generate VeraPDF reports
        run: |
          /tmp/verapdf -f ua1 --format html ${{env.PDF_FOLDER}}/book-classical.pdf > ${{env.VERA_FOLDER}}/book-classical-verapdf.html
          /tmp/verapdf -f ua1 --format html ${{env.PDF_FOLDER}}/book-fancy.pdf > ${{env.VERA_FOLDER}}/book-fancy-verapdf.html
          /tmp/verapdf -f ua1 --format html ${{env.PDF_FOLDER}}/letter.pdf > ${{env.VERA_FOLDER}}/letter-verapdf.html
          /tmp/verapdf -f ua1 --format html ${{env.PDF_FOLDER}}/report.pdf > ${{env.VERA_FOLDER}}/report-verapdf.html
          /tmp/verapdf -f ua1 --format html ${{env.PDF_FOLDER}}/ > ${{env.VERA_FOLDER}}/summary.html
      - name: Archive generated PDFs
        if: ${{ always() }}
        uses: actions/upload-artifact@v4
        with:
          name: vera-results
          path: |
            ${{env.VERA_FOLDER}}
            ${{env.PDF_FOLDER}}
          retention-days: 1


================================================
FILE: .github/workflows/test_samples.yml
================================================
name: WeasyPrint's samples tests
on: [push, pull_request]

env:
  REPORTS_FOLDER: 'report'

jobs:
  samples:
    name: Generate samples
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
      - name: Upgrade pip and setuptools
        run: python -m pip install --upgrade pip setuptools
      - name: Install requirements
        run: python -m pip install .
      - name: Clone samples repository
        run: git clone https://github.com/CourtBouillon/weasyprint-samples.git
      - name: Create output folder
        run: mkdir ${{env.REPORTS_FOLDER}}
      - name: Book classical
        run: python -m weasyprint weasyprint-samples/book/book.html -s weasyprint-samples/book/book-classical.css ${{env.REPORTS_FOLDER}}/book-classical.pdf
      - name: Book fancy
        run: python -m weasyprint weasyprint-samples/book/book.html -s weasyprint-samples/book/book.css ${{env.REPORTS_FOLDER}}/book-fancy.pdf
      - name: Invoice
        run: python -m weasyprint weasyprint-samples/invoice/invoice.html ${{env.REPORTS_FOLDER}}/invoice.pdf
      - name: Letter
        run: python -m weasyprint weasyprint-samples/letter/letter.html ${{env.REPORTS_FOLDER}}/letter.pdf
      - name: Poster
        run: python -m weasyprint weasyprint-samples/poster/poster.html -s weasyprint-samples/poster/poster.css ${{env.REPORTS_FOLDER}}/poster.pdf
      - name: Flyer
        run: python -m weasyprint weasyprint-samples/poster/poster.html -s weasyprint-samples/poster/flyer.css ${{env.REPORTS_FOLDER}}/flyer.pdf
      - name: Report
        run: python -m weasyprint weasyprint-samples/report/report.html ${{env.REPORTS_FOLDER}}/report.pdf
      - name: Ticket
        run: python -m weasyprint weasyprint-samples/ticket/ticket.html ${{env.REPORTS_FOLDER}}/ticket.pdf
      - name: Archive generated PDFs
        uses: actions/upload-artifact@v4
        with:
          name: generated-documents
          path: ${{env.REPORTS_FOLDER}}
          retention-days: 1


================================================
FILE: .github/workflows/tests.yml
================================================
name: WeasyPrint's tests
on: [push, pull_request]

jobs:
  tests:
    name: ${{ matrix.os }} - ${{ matrix.python-version }}
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
        python-version: ['3.14']
        include:
          - os: ubuntu-latest
            python-version: '3.10'
          - os: ubuntu-latest
            python-version: 'pypy-3.11'
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install Ghostscript (Ubuntu)
        if: matrix.os == 'ubuntu-latest'
        run: sudo apt-get update -y && sudo apt-get install ghostscript -y
      - name: Install DejaVu, Pango and Ghostscript (MacOS)
        if: matrix.os == 'macos-latest'
        run: |
          brew update
          brew install --cask font-dejavu
          brew install pango ghostscript
      - name: Install DejaVu, Pango and Ghostscript (Windows)
        if: matrix.os == 'windows-latest'
        run: |
          C:\msys64\usr\bin\bash -lc 'pacman -S mingw-w64-x86_64-ttf-dejavu mingw-w64-x86_64-pango mingw-w64-x86_64-ghostscript --noconfirm'
          xcopy "C:\msys64\mingw64\share\fonts\TTF" "C:\Users\runneradmin\.fonts" /e /i
          echo "C:\msys64\mingw64\bin" | Out-File -FilePath $env:GITHUB_PATH
          rm C:\msys64\mingw64\bin\python.exe
      - name: Upgrade pip and setuptools
        run: python -m pip install --upgrade pip setuptools
      - name: Install tests’ requirements
        run: python -m pip install .[test] pytest-xdist
      - name: Launch tests
        run: python -m pytest -n auto
        env:
          DYLD_FALLBACK_LIBRARY_PATH: /opt/homebrew/lib
      - name: Check coding style
        run: python -m ruff check


================================================
FILE: .gitignore
================================================
*.pyc
.cache
/.coverage
/build
/dist
/docs/_build
/pytest_cache
/tests/draw/results
/venv


================================================
FILE: LICENSE
================================================
BSD 3-Clause License

Copyright (c) 2011-2021, Simon Sapin and contributors.
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

* Neither the name of the copyright holder nor the names of its
  contributors may be used to endorse or promote products derived from
  this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


================================================
FILE: README.rst
================================================
**The Awesome Document Factory**

WeasyPrint is a smart solution helping web developers to create PDF
documents. It turns simple HTML pages into gorgeous statistical reports,
invoices, tickets…

From a technical point of view, WeasyPrint is a visual rendering engine for
HTML and CSS that can export to PDF. It aims to support web standards for
printing. WeasyPrint is free software made available under a BSD license.

It is based on various libraries but *not* on a full rendering engine like
WebKit or Gecko. The CSS layout engine is written in Python, designed for
pagination, and meant to be easy to hack on.

* Free software: BSD license
* For Python 3.10+, tested on CPython and PyPy
* Documentation: https://doc.courtbouillon.org/weasyprint
* Examples: https://weasyprint.org/#samples
* Changelog: https://github.com/Kozea/WeasyPrint/releases
* Code, issues, tests: https://github.com/Kozea/WeasyPrint
* Code of conduct: https://www.courtbouillon.org/code-of-conduct
* Professional support: https://www.courtbouillon.org
* Donation: https://opencollective.com/courtbouillon

WeasyPrint has been created and developed by Kozea (https://kozea.fr/).
Professional support, maintenance and community management is provided by
CourtBouillon (https://www.courtbouillon.org/).

Copyrights are retained by their contributors, no copyright assignment is
required to contribute to WeasyPrint. Unless explicitly stated otherwise, any
contribution intentionally submitted for inclusion is licensed under the BSD
3-clause license, without any additional terms or conditions. For full
authorship information, see the version control history.


================================================
FILE: docs/api_reference.rst
================================================
API Reference
=============

.. currentmodule:: weasyprint


This page is for WeasyPrint |version|. See :doc:`changelog </changelog>` for
older versions.


API Stability
-------------

Everything described here is considered “public”: this is what you can rely
on. We will try to maintain backward-compatibility, and we really often do, but
there is no hard promise.

Anything else should not be used outside of WeasyPrint itself. We reserve
the right to change it or remove it at any point. Use it at your own risk,
or have dependency to a specific WeasyPrint version.


Versioning
----------

WeasyPrint provides frequent major releases, and minor releases with only bug
fixes. Versioning is close to what many browsers do, including Firefox and
Chrome: big major numbers, small minor numbers.

Even if each version does not break the API, each version does break the way
documents are rendered, which is what really matters at the end. Providing
minor versions would give the illusion that developers can just update
WeasyPrint without checking that everything works.

Unfortunately, we have the same problem as the other browsers: when a new
version is released, most of the user's websites are rendered exactly the same,
but a small part is not. And the only ways to know that, for web developers,
are to read the changelog and to check that their pages are correctly rendered.

More about this choice can be found in
issue `#900`_.

.. _#900: https://github.com/Kozea/WeasyPrint/issues/900


Command-line API
----------------

.. autofunction:: weasyprint.__main__.main(argv=sys.argv)


Python API
----------

.. autoclass:: HTML(input, **kwargs)
    :members:
.. autoclass:: CSS(input, **kwargs)
.. autoclass:: Attachment(input, **kwargs)
.. autodata:: DEFAULT_OPTIONS

.. module:: weasyprint.document
.. autoclass:: Document
    :members:
.. autoclass:: DocumentMetadata()
    :members:
.. autoclass:: Page()
    :members:
    :exclude-members: paint

.. module:: weasyprint.urls
.. autoclass:: URLFetcher
    :members:
    :member-order: bysource
.. autoclass:: URLFetcherResponse
.. autoclass:: FatalURLFetchingError

.. module:: weasyprint.text.fonts
.. autoclass:: FontConfiguration()

.. module:: weasyprint.css.counters
.. autoclass:: CounterStyle()


Supported Features
------------------


URLs
~~~~

WeasyPrint can read normal files, HTTP, FTP and `data URIs`_. It will follow
HTTP redirects but more advanced features like cookies and authentication
are currently not supported, although a custom :ref:`URL fetcher
<URL Fetchers>` can help.

.. _data URIs: https://en.wikipedia.org/wiki/Data_URI_scheme


HTML
~~~~

Supported HTML Tags
+++++++++++++++++++

Many HTML elements are implemented in CSS through the HTML5
`User-Agent stylesheet`_.

Some elements need special treatment:

* The ``<base>`` element, if present, determines the base for relative URLs.
* CSS stylesheets can be embedded in ``<style>`` elements or linked by
  ``<link rel=stylesheet>`` elements.
* ``<img>``, ``<embed>`` or ``<object>`` elements accept images either
  in raster formats supported by Pillow_ (including PNG, JPEG, GIF, ...)
  or in SVG. SVG images are not rasterized but rendered
  as vectors in the PDF output.

HTML `presentational hints`_ are not supported by default, but most of them can
be supported:

* by using the ``--presentational-hints`` CLI parameter, or
* by setting the ``presentational_hints`` parameter of the ``HTML.render`` or
  ``HTML.write_*`` methods to ``True``.

Presentational hints include a wide array of attributes that direct styling in
HTML, including font ``color`` and ``size``, list attributes like ``type`` and
``start``, various table alignment attributes, and others. If the document
generated by WeasyPrint is missing some of the features you expect from the
HTML, try to enable this option.

.. _User-Agent stylesheet: https://github.com/Kozea/WeasyPrint/blob/main/weasyprint/css/html5_ua.css
.. _presentational hints: https://www.w3.org/TR/html5/rendering.html#presentational-hints
.. _Pillow: https://python-pillow.org/

Stylesheet Origins
++++++++++++++++++

HTML documents are rendered with stylesheets from three *origins*:

* The HTML5 `user agent stylesheet`_ (defines the default appearance
  of HTML elements);
* Author stylesheets embedded in the document in ``<style>`` elements
  or linked by ``<link rel=stylesheet>`` elements;
* User stylesheets provided in the API.

Keep in mind that *user* stylesheets have a lower priority than *author*
stylesheets in the cascade_, unless you use `!important`_ in declarations
to raise their priority.

.. _user agent stylesheet: https://github.com/Kozea/WeasyPrint/blob/main/weasyprint/css/html5_ua.css
.. _cascade: https://www.w3.org/TR/CSS21/cascade.html#cascading-order
.. _!important: https://www.w3.org/TR/CSS21/cascade.html#important-rules


PDF
~~~

In addition to text, raster and vector graphics, WeasyPrint’s PDF files
can contain hyperlinks, bookmarks, attachments and forms.

Hyperlinks will be clickable in PDF viewers that support them. They can
be either internal, to another part of the same document (eg.
``<a href="#pdf">``) or external, to an URL. External links are resolved
to absolute URLs: ``<a href="/blog-articles/">`` on the CourtBouillon website
would always point to https://www.courtbouillon.org/blog-articles/ in PDF
files.

PDF bookmarks are also called outlines and are generally shown in a
sidebar. Clicking on an entry scrolls the matching part of the document
into view. By default all ``<h1>`` to ``<h6>`` titles generate bookmarks,
but this can be controlled with `PDF bookmarks`_.)

Attachments are related files, embedded in the PDF itself. They can be
specified through ``<link rel=attachment>`` elements to add resources globally
or through regular links with ``<a rel=attachment>`` to attach a resource that
can be saved by clicking on said link. The ``title`` attribute can be used as
description of the attachment.

Generated documents can also include PDF forms, using the ``appearance: auto``
CSS property or the ``--pdf-forms`` CLI option.

The generation of PDF/A and PDF/UA documents is supported. However, the
generated documents are not guaranteed to be valid, and users have the
responsibility to check that they follow the rules listed by the related
specifications.


Fonts
~~~~~

WeasyPrint can use any font that Pango_ can find installed on the system. Fonts are
automatically embedded in PDF files and are subset by default to only include the glyphs
used in the PDF. Subsetting is done with hb-subset_ when available on the system,
or by the slower fontTools_ library as a fallback.

Pango_ always uses Fontconfig_ to access fonts, even on Windows and macOS. You
can list the available fonts thanks to the ``fc-list`` command, and know which
font is matched by a given pattern thanks to ``fc-match``. Copying a font file
into the ``~/.local/share/fonts`` directory is generally enough to install a
new font. WeasyPrint should support the major font formats handled by HarfBuzz_.

WeasyPrint follows the Fontconfig_ configuration of the system. This default
configuration is often useful for many cases: font fallbacks for missing glyphs, aliases
for standard font families like "serif" or "monospace", colored variants for emojis,
etc. But some of these default rules can sometimes interfere with CSS rules, and it may
be interesting to disable them if you need to tweak details about font management.

When a Unicode code point is not supported by a font and its fallbacks, the font’s `.notdef glyph`_ is
displayed instead, and a warning is displayed in logs. Because of the way Pango handles
this case, the .notdef glyph may be rendered with an incorrect width (advance), but the layout of
the other glyphs is correct. Text search and selection work as if the glyph was
available.

.. _hb-subset: https://harfbuzz.github.io/harfbuzz-hb-subset.html
.. _fontTools: https://fonttools.readthedocs.io/en/latest/
.. _Pango: https://www.pango.org/
.. _Fontconfig: https://www.freedesktop.org/wiki/Software/fontconfig/
.. _HarfBuzz: https://harfbuzz.github.io/
.. _.notdef glyph: https://en.wikipedia.org/wiki/Notdef_glyph


CSS
~~~

WeasyPrint supports many of the `CSS specifications`_ written by the W3C. You
will find in this chapter a comprehensive list of the specifications or drafts
with at least one feature implemented in WeasyPrint.

.. _CSS specifications: https://www.w3.org/Style/CSS/current-work

CSS Level 2 Revision 1
++++++++++++++++++++++

The `CSS Level 2 Revision 1`_ specification, best known as CSS 2.1, is pretty
well supported by WeasyPrint. Since version 0.11, it passes the famous `Acid2
Test`_.

The CSS 2.1 features listed here are **not** supported:

* On tables: `visibility: collapse`_.
* Minimum and maximum height_ on table-related boxes.
* Minimum and maximum width_ and height_ on page-margin boxes.
* Conforming `font matching algorithm`_. Currently ``font-family``
  is passed as-is to Pango.
* Right-to-left or `bi-directional text`_.
* `System colors`_ and `system fonts`_. The former are deprecated in `CSS Color
  Module Level 3`_.

.. _CSS Level 2 Revision 1: https://www.w3.org/TR/CSS21/
.. _Acid2 Test: https://www.webstandards.org/files/acid2/test.html
.. _empty-cells: https://www.w3.org/TR/CSS21/tables.html#empty-cells
.. _visibility\: collapse: https://www.w3.org/TR/CSS21/tables.html#dynamic-effects
.. _width: https://www.w3.org/TR/CSS21/visudet.html#min-max-widths
.. _height: https://www.w3.org/TR/CSS21/visudet.html#min-max-heights
.. _font matching algorithm: https://www.w3.org/TR/CSS21/fonts.html#algorithm
.. _Bi-directional text: https://www.w3.org/TR/CSS21/visuren.html#direction
.. _System colors: https://www.w3.org/TR/CSS21/ui.html#system-colors
.. _system fonts: https://www.w3.org/TR/CSS21/fonts.html#propdef-font
.. _CSS Color Module Level 3: https://www.w3.org/TR/css-color-3/

To the best of our knowledge, everything else that applies to the
print media **is** supported. Please report a bug if you find this list
incomplete.

Selectors Level 3 / 4
+++++++++++++++++++++

With the exceptions noted here, all `Selectors Level 3`_ are supported.

PDF is generally not interactive. The ``:hover``, ``:active``, ``:focus``,
``:target`` and ``:visited`` pseudo-classes are accepted as valid but
never match anything.

Everything in `Selectors Level 4`_ is supported, except:

- ``:dir``,
- input pseudo-classes (``:valid``, ``:invalid``…),
- column selector (``||``, ``:nth-col()``, ``:nth-last-col()``).

.. _Selectors Level 3: https://www.w3.org/TR/selectors-3/
.. _Selectors Level 4: https://www.w3.org/TR/selectors-4/

CSS Text Module Level 3 / 4
+++++++++++++++++++++++++++

The `CSS Text Module Level 3`_ and `CSS Text Module Level 4`_ are working
drafts defining "properties for text manipulation" and covering "line breaking,
justification and alignment, white space handling, and text transformation".

Among their features, some are already included in CSS 2.1, sometimes with
missing or different values (``text-indent``, ``text-align``,
``letter-spacing``, ``word-spacing``, ``text-transform``, ``white-space``).

New properties defined in Level 3 are supported:

- the ``overflow-wrap`` property replacing ``word-wrap``;
- the ``break-all`` value of the ``word-break`` property (see `#1153`_);
- the ``full-width`` value of the ``text-transform`` property; and
- the ``start``, ``end`` and ``justify-all`` values of the ``text-align`` property;
- the ``text-align-last`` and ``text-justify`` properties; and
- the ``tab-size`` property.

Properties controlling hyphenation_ are supported by WeasyPrint:

- ``hyphens``,
- ``hyphenate-character``,
- ``hyphenate-limit-chars``, and
- ``hyphenate-limit-zone``.

To get automatic hyphenation, you to set it to ``auto``
*and* have the ``lang`` HTML attribute set to one of the languages
`supported by Pyphen`_.

.. code-block:: html

    <!doctype html>
    <html lang=en>
    <style>
      html { hyphens: auto }
    </style>
    …

Automatic hyphenation can be disabled again with the ``manual`` value:

.. code-block:: css

    html { hyphens: auto }
    a[href]::after { content: ' [' attr(href) ']'; hyphens: manual }

The other features provided by `CSS Text Module Level 3`_ are **not**
supported:

- the ``line-break`` property;
- the ``match-parent`` value of the ``text-align`` property;
- the ``text-indent`` and ``hanging-punctuation`` properties.

The other features provided by `CSS Text Module Level 4`_ are **not**
supported:

- the ``text-space-collapse`` and ``text-space-trim`` properties;
- the ``text-wrap``, ``wrap-before``, ``wrap-after`` and ``wrap-inside``
  properties;
- the ``text-align`` property with an alignment character;
- the ``pre-wrap-auto`` value of the ``white-space`` property; and
- the ``text-spacing`` property.

.. _#1153: https://github.com/Kozea/WeasyPrint/issues/1153
.. _supported by Pyphen: https://github.com/Kozea/Pyphen/tree/main/pyphen/dictionaries
.. _hyphenation: https://www.w3.org/TR/css-text-3/#hyphenation
.. _CSS Text Module Level 3: https://www.w3.org/TR/css-text-3/
.. _CSS Text Module Level 4: https://www.w3.org/TR/css-text-4/

CSS Fonts Module Level 3 / 4
++++++++++++++++++++++++++++

The `CSS Fonts Module Level 3`_ is a candidate recommendation describing "how
font properties are specified and how font resources are loaded dynamically".

WeasyPrint supports the ``font-size``, ``font-stretch``, ``font-style`` and
``font-weight`` properties, coming from CSS 2.1.

WeasyPrint also supports the following font features added in Level 3:
- ``font-kerning``,
- ``font-variant-ligatures``,
- ``font-variant-position``,
- ``font-variant-caps``,
- ``font-variant-numeric``,
- ``font-variant-east-asian``,
- ``font-feature-settings``, and
- ``font-language-override``.

``font-family`` is supported. The string is given to Pango that tries to find a
matching font in a way different from what is defined in the recommendation,
but that should not be a problem for common use.

The shorthand ``font`` and ``font-variant`` properties are supported.

WeasyPrint supports the ``@font-face`` rule.

WeasyPrint does **not** support the ``@font-feature-values`` rule and the
values of ``font-variant-alternates`` other than ``normal`` and
``historical-forms``.

From `CSS Fonts Module Level 4`_ we only support the
``font-variation-settings`` property enabling specific font variations.

.. _CSS Fonts Module Level 3: https://www.w3.org/TR/css-fonts-3/
.. _CSS Fonts Module Level 4: https://www.w3.org/TR/css-fonts-4/


CSS Paged Media Module Level 3
++++++++++++++++++++++++++++++

The `CSS Paged Media Module Level 3`_ is a working draft including features for
paged media "describing how:

- page breaks are created and avoided;
- the page properties such as size, orientation, margins, border, and padding
  are specified;
- headers and footers are established within the page margins;
- content such as page counters are placed in the headers and footers; and
- orphans and widows can be controlled."

All the features of this draft are available, including:

- the ``@page`` rule and the ``:left``, ``:right``, ``:first`` and ``:blank``
  selectors;
- the page margin boxes;
- the page-based counters (with known limitations  `#93`_);
- the page ``size``, ``bleed`` and ``marks`` properties;
- the named pages.

.. _CSS Paged Media Module Level 3: https://drafts.csswg.org/css-page-3/
.. _#93: https://github.com/Kozea/WeasyPrint/issues/93

CSS Generated Content for Paged Media Module
++++++++++++++++++++++++++++++++++++++++++++

The `CSS Generated Content for Paged Media Module`_ (GCPM) is a working draft
defining "new properties and values, so that authors may bring new techniques
(running headers and footers, footnotes, page selection) to paged media".

`Page selectors`_ are supported by WeasyPrint. You can select pages according
to their position in the document:

.. code-block:: css

    @page :nth(3) { background: red } /* Third page */
    @page :nth(2n+1) { background: green } /* Odd pages */
    @page :nth(1 of chapter) { background: blue } /* First pages of chapters */

You can also use `running elements`_ to put HTML boxes into the page margins
(but the ``start`` parameter of ``element()`` is not supported).

Footnotes_ are supported. You can put a box in the footnote area using the
``float: footnote`` property. Footnote markers and footnote calls can be
defined using the ``::footnote-marker`` and ``::footnote-call``
pseudo-elements. You can also change the way footnotes are displayed using the
``footnote-display`` property (``compact`` is not supported), and influence
over the rendering of difficult pages with ``footnote-policy``.

.. _CSS Generated Content for Paged Media Module: https://www.w3.org/TR/css-gcpm-3/
.. _Page selectors: https://www.w3.org/TR/css-gcpm-3/#document-page-selectors
.. _running elements: https://www.w3.org/TR/css-gcpm-3/#running-elements
.. _Footnotes: https://www.w3.org/TR/css-gcpm-3/#footnotes

CSS Generated Content Module Level 3
++++++++++++++++++++++++++++++++++++

The `CSS Generated Content Module Level 3`_ is a working draft helping "authors
[who] sometimes want user agents to render content that does not come from the
document tree. One familiar example of this is numbered headings
[…]. Similarly, authors may want the user agent to insert the word "Figure"
before the caption of a figure […], or replacing elements with images or other
multimedia content."

`Named strings`_ are supported by WeasyPrint. You can define strings related to
the first or last element of a type present on a page, and display these
strings in page borders. This feature is really useful to add the title of the
current chapter at the top of the pages of a book for example.

The named strings can embed static strings, counters, cross-references, tag
contents and tag attributes.

.. code-block:: css

    @top-center { content: string(chapter) }
    h2 { string-set: chapter "Current chapter: " content() }

`Cross-references`_ retrieve counter or content values from targets (anchors or
identifiers) in the current document:

.. code-block:: css

    a::after { content: ", on page " target-counter(attr(href), page) }
    a::after { content: ", see " target-text(attr(href)) }

In particular, ``target-counter()`` and ``target-text()`` are useful when it
comes to tables of contents (see `an example`_).

You can also control `PDF bookmarks`_ with WeasyPrint. Using the
``bookmark-level``, ``bookmark-label`` and ``bookmark-state`` properties, you
can add bookmarks that will be available in your PDF reader.

Bookmarks have already been added in the WeasyPrint's `user agent stylesheet`_,
so your generated documents will automatically have bookmarks on headers (from
``<h1>`` to ``<h6>``). But for example, if you have only one top-level ``<h1>``
and do not wish to include it in the bookmarks, add this in your stylesheet:

.. code-block:: css

    h1 { bookmark-level: none }

`Leaders`_ are also supported:

.. code-block:: css

    li a::after {
        content: ' ' leader(dotted) ' ' target-counter(attr(href), page);
    }

The other features of this module are **not** implemented:

- quotes (``content: *-quote``);

.. _CSS Generated Content Module Level 3: https://www.w3.org/TR/css-content-3/
.. _Quotes: https://www.w3.org/TR/css-content-3/#quotes
.. _Named strings: https://www.w3.org/TR/css-content-3/#named-strings
.. _Cross-references: https://www.w3.org/TR/css-content-3/#cross-references
.. _an example: https://github.com/Kozea/WeasyPrint/pull/652#issuecomment-403276559
.. _PDF bookmarks: https://www.w3.org/TR/css-content-3/#bookmark-generation
.. _user agent stylesheet: https://github.com/Kozea/WeasyPrint/blob/main/weasyprint/css/html5_ua.css
.. _Leaders: https://www.w3.org/TR/css-content-3/#leaders

CSS Color Module Level 4 / 5
++++++++++++++++++++++++++++

The `CSS Color Module Level 4`_ is a recommendation defining "CSS properties which allow
authors to specify the foreground color and opacity of the text content of an element".
Its main goal is to specify how colors are defined, including color keywords and many
color notations including ``#rgba``, ``rgb()``, ``hsl()``, ``hwb()``, ``lab()``, etc.
The standard ``color()`` function gives a common way to define colors giving their color
space. Opacity and alpha compositing are also defined in this document.

This recommendation is fully implemented in WeasyPrint, except the deprecated
System Colors.

The `CSS Color Module Level 5`_ is a working draft adding "color modification functions,
custom color spaces (ICC profiles), ``contrast-color()``, ``light-dark()`` and
``device-cmyk()``" to level 4.

WeasyPrint supports the ``light-dark()`` and ``device-cmyk()`` properties, and the
``@color-profile`` at-rule.

WeasyPrint does **not** support the ``color-mix()`` and ``contrast-color()`` properties.

.. _CSS Color Module Level 4: https://www.w3.org/TR/css-color-4/
.. _CSS Color Module Level 5: https://www.w3.org/TR/css-color-5/

CSS Transforms Module Level 1
+++++++++++++++++++++++++++++

The `CSS Transforms Module Level 1`_ working draft "describes a coordinate
system within each element is positioned. This coordinate space can be modified
with the transform property. Using transform, elements can be translated,
rotated and scaled in two or three dimensional space."

WeasyPrint supports the ``transform`` and ``transform-origin`` properties, and
all the 2D transformations (``matrix``, ``rotate``, ``translate``,
``translateX``, ``translateY``, ``scale``, ``scaleX``, ``scaleY``, ``skew``,
``skewX``, ``skewY``).

WeasyPrint does **not** support the ``transform-style``, ``perspective``,
``perspective-origin`` and ``backface-visibility`` properties, and all the 3D
transformations (``matrix3d``, ``rotate3d``, ``rotateX``, ``rotateY``,
``rotateZ``, ``translate3d``, ``translateZ``, ``scale3d``, ``scaleZ``).

.. _CSS Transforms Module Level 1: https://drafts.csswg.org/css-transforms-1/

CSS Backgrounds and Borders Module Level 3
++++++++++++++++++++++++++++++++++++++++++

The `CSS Backgrounds and Borders Module Level 3`_ is a candidate recommendation
defining properties dealing "with the decoration of the border area and with
the background of the content, padding and border areas".

The `border part`_ of this module is supported, as it is already included in
the the CSS 2.1 specification.

WeasyPrint supports the `background part`_ of this module (allowing multiple
background layers per box), including the ``background``, ``background-color``,
``background-image``, ``background-repeat``, ``background-attachment``,
``background-position``, ``background-clip``, ``background-origin`` and
``background-size`` properties.

WeasyPrint also supports the `rounded corners part`_ of this module, including
the ``border-radius`` property.

WeasyPrint also supports the `border images part`_ of this module, including the
``border-image``, ``border-image-source``, ``border-image-slice``,
``border-image-width``, ``border-image-outset`` and ``border-image-repeat``
properties.

WeasyPrint does **not** support the `box shadow part`_ of this module,
including the ``box-shadow`` property. This feature has been implemented in a
`git branch`_ that is not released, as it relies on raster implementation of
shadows.

.. _CSS Backgrounds and Borders Level 3: https://www.w3.org/TR/css-backgrounds-3/
.. _border part: https://www.w3.org/TR/css-backgrounds-3/#borders
.. _background part: https://www.w3.org/TR/css-backgrounds-3/#backgrounds
.. _rounded corners part: https://www.w3.org/TR/css-backgrounds-3/#corners
.. _border images part: https://www.w3.org/TR/css-backgrounds-3/#border-images
.. _box shadow part: https://www.w3.org/TR/css-backgrounds-3/#misc
.. _git branch: https://github.com/Kozea/WeasyPrint/pull/149

CSS Image Values and Replaced Content Module Level 3 / 4
++++++++++++++++++++++++++++++++++++++++++++++++++++++++

The `Image Values and Replaced Content Module Level 3`_ is a candidate
recommendation introducing "additional ways of representing 2D images, for
example as a list of URIs denoting fallbacks, or as a gradient", defining
"several properties for manipulating raster images and for sizing or
positioning replaced elements" and "generic sizing algorithm for replaced
elements".

The `Image Values and Replaced Content Module Level 4`_ is a working draft on
the same subject.

The ``linear-gradient()``, ``radial-gradient()`` and
``repeating-radial-gradient()`` properties are supported as background images.

The the ``url()`` notation is supported, but the ``image()`` notation is
**not** supported for background images.

The ``object-fit`` and ``object-position`` properties are supported.

The ``from-image`` and ``snap`` values of the ``image-resolution`` property are
**not** supported, but the ``resolution`` value is supported.

The ``image-rendering`` and ``image-orientation`` properties are supported.

.. _Image Values and Replaced Content Module Level 3: https://www.w3.org/TR/css-images-3/
.. _Image Values and Replaced Content Module Level 4: https://www.w3.org/TR/css-images-4/

CSS Box Sizing Module Level 3
+++++++++++++++++++++++++++++

The `CSS Box Sizing Module Level 3`_ is a candidate recommendation extending
"the CSS sizing properties with keywords that represent content-based
'intrinsic' sizes and context-based 'extrinsic' sizes."

The new property defined in this document is implemented in WeasyPrint:
``box-sizing``.

The ``min-content``, ``max-content`` and ``fit-content()`` sizing values are
**not** supported.

.. _CSS Box Sizing Module Level 3: https://www.w3.org/TR/css-sizing-3/

CSS Overflow Module Level 3
+++++++++++++++++++++++++++

The `CSS Overflow Module Level 3`_ is a working draft containing "the features
of CSS relating to scrollable overflow handling in visual media."

The ``overflow`` property is supported, as defined in CSS2. ``overflow-x``,
``overflow-y``, ``overflow-clip-margin``, ``overflow-inline`` and
``overflow-block`` are **not** supported.

The ``text-overflow``, ``block-ellipsis``, ``line-clamp``, ``max-lines`` and
``continue`` properties are supported.

.. _CSS Overflow Module Level 3: https://www.w3.org/TR/2020/WD-css-overflow-3-20200603/

CSS Values and Units Module Level 3 / 4
+++++++++++++++++++++++++++++++++++++++

The `CSS Values and Units Module Level 3`_ defines various units and
keywords used in "value definition field of each CSS property".

The `CSS Values and Units Module Level 4`_ adds many new units, unit types and math
functions.

The ``initial`` and ``inherit`` CSS-wide keywords are supported, but the
``unset`` keyword is **not** supported.

Quoted strings, URLs and numeric data types are supported.

Font-relative lengths (``*em``, ``*ex``, ``*ch``, ``*cap``, ``*ic``, ``*lh``),
viewport-relative lengths (``*vw``, ``*vh``, ``*vi``, ``*vb``, ``*vmin``, ``*vmax``),
absolute lengths (``cm``, ``mm``, ``q``, ``in``, ``pt``, ``pc``, ``px``), angles
(``rad``, ``grad``, ``turn``, ``deg``), resolutions (``dpi``, ``dpcm``, ``dppx``, ``x``)
are supported.

Unspecified page-relative units (``pvw``, ``pvh``…) are also supported. They are
relative to the whole page size (including page margins), while all the other units are
relative to the page area size (without page margins).

The ``attr()`` functional notation is allowed in the ``content`` and
``string-set`` properties.

All the mathematical functions (``calc()``…) are supported.

.. _CSS Values and Units Module Level 3: https://www.w3.org/TR/css3-values/
.. _CSS Values and Units Module Level 4: https://www.w3.org/TR/css4-values/

CSS Multi-column Layout Module
++++++++++++++++++++++++++++++

The `CSS Multi-column Layout Module`_ "describes multi-column layouts in CSS, a
style sheet language for the web. Using functionality described in the
specification, content can be flowed into multiple columns with a gap and a
rule between them."

Simple multi-column layouts are supported in WeasyPrint. Features such as
constrained height, spanning columns or column breaks are **not**
supported. Pagination and overflow are not seriously tested.

The ``column-width`` and ``column-count`` properties, and the ``columns``
shorthand property are supported.

The ``column-gap``, ``column-rule-color``, ``column-rule-style`` and
``column-rule-width`` properties, and the ``column-rule`` shorthand property
are supported.

The ``break-before``, ``break-after`` and ``break-inside`` properties are
supported.

The ``column-span`` property is supported for direct children of columns.

The ``column-fill`` property is supported, with a column balancing algorithm
that should be efficient with simple cases.

.. _CSS Multi-column Layout Module: https://www.w3.org/TR/css-multicol-1/

CSS Fragmentation Module Level 3 / 4
++++++++++++++++++++++++++++++++++++

The `CSS Fragmentation Module Level 3`_ "describes the fragmentation model that
partitions a flow into pages, columns, or regions. It builds on the Page model
module and introduces and defines the fragmentation model. It adds
functionality for pagination, breaking variable fragment size and orientation,
widows and orphans."

The `CSS Fragmentation Module Level 4`_ is a working draft on the same subject.

The ``break-before``, ``break-after`` and ``break-inside`` properties are
supported for pages, but **not** for columns and regions. ``page-break-*``
aliases as defined in CSS2 are supported too.

The ``orphans`` and ``widows`` properties are supported.

The ``box-decoration-break`` property is supported, but backgrounds are always
repeated and not extended through the whole box as it should be with 'slice'
value.

The ``margin-break`` property is supported.

.. _CSS Fragmentation Module Level 3: https://www.w3.org/TR/css-break-3/
.. _CSS Fragmentation Module Level 4: https://www.w3.org/TR/css-break-4/

CSS Custom Properties for Cascading Variables Module Level 1
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

The `CSS Custom Properties for Cascading Variables Module Level 1`_ "introduces
cascading variables as a new primitive value type that is accepted by all CSS
properties, and custom properties for defining them."

The custom properties and the ``var()`` notation are supported.

.. _CSS Custom Properties for Cascading Variables Module Level 1: https://www.w3.org/TR/css-variables/

CSS Text Decoration Module Level 3 / 4
++++++++++++++++++++++++++++++++++++++

The `CSS Text Decoration Module Level 3`_ "contains the features of CSS
relating to text decoration, such as underlines, text shadows, and emphasis
marks."

The `CSS Text Decoration Module Level 4`_ is a working draft on the same subject.

The ``text-decoration-line``, ``text-decoration-style``,
``text-decoration-color``, ``text-decoration-thickness`` and
``text-underline-offset`` properties are supported. The ``text-decoration``
shorthand is also supported.

The other properties (``text-underline-position``, ``text-emphasis-*``,
``text-shadow``) are not supported.

.. _CSS Text Decoration Module Level 3: https://www.w3.org/TR/css-text-decor-3/
.. _CSS Text Decoration Module Level 4: https://www.w3.org/TR/css-text-decor-4/

CSS Flexible Box Layout Module Level 1
++++++++++++++++++++++++++++++++++++++

The `CSS Flexible Box Layout Module Level 1`_ "describes a CSS box model
optimized for user interface design", also known as "flexbox".

This module works for simple use cases but is not deeply tested.

All the ``flex-*``, ``align-*``, ``justify-*`` and ``order`` properties are
supported. The ``flex`` and ``flex-flow`` shorthands are supported too.

.. _CSS Flexible Box Layout Module Level 1: https://www.w3.org/TR/css-flexbox-1/

CSS Grid Layout Module Level 2
++++++++++++++++++++++++++++++

The `CSS Grid Layout Module Level 2`_ "defines a two-dimensional grid-based layout
system, optimized for user interface design".

This module works for simple cases, but has some limitations. Here are
non-exhaustive lists of supported/unsupported features.

Supported:

- ``display: grid``,
- ``grid-auto-*``, ``grid-template-*`` and other ``grid-*`` properties,
- ``grid`` and other ``grid-*`` shorthands,
- flexible lengths (``fr`` unit),
- line names,
- grid areas,
- auto rows and auto columns,
- ``z-index``,
- ``repeat(X, *)``,
- ``minmax()``,
- ``align-*`` and ``justify-*`` alignment properties,
- ``gap`` and ``*-gap`` properties for gutters,
- dense auto flow,
- ``order``,
- margins, borders, padding on grid containers and grid items,
- fragmentation between rows.

Unsupported or untested:

- ``display: inline-grid``,
- auto content size for grid containers,
- ``grid-auto-flow: column``,
- subgrids,
- ``repeat(auto-fill, *)`` and ``repeat(auto-fit, *)``,
- auto margins for grid items,
- ``span`` with line names,
- ``span`` for flexible tracks,
- ``safe`` and ``unsafe`` alignments,
- baseline alignment,
- grid items with intrinsic size (images),
- distribute space beyond limits,
- grid items larger than grid containers,
- ``min-width``, ``max-width``, ``min-height``, ``max-height`` on grid items,
- complex ``min-content`` and ``max-content`` cases,
- absolutely positioned and floating grid items,
- fragmentation in rows.

.. _CSS Grid Layout Module Level 2: https://www.w3.org/TR/css-grid-2/

CSS Basic User Interface Module Level 3/4
+++++++++++++++++++++++++++++++++++++++++

The `CSS Basic User Interface Module Level 3/4`_ "enables authors to style user
interface related properties and values."

The ``outline-width``, ``outline-style``, ``outline-color`` properties and the
``outline`` shorthand are supported. The ``outline-offset`` property is also
supported.

The ``resize``, ``cursor``, ``caret-*`` and ``nav-*`` properties are **not**
supported.

The ``appearance`` property is supported. When set to ``auto``, it displays
form fields as PDF form fields (supported for text inputs, check boxes, text
areas, and select only).

The ``accent-color`` property is **not** supported.


================================================
FILE: docs/changelog.rst
================================================
Changelog
=========


Version 68.1
------------

Released on 2026-02-06.

Bug fixes:

* `#2662 <https://github.com/Kozea/WeasyPrint/issues/2662>`_:
  Don’t crash when SVG clip paths are not in defs tags
* `#2665 <https://github.com/Kozea/WeasyPrint/issues/2665>`_:
  Fix position of box bounding box
* `#2663 <https://github.com/Kozea/WeasyPrint/issues/2663>`_:
  Fix transparency with Acrobat and Edge
* `#2666 <https://github.com/Kozea/WeasyPrint/issues/2666>`_:
  Don’t rely on random default font to define test page size
* `#2670 <https://github.com/Kozea/WeasyPrint/issues/2670>`_:
  Fix pattern detection of URL schemes
* `#2671 <https://github.com/Kozea/WeasyPrint/pull/2671>`_:
  Improve API compatibility between URLFetcherResponse and addinfourl
* `#2672 <https://github.com/Kozea/WeasyPrint/issues/2672>`_:
  Fix charset for old URL fetcher requests
* `#2675 <https://github.com/Kozea/WeasyPrint/pull/2675>`_,
  `#2673 <https://github.com/Kozea/WeasyPrint/issues/2673>`_:
  Fix calc for many properties

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Spacinov
* Syslifters
* Kobalt
* Simon Sapin
* Grip Angebotssoftware
* Manuel Barkhau
* Simonsoft
* KontextWork
* Menutech
* TrainingSparkle
* Healthchecks.io
* Method B
* FieldHub
* Hammerbacher
* Yanal-Yves Fargialla
* Morntag
* Piloterr
* Xavid
* Charlie S.
* Prothesis Dental Solutions
* Kai DeLorenzo


Version 68.0
------------

Released on 2026-01-19.

**This is a security update (CVE-2025-68616).**

We strongly recommend to upgrade WeasyPrint to the latest version if you use the
``default_url_fetcher`` function in your custom URL fetcher, or if you use the
``allowed_protocols`` parameter of the ``default_url_fetcher`` function.

Security:

* Always use URL fetcher for HTTP redirects

Python API:

* ``default_url_fetcher()`` is deprecated, use the new ``URLFetcher`` class instead, see
  :ref:`URL Fetchers` for more information about URL fetchers
* ``DocumentMetadata.generate_rdf_metadata`` is now a method that can be overridden
  instead of a parameter, see :ref:`Factur-X / ZUGFeRD (Electronic Invoices)` for
  examples to create e-invoices

Features:

* `#2609 <https://github.com/Kozea/WeasyPrint/pull/2609>`_,
  `#2603 <https://github.com/Kozea/WeasyPrint/issues/2603>`_,
  `#351 <https://github.com/Kozea/WeasyPrint/issues/351>`_:
  Refactor URL fetcher API
* `#2632 <https://github.com/Kozea/WeasyPrint/pull/2632>`_:
  Support legacy 0 value for angles
* `#2627 <https://github.com/Kozea/WeasyPrint/pull/2627>`_:
  Add font-face support to SVG
* `#2646 <https://github.com/Kozea/WeasyPrint/pull/2646>`_,
  `#2255 <https://github.com/Kozea/WeasyPrint/issues/2255>`_:
  Add font shorthand support for SVG text elements
* `#2590 <https://github.com/Kozea/WeasyPrint/pull/2590>`_,
  `#1749 <https://github.com/Kozea/WeasyPrint/issues/1749>`_:
  Honor language-specific rules for text-transform
* `#2645 <https://github.com/Kozea/WeasyPrint/pull/2645>`_,
  `#2613 <https://github.com/Kozea/WeasyPrint/issues/2613>`_:
  Improve SVG and SVG emojis rendering
* `#2658 <https://github.com/Kozea/WeasyPrint/pull/2658>`_,
  `#2583 <https://github.com/Kozea/WeasyPrint/issues/2583>`_:
  Add CLI for Factur-X / ZUGFeRD e-invoices

Bug fixes:

* `#2649 <https://github.com/Kozea/WeasyPrint/issues/2649>`_:
  Refactor URL fetcher API
* `#2643 <https://github.com/Kozea/WeasyPrint/pull/2643>`_,
  `#2628 <https://github.com/Kozea/WeasyPrint/issues/2628>`_:
  Handle box-sizing: border-box in grid layout
* `#2641 <https://github.com/Kozea/WeasyPrint/pull/2641>`_,
  `#1875 <https://github.com/Kozea/WeasyPrint/issues/1875>`_:
  Process whitespace after checking all pending targets
* `#2488 <https://github.com/Kozea/WeasyPrint/pull/2488>`_,
  `#2485 <https://github.com/Kozea/WeasyPrint/issues/2485>`_:
  Preserve page groups during layout repagination
* `#2642 <https://github.com/Kozea/WeasyPrint/pull/2642>`_,
  `#2631 <https://github.com/Kozea/WeasyPrint/issues/2631>`_:
  Don’t use isolated transparency groups
* `#2637 <https://github.com/Kozea/WeasyPrint/issues/2637>`_:
  Fix repeating radial gradients rendering
* `#2622 <https://github.com/Kozea/WeasyPrint/issues/2622>`_:
  Fix validation of colors
* `#2626 <https://github.com/Kozea/WeasyPrint/issues/2626>`_:
  Share grid items rendering advancement between a box and its copies
* `#2621 <https://github.com/Kozea/WeasyPrint/issues/2621>`_:
  Correctly handle fallback values of attr()
* `#2619 <https://github.com/Kozea/WeasyPrint/issues/2619>`_:
  Fix SVG fonts
* `#2629 <https://github.com/Kozea/WeasyPrint/issues/2629>`_:
  Always define extra skip height that may be used after
* `#2648 <https://github.com/Kozea/WeasyPrint/issues/2648>`_:
  Fix numbers validation in font-feature-settings
* `#2648 <https://github.com/Kozea/WeasyPrint/issues/2660>`_:
  Fix keyword values for text-decoration-thickness
* `#2661 <https://github.com/Kozea/WeasyPrint/issues/2661>`_:
  Respect inline images when defining minimum table width

Documentation:

* `#2638 <https://github.com/Kozea/WeasyPrint/pull/2638>`_:
  Update Python command for Windows installation steps

Contributors:

* Guillaume Ayoub
* Jurriaan Pruis
* Mohamed Hamed
* Alexandra Usatenko
* Andrea Corna
* Aoishik Khan
* Joe

Backers and sponsors:

* Spacinov
* Syslifters
* Kobalt
* Simon Sapin
* Grip Angebotssoftware
* Manuel Barkhau
* Simonsoft
* KontextWork
* Menutech
* TrainingSparkle
* Healthchecks.io
* Method B
* FieldHub
* Hammerbacher
* Yanal-Yves Fargialla
* Morntag
* Piloterr
* Xavid
* Charlie S.
* Prothesis Dental Solutions
* Kai DeLorenzo


Version 67.0
------------

Released on 2025-12-02.

Dependencies:

* Python 3.10+ is now needed, Python 3.9 is not supported anymore
* tinycss2 1.5.0+ is now needed
* fontTools 4.59.2+ is now needed

Features:

* `#2560 <https://github.com/Kozea/WeasyPrint/pull/2560>`_,
  `#640 <https://github.com/Kozea/WeasyPrint/issues/640>`_,
  `#844 <https://github.com/Kozea/WeasyPrint/issues/844>`_,
  `#1091 <https://github.com/Kozea/WeasyPrint/issues/1091>`_,
  `#2517 <https://github.com/Kozea/WeasyPrint/issues/2517>`_:
  Support CMYK colors, PDF/X, color profiles and light-dark() function
* `#2558 <https://github.com/Kozea/WeasyPrint/pull/2558>`_,
  `#1175 <https://github.com/Kozea/WeasyPrint/issues/1175>`_:
  Support ::first-line, with financial support from Karte Technology
* `#2552 <https://github.com/Kozea/WeasyPrint/pull/2552>`_:
  Support CSS layers, with financial support from Code & Co.
* `#2564 <https://github.com/Kozea/WeasyPrint/pull/2564>`_,
  `#2599 <https://github.com/Kozea/WeasyPrint/pull/2599>`_,
  `#2397 <https://github.com/Kozea/WeasyPrint/issues/2397>`_:
  Allow page breaks in grid rows, with financial support from Ocean Recap
* `#2568 <https://github.com/Kozea/WeasyPrint/pull/2568>`_,
  `#357 <https://github.com/Kozea/WeasyPrint/issues/357>`_:
  Support calc() and other mathematical functions
* `#2575 <https://github.com/Kozea/WeasyPrint/pull/2575>`_,
  `#2574 <https://github.com/Kozea/WeasyPrint/issues/2574>`_:
  Support PDF/A-1a, PDF/A-2a and PDF/A-3a
* `#2611 <https://github.com/Kozea/WeasyPrint/pull/2611>`_,
  `#2573 <https://github.com/Kozea/WeasyPrint/issues/2573>`_:
  Support PDF/A-4e and PDF/A-4f
* `#2523 <https://github.com/Kozea/WeasyPrint/pull/2523>`_:
  Display tofu for missing glyphs
* `#2581 <https://github.com/Kozea/WeasyPrint/pull/2581>`_:
  Add option to disable protocols in URL resolution
* `#2570 <https://github.com/Kozea/WeasyPrint/pull/2570>`_:
  Support rch, cap, rcap, rex, ic and ric font-relative units
* `#2547 <https://github.com/Kozea/WeasyPrint/pull/2547>`_,
  `#2140 <https://github.com/Kozea/WeasyPrint/issues/2140>`_:
  Support "only" keyword in media queries

Bug fixes:

* `#2516 <https://github.com/Kozea/WeasyPrint/pull/2516>`_,
  `#1510 <https://github.com/Kozea/WeasyPrint/issues/1510>`_:
  Fix rendering of first line of text with nested right float
* `#2510 <https://github.com/Kozea/WeasyPrint/pull/2510>`_,
  `#1073 <https://github.com/Kozea/WeasyPrint/issues/1073>`_,
  `#2507 <https://github.com/Kozea/WeasyPrint/issues/2507>`_:
  Avoid Pango crashes and font mismatches with @font-face rules referencing local fonts
* `#2532 <https://github.com/Kozea/WeasyPrint/pull/2532>`_,
  `#2531 <https://github.com/Kozea/WeasyPrint/issues/2531>`_:
  Use fonttools instancer instead of deprecated mutator API
* `#2541 <https://github.com/Kozea/WeasyPrint/pull/2541>`_:
  Fix syntax of functions
* `#2543 <https://github.com/Kozea/WeasyPrint/pull/2543>`_:
  Allow font-related units to access @font-face fonts
* `#2525 <https://github.com/Kozea/WeasyPrint/pull/2525>`_:
  Respect top margins and avoid overlapping footnotes for columns, with financial support from Code & Co.
* `#2536 <https://github.com/Kozea/WeasyPrint/pull/2536>`_:
  Remove Subtype key from font descriptor
* `#2539 <https://github.com/Kozea/WeasyPrint/pull/2539>`_:
  Fix min width for SVGs with intrinsic ratio but no intrinsic size
* `#2537 <https://github.com/Kozea/WeasyPrint/pull/2537>`_,
  `#2533 <https://github.com/Kozea/WeasyPrint/issues/2533>`_:
  Fix order of operators when drawing SVGs
* `#2538 <https://github.com/Kozea/WeasyPrint/pull/2538>`_:
  Don’t crash with nested unknown functions
* `#2542 <https://github.com/Kozea/WeasyPrint/pull/2542>`_:
  Don’t crash when lh and rlh are used for line height or font size
* `#2540 <https://github.com/Kozea/WeasyPrint/pull/2540>`_,
  `#2528 <https://github.com/Kozea/WeasyPrint/issues/2528>`_:
  Use locale encoding instead of filesystem encoding for font paths
* `#2563 <https://github.com/Kozea/WeasyPrint/pull/2563>`_,
  `#2479 <https://github.com/Kozea/WeasyPrint/issues/2479>`_:
  Don’t avoid float collisions for atomic flex items
* `#2569 <https://github.com/Kozea/WeasyPrint/pull/2569>`_:
  Don’t be case-sensitive for units
* `#2567 <https://github.com/Kozea/WeasyPrint/pull/2567>`_,
  `#2566 <https://github.com/Kozea/WeasyPrint/issues/2566>`_:
  Add x-default attribute for metadata description to be compliant with PDF/A
* `#2586 <https://github.com/Kozea/WeasyPrint/pull/2586>`_,
  `#2571 <https://github.com/Kozea/WeasyPrint/issues/2571>`_:
  Improve formatting contexts management
* `#2600 <https://github.com/Kozea/WeasyPrint/pull/2600>`_:
  Fix SVG image aspect ratio when only width or height is specified
* `#2612 <https://github.com/Kozea/WeasyPrint/pull/2612>`_,
  `#2595 <https://github.com/Kozea/WeasyPrint/pull/2595>`_:
  Clean block layout and fix corner cases
* `#2522 <https://github.com/Kozea/WeasyPrint/issues/2522>`_:
  Ignore preserveAspectRatio when SVG has no viewBox
* `#2544 <https://github.com/Kozea/WeasyPrint/issues/2544>`_:
  Allow to use a variable twice in a function
* `#2555 <https://github.com/Kozea/WeasyPrint/issues/2555>`_:
  Fix flex gap in right-to-left context
* `#2591 <https://github.com/Kozea/WeasyPrint/issues/2591>`_:
  Respect non-auto widths and fix padding of grid items
* `#2601 <https://github.com/Kozea/WeasyPrint/issues/2601>`_:
  Don’t crash when tagged tables are not displayed as tables
* `#2607 <https://github.com/Kozea/WeasyPrint/issues/2607>`_:
  Fix rendering of multiline textareas with PDF forms
* `#2106 <https://github.com/Kozea/WeasyPrint/issues/2106>`_:
  Force variable initialization to avoid crashes during column layout
* `#2618 <https://github.com/Kozea/WeasyPrint/pull/2618>`_,
  `#2617 <https://github.com/Kozea/WeasyPrint/issues/2617>`_:
  Fix rendering of relative grid and flex items

Documentation:

* `#2535 <https://github.com/Kozea/WeasyPrint/pull/2535>`_:
  `#2534 <https://github.com/Kozea/WeasyPrint/issues/2534>`_:
  Removed reference to defunct site

Contributors:

* Guillaume Ayoub
* Fazle Rabbi Ferdaus
* Lucie Anglade
* Luca Vercelli
* ChickenF622
* Ernie Chu
* Mark Pullin
* Malte Laukötter
* Markus Mohanty
* Yvonne Kothmeier
* Jarom Ort
* kuypan

Backers and sponsors:

* Spacinov
* Syslifters
* Kobalt
* Simon Sapin
* Grip Angebotssoftware
* Manuel Barkhau
* Simonsoft
* KontextWork
* Menutech
* TrainingSparkle
* Healthchecks.io
* Method B
* FieldHub
* Hammerbacher
* Yanal-Yves Fargialla
* Morntag
* Piloterr
* Xavid
* Charlie S.
* Prothesis Dental Solutions
* Kai DeLorenzo


Version 66.0
------------

Released on 2025-07-24.

Features:

* `#2475 <https://github.com/Kozea/WeasyPrint/pull/2475>`_:
  Add support for 'lh' and 'rlh' units
* `#2432 <https://github.com/Kozea/WeasyPrint/issues/2432>`_,
  `#2437 <https://github.com/Kozea/WeasyPrint/pull/2437>`_:
  Report footnotes when text overflows because of orphans, with financial support from Code & Co.
* `#2256 <https://github.com/Kozea/WeasyPrint/issues/2256>`_,
  `#2466 <https://github.com/Kozea/WeasyPrint/pull/2466>`_:
  Handle transform-origin in SVG
* `#2445 <https://github.com/Kozea/WeasyPrint/pull/2445>`_:
  Add parameter to have additional HTTP headers for url_fetcher

Bug fixes:

* `#2471 <https://github.com/Kozea/WeasyPrint/pull/2471>`_,
  `#2506 <https://github.com/Kozea/WeasyPrint/pull/2506>`_,
  `#2500 <https://github.com/Kozea/WeasyPrint/issues/2500>`_,
  `#2460 <https://github.com/Kozea/WeasyPrint/issues/2460>`_,
  `#2363 <https://github.com/Kozea/WeasyPrint/issues/2363>`_,
  `#2470 <https://github.com/Kozea/WeasyPrint/issues/2470>`_,
  `#1872 <https://github.com/Kozea/WeasyPrint/issues/1872>`_,
  `#2153 <https://github.com/Kozea/WeasyPrint/issues/2153>`_,
  `#1838 <https://github.com/Kozea/WeasyPrint/issues/1838>`_,
  `#1837 <https://github.com/Kozea/WeasyPrint/issues/1837>`_,
  `#1784 <https://github.com/Kozea/WeasyPrint/issues/1784>`_,
  `#1835 <https://github.com/Kozea/WeasyPrint/issues/1835>`_,
  `#2444 <https://github.com/Kozea/WeasyPrint/issues/2444>`_,
  `#2497 <https://github.com/Kozea/WeasyPrint/issues/2497>`_,
  `#2505 <https://github.com/Kozea/WeasyPrint/issues/2505>`_,
  `#2503 <https://github.com/Kozea/WeasyPrint/issues/2503>`_,
  `#1836 <https://github.com/Kozea/WeasyPrint/issues/1836>`_,
  `#2467 <https://github.com/Kozea/WeasyPrint/issues/2467>`_:
  Improve PDF/UA support, with financial support from NLnet
* `#2425 <https://github.com/Kozea/WeasyPrint/pull/2425>`_,
  `#1557 <https://github.com/Kozea/WeasyPrint/issues/1557>`_:
  Improve position of outside markers
* `#2409 <https://github.com/Kozea/WeasyPrint/pull/2409>`_,
  `#2265 <https://github.com/Kozea/WeasyPrint/issues/2265>`_:
  Draw circles instead of rectangles when drawing dotted borders
* `#2416 <https://github.com/Kozea/WeasyPrint/pull/2416>`_,
  `#2270 <https://github.com/Kozea/WeasyPrint/issues/2270>`_:
  Correctly split words for automatic hyphenation
* `#2439 <https://github.com/Kozea/WeasyPrint/pull/2439>`_,
  `#2426 <https://github.com/Kozea/WeasyPrint/issues/2426>`_:
  Don’t rely on URL protocols outside URL fetcher function
* `#2433 <https://github.com/Kozea/WeasyPrint/pull/2433>`_:
  Disable style for deprecated outline algorithm
* `#2447 <https://github.com/Kozea/WeasyPrint/pull/2447>`_,
  `#2441 <https://github.com/Kozea/WeasyPrint/issues/2441>`_,
  `#2448 <https://github.com/Kozea/WeasyPrint/issues/2448>`_:
  Improve min- and max-content calculation, with financial support from Menutech
* `#2454 <https://github.com/Kozea/WeasyPrint/pull/2454>`_,
  `#2442 <https://github.com/Kozea/WeasyPrint/issues/2442>`_,
  `#2449 <https://github.com/Kozea/WeasyPrint/issues/2449>`_:
  Minor fixes for flex layout
* `#2473 <https://github.com/Kozea/WeasyPrint/pull/2473>`_,
  `#2459 <https://github.com/Kozea/WeasyPrint/issues/2459>`_:
  Include out-of-flow boxes in page layout progress, with financial support from Pathfindr
* `#2458 <https://github.com/Kozea/WeasyPrint/pull/2458>`_:
  Replace deprecated warn logger function
* `#2494 <https://github.com/Kozea/WeasyPrint/pull/2494>`_,
  `#1856 <https://github.com/Kozea/WeasyPrint/issues/1856>`_:
  Fix bug with bottom margins in columns
* `#2435 <https://github.com/Kozea/WeasyPrint/issues/2435>`_:
  Make footnote calls inherit from footnotes
* `#2484 <https://github.com/Kozea/WeasyPrint/issues/2484>`_,
  `#2456 <https://github.com/Kozea/WeasyPrint/issues/2456>`_:
  Allow to avoid page breaks after table-row-group elements
* `#2450 <https://github.com/Kozea/WeasyPrint/issues/2450>`_:
  Draw background and borders for relative grid containers
* `#2453 <https://github.com/Kozea/WeasyPrint/issues/2453>`_:
  Don’t advance position_y for collapsed margins of discarded children
* `#2493 <https://github.com/Kozea/WeasyPrint/issues/2493>`_:
  Fix endless loop with CSS variables referencing each other
* `#2502 <https://github.com/Kozea/WeasyPrint/issues/2502>`_:
  Ignore bottom margin when calculating footnote overflow

Contributors:

* Guillaume Ayoub
* Lucie Anglade
* Alvaro Garcia Fernandez
* Emmanuel Ferdman
* Gabriel Corona
* Markus Mohanty
* Luca Vercelli
* Tre Huang

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Syslifters
* Simon Sapin
* Manuel Barkhau
* Simonsoft
* Menutech
* KontextWork
* TrainingSparkle
* Healthchecks.io
* Hammerbacher
* DocRaptor
* Yanal-Yves Fargialla
* Method B
* FieldHub
* Morntag
* Xavid
* Kai DeLorenzo
* Charlie S.
* Alan Villalobos


Version 65.1
------------

Released on 2025-04-14.

Bug fixes:

* `#2414 <https://github.com/Kozea/WeasyPrint/issues/2414>`_:
  Correctly handle flex columns split between pages
* `1b24ad9 <https://github.com/Kozea/WeasyPrint/commit/1b24ad9>`_:
  Include padding in outer size of item elements
* `#2419 <https://github.com/Kozea/WeasyPrint/issues/2419>`_:
  Set main tag as block by default
* `#2415 <https://github.com/Kozea/WeasyPrint/issues/2415>`_:
  Fix support of replaced block box as flex items
* `83da2fe0 <https://github.com/Kozea/WeasyPrint/commit/83da2fe0>`_:
  Fix margins and padding for rtl lists
* `#2429 <https://github.com/Kozea/WeasyPrint/issues/2429>`_,
  `#1076 <https://github.com/Kozea/WeasyPrint/issues/1076>`_,
  `#2431 <https://github.com/Kozea/WeasyPrint/pull/2431>`_:
  Fix page groups

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Syslifters
* Simon Sapin
* Manuel Barkhau
* Simonsoft
* Menutech
* KontextWork
* TrainingSparkle
* Healthchecks.io
* Hammerbacher
* DocRaptor
* Yanal-Yves Fargialla
* Method B
* FieldHub
* Morntag
* Xavid
* Kai DeLorenzo
* Charlie S.
* Alan Villalobos


Version 65.0
------------

Released on 2025-03-20.

Dependencies:

* CSSSelect2 0.8.0 is now needed

Features:

* `#1665 <https://github.com/Kozea/WeasyPrint/issues/1665>`_:
  Support gap properties in Flex layout, with financial support from NLnet
* `#378 <https://github.com/Kozea/WeasyPrint/issues/378>`_,
  `#2405 <https://github.com/Kozea/WeasyPrint/pull/2405>`_:
  Handle @font-face unicode-range
* `#2394 <https://github.com/Kozea/WeasyPrint/pull/2394>`_:
  Modernize and improve default user agent stylesheets

Bug fixes:

* `#2362 <https://github.com/Kozea/WeasyPrint/issues/2362>`_,
  `#2387 <https://github.com/Kozea/WeasyPrint/pull/2387>`_,
  `#601 <https://github.com/Kozea/WeasyPrint/issues/601>`_,
  `#1967 <https://github.com/Kozea/WeasyPrint/issues/1967>`_,
  `#1805 <https://github.com/Kozea/WeasyPrint/issues/1805>`_,
  `#2163 <https://github.com/Kozea/WeasyPrint/issues/2163>`_,
  `#2342 <https://github.com/Kozea/WeasyPrint/issues/2342>`_,
  `#2374 <https://github.com/Kozea/WeasyPrint/issues/2374>`_,
  `#1109 <https://github.com/Kozea/WeasyPrint/issues/1109>`_,
  `#1356 <https://github.com/Kozea/WeasyPrint/issues/1356>`_,
  `#1327 <https://github.com/Kozea/WeasyPrint/issues/1327>`_,
  `#1563 <https://github.com/Kozea/WeasyPrint/issues/1563>`_,
  `#1652 <https://github.com/Kozea/WeasyPrint/issues/1652>`_,
  `#2351 <https://github.com/Kozea/WeasyPrint/issues/2351>`_,
  `#2312 <https://github.com/Kozea/WeasyPrint/issues/2312>`_,
  `#2340 <https://github.com/Kozea/WeasyPrint/issues/2340>`_,
  `#1311 <https://github.com/Kozea/WeasyPrint/issues/1311>`_,
  `#2066 <https://github.com/Kozea/WeasyPrint/issues/2066>`_,
  `#2359 <https://github.com/Kozea/WeasyPrint/issues/2359>`_,
  `#2053 <https://github.com/Kozea/WeasyPrint/issues/2053>`_:
  Improve Flex layout, with financial support from NLnet.
* `#1686 <https://github.com/Kozea/WeasyPrint/issues/1686>`_,
  `#2404 <https://github.com/Kozea/WeasyPrint/pull/2404>`_:
  Fix duplicate text selection with right-to-left text
* `#2372 <https://github.com/Kozea/WeasyPrint/issues/2372>`_,
  `#2389 <https://github.com/Kozea/WeasyPrint/pull/2389>`_:
  Fix justification of right-to-left text
* `#2403 <https://github.com/Kozea/WeasyPrint/issues/2403>`_:
  Fix emoji rendering with older versions of Pango
* `#2392 <https://github.com/Kozea/WeasyPrint/issues/2392>`_:
  Fix complex cases involving nested SVG text anchors
* `#2396 <https://github.com/Kozea/WeasyPrint/issues/2396>`_,
  `#2398 <https://github.com/Kozea/WeasyPrint/pull/2398>`_:
  Fix and improve font names in PDF
* `#2269 <https://github.com/Kozea/WeasyPrint/issues/2269>`_,
  `#2390 <https://github.com/Kozea/WeasyPrint/pull/2390>`_:
  Apply justification to non-breaking spaces
* `#2362 <https://github.com/Kozea/WeasyPrint/issues/2362>`_,
  `#2387 <https://github.com/Kozea/WeasyPrint/pull/2387>`_:
  Improve Flex layout, with financial support from NLnet.

Contributors:

* Guillaume Ayoub
* Luca Vercelli

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Syslifters
* Simon Sapin
* Manuel Barkhau
* Simonsoft
* Menutech
* KontextWork
* TrainingSparkle
* Healthchecks.io
* Hammerbacher
* DocRaptor
* Yanal-Yves Fargialla
* Method B
* FieldHub
* Morntag
* Xavid
* Kai DeLorenzo
* Charlie S.
* Alan Villalobos


Version 64.1
------------

Released on 2025-02-20.

Bug fixes:

* `#2368 <https://github.com/Kozea/WeasyPrint/issues/2368>`_:
  Fix ascent and descent font values
* `#2370 <https://github.com/Kozea/WeasyPrint/issues/2370>`_:
  Avoid endless recursion for variables in nested functions
* `#2275 <https://github.com/Kozea/WeasyPrint/issues/2275>`_:
  Use correct containing block to render waiting children
* `#2375 <https://github.com/Kozea/WeasyPrint/issues/2375>`_:
  Ensure that we handle text-anchor only on text content elements
* `#2090 <https://github.com/Kozea/WeasyPrint/issues/2090>`_:
  Only create font temporary folder when adding fonts
* `#2383 <https://github.com/Kozea/WeasyPrint/issues/2383>`_:
  Fix grid-template-areas validation and allow uppercase identifiers for grid lines

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Syslifters
* Simon Sapin
* Manuel Barkhau
* Simonsoft
* Menutech
* KontextWork
* TrainingSparkle
* Healthchecks.io
* Hammerbacher
* DocRaptor
* Yanal-Yves Fargialla
* Method B
* FieldHub
* Morntag
* Xavid
* Kai DeLorenzo
* Charlie S.


Version 64.0
------------

Released on 2025-01-30.

Features:

* `#2338 <https://github.com/Kozea/WeasyPrint/pull/2338>`_:
  Allow custom RDF metadata for PDF/A and eInvoices
* `#123 <https://github.com/Kozea/WeasyPrint/issues/123>`_,
  `#2345 <https://github.com/Kozea/WeasyPrint/pull/2345>`_:
  Handle small-caps synthesis
* `#2343 <https://github.com/Kozea/WeasyPrint/issues/2343>`_:
  Support outline-offset
* `#2361 <https://github.com/Kozea/WeasyPrint/pull/2361>`_:
  Support text-underline-offset and text-decoration-thickness
* `#2296 <https://github.com/Kozea/WeasyPrint/issues/2296>`_:
  Don’t crash with tables with rounded corners split between pages

Bug fixes:

* `#2360 <https://github.com/Kozea/WeasyPrint/issues/2360>`_:
  Fix gradients with non-RGB colors
* `#2355 <https://github.com/Kozea/WeasyPrint/issues/2355>`_,
  `#2358 <https://github.com/Kozea/WeasyPrint/pull/2358>`_:
  Align png emojis to the surrounding text
* `#2353 <https://github.com/Kozea/WeasyPrint/issues/2353>`_:
  Fix alignment of SVG text with multiple nested text-anchor values
* `#2350 <https://github.com/Kozea/WeasyPrint/pull/2350>`_:
  Fix logging restoration in capture_logs
* `#2341 <https://github.com/Kozea/WeasyPrint/pull/2341>`_:
  Fix page groups
* `#2314 <https://github.com/Kozea/WeasyPrint/pulls/2314>`_:
  Use CSS 'image-rendering' attribute for images in SVGs
* `#2332 <https://github.com/Kozea/WeasyPrint/issues/2332>`_:
  Fix opacity for translated SVG elements
* `#2329 <https://github.com/Kozea/WeasyPrint/issues/2329>`_:
  Refactor text.line_break.get_log_attrs
* `#2325 <https://github.com/Kozea/WeasyPrint/issues/2325>`_,
  `#2326 <https://github.com/Kozea/WeasyPrint/pull/2326>`_:
  Fix table overflow edge cases

Performance:

* `#2347 <https://github.com/Kozea/WeasyPrint/issues/2347>`_,
  `#2364 <https://github.com/Kozea/WeasyPrint/pull/2364>`_:
  Improve rendering speed for text

Documentation:

* `#2352 <https://github.com/Kozea/WeasyPrint/pull/2352>`_:
  Add more use cases in documentation, use Furo theme

Contributors:

* Guillaume Ayoub
* Kesara Rathnayake
* Xavid Pretzer
* David Tagatac
* Ernesto Ruge
* Niko Abeler
* Noam Kushinsky

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Syslifters
* Simon Sapin
* Manuel Barkhau
* Simonsoft
* Menutech
* KontextWork
* TrainingSparkle
* Healthchecks.io
* Hammerbacher
* DocRaptor
* Yanal-Yves Fargialla
* Method B
* FieldHub
* Morntag
* Xavid
* Kai DeLorenzo
* Charlie S.


Version 63.1
------------

Released on 2024-12-10.

Dependencies:

* `#2297 <https://github.com/Kozea/WeasyPrint/issues/2297>`_:
  Remove upper bounds for dependencies

Bug fixes:

* `#2300 <https://github.com/Kozea/WeasyPrint/pull/2300>`_,
  `#2292 <https://github.com/Kozea/WeasyPrint/issues/2292>`_:
  Don’t avoid floats for flex items
* `#2301 <https://github.com/Kozea/WeasyPrint/pull/2301>`_,
  `#2293 <https://github.com/Kozea/WeasyPrint/issues/2293>`_:
  Include floats in calculation of minimum cell height
* `#2303 <https://github.com/Kozea/WeasyPrint/pull/2303>`_,
  `#2302 <https://github.com/Kozea/WeasyPrint/issues/2302>`_:
  Set alpha even when current color channels didn’t change
* `#2306 <https://github.com/Kozea/WeasyPrint/issues/2306>`_:
  Don’t try to increase column width when there’s no extra width
* `#2304 <https://github.com/Kozea/WeasyPrint/issues/2304>`_:
  Don’t forget skip stack when drawing flex items
* `#2316 <https://github.com/Kozea/WeasyPrint/issues/2316>`_:
  Don’t crash with SVG symbols
* `#2320 <https://github.com/Kozea/WeasyPrint/issues/2320>`_:
  Fix currentcolor detection when parsing gradient color stops
* `#2322 <https://github.com/Kozea/WeasyPrint/pull/2322>`_,
  `#2289 <https://github.com/Kozea/WeasyPrint/issues/2289>`_:
  Don’t add DLL directories when using Windows executable
* `#2323 <https://github.com/Kozea/WeasyPrint/pull/2323>`_,
  `#2305 <https://github.com/Kozea/WeasyPrint/issues/2305>`_:
  Fix different rendering test

Performance:

* `#2319 <https://github.com/Kozea/WeasyPrint/issues/2319>`_:
  Fix memory leaks

Documentation:

* `#2299 <https://github.com/Kozea/WeasyPrint/pull/2299>`_:
  Update install instructions for Alpine
* `#2321 <https://github.com/Kozea/WeasyPrint/pull/2321>`_:
  Add example invocation of WeasyPrint on the "Contribute" page

Contributors:

* Guillaume Ayoub
* Jó Ágila Bitsch
* Lucie Anglade
* Alexander Gitter
* Luke Cousins

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Syslifters
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* Simon Sapin
* TrainingSparkle
* Healthchecks.io
* Hammerbacher
* Advance Insight
* Docraptor
* Method B
* FieldHub
* Yanal-Yves Fargialla
* Morntag
* Xavid


Version 63.0
------------

Released on 2024-10-29.

Dependencies:

* Python 3.13 is now supported
* pydyf 0.11.0+ is now needed
* tinycss2 1.4.0+ is now needed
* tinyhtml5 2.0.0+ is now needed, instead of html5lib

Features:

* `#2252 <https://github.com/Kozea/WeasyPrint/pull/2252>`_,
  `#895 <https://github.com/Kozea/WeasyPrint/issues/895>`_:
  Handle page groups, with financial support from Code & Co.
* `#1630 <https://github.com/Kozea/WeasyPrint/issues/1630>`_,
  `#2286 <https://github.com/Kozea/WeasyPrint/pull/2286>`_:
  Support CSS Color Level 4
* `#2192 <https://github.com/Kozea/WeasyPrint/pull/2192>`_:
  Add PDF variant for debugging purpose
* `#2208 <https://github.com/Kozea/WeasyPrint/pull/2208>`_:
  Support submit inputs in PDF forms
* `#2139 <https://github.com/Kozea/WeasyPrint/pull/2139>`_:
  Support ``mask-border-*`` properties
* `#1831 <https://github.com/Kozea/WeasyPrint/issues/1831>`_,
  `#2143 <https://github.com/Kozea/WeasyPrint/pull/2143>`_:
  Support radio inputs in PDF forms

Bug fixes:

* `#2262 <https://github.com/Kozea/WeasyPrint/issues/2262>`_:
  Avoid integer overflows when converting units from/to doubles
* `#2260 <https://github.com/Kozea/WeasyPrint/pull/2260>`_:
  Avoid float collision with box establishing formatting context
* `#2240 <https://github.com/Kozea/WeasyPrint/issues/2240>`_,
  `#2242 <https://github.com/Kozea/WeasyPrint/pull/2242>`_:
  Handle ``svg`` tags with no size
* `#2231 <https://github.com/Kozea/WeasyPrint/pull/2231>`_,
  `#1171 <https://github.com/Kozea/WeasyPrint/issues/1171>`_,
  `#2222 <https://github.com/Kozea/WeasyPrint/issues/2222>`_,
  `#1208 <https://github.com/Kozea/WeasyPrint/issues/1208>`_:
  Fix several problems related to ``flex-direction: column``
* `#2239 <https://github.com/Kozea/WeasyPrint/issues/2239>`_:
  Don’t fail when SVG markers are undefined references
* `#2230 <https://github.com/Kozea/WeasyPrint/issues/2230>`_,
  `#2238 <https://github.com/Kozea/WeasyPrint/pull/2238>`_:
  Set explicit flags when loading DLLs on Windows
* `#2228 <https://github.com/Kozea/WeasyPrint/issues/2228>`_,
  `#1942 <https://github.com/Kozea/WeasyPrint/issues/1942>`_:
  Store original and PDF stream images in different cache slots
* `#2234 <https://github.com/Kozea/WeasyPrint/issues/2234>`_:
  Apply stylesheet and other basic operations to SVG root tag
* `#2054 <https://github.com/Kozea/WeasyPrint/issues/2054>`_,
  `#2233 <https://github.com/Kozea/WeasyPrint/pull/2233>`_:
  Keep auto margins on flex layout boxes
* `#1883 <https://github.com/Kozea/WeasyPrint/issues/1883>`_:
  Don’t crash with empty list marker strings
* `#2216 <https://github.com/Kozea/WeasyPrint/issues/2216>`_:
  Fix vertical alignment of out-of-flow elements in tables
* `#996 <https://github.com/Kozea/WeasyPrint/issues/996>`_,
  `#2219 <https://github.com/Kozea/WeasyPrint/pull/2219>`_:
  Don’t ignore absolutely positioned elements inside flex boxes
* `#2217 <https://github.com/Kozea/WeasyPrint/issues/2217>`_:
  Don’t crash with ``normal`` column gaps
* `#1817 <https://github.com/Kozea/WeasyPrint/issues/1817>`_:
  Don’t assume that lines break after spaces
* `#1868 <https://github.com/Kozea/WeasyPrint/issues/1868>`_:
  Don’t break rows with atomic cells
* `#2166 <https://github.com/Kozea/WeasyPrint/issues/2166>`_:
  Don’t display bottom border on cells in split rows
* `61852c4 <https://github.com/Kozea/WeasyPrint/commit/61852c4>`_:
  Capture fontTools logs when subsetting fonts
* `#2190 <https://github.com/Kozea/WeasyPrint/pull/2190>`_:
  Don’t use a pattern when drawing backgrounds for no-repeat background images
* `#2185 <https://github.com/Kozea/WeasyPrint/issues/2185>`_:
  Check that Harfbuzz version is at least 4.1.0 to subset fonts
* `#2180 <https://github.com/Kozea/WeasyPrint/issues/2180>`_:
  Store width for all glyphs when font is not subset
* `#2183 <https://github.com/Kozea/WeasyPrint/issues/2183>`_:
  Respect ``break-inside: avoid`` for flex items
* `#2055 <https://github.com/Kozea/WeasyPrint/issues/2055>`_,
  `#2058 <https://github.com/Kozea/WeasyPrint/pull/2058>`_:
  Fix right-to-left tables with collapsed borders
* `#2179 <https://github.com/Kozea/WeasyPrint/pull/2179>`_,
  `#1128 <https://github.com/Kozea/WeasyPrint/issues/1128>`_:
  Handle buggy Adobe Photoshop CMYK JPEGs
* `#2175 <https://github.com/Kozea/WeasyPrint/issues/2175>`_:
  Don’t compress PDF metadata for PDF/A-1
* `#2174 <https://github.com/Kozea/WeasyPrint/issues/2174>`_:
  Fix extra width distribution for auto table layout

Performance:

* `#1155 <https://github.com/Kozea/WeasyPrint/issues/1155>`_:
  Improve rendering speed for large colspan values
* `#2120 <https://github.com/Kozea/WeasyPrint/issues/2120>`_,
  `#2178 <https://github.com/Kozea/WeasyPrint/pull/2178>`_:
  Use Harfbuzz to subset fonts by default

Documentation:

* `#2282 <https://github.com/Kozea/WeasyPrint/issues/2282>`_,
  `#2284 <https://github.com/Kozea/WeasyPrint/pull/2284>`_:
  Simplify Alpine install instructions
* `#2254 <https://github.com/Kozea/WeasyPrint/issues/2254>`_:
  Add warning about antivirus false detection
* `#2220 <https://github.com/Kozea/WeasyPrint/pull/2220>`_:
  Add extra information to debug logs
* `#2211 <https://github.com/Kozea/WeasyPrint/pull/2211>`_:
  Fix link to samples
* `#2195 <https://github.com/Kozea/WeasyPrint/pull/2195>`_:
  Update cache argument documentation
* `#2105 <https://github.com/Kozea/WeasyPrint/issues/2105>`_,
  `#2151 <https://github.com/Kozea/WeasyPrint/pull/2151>`_:
  Use MSYS2 instead of GTK+3 for Windows

Contributors:

* Guillaume Ayoub
* David Huggins-Daines
* Xavid Pretzer
* Yann Trividic
* Kevin Kays
* Alejandro Avilés
* Gianluca Teti
* Gregory Goodson
* Lucie Anglade
* Roman Sirokov

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Syslifters
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* Simon Sapin
* TrainingSparkle
* Healthchecks.io
* Hammerbacher
* Advance Insight
* Docraptor
* Method B
* FieldHub
* Yanal-Yves Fargialla
* Morntag
* Xavid


Version 62.3
------------

Released on 2024-06-21.

Bug fixes:

* `#2174 <https://github.com/Kozea/WeasyPrint/issues/2174>`_:
  Fix extra width distribution for auto table layout
* `#2175 <https://github.com/Kozea/WeasyPrint/issues/2175>`_:
  Don’t compress PDF metadata for PDF/A-1
* `61f8bb3 <https://github.com/Kozea/WeasyPrint/commit/61f8bb3>`_:
  Set default PDF variant values in options before generating PDF
* `2c4351e <https://github.com/Kozea/WeasyPrint/commit/2c4351e>`_:
  Avoid PDF artifacts when drawing 0-width borders
* `d9d7f62 <https://github.com/Kozea/WeasyPrint/commit/d9d7f62>`_:
  Don’t duplicate column when container is split on multiple pages
* `4617b94 <https://github.com/Kozea/WeasyPrint/commit/4617b94>`_:
  Don’t set default Fontconfig values for unset properties
* `4c81663 <https://github.com/Kozea/WeasyPrint/commit/4c81663>`_:
  Fix layout when all footnotes are removed from the footnote area
* `#2184 <https://github.com/Kozea/WeasyPrint/issues/2184>`_:
  Make items overflowing grid wrap to the next row/column
* `#2187 <https://github.com/Kozea/WeasyPrint/issues/2187>`_:
  Don’t append useless tracks when grid elements are positioned

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* Simon Sapin
* René Fritz
* TrainingSparkle
* Healthchecks.io
* Hammerbacher
* Docraptor
* Yanal-Yves Fargialla
* Douwe van Loenen
* Morntag
* Xavid


Version 62.2
------------

Released on 2024-06-04.

Features:

* `#2142 <https://github.com/Kozea/WeasyPrint/issues/2142>`_,
  `#2162 <https://github.com/Kozea/WeasyPrint/pull/2162>`_:
  Support grid-auto-flow: column, with financial support from Menutech

Bug fixes:

* `#2167 <https://github.com/Kozea/WeasyPrint/issues/2167>`_:
  Fix space added by CSS gap at the end
* `#2134 <https://github.com/Kozea/WeasyPrint/issues/2134>`_:
  Remove absolute placeholders from discarded content
* `#2154 <https://github.com/Kozea/WeasyPrint/issues/2154>`_:
  Don’t crash when grid items have auto margins
* `8cdd66f <https://github.com/Kozea/WeasyPrint/commit/8cdd66f>`_:
  Fix CSS nesting for nested selectors with comma
* `3359db5 <https://github.com/Kozea/WeasyPrint/commit/3359db5>`_:
  Fix and test grid shorthand
* `82deda4 <https://github.com/Kozea/WeasyPrint/commit/82deda4>`_:
  Fix wrong resume_at for split floats
* `ff2acf1 <https://github.com/Kozea/WeasyPrint/commit/ff2acf1>`_:
  Ensure that gradient size is positive to please some PDF readers

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* Simon Sapin
* René Fritz
* TrainingSparkle
* Healthchecks.io
* Hammerbacher
* Docraptor
* Yanal-Yves Fargialla
* Douwe van Loenen
* Morntag
* Xavid


Version 62.1
------------

Released on 2024-05-06.

Bug fixes:

* `#2144 <https://github.com/Kozea/WeasyPrint/issues/2144>`_,
  `#2149 <https://github.com/Kozea/WeasyPrint/pull/2149>`_:
  Avoid broken fonts when generating multiple documents
* `c10c6892 <https://github.com/Kozea/WeasyPrint/commit/c10c6892>`_:
  Display at least one grid row on empty pages
* `#2146 <https://github.com/Kozea/WeasyPrint/issues/2146>`_:
  Don’t crash when flex container’s parent’s height is auto

Contributors:

* Guillaume Ayoub
* Claudius Ellsel

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* Simon Sapin
* René Fritz
* TrainingSparkle
* Healthchecks.io
* Docraptor
* Yanal-Yves Fargialla
* Douwe van Loenen
* Morntag
* Xavid


Version 62.0
------------

Released on 2024-04-30.

Dependencies:

* Python 3.9+ is now needed, Python 3.7 and 3.8 are not supported anymore
* pydyf 0.10.0+ is now needed
* tinycss2 1.3.0+ is now needed

Features:

* `#543 <https://github.com/Kozea/WeasyPrint/issues/543>`_,
  `#2121 <https://github.com/Kozea/WeasyPrint/pull/2121>`_:
  Support CSS Grid layout
* `#2124 <https://github.com/Kozea/WeasyPrint/issues/2124>`_,
  `#2125 <https://github.com/Kozea/WeasyPrint/pull/2125>`_:
  Support border-image-* properties
* `#2084 <https://github.com/Kozea/WeasyPrint/issues/2084>`_,
  `#2077 <https://github.com/Kozea/WeasyPrint/pull/2077>`_:
  Support CSS nesting
* `#2101 <https://github.com/Kozea/WeasyPrint/issues/2101>`_:
  Support HTML maxlength attribute for form fields
* `#2095 <https://github.com/Kozea/WeasyPrint/pull/2095>`_:
  Apply overflow to replaced boxes
* `245e4f5 <https://github.com/Kozea/WeasyPrint/commit/245e4f5>`_:
  Add support of PDF/A-?u

Bug fixes:

* `#2136 <https://github.com/Kozea/WeasyPrint/issues/2136>`_:
  Don’t clip aligned text in SVG
* `#2135 <https://github.com/Kozea/WeasyPrint/pull/2135>`_:
  Allow column-direction flex containers to use percentage-based heights
* `#2128 <https://github.com/Kozea/WeasyPrint/issues/2128>`_:
  Don’t crash when a FontConfig object is destroyed early
* `#2079 <https://github.com/Kozea/WeasyPrint/issues/2079>`_:
  Fix executable file for some Windows versions
* `#2131 <https://github.com/Kozea/WeasyPrint/issues/2131>`_:
  Fix alpha for images before/after transparent text
* `#2111 <https://github.com/Kozea/WeasyPrint/issues/2111>`_:
  Handle auto and none values for CSS quotes property
* `#2103 <https://github.com/Kozea/WeasyPrint/issues/2103>`_:
  Don’t crash with overconstrained columns
* `#2100 <https://github.com/Kozea/WeasyPrint/issues/2100>`_:
  Fix rounding error when detecting overflows
* `#2093 <https://github.com/Kozea/WeasyPrint/issues/2093>`_,
  `#2097 <https://github.com/Kozea/WeasyPrint/issues/2097>`_,
  `#2094 <https://github.com/Kozea/WeasyPrint/pull/2094>`_:
  Mark use of md5() and sha1() as not for security
* `#1956 <https://github.com/Kozea/WeasyPrint/issues/1956>`_,
  `#2087 <https://github.com/Kozea/WeasyPrint/pull/2087>`_:
  Use CSS table module level 3 to compute widths
* `#2086 <https://github.com/Kozea/WeasyPrint/pull/2086>`_:
  Fix selects with empty values displaying None
* `#1112 <https://github.com/Kozea/WeasyPrint/issues/1112>`_,
  `#2082 <https://github.com/Kozea/WeasyPrint/issues/2082>`_,
  `#2085 <https://github.com/Kozea/WeasyPrint/pull/2085>`_:
  Fix computation for outer min-content width for table cells
* `016bd81 <https://github.com/Kozea/WeasyPrint/commit/016bd81>`_:
  Fix many different bugs with SVG markers

Performance:

* `#2130 <https://github.com/Kozea/WeasyPrint/issues/2130>`_:
  Cache font key instead of whole font content

Documentation:

* `#2108 <https://github.com/Kozea/WeasyPrint/pull/2108>`_:
  Update documentation about CSS leader() function

Contributors:

* Guillaume Ayoub
* Lucie Anglade
* Xavid Pretzer
* kygoh
* Germain Gueutier
* Vagner José Nicolodi

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* Simon Sapin
* René Fritz
* TrainingSparkle
* Healthchecks.io
* Docraptor
* Yanal-Yves Fargialla
* Douwe van Loenen
* Morntag
* Xavid


Version 61.2
------------

Released on 2024-03-08.

**This is a security update.**

We strongly recommend to upgrade WeasyPrint to the latest version if you use
WeasyPrint 61.0 or 61.1. Older versions are not impacted.

Security:

- Always use URL fetcher for attachments

Contributors:

* Guillaume Ayoub
* Ilia Novoselov

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* René Fritz
* Simon Sapin
* Arcanite
* TrainingSparkle
* Healthchecks.io
* Hammerbacher
* Docraptor
* Yanal-Yves Fargialla
* Morntag
* NBCO


Version 61.1
------------

Released on 2024-02-26.

Bug fixes:

- `#2075 <https://github.com/Kozea/WeasyPrint/issues/2075>`_:
  Use default value when variable is not defined
- `#2070 <https://github.com/Kozea/WeasyPrint/issues/2070>`_:
  Don’t crash when rendering SVGs with non-text a children
- Don’t crash when SVG file can’t be rendered

Documentation:

- `#2067 <https://github.com/Kozea/WeasyPrint/pull/2067>`_:
  Suggest "dnf" instead of "yum" to install Fedora packages
- Improve documentation for Windows
- Fix required version of TinyCSS2

Contributors:

* Guillaume Ayoub
* Felix Schwarz
* Lucie Anglade

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* René Fritz
* Simon Sapin
* Arcanite
* TrainingSparkle
* Healthchecks.io
* Hammerbacher
* Docraptor
* Yanal-Yves Fargialla
* Morntag
* NBCO


Version 61.0
------------

Released on 2024-02-12.

Python API:

* ``DocumentMetadata.attachments`` is now a list of ``Attachment`` objects, not
  a list of ``(url, description)`` tuples.

New features:

* `#1219 <https://github.com/Kozea/WeasyPrint/issues/1219>`_,
  `#2017 <https://github.com/Kozea/WeasyPrint/pull/2017>`_:
  Support var() in shorthand and multiple-value functions
* `#1986 <https://github.com/Kozea/WeasyPrint/issues/1986>`_:
  Support percentages for opacity
* `#2050 <https://github.com/Kozea/WeasyPrint/pull/2050>`_:
  Build executable file for Windows
* `#2000 <https://github.com/Kozea/WeasyPrint/pull/2000>`_:
  Support select fields
* `#1993 <https://github.com/Kozea/WeasyPrint/issues/1993>`_:
  Handle background-attachment: fixed to cover the whole page
* `#2023 <https://github.com/Kozea/WeasyPrint/issues/2023>`_,
  `#2022 <https://github.com/Kozea/WeasyPrint/pull/2022>`_:
  Allow text-based file objects for HTML and CSS classes
* `#2014 <https://github.com/Kozea/WeasyPrint/pull/2014>`_:
  Remove warnings for PDF/A and PDF/UA compatibility

Bug fixes:

* `#2052 <https://github.com/Kozea/WeasyPrint/issues/2052>`_,
  `#1869 <https://github.com/Kozea/WeasyPrint/pull/1869>`_:
  Handle attachments for PDF/A documents
* `#2013 <https://github.com/Kozea/WeasyPrint/issues/2013>`_,
  `#2051 <https://github.com/Kozea/WeasyPrint/pull/2051>`_:
  Apply margin to running tables
* `#1278 <https://github.com/Kozea/WeasyPrint/issues/1278>`_,
  `#1884 <https://github.com/Kozea/WeasyPrint/pull/1884>`_:
  Draw collapsed borders of running tables
* `#2029 <https://github.com/Kozea/WeasyPrint/issues/2029>`_:
  Fix page counter in non-root absolute boxes
* `#2043 <https://github.com/Kozea/WeasyPrint/pull/2043>`_:
  Fix text-anchor on SVG tspan elements
* `#1968 <https://github.com/Kozea/WeasyPrint/issues/1968>`_,
  `#2039 <https://github.com/Kozea/WeasyPrint/pull/2039>`_:
  Use cell's border-height to calculate table row height
* `#2030 <https://github.com/Kozea/WeasyPrint/issues/2030>`_:
  Ensure that bounding box is set to invisible text tags
* `#2040 <https://github.com/Kozea/WeasyPrint/issues/2040>`_,
  `#2041 <https://github.com/Kozea/WeasyPrint/pull/2041>`_:
  Don’t crash on malformed URLs
* `#2026 <https://github.com/Kozea/WeasyPrint/issues/2026>`_:
  Don’t break pages when fixed-height elements don’t overflow page
* `#2038 <https://github.com/Kozea/WeasyPrint/issues/2038>`_:
  Don’t mix original streams when drawing transparent text
* `#2016 <https://github.com/Kozea/WeasyPrint/issues/2016>`_:
  Avoid duplication when breaking out-of-flow boxes
* `#2012 <https://github.com/Kozea/WeasyPrint/issues/2012>`_:
  Don’t crash when CSS properties have no value
* `#2010 <https://github.com/Kozea/WeasyPrint/issues/2010>`_,
  `#1287 <https://github.com/Kozea/WeasyPrint/issues/1287>`_:
  Fix many corner cases with CSS variables
* `#1996 <https://github.com/Kozea/WeasyPrint/issues/1996>`_:
  Don’t crash when drawing groove/ridge collapsed borders
* `#1982 <https://github.com/Kozea/WeasyPrint/issues/1982>`_:
  Fix SVG markers size, position and drawing

Documentation:

* `#2021 <https://github.com/Kozea/WeasyPrint/issues/2021>`_,
  `#2048 <https://github.com/Kozea/WeasyPrint/pull/2048>`_:
  Replace non-virtualenv installation instructions with distribution packages

Contributors:

* Guillaume Ayoub
* kygoh
* Lucie Anglade
* Timo Ramsauer
* Alexander Gitter
* Michael Lisitsa
* Vagner José Nicolodi
* Manolis Stamatogiannakis
* Pascal de Bruijn
* Viktor Shevtsov
* Eduardo Gonzalez
* Kesara Rathnayake

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* René Fritz
* Simon Sapin
* Arcanite
* TrainingSparkle
* Healthchecks.io
* Hammerbacher
* Docraptor
* Yanal-Yves Fargialla
* Morntag
* NBCO


Version 60.2
------------

Released on 2023-12-11.

Bug fixes:

* `#1982 <https://github.com/Kozea/WeasyPrint/issues/1982>`_:
  Fix SVG markers size, position and drawing
* `23cfc775 <https://github.com/Kozea/WeasyPrint/commit/23cfc775>`_:
  Draw background behind absolutely positioned replaced boxes
* `fe2f0c69 <https://github.com/Kozea/WeasyPrint/commit/fe2f0c69>`_:
  Don’t crash with bitmap fonts with no "glyf" table
* `14605225 <https://github.com/Kozea/WeasyPrint/commit/14605225>`_:
  Improve SVG text-anchor attribute

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* NCC Group
* René Fritz
* Nicola Auchmuty
* Syslifters
* Hammerbacher
* TrainingSparkle
* Daniel Kucharski
* Healthchecks.io
* Yanal-Yves Fargialla
* WakaTime
* Paheko
* Synapsium
* DocRaptor


Version 60.1
------------

Released on 2023-09-29.

Bug fixes:

* `#1973 <https://github.com/Kozea/WeasyPrint/issues/1973>`_:
  Fix crash caused by wrong UTF-8 indices

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* NCC Group
* René Fritz
* Nicola Auchmuty
* Syslifters
* Hammerbacher
* TrainingSparkle
* Daniel Kucharski
* Healthchecks.io
* Yanal-Yves Fargialla
* WakaTime
* Paheko
* Synapsium
* DocRaptor


Version 60.0
------------

Released on 2023-09-25.

New features:

* `#1903 <https://github.com/Kozea/WeasyPrint/issues/1903>`_:
  Print form fields
* `#1922 <https://github.com/Kozea/WeasyPrint/pull/1922>`_:
  Add support for textLength and lengthAdjust in SVG text elements
* `#1965 <https://github.com/Kozea/WeasyPrint/issues/1965>`_:
  Handle <wbr> tag
* `#1970 <https://github.com/Kozea/WeasyPrint/pull/1970>`_:
  Handle y offset of glyphs
* `#1909 <https://github.com/Kozea/WeasyPrint/issues/1909>`_:
  Add a --timeout option

Bug fixes:

* `#1887 <https://github.com/Kozea/WeasyPrint/pull/1887>`_:
  Fix footnote-call displayed incorrectly for some fonts
* `#1890 <https://github.com/Kozea/WeasyPrint/pull/1890>`_:
  Fix page-margin boxes layout algorithm
* `#1908 <https://github.com/Kozea/WeasyPrint/pull/1908>`_:
  Fix IndexError when rendering PDF version 1.4
* `#1906 <https://github.com/Kozea/WeasyPrint/issues/1906>`_:
  Apply text transformations to first-letter pseudo elements
* `#1915 <https://github.com/Kozea/WeasyPrint/pull/1915>`_:
  Avoid footnote appearing before its call
* `#1934 <https://github.com/Kozea/WeasyPrint/pull/1934>`_:
  Fix balance before "column-span: all"
* `#1935 <https://github.com/Kozea/WeasyPrint/issues/1935>`_:
  Only draw required glyph with OpenType-SVG fonts
* `#1595 <https://github.com/Kozea/WeasyPrint/issues/1595>`_:
  Don’t draw clipPath when defined after reference
* `#1895 <https://github.com/Kozea/WeasyPrint/pull/1895>`_:
  Don’t ignore min-width when computing cell size
* `#1899 <https://github.com/Kozea/WeasyPrint/pull/1899>`_:
  Fix named pages inheritance
* `#1936 <https://github.com/Kozea/WeasyPrint/pull/1936>`_:
  Avoid page breaks caused by children of overflow hidden boxes
* `#1943 <https://github.com/Kozea/WeasyPrint/issues/1943>`_:
  Use bleed area for page’s painting area
* `#1946 <https://github.com/Kozea/WeasyPrint/issues/1946>`_:
  Use margin box of children to define available width for leaders

Contributors:

* Guillaume Ayoub
* Sahil Rohilla
* Azharuddin Syed
* kygoh
* Andy Lenards
* Gaurav Samudra
* Michael Wedl
* Lucie Anglade
* Obeida Shamoun
* Evgeniy Krysanov

Backers and sponsors:

* Spacinov
* Kobalt
* Grip Angebotssoftware
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* NCC Group
* René Fritz
* Nicola Auchmuty
* Syslifters
* Hammerbacher
* TrainingSparkle
* Daniel Kucharski
* Healthchecks.io
* Yanal-Yves Fargialla
* WakaTime
* Paheko
* Synapsium
* DocRaptor


Version 59.0
------------

Released on 2023-05-11.

This version also includes the changes from unstable b1 version listed
below.

Bug fixes:

* `#1864 <https://github.com/Kozea/WeasyPrint/issues/1864>`_:
  Handle overflow for svg and symbol tags in SVG images
* `#1867 <https://github.com/Kozea/WeasyPrint/pull/1867>`_:
  Remove duplicate compression of attachments
* `d0ad5c1 <https://github.com/Kozea/WeasyPrint/commit/d0ad5c1>`_:
  Override use tag children instead of drawing their references
* `93df1a5 <https://github.com/Kozea/WeasyPrint/commit/93df1a5>`_:
  Don’t resize the same image twice when the --dpi option is set
* `#1874 <https://github.com/Kozea/WeasyPrint/pull/1874>`_:
  Drawn underline and overline behind text

Contributors:

* Guillaume Ayoub
* Timo Ramsauer
* Alexander Mankuta

Backers and sponsors:

* Castedo Ellerman
* Kobalt
* Spacinov
* Grip Angebotssoftware
* Crisp BV
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* NCC Group
* René Fritz
* Moritz Mahringer
* Yanal-Yves Fargialla
* Piotr Horzycki
* Healthchecks.io
* TrainingSparkle
* Hammerbacher
* Synapsium


Version 59.0b1
--------------

Released on 2023-04-14.

**This version is experimental, don't use it in production. If you find bugs,
please report them!**

Command-line API:

* The ``--optimize-size`` option and its short equivalent ``-O`` have been
  deprecated. To activate or deactivate different size optimizations, you can
  now use:

  * ``--uncompressed-pdf``,
  * ``--optimize-images``,
  * ``--full-fonts``,
  * ``--hinting``,
  * ``--dpi <resolution>``, and
  * ``--jpeg-quality <quality>``.

* A new ``--cache-folder <folder>`` option has been added to store temporary
  data in the given folder on the disk instead of keeping them in memory.

Python API:

* Global rendering options are now given in ``**options`` instead of dedicated
  parameters, with slightly different names. It means that the signature of the
  ``HTML.render()``, ``HTML.write_pdf()`` and ``Document.write_pdf()`` has
  changed. Here are the steps to port your Python code to v59.0:

  1. Use named parameters for these functions, not positioned parameters.
  2. Rename some the parameters:

     * ``image_cache`` becomes ``cache`` (see below),
     * ``identifier`` becomes ``pdf_identifier``,
     * ``variant`` becomes ``pdf_variant``,
     * ``version`` becomes ``pdf_version``,
     * ``forms`` becomes ``pdf_forms``.

* The ``optimize_size`` parameter of ``HTML.render()``, ``HTML.write_pdf()``
  and ``Document()`` has been removed and will be ignored. You can now use the
  ``uncompressed_pdf``, ``full_fonts``, ``hinting``, ``dpi`` and
  ``jpeg_quality`` parameters that are included in ``**options``.

* The ``cache`` parameter can be included in ``**options`` to replace
  ``image_cache``. If it is a dictionary, this dictionary will be used to store
  temporary data in memory, and can be even shared between multiple documents.
  If it’s a folder Path or string, WeasyPrint stores temporary data in the
  given temporary folder on disk instead of keeping them in memory.

New features:

* `#1853 <https://github.com/Kozea/WeasyPrint/pull/1853>`_,
  `#1854 <https://github.com/Kozea/WeasyPrint/issues/1854>`_:
  Reduce PDF size, with financial support from Code & Co.
* `#1824 <https://github.com/Kozea/WeasyPrint/issues/1824>`_,
  `#1829 <https://github.com/Kozea/WeasyPrint/pull/1829>`_:
  Reduce memory use for images
* `#1858 <https://github.com/Kozea/WeasyPrint/issues/1858>`_:
  Add an option to keep hinting information in embedded fonts

Bug fixes:

* `#1855 <https://github.com/Kozea/WeasyPrint/issues/1855>`_:
  Fix position of emojis in justified text
* `#1852 <https://github.com/Kozea/WeasyPrint/issues/1852>`_:
  Don’t crash when line can be split before trailing spaces
* `#1843 <https://github.com/Kozea/WeasyPrint/issues/1843>`_:
  Fix syntax of dates in metadata
* `#1827 <https://github.com/Kozea/WeasyPrint/issues/1827>`_,
  `#1832 <https://github.com/Kozea/WeasyPrint/pull/1832>`_:
  Fix word-spacing problems with nested tags

Documentation:

* `#1841 <https://github.com/Kozea/WeasyPrint/issues/1841>`_:
  Add a paragraph about unsupported calc() function

Contributors:

* Guillaume Ayoub
* Lucie Anglade
* Alex Ch
* whi_ne
* Jonas Castro

Backers and sponsors:

* Castedo Ellerman
* Kobalt
* Spacinov
* Grip Angebotssoftware
* Crisp BV
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* NCC Group
* René Fritz
* Moritz Mahringer
* Yanal-Yves Fargialla
* Piotr Horzycki
* Healthchecks.io
* TrainingSparkle
* Hammerbacher
* Synapsium


Version 58.1
------------

Released on 2023-03-07.

Bug fixes:

* `#1815 <https://github.com/Kozea/WeasyPrint/issues/1815>`_:
  Fix bookmarks coordinates
* `#1822 <https://github.com/Kozea/WeasyPrint/issues/1822>`_,
  `#1823 <https://github.com/Kozea/WeasyPrint/pull/1823>`_:
  Fix vertical positioning for absolute replaced elements

Documentation:

* `#1814 <https://github.com/Kozea/WeasyPrint/pull/1814>`_:
  Fix broken link pointing to samples

Contributors:

* Guillaume Ayoub
* Jonas Castro
* Lucie Anglade
* Menelaos Kotoglou

Backers and sponsors:

* Kobalt
* Grip Angebotssoftware
* Spacinov
* Crisp BV
* Castedo Ellerman
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* NCC Group
* René Fritz
* Moritz Mahringer
* Yanal-Yves Fargialla
* Piotr Horzycki
* Healthchecks.io
* Hammerbacher
* TrainingSparkle
* Synapsium


Version 58.0
------------

Released on 2023-02-17.

This version also includes the changes from unstable b1 version listed
below.

Bug fixes:

* `#1807 <https://github.com/Kozea/WeasyPrint/issues/1807>`_:
  Don’t crash when out-of-flow box is split in out-of-flow parent
* `#1806 <https://github.com/Kozea/WeasyPrint/issues/1806>`_:
  Don’t crash when fixed elements aren’t displayed yet in aborted line
* `#1809 <https://github.com/Kozea/WeasyPrint/issues/1809>`_:
  Fix background drawing for out-of-the-page transformed boxes

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Kobalt
* Grip Angebotssoftware
* Crisp BV
* Spacinov
* Castedo Ellerman
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* NCC Group
* René Fritz
* Moritz Mahringer
* Yanal-Yves Fargialla
* Piotr Horzycki
* Healthchecks.io


Version 58.0b1
--------------

Released on 2023-02-03.

**This version is experimental, don't use it in production. If you find bugs,
please report them!**

New features:

* `#61 <https://github.com/Kozea/WeasyPrint/issues/61>`_,
  `#1796 <https://github.com/Kozea/WeasyPrint/pull/1796>`_:
  Support PDF forms, with financial support from Personalkollen
* `#1173 <https://github.com/Kozea/WeasyPrint/issues/1173>`_:
  Add style for form fields

Bug fixes:

* `#1777 <https://github.com/Kozea/WeasyPrint/issues/1777>`_:
  Detect JPEG/MPO images as normal JPEG files
* `#1771 <https://github.com/Kozea/WeasyPrint/pull/1771>`_:
  Improve SVG gradients

Contributors:

* Guillaume Ayoub
* Lucie Anglade

Backers and sponsors:

* Kobalt
* Grip Angebotssoftware
* Crisp BV
* Spacinov
* Castedo Ellerman
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* NCC Group
* René Fritz
* Moritz Mahringer
* Yanal-Yves Fargialla
* Piotr Horzycki
* Healthchecks.io


Version 57.2
------------

Released on 2022-12-23.

Bug fixes:

* `0f2e377 <https://github.com/Kozea/WeasyPrint/commit/0f2e377>`_:
  Print annotations with PDF/A
* `0e9426f <https://github.com/Kozea/WeasyPrint/commit/0e9426f>`_:
  Hide annotations with PDF/UA
* `#1764 <https://github.com/Kozea/WeasyPrint/issues/1764>`_:
  Use reference instead of stream for annotation appearance stream
* `#1783 <https://github.com/Kozea/WeasyPrint/pull/1783>`_:
  Fix multiple font weights for @font-face declarations

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Grip Angebotssoftware
* Manuel Barkhau
* Crisp BV
* SimonSoft
* Menutech
* Spacinov
* KontextWork
* René Fritz
* NCC Group
* Kobalt
* Tom Pohl
* Castedo Ellerman
* Moritz Mahringer
* Piotr Horzycki
* Gábor Nyers
* Sidharth Kapur


Version 57.1
------------

Released on 2022-11-04.

Dependencies:

* `#1754 <https://github.com/Kozea/WeasyPrint/pull/1754>`_:
  Pillow 9.1.0 is now needed

Bug fixes:

* `#1756 <https://github.com/Kozea/WeasyPrint/pull/1756>`_:
  Fix rem font size for SVG images
* `#1755 <https://github.com/Kozea/WeasyPrint/issues/1755>`_:
  Keep format when transposing images
* `#1753 <https://github.com/Kozea/WeasyPrint/issues/1753>`_:
  Don’t use deprecated ``read_text`` function when ``files`` is available
* `#1741 <https://github.com/Kozea/WeasyPrint/issues/1741>`_:
  Generate better manpage
* `#1747 <https://github.com/Kozea/WeasyPrint/issues/1747>`_:
  Correctly set target counters in pages’ absolute elements
* `#1748 <https://github.com/Kozea/WeasyPrint/issues/1748>`_:
  Always set font size when font is changed in line
* `2b05137 <https://github.com/Kozea/WeasyPrint/commit/2b05137>`_:
  Fix stability of font identifiers

Documentation:

* `#1750 <https://github.com/Kozea/WeasyPrint/pull/1750>`_:
  Fix documentation spelling

Contributors:

* Guillaume Ayoub
* Eli Schwartz
* Mikhail Anikin
* Scott Kitterman

Backers and sponsors:

* Grip Angebotssoftware
* Manuel Barkhau
* Crisp BV
* SimonSoft
* Menutech
* Spacinov
* KontextWork
* René Fritz
* NCC Group
* Kobalt
* Tom Pohl
* John R Ellis
* Castedo Ellerman
* Moritz Mahringer
* Gábor
* Piotr Horzycki


Version 57.0
------------

Released on 2022-10-18.

This version also includes the changes from unstable b1 version listed
below.

New features:

* `a4fc7a1 <https://github.com/Kozea/WeasyPrint/commit/a4fc7a1>`_:
  Support image-orientation

Bug fixes:

* `#1739 <https://github.com/Kozea/WeasyPrint/issues/1739>`_:
  Set baseline on all flex containers
* `#1740 <https://github.com/Kozea/WeasyPrint/issues/1740>`_:
  Don’t crash when currentColor is set on root svg tag
* `#1718 <https://github.com/Kozea/WeasyPrint/issues/1718>`_:
  Don’t crash with empty bitmap glyphs
* `#1736 <https://github.com/Kozea/WeasyPrint/issues/1736>`_:
  Always use the font’s vector variant when possible
* `eef8b4d <https://github.com/Kozea/WeasyPrint/commit/eef8b4d>`_:
  Always set color and state before drawing
* `#1662 <https://github.com/Kozea/WeasyPrint/issues/1662>`_:
  Use a stable key to store stream fonts
* `#1733 <https://github.com/Kozea/WeasyPrint/issues/1733>`_:
  Don’t remove attachments when adding internal anchors
* `3c4fa50 <https://github.com/Kozea/WeasyPrint/commit/3c4fa50>`_,
  `c215697 <https://github.com/Kozea/WeasyPrint/commit/c215697>`_,
  `d275dac <https://github.com/Kozea/WeasyPrint/commit/d275dac>`_,
  `b04bfff <https://github.com/Kozea/WeasyPrint/commit/b04bfff>`_:
  Fix many bugs related to PDF/UA structure

Performance:

* `dfccf1b <https://github.com/Kozea/WeasyPrint/commit/dfccf1b>`_:
  Use faces as fonts dictionary keys
* `0dc12b6 <https://github.com/Kozea/WeasyPrint/commit/0dc12b6>`_:
  Cache add_font to avoid calling get_face too often
* `75e17bf <https://github.com/Kozea/WeasyPrint/commit/75e17bf>`_:
  Don’t call process_whitespace twice on many children
* `498d3e1 <https://github.com/Kozea/WeasyPrint/commit/498d3e1>`_:
  Optimize __missing__ functions

Documentation:

* `863b3d6 <https://github.com/Kozea/WeasyPrint/commit/863b3d6>`_:
  Update documentation of installation on macOS with Homebrew

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Grip Angebotssoftware
* Manuel Barkhau
* Crisp BV
* SimonSoft
* Menutech
* Spacinov
* KontextWork
* René Fritz
* NCC Group
* Kobalt
* Tom Pohl
* John R Ellis
* Castedo Ellerman
* Moritz Mahringer
* Gábor
* Piotr Horzycki


Version 57.0b1
--------------

Released on 2022-09-22.

**This version is experimental, don't use it in production. If you find bugs,
please report them!**

New features:

* `#1704 <https://github.com/Kozea/WeasyPrint/pull/1704>`_:
  Support PDF/UA, with financial support from Novareto
* `#1454 <https://github.com/Kozea/WeasyPrint/issues/1454>`_:
  Support variable fonts

Bug fixes:

* `#1058 <https://github.com/Kozea/WeasyPrint/issues/1058>`_:
  Fix bullet position after page break, with financial support from OpenZeppelin
* `#1707 <https://github.com/Kozea/WeasyPrint/issues/1707>`_:
  Fix footnote positioning in multicolumn layout, with financial support from Code & Co.
* `#1722 <https://github.com/Kozea/WeasyPrint/issues/1722>`_:
  Handle skew transformation with only one parameter
* `#1715 <https://github.com/Kozea/WeasyPrint/issues/1715>`_:
  Don’t crash when images are truncated
* `#1697 <https://github.com/Kozea/WeasyPrint/issues/1697>`_:
  Don’t crash when attr() is used in text-decoration-color
* `#1695 <https://github.com/Kozea/WeasyPrint/pull/1695>`_:
  Include language information in PDF metadata
* `#1612 <https://github.com/Kozea/WeasyPrint/issues/1612>`_:
  Don’t lowercase letters when capitalizing text
* `#1700 <https://github.com/Kozea/WeasyPrint/issues/1700>`_:
  Fix crash when rendering footnote with repagination
* `#1667 <https://github.com/Kozea/WeasyPrint/issues/1667>`_:
  Follow EXIF metadata for image rotation
* `#1669 <https://github.com/Kozea/WeasyPrint/issues/1669>`_:
  Take care of floats when remvoving placeholders
* `#1638 <https://github.com/Kozea/WeasyPrint/issues/1638>`_:
  Use the original box when breaking waiting children

Contributors:

* Guillaume Ayoub
* Konstantin Weddige
* VeteraNovis
* Lucie Anglade

Backers and sponsors:

* Grip Angebotssoftware
* Manuel Barkhau
* Crisp BV
* SimonSoft
* Menutech
* Spacinov
* KontextWork
* René Fritz
* NCC Group
* Kobalt
* Tom Pohl
* John R Ellis
* Moritz Mahringer
* Gábor
* Piotr Horzycki
* Andrew Ittner


Version 56.1
------------

Released on 2022-07-24.

Bug fixes:

* `#1674 <https://github.com/Kozea/WeasyPrint/issues/1674>`_:
  Follow max-height on footnot area, with financial support from Code & Co.
* `#1678 <https://github.com/Kozea/WeasyPrint/issues/1678>`_:
  Fix gradients with opacity set

Contributors:

* Guillaume Ayoub
* Lucie Anglade

Backers and sponsors:

* Grip Angebotssoftware
* Manuel Barkhau
* Crisp BV
* SimonSoft
* Menutech
* Spacinov
* KontextWork
* René Fritz
* NCC Group
* Kobalt
* Tom Pohl
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla
* Gábor
* Piotr Horzycki
* Andrew Ittner


Version 56.0
------------

Released on 2022-07-07.

This version also includes the changes from unstable b1 version listed
below.

New features:

* `70f9b62 <https://github.com/Kozea/WeasyPrint/commit/70f9b62>`_:
  Support format 5 for bitmap glyphs

Bug fixes:

* `#1666 <https://github.com/Kozea/WeasyPrint/issues/1666>`_
  Fix reproducible PDF generation with embedded images
* `#1668 <https://github.com/Kozea/WeasyPrint/issues/1668>`_:
  Fix @page:nth() selector
* `3bd9a8e <https://github.com/Kozea/WeasyPrint/commit/3bd9a8e>`_:
  Don’t limit the opacity groups to the original box size
* `cb9540b <https://github.com/Kozea/WeasyPrint/commit/cb9540b>`_,
  `76d174f <https://github.com/Kozea/WeasyPrint/commit/76d174f>`_,
  `9ce6547 <https://github.com/Kozea/WeasyPrint/commit/9ce6547>`_:
  Minor bugfixes for split table rows

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Grip Angebotssoftware
* Manuel Barkhau
* Crisp BV
* SimonSoft
* Menutech
* Spacinov
* KontextWork
* René Fritz
* NCC Group
* Kobalt
* Des images et des mots
* Andreas Zettl
* Tom Pohl
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla
* Gábor
* Piotr Horzycki


Version 56.0b1
--------------

Released on 2022-06-17.

**This version is experimental, don't use it in production. If you find bugs,
please report them!**

Dependencies:

* pydyf 0.2.0+ is now needed

New features:

* `#1660 <https://github.com/Kozea/WeasyPrint/pull/1660>`_:
  Support nested line-clamp, with financial support from Expert Germany
* `#1644 <https://github.com/Kozea/WeasyPrint/pull/1644>`_,
  `#1645 <https://github.com/Kozea/WeasyPrint/issues/1645>`_:
  Support bitmap fonts, with financial support from Expert Germany
* `#1651 <https://github.com/Kozea/WeasyPrint/pull/1651>`_,
  `#630 <https://github.com/Kozea/WeasyPrint/issues/630>`_:
  Support PDF/A, with financial support from Blueshoe

Bug fixes:

* `#1656 <https://github.com/Kozea/WeasyPrint/issues/1656>`_:
  Fix chained variables in the same selector block
* `#1028 <https://github.com/Kozea/WeasyPrint/issues/1028>`_:
  Fix font weight management in @font-face rules
* `#1653 <https://github.com/Kozea/WeasyPrint/issues/1653>`_:
  Don’t crash when @font-face’s src ends with a comma
* `#1650 <https://github.com/Kozea/WeasyPrint/issues/1650>`_:
  Don’t check origin when URL only contains fragment
* `e38bff8 <https://github.com/Kozea/WeasyPrint/commit/e38bff8>`_:
  Don’t crash when inherited SVG attributes are not set on the parent

Performance:

* `e6021da <https://github.com/Kozea/WeasyPrint/commit/e6021da>`_:
  Launch tests in parallel by default

Contributors:

* Guillaume Ayoub
* aschmitz
* Lucie Anglade

Backers and sponsors:

* Grip Angebotssoftware
* Manuel Barkhau
* Crisp BV
* SimonSoft
* Menutech
* Spacinov
* KontextWork
* René Fritz
* NCC Group
* Kobalt
* Des images et des mots
* Andreas Zettl
* Tom Pohl
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla
* Gábor
* Piotr Horzycki


Version 55.0
------------

Released on 2022-05-12.

This version also includes the changes from unstable b1 version listed
below.

Bug fixes:

* `#1626 <https://github.com/Kozea/WeasyPrint/issues/1626>`_,
  `3802f88 <https://github.com/Kozea/WeasyPrint/commit/3802f88>`_:
  Fix the vertical position and available height of absolute boxes
* `9641098 <https://github.com/Kozea/WeasyPrint/commit/9641098>`_,
  `e5e6b88 <https://github.com/Kozea/WeasyPrint/commit/e5e6b88>`_:
  Minor fixes for multi-column layout
* `0fcc7de <https://github.com/Kozea/WeasyPrint/commit/0fcc7de>`_:
  Don’t stop rendering SVG when CSS parsing fails
* `#1636 <https://github.com/Kozea/WeasyPrint/pull/1636>`_:
  Fix sequential footnotes that could disappear when overflowing
* `#1637 <https://github.com/Kozea/WeasyPrint/issues/1637>`_:
  Fix position of absolute boxes with right-to-left direction
* `#1641 <https://github.com/Kozea/WeasyPrint/issues/1641>`_:
  Fix relative paths for SVG files stored as data URLs

Contributors:

* Guillaume Ayoub
* aschmitz

Backers and sponsors:

* Grip Angebotssoftware
* Manuel Barkhau
* Crisp BV
* SimonSoft
* Menutech
* Spacinov
* KontextWork
* René Fritz
* NCC Group
* Kobalt
* Nathalie Gutton
* Andreas Zettl
* Tom Pohl
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla
* Gábor
* Piotr Horzycki


Version 55.0b1
--------------

Released on 2022-04-15.

**This version is experimental, don't use it in production. If you find bugs,
please report them!**

Dependencies:

* Python 3.7+ is now needed, Python 3.6 is not supported anymore

New features:

* `#1534 <https://github.com/Kozea/WeasyPrint/pull/1534>`_:
  Support ``word-break: break-all``
* `#489 <https://github.com/Kozea/WeasyPrint/issues/489>`_,
  `#1619 <https://github.com/Kozea/WeasyPrint/pull/1619>`_:
  Support column breaks
* `#1553 <https://github.com/Kozea/WeasyPrint/issues/1553>`_:
  Allow reproducible PDF generation

Bug fixes:

* `#1007 <https://github.com/Kozea/WeasyPrint/issues/1007>`_,
  `#1524 <https://github.com/Kozea/WeasyPrint/pull/1524>`_:
  Handle ``inherit`` in shorthand properties
* `#1539 <https://github.com/Kozea/WeasyPrint/issues/1539>`_,
  `#1541 <https://github.com/Kozea/WeasyPrint/pull/1541>`_:
  Space out no-repeat patterns
* `#1554 <https://github.com/Kozea/WeasyPrint/pull/1554>`_:
  Avoid invalid PDF operators when drawing SVG text
* `#1564 <https://github.com/Kozea/WeasyPrint/issues/1564>`_,
  `#1566 <https://github.com/Kozea/WeasyPrint/pull/1566>`_,
  `#1570 <https://github.com/Kozea/WeasyPrint/pull/1570>`_:
  Don’t output footnotes before their call sites
* `#1020 <https://github.com/Kozea/WeasyPrint/issues/1020>`_,
  `#1597 <https://github.com/Kozea/WeasyPrint/pull/1597>`_:
  Prevent infinite loops in multi-column layout
* `#1512 <https://github.com/Kozea/WeasyPrint/issues/1512>`_,
  `#1613 <https://github.com/Kozea/WeasyPrint/pull/1613>`_:
  Fix position of absolute boxes in right-to-left contexts
* `#1093 <https://github.com/Kozea/WeasyPrint/issues/1093>`_:
  Draw borders around absolute replaced boxes
* `#984 <https://github.com/Kozea/WeasyPrint/issues/984>`_,
  `#1604 <https://github.com/Kozea/WeasyPrint/issues/1604>`_:
  Fix skip stacks for columns
* `#1621 <https://github.com/Kozea/WeasyPrint/issues/1621>`_:
  Better support of nested ``text-decoration`` properties
* `fe1f3d9 <https://github.com/Kozea/WeasyPrint/commit/fe1f3d9>`_:
  Fix absolute blocks in lines
* `4650b70 <https://github.com/Kozea/WeasyPrint/commit/4650b70>`_:
  Clear adjoining margins when a container’s child doesn’t fit

Performance:

* `#1548 <https://github.com/Kozea/WeasyPrint/pull/1548>`_:
  Improve tests speed
* `3b0ae92 <https://github.com/Kozea/WeasyPrint/commit/3b0ae92>`_,
  `#1457 <https://github.com/Kozea/WeasyPrint/issues/1457>`_:
  Improve fonts management
* `#1597 <https://github.com/Kozea/WeasyPrint/pull/1597>`_:
  Improve column layout speed
* `#1587 <https://github.com/Kozea/WeasyPrint/pull/1587>`_,
  `#1607 <https://github.com/Kozea/WeasyPrint/pull/1607>`_,
  `#1608 <https://github.com/Kozea/WeasyPrint/pull/1608>`_:
  Cache ``ch`` and ``ex`` units calculations

Contributors:

* Guillaume Ayoub
* aschmitz
* Lucie Anglade
* Christoph Kepper
* Jack Lin
* Rian McGuire

Backers and sponsors:

* Grip Angebotssoftware
* Manuel Barkhau
* Crisp BV
* SimonSoft
* Menutech
* KontextWork
* Maykin Media
* René Fritz
* NCC Group
* Spacinov
* Nathalie Gutton
* Andreas Zettl
* Tom Pohl
* Kobalt
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla
* Gábor
* Piotr Horzycki
* DeivGuerrero


Version 54.3
------------

Released on 2022-04-04.

Bug fixes:

* `#1588 <https://github.com/Kozea/WeasyPrint/pull/1588>`_:
  Support position: absolute in footnotes
* `#1586 <https://github.com/Kozea/WeasyPrint/issues/1586>`_:
  Fix discarded text-align values

Contributors:

* aschmitz
* Guillaume Ayoub

Backers and sponsors:

* Grip Angebotssoftware
* Manuel Barkhau
* Crisp BV
* SimonSoft
* Menutech
* KontextWork
* Maykin Media
* René Fritz
* NCC Group
* Spacinov
* Nathalie Gutton
* Andreas Zettl
* Tom Pohl
* Kobalt
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla
* Gábor
* Piotr Horzycki
* DeivGuerrero


Version 54.2
------------

Released on 2022-02-27.

Bug fixes:

* `#1575 <https://github.com/Kozea/WeasyPrint/issues/1575>`_:
  Always store parent blocks children as lists
* `#1574 <https://github.com/Kozea/WeasyPrint/issues/1574>`_,
  `#1559 <https://github.com/Kozea/WeasyPrint/pull/1559>`_:
  Fix float rounding errors
* `#1571 <https://github.com/Kozea/WeasyPrint/issues/1571>`_:
  Ignore unknown glyphs
* `#1561 <https://github.com/Kozea/WeasyPrint/issues/1561>`_,
  `#1562 <https://github.com/Kozea/WeasyPrint/issues/1562>`_:
  Fix line break when breaks occur between a nbsp and an inline block
* `#1560 <https://github.com/Kozea/WeasyPrint/issues/1560>`_:
  Always set the child index
* `#1558 <https://github.com/Kozea/WeasyPrint/issues/1558>`_:
  Fix patterns with use tags

Contributors:

* Guillaume Ayoub
* Lucie Anglade
* Jack Lin
* aschmitz

Backers and sponsors:

* Grip Angebotssoftware
* Manuel Barkhau
* Crisp BV
* SimonSoft
* Menutech
* KontextWork
* Maykin Media
* René Fritz
* NCC Group
* Spacinov
* Nathalie Gutton
* Andreas Zettl
* Tom Pohl
* Kobalt
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla
* Gábor
* Piotr Horzycki
* DeivGuerrero


Version 54.1
------------

Released on 2022-01-31.

New features:

* `#1547 <https://github.com/Kozea/WeasyPrint/issues/1547>`_:
  Handle break-inside: avoid on tr tags

Bug fixes:

* `#1540 <https://github.com/Kozea/WeasyPrint/issues/1540>`_,
  `#1239 <https://github.com/Kozea/WeasyPrint/issues/1239>`_:
  Handle absolute children in running elements
* `#1538 <https://github.com/Kozea/WeasyPrint/issues/1538>`_:
  Handle invalid values in text-align
* `#1536 <https://github.com/Kozea/WeasyPrint/issues/1536>`_:
  Handle absolute flex boxes

Contirbutors:

* Guillaume Ayoub
* Lucie Anglade

Backers and sponsors:

* H-Net: Humanities and Social Sciences Online
* Grip Angebotssoftware
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* Crisp BV
* Maykin Media
* René Fritz
* Simon Sapin
* NCC Group
* Nathalie Gutton
* Andreas Zettl
* Tom Pohl
* Spacinov
* Des images et des mots
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla
* Gábor
* Piotr Horzycki


Version 54.0
------------

Released on 2022-01-08.

This version also includes the changes from unstable b1 version listed
below.

Bug fixes:

* `#1531 <https://github.com/Kozea/WeasyPrint/issues/1531>`_:
  Always use absolute paths to get hrefs in SVG
* `#1523 <https://github.com/Kozea/WeasyPrint/issues/1523>`_:
  Fix many rendering problems of broken tables
* `e1aee70 <https://github.com/Kozea/WeasyPrint/commit/e1aee70>`_:
  Fix support of fonts with SVG emojis

Contirbutors:

* Guillaume Ayoub

Backers and sponsors:

* Grip Angebotssoftware
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* Crisp BV
* Maykin Media
* René Fritz
* Simon Sapin
* NCC Group
* Nathalie Gutton
* Andreas Zettl
* Tom Pohl
* Des images et des mots
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla
* Gábor
* Piotr Horzycki


Version 54.0b1
--------------

Released on 2021-12-13.

**This version is experimental, don't use it in production. If you find bugs,
please report them!**

Dependencies:

* html5lib 1.1+ is now needed.

New features:

* `#1509 <https://github.com/Kozea/WeasyPrint/pull/1509>`_:
  Support footnotes, with financial support from Code & Co.
* `#36 <https://github.com/Kozea/WeasyPrint/issues/36>`_:
  Handle parallel flows for floats, absolutes, table-cells
* `#1389 <https://github.com/Kozea/WeasyPrint/pull/1389>`_:
  Support ``text-align-last`` and ``text-align-all`` properties
* `#1434 <https://github.com/Kozea/WeasyPrint/pull/1434>`_:
  Draw SVG and PNG emojis
* `#1520 <https://github.com/Kozea/WeasyPrint/pull/1520>`_:
  Support ``overflow-wrap: anywhere``
* `#1435 <https://github.com/Kozea/WeasyPrint/issues/1435>`_:
  Add environment variable to set DLL folder on Windows

Performance:

* `#1439 <https://github.com/Kozea/WeasyPrint/issues/1439>`_:
  Cache SVG ``use`` tags
* `#1481 <https://github.com/Kozea/WeasyPrint/pull/1481>`_:
  Encode non-JPEG images as PNGs instead of JPEG2000s

Bug fixes:

* `#137 <https://github.com/Kozea/WeasyPrint/issues/137>`_:
  Don’t use ``text-transform`` text for content-based uses
* `#1443 <https://github.com/Kozea/WeasyPrint/issues/1443>`_:
  Don’t serialize and parse again inline SVG files
* `#607 <https://github.com/Kozea/WeasyPrint/issues/607>`_:
  Correctly handle whitespaces in bookmark labels
* `#1094 <https://github.com/Kozea/WeasyPrint/issues/1094>`_:
  Fix column height with ``column-span`` content
* `#1473 <https://github.com/Kozea/WeasyPrint/issues/1473>`_:
  Fix absolutely positioned boxes in duplicated pages
* `#1491 <https://github.com/Kozea/WeasyPrint/issues/1491>`_:
  Fix ``target-counter`` attribute in flex items
* `#1515 <https://github.com/Kozea/WeasyPrint/issues/1515>`_,
  `#1508 <https://github.com/Kozea/WeasyPrint/issues/1508>`_:
  Don’t draw empty glyphs
* `#1499 <https://github.com/Kozea/WeasyPrint/issues/1499>`_:
  Don’t crash when font size is really small

Documentation:

* `#1519 <https://github.com/Kozea/WeasyPrint/issues/1519>`_:
  Fix typo

Packaging:

* The source package does not include a ``setup.py`` file anymore. You can find
  more information about this in
  `issue #1410 <https://github.com/Kozea/WeasyPrint/issues/1410>`_.

Contirbutors:

* Guillaume Ayoub
* Lucie Anglade
* Colin Kinloch
* aschmitz
* Pablo González
* Rian McGuire

Backers and sponsors:

* Grip Angebotssoftware
* Manuel Barkhau
* SimonSoft
* Menutech
* KontextWork
* Crisp BV
* Maykin Media
* René Fritz
* Simon Sapin
* NCC Group
* Nathalie Gutton
* Andreas Zettl
* Tom Pohl
* Des images et des mots
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla
* Gábor
* Piotr Horzycki


Version 53.4
------------

Released on 2021-11-14.

Bug fixes:

* `#1446 <https://github.com/Kozea/WeasyPrint/issues/1446>`_:
  Fix background on pages with a bleed property
* `#1455 <https://github.com/Kozea/WeasyPrint/issues/1455>`_:
  Use SVG width/height as inner size when no viewBox is given
* `#1469 <https://github.com/Kozea/WeasyPrint/issues/1469>`_:
  Only enable letter- and word-spacing when needed
* `#1471 <https://github.com/Kozea/WeasyPrint/issues/1471>`_:
  Don’t display inputs with "hidden" type
* `#1485 <https://github.com/Kozea/WeasyPrint/issues/1485>`_:
  Allow quotes in url() syntax for SVG,
  Use better approximations for font ascent and descent values in SVG
* `#1486 <https://github.com/Kozea/WeasyPrint/issues/1486>`_:
  Fix images embedded from multiple pages
* `#1489 <https://github.com/Kozea/WeasyPrint/issues/1489>`_:
  Use a better hash for fonts to avoid collisions
* `abd54c4 <https://github.com/Kozea/WeasyPrint/commit/abd54c4>`_:
  Set SVG ratio when width and height are 0

Contributors:

* Guillaume Ayoub
* Lucie Anglade

Backers and sponsors:

* Grip Angebotssoftware
* SimonSoft
* Menutech
* Manuel Barkhau
* Simon Sapin
* KontextWork
* René Fritz
* Maykin Media
* NCC Group
* Crisp BV
* Des images et des mots
* Andreas Zettl
* Nathalie Gutton
* Tom Pohl
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla
* G. Allard
* Gábor


Version 53.3
------------

Released on 2021-09-10.

Bug fixes:

* `#1431 <https://github.com/Kozea/WeasyPrint/issues/1431>`_,
  `#1440 <https://github.com/Kozea/WeasyPrint/issues/1440>`_:
  Fix crashes and malformed PDF files
* `#1430 <https://github.com/Kozea/WeasyPrint/issues/1430>`_:
  Handle cx and cy in SVG rotations
* `#1436 <https://github.com/Kozea/WeasyPrint/pull/1436>`_:
  Fix marker-start being drawn on mid vertices

Contributors:

* Guillaume Ayoub
* Rian McGuire
* Lucie Anglade

Backers and sponsors:

* Grip Angebotssoftware
* SimonSoft
* Menutech
* Manuel Barkhau
* Simon Sapin
* KontextWork
* René Fritz
* Maykin Media
* NCC Group
* Des images et des mots
* Andreas Zettl
* Nathalie Gutton
* Tom Pohl
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla


Version 53.2
------------

Released on 2021-08-27.

New features:

* `#1428 <https://github.com/Kozea/WeasyPrint/issues/1428>`_:
  Re-add the ``make_bookmark_tree()`` method

Bug fixes:

* `#1429 <https://github.com/Kozea/WeasyPrint/issues/1429>`_:
  Fix package deployed on PyPI

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Grip Angebotssoftware
* PDF Blocks
* SimonSoft
* Menutech
* Manuel Barkhau
* Simon Sapin
* KontextWork
* René Fritz
* Maykin Media
* NCC Group
* Des images et des mots
* Andreas Zettl
* Nathalie Gutton
* Tom Pohl
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla


Version 53.1
------------

Released on 2021-08-22.

Bug fixes:

* `#1409 <https://github.com/Kozea/WeasyPrint/issues/1409>`_:
  Don’t crash when leaders are in floats
* `#1414 <https://github.com/Kozea/WeasyPrint/issues/1414>`_:
  Embed images once
* `#1417 <https://github.com/Kozea/WeasyPrint/issues/1417>`_:
  Fix crash with SVG intrinsic ratio

Documentation:

* `#1422 <https://github.com/Kozea/WeasyPrint/issues/1422>`_:
  Include ``weasyprint.tools`` removal in documentation

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Grip Angebotssoftware
* PDF Blocks
* SimonSoft
* Menutech
* Manuel Barkhau
* Simon Sapin
* KontextWork
* René Fritz
* Maykin Media
* NCC Group
* Des images et des mots
* Andreas Zettl
* Nathalie Gutton
* Tom Pohl
* Moritz Mahringer
* Florian Demmer
* Yanal-Yves Fargialla


Version 53.0
------------

Released on 2021-07-31.

This version also includes the changes from unstable b1 and b2 versions listed
below.

Dependencies:

* Pango 1.44.0+ is now needed.
* pydyf 0.0.3+ is now needed.
* fontTools 4.0.0+ is now needed.
* html5lib 1.0.1+ is now needed.

API changes:

* ``FontConfiguration`` is now in the ``weasyprint.text.fonts`` module.
* ``--format`` and ``--resolution`` options have been deprecated, PDF is the
  only output format supported.
* ``--optimize-images`` option has been deprecated and replaced by
  ``--optimize-size``, allowing ``images``, ``fonts``, ``all`` and ``none``
  values.
* ``weasyprint.tools`` have been removed.
* ``Document.resolve_links``, ``Document.make_bookmark_tree`` and
  ``Document.add_hyperlinks`` have been removed.

Performance:

* Improve image management

New features:

* `#1374 <https://github.com/Kozea/WeasyPrint/issues/1374>`_:
  Support basic "clipPath" in SVG

Bug fixes:

* `#1369 <https://github.com/Kozea/WeasyPrint/issues/1369>`_:
  Render use path in SVG
* `#1370 <https://github.com/Kozea/WeasyPrint/issues/1370>`_:
  Fix fill color on use path in SVG
* `#1371 <https://github.com/Kozea/WeasyPrint/issues/1371>`_:
  Handle stroke-opacity and fill-opacity
* `#1378 <https://github.com/Kozea/WeasyPrint/issues/1378>`_:
  Fix crash with borders whose widths are in em
* `#1394 <https://github.com/Kozea/WeasyPrint/issues/1394>`_:
  Fix crash on draw_pattern
* `#880 <https://github.com/Kozea/WeasyPrint/issues/880>`_:
  Handle stacking contexts put in contexts by previous generations
* `#1386 <https://github.com/Kozea/WeasyPrint/issues/1386>`_:
  Catch font subsetting errors
* `#1403 <https://github.com/Kozea/WeasyPrint/issues/1403>`_:
  Fix how x and y attributes are handled in SVG
* `#1399 <https://github.com/Kozea/WeasyPrint/issues/1399>`_,
  `#1401 <https://github.com/Kozea/WeasyPrint/pull/1401>`_:
  Don’t crash when use tags reference non-existing element
* `#1393 <https://github.com/Kozea/WeasyPrint/issues/1393>`_:
  Handle font collections
* `#1408 <https://github.com/Kozea/WeasyPrint/issues/1408>`_:
  Handle x and y attributes in use tags

Documentation:

* `#1391 <https://github.com/Kozea/WeasyPrint/issues/1391>`_,
  `#1405 <https://github.com/Kozea/WeasyPrint/pull/1405>`_:
  Add documentation for installation

Contributors:

* Guillaume Ayoub
* Lucie Anglade
* Pelle Bo Regener
* aschmitz
* John Jackson
* Felix Schwarz
* Syrus Dark
* Christoph Päper

Backers and sponsors:

* OpenEdition
* Grip Angebotssoftware
* Simonsoft
* PDF Blocks
* Menutech
* Manuel Barkhau
* print-css.rocks
* Simon Sapin
* KontextWork
* René Fritz
* Maykin Media
* Nathalie Gutton
* Andreas Zettl
* Tom Pohl
* NCC Group
* Moritz Mahringer
* Florian Demmer
* Des images et des mots
* Mohammed Y. Alnajdi
* Yanal-Yves Fargialla
* Yevhenii Hyzyla


Version 53.0b2
--------------

Released on 2021-05-30.

**This version is experimental, don't use it in production. If you find bugs,
please report them!**

New features:

* `#359 <https://github.com/Kozea/WeasyPrint/issues/359>`_:
  Embed full sets of fonts in PDF

Bug fixes:

* `#1345 <https://github.com/Kozea/WeasyPrint/issues/1345>`_:
  Fix position of SVG use tags
* `#1346 <https://github.com/Kozea/WeasyPrint/pull/1346>`_:
  Handle "stroke-dasharray: none"
* `#1352 <https://github.com/Kozea/WeasyPrint/issues/1352>`_,
  `#1358 <https://github.com/Kozea/WeasyPrint/pull/1358>`_:
  Sort link target identifiers
* `#1357 <https://github.com/Kozea/WeasyPrint/issues/1357>`_:
  Fix font information
* `#1362 <https://github.com/Kozea/WeasyPrint/issues/1362>`_:
  Handle visibility and display properties in SVG
* `#1365 <https://github.com/Kozea/WeasyPrint/issues/1365>`_:
  Cascade inherited attributes for use tags
* `#1366 <https://github.com/Kozea/WeasyPrint/issues/1366>`_:
  Correctly handle style attributes in SVG
* `#1367 <https://github.com/Kozea/WeasyPrint/issues/1367>`_:
  Include line stroke in box bounding

Documentation:

* `#1341 <https://github.com/Kozea/WeasyPrint/pull/1341>`_:
  Fix typos

Contributors:

* Guillaume Ayoub
* aschmitz
* John Jackson
* Lucie Anglade
* Pelle Bo Regener

Backers and sponsors:

* OpenEdition
* print-css.rocks
* Simonsoft
* PDF Blocks
* Menutech
* Manuel Barkhau
* Simon Sapin
* Grip Angebotssoftware
* KontextWork
* René Fritz
* Nathalie Gutton
* Andreas Zettl
* Tom Pohl
* Maykin Media
* Moritz Mahringer
* Florian Demmer
* Mohammed Y. Alnajdi
* NCC Group
* Des images et des mots
* Yanal-Yves Fargialla
* Yevhenii Hyzyla


Version 53.0b1
--------------

Released on 2021-04-22.

**This version is experimental, don't use it in production. If you find bugs,
please report them!**

Dependencies:

* This version uses its own PDF generator instead of Cairo. Rendering may be
  different for text, gradients, SVG images…
* Packaging is now done with Flit.

New features:

* `#1328 <https://github.com/Kozea/WeasyPrint/pull/1328>`_:
  Add ISO and JIS paper sizes
* `#1309 <https://github.com/Kozea/WeasyPrint/pull/1309>`_:
  Leader support, with financial support from Simonsoft

Bug fixes:

* `#504 <https://github.com/Kozea/WeasyPrint/issues/504>`_:
  Fix rendering bugs with PDF gradients
* `#606 <https://github.com/Kozea/WeasyPrint/issues/606>`_:
  Fix rounding errors on PDF dimensions
* `#1264 <https://github.com/Kozea/WeasyPrint/issues/1264>`_:
  Include witdh/height when calculating auto margins of absolute boxes
* `#1191 <https://github.com/Kozea/WeasyPrint/issues/1191>`_:
  Don’t try to get an earlier page break between columns
* `#1235 <https://github.com/Kozea/WeasyPrint/issues/1235>`_:
  Include padding, border, padding when calculating inline-block width
* `#1199 <https://github.com/Kozea/WeasyPrint/issues/1199>`_:
  Fix kerning issues with small fonts

Documentation:

* `#1298 <https://github.com/Kozea/WeasyPrint/pull/1298>`_:
  Rewrite documentation

Contributors:

* Guillaume Ayoub
* Lucie Anglade
* Felix Schwarz
* Syrus Dark
* Christoph Päper

Backers and sponsors:

* Simonsoft
* PDF Blocks
* Menutech
* Manuel Barkhau
* Simon Sapin
* Nathalie Gutton
* Andreas Zettl
* René Fritz
* Tom Pohl
* KontextWork
* Moritz Mahringer
* Florian Demmer
* Maykin Media
* Yanal-Yves Fargialla
* Des images et des mots
* Yevhenii Hyzyla


Version 52.5
------------

Released on 2021-04-17.

Bug fixes:

* `#1336 <https://github.com/Kozea/WeasyPrint/issues/1336>`_:
  Fix text breaking exception
* `#1318 <https://github.com/Kozea/WeasyPrint/issues/1318>`_:
  Fix @font-face rules with Pango 1.48.3+

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Simonsoft
* PDF Blocks
* Menutech
* Manuel Barkhau
* Simon Sapin
* Nathalie Gutton
* Andreas Zettl
* René Fritz
* Tom Pohl
* KontextWork
* Moritz Mahringer
* Florian Demmer
* Maykin Media
* Yanal-Yves Fargialla
* Des images et des mots
* Yevhenii Hyzyla


Version 52.4
------------

Released on 2021-03-11.

Bug fixes:

* `#1304 <https://github.com/Kozea/WeasyPrint/issues/1304>`_:
  Don’t try to draw SVG files with no size
* `ece5f066 <https://github.com/Kozea/WeasyPrint/commit/ece5f066>`_:
  Avoid crash on last word detection
* `4ee42e48 <https://github.com/Kozea/WeasyPrint/commit/4ee42e48>`_:
  Remove last word before ellipses when hyphenated

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* PDF Blocks
* Simonsoft
* Menutech
* Simon Sapin
* Manuel Barkhau
* Andreas Zettl
* Nathalie Gutton
* Tom Pohl
* René Fritz
* Moritz Mahringer
* Florian Demmer
* KontextWork
* Michele Mostarda


Version 52.3
------------

Released on 2021-03-02.

Bug fixes:

* `#1299 <https://github.com/Kozea/WeasyPrint/issues/1299>`_:
  Fix imports with url() and quotes

New features:

* `#1300 <https://github.com/Kozea/WeasyPrint/pull/1300>`_:
  Add support of line-clamp, with financial support from
  expert Germany

Contributors:

* Guillaume Ayoub
* Lucie Anglade

Backers and sponsors:

* PDF Blocks
* Simonsoft
* Menutech
* Simon Sapin
* Manuel Barkhau
* Andreas Zettl
* Nathalie Gutton
* Tom Pohl
* Moritz Mahringer
* Florian Demmer
* KontextWork
* Michele Mostarda


Version 52.2
------------

Released on 2020-12-06.

Bug fixes:

* `238e214 <https://github.com/Kozea/WeasyPrint/commit/238e214>`_:
  Fix URL handling with tinycss2
* `#1248 <https://github.com/Kozea/WeasyPrint/issues/1248>`_:
  Include missing test data
* `#1254 <https://github.com/Kozea/WeasyPrint/issues/1254>`_:
  Top margins removed from children when tables are displayed on multiple pages
* `#1250 <https://github.com/Kozea/WeasyPrint/issues/1250>`_:
  Correctly draw borders on the last line of split tables
* `a6f9c80 <https://github.com/Kozea/WeasyPrint/commit/a6f9c80>`_:
  Add a nice gif to please gdk-pixbuf 2.42.0

Contributors:

* Guillaume Ayoub
* Lucie Anglade
* Felix Schwarz

Backers and sponsors:

* PDF Blocks
* Simonsoft
* Menutech
* Simon Sapin
* Nathalie Gutton
* Andreas Zetti
* Tom Pohl
* Florian Demmer
* Moritz Mahringer


Version 52.1
------------

Released on 2020-11-02.

Bug fixes:

* `238e214 <https://github.com/Kozea/WeasyPrint/commit/238e214>`_:
  Fix URL handling with tinycss2

Contributors:

* Guillaume Ayoub

Backers and sponsors:

* Simonsoft
* Simon Sapin
* Nathalie Gutton
* Andreas Zettl
* Florian Demmer
* Moritz Mahringer


Version 52
----------

Released on 2020-10-29.

Dependencies:

* Python 3.6+ is now needed, Python 3.5 is not supported anymore
* WeasyPrint now depends on Pillow

New features:

* `#1019 <https://github.com/Kozea/WeasyPrint/issues/1019>`_:
  Implement ``counter-set``
* `#1080 <https://github.com/Kozea/WeasyPrint/issues/1080>`_:
  Don’t display ``template`` tags
* `#1210 <https://github.com/Kozea/WeasyPrint/pull/1210>`_:
  Use ``download`` attribute in ``a`` tags for attachment's filename
* `#1206 <https://github.com/Kozea/WeasyPrint/issues/1206>`_:
  Handle strings in ``list-style-type``
* `#1165 <https://github.com/Kozea/WeasyPrint/pull/1165>`_:
  Add support for concatenating ``var()`` functions in ``content`` declarations
* `c56b96b <https://github.com/Kozea/WeasyPrint/commit/c56b96b>`_:
  Add an option to optimize embedded images size, with financial support from
  Hashbang
* `#969 <https://github.com/Kozea/WeasyPrint/issues/969>`_:
  Add an image cache that can be shared between documents, with financial
  support from Hashbang

Bug fixes:

* `#1141 <https://github.com/Kozea/WeasyPrint/pull/1141>`_:
  Don’t clip page margins on account of ``body`` overflow
* `#1000 <https://github.com/Kozea/WeasyPrint/issues/1000>`_:
  Don’t apply ``text-indent`` twice on inline blocks
* `#1051 <https://github.com/Kozea/WeasyPrint/issues/1051>`_:
  Avoid random line breaks
* `#1120 <https://github.com/Kozea/WeasyPrint/pull/1120>`_:
  Gather target counters in page margins
* `#1110 <https://github.com/Kozea/WeasyPrint/issues/1110>`_:
  Handle most cases for boxes avoiding floats in rtl containers, with financial
  support from Innovative Software
* `#1111 <https://github.com/Kozea/WeasyPrint/issues/1111>`_:
  Fix horizontal position of last rtl line, with financial support from
  Innovative Software
* `#1114 <https://github.com/Kozea/WeasyPrint/issues/1114>`_:
  Fix bug with transparent borders in tables
* `#1146 <https://github.com/Kozea/WeasyPrint/pull/1146>`_:
  Don’t gather bookmarks twice for blocks that are displayed on two pages
* `#1237 <https://github.com/Kozea/WeasyPrint/issues/1237>`_:
  Use fallback fonts on unsupported WOFF2 and WOFF fonts
* `#1025 <https://github.com/Kozea/WeasyPrint/issues/1025>`_:
  Don’t insert the same layout attributes multiple times
* `#1027 <https://github.com/Kozea/WeasyPrint/issues/1027>`_:
  Don’t try to break tables after the header or before the footer
* `#1050 <https://github.com/Kozea/WeasyPrint/issues/1050>`_:
  Don’t crash on absolute SVG files with no intrinsic size
* `#1204 <https://github.com/Kozea/WeasyPrint/issues/1204>`_:
  Fix a crash with a flexbox corner case
* `#1030 <https://github.com/Kozea/WeasyPrint/pull/1030>`_:
  Fix frozen builds
* `#1089 <https://github.com/Kozea/WeasyPrint/pull/1089>`_:
  Fix Pyinstaller builds
* `#1216 <https://github.com/Kozea/WeasyPrint/pull/1213>`_:
  Fix embedded files
* `#1225 <https://github.com/Kozea/WeasyPrint/pull/1225>`_:
  Initial support of RTL direction in flexbox layout

Documentation:

* `#1149 <https://github.com/Kozea/WeasyPrint/issues/1149>`_:
  Add the ``--quiet`` CLI option in the documentation
* `#1061 <https://github.com/Kozea/WeasyPrint/pull/1061>`_:
  Update install instructions on Windows

Tests:

* `#1209 <https://github.com/Kozea/WeasyPrint/pull/1209>`_:
  Use GitHub Actions instead of Travis

Contributors:

* Guillaume Ayoub
* Lucie Anglade
* Tontyna
* Mohammed Y. Alnajdi
* Mike Voets
* Bjarni Þórisson
* Balázs Dukai
* Bart Broere
* Endalkachew
* Felix Schwarz
* Julien Sanchez
* Konstantin Alekseev
* Nicolas Hart
* Nikolaus Schlemm
* Thomas J. Lampoltshammer
* mPyth
* nempoBu4
* saddy001

Backers and sponsors:

* Hashbang
* Innovative Software
* Screenbreak
* Simon Sapin
* Lisa Warshaw
* Nathalie Gutton
* Andreas Zettl
* Florian Demmer
* Moritz Mahringer


Version 51
----------

Released on 2019-12-23.

Dependencies:

* Pyphen 0.9.1+ is now needed

New features:

* `#882 <https://github.com/Kozea/WeasyPrint/pull/882>`_:
  Add support of ``element()`` and ``running()``
* `#972 <https://github.com/Kozea/WeasyPrint/pull/972>`_:
  Add HTML element to Box class
* `7a4d6f8 <https://github.com/Kozea/WeasyPrint/commit/7a4d6f8>`_:
  Support ``larger`` and ``smaller`` values for ``font-size``

Bug fixes:

* `#960 <https://github.com/Kozea/WeasyPrint/pull/960>`_:
  Fix how fonts used for macOS tests are installed
* `#956 <https://github.com/Kozea/WeasyPrint/pull/956>`_:
  Fix various crashes due to line breaking bugs
* `#983 <https://github.com/Kozea/WeasyPrint/issues/983>`_:
  Fix typo in variable name
* `#975 <https://github.com/Kozea/WeasyPrint/pull/975>`_:
  Don’t crash when ``string-set`` is set to ``none``
* `#998 <https://github.com/Kozea/WeasyPrint/pull/998>`_:
  Keep font attributes when text lines are modified
* `#1005 <https://github.com/Kozea/WeasyPrint/issues/1005>`_:
  Don’t let presentational hints add decorations on tables with no borders
* `#974 <https://github.com/Kozea/WeasyPrint/pull/974>`_:
  Don’t crash on improper ``var()`` values
* `#1012 <https://github.com/Kozea/WeasyPrint/pull/1012>`_:
  Fix rendering of header and footer for empty tables
* `#1013 <https://github.com/Kozea/WeasyPrint/issues/1013>`_:
  Avoid quadratic time relative to tree depth when setting page names

Contributors:

- Lucie Anglade
- Guillaume Ayoub
- Guillermo Bonvehí
- Holger Brunn
- Felix Schwarz
- Tontyna


Version 50
----------

Released on 2019-09-19.

New features:

* `#209 <https://github.com/Kozea/WeasyPrint/issues/209>`_:
  Make ``break-*`` properties work inside tables
* `#661 <https://github.com/Kozea/WeasyPrint/issues/661>`_:
  Make blocks with ``overflow: auto`` grow to include floating children

Bug fixes:

* `#945 <https://github.com/Kozea/WeasyPrint/issues/945>`_:
  Don't break pages between a list item and its marker
* `#727 <https://github.com/Kozea/WeasyPrint/issues/727>`_:
  Avoid tables lost between pages
* `#831 <https://github.com/Kozea/WeasyPrint/issues/831>`_:
  Ignore auto margins on flex containers
* `#923 <https://github.com/Kozea/WeasyPrint/issues/923>`_:
  Fix a couple of crashes when splitting a line twice
* `#896 <https://github.com/Kozea/WeasyPrint/issues/896>`_:
  Fix skip stack order when using a reverse flex direction

Contributors:

- Lucie Anglade
- Guillaume Ayoub


Version 49
----------

Released on 2019-09-11.

Performance:

* Speed and memory use have been largely improved.

New features:

* `#700 <https://github.com/Kozea/WeasyPrint/issues/700>`_:
  Handle ``::marker`` pseudo-selector
* `135dc06c <https://github.com/Kozea/WeasyPrint/commit/135dc06c>`_:
  Handle ``recto`` and ``verso`` parameters for page breaks
* `#907 <https://github.com/Kozea/WeasyPrint/pull/907>`_:
  Provide a clean way to build layout contexts

Bug fixes:

* `#937 <https://github.com/Kozea/WeasyPrint/issues/937>`_:
  Fix rendering of tables with empty lines and rowspans
* `#897 <https://github.com/Kozea/WeasyPrint/issues/897>`_:
  Don't crash when small columns are wrapped in absolute blocks
* `#913 <https://github.com/Kozea/WeasyPrint/issues/913>`_:
  Fix a test about gradient colors
* `#924 <https://github.com/Kozea/WeasyPrint/pull/924>`_:
  Fix title for document with attachments
* `#917 <https://github.com/Kozea/WeasyPrint/issues/917>`_:
  Fix tests with Pango 1.44
* `#919 <https://github.com/Kozea/WeasyPrint/issues/919>`_:
  Fix padding and margin management for column flex boxes
* `#901 <https://github.com/Kozea/WeasyPrint/issues/901>`_:
  Fix width of replaced boxes with no intrinsic width
* `#906 <https://github.com/Kozea/WeasyPrint/issues/906>`_:
  Don't respect table cell width when content doesn't fit
* `#927 <https://github.com/Kozea/WeasyPrint/pull/927>`_:
  Don't use deprecated ``logger.warn`` anymore
* `a8662794 <https://github.com/Kozea/WeasyPrint/commit/a8662794>`_:
  Fix margin collapsing between caption and table wrapper
* `87d9e84f <https://github.com/Kozea/WeasyPrint/commit/87d9e84f>`_:
  Avoid infinite loops when rendering columns
* `789b80e6 <https://github.com/Kozea/WeasyPrint/commit/789b80e6>`_:
  Only use in flow children to set columns height
* `615e298a <https://github.com/Kozea/WeasyPrint/commit/615e298a>`_:
  Don't include floating elements each time we try to render a column
* `48d8632e <https://github.com/Kozea/WeasyPrint/commit/48d8632e>`_:
  Avoid not in flow children to compute column height
* `e7c452ce <https://github.com/Kozea/WeasyPrint/commit/e7c452ce>`_:
  Fix collapsing margins for columns
* `fb0887cf <https://github.com/Kozea/WeasyPrint/commit/fb0887cf>`_:
  Fix crash when using currentColor in gradients
* `f66df067 <https://github.com/Kozea/WeasyPrint/commit/f66df067>`_:
  Don't crash when using ex units in word-spacing in letter-spacing
* `c790ff20 <https://github.com/Kozea/WeasyPrint/commit/c790ff20>`_:
  Don't crash when properties needing base URL use var functions
* `d63eac31 <https://github.com/Kozea/WeasyPrint/commit/d63eac31>`_:
  Don't crash with object-fit: non images with no intrinsic size

Documentation:

* `#900 <https://github.com/Kozea/WeasyPrint/issues/900>`_:
  Add documentation about semantic versioning
* `#692 <https://github.com/Kozea/WeasyPrint/issues/692>`_:
  Add a snippet about PDF magnification
* `#899 <https://github.com/Kozea/WeasyPrint/pull/899>`_:
  Add .NET wrapper link
* `#893 <https://github.com/Kozea/WeasyPrint/pull/893>`_:
  Fixed wrong nested list comprehension example
* `#902 <https://github.com/Kozea/WeasyPrint/pull/902>`_:
  Add ``state`` to the ``make_bookmark_tree`` documentation
* `#921 <https://github.com/Kozea/WeasyPrint/pull/921>`_:
  Fix typos in the documentation
* `#328 <https://github.com/Kozea/WeasyPrint/issues/328>`_:
  Add CSS sample for forms

Contributors:

- Lucie Anglade
- Guillaume Ayoub
- Raphael Gaschignard
- Stani
- Szmen
- Thomas Dexter
- Tontyna


Version 48
----------

Released on 2019-07-08.

Dependencies:

* CairoSVG 2.4.0+ is now needed

New features:

* `#891 <https://github.com/Kozea/WeasyPrint/pull/891>`_:
  Handle ``text-overflow``
* `#878 <https://github.com/Kozea/WeasyPrint/pull/878>`_:
  Handle ``column-span``
* `#855 <https://github.com/Kozea/WeasyPrint/pull/855>`_:
  Handle all the ``text-decoration`` features
* `#238 <https://github.com/Kozea/WeasyPrint/issues/238>`_:
  Don't repeat background images when it's not needed
* `#875 <https://github.com/Kozea/WeasyPrint/issues/875>`_:
  Handle ``object-fit`` and ``object-position``
* `#870 <https://github.com/Kozea/WeasyPrint/issues/870>`_:
  Handle ``bookmark-state``

Bug fixes:

* `#686 <https://github.com/Kozea/WeasyPrint/issues/686>`_:
  Fix column balance when children are not inline
* `#885 <https://github.com/Kozea/WeasyPrint/issues/885>`_:
  Actually use the content box to resolve flex items percentages
* `#867 <https://github.com/Kozea/WeasyPrint/issues/867>`_:
  Fix rendering of KaTeX output, including (1) set row baseline of tables when
  no cells are baseline-aligned, (2) set baseline for inline tables, (3) don't
  align lines larger than their parents, (4) force CairoSVG to respect image
  size defined by CSS.
* `#873 <https://github.com/Kozea/WeasyPrint/issues/873>`_:
  Set a minimum height for empty list elements with outside marker
* `#811 <https://github.com/Kozea/WeasyPrint/issues/811>`_:
  Don't use translations to align flex items
* `#851 <https://github.com/Kozea/WeasyPrint/issues/851>`_,
  `#860 <https://github.com/Kozea/WeasyPrint/issues/860>`_:
  Don't cut pages when content overflows a very little bit
* `#862 <https://github.com/Kozea/WeasyPrint/issues/862>`_:
  Don't crash when using UTC dates in metadata

Documentation:

* `#854 <https://github.com/Kozea/WeasyPrint/issues/854>`_:
  Add a "Tips & Tricks" section

Contributors:

- Gabriel Corona
- Guillaume Ayoub
- Manuel Barkhau
- Nathan de Maestri
- Lucie Anglade
- theopeek


Version 47
----------

Released on 2019-04-12.

New features:

* `#843 <https://github.com/Kozea/WeasyPrint/pull/843>`_:
  Handle CSS variables
* `#846 <https://github.com/Kozea/WeasyPrint/pull/846>`_:
  Handle ``:nth()`` page selector
* `#847 <https://github.com/Kozea/WeasyPrint/pull/847>`_:
  Allow users to use a custom SSL context for HTTP requests

Bug fixes:

* `#797 <https://github.com/Kozea/WeasyPrint/issues/797>`_:
  Fix underlined justified text
* `#836 <https://github.com/Kozea/WeasyPrint/issues/836>`_:
  Fix crash when flex items are replaced boxes
* `#835 <https://github.com/Kozea/WeasyPrint/issues/835>`_:
  Fix ``margin-break: auto``


Version 46
----------

Released on 2019-03-20.

New features:

* `#771 <https://github.com/Kozea/WeasyPrint/issues/771>`_:
  Handle ``box-decoration-break``
* `#115 <https://github.com/Kozea/WeasyPrint/issues/115>`_:
  Handle ``margin-break``
* `#821 <https://github.com/Kozea/WeasyPrint/issues/821>`_:
  Continuous integration includes tests on Windows

Bug fixes:

* `#765 <https://github.com/Kozea/WeasyPrint/issues/765>`_,
  `#754 <https://github.com/Kozea/WeasyPrint/issues/754>`_,
  `#800 <https://github.com/Kozea/WeasyPrint/issues/800>`_:
  Fix many crashes related to the flex layout
* `#783 <https://github.com/Kozea/WeasyPrint/issues/783>`_:
  Fix a couple of crashes with strange texts
* `#827 <https://github.com/Kozea/WeasyPrint/pull/827>`_:
  Named strings and counters are case-sensitive
* `#823 <https://github.com/Kozea/WeasyPrint/pull/823>`_:
  Shrink min/max-height/width according to box-sizing
* `#728 <https://github.com/Kozea/WeasyPrint/issues/728>`_,
  `#171 <https://github.com/Kozea/WeasyPrint/issues/171>`_:
  Don't crash when fixed boxes are nested
* `#610 <https://github.com/Kozea/WeasyPrint/issues/610>`_,
  `#828 <https://github.com/Kozea/WeasyPrint/issues/828>`_:
  Don't crash when preformatted text lines end with a space
* `#808 <https://github.com/Kozea/WeasyPrint/issues/808>`_,
  `#387 <https://github.com/Kozea/WeasyPrint/issues/387>`_:
  Fix position of some images
* `#813 <https://github.com/Kozea/WeasyPrint/issues/813>`_:
  Don't crash when long preformatted text lines end with ``\n``

Documentation:

* `#815 <https://github.com/Kozea/WeasyPrint/pull/815>`_:
  Add documentation about custom ``url_fetcher``


Version 45
----------

Released on 2019-02-20.

WeasyPrint now has a `code of conduct
<https://github.com/Kozea/WeasyPrint/blob/master/CODE_OF_CONDUCT.rst>`_.

A new website has been launched, with beautiful and useful graphs about speed
and memory use across versions: check `WeasyPerf
<https://kozea.github.io/WeasyPerf/index.html>`_.

Dependencies:

* Python 3.5+ is now needed, Python 3.4 is not supported anymore

Bug fixes:

* `#798 <https://github.com/Kozea/WeasyPrint/pull/798>`_:
  Prevent endless loop and index out of range in pagination
* `#767 <https://github.com/Kozea/WeasyPrint/issues/767>`_:
  Add a ``--quiet`` CLI parameter
* `#784 <https://github.com/Kozea/WeasyPrint/pull/784>`_:
  Fix library loading on Alpine
* `#791 <https://github.com/Kozea/WeasyPrint/pull/791>`_:
  Use path2url in tests for Windows
* `#789 <https://github.com/Kozea/WeasyPrint/pull/789>`_:
  Add LICENSE file to distributed sources
* `#788 <https://github.com/Kozea/WeasyPrint/pull/788>`_:
  Fix pending references
* `#780 <https://github.com/Kozea/WeasyPrint/issues/780>`_:
  Don't draw patterns for empty page backgrounds
* `#774 <https://github.com/Kozea/WeasyPrint/issues/774>`_:
  Don't crash when links include quotes
* `#637 <https://github.com/Kozea/WeasyPrint/issues/637>`_:
  Fix a problem with justified text
* `#763 <https://github.com/Kozea/WeasyPrint/pull/763>`_:
  Launch tests with Python 3.7
* `#704 <https://github.com/Kozea/WeasyPrint/issues/704>`_:
  Fix a corner case with tables
* `#804 <https://github.com/Kozea/WeasyPrint/pull/804>`_:
  Don't logger handlers defined before importing WeasyPrint
* `#109 <https://github.com/Kozea/WeasyPrint/issues/109>`_,
  `#748 <https://github.com/Kozea/WeasyPrint/issues/748>`_:
  Don't include punctuation for hyphenation
* `#770 <https://github.com/Kozea/WeasyPrint/issues/770>`_:
  Don't crash when people use uppercase words from old-fashioned Microsoft
  fonts in tables, especially when there's an 5th column
* Use a `separate logger
  <https://weasyprint.readthedocs.io/en/latest/tutorial.html#logging>`_ to
  report the rendering process
* Add a ``--debug`` CLI parameter and set debug level for unknown prefixed CSS
  properties
* Define minimal versions of Python and setuptools in setup.cfg

Documentation:

* `#796 <https://github.com/Kozea/WeasyPrint/pull/796>`_:
  Fix a small typo in the tutorial
* `#792 <https://github.com/Kozea/WeasyPrint/pull/792>`_:
  Document no alignment character support
* `#773 <https://github.com/Kozea/WeasyPrint/pull/773>`_:
  Fix phrasing in Hacking section
* `#402 <https://github.com/Kozea/WeasyPrint/issues/402>`_:
  Add a paragraph about fontconfig error
* `#764 <https://github.com/Kozea/WeasyPrint/pull/764>`_:
  Fix list of dependencies for Alpine
* Fix API documentation of HTML and CSS classes


Version 44
----------

Released on 2018-12-29.

Bug fixes:

* `#742 <https://github.com/Kozea/WeasyPrint/issues/742>`_:
  Don't crash during PDF generation when locale uses commas as decimal separator
* `#746 <https://github.com/Kozea/WeasyPrint/issues/746>`_:
  Close file when reading VERSION
* Improve speed and memory usage for long texts.

Documentation:

* `#733 <https://github.com/Kozea/WeasyPrint/pull/733>`_:
  Small documentation fixes
* `#735 <https://github.com/Kozea/WeasyPrint/pull/735>`_:
  Fix broken links in NEWS.rst


Version 43
----------

Released on 2018-11-09.

Bug fixes:

* `#726 <https://github.com/Kozea/WeasyPrint/issues/726>`_:
  Make empty strings clear previous values of named strings
* `#729 <https://github.com/Kozea/WeasyPrint/issues/729>`_:
  Include tools in packaging

This version also includes the changes from unstable rc1 and rc2 versions
listed below.


Version 43rc2
-------------

Released on 2018-11-02.

**This version is experimental, don't use it in production. If you find bugs,
please report them!**

Bug fixes:

* `#706 <https://github.com/Kozea/WeasyPrint/issues/706>`_:
  Fix text-indent at the beginning of a page
* `#687 <https://github.com/Kozea/WeasyPrint/issues/687>`_:
  Allow query strings in file:// URIs
* `#720 <https://github.com/Kozea/WeasyPrint/issues/720>`_:
  Optimize minimum size calculation of long inline elements
* `#717 <https://github.com/Kozea/WeasyPrint/issues/717>`_:
  Display <details> tags as blocks
* `#691 <https://github.com/Kozea/WeasyPrint/issues/691>`_:
  Don't recalculate max content widths when distributing extra space for tables
* `#722 <https://github.com/Kozea/WeasyPrint/issues/722>`_:
  Fix bookmarks and strings set on images
* `#723 <https://github.com/Kozea/WeasyPrint/issues/723>`_:
  Warn users when string() is not used in page margin


Version 43rc1
-------------

Released on 2018-10-15.

**This version is experimental, don't use it in production. If you find bugs,
please report them!**

Dependencies:

* Python 3.4+ is now needed, Python 2.x is not supported anymore
* Cairo 1.15.4+ is now needed, but 1.10+ should work with missing features
  (such as links, outlines and metadata)
* Pdfrw is not needed anymore

New features:

* `Beautiful website <https://weasyprint.org>`_
* `#579 <https://github.com/Kozea/WeasyPrint/issues/579>`_:
  Initial support of flexbox
* `#592 <https://github.com/Kozea/WeasyPrint/pull/592>`_:
  Support @font-face on Windows
* `#306 <https://github.com/Kozea/WeasyPrint/issues/306>`_:
  Add a timeout parameter to the URL fetcher functions
* `#594 <https://github.com/Kozea/WeasyPrint/pull/594>`_:
  Split tests using modern pytest features
* `#599 <https://github.com/Kozea/WeasyPrint/pull/599>`_:
  Make tests pass on Windows
* `#604 <https://github.com/Kozea/WeasyPrint/pull/604>`_:
  Handle target counters and target texts
* `#631 <https://github.com/Kozea/WeasyPrint/pull/631>`_:
  Enable counter-increment and counter-reset in page context
* `#622 <https://github.com/Kozea/WeasyPrint/issues/622>`_:
  Allow pathlib.Path objects for HTML, CSS and Attachment classes
* `#674 <https://github.com/Kozea/WeasyPrint/issues/674>`_:
  Add extensive installation instructions for Windows

Bug fixes:

* `#558 <https://github.com/Kozea/WeasyPrint/issues/558>`_:
  Fix attachments
* `#565 <https://github.com/Kozea/WeasyPrint/issues/565>`_,
  `#596 <https://github.com/Kozea/WeasyPrint/issues/596>`_,
  `#539 <https://github.com/Kozea/WeasyPrint/issues/539>`_:
  Fix many PDF rendering, printing and compatibility problems
* `#614 <https://github.com/Kozea/WeasyPrint/issues/614>`_:
  Avoid crashes and endless loops caused by a Pango bug
* `#662 <https://github.com/Kozea/WeasyPrint/pull/662>`_:
  Fix warnings and errors when generating documentation
* `#666 <https://github.com/Kozea/WeasyPrint/issues/666>`_,
  `#685 <https://github.com/Kozea/WeasyPrint/issues/685>`_:
  Fix many table layout rendering problems
* `#680 <https://github.com/Kozea/WeasyPrint/pull/680>`_:
  Don't crash when there's no font available
* `#662 <https://github.com/Kozea/WeasyPrint/pull/662>`_:
  Fix support of some align values in tables


Version 0.42.3
--------------

Released on 2018-03-27.

Bug fixes:

* `#583 <https://github.com/Kozea/WeasyPrint/issues/583>`_:
  Fix floating-point number error to fix floating box layout
* `#586 <https://github.com/Kozea/WeasyPrint/issues/586>`_:
  Don't optimize resume_at when splitting lines with trailing spaces
* `#582 <https://github.com/Kozea/WeasyPrint/issues/582>`_:
  Fix table layout with no overflow
* `#580 <https://github.com/Kozea/WeasyPrint/issues/580>`_:
  Fix inline box breaking function
* `#576 <https://github.com/Kozea/WeasyPrint/issues/576>`_:
  Split replaced_min_content_width and replaced_max_content_width
* `#574 <https://github.com/Kozea/WeasyPrint/issues/574>`_:
  Respect text direction and don't translate rtl columns twice
* `#569 <https://github.com/Kozea/WeasyPrint/issues/569>`_:
  Get only first line's width of inline children to get linebox width


Version 0.42.2
--------------

Released on 2018-02-04.

Bug fixes:

* `#560 <https://github.com/Kozea/WeasyPrint/issues/560>`_:
  Fix a couple of crashes and endless loops when breaking lines.


Version 0.42.1
--------------

Released on 2018-02-01.

Bug fixes:

* `#566 <https://github.com/Kozea/WeasyPrint/issues/566>`_:
  Don't crash when using @font-config.
* `#567 <https://github.com/Kozea/WeasyPrint/issues/567>`_:
  Fix text-indent with text-align: justify.
* `#465 <https://github.com/Kozea/WeasyPrint/issues/465>`_:
  Fix string(\*, start).
* `#562 <https://github.com/Kozea/WeasyPrint/issues/562>`_:
  Handle named pages with pseudo-class.
* `#507 <https://github.com/Kozea/WeasyPrint/issues/507>`_:
  Fix running headers.
* `#557 <https://github.com/Kozea/WeasyPrint/issues/557>`_:
  Avoid infinite loops in inline_line_width.
* `#555 <https://github.com/Kozea/WeasyPrint/issues/555>`_:
  Fix margins, borders and padding in column layouts.


Version 0.42
------------

Released on 2017-12-26.

WeasyPrint is not tested with (end-of-life) Python 3.3 anymore.

**This release is probably the last version of the 0.x series.**

Next version may include big changes:

- end of Python 2.7 support,
- initial support of bidirectional text,
- initial support of flexbox,
- improvements for speed and memory usage.

New features:

* `#532 <https://github.com/Kozea/WeasyPrint/issues/532>`_:
  Support relative file URIs when using CLI.

Bug fixes:

* `#553 <https://github.com/Kozea/WeasyPrint/issues/553>`_:
  Fix slow performance for pre-formatted boxes with a lot of children.
* `#409 <https://github.com/Kozea/WeasyPrint/issues/409>`_:
  Don't crash when rendering some tables.
* `#39 <https://github.com/Kozea/WeasyPrint/issues/39>`_:
  Fix rendering of floats in inlines.
* `#301 <https://github.com/Kozea/WeasyPrint/issues/301>`_:
  Split lines carefully.
* `#530 <https://github.com/Kozea/WeasyPrint/issues/530>`_:
  Fix root when frozen with Pyinstaller.
* `#534 <https://github.com/Kozea/WeasyPrint/issues/534>`_:
  Handle SVGs containing images embedded as data URIs.
* `#360 <https://github.com/Kozea/WeasyPrint/issues/360>`_:
  Fix border-radius rendering problem with some PDF readers.
* `#525 <https://github.com/Kozea/WeasyPrint/issues/525>`_:
  Fix pipenv support.
* `#227 <https://github.com/Kozea/WeasyPrint/issues/227>`_:
  Smartly handle replaced boxes with percentage width in auto-width parents.
* `#520 <https://github.com/Kozea/WeasyPrint/issues/520>`_:
  Don't ignore CSS @page rules that are imported by an @import rule.


Version 0.41
------------

Released on 2017-10-05.

WeasyPrint now depends on pdfrw >= 0.4.

New features:

* `#471 <https://github.com/Kozea/WeasyPrint/issues/471>`_:
  Support page marks and bleed.

Bug fixes:

* `#513 <https://github.com/Kozea/WeasyPrint/issues/513>`_:
  Don't crash on unsupported image-resolution values.
* `#506 <https://github.com/Kozea/WeasyPrint/issues/506>`_:
  Fix @font-face use with write_* methods.
* `#500 <https://github.com/Kozea/WeasyPrint/pull/500>`_:
  Improve readability of _select_source function.
* `#498 <https://github.com/Kozea/WeasyPrint/issues/498>`_:
  Use CSS prefixes as recommended by the CSSWG.
* `#441 <https://github.com/Kozea/WeasyPrint/issues/441>`_:
  Fix rendering problems and crashes when using @font-face.
* `bb3a4db <https://github.com/Kozea/WeasyPrint/commit/bb3a4db>`_:
  Try to break pages after a block before trying to break inside it.
* `1d1654c <https://github.com/Kozea/WeasyPrint/commit/1d1654c>`_:
  Fix and test corner cases about named pages.

Documentation:

* `#508 <https://github.com/Kozea/WeasyPrint/pull/508>`_:
  Add missing libpangocairo dependency for Debian and Ubuntu.
* `a7b17fb <https://github.com/Kozea/WeasyPrint/commit/a7b17fb>`_:
  Add documentation on logged rendering steps.


Version 0.40
------------

Released on 2017-08-17.

WeasyPrint now depends on cssselect2 instead of cssselect and lxml.

New features:

* `#57 <https://github.com/Kozea/WeasyPrint/issues/57>`_:
  Named pages.
* Unprefix properties, see
  `#498 <https://github.com/Kozea/WeasyPrint/issues/498>`_.
* Add a "verbose" option logging the document generation steps.

Bug fixes:

* `#483 <https://github.com/Kozea/WeasyPrint/issues/483>`_:
  Fix slow performance with long pre-formatted texts.
* `#70 <https://github.com/Kozea/WeasyPrint/issues/70>`_:
  Improve speed and memory usage for long documents.
* `#487 <https://github.com/Kozea/WeasyPrint/issues/487>`_:
  Don't crash on local() fonts with a space and no quotes.


Version 0.39
------------

Released on 2017-06-24.

Bug fixes:

* Fix the use of WeasyPrint's URL fetcher with CairoSVG.


Version 0.38
------------

Released on 2017-06-16.

Bug fixes:

* `#477 <https://github.com/Kozea/WeasyPrint/issues/477>`_:
  Don't crash on font-face's src attributes with local functions.


Version 0.37
------------

Released on 2017-06-15.

WeasyPrint now depends on tinycss2 instead of tinycss.

New features:

* `#437 <https://github.com/Kozea/WeasyPrint/issues/437>`_:
  Support local links in generated PDFs.

Bug fixes:

* `#412 <https://github.com/Kozea/WeasyPrint/issues/412>`_:
  Use a NullHandler log handler when WeasyPrint is used as a library.
* `#417 <https://github.com/Kozea/WeasyPrint/issues/417>`_,
  `#472 <https://github.com/Kozea/WeasyPrint/issues/472>`_:
  Don't crash on some line breaks.
* `#327 <https://github.com/Kozea/WeasyPrint/issues/327>`_:
  Don't crash with replaced elements with height set in percentages.
* `#467 <https://github.com/Kozea/WeasyPrint/issues/467>`_:
  Remove incorrect line breaks.
* `#446 <https://github.com/Kozea/WeasyPrint/pull/446>`_:
  Let the logging module do the string interpolation.


Version 0.36
------------

Released on 2017-02-25.

New features:

* `#407 <https://github.com/Kozea/WeasyPrint/pull/407>`_:
  Handle ::first-letter.
* `#423 <https://github.com/Kozea/WeasyPrint/pull/423>`_:
  Warn user about broken cairo versions.

Bug fixes:

* `#411 <https://github.com/Kozea/WeasyPrint/pull/411>`_:
  Typos fixed in command-line help.


Version 0.35
------------

Released on 2017-02-25.

Bug fixes:

* `#410 <https://github.com/Kozea/WeasyPrint/pull/410>`_:
  Fix AssertionError in split_text_box.


Version 0.34
------------

Released on 2016-12-21.

Bug fixes:

* `#398 <https://github.com/Kozea/WeasyPrint/issues/398>`_:
  Honor the presentational_hints option for PDFs.
* `#399 <https://github.com/Kozea/WeasyPrint/pull/399>`_:
  Avoid CairoSVG-2.0.0rc* on Python 2.
* `#396 <https://github.com/Kozea/WeasyPrint/issues/396>`_:
  Correctly close files open by mkstemp.
* `#403 <https://github.com/Kozea/WeasyPrint/issues/403>`_:
  Cast the number of columns into int.
* Fix multi-page multi-columns and add related tests.


Version 0.33
------------

Released on 2016-11-28.

New features:

* `#393 <https://github.com/Kozea/WeasyPrint/issues/393>`_:
  Add tests on MacOS.
* `#370 <https://github.com/Kozea/WeasyPrint/issues/370>`_:
  Enable @font-face on MacOS.

Bug fixes:

* `#389 <https://github.com/Kozea/WeasyPrint/issues/389>`_:
  Always update resume_at when splitting lines.
* `#394 <https://github.com/Kozea/WeasyPrint/issues/394>`_:
  Don't build universal wheels.
* `#388 <https://github.com/Kozea/WeasyPrint/issues/388>`_:
  Fix logic when finishing block formatting context.


Version 0.32
------------

Released on 2016-11-17.

New features:

* `#28 <https://github.com/Kozea/WeasyPrint/issues/28>`_:
  Support @font-face on Linux.
* Support CSS fonts level 3 almost entirely, including OpenType features.
* `#253 <https://github.com/Kozea/WeasyPrint/issues/253>`_:
  Support presentational hints (optional).
* Support break-after, break-before and break-inside for pages and columns.
* `#384 <https://github.com/Kozea/WeasyPrint/issues/384>`_:
  Major performance boost.

Bux fixes:

* `#368 <https://github.com/Kozea/WeasyPrint/issues/368>`_:
  Respect white-space for shrink-to-fit.
* `#382 <https://github.com/Kozea/WeasyPrint/issues/382>`_:
  Fix the preferred width for column groups.
* Handle relative boxes in column-layout boxes.

Documentation:

* Add more and more documentation about Windows installation.
* `#355 <https://github.com/Kozea/WeasyPrint/issues/355>`_:
  Add fonts requirements for tests.


Version 0.31
------------

Released on 2016-08-28.

New features:

* `#124 <https://github.com/Kozea/WeasyPrint/issues/124>`_:
  Add MIME sniffing for images.
* `#60 <https://github.com/Kozea/WeasyPrint/issues/60>`_:
  CSS Multi-column Layout.
* `#197 <https://github.com/Kozea/WeasyPrint/pull/197>`_:
  Add hyphens at line breaks activated by a soft hyphen.

Bux fixes:

* `#132 <https://github.com/Kozea/WeasyPrint/pull/132>`_:
  Fix Python 3 compatibility on Windows.

Documentation:

* `#329 <https://github.com/Kozea/WeasyPrint/issues/329>`_:
  Add documentation about installation on Windows.


Version 0.30
------------

Released on 2016-07-18.

WeasyPrint now depends on html5lib-0.999999999.

Bux fixes:

* Fix Acid2
* `#325 <https://github.com/Kozea/WeasyPrint/issues/325>`_:
  Cutting lines is broken in page margin boxes.
* `#334 <https://github.com/Kozea/WeasyPrint/issues/334>`_:
  Newest html5lib 0.999999999 breaks rendering.


Version 0.29
------------

Released on 2016-06-17.

Bug fixes:

* `#263 <https://github.com/Kozea/WeasyPrint/pull/263>`_:
  Don't crash with floats with percents in positions.
* `#323 <https://github.com/Kozea/WeasyPrint/pull/323>`_:
  Fix CairoSVG 2.0 pre-release dependency in Python 2.x.


Version 0.28
------------

Released on 2016-05-16.

Bug fixes:

* `#189 <https://github.com/Kozea/WeasyPrint/issues/189>`_:
  ``white-space: nowrap`` still wraps on hyphens
* `#305 <https://github.com/Kozea/WeasyPrint/issues/305>`_:
  Fix crashes on some tables
* Don't crash when transform matrix isn't invertible
* Don't crash when rendering ratio-only SVG images
* Fix margins and borders on some tables


Version 0.27
------------

Released on 2016-04-08.

New features:

* `#295 <https://github.com/Kozea/WeasyPrint/pull/295>`_:
  Support the 'rem' unit.
* `#299 <https://github.com/Kozea/WeasyPrint/pull/299>`_:
  Enhance the support of SVG images.

Bug fixes:

* `#307 <https://github.com/Kozea/WeasyPrint/issues/307>`_:
  Fix the layout of cells larger than their tables.

Documentation:

* The website is now on GitHub Pages, the documentation is on Read the Docs.
* `#297 <https://github.com/Kozea/WeasyPrint/issues/297>`_:
  Rewrite the CSS chapter of the documentation.


Version 0.26
------------

Released on 2016-01-29.

New features:

* Support the `empty-cells` attribute.
* Respect table, column and cell widths.

Bug fixes:

* `#172 <https://github.com/Kozea/WeasyPrint/issues/172>`_:
  Unable to set table column width on tables td's.
* `#151 <https://github.com/Kozea/WeasyPrint/issues/151>`_:
  Table background colour bleeds beyond table cell boundaries.
* `#260 <https://github.com/Kozea/WeasyPrint/issues/260>`_:
  TypeError: unsupported operand type(s) for +: 'float' and 'str'.
* `#288 <https://github.com/Kozea/WeasyPrint/issues/288>`_:
  Unwanted line-breaks in bold text.
* `#286 <https://github.com/Kozea/WeasyPrint/issues/286>`_:
  AttributeError: 'Namespace' object has no attribute 'attachments'.


Version 0.25
------------

Released on 2015-12-17.

New features:

* Support the 'q' unit.

Bug fixes:

* `#285 <https://github.com/Kozea/WeasyPrint/issues/285>`_:
  Fix a crash happening when splitting lines.
* `#284 <https://github.com/Kozea/WeasyPrint/issues/284>`_:
  Escape parenthesis in PDF links.
* `#280 <https://github.com/Kozea/WeasyPrint/pull/280>`_:
  Replace utf8 with utf-8 for gettext/django compatibility.
* `#269 <https://github.com/Kozea/WeasyPrint/pull/269>`_:
  Add support for use when frozen.
* `#250 <https://github.com/Kozea/WeasyPrint/issues/250>`_:
  Don't crash when attachments are not available.


Version 0.24
------------

Released on 2015-08-04.

New features:

* `#174 <https://github.com/Kozea/WeasyPrint/issues/174>`_:
  Basic support for Named strings.

Bug fixes:

* `#207 <https://github.com/Kozea/WeasyPrint/issues/207>`_:
  Draw rounded corners on replaced boxes.
* `#224 <https://github.com/Kozea/WeasyPrint/pull/224>`_:
  Rely on the font size for rounding bug workaround.
* `#31 <https://github.com/Kozea/WeasyPrint/issues/31>`_:
  Honor the vertical-align property in fixed-height cells.
* `#202 <https://github.com/Kozea/WeasyPrint/issues/202>`_:
  Remove unreachable area/border at bottom of page.
* `#225 <https://github.com/Kozea/WeasyPrint/issues/225>`_:
  Don't allow unknown units during line-height validation.
* Fix some wrong conflict resolutions for table borders with inset
  and outset styles.


Version 0.23
------------

Released on 2014-09-16.

Bug fixes:

* `#196 <https://github.com/Kozea/WeasyPrint/issues/196>`_:
  Use the default image sizing algorithm for images’s preferred size.
* `#194 <https://github.com/Kozea/WeasyPrint/pull/194>`_:
  Try more library aliases with ``dlopen()``.
* `#201 <https://github.com/Kozea/WeasyPrint/pull/201>`_:
  Consider ``page-break-after-avoid`` when pushing floats to the next page.
* `#217 <https://github.com/Kozea/WeasyPrint/issues/217>`_:
  Avoid a crash on zero-sized background images.

Release process:

* Start testing on Python 3.4 on Travis-CI.


Version 0.22
------------

Released on 2014-05-05.

New features:

* `#86 <https://github.com/Kozea/WeasyPrint/pull/86>`_:
  Support gzip and deflate encoding in HTTP responses
* `#177 <https://github.com/Kozea/WeasyPrint/pull/177>`_:
  Support for PDF attachments.

Bug fixes:

* `#169 <https://github.com/Kozea/WeasyPrint/issues/169>`_:
  Fix a crash on percentage-width columns in an auto-width table.
* `#168 <https://github.com/Kozea/WeasyPrint/issues/168>`_:
  Make ``<fieldset>`` a block in the user-agent stylesheet.
* `#175 <https://github.com/Kozea/WeasyPrint/issues/175>`_:
  Fix some ``dlopen()`` library loading issues on OS X.
* `#183 <https://github.com/Kozea/WeasyPrint/issues/183>`_:
  Break to the next page before a float that would overflow the page.
  (It might still overflow if it’s bigger than the page.)
* `#188 <https://github.com/Kozea/WeasyPrint/issues/188>`_:
  Require a recent enough version of Pyphen

Release process:

* Drop Python 3.1 support.
* Set up [Travis CI](https://travis-ci.org/)
  to automatically test all pushes and pull requests.
* Start testing on Python 3.4 locally. (Travis does not support 3.4 yet.)


Version 0.21
------------

Released on 2014-01-11.

New features:

* Add the `overflow-wrap <https://drafts.csswg.org/css-text/#overflow-wrap>`_
  property, allowing line breaks inside otherwise-unbreakable words.
  Thanks Frédérick Deslandes!
* Add the `image-resolution
  <https://drafts.csswg.org/css-images-3/#the-image-resolution>`_ property,
  allowing images to be sized proportionally to their intrinsic size
  at a resolution other than 96 image pixels per CSS ``in``
  (ie. one image pixel per CSS ``px``)

Bug fixes:

* `#145 <https://github.com/Kozea/WeasyPrint/issues/145>`_:
  Fix parsing HTML from an HTTP URL on Python 3.x
* `#40 <https://github.com/Kozea/WeasyPrint/issues/40>`_:
  Use more general hyphenation dictionaries for specific document languages.
  (E.g. use ``hyph_fr.dic`` for ``lang="fr_FR"``.)
* `#26 <https://github.com/Kozea/WeasyPrint/issues/26>`_:
  Fix ``min-width`` and ``max-width`` on floats.
* `#100 <https://github.com/Kozea/WeasyPrint/issues/100>`_:
  Fix a crash on trailing whitespace with ``font-size: 0``
* `#82 <https://github.com/Kozea/WeasyPrint/issues/82>`_:
  Borders on tables with ``border-collapse: collapse`` were sometimes
  drawn at an incorrect position.
* `#30 <https://github.com/Kozea/WeasyPrint/issues/30>`_:
  Fix positioning of images with ``position: absolute``.
* `#118 <https://github.com/Kozea/WeasyPrint/issues/118>`_:
  Fix a crash when using ``position: absolute``
  inside a ``position: relative`` element.
* Fix ``visibility: collapse`` to behave like ``visibility: hidden``
  on elements other than table rows and table columns.
* `#147 <https://github.com/Kozea/WeasyPrint/issues/147>`_ and
  `#153 <https://github.com/Kozea/WeasyPrint/issues/153>`_:
  Fix dependencies to require lxml 3.0 or a more recent version.
  Thanks gizmonerd and Thomas Grainger!
* `#152 <https://github.com/Kozea/WeasyPrint/issues/152>`_:
  Fix a crash on percentage-sized table cells in auto-sized tables.
  Thanks Johannes Duschl!


Version 0.20.2
--------------

Released on 2013-12-18.

* Fix `#146 <https://github.com/Kozea/WeasyPrint/issues/146>`_: don't crash
  when drawing really small boxes with dotted/dashed borders


Version 0.20.1
--------------

Released on 2013-12-16.

* Depend on html5lib >= 0.99 instead of 1.0b3 to fix pip 1.4 support.
* Fix `#74 <https://github.com/Kozea/WeasyPrint/issues/74>`_: don't crash on
  space followed by dot at line break.
* Fix `#78 <https://github.com/Kozea/WeasyPrint/issues/78>`_: nicer colors for
  border-style: ridge/groove/inset/outset.


Version 0.20
------------

Released on 2013-12-14.

* Add support for ``border-radius``.
* Feature `#77 <https://github.com/Kozea/WeasyPrint/issues/77>`_: Add PDF
  metadata from HTML.
* Feature `#12 <https://github.com/Kozea/WeasyPrint/pull/12>`_: Use html5lib.
* Tables: handle percentages for column groups, columns and cells, and values
  for row height.
* Bug fixes:

  * Fix `#84 <https://github.com/Kozea/WeasyPrint/pull/84>`_: don't crash when
    stylesheets are not available.
  * Fix `#101 <https://github.com/Kozea/WeasyPrint/issues/101>`_: use page ids
    instead of page numbers in PDF bookmarks.
  * Use ``logger.warning`` instead of deprecated ``logger.warn``.
  * Add 'font-stretch' in the 'font' shorthand.


Version 0.19.2
--------------

Released on 2013-06-18.

Bug fix release:

* Fix `#88 <https://github.com/Kozea/WeasyPrint/issues/88>`_:
  ``text-decoration: overline`` not being drawn above the text
* Bug fix: Actually draw multiple lines when multiple values are given
  to ``text-decoration``.
* Use the font metrics for text decoration positioning.
* Bug fix: Don't clip the border with ``overflow: hidden``.
* Fix `#99 <https://github.com/Kozea/WeasyPrint/issues/99>`_:
  Regression: JPEG images not loading with cairo 1.8.x.


Version 0.19.1
--------------

Released on 2013-04-30.

Bug fix release:

* Fix incorrect intrinsic width calculation
  leading to unnecessary line breaks in floats, tables, etc.
* Tweak border painting to look better
* Fix unnecessary page break before big tables.
* Fix table row overflowing at the bottom of the page
  when there are margins above the table.
* Fix ``position: fixed`` to actually repeat on every page.
* Fix `#76 <https://github.com/Kozea/WeasyPrint/issues/76>`_:
  repeat ``<thead>`` and ``<tfoot>`` elements on every page,
  even with table border collapsing.


Version 0.19
------------

Released on 2013-04-18.

* Add support for ``linear-gradient()`` and ``radial-gradient``
  in background images.
* Add support for the ``ex`` and ``ch`` length units.
  (``1ex`` is based on the font instead of being always ``0.5em`` as before.)
* Add experimental support for Level 4 hyphenation properties.
* Drop support for CFFI < 0.6 and cairocffi < 0.4.
* Many bug fixes, including:

 * Fix `#54 <https://github.com/Kozea/WeasyPrint/issues/54>`_:
   min/max-width/height on block-level images.
 * Fix `#71 <https://github.com/Kozea/WeasyPrint/issues/71>`_:
   Crash when parsing nested functional notation.


Version 0.18
------------

Released on 2013-03-30.

* Add support for Level 3 backgrounds,
  including multiple background layers per element/box.
* Forward-compatibility with (future releases of) cairocffi 0.4+ and CFFI 0.6+.
* Bug fixes:

  * Avoid some unnecessary line breaks
    for elements sized based on their content (aka. “shrink-to-fit”)
    such as floats and page headers.
  * Allow page breaks between empty blocks.
  * Fix `#66 <https://github.com/Kozea/WeasyPrint/issues/66>`_:
    Resolve images’ auto width from non-auto height and intrinsic ratio.
  * Fix `#21 <https://github.com/Kozea/WeasyPrint/issues/21>`_:
    The ``data:`` URL scheme is case-insensitive.
  * Fix `#53 <https://github.com/Kozea/WeasyPrint/issues/53>`_:
    Crash when backtracking for ``break-before/after: avoid``.


Version 0.17.1
--------------

Released on 2013-03-18.

Bug fixes:

* Fix `#41 <https://github.com/Kozea/WeasyPrint/issues/41>`_:
  GObject initialization when GDK-PixBuf is not installed.
* Fix `#42 <https://github.com/Kozea/WeasyPrint/issues/42>`_:
  absolute URLs without a base URL (ie. document parsed from a string.)
* Fix some whitespace collapsing bugs.
* Fix absolutely-positioned elements inside inline elements.
* Fix URL escaping of image references from CSS.
* Fix `#49 <https://github.com/Kozea/WeasyPrint/issues/49>`_:
  Division by 0 on dashed or dotted border smaller than one dot/dash.
* Fix `#44 <https://github.com/Kozea/WeasyPrint/issues/44>`_:
  bad interaction of ``page-break-before/after: avoid`` and floats.


Version 0.17
------------

Released on 2013-02-27.

* Added `text hyphenation`_ with the ``-weasy-hyphens`` property.
* When a document includes JPEG images, embed them as JPEG in the PDF output.
  This often results in smaller PDF file size
  compared to the default *deflate* compression.
* Switched to using CFFI instead of PyGTK or PyGObject-introspection.
* Layout bug fixes:

  - Correctly trim whitespace at the end of lines.
  - Fix some cases with floats within inline content.

.. _text hyphenation: https://weasyprint.readthedocs.io/en/latest/features.html#css-text-module-level-3-4


Version 0.16
------------

Released on 2012-12-13.

* Add the ``zoom`` parameter to ``HTML.write_pdf`` and
  ``Document.write_pdf() <weasyprint.document.Document.write_pdf>``
* Fix compatibility with old (and buggy) pycairo versions.
  WeasyPrint is now tested on 1.8.8 in addition to the latest.
* Fix layout bugs related to line trailing spaces.


Version 0.15
------------

Released on 2012-10-09.

* Add a low-level API that enables painting pages individually on any
  cairo surface.
* **Backward-incompatible change**: remove the ``HTML.get_png_pages``
  method. The new low-level API covers this functionality and more.
* Add support for the ``font-stretch`` property.
* Add support for ``@page:blank`` to select blank pages.
* New Sphinx-based and improved docs
* Bug fixes:

  - Importing Pango in some PyGTK installations.
  - Layout of inline-blocks with `vertical-align: top` or `bottom`.
  - Do not repeat a block’s margin-top or padding-top after a page break.
  - Performance problem with large tables split across many pages.
  - Anchors and hyperlinks areas now follow CSS transforms.
    Since PDF links have to be axis-aligned rectangles, the bounding box
    is used. This may be larger than expected with rotations that are
    not a multiple of 90 degrees.


Version 0.14
------------

Released on 2012-08-03.

* Add a public API to choose media type used for @media.
  (It still defaults to ``print``). Thanks Chung Lu!
* Add ``--base-url`` and ``--resolution`` to the command-line API, making it
  as complete as the Python one.
* Add support for the ``<base href="...">`` element in HTML.
* Add support for CSS outlines
* Switch to gdk-pixbuf instead of Pystacia for loading raster images.
* Bug fixes:

  - Handling of filenames and URLs on Windows
  - Unicode filenames with older version of py2cairo
  - ``base_url`` now behaves as expected when set to a directory name.
  - Make some tests more robust


Version 0.13
------------

Released on 2012-07-23.

* Add support for PyGTK, as an alternative to PyGObject + introspection.
  This should make WeasyPrint easier to run on platforms that not not have
  packages for PyGObject 3.x yet.
* Bug fix: crash in PDF outlines for some malformed HTML documents


Version 0.12
------------

Released on 2012-07-19.

* Add support for collapsed borders on tables. This is currently incompatible
  with repeating header and footer row groups on each page: headers and footers
  are treated as normal row groups on table with ``border-collapse: collapse``.
* Add ``url_fetcher`` to the public API. This enables users to hook into
  WeasyPrint for fetching linked stylesheets or images, eg. to generate them
  on the fly without going through the network.
  This enables the creation of `Flask-WeasyPrint
  <https://packages.python.org/Flask-WeasyPrint/>`_.


Version 0.11
------------

Released on 2012-07-04.

* Add support for floats and clear.
  Together with various bug fixes, this enables WeasyPrint to pass the Acid2
  test! Acid2 is now part of our automated test suite.
* Add support for the width, min-width, max-width, height, min-height and
  max-height properties in @page. The size property is now the size of the
  page’s containing block.
* Switch the Variable Dimension rules to `the new proposal
  <https://github.com/SimonSapin/css/blob/master/margin-boxes-variable-dimension>`_.
  The previous implementation was broken in many cases.
* The ``image-rendering``, ``transform``, ``transform-origin`` and ``size``
  properties are now unprefixed. The prefixed form (eg. -weasy-size) is ignored
  but gives a specific warning.


Version 0.10
------------

Released on 2012-06-25.

* Add ``get_png_pages()`` to the public API. It returns each page as
  a separate PNG image.
* Add a ``resolution`` parameter for PNG.
* Add *WeasyPrint Navigator*, a web application that shows WeasyPrint’s
  output with clickable links. Yes, that’s a browser in your browser.
  Start it with ``python -m weasyprint.navigator``
* Add support for `vertical-align: top` and `vertical-align: bottom`
* Add support for `page-break-before: avoid` and `page-break-after: avoid`
* Bug fixes


Version 0.9
-----------

Released on 2012-06-04.

* Relative, absolute and fixed positioning
* Proper painting order (z-index)
* In PDF: support for internal and external hyperlinks as well as bookmarks.
* Added the ``tree`` parameter to the ``HTML`` class: accepts a parsed lxml
  object.
* Bug fixes, including many crashes.

Bookmarks can be controlled by the ``-weasy-bookmark-level`` and
``-weasy-bookmark-label`` properties, as described in `CSS Generated Content
for Paged Media Module <https://drafts.csswg.org/css-gcpm-3/#bookmarks>`_.

The default UA stylesheet sets a matching bookmark level on all ``<h1>``
to ``<h6>`` elements.


Version 0.8
-----------

Released on 2012-05-07.

* Switch from cssutils to tinycss_ as the CSS parser.
* Switch to the new cssselect_, almost all level 3 selectors are supported now.
* Support for inline blocks and inline tables
* Automatic table layout (column widths)
* Support for the ``min-width``, ``max-width``, ``min-height`` and
  ``max-height`` properties, except on table-related and page-related boxes.
* Speed improvements on big stylesheets / small documents thanks to tinycss.
* Many bug fixes

.. _tinycss: https://packages.python.org/tinycss/
.. _cssselect: https://packages.python.org/cssselect/


Version 0.7.1
-------------

Released on 2012-03-21.

Change the license from AGPL to BSD.


Version 0.7
-----------

Released on 2012-03-21.

* Support page breaks between table rows
* Support for the ``orphans`` and ``widows`` properties.
* Support for ``page-break-inside: avoid``
* Bug fixes

Only avoiding page breaks before/after an element is still missing.


Version 0.6.1
-------------

Released on 2012-03-01.

Fix a packaging bug. (Remove use_2to3 in setup.py. We use the same
codebase for Python 2 and 3.)


Version 0.6
-----------

Released on 2012-02-29.

* *Backward incompatible*: completely change the Python API. See the
  documentation:
  https://weasyprint.readthedocs.io/en/latest/tutorial.html#as-a-python-library
* *Backward incompatible*: Proper margin collapsing.
  This changes how blocks are rendered: adjoining margins "collapse"
  (their maximum is used) instead of accumulating.
* Support images in ``embed`` or ``object`` elements.
* Switch to pystacia instead of PIL for raster images
* Add compatibility with CPython 2.6 and 3.2. (Previously only 2.7
  was supported)
* Many bug fixes


Version 0.5
-----------

Released on 2012-02-08.

* Support for the ``overflow`` and ``clip`` properties.
* Support for the ``opacity`` property from CSS3 Colors.
* Support for CSS 2D Transforms. These are prefixed, so you need to use
  ``-weasy-transform`` and ``-weasy-transform-origin``.


Version 0.4
-----------

Released on 2012-02-07.

* Support ``text-align: justify``, ``word-spacing`` and ``letter-spacing``.
* Partial support for CSS3 Paged Media: page size and margin boxes with
  page-based counters.
* All CSS 2.1 border styles
* Fix SVG images with non-pixel units. Requires CairoSVG 0.3
* Support for ``page-break-before`` and ``page-break-after``, except for
  the value ``avoid``.
* Support for the ``background-clip``, ``background-origin`` and
  ``background-size`` from CSS3 (but still with a single background
  per element)
* Support for the ``image-rendering`` from SVG. This one is prefixed,
  use ``-weasy-image-rendering``. It only has an effect on PNG output.


Version 0.3.1
-------------

Released on 2011-12-14.

Compatibility with CairoSVG 0.1.2


Version 0.3
-----------

Released on 2011-12-13.

* **Backward-incompatible change:** the 'size' property is now prefixed (since
  it is in an experimental specification). Use '-weasy-size' instead.
* cssutils 0.9.8 or higher is now required.
* Support SVG images with CairoSVG
* Support generated content: the ``:before`` and ``:after`` pseudo-elements,
  the ``content``, ``quotes`` and ``counter-*`` properties.
* Support ordered lists: all CSS 2.1 values of the ``list-style-type`` property.
* New user-agent stylesheet with HTML 5 elements and automatic quotes for many
  languages. Thanks Peter Moulder!
* Disable cssutils validation warnings, they are redundant with WeasyPrint’s.
* Add ``--version`` to the command-line script.
* Various bug fixes


Version 0.2
-----------

Released on 2011-11-25.

* Support for tables.
* Support the `box-sizing` property from CSS 3 Basic User Interface
* Support all values of vertical-align except top and bottom. They are
  interpreted as text-top and text-bottom.
* Minor bug fixes

Tables have some limitations:
Only the fixed layout and separate border model are supported.
There are also no page break inside tables so a table higher
than a page will overflow.


Version 0.1
-----------

Released on 2011-10-28.

First packaged release. Supports "simple" CSS 2.1 pages: there is no
support for floats, tables, or absolute positioning. Other than that
most of CSS 2.1 is supported, as well as CSS 3 Colors and Selectors.


================================================
FILE: docs/common_use_cases.rst
================================================
Common Use Cases
================


Include in Web Applications
---------------------------

Using WeasyPrint in web applications sometimes requires attention on some
details.

Security Problems
.................

First of all, rendering untrusted HTML and CSS files can lead to :ref:`security
problems <Security>`. Please be sure to carefully follow the different proposed
solutions if you allow your users to modify the source of the rendered
documents in any way.

Rights Management
.................

Another problem is rights management: you often need to render templates that
can only be accessed by authenticated users, and WeasyPrint installed on the
server doesn’t send the same cookies as the ones sent by the users. Extensions
such as Flask-WeasyPrint_ (for Flask_) or Django-WeasyPrint_ (for Django_)
solve this issue with a small amount of code. If you use another framework, you
can read these extensions and probably find an equivalent workaround.

.. _Flask-Weasyprint: https://github.com/Kozea/Flask-WeasyPrint
.. _Flask: https://flask.palletsprojects.com/
.. _Django-WeasyPrint: https://github.com/fdemmer/django-weasyprint
.. _Django: https://www.djangoproject.com/

Server Side Requests & Self-Signed SSL Certificates
...................................................

If your server is requesting data from itself, you may encounter a self-signed
certificate error, even if you have a valid certificate.

You need to add yourself as a Certificate Authority, so that your self-signed
SSL certificates can be requested.

.. code-block:: bash

   # If you have not yet created a certificate.
   sudo openssl req -x509 \
       -sha256 \
       -nodes \
       -newkey rsa:4096 \
       -days 365 \
       -keyout localhost.key \
       -out localhost.crt

   # Follow the prompts about your certificate and the domain name.
   openssl x509 -text -noout -in localhost.crt

Add your new self-signed SSL certificate to your nginx.conf, below the line
``server_name 123.123.123.123;``:

.. code-block:: bash

   ssl_certificate /etc/ssl/certs/localhost.crt;
   ssl_certificate_key /etc/ssl/private/localhost.key;

The SSL certificate will be valid when accessing your website from the
internet. However, images will not render when requesting files from the same
server.

You will need to add your new self-signed certificates as trusted:

.. code-block:: bash

   sudo cp /etc/ssl/certs/localhost.crt /usr/local/share/ca-certificates/localhost.crt
   sudo cp /etc/ssl/private/localhost.key /usr/local/share/ca-certificates/localhost.key

   # Update the certificate authority trusted certificates.
   sudo update-ca-certificates

   # Export your newly updated Certificate Authority Bundle file.
   # If using Django, it will use the newly signed certificate authority as
   # valid and images will load properly.
   sudo tee -a /etc/environment <<< 'export REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt'


Adjust Document Dimensions
--------------------------

WeasyPrint does not provide support for adjusting page size or document margins
via command-line flags. This is best accomplished with the CSS ``@page``
at-rule. Consider the following example:

.. code-block:: css

  @page {
    size: Letter; /* Change from the default size of A4 */
    margin: 3cm; /* Set margin on each page */
  }

There is much more which can be achieved with the ``@page`` at-rule,
such as page numbers, headers, etc. Read more about the page_ at-rule.

.. _page: https://developer.mozilla.org/en-US/docs/Web/CSS/@page


Generate Specialized PDFs
-------------------------

WeasyPrint can generate different PDF variants, including PDF/UA and PDF/A. The
feature is available by using the ``--pdf-variant`` CLI option, or the
``pdf_variant`` Python parameter of :func:`HTML.write_pdf
<weasyprint.HTML.write_pdf>`.

.. code-block:: python

  from weasyprint import HTML
  HTML(string="<p>document</p>").write_pdf("document.pdf", pdf_variant="pdf/a-3u")

.. code-block:: sh

  $ weasyprint document.html --pdf-variant="pdf/ua-1" document.pdf

The different supported variants can be listed using ``weasyprint --help``.

Even if WeasyPrint tries to generate valid documents, the result is not
guaranteed: the HTML, CSS and PDF features chosen by the user must follow the
limitations defined by the different specifications.

PDF/A (Archiving)
.................

PDF/A documents are specialized for archiving purposes. They are a simple
subset of PDF, with a lot of limitations: no audio, video or JavaScript,
defined color spaces, embedded fonts, etc.

If possible, PDF/A-3u should be preferred: it allows transparency layers that
are forbidden in A-1, and arbitrary formats for attached files that are
forbidden in A-2. The "u" part of the variant indicates that the PDF text is
available as Unicode.

PDF/A documents include a PDF identifier, that is mainly useful to indicate
that a PDF is a new version of another PDF. By default, WeasyPrint generates a
valid PDF identifier, but you can provide your own with the
``--pdf-identifier`` CLI option or ``pdf_identifier`` Python parameter.

If your document includes images, you must set the ``image-rendering:
crisp-edges`` property to avoid anti-aliasing, that is forbidden by PDF/A.

PDF/UA (Universal Accessibility)
................................

PDF/UA documents are specialized for accessibility purposes. They include extra
metadata that define document information and content structure.

The main constraint to get valid PDF/UA documents is to use a correct HTML
structure, to avoid inconsistencies in the PDF structure. The HTML order is
also used to define the order of the PDF content.

Some information is required in your HTML file, including a ``<title>`` tag,
and a ``lang`` attribute set on the ``<html>`` tag.

PDF/X (Graphics Exchange)
.........................

PDF/X documents facilitate graphics exchange and adds printing-related requirements such
as color profiles.

The easiest way to fulfill these requirements is to use device-dependent CMYK colors and
images everywhere in your document. For colors, you can use the ``device-cmyk()``
function:

.. code-block:: css

   body { color: device-cmyk(0% 10% 0% 80%) }

You also have to define the output profile color to use.

.. code-block:: css

   @color-profile device-cmyk {
     components: cyan, magenta, yellow, black;
     src: url(path/to/cmyk-profile.icc);
   }

If possible, PDF/X-4 should be preferred: it allows transparency layers that are
forbidden by previous variants.

Factur-X / ZUGFeRD (Electronic Invoices)
........................................

Factur-X / ZUGFeRD is a Franco-German standard for hybrid e-invoice, the first
implementation of the European Semantic Standard EN 16931. It enables users to
include normalized metadata in PDF invoices, such as companies information or
invoice amounts, so that compatible software can automatically read this
information. This standard is based on PDF/A-3b.

WeasyPrint can generate Factur-X / ZUGFeRD documents. Invoice metadata must be
generated by the user and included in the PDF document when rendered. Two
different metadata files are required:

- the first one is RDF metadata, containing document metadata and PDF/A
  extension information;
- the second one is Factur-X / ZUGFeRD metadata, containing invoice amounts,
  plus seller and buyer information.

Here is an example of Factur-X document generation.

``rdf.xml``:

.. code-block:: xml

  <rdf:RDF
      xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
      xmlns:fx="urn:factur-x:pdfa:CrossIndustryDocument:invoice:1p0#"
      xmlns:pdfaExtension="http://www.aiim.org/pdfa/ns/extension/"
      xmlns:pdfaSchema="http://www.aiim.org/pdfa/ns/schema#"
      xmlns:pdfaProperty="http://www.aiim.org/pdfa/ns/property#">
    <rdf:Description rdf:about="">
      <fx:ConformanceLevel>MINIMUM</fx:ConformanceLevel>
      <fx:DocumentFileName>factur-x.xml</fx:DocumentFileName>
      <fx:DocumentType>INVOICE</fx:DocumentType>
      <fx:Version>1.0</fx:Version>
    </rdf:Description>
    <rdf:Description rdf:about="">
      <pdfaExtension:schemas>
        <rdf:Bag>
          <rdf:li rdf:parseType="Resource">
            <pdfaSchema:schema>Factur-X PDFA Extension Schema</pdfaSchema:schema>
            <pdfaSchema:namespaceURI>urn:factur-x:pdfa:CrossIndustryDocument:invoice:1p0#</pdfaSchema:namespaceURI>
            <pdfaSchema:prefix>fx</pdfaSchema:prefix>
            <pdfaSchema:property>
              <rdf:Seq>
                <rdf:li rdf:parseType="Resource">
                  <pdfaProperty:name>DocumentFileName</pdfaProperty:name>
                  <pdfaProperty:valueType>Text</pdfaProperty:valueType>
                  <pdfaProperty:category>external</pdfaProperty:category>
                  <pdfaProperty:description>name of the embedded XML invoice file</pdfaProperty:description>
                </rdf:li>
                <rdf:li rdf:parseType="Resource">
                  <pdfaProperty:name>DocumentType</pdfaProperty:name>
                  <pdfaProperty:valueType>Text</pdfaProperty:valueType>
                  <pdfaProperty:category>external</pdfaProperty:category>
                  <pdfaProperty:description>INVOICE</pdfaProperty:description>
                </rdf:li>
                <rdf:li rdf:parseType="Resource">
                  <pdfaProperty:name>Version</pdfaProperty:name>
                  <pdfaProperty:valueType>Text</pdfaProperty:valueType>
                  <pdfaProperty:category>external</pdfaProperty:category>
                  <pdfaProperty:description>The actual version of the Factur-X XML schema</pdfaProperty:description>
                </rdf:li>
                <rdf:li rdf:parseType="Resource">
                  <pdfaProperty:name>ConformanceLevel</pdfaProperty:name>
                  <pdfaProperty:valueType>Text</pdfaProperty:valueType>
                  <pdfaProperty:category>external</pdfaProperty:category>
                  <pdfaProperty:description>The conformance level of the embedded Factur-X data</pdfaProperty:description>
                </rdf:li>
              </rdf:Seq>
            </pdfaSchema:property>
          </rdf:li>
        </rdf:Bag>
      </pdfaExtension:schemas>
    </rdf:Description>
  </rdf:RDF>

``factur-x.xml``:

.. code-block:: xml

  <rsm:CrossIndustryInvoice
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:qdt="urn:un:unece:uncefact:data:standard:QualifiedDataType:100"
      xmlns:udt="urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100"
      xmlns:rsm="urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100"
      xmlns:ram="urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100">
    <rsm:ExchangedDocumentContext>
      <ram:BusinessProcessSpecifiedDocumentContextParameter>
        <ram:ID>A1</ram:ID>
      </ram:BusinessProcessSpecifiedDocumentContextParameter>
      <ram:GuidelineSpecifiedDocumentContextParameter>
        <ram:ID>urn:factur-x.eu:1p0:minimum</ram:ID>
      </ram:GuidelineSpecifiedDocumentContextParameter>
    </rsm:ExchangedDocumentContext>
    <rsm:ExchangedDocument>
      <ram:ID>123</ram:ID>
      <ram:TypeCode>380</ram:TypeCode>
      <ram:IssueDateTime>
        <udt:DateTimeString format="102">20200131</udt:DateTimeString>
      </ram:IssueDateTime>
    </rsm:ExchangedDocument>
    <rsm:SupplyChainTradeTransaction>
      <ram:ApplicableHeaderTradeAgreement>
        <ram:BuyerReference>Buyer</ram:BuyerReference>
        <ram:SellerTradeParty>
          <ram:Name>Supplyer Corp</ram:Name>
          <ram:SpecifiedLegalOrganization>
            <ram:ID schemeID="0002">123456782</ram:ID>
          </ram:SpecifiedLegalOrganization>
          <ram:PostalTradeAddress>
            <ram:CountryID>FR</ram:CountryID>
          </ram:PostalTradeAddress>
          <ram:SpecifiedTaxRegistration>
            <ram:ID schemeID="VA">FR11123456782</ram:ID>
          </ram:SpecifiedTaxRegistration>
        </ram:SellerTradeParty>
        <ram:BuyerTradeParty>
          <ram:Name>Buyer Corp</ram:Name>
          <ram:SpecifiedLegalOrganization>
            <ram:ID schemeID="0002">987654324</ram:ID>
          </ram:SpecifiedLegalOrganization>
        </ram:BuyerTradeParty>
        <ram:BuyerOrderReferencedDocument >
          <ram:IssuerAssignedID>456</ram:IssuerAssignedID>
        </ram:BuyerOrderReferencedDocument>
      </ram:ApplicableHeaderTradeAgreement>
      <ram:ApplicableHeaderTradeDelivery/>
      <ram:ApplicableHeaderTradeSettlement>
        <ram:InvoiceCurrencyCode>EUR</ram:InvoiceCurrencyCode>
        <ram:SpecifiedTradeSettlementHeaderMonetarySummation>
          <ram:TaxBasisTotalAmount>100.00</ram:TaxBasisTotalAmount>
          <ram:TaxTotalAmount currencyID="EUR">20.00</ram:TaxTotalAmount>
          <ram:GrandTotalAmount>120.00</ram:GrandTotalAmount>
          <ram:DuePayableAmount>120.00</ram:DuePayableAmount>
        </ram:SpecifiedTradeSettlementHeaderMonetarySummation>
      </ram:ApplicableHeaderTradeSettlement>
    </rsm:SupplyChainTradeTransaction>
  </rsm:CrossIndustryInvoice>

``invoice.html``:

.. code-block:: html

  <h1>Invoice</h1>

Command-line::

  weasyprint invoice.html invoice.pdf --attachment=factur-x.xml --attachment-relationship=Data --xmp-metadata=rdf.xml --pdf-variant=pdf/a-3a

Or Python API:

.. code-block:: python

  from weasyprint import Attachment, HTML

  document = HTML("invoice.html").render()

  factur_x_xml = Path("factur-x.xml").read_text()
  attachment = Attachment(string=factur_x_xml, name="factur-x.xml", relationship="Data")
  document.metadata.attachments = [attachment]

  xmp_metadata = Path("rdf.xml").read_text().encode()
  document.metadata.xmp_metadata = [xmp_metadata]

  document.write_pdf("invoice.pdf", pdf_variant="pdf/a-3b")

Of course, the content of these files has to be adapted to the content of real
invoices.


Include PDF Forms
-----------------

By default, form fields are transformed into pure text and graphical shapes
when exported to PDF. But WeasyPrint gives the possibility to generate real PDF
forms that can be filled with a PDF reader. These forms can even send requests
with the data filled in the PDF, just as the same form would do in a web
browser.

To transform all HTML forms into PDF forms, you can use the ``--pdf-forms`` CLI
option or ``pdf_forms`` Python parameter.

.. code-block:: python

  from weasyprint import HTML
  HTML(string="<input value='test'>").write_pdf("test.pdf", pdf_forms=True)

.. code-block:: sh

  $ weasyprint document.html --pdf-forms document.pdf

You can also define which specific fields (``input``, ``select``, ``textarea``,
``button``) have to be transformed into PDF forms by setting the ``appearance``
CSS property to ``auto`` on them. In this case, as for browsers, you’ll have to
manually override the default style set by the user agent stylesheet. Reading
`the stylesheet set by the --pdf-forms option
<https://github.com/Kozea/WeasyPrint/blob/main/weasyprint/css/html5_ua_form.css>`_
can help to override this style.

.. code-block:: html

  <style>
    label { display: block }
    .pdf-form { appearance: auto }
    .pdf-form::before { visibility: hidden }
  </style>
  <label>
    Can't be modified in PDF
    <input value="static">
  </label>
  <label>
    Can be modified in PDF
    <input class="pdf-form" value="dynamic">
  </label>

PDF forms support can be quite poor depending on the PDF reader you use. If a
feature doesn’t work for you, please check that this feature is actually
supported by your PDF reader before reporting a bug.


Define PDF Metadata
-------------------

PDF documents can include various metadata, such as title, authors or creation
date. The easiest way to define them is to include them in your HTML file:
these fields are normalized and can be automatically picked up by WeasyPrint.

.. code-block:: html

  <html lang="en">
    <head>
      <title>PDF Sample with Metadata</title>
      <meta name="author" content="Jane Doe">
      <meta name="author" content="John Doe">
      <meta name="generator" content="HTML generator">
      <meta name="keywords" content="HTML, CSS, PDF">
      <meta name="dcterms.created" content="2000-12-31T12:34:56+02:00">
      <meta name="dcterms.modified" content="2010-07-14">
      <meta name="description" content="This is a simple sample">
    </head>
  </html>

HTML metadata values listed here, including language and title, are stored in
the corresponding, normalized fields in PDF.

If you use custom metadata fields, they are not stored in PDF by default. You
can include them in the PDF info dictionary using the ``--custom-metadata`` CLI
option or the ``custsom_metadata`` Python parameter.

.. code-block:: python

  from weasyprint import HTML
  HTML(string="<meta name="recipe" content="fries">").write_pdf("recipe.pdf", custom_metadata=True)

.. code-block:: sh

  $ weasyprint document.html --custom-metadata document.pdf


Attach Files
------------

You can attach files to your generated PDF. These files can be opened when a
link is clicked in the PDF, or just available in the list of attached files in
your PDF reader.

To attach a file with a regular link, you can use a regular anchor with the
``rel`` attribute set to ``attachment``.

.. code-block:: html

  <a rel="attachment" href="note.txt">view attached note</a>

To attach a file globally to the document, you can add a ``link`` tag in your
``head``:

.. code-block:: html

  <link rel="attachment" href="note.txt">

If you don’t want to attach your files using HTML tags, you can also use the
``--attachment`` CLI option, multiple times if needed.

.. code-block:: sh

  $ weasyprint document.html --attachment note.txt --attachment photo.jpg document.pdf

In a Python script, you can also attach files using the
:class:`weasyprint.Attachment` class.

.. code-block:: python

  from weasyprint import Attachment, HTML
  attachments = [Attachment("note.txt"), Attachment("photo.jpg")]
  HTML(string="<p>PDF with attachments</p>").write_pdf("recipe.pdf", attachments=attachments)


Cache and Optimize Images
-------------------------

WeasyPrint provides many options to deal with images: ``optimize_images``,
``jpeg_quality``, ``dpi`` and ``cache``.

``optimize_images`` can enable size optimization for images. When enabled, the
generated PDF will include smaller images with no quality penalty, but the
rendering time may be slightly increased.

The ``jpeg_quality`` option can be set to decrease the quality of JPEG images
included in the PDF. You can set a value between 95 (best quality) to 0
(smaller image size), depending on your needs.

The ``dpi`` option offers the possibility to reduce the size (in pixels, and
thus in bytes) of all included raster images. The resolution, set in dots per
inch, indicates the maximum number of pixels included in one inch on the
generated PDF.

.. code-block:: python

    # Original high-quality images, faster, but generated PDF is larger
    HTML('https://weasyprint.org/').write_pdf('weasyprint.pdf')

    # Optimized lower-quality images, a bit slower, but generated PDF is smaller
    HTML('https://weasyprint.org/').write_pdf(
        'weasyprint.pdf', optimize_images=True, jpeg_quality=60, dpi=150)

``cache`` gives the possibility to use a cache for images, avoiding to
download, parse and optimize them each time they are used.

By default, the cache is used document by document, but you can share it
between documents if needed. This feature can save a lot of network and CPU
time when you render a lot of documents that use the same images.

.. code-block:: python

    cache = {}
    for i in range(10):
        HTML(f'https://weasyprint.org/').write_pdf(
            f'example-{i}.pdf', cache=cache)

It’s also possible to cache images on disk instead of keeping them in memory.
The ``--cache-folder`` CLI option can be used to define the folder used to
store temporary images. You can also provide this folder path as a string for
``cache``.


Improve Rendering Speed and Memory Use
--------------------------------------

WeasyPrint is often slower than other web engines. Python is the usual suspect,
but it’s not the main culprit here. :ref:`Optimization is not the main goal of
WeasyPrint <Why Python?>` and it may lead to unbearable long rendering times.

First of all: WeasyPrint’s performance gets generally better with time. You can
check WeasyPerf_ to compare time and memory needed across versions.

Some tips may help you to get better results.

- A high number of CSS properties with a high number of HTML tags can lead to a
  huge amount of time spent for the cascade. Avoiding large CSS frameworks can
  drastically reduce the rendering time.
- Tables are known to be slow, especially when they are rendered on multiple
  pages. When possible, using a common block layout instead gives much faster
  renderings.
- Optimizing images and fonts can reduce the PDF size, but increase the
  rendering time. Moreover, caching images gives the possibility to read and
  optimize images only once, and thus to save time when the same image is used
  multiple times. See :ref:`Cache and Optimize Images`.

.. _WeasyPerf: https://kozea.github.io/WeasyPerf/


Show Log Messages
-----------------

Most errors (unsupported CSS property, missing image…) are not fatal and will
not prevent a document from being rendered. WeasyPrint uses the :mod:`logging`
module from the Python standard library to log these errors and let you know
about them.

When WeasyPrint is launched in a terminal, logged messages will go to the
standard error stream (``stderr``) by default. When used as a library, logs are
not displayed at all. You can change that by configuring the ``weasyprint``
logger object:

.. code-block:: python

    import logging
    logger = logging.getLogger('weasyprint')

    # Display warnings, errors and critical messages.
    logger.setLevel(logging.WARNING)

    # Save logs to the weasyprint.log file.
    logger.addHandler(logging.FileHandler('weasyprint.log'))
    # Print logs on console.
    logger.addHandler(logging.StreamHandler())

The ``weasyprint.progress`` logger is used to report the rendering progress. It
is useful to get feedback when WeasyPrint is launched in a terminal (using the
``--verbose`` or ``--debug`` option), or to give this feedback to end users
when used as a library.

See the documentation of the :mod:`logging` module for details.


================================================
FILE: docs/conf.py
================================================
# WeasyPrint documentation build configuration file.

import weasyprint

# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = [
    'sphinx.ext.autodoc', 'sphinx.ext.intersphinx',
    'sphinx.ext.autosectionlabel']

# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']

# The suffix of source filenames.
source_suffix = '.rst'

# The master toctree document.
master_doc = 'index'

# General information about the project.
project = 'WeasyPrint'
copyright = 'Simon Sapin and contributors'

# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The full version, including alpha/beta/rc tags.
release = weasyprint.__version__

# The short X.Y version.
version = release

# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']

# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'monokai'

# The theme to use for HTML and HTML Help pages.  See the documentation for
# a list of builtin themes.
html_theme = 'furo'

html_theme_options = {
    'top_of_page_buttons': ['edit'],
    'source_edit_link':
    'https://github.com/Kozea/WeasyPrint/edit/main/docs/{filename}',
}

# Favicon URL
html_favicon = 'https://www.courtbouillon.org/static/images/favicon.png'

# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = []

# These paths are either relative to html_static_path
# or fully qualified paths (eg. https://...)
html_css_files = [
    'https://www.courtbouillon.org/static/docs-furo.css',
]

# Output file base name for HTML help builder.
htmlhelp_basename = 'weasyprintdoc'

# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
    ('manpage', 'weasyprint', 'The Awesome Document Factory',
     ['Simon Sapin and contributors'], 1)
]

# Don’t autolabel man page titles.
autosectionlabel_maxdepth = 4

# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author, dir menu entry, description, category)
texinfo_documents = [(
    'index', 'WeasyPrint', 'WeasyPrint Documentation',
    'Simon Sapin and contributors', 'WeasyPrint',
    'The Awesome Document Factory', 'Miscellaneous'),
]

# Example configuration for intersphinx: refer to the Python standard library.
intersphinx_mapping = {
    'python': ('https://docs.python.org/3/', None),
    'pydyf': ('https://doc.courtbouillon.org/pydyf/stable/', None),
}


================================================
FILE: docs/contribute.rst
================================================
Contribute
==========

You want to add some code to WeasyPrint, launch its tests or improve its
documentation? Thank you very much! Here are some tips to help you play with
WeasyPrint in good conditions.

The first step is to clone the repository, create a virtual environment and
install WeasyPrint dependencies:

.. code-block:: shell

   git clone https://github.com/Kozea/WeasyPrint.git
   cd WeasyPrint
   python -m venv venv
   venv/bin/pip install -e '.[doc,test]'

You can then launch Python to test your changes:

.. code-block:: shell

   venv/bin/python

Running WeasyPrint might look something like this:

.. code-block:: shell

   venv/bin/python -m weasyprint example.html example.pdf


Code & Issues
-------------

If you’ve found a bug in WeasyPrint, it’s time to report it, and to fix it if you
can!

You can report bugs and feature requests on `GitHub`_. If you want to add or
fix some code, please fork the repository and create a pull request, we’ll be
happy to review your work.

You can find more information about the code architecture in the :ref:`Dive
into the Source` section.

.. _GitHub: https://github.com/Kozea/WeasyPrint


Tests
-----

Tests are stored in the ``tests`` folder at the top of the repository. They use
the pytest_ library.

Tests require Ghostscript_ to be installed and available on the local path. You
should also install all the `DejaVu fonts`_ if you’re on Linux.

You can launch tests using the following command::

  venv/bin/python -m pytest

WeasyPrint also uses ruff_ to check the coding style::

  venv/bin/python -m ruff check

.. _pytest: https://docs.pytest.org/
.. _Ghostscript: https://www.ghostscript.com/
.. _DejaVu fonts: https://dejavu-fonts.github.io/
.. _ruff: https://docs.astral.sh/ruff/


Documentation
-------------

Documentation is stored in the ``docs`` folder at the top of the repository. It
relies on the `Sphinx`_ library.

You can build the documentation using the following command::

  venv/bin/sphinx-build docs docs/_build

The documentation home page can now be found in the
``/path/to/weasyprint/docs/_build/index.html`` file. You can open this file in a
browser to see the final rendering.

.. _Sphinx: https://www.sphinx-doc.org/


================================================
FILE: docs/first_steps.rst
================================================
First Steps
===========

.. currentmodule:: weasyprint


Installation
------------

WeasyPrint |version| depends on:

* Python_ ≥ 3.10.0
* Pango_ ≥ 1.44.0
* pydyf_ ≥ 0.11.0
* CFFI_ ≥ 0.6
* tinyhtml5_ ≥ 2.0.0b1
* tinycss2_ ≥ 1.5.0
* cssselect2_ ≥ 0.8.0
* Pyphen_ ≥ 0.9.1
* Pillow_ ≥ 9.1.0
* fontTools_ ≥ 4.59.2

.. _Python: https://www.python.org/
.. _Pango: https://pango.gnome.org/
.. _CFFI: https://cffi.readthedocs.io/
.. _pydyf: https://doc.courtbouillon.org/pydyf/
.. _tinyhtml5: https://doc.courtbouillon.org/tinyhtml5/
.. _tinycss2: https://doc.courtbouillon.org/tinycss2/
.. _cssselect2: https://doc.courtbouillon.org/cssselect2/
.. _Pyphen: https://pyphen.org/
.. _Pillow: https://python-pillow.org/
.. _fontTools: https://github.com/fonttools/fonttools

There are many ways to install WeasyPrint, depending on the system you use.


Linux
~~~~~

The easiest way to install WeasyPrint on Linux is to use the package manager of
your distribution. WeasyPrint is packaged for recent versions of Debian_,
Ubuntu_, Fedora_, Archlinux_, Gentoo_…

.. _Debian: https://packages.debian.org/search?keywords=weasyprint&searchon=names&suite=all&section=all
.. _Ubuntu: https://packages.ubuntu.com/search?keywords=weasyprint&searchon=names&suite=all&section=all
.. _Fedora: https://src.fedoraproject.org/rpms/weasyprint
.. _Archlinux: https://aur.archlinux.org/packages/python-weasyprint
.. _Gentoo: https://packages.gentoo.org/packages/dev-python/weasyprint

If WeasyPrint is not available on your distribution, or if you want to use a
more recent version of WeasyPrint, you have to be sure that Python_ and Pango_
are installed on your system, and that they are recent enough. You can verify
this by launching::

  python3 --version
  pango-view --version

If the version of Pango provided by your distribution is too old, you can use
version 52.5 of WeasyPrint which does not need recent Pango features.

When everything is OK, you can install WeasyPrint directly on your system or
in a `virtual environment`_ using `pip`_::

  python3 -m venv venv
  source venv/bin/activate
  pip install weasyprint
  weasyprint --info

.. _virtual environment: https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/
.. _pip: https://pip.pypa.io/


Alpine ≥ 3.17
+++++++++++++

To install WeasyPrint using your distribution’s package::

  apk add weasyprint

To install WeasyPrint inside a virtualenv using wheels (if possible), you need
the following packages::

  apk add py3-pip so:libgobject-2.0.so.0 so:libpango-1.0.so.0 so:libharfbuzz.so.0 so:libharfbuzz-subset.so.0 so:libfontconfig.so.1 so:libpangoft2-1.0.so.0

To install WeasyPrint inside a virtualenv without using wheels, you need the
following packages::

  apk add py3-pip so:libgobject-2.0.so.0 so:libpango-1.0.so.0 so:libharfbuzz.so.0 so:libharfbuzz-subset.so.0 so:libfontconfig.so.1 so:libpangoft2-1.0.so.0
  apk add gcc musl-dev python3-dev zlib-dev jpeg-dev openjpeg-dev libwebp-dev g++ libffi-dev


Archlinux
+++++++++

To install WeasyPrint using your distribution’s package::

  pacman -S python-weasyprint

To install WeasyPrint inside a virtualenv using wheels (if possible), you need
the following packages::

  pacman -S python-pip pango

To install WeasyPrint inside a virtualenv without using wheels, you need the
following packages::

  pacman -S python-pip pango gcc libjpeg-turbo openjpeg2


Debian ≥ 11
+++++++++++

To install WeasyPrint using your distribution’s package::

  apt install weasyprint

To install WeasyPrint inside a virtualenv using wheels (if possible), you need
the following packages::

  apt install python3-pip libpango-1.0-0 libpangoft2-1.0-0 libharfbuzz-subset0

To install WeasyPrint inside a virtualenv without using wheels, you need the
following packages::

  apt install python3-pip libpango-1.0-0 libpangoft2-1.0-0 libharfbuzz-subset0 libjpeg-dev libopenjp2-7-dev libffi-dev


Fedora ≥ 39
+++++++++++

To install WeasyPrint using your distribution’s package::

  dnf install weasyprint

To install WeasyPrint inside a virtualenv using wheels (if possible), you need
the following packages::

  dnf install python-pip pango

To install WeasyPrint inside a virtualenv without using wheels, you need the
following packages::

  dnf install python3-pip pango gcc python3-devel gcc-c++ zlib-devel libjpeg-devel openjpeg2-devel libffi-devel


Ubuntu ≥ 20.04
++++++++++++++

To install WeasyPrint using your distribution’s package::

  apt install weasyprint

To install WeasyPrint inside a virtualenv using wheels (if possible), you need
the following packages::

  apt install python3-pip libpango-1.0-0 libharfbuzz0b libpangoft2-1.0-0 libharfbuzz-subset0

To install WeasyPrint inside a virtualenv without using wheels, you need the
following packages::

  apt install python3-pip libpango-1.0-0 libharfbuzz0b libpangoft2-1.0-0 libharfbuzz-subset0 libffi-dev libjpeg-dev libopenjp2-7-dev


macOS
~~~~~

The easiest way to install WeasyPrint on macOS is to use Homebrew_::

  brew install weasyprint

.. _Homebrew: https://brew.sh/


Windows
~~~~~~~

To use WeasyPrint on Windows, the easiest way is to use the `executable`_ of
the latest release.

.. warning::

   WeasyPrint is regularly marked as malware by different antivirus companies.
   See `#2081`_ or `#2092`_ to get more information on this topic. Don’t
   hesitate to report the false positive detection to your antivirus company in
   order to improve malware detection for future versions.

If you want to use WeasyPrint as a Python library, you’ll have to follow a few
extra steps. Please read this chapter carefully.

The first step is to install the `Python Install Manager`_ from the Microsoft
Store.

When Python is installed, you have to install Pango and its dependencies. The
easiest way to install these libraries is to use MSYS2. Here are the steps you
have to follow:

- Install `MSYS2`_ keeping the default options.
- After installation, in MSYS2’s shell, execute ``pacman -S mingw-w64-x86_64-pango``.
- Close MSYS2’s shell.

You can then launch a Windows command prompt by clicking on the Start menu,
typing ``cmd`` and clicking the "Command Prompt" icon. Install WeasyPrint in a
`virtual environment`_ using `pip`_::

  python -m venv venv
  venv\Scripts\activate.bat
  python -m pip install weasyprint
  python -m weasyprint --info

.. _executable: https://github.com/Kozea/WeasyPrint/releases
.. _#2081: https://github.com/Kozea/WeasyPrint/issues/2081
.. _#2092: https://github.com/Kozea/WeasyPrint/issues/2092
.. _Python Install Manager: https://apps.microsoft.com/detail/9nq7512cxl7t
.. _MSYS2: https://www.msys2.org/#installation


Other Solutions
~~~~~~~~~~~~~~~

Other solutions are available to install WeasyPrint. These solutions are not
tested but they are known to work for some use cases on specific platforms.

Macports
++++++++

On macOS, you can install WeasyPrint’s dependencies with Macports_::

  sudo port install py-pip pango libffi

You can then install WeasyPrint in a `virtual environment`_ using `pip`_::

  python3 -m venv venv
  source venv/bin/activate
  pip install weasyprint
  weasyprint --info

.. _Macports: https://www.macports.org/

Conda
+++++

On Linux and macOS, WeasyPrint is available on Conda_, with `a WeasyPrint
package on Conda Forge`_.

.. _Conda: https://docs.conda.io/projects/conda/en/latest/
.. _a WeasyPrint package on Conda Forge: https://anaconda.org/conda-forge/weasyprint

WSL
+++

On Windows, you can also use WSL_ and install WeasyPrint the same way it has to
be installed on Linux.

.. _WSL: https://docs.microsoft.com/en-us/windows/wsl/

.NET Wrapper
++++++++++++

On Windows, Bader Albarrak maintains `a .NET wrapper`_.

.. _a .NET wrapper: https://github.com/balbarak/WeasyPrint-netcore

AWS
+++

Kotify maintains `an AWS Lambda layer`_, see issue `#1003`_ for more
information.

.. _an AWS Lambda layer: https://github.com/kotify/cloud-print-utils
.. _#1003: https://github.com/Kozea/WeasyPrint/issues/1003

Docker
++++++

Luca Vercelli maintains `Docker images`_.

.. _an AWS Lambda layer: https://github.com/kotify/cloud-print-utils
.. _Docker images: https://github.com/luca-vercelli/WeasyPrint-docker-images/


Troubleshooting
~~~~~~~~~~~~~~~

Most of the installation problems have already been met, and some `issues on
GitHub`_ could help you to solve them. If the solutions here don’t solve your
problem, please open a new issue (and don’t add comments to closed issues).

.. _issues on GitHub: https://github.com/Kozea/WeasyPrint/issues

Missing Library
+++++++++++++++

On Windows or macOS, most of the problems come from unreachable libraries. If
you get an error like ``cannot load library 'xxx': error xxx``, it means that
WeasyPrint can’t find this library.

On Windows, you can set the ``WEASYPRINT_DLL_DIRECTORIES`` environment variable
to list the folders where the DLL files can be found. For example, in
``cmd.exe``::

  set WEASYPRINT_DLL_DIRECTORIES=C:\msys64\mingw64\bin

On macOS, you can set the ``DYLD_FALLBACK_LIBRARY_PATH`` environment variable::

  export DYLD_FALLBACK_LIBRARY_PATH=/opt/homebrew/lib:$DYLD_FALLBACK_LIBRARY_PATH

Of course, check that the folders you set actually contain the ``.dll`` (on
Windows) or ``.dylib`` (on macOS) files WeasyPrint requires.

Missing Fonts
+++++++++++++

If no character is drawn in the generated PDF, or if you get squares instead of
letters, you have to install fonts and make them available to WeasyPrint.
Following the standard way to install fonts on your system should be enough.
You can also use ``@font-face`` rules to explicitly reference fonts using URLs.


Command-Line
------------

Using the WeasyPrint command line interface can be as simple as this:

.. code-block:: sh

    weasyprint https://weasyprint.org /tmp/weasyprint-website.pdf

You may see warnings on the standard error output about unsupported CSS
properties. See :ref:`Command-Line API` for the details of all available
options.

In particular, the ``-s`` option can add a filename for a
:ref:`user stylesheet <Stylesheet Origins>`. For quick experimentation
however, you may not want to create a file. In bash or zsh, you can
use the shell’s redirection instead:

.. code-block:: sh

    weasyprint https://weasyprint.org /tmp/weasyprint-website.pdf \
        -s <(echo 'body { font-family: serif !important }')

If you have many documents to convert you may prefer using the Python API
in long-lived processes to avoid paying the start-up costs every time.


Python Library
--------------

.. attention::

    Using WeasyPrint with untrusted HTML or untrusted CSS may lead to various
    :ref:`security problems <security>`.

Quickstart
~~~~~~~~~~

The Python version of the above example goes like this:

.. code-block:: python

    from weasyprint import HTML
    HTML('https://weasyprint.org/').write_pdf('/tmp/weasyprint-website.pdf')

… or with the inline stylesheet:

.. code-block:: python

    from weasyprint import HTML, CSS
    HTML('https://weasyprint.org/').write_pdf('/tmp/weasyprint-website.pdf',
        stylesheets=[CSS(string='body { font-family: serif !important }')])

Instantiating HTML and CSS Objects
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

If you have a file name, an absolute URL or a readable :term:`file object`,
you can just pass it to :class:`HTML` or :class:`CSS` to create an instance.
Alternatively, use a named argument so that no guessing is involved:

.. code-block:: python

    from weasyprint import HTML

    HTML('../foo.html')  # Same as …
    HTML(filename='../foo.html')

    HTML('https://weasyprint.org')  # Same as …
    HTML(url='https://weasyprint.org')

    HTML(sys.stdin)  # Same as …
    HTML(file_obj=sys.stdin)

If you have a byte string or Unicode string already in memory you can also pass
that, although the argument must be named:

.. code-block:: python

    from weasyprint import HTML, CSS

    # HTML('<h1>foo') would be filename
    HTML(string='''
        <h1>The title</h1>
        <p>Content goes here
    ''')
    CSS(string='@page { size: A3; margin: 1cm }')

If you have ``@font-face`` rules in your CSS, you have to create a
``FontConfiguration`` object:

.. code-block:: python

    from weasyprint import HTML, CSS
    from weasyprint.text.fonts import FontConfiguration

    font_config = FontConfiguration()
    html = HTML(string='<h1>The title</h1>')
    css = CSS(string='''
        @font-face {
            font-family: Gentium;
            src: url(https://example.com/fonts/Gentium.otf);
        }
        h1 { font-family: Gentium }''', font_config=font_config)
    html.write_pdf(
        '/tmp/example.pdf', stylesheets=[css],
        font_config=font_config)

Rendering to a Single File
~~~~~~~~~~~~~~~~~~~~~~~~~~

Once you have a :class:`HTML` object, call its :meth:`HTML.write_pdf` method to
get the rendered document in a single PDF file.

Without arguments, this method returns a byte string in memory. If you pass a
file name or a writable :term:`file object`, they will write there directly
instead. (**Warning**: with a filename, these methods will overwrite existing
files silently.)

Rendering Individual Pages
~~~~~~~~~~~~~~~~~~~~~~~~~~

If you want more than a single PDF, the :meth:`HTML.render` method gives you a
:class:`document.Document` object with access to individual
:class:`document.Page` objects. Thus you can get the number of pages, their
size\ [#]_, the details of hyperlinks and bookmarks, etc. Documents also have a
:meth:`document.Document.write_pdf` method, and you can get a subset of the
pages with :meth:`document.Document.copy()`.

.. [#] Pages in the same document do not always have the same size.

See the :ref:`Python API` for details. A few random examples:

.. code-block:: python

    # Write odd and even pages separately:
    #   Lists count from 0 but page numbers usually from 1
    #   [::2] is a slice of even list indexes but odd-numbered pages.
    document.copy(document.pages[::2]).write_pdf('odd_pages.pdf')
    document.copy(document.pages[1::2]).write_pdf('even_pages.pdf')

.. code-block:: python

    # Print the outline of the document.
    # Output on https://www.w3.org/TR/CSS21/intro.html
    #     1. Introduction to CSS 2.1 (page 2)
    #       1. A brief CSS 2.1 tutorial for HTML (page 2)
    #       2. A brief CSS 2.1 tutorial for XML (page 5)
    #       3. The CSS 2.1 processing model (page 6)
    #         1. The canvas (page 7)
    #         2. CSS 2.1 addressing model (page 7)
    #       4. CSS design principles (page 8)
    def print_outline(bookmarks, indent=0):
        for i, bookmark in enumerate(bookmarks, 1):
            page = bookmark.destination[0]
            print('%s%d. %s (page %d)' % (
                ' ' * indent, i, bookmark.label.lstrip('0123456789. '), page))
            print_outline(bookmark.children, indent + 2)
    print_outline(document.make_bookmark_tree())

URL Fetchers
~~~~~~~~~~~~

WeasyPrint goes through a *URL fetcher* to fetch external resources such as
images or CSS stylesheets. The default fetcher can natively open file and
HTTP URLs, but the HTTP client does not support advanced features like cookies
or authentication. This can be worked-around by passing a custom
:class:`URLFetcher <urls.URLFetcher>` to the :class:`HTML` or :class:`CSS`
classes.

Some features, such as the timeout delay, can be configured as parameters:

.. code-block:: python

    from weasyprint import HTML
    from weasyprint.urls import URLFetcher

    HTML(string='<html>', url_fetcher=URLFetcher(timeout=20)).write_pdf('out.pdf')

Custom fetchers can also choose to handle some URLs and defer others to the default
fetcher:

.. code-block:: python

    from weasyprint import HTML
    from weasyprint.urls import URLFetcher, URLFetcherResponse

    class MyFetcher(URLFetcher):
        def fetch(self, url, headers=None):
            if url.startswith('graph:'):
                graph_data = [float(value) for value in url[6:].split(',')]
                string = generate_graph(graph_data)
                return URLFetcherResponse(url, string, {'Content-Type': 'image/png'})
            return super().fetch(url, headers)

    source = '<img src="graph:42,10.3,87">'
    HTML(string=source, url_fetcher=MyFetcher()).write_pdf('out.pdf')

By default, all errors raised by the fetcher are caught by WeasyPrint and emit a
warning. If you want some errors to be fatal and stop the rendering, you can raise a
:class:`urls.FatalURLFetchingError`.

.. code-block:: python

    from weasyprint import HTML
    from weasyprint.urls import URLFetcher, FatalURLFetchingError

    class MyFetcher(URLFetcher):
        def fetch(self, url, headers=None):
            try:
                return super().fetch(url, headers)
            except Exception as exception:
                if url.endswith('.css'):
                    # Stop the rendering if a problem happens with a stylesheet.
                    message = f'Problem with stylesheet at {url}'
                    raise FatalURLFetchingError(message) from exception
                else:
                    # Raise original error that will be caught by WeasyPrint.
                    raise exception

    HTML(string='<html>', url_fetcher=MyFetcher()).write_pdf('out.pdf')

Flask-WeasyPrint_ for Flask_ and Django-Weasyprint_ for Django_ both make
use of a custom URL fetcher to integrate WeasyPrint and use the filesystem
instead of a network call for static and media files.

A custom fetcher should be returning a :class:`urls.URLFetcherResponse`.

If a ``file_obj`` is given, the resource will be closed automatically by
the function internally used by WeasyPrint to retrieve data.

.. _Flask-Weasyprint: https://github.com/Kozea/Flask-WeasyPrint
.. _Flask: https://flask.pocoo.org/
.. _Django-WeasyPrint: https://github.com/fdemmer/django-weasyprint
.. _Django: https://www.djangoproject.com/


Security
--------

*This section has been added thanks to the very useful reports and advice from
Raz Becker.*

When used with untrusted HTML or untrusted CSS, WeasyPrint can meet security
problems. You will need extra configuration in your Python application to avoid
high memory use, endless renderings or local files leaks.

As for any service dealing with untrusted data, you should at least follow
basic security rules with WeasyPrint: don’t launch the service as root, launch
it as a user with limited access to filesystem, network and memory. Using a
container can also be a simple way to limit the possibilities given to an
attacker in case of security breach.

Long Renderings
~~~~~~~~~~~~~~~

WeasyPrint is pretty slow and can take a long time to render long documents or
specially crafted HTML pages.

When WeasyPrint used on a server with HTML or CSS files from untrusted sources,
this problem can lead to very long time renderings, with processes with high
CPU and memory use. Even small documents may lead to really long rendering
times, restricting HTML document size is not enough.

If you use WeasyPrint on a server with HTML or CSS samples coming from
untrusted users, you should:

- limit rendering time and memory use of your process, for example using
  ``evil-reload-on-as`` and ``harakiri`` options if you use uWSGI,
- limit memory use at the OS level, for example with ``ulimit`` on Linux,
- automatically kill the process when it uses too much memory or when the
  rendering time is too high, by regularly launching a script to do so if no
  better option is available,
- truncate and sanitize HTML and CSS input to avoid very long documents and
  access to external URLs.

Infinite Requests
~~~~~~~~~~~~~~~~~

WeasyPrint can reach files on the network, for example using ``https://``
URIs. For various reasons, HTTP requests may take a long time and lead to
problems similar to :ref:`Long Renderings`.

WeasyPrint has a default timeout of 10 seconds for HTTP, HTTPS and FTP
resources. This timeout has no effect with other protocols, including access to
``file://`` URIs.

If you use WeasyPrint on a server with HTML or CSS samples coming from
untrusted users, or need to reach network resources, you should:

- use a custom :ref:`URL fetcher <URL Fetchers>`,
- follow solutions listed in :ref:`Long Renderings`.

Infinite Loops
~~~~~~~~~~~~~~

WeasyPrint has been hit by a large number of bugs, including infinite
loops. Specially crafted HTML and CSS files can quite easily lead to infinite
loops and infinite rendering times.

If you use WeasyPrint on a server with HTML or CSS samples coming from
untrusted users, you should:

- follow solutions listed in :ref:`Long Renderings`.

Huge Values
~~~~~~~~~~~

WeasyPrint doesn't restrict integer and float values used in CSS. Using huge
values for some properties (page sizes, font sizes, block sizes) can lead to
various problems, including infinite rendering times, huge PDF files, high
memory use and crashes.

This problem is really hard to avoid. Even parsing CSS stylesheets and
searching for huge values is not enough, as it is quite easy to trick CSS
pre-processors using relative units (``em`` and ``%`` for example).

If you use WeasyPrint on a server with HTML or CSS samples coming from
untrusted users, you should:

- follow solutions listed in :ref:`Long Renderings`.

Access to Local Files
~~~~~~~~~~~~~~~~~~~~~

As any web renderer, WeasyPrint can reach files on the local filesystem using
``file://`` URIs. These files can be shown in ``img`` or ``embed`` tags for
example.

When WeasyPrint used on a server with HTML or CSS files from untrusted sources,
this feature may be used to know if files are present on the server filesystem,
and to embed them in generated documents.

Unix-like systems also have special local files with infinite size, like
``/dev/urandom``. Referencing these files in HTML or CSS files obviously lead
to infinite time renderings.

If you use WeasyPrint on a server with HTML or CSS samples coming from
untrusted users, you should:

- restrict your process access to trusted files using sandboxing solutions,
- use a custom :ref:`URL fetcher <URL Fetchers>` that doesn't allow ``file://``
  URLs or filters access depending on given paths.
- follow solutions listed in :ref:`Long Renderings`.

System Information Leaks
~~~~~~~~~~~~~~~~~~~~~~~~

WeasyPrint relies on many libraries that can leak hardware and software
information. Even when this information looks useless, it can be used by
attackers to exploit other security breaches.

Leaks can include (but are not restricted to):

- locally installed fonts (using ``font-family`` and ``@font-face``),
- network configuration (IPv4 and IPv6 support, IP addressing, firewall
  configuration, using ``https://`` URIs and tracking time used to render
  documents),
- Python, Pango and other libraries versions (implementation details
  lead to different renderings).

SVG Images
~~~~~~~~~~

Rendering SVG images more or less suffers from the same problems as the ones
listed here for WeasyPrint.

Security advices apply for untrusted SVG files as they apply for untrusted HTML
and CSS documents.

Note that WeasyPrint’s URL fetcher is used to render SVG files.


================================================
FILE: docs/going_further.rst
================================================
Going Further
=============

.. currentmodule:: weasyprint


Why WeasyPrint?
---------------

Automatic document generation is a common need of many applications, even if a
lot of operations do not require printed paper anymore.

Invoices, tickets, leaflets, diplomas, documentation, books… All these
documents are read and used on paper, but also on electronical readers, on
smartphones, on computers. PDF is a great format to store and display them in
a reliable way, with pagination.

Using HTML and CSS to generate static and paged content can be strange at first
glance: browsers display only one page, with variable dimensions, often in a
very dynamic way. But paged media layout is actually included in CSS2_, which
was already a W3C recommendation in 1998.

Other well-known tools can be used to automatically generate PDF documents,
like LaTeX and LibreOffice, but they miss many advantages that HTML and CSS
offer. HTML and CSS are very widely known, by developers but also by
webdesigners. They are specified in a backwards-compatible way, and regularly
adapted to please the use of billions of people. They are really easy to write
and generate, with a ridiculous amount of tools that are finely adapted to the
needs and taste of their users.

However, the web engines that are used for browsers were very limited for
pagination when WeasyPrint was created in 2011. Even now, they lack a lot of
basic features. That’s why projects such as wkhtmltopdf_ and PagedJS_ have been
created: they add some of these features to existing browsers.

Other solutions have beed developed, including web engine dedicated to paged
media. Prince_, Antennahouse_ or `Typeset.sh`_ created original renderers
supporting many features related to pagination. These tools are very powerful,
but they are not open source.

Building a free and open source web renderer generating high-quality documents
is the main goal of WeasyPrint. Do you think that it was a little bit crazy to
create such a big project from scratch? Here is what `Simon Sapin`_ wrote
in WeasyPrint’s documentation one month after the beginning:

  Are we crazy? Yes. But not that much. Each modern web browser did take many
  developers’ many years of work to get where they are now, but WeasyPrint’s
  scope is much smaller: there is no user-interaction, no JavaScript, no live
  rendering (the document doesn’t changed after it was first parsed) and no
  quirks mode (we don’t need to support every broken page of the web.)

  We still need however to implement the whole CSS box model and visual
  rendering. This is a lot of work, but we feel we can get something useful
  much quicker than “Let’s build a rendering engine!” may seem.

Simon is often right.

.. _CSS2: https://www.w3.org/TR/1998/REC-CSS2-19980512/
.. _wkhtmltopdf: https://wkhtmltopdf.org/
.. _PagedJS: https://www.pagedjs.org/
.. _Prince: https://www.princexml.com/
.. _Antennahouse: https://www.antennahouse.com/
.. _Typeset.sh: https://typeset.sh/
.. _Simon Sapin: https://exyr.org/


Why Python?
-----------

Python is a really good language to design a small, OS-agnostic parser. As it
is object-oriented, it gives the possibility to follow the specification with
high-level classes and a small amount of very simple code.

Speed is not WeasyPrint’s main goal. Web rendering is a very complex task, and
following :pep:`the Zen of Python <20>` helped a lot to keep our sanity (both in our
code and in our heads): code simplicity, maintainability and flexibility are
the most important goals for this library, as they give the ability to stay
really close to the specification and to fix bugs easily.


Dive into the Source
--------------------

This chapter is a high-level overview of WeasyPrint’s source code. For more
details, see the various docstrings or even the code itself. When in doubt,
feel free to :ref:`ask <Support>`!

Much `like in web browsers`_, the rendering of a document in WeasyPrint goes
like this:

1. The HTML document is fetched and parsed into a tree of elements (like DOM).
2. CSS stylesheets (either found in the HTML or supplied by the user) are
   fetched and parsed.
3. The stylesheets are applied to the DOM-like tree.
4. The DOM-like tree with styles is transformed into a *formatting structure*
   made of rectangular boxes.
5. These boxes are *laid-out* with fixed dimensions and position onto pages.
6. For each page, the boxes are re-ordered to observe stacking rules, and are
   drawn on a PDF page.
7. Metadata −such as document information, attachments, embedded files,
   hyperlinks, and PDF trim and bleed boxes− are added to the PDF.

.. _like in web browsers: https://www.html5rocks.com/en/tutorials/internals/howbrowserswork/#The_main_flow


Parsing HTML
............

Not much to see here. The :class:`HTML` class handles step 1 and
gives a tree of HTML *elements*. Although the actual API is different, this
tree is conceptually the same as what web browsers call *the DOM*.


Parsing CSS
...........

As with HTML, CSS stylesheets are parsed in the :class:`CSS` class
with an external library, tinycss2_.

In addition to the actual parsing, the ``css`` and ``css.validation``
modules do some pre-processing:

* Unknown and unsupported declarations are ignored with warnings.
  Remaining property values are parsed in a property-specific way
  from raw tinycss2 tokens into a higher-level form.
* Shorthand properties are expanded. For example, ``margin`` becomes
  ``margin-top``, ``margin-right``, ``margin-bottom`` and ``margin-left``.
* Hyphens in property names are replaced by underscores (``margin-top`` becomes
  ``margin_top``). This transformation is safe since none of the known (not
  ignored) properties have an underscore character.
* Selectors are pre-compiled with cssselect2_.

.. _tinycss2: https://pypi.python.org/pypi/tinycss2
.. _cssselect2: https://pypi.python.org/pypi/cssselect2


The Cascade
...........

After that and still in the ``css`` package, the cascade_
(that’s the C in CSS!) applies the stylesheets to the element tree.
Selectors associate property declarations to elements. In case of conflicting
declarations (different values for the same property on the same element),
the one with the highest *weight* wins. Weights are based on the stylesheet’s
:ref:`origin <Stylesheet Origins>`, ``!important`` markers, selector
specificity and source order. Missing values are filled in through
*inheritance* (from the parent element) or the property’s *initial value*,
so that every element has a *specified value* for every property.

.. _cascade: https://www.w3.org/TR/CSS21/cascade.html

These *specified values* are turned into *computed values* in the
``css.computed_values`` module. Keywords and lengths in various units are
converted to pixels, etc. At this point the value for some properties can be
represented by a single number or string, but some require more complex
objects. For example, a ``Dimension`` object can be either an absolute length
or a percentage.

The final result of the ``css.get_all_computed_styles`` function is a big dict
where keys are ``(element, pseudo_element_type)`` tuples, and keys are style
dict objects. Elements are ElementTree elements, while the type of
pseudo-element is a string for eg. ``::first-line`` selectors, or :obj:`None`
for “normal” elements. Style dict objects are dicts mapping property names to
the computed values. (The return value is not the dict itself, but a
convenience ``style_for`` function for accessing it.)


Formatting Structure
....................

The `visual formatting model`_ explains how *elements* (from the ElementTree
tree) generate *boxes* (in the formatting structure). This is step 4 above.
Boxes may have children and thus form a tree, much like elements. This tree is
generally close but not identical to the ElementTree tree: some elements
generate more than one box or none.

.. _visual formatting model: https://www.w3.org/TR/CSS21/visuren.html

Boxes are of a lot of different kinds. For example you should not confuse
*block-level boxes* and *block containers*, though *block boxes* are both.  The
``formatting_structure.boxes`` module has a whole hierarchy of classes to
represent all these boxes. We won’t go into the details here, see the module
and class docstrings.

The ``formatting_structure.build`` module takes an ElementTree tree with
associated computed styles, and builds a formatting structure. It generates the
right boxes for each element and ensures they conform to the models rules
(eg. an inline box can not contain a block). Each box has a ``style``
attribute containing the style dict of computed values.

The main logic is based on the ``display`` property, but it can be overridden
for some elements by adding a handler in the ``html`` module.
This is how ``<img>`` and ``<td colspan=3>`` are currently implemented,
for example.

This module is rather short as most of HTML is defined in CSS rather than
in Python, in the `user agent stylesheet`_.

The ``formatting_structure.build.build_formatting_structure`` function returns
the box for the root element (and, through its ``children`` attribute, the
whole tree).

.. _user agent stylesheet: https://github.com/Kozea/WeasyPrint/blob/main/weasyprint/css/html5_ua.css


Layout
......

Step 5 is the layout. You could say the everything else is glue code and
this is where the magic happens.

During the layout the document’s content is, well, laid out on pages.
This is when we decide where to do line breaks and page breaks. If a break
happens inside of a box, that box is split into two (or more) boxes in the
layout result.

According to the `box model`_, each box has rectangular margin, border,
padding and content areas:

.. _box model: https://www.w3.org/TR/CSS21/box.html

.. image:: https://www.w3.org/TR/CSS21/images/boxdim.png
   :alt: CSS Box Model
   :class: dark-invert

While ``box.style`` contains computed values, the `used values`_ are set as
attributes of the ``Box`` object itself during the layout. This include
resolving percentages and especially ``auto`` values into absolute, pixel
lengths. Once the layout done, each box has used values for margins, border
width, padding of each four sides, as well as the ``width`` and ``height`` of
the content area. They also have ``position_x`` and ``position_y``, the
absolute coordinates of the top-left corner of the margin box (**not** the
content box) from the top-left corner of the page.\ [#]_

Boxes also have helpers methods such as ``content_box_y`` and ``margin_width``
that give other metrics that can be useful in various parts of the code.

The final result of the layout is a list of ``PageBox`` objects.

.. [#] These are the coordinates *if* no `CSS transform`_ applies.
       Transforms change the actual location of boxes, but they are applied
       later during drawing and do not affect layout.
.. _used values: https://www.w3.org/TR/CSS21/cascade.html#used-value
.. _CSS transform: https://www.w3.org/TR/css-transforms-1/


Stacking & Drawing
..................

In step 6, the boxes are reordered by the ``stacking`` module to observe
`stacking rules`_ such as the ``z-index`` property.  The result is a tree of
*stacking contexts*.

Next, each laid-out page is *drawn* onto a PDF page. Since each box has
absolute coordinates on the page from the layout step, the logic here should be
minimal. If you find yourself adding a lot of logic here, maybe it should go in
the layout or stacking instead.

The code lives in the ``draw`` module.

.. _stacking rules: https://www.w3.org/TR/CSS21/zindex.html


Metadata
........

Finally (step 7), the ``pdf`` adds metadata to the PDF file: document
information, attachments, hyperlinks, embedded files, trim box and bleed box.


================================================
FILE: docs/index.rst
================================================
WeasyPrint
==========

.. currentmodule:: weasyprint

.. include:: ../README.rst

.. toctree::
   :caption: Documentation
   :maxdepth: 2

   first_steps
   common_use_cases
   api_reference
   going_further

.. toctree::
   :caption: Extra Information
   :maxdepth: 2

   changelog
   contribute
   support


================================================
FILE: docs/manpage.rst
================================================
:orphan:

.. currentmodule:: weasyprint


Description
-----------

.. autofunction:: weasyprint.__main__.main(argv=sys.argv)
   :noindex:


About
-----

.. include:: ../README.rst


================================================
FILE: docs/support.rst
================================================
Support
=======


Sponsorship
-----------

With `donations and sponsorship`, you help make the projects
better. Donations allow the CourtBouillon team to have more time dedicated to
add new features, fix bugs, and improve documentation.

.. _donations and sponsorship: https://opencollective.com/courtbouillon


Professional Support
--------------------

You can improve your experience with CourtBouillon’s tools thanks to our
professional support. You want bugs fixed as soon as possible? Your projects
would highly benefit from some new features? You or your team would like to get
new skills with one of the technologies we master?

Please contact us by mail, by chat, or by tweet to get in touch and find the
best way we can help you.

.. _mail: mailto:contact@courtbouillon.org
.. _chat: https://gitter.im/CourtBouillon/tinycss2
.. _tweet: https://twitter.com/BouillonCourt


================================================
FILE: pyproject.toml
================================================
[build-system]
requires = ['flit_core >=3.2,<4']
build-backend = 'flit_core.buildapi'

[project]
name = 'weasyprint'
description = 'The Awesome Document Factory'
keywords = ['html', 'css', 'pdf', 'converter']
authors = [{name = 'Simon Sapin', email = 'simon.sapin@exyr.org'}]
maintainers = [{name = 'CourtBouillon', email = 'contact@courtbouillon.org'}]
requires-python = '>=3.10'
readme = {file = 'README.rst', content-type = 'text/x-rst'}
license = {file = 'LICENSE'}
dependencies = [
  'pydyf >=0.11.0',
  'cffi >=0.6',
  'tinyhtml5 >=2.0.0b1',
  'tinycss2 >=1.5.0',
  'cssselect2 >=0.8.0',
  'Pyphen >=0.9.1',
  'Pillow >=9.1.0',
  'fonttools[woff] >=4.59.2',
]
classifiers = [
  'Development Status :: 5 - Production/Stable',
  'Intended Audience :: Developers',
  'License :: OSI Approved :: BSD License',
  'Operating System :: OS Independent',
  'Programming Language :: Python',
  'Programming Language :: Python :: 3',
  'Programming Language :: Python :: 3 :: Only',
  'Programming Language :: Python :: 3.10',
  'Programming Language :: Python :: 3.11',
  'Programming Language :: Python :: 3.12',
  'Programming Language :: Python :: 3.13',
  'Programming Language :: Python :: 3.14',
  'Programming Language :: Python :: Implementation :: CPython',
  'Programming Language :: Python :: Implementation :: PyPy',
  'Topic :: Internet :: WWW/HTTP',
  'Topic :: Text Processing :: Markup :: HTML',
  'Topic :: Multimedia :: Graphics :: Graphics Conversion',
  'Topic :: Printing',
]
dynamic = ['version']

[project.urls]
Homepage = 'https://weasyprint.org/'
Documentation = 'https://doc.courtbouillon.org/weasyprint/'
Code = 'https://github.com/Kozea/WeasyPrint'
Issues = 'https://github.com/Kozea/WeasyPrint/issues'
Changelog = 'https://github.com/Kozea/WeasyPrint/releases'
Donation = 'https://opencollective.com/courtbouillon'

[project.optional-dependencies]
doc = ['sphinx', 'furo']
test = ['pytest', 'ruff', 'Pillow >=12.1.0']

[project.scripts]
weasyprint = 'weasyprint.__main__:main'

[tool.flit.sdist]
exclude = ['.*']

[tool.coverage.run]
branch = true
include = ['tests/*', 'weasyprint/*']

[tool.coverage.report]
exclude_lines = ['pragma: no cover', 'def __repr__', 'raise NotImplementedError']

[tool.ruff.lint]
select = ['E', 'W', 'F', 'I', 'N', 'RUF', 'T20', 'PIE', 'PT', 'RSE', 'UP', 'Q']
ignore = ['E226', 'RUF001', 'RUF002', 'RUF003', 'RUF039', 'RUF059', 'UP031']

[tool.ruff.lint.flake8-quotes]
inline-quotes = 'single'
multiline-quotes = 'single'

================================================
FILE: tests/__init__.py
================================================
"""The Weasyprint test suite."""


================================================
FILE: tests/conftest.py
================================================
"""Configuration for WeasyPrint tests.

This module adds a PNG export based on Ghostscript.

Note that Ghostscript is released under AGPL.

"""

import io
import os
import shutil
from subprocess import PIPE, run
from tempfile import NamedTemporaryFile

import pytest
from PIL import Image

from weasyprint import HTML
from weasyprint.document import Document

from . import draw

MAGIC_NUMBER = b'\x89\x50\x4e\x47\x0d\x0a\x1a\x0a'


def document_write_png(document, target=None, resolution=96, antialiasing=1,
                       zoom=4/30, split_images=False):
    # Use temporary files because gs on Windows doesn’t accept binary on stdin
    with NamedTemporaryFile(delete=False) as pdf:
        document.write_pdf(pdf, zoom=zoom)
    command = (
        'gs', '-q', '-sDEVICE=png16m', f'-dTextAlphaBits={antialiasing}',
        f'-dGraphicsAlphaBits={antialiasing}', '-dBATCH', '-dNOPAUSE',
        '-dPDFSTOPONERROR', f'-r{resolution / zoom}', '-dUsePDFX3Profile',
        '-sOutputFile=-', pdf.name)
    pngs = run(command, stdout=PIPE).stdout
    os.remove(pdf.name)

    error = pngs.split(MAGIC_NUMBER)[0].decode().strip() or 'no output'
    assert pngs.startswith(MAGIC_NUMBER), f'Ghostscript error: {error}'

    if split_images:
        assert target is None

    # TODO: use a different way to find PNG files in stream
    magic_numbers = pngs.count(MAGIC_NUMBER)
    if magic_numbers == 1:
        if target is None:
            return [pngs] if split_images else pngs
        png = io.BytesIO(pngs)
    else:
        images = [MAGIC_NUMBER + png for png in pngs[8:].split(MAGIC_NUMBER)]
        if split_images:
            return images
        images = [Image.open(io.BytesIO(image)) for image in images]
        width = max(image.width for image in images)
        height = sum(image.height for image in images)
        output_image = Image.new('RGBA', (width, height))
        top = 0
        for image in images:
            output_image.paste(image, (int((width - image.width) / 2), top))
            top += image.height
        png = io.BytesIO()
        output_image.save(png, format='png')

    png.seek(0)

    if target is None:
        return png.read()

    if hasattr(target, 'write'):
        shutil.copyfileobj(png, target)
    else:
        with open(target, 'wb') as fd:
            shutil.copyfileobj(png, fd)


def html_write_png(document, target=None, font_config=None, counter_style=None,
                   resolution=96, **options):
    document = document.render(font_config, counter_style, **options)
    return document.write_png(target, resolution)


Document.write_png = document_write_png
HTML.write_png = html_write_png


def test_filename(filename):
    return ''.join(
        character if character.isalnum() else '_'
        for character in filename[5:50]).rstrip('_')


@pytest.fixture
def assert_pixels(request, *args, **kwargs):
    return lambda *args, **kwargs: draw.assert_pixels(
        test_filename(request.node.name), *args, **kwargs)


@pytest.fixture
def assert_same_renderings(request, *args, **kwargs):
    return lambda *args, **kwargs: draw.assert_same_renderings(
        test_filename(request.node.name), *args, **kwargs)


@pytest.fixture
def assert_different_renderings(request, *args, **kwargs):
    return lambda *args, **kwargs: draw.assert_different_renderings(
        test_filename(request.node.name), *args, **kwargs)


@pytest.fixture
def assert_pixels_equal(request, *args, **kwargs):
    return lambda *args, **kwargs: draw.assert_pixels_equal(
        test_filename(request.node.name), *args, **kwargs)


================================================
FILE: tests/css/__init__.py
================================================
"""Test CSS features."""


================================================
FILE: tests/css/test_common.py
================================================
"""Test the CSS parsing, cascade, inherited and computed values."""

from math import isclose

import pytest

from weasyprint import CSS
from weasyprint.css import find_stylesheets, get_all_computed_styles
from weasyprint.urls import URLFetcher, path2url

from ..testing_utils import (  # isort:skip
    BASE_URL, FakeHTML, assert_no_logs, capture_logs, resource_path)


@assert_no_logs
def test_find_stylesheets():
    html = FakeHTML(resource_path('doc1.html'))

    sheets = list(find_stylesheets(
        html.wrapper_element, 'print', URLFetcher(), html.base_url, font_config=None,
        counter_style=None, color_profiles=None, page_rules=None, layers=None))
    assert len(sheets) == 2
    # Also test that stylesheets are in tree order.
    sheet_names = [
        sheet.base_url.rsplit('/', 1)[-1].rsplit(',', 1)[-1]
        for sheet in sheets]
    assert sheet_names == ['a%7Bcolor%3AcurrentColor%7D', 'doc1.html']

    rules = []
    for sheet in sheets:
        for sheet_rules in sheet.matcher.lower_local_name_selectors.values():
            for rule in sheet_rules:
                rules.append(rule)
        for rule in sheet.page_rules:
            rules.append(rule)
    assert len(rules) == 10

    # TODO: Test that the values are correct too.


@assert_no_logs
def test_annotate_document():
    document = FakeHTML(resource_path('doc1.html'))
    document._ua_stylesheets = (
        lambda *_, **__: [CSS(resource_path('mini_ua.css'))])
    style_for = get_all_computed_styles(
        document, user_stylesheets=[CSS(resource_path('user.css'))])

    # Element objects behave as lists of their children.
    _head, body = document.etree_element
    h1, p, ul, div = body
    li_0, _li_1 = ul
    a, = li_0
    span1, = div
    span2, = span1

    h1 = style_for(h1)
    p = style_for(p)
    ul = style_for(ul)
    li_0 = style_for(li_0)
    div = style_for(div)
    after = style_for(a, 'after')
    a = style_for(a)
    span1 = style_for(span1)
    span2 = style_for(span2)

    assert h1['background_image'] == (
        ('url', path2url(resource_path('logo_small.png'))),)

    assert h1['font_weight'] == 700
    assert h1['font_size'] == 40  # 2em

    # x-large * initial = 3/2 * 16 = 24
    assert p['margin_top'] == (24, 'px')
    assert p['margin_right'] == (0, 'px')
    assert p['margin_bottom'] == (24, 'px')
    assert p['margin_left'] == (0, 'px')
    assert p['background_color'] == 'currentcolor'

    # 2em * 1.25ex = 2 * 20 * 1.25 * 0.8 = 40
    # 2.5ex * 1.25ex = 2.5 * 0.8 * 20 * 1.25 * 0.8 = 40
    # TODO: ex unit doesn't work with @font-face fonts, see computed_values.py
    # assert ul['margin_top'] == (40, 'px')
    # assert ul['margin_right'] == (40, 'px')
    # assert ul['margin_bottom'] == (40, 'px')
    # assert ul['margin_left'] == (40, 'px')

    assert ul['font_weight'] == 400
    # thick = 5px, 0.25 inches = 96*.25 = 24px
    assert ul['border_top_width'] == 0
    assert ul['border_right_width'] == 5
    assert ul['border_bottom_width'] == 0
    assert ul['border_left_width'] == 24

    assert li_0['font_weight'] == 700
    assert li_0['font_size'] == 8  # 6pt
    assert li_0['margin_top'] == (16, 'px')  # 2em
    assert li_0['margin_right'] == (0, 'px')
    assert li_0['margin_bottom'] == (16, 'px')
    assert li_0['margin_left'] == (32, 'px')  # 4em

    assert a['text_decoration_line'] == {'underline'}
    assert a['font_weight'] == 900
    assert a['font_size'] == 24  # 300% of 8px
    assert a['padding_top'] == (1, 'px')
    assert a['padding_right'] == (2, 'px')
    assert a['padding_bottom'] == (3, 'px')
    assert a['padding_left'] == (4, 'px')
    assert a['border_top_width'] == 42
    assert a['border_bottom_width'] == 42

    assert a['color'] == (1, 0, 0, 1)
    assert a['border_top_color'] == 'currentcolor'

    assert div['font_size'] == 40  # 2 * 20px
    assert span1['width'] == (160, 'px')  # 10 * 16px (root default is 16px)
    assert span1['height'] == (400, 'px')  # 10 * (2 * 20px)
    assert span2['font_size'] == 32

    # The href attr should be as in the source, not made absolute.
    assert after['content'] == (
        ('string', ' ['), ('string', 'home.html'), ('string', ']'))
    assert after['background_color'] == (1, 0, 0, 1)
    assert after['border_top_width'] == 42
    assert after['border_bottom_width'] == 3

    # TODO: much more tests here: test that origin and selector precedence
    # and inheritance are correct…


@assert_no_logs
def test_important():
    document = FakeHTML(string='''
      <style>
        p:nth-child(1) { color: lime }
        body p:nth-child(2) { color: red }

        p:nth-child(3) { color: lime !important }
        body p:nth-child(3) { color: red }

        body p:nth-child(5) { color: lime }
        p:nth-child(5) { color: red }

        p:nth-child(6) { color: red }
        p:nth-child(6) { color: lime }
      </style>
      <p></p>
      <p></p>
      <p></p>
      <p></p>
      <p></p>
      <p></p>
    ''')
    page, = document.render(stylesheets=[CSS(string='''
      body p:nth-child(1) { color: red }
      p:nth-child(2) { color: lime !important }

      p:nth-child(4) { color: lime !important }
      body p:nth-child(4) { color: red }
    ''')]).pages
    html, = page._page_box.children
    body, = html.children
    for paragraph in body.children:
        assert paragraph.style['color'] == (0, 1, 0, 1)  # lime (light green)


@assert_no_logs
@pytest.mark.parametrize(('value', 'width'), [
    # Absolute units.
    ('96px', 96),
    ('1in', 96),
    ('72pt', 96),
    ('6pc', 96),
    ('2.54cm', 96),
    ('25.4mm', 96),
    ('101.6q', 96),
    # Font-relative units.
    ('1.1em', 11),
    ('1.1rem', 17.6),
    ('1.1ch', 11),
    ('1.1rch', 17.6),
    ('1.1cap', 11),
    ('1.1rcap', 17.6),
    ('1.5ex', 12),
    ('2rex', 25.6),
    ('1ic', 20),
    ('1ric', 32),
    ('1.1lh', 13.2),
    ('1.1rlh', 26.4),
    # Viewport-relative units.
    ('50vh', 50),
    ('50vw', 100),
    ('25vb', 25),
    ('1.25vi', 2.5),
    ('10vmin', 10),
    ('20vmax', 40),
    ('50lvh', 50),
    ('50lvw', 100),
    ('25lvb', 25),
    ('1.25lvi', 2.5),
    ('10lvmin', 10),
    ('20lvmax', 40),
    ('50svh', 50),
    ('50svw', 100),
    ('25svb', 25),
    ('1.25svi', 2.5),
    ('10svmin', 10),
    ('20svmax', 40),
    ('50dvh', 50),
    ('50dvw', 100),
    ('25dvb', 25),
    ('1.25dvi', 2.5),
    ('10dvmin', 10),
    ('20dvmax', 40),
    ('50pvh', 100),
    ('50pvw', 150),
    ('25pvb', 50),
    ('1.5pvi', 4.5),
    ('10pvmin', 20),
    ('20pvmax', 60),
])
def test_units(value, width):
    document = FakeHTML(base_url=BASE_URL, string='''
      <html style="font: 16px / 1.5 weasyprint">
      <style>@page { size: 300px 200px; margin: 50px }</style>
      <body style="font: 10px / 1.2 weasyprint">
      <p style="margin-left: %s"></p>
      <p style="margin-left: %s"></p>
      ''' % (value, value.upper()))
    page, = document.render().pages
    html, = page._page_box.children
    body, = html.children
    p1, p2 = body.children
    assert p1.margin_left == p2.margin_left
    assert isclose(p1.margin_left, width, rel_tol=0.01)


@assert_no_logs
@pytest.mark.parametrize('property', ['line-height', 'font-size'])
def test_recursive_lh(property):
    document = FakeHTML(base_url=BASE_URL, string='''
      <html style="%s: 1lh">
      <body style="%s: 1rlh">a''' % (property, property))
    document.render().pages
    document = FakeHTML(base_url=BASE_URL, string='''
      <html style="%s: 1rlh">
      <body style="%s: 1lh">a''' % (property, property))
    document.render().pages


@pytest.mark.parametrize(('media', 'width', 'warning'), [
    ('@media screen { @page { size: 10px } }', 20, False),
    ('@media print { @page { size: 10px } }', 10, False),
    ('@media ("unknown content") { @page { size: 10px } }', 20, True),
])
def test_media_queries(media, width, warning):
    document = FakeHTML(string='<p>a<span>b')
    with capture_logs() as logs:
        page, = document.render(
            stylesheets=[CSS(string='@page{size:20px}%s' % media)]).pages
    html, = page._page_box.children
    assert html.width == width
    assert (logs if warning else not logs)


================================================
FILE: tests/css/test_counters.py
================================================
"""Test CSS counters."""

import pytest

from ..testing_utils import (  # isort:skip
    FakeHTML, assert_no_logs, assert_tree, parse_all, render_pages)

RENDER = FakeHTML(string='')._ua_counter_style()[0].render_value


@assert_no_logs
def test_counters_1():
    assert_tree(parse_all('''
      <style>
        p { counter-increment: p 2 }
        p:before { content: counter(p); }
        p:nth-child(1) { counter-increment: none; }
        p:nth-child(2) { counter-increment: p; }
      </style>
      <p></p>
      <p></p>
      <p></p>
      <p style="counter-reset: p 117 p"></p>
      <p></p>
      <p></p>
      <p style="counter-reset: p -13"></p>
      <p></p>
      <p></p>
      <p style="counter-reset: p 42"></p>
      <p></p>
      <p></p>'''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::before', 'Inline', [
                    ('p::before', 'Text', counter)])])])
        for counter in '0 1 3  2 4 6  -11 -9 -7  44 46 48'.split()])


@assert_no_logs
def test_counters_2():
    assert_tree(parse_all('''
      <ol style="list-style-position: inside">
        <li></li>
        <li></li>
        <li></li>
        <li><ol>
          <li></li>
          <li style="counter-increment: none"></li>
          <li></li>
        </ol></li>
        <li></li>
      </ol>'''), [
        ('ol', 'Block', [
            ('li', 'Block', [
                ('li', 'Line', [
                    ('li::marker', 'Inline', [
                        ('li::marker', 'Text', '1. ')])])]),
            ('li', 'Block', [
                ('li', 'Line', [
                    ('li::marker', 'Inline', [
                        ('li::marker', 'Text', '2. ')])])]),
            ('li', 'Block', [
                ('li', 'Line', [
                    ('li::marker', 'Inline', [
                        ('li::marker', 'Text', '3. ')])])]),
            ('li', 'Block', [
                ('li', 'Block', [
                    ('li', 'Line', [
                        ('li::marker', 'Inline', [
                            ('li::marker', 'Text', '4. ')])])]),
                ('ol', 'Block', [
                    ('li', 'Block', [
                        ('li', 'Line', [
                            ('li::marker', 'Inline', [
                                ('li::marker', 'Text', '1. ')])])]),
                    ('li', 'Block', [
                        ('li', 'Line', [
                            ('li::marker', 'Inline', [
                                ('li::marker', 'Text', '1. ')])])]),
                    ('li', 'Block', [
                        ('li', 'Line', [
                            ('li::marker', 'Inline', [
                                ('li::marker', 'Text', '2. ')])])])])]),
            ('li', 'Block', [
                ('li', 'Line', [
                    ('li::marker', 'Inline', [
                        ('li::marker', 'Text', '5. ')])])])])])


@assert_no_logs
def test_counters_3():
    assert_tree(parse_all('''
      <style>
        p { display: list-item; list-style: inside decimal }
      </style>
      <div>
        <p></p>
        <p></p>
        <p style="counter-reset: list-item 7 list-item -56"></p>
      </div>
      <p></p>'''), [
        ('div', 'Block', [
            ('p', 'Block', [
                ('p', 'Line', [
                    ('p::marker', 'Inline', [
                        ('p::marker', 'Text', '1. ')])])]),
            ('p', 'Block', [
                ('p', 'Line', [
                    ('p::marker', 'Inline', [
                        ('p::marker', 'Text', '2. ')])])]),
            ('p', 'Block', [
                ('p', 'Line', [
                    ('p::marker', 'Inline', [
                        ('p::marker', 'Text', '-55. ')])])])]),
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::marker', 'Inline', [
                    ('p::marker', 'Text', '1. ')])])])])


@assert_no_logs
def test_counters_4():
    assert_tree(parse_all('''
      <style>
        section:before { counter-reset: h; content: '' }
        h1:before { counter-increment: h; content: counters(h, '.') }
      </style>
      <body>
        <section><h1></h1>
          <h1></h1>
          <section><h1></h1>
            <h1></h1>
          </section>
          <h1></h1>
        </section>
      </body>'''), [
        ('section', 'Block', [
            ('section', 'Block', [
                ('section', 'Line', [
                    ('section::before', 'Inline', [])])]),
            ('h1', 'Block', [
                ('h1', 'Line', [
                    ('h1::before', 'Inline', [
                        ('h1::before', 'Text', '1')])])]),
            ('h1', 'Block', [
                ('h1', 'Line', [
                    ('h1::before', 'Inline', [
                        ('h1::before', 'Text', '2')])])]),
            ('section', 'Block', [
                ('section', 'Block', [
                    ('section', 'Line', [
                        ('section::before', 'Inline', [])])]),
                ('h1', 'Block', [
                    ('h1', 'Line', [
                        ('h1::before', 'Inline', [
                            ('h1::before', 'Text', '2.1')])])]),
                ('h1', 'Block', [
                    ('h1', 'Line', [
                        ('h1::before', 'Inline', [
                            ('h1::before', 'Text', '2.2')])])])]),
            ('h1', 'Block', [
                ('h1', 'Line', [
                    ('h1::before', 'Inline', [
                        ('h1::before', 'Text', '3')])])])])])


@assert_no_logs
def test_counters_5():
    assert_tree(parse_all('''
      <style>
        p:before { content: counter(c) }
      </style>
      <div>
        <span style="counter-reset: c">
          Scope created now, deleted after the div
        </span>
      </div>
      <p></p>'''), [
        ('div', 'Block', [
            ('div', 'Line', [
                ('span', 'Inline', [
                    ('span', 'Text',
                     'Scope created now, deleted after the div ')])])]),
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::before', 'Inline', [
                    ('p::before', 'Text', '0')])])])])


@assert_no_logs
def test_counters_6():
    # counter-increment may interfere with display: list-item
    assert_tree(parse_all('''
      <p style="counter-increment: c;
                display: list-item; list-style: inside decimal">'''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::marker', 'Inline', [
                    ('p::marker', 'Text', '0. ')])])])])


@assert_no_logs
def test_counters_7():
    # Regression test for #827.
    # Test that counters are case-sensitive.
    assert_tree(parse_all('''
      <style>
        p { counter-increment: p 2 }
        p:before { content: counter(p) '.' counter(P); }
      </style>
      <p></p>
      <p style="counter-increment: P 3"></p>
      <p></p>'''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::before', 'Inline', [
                    ('p::before', 'Text', counter)])])])
        for counter in '2.0 2.3 4.3'.split()])


@assert_no_logs
def test_counters_8():
    assert_tree(parse_all('''
      <style>
        p:before { content: 'a'; display: list-item }
      </style>
      <p></p>
      <p></p>'''), 2 * [
        ('p', 'Block', [
          ('p::before', 'Block', [
            ('p::marker', 'Block', [
              ('p::marker', 'Line', [
                ('p::marker', 'Text', '• ')])]),
            ('p::before', 'Block', [
                ('p::before', 'Line', [
                    ('p::before', 'Text', 'a')])])])])])


@pytest.mark.xfail
@assert_no_logs
def test_counters_9():
    page, = render_pages('''
      <ol>
        <li></li>
        <li>
          <ol style="counter-reset: a">
            <li></li>
            <li></li>
          </ol>
        </li>
        <li></li>
      </ol>
    ''')
    html, = page._page_box.children
    body, = html.children
    ol1, = body.children
    oli1, oli2, oli3 = ol1.children
    marker, ol2 = oli2.children
    oli21, oli22 = ol2.children
    assert oli1.children[0].children[0].children[0].text == '1. '
    assert oli2.children[0].children[0].children[0].text == '2. '
    assert oli21.children[0].children[0].children[0].text == '1. '
    assert oli22.children[0].children[0].children[0].text == '2. '
    assert oli3.children[0].children[0].children[0].text == '3. '


@assert_no_logs
def test_counter_styles_1():
    assert_tree(parse_all('''
      <style>
        body { --var: 'Counter'; counter-reset: p -12 }
        p { counter-increment: p }
        p:nth-child(1):before { content: '-' counter(p, none) '-'; }
        p:nth-child(2):before { content: counter(p, disc); }
        p:nth-child(3):before { content: counter(p, circle); }
        p:nth-child(4):before { content: counter(p, square); }
        p:nth-child(5):before { content: counter(p); }
        p:nth-child(6):before { content: var(--var) ':' counter(p); }
        p:nth-child(7):before { content: counter(p) ':' var(--var); }
      </style>
      <p></p>
      <p></p>
      <p></p>
      <p></p>
      <p></p>
      <p></p>
      <p></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::before', 'Inline', [
                    ('p::before', 'Text', counter)])])])
        for counter in '--  •  ◦  ▪  -7 Counter:-6 -5:Counter'.split()])


@assert_no_logs
def test_counter_styles_2():
    assert_tree(parse_all('''
      <style>
        p { counter-increment: p }
        p::before { content: counter(p, decimal-leading-zero); }
      </style>
      <p style="counter-reset: p -1987"></p>
      <p></p>
      <p style="counter-reset: p -12"></p>
      <p></p>
      <p></p>
      <p></p>
      <p style="counter-reset: p -2"></p>
      <p></p>
      <p></p>
      <p></p>
      <p style="counter-reset: p 8"></p>
      <p></p>
      <p></p>
      <p style="counter-reset: p 98"></p>
      <p></p>
      <p></p>
      <p style="counter-reset: p 4134"></p>
      <p></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::before', 'Inline', [
                    ('p::before', 'Text', counter)])])])
        for counter in '''-1986 -1985  -11 -10 -9 -8  -1 00 01 02  09 10 11
                            99 100 101  4135 4136'''.split()])


@assert_no_logs
def test_counter_styles_3():
    assert [RENDER(value, 'decimal-leading-zero') for value in [
        -1986, -1985,
        -11, -10, -9, -8,
        -1, 0, 1, 2,
        9, 10, 11,
        99, 100, 101,
        4135, 4136
    ]] == '''
        -1986 -1985  -11 -10 -9 -8  -1 00 01 02  09 10 11
        99 100 101  4135 4136
    '''.split()


@assert_no_logs
def test_counter_styles_4():
    assert [RENDER(value, 'lower-roman') for value in [
        -1986, -1985,
        -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
        49, 50,
        389, 390,
        3489, 3490, 3491,
        4999, 5000, 5001
     ]] == '''
        -1986 -1985  -1 0 i ii iii iv v vi vii viii ix x xi xii
        xlix l  ccclxxxix cccxc  mmmcdlxxxix mmmcdxc mmmcdxci
        4999 5000 5001
    '''.split()


@assert_no_logs
def test_counter_styles_5():
    assert [RENDER(value, 'upper-roman') for value in [
         -1986, -1985,
         -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
         49, 50,
         389, 390,
         3489, 3490, 3491,
         4999, 5000, 5001
    ]] == '''
        -1986 -1985  -1 0 I II III IV V VI VII VIII IX X XI XII
        XLIX L  CCCLXXXIX CCCXC  MMMCDLXXXIX MMMCDXC MMMCDXCI
        4999 5000 5001
    '''.split()


@assert_no_logs
def test_counter_styles_6():
    assert [RENDER(value, 'lower-alpha') for value in [
        -1986, -1985,
        -1, 0, 1, 2, 3, 4,
        25, 26, 27, 28, 29,
        2002, 2003
    ]] == '''
        -1986 -1985  -1 0 a b c d  y z aa ab ac bxz bya
    '''.split()


@assert_no_logs
def test_counter_styles_7():
    assert [RENDER(value, 'upper-alpha') for value in [
        -1986, -1985,
        -1, 0, 1, 2, 3, 4,
        25, 26, 27, 28, 29,
        2002, 2003
    ]] == '''
        -1986 -1985  -1 0 A B C D  Y Z AA AB AC BXZ BYA
    '''.split()


@assert_no_logs
def test_counter_styles_8():
    assert [RENDER(value, 'lower-latin') for value in [
        -1986, -1985,
        -1, 0, 1, 2, 3, 4,
        25, 26, 27, 28, 29,
        2002, 2003
    ]] == '''
        -1986 -1985  -1 0 a b c d  y z aa ab ac bxz bya
    '''.split()


@assert_no_logs
def test_counter_styles_9():
    assert [RENDER(value, 'upper-latin') for value in [
        -1986, -1985,
        -1, 0, 1, 2, 3, 4,
        25, 26, 27, 28, 29,
        2002, 2003
    ]] == '''
        -1986 -1985  -1 0 A B C D  Y Z AA AB AC BXZ BYA
    '''.split()


@assert_no_logs
def test_counter_styles_10():
    assert [RENDER(value, 'georgian') for value in [
        -1986, -1985,
        -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
        20, 30, 40, 50, 60, 70, 80, 90, 100,
        200, 300, 400, 500, 600, 700, 800, 900, 1000,
        2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000,
        19999, 20000, 20001
    ]] == '''
        -1986 -1985  -1 0 ა
        ბ გ დ ე ვ ზ ჱ თ ი ია იბ
        კ ლ მ ნ ჲ ო პ ჟ რ
        ს ტ ჳ ფ ქ ღ ყ შ ჩ
        ც ძ წ ჭ ხ ჴ ჯ ჰ ჵ
        ჵჰშჟთ 20000 20001
    '''.split()


@assert_no_logs
def test_counter_styles_11():
    assert [RENDER(value, 'armenian') for value in [
        -1986, -1985,
        -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
        20, 30, 40, 50, 60, 70, 80, 90, 100,
        200, 300, 400, 500, 600, 700, 800, 900, 1000,
        2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000,
        9999, 10000, 10001
    ]] == '''
        -1986 -1985  -1 0 Ա
        Բ Գ Դ Ե Զ Է Ը Թ Ժ ԺԱ ԺԲ
        Ի Լ Խ Ծ Կ Հ Ձ Ղ Ճ
        Մ Յ Ն Շ Ո Չ Պ Ջ Ռ
        Ս Վ Տ Ր Ց Ւ Փ Ք
        ՔՋՂԹ 10000 10001
    '''.split()


@assert_no_logs
@pytest.mark.parametrize(('arguments', 'values'), [
    ('cyclic "a" "b" "c"', ('a ', 'b ', 'c ', 'a ')),
    ('symbolic "a" "b"', ('a ', 'b ', 'aa ', 'bb ')),
    ('"a" "b"', ('a ', 'b ', 'aa ', 'bb ')),
    ('alphabetic "a" "b"', ('a ', 'b ', 'aa ', 'ab ')),
    ('fixed "a" "b"', ('a ', 'b ', '3 ', '4 ')),
    ('numeric "0" "1" "2"', ('1 ', '2 ', '10 ', '11 ')),
])
def test_counter_symbols(arguments, values):
    page, = render_pages('''
      <style>
        ol { list-style-type: symbols(%s) }
      </style>
      <ol>
        <li>abc</li>
        <li>abc</li>
        <li>abc</li>
        <li>abc</li>
      </ol>
    ''' % arguments)
    html, = page.children
    body, = html.children
    ol, = body.children
    li_1, li_2, li_3, li_4 = ol.children
    assert li_1.children[0].children[0].children[0].text == values[0]
    assert li_2.children[0].children[0].children[0].text == values[1]
    assert li_3.children[0].children[0].children[0].text == values[2]
    assert li_4.children[0].children[0].children[0].text == values[3]


@assert_no_logs
@pytest.mark.parametrize(('style_type', 'values'), [
    ('decimal', ('1. ', '2. ', '3. ', '4. ')),
    ('"/"', ('/', '/', '/', '/')),
])
def test_list_style_types(style_type, values):
    page, = render_pages('''
      <style>
        ol { list-style-type: %s }
      </style>
      <ol>
        <li>abc</li>
        <li>abc</li>
        <li>abc</li>
        <li>abc</li>
      </ol>
    ''' % style_type)
    html, = page.children
    body, = html.children
    ol, = body.children
    li_1, li_2, li_3, li_4 = ol.children
    assert li_1.children[0].children[0].children[0].text == values[0]
    assert li_2.children[0].children[0].children[0].text == values[1]
    assert li_3.children[0].children[0].children[0].text == values[2]
    assert li_4.children[0].children[0].children[0].text == values[3]


def test_list_style_type_empty_string():
    # Regression test for #1883.
    render_pages('<ul><li style="list-style-type: \'\'">')


def test_counter_set():
    page, = render_pages('''
      <style>
        body { counter-reset: h2 0 h3 4; font-size: 1px }
        article { counter-reset: h2 2 }
        h1 { counter-increment: h1 }
        h1::before { content: counter(h1) }
        h2 { counter-increment: h2; counter-set: h3 3 }
        h2::before { content: counter(h2) }
        h3 { counter-increment: h3 }
        h3::before { content: counter(h3) }
      </style>
      <article>
        <h1></h1>
      </article>
      <article>
        <h2></h2>
        <h3></h3>
      </article>
      <article>
        <h3></h3>
      </article>
      <article>
        <h2></h2>
      </article>
      <article>
        <h3></h3>
        <h3></h3>
      </article>
      <article>
        <h1></h1>
        <h2></h2>
        <h3></h3>
      </article>
    ''')
    html, = page.children
    body, = html.children
    art_1, art_2, art_3, art_4, art_5, art_6 = body.children

    h1, = art_1.children
    assert h1.children[0].children[0].children[0].text == '1'

    h2, h3, = art_2.children
    assert h2.children[0].children[0].children[0].text == '3'
    assert h3.children[0].children[0].children[0].text == '4'

    h3, = art_3.children
    assert h3.children[0].children[0].children[0].text == '5'

    h2, = art_4.children
    assert h2.children[0].children[0].children[0].text == '3'

    h3_1, h3_2 = art_5.children
    assert h3_1.children[0].children[0].children[0].text == '4'
    assert h3_2.children[0].children[0].children[0].text == '5'

    h1, h2, h3 = art_6.children
    assert h1.children[0].children[0].children[0].text == '1'
    assert h2.children[0].children[0].children[0].text == '3'
    assert h3.children[0].children[0].children[0].text == '4'


def test_counter_multiple_extends():
    # Inspired by W3C failing test system-extends-invalid
    page, = render_pages('''
      <style>
        @counter-style a {
          system: extends b;
          prefix: a;
        }
        @counter-style b {
          system: extends c;
          suffix: b;
        }
        @counter-style c {
          system: extends b;
          pad: 2 c;
        }
        @counter-style d {
          system: extends d;
          prefix: d;
        }
        @counter-style e {
          system: extends unknown;
          prefix: e;
        }
        @counter-style f {
          system: extends decimal;
          symbols: a;
        }
        @counter-style g {
          system: extends decimal;
          additive-symbols: 1 a;
        }
      </style>
      <ol>
        <li style="list-style-type: a"></li>
        <li style="list-style-type: b"></li>
        <li style="list-style-type: c"></li>
        <li style="list-style-type: d"></li>
        <li style="list-style-type: e"></li>
        <li style="list-style-type: f"></li>
        <li style="list-style-type: g"></li>
        <li style="list-style-type: h"></li>
      </ol>
    ''')
    html, = page.children
    body, = html.children
    ol, = body.children
    li_1, li_2, li_3, li_4, li_5, li_6, li_7, li_8 = ol.children
    assert li_1.children[0].children[0].children[0].text == 'a1b'
    assert li_2.children[0].children[0].children[0].text == '2b'
    assert li_3.children[0].children[0].children[0].text == 'c3. '
    assert li_4.children[0].children[0].children[0].text == 'd4. '
    assert li_5.children[0].children[0].children[0].text == 'e5. '
    assert li_6.children[0].children[0].children[0].text == '6. '
    assert li_7.children[0].children[0].children[0].text == '7. '
    assert li_8.children[0].children[0].children[0].text == '8. '


================================================
FILE: tests/css/test_descriptors.py
================================================
"""Test CSS descriptors."""

import pytest
import tinycss2

from weasyprint.css import preprocess_stylesheet
from weasyprint.css.validation.descriptors import preprocess_descriptors

from ..testing_utils import assert_no_logs, capture_logs


@assert_no_logs
def test_font_face_1():
    stylesheet = tinycss2.parse_stylesheet(
        '@font-face {'
        '  font-family: Gentium Hard;'
        '  src: url(https://example.com/fonts/Gentium.woff);'
        '}')
    at_rule, = stylesheet
    assert at_rule.at_keyword == 'font-face'
    font_family, src = list(preprocess_descriptors(
        'font-face', 'https://weasyprint.org/foo/',
        tinycss2.parse_blocks_contents(at_rule.content)))
    assert font_family == ('font_family', 'Gentium Hard')
    assert src == (
        'src', (('external', 'https://example.com/fonts/Gentium.woff'),))


@assert_no_logs
def test_font_face_2():
    stylesheet = tinycss2.parse_stylesheet(
        '@font-face {'
        '  font-family: "Fonty Smiley";'
        '  src: url(Fonty-Smiley.woff);'
        '  font-style: italic;'
        '  font-weight: 200;'
        '  font-stretch: condensed;'
        '}')
    at_rule, = stylesheet
    assert at_rule.at_keyword == 'font-face'
    font_family, src, font_style, font_weight, font_stretch = list(
        preprocess_descriptors(
            'font-face', 'https://weasyprint.org/foo/',
            tinycss2.parse_blocks_contents(at_rule.content)))
    assert font_family == ('font_family', 'Fonty Smiley')
    assert src == (
        'src', (('external', 'https://weasyprint.org/foo/Fonty-Smiley.woff'),))
    assert font_style == ('font_style', 'italic')
    assert font_weight == ('font_weight', 200)
    assert font_stretch == ('font_stretch', 'condensed')


@assert_no_logs
def test_font_face_3():
    stylesheet = tinycss2.parse_stylesheet(
        '@font-face {'
        '  font-family: Gentium Hard;'
        '  src: local();'
        '}')
    at_rule, = stylesheet
    assert at_rule.at_keyword == 'font-face'
    font_family, src = list(preprocess_descriptors(
        'font-face', 'https://weasyprint.org/foo/',
        tinycss2.parse_blocks_contents(at_rule.content)))
    assert font_family == ('font_family', 'Gentium Hard')
    assert src == ('src', (('local', None),))


@assert_no_logs
def test_font_face_4():
    # Regression test for #487.
    stylesheet = tinycss2.parse_stylesheet(
        '@font-face {'
        '  font-family: Gentium Hard;'
        '  src: local(Gentium Hard);'
        '}')
    at_rule, = stylesheet
    assert at_rule.at_keyword == 'font-face'
    font_family, src = list(preprocess_descriptors(
        'font-face', 'https://weasyprint.org/foo/',
        tinycss2.parse_blocks_contents(at_rule.content)))
    assert font_family == ('font_family', 'Gentium Hard')
    assert src == ('src', (('local', 'Gentium Hard'),))


@assert_no_logs
def test_font_face_5():
    # Regression test for #1653.
    stylesheet = tinycss2.parse_stylesheet(
        '@font-face {'
        '  font-family: Gentium Hard;'
        '  src: local(Gentium Hard);'
        '  src: local(Gentium Soft),'
        '}')
    at_rule, = stylesheet
    assert at_rule.at_keyword == 'font-face'
    with capture_logs() as logs:
        font_family, src = list(preprocess_descriptors(
            'font-face', 'https://weasyprint.org/foo/',
            tinycss2.parse_blocks_contents(at_rule.content)))
    assert font_family == ('font_family', 'Gentium Hard')
    assert src == ('src', (('local', 'Gentium Hard'),))
    assert len(logs) == 1
    assert 'invalid value' in logs[0]


def test_font_face_bad_1():
    stylesheet = tinycss2.parse_stylesheet(
        '@font-face {'
        '  font-family: "Bad Font";'
        '  src: url(BadFont.woff);'
        '  font-stretch: expanded;'
        '  font-style: wrong;'
        '  font-weight: bolder;'
        '  font-stretch: wrong;'
        '}')
    at_rule, = stylesheet
    assert at_rule.at_keyword == 'font-face'
    with capture_logs() as logs:
        font_family, src, font_stretch = list(
            preprocess_descriptors(
                'font-face', 'https://weasyprint.org/foo/',
                tinycss2.parse_blocks_contents(at_rule.content)))
    assert font_family == ('font_family', 'Bad Font')
    assert src == (
        'src', (('external', 'https://weasyprint.org/foo/BadFont.woff'),))
    assert font_stretch == ('font_stretch', 'expanded')
    assert logs == [
        'WARNING: Ignored `font-style: wrong` at 1:91, invalid value.',
        'WARNING: Ignored `font-weight: bolder` at 1:111, invalid value.',
        'WARNING: Ignored `font-stretch: wrong` at 1:133, invalid value.']


def test_font_face_bad_2():
    stylesheet = tinycss2.parse_stylesheet('@font-face{}')
    with capture_logs() as logs:
        preprocess_stylesheet(
            'print', 'https://wp.org/foo/', stylesheet, None, None, None,
            None, None, None, None)
    assert logs == [
        "WARNING: Missing src descriptor in '@font-face' rule at 1:1"]


def test_font_face_bad_3():
    stylesheet = tinycss2.parse_stylesheet('@font-face{src: url(test.woff)}')
    with capture_logs() as logs:
        preprocess_stylesheet(
            'print', 'https://wp.org/foo/', stylesheet, None, None, None,
            None, None, None, None)
    assert logs == [
        "WARNING: Missing font-family descriptor in '@font-face' rule at 1:1"]


def test_font_face_bad_4():
    stylesheet = tinycss2.parse_stylesheet('@font-face{font-family: test}')
    with capture_logs() as logs:
        preprocess_stylesheet(
            'print', 'https://wp.org/foo/', stylesheet, None, None, None,
            None, None, None, None)
    assert logs == [
        "WARNING: Missing src descriptor in '@font-face' rule at 1:1"]


def test_font_face_bad_5():
    stylesheet = tinycss2.parse_stylesheet(
        '@font-face { font-family: test; src: wrong }')
    with capture_logs() as logs:
        preprocess_stylesheet(
            'print', 'https://wp.org/foo/', stylesheet, None, None, None,
            None, None, None, None)
    assert logs == [
        'WARNING: Ignored `src: wrong ` at 1:33, invalid value.',
        "WARNING: Missing src descriptor in '@font-face' rule at 1:1"]


def test_font_face_bad_6():
    stylesheet = tinycss2.parse_stylesheet(
        '@font-face { font-family: good, bad; src: url(test.woff) }')
    with capture_logs() as logs:
        preprocess_stylesheet(
            'print', 'https://wp.org/foo/', stylesheet, None, None, None,
            None, None, None, None)
    assert logs == [
        'WARNING: Ignored `font-family: good, bad` at 1:14, invalid value.',
        "WARNING: Missing font-family descriptor in '@font-face' rule at 1:1"]


def test_font_face_bad_7():
    stylesheet = tinycss2.parse_stylesheet(
        '@font-face { font-family: good, bad; src: really bad }')
    with capture_logs() as logs:
        preprocess_stylesheet(
            'print', 'https://wp.org/foo/', stylesheet, None, None, None,
            None, None, None, None)
    assert logs == [
        'WARNING: Ignored `font-family: good, bad` at 1:14, invalid value.',
        'WARNING: Ignored `src: really bad ` at 1:38, invalid value.',
        "WARNING: Missing src descriptor in '@font-face' rule at 1:1"]


@pytest.mark.parametrize('rule', [
    '@counter-style test {system: alphabetic; symbols: a}',
    '@counter-style test {system: cyclic}',
    '@counter-style test {system: additive; additive-symbols: a 1}',
    '@counter-style test {system: additive; additive-symbols: 10 x, 1 i, 5 v}',
])
def test_counter_style_invalid(rule):
    stylesheet = tinycss2.parse_stylesheet(rule)
    with capture_logs() as logs:
        preprocess_stylesheet(
            'print', 'https://wp.org/foo/', stylesheet, None, None, None,
            None, None, None, {})
    assert len(logs) >= 1


================================================
FILE: tests/css/test_errors.py
================================================
"""Test CSS errors and warnings."""

import pytest

from weasyprint import CSS

from ..testing_utils import assert_no_logs, capture_logs, render_pages


@assert_no_logs
@pytest.mark.parametrize(('source', 'messages'), [
    (':lipsum { margin: 2cm', ['WARNING: Invalid or unsupported selector']),
    ('::lipsum { margin: 2cm', ['WARNING: Invalid or unsupported selector']),
    ('foo { margin-color: red', ['WARNING: Ignored', 'unknown property']),
    ('foo { margin-top: red', ['WARNING: Ignored', 'invalid value']),
    ('@import "relative-uri.css"',
     ['ERROR: Relative URI reference without a base URI']),
    ('@import "invalid-protocol://absolute-URL"',
     ['ERROR: Failed to load stylesheet at']),
    ('test', ['WARNING: Parse error']),
    ('@test', ['WARNING: Unknown empty rule']),
    ('@test {}', ['WARNING: Unknown rule']),
])
def test_warnings(source, messages):
    with capture_logs() as logs:
        CSS(string=source)
    assert len(logs) == 1, source
    for message in messages:
        assert message in logs[0]


@assert_no_logs
def test_warnings_stylesheet():
    with capture_logs() as logs:
        render_pages('<link rel=stylesheet href=invalid-protocol://absolute>')
    assert len(logs) == 1
    assert 'ERROR: Failed to load stylesheet at' in logs[0]


@assert_no_logs
@pytest.mark.parametrize('style', [
    '<style> html { color red; color: blue; color',
    '<html style="color; color: blue; color red">',
])
def test_error_recovery(style):
    with capture_logs() as logs:
        page, = render_pages(style)
        html, = page.children
        assert html.style['color'] == (0, 0, 1, 1)  # blue
    assert len(logs) == 2


================================================
FILE: tests/css/test_expanders.py
================================================
"""Test expanders for shorthand properties."""

import pytest
import tinycss2
from tinycss2.color5 import parse_color

from weasyprint.css import preprocess_declarations
from weasyprint.css.properties import INITIAL_VALUES, ZERO_PIXELS
from weasyprint.css.validation.expanders import EXPANDERS

from ..testing_utils import assert_no_logs, capture_logs


def expand_to_dict(css, expected_error=None):
    """Helper to test shorthand properties expander functions."""
    declarations = tinycss2.parse_blocks_contents(css)

    with capture_logs() as logs:
        base_url = 'https://weasyprint.org/foo/'
        declarations = list(preprocess_declarations(base_url, declarations))

    if expected_error:
        assert len(logs) == 1
        assert expected_error in logs[0]
    else:
        assert not logs

    return {
        name: parse_color(value)
        if name.endswith('_color') and value != 'inherit' else value
        for name, value, _ in declarations if value != 'initial'}


def assert_invalid(css, message='invalid'):
    assert expand_to_dict(css, message) == {}


@assert_no_logs
@pytest.mark.parametrize('expander', EXPANDERS)
def test_empty_expander_value(expander):
    assert_invalid(f'{expander}:', message='Ignored')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('none', {'text_decoration_line': 'none'}),
    ('overline', {'text_decoration_line': {'overline'}}),
    ('overline blink line-through', {
        'text_decoration_line': {'blink', 'line-through', 'overline'},
    }),
    ('red', {'text_decoration_color': parse_color('red')}),
    ('blue 1px', {
        'text_decoration_color': parse_color('blue'),
        'text_decoration_thickness': (1, 'px'),
    }),
    ('100% none', {
        'text_decoration_line': 'none',
        'text_decoration_thickness': (100, '%'),
    }),
    ('inherit', {
        f'text_decoration_{key}': 'inherit'
        for key in ('color', 'line', 'style', 'thickness')}),
])
def test_text_decoration(rule, result):
    assert expand_to_dict(f'text-decoration: {rule}') == result


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'solid solid',
    'red red',
    'underline none',
    '1px 100%',
    'none none',
])
def test_text_decoration_invalid(rule):
    assert_invalid(f'text-decoration: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('margin: inherit', {
        'margin_top': 'inherit',
        'margin_right': 'inherit',
        'margin_bottom': 'inherit',
        'margin_left': 'inherit',
    }),
    ('margin: 1em', {
        'margin_top': (1, 'em'),
        'margin_right': (1, 'em'),
        'margin_bottom': (1, 'em'),
        'margin_left': (1, 'em'),
    }),
    ('margin: -1em auto 20%', {
        'margin_top': (-1, 'em'),
        'margin_right': 'auto',
        'margin_bottom': (20, '%'),
        'margin_left': 'auto',
    }),
    ('padding: 1em 0', {
        'padding_top': (1, 'em'),
        'padding_right': (0, None),
        'padding_bottom': (1, 'em'),
        'padding_left': (0, None),
    }),
    ('padding: 1em 0 2%', {
        'padding_top': (1, 'em'),
        'padding_right': (0, None),
        'padding_bottom': (2, '%'),
        'padding_left': (0, None),
    }),
    ('padding: 1em 0 2em 5px', {
        'padding_top': (1, 'em'),
        'padding_right': (0, None),
        'padding_bottom': (2, 'em'),
        'padding_left': (5, 'px'),
    }),
])
def test_four_sides(rule, result):
    assert expand_to_dict(rule) == result


@assert_no_logs
def test_four_sides_warning():
    assert expand_to_dict('padding: 1 2 3 4 5', 'Expected 1 to 4 tokens, got 5') == {}


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'margin: rgb(0, 0, 0)',
    'padding: auto',
    'padding: -12px',
    'border-width: -3em',
    'border-width: 12%',
])
def test_four_sides_invalid(rule):
    assert_invalid(rule)


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('border-top: 3px dotted red', {
        'border_top_width': (3, 'px'),
        'border_top_style': 'dotted',
        'border_top_color': (1, 0, 0, 1),  # red
    }),
    ('border-top: 3px dotted', {
        'border_top_width': (3, 'px'),
        'border_top_style': 'dotted',
    }),
    ('border-top: 3px red', {
        'border_top_width': (3, 'px'),
        'border_top_color': (1, 0, 0, 1),  # red
    }),
    ('border-top: solid', {'border_top_style': 'solid'}),
    ('border: 6px dashed lime', {
        'border_top_width': (6, 'px'),
        'border_top_style': 'dashed',
        'border_top_color': (0, 1, 0, 1),  # lime

        'border_left_width': (6, 'px'),
        'border_left_style': 'dashed',
        'border_left_color': (0, 1, 0, 1),  # lime

        'border_bottom_width': (6, 'px'),
        'border_bottom_style': 'dashed',
        'border_bottom_color': (0, 1, 0, 1),  # lime

        'border_right_width': (6, 'px'),
        'border_right_style': 'dashed',
        'border_right_color': (0, 1, 0, 1),  # lime
    }),
])
def test_borders(rule, result):
    assert expand_to_dict(rule) == result


@assert_no_logs
def test_borders_invalid():
    assert_invalid('border: 6px dashed left')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('list-style: inherit', {
        'list_style_position': 'inherit',
        'list_style_image': 'inherit',
        'list_style_type': 'inherit',
    }),
    ('list-style: url(../bar/lipsum.png)', {
        'list_style_image': ('url', 'https://weasyprint.org/bar/lipsum.png'),
    }),
    ('list-style: square', {
        'list_style_type': 'square',
    }),
    ('list-style: circle inside', {
        'list_style_position': 'inside',
        'list_style_type': 'circle',
    }),
    ('list-style: none circle inside', {
        'list_style_position': 'inside',
        'list_style_image': ('none', None),
        'list_style_type': 'circle',
    }),
    ('list-style: none inside none', {
        'list_style_position': 'inside',
        'list_style_image': ('none', None),
        'list_style_type': 'none',
    }),
    ('list-style: inside special none', {
        'list_style_position': 'inside',
        'list_style_image': ('none', None),
        'list_style_type': 'special',
    }),
])
def test_list_style(rule, result):
    assert expand_to_dict(rule) == result


@assert_no_logs
def test_list_style_warning():
    assert_invalid(
        'list-style: circle disc',
        'got multiple type values in a list-style shorthand')


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'list-style: none inside none none',
    'list-style: 1px',
])
def test_list_style_invalid(rule):
    assert_invalid(rule)


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('red', {'background_color': (1, 0, 0, 1)}),
    ('url(lipsum.png)', {
        'background_image': [
            ('url', 'https://weasyprint.org/foo/lipsum.png')]}),
    ('no-repeat', {
        'background_repeat': [('no-repeat', 'no-repeat')]}),
    ('fixed', {
        'background_attachment': ['fixed']}),
    ('repeat no-repeat fixed', {
        'background_repeat': [('repeat', 'no-repeat')],
        'background_attachment': ['fixed']}),
    ('inherit', {
        'background_repeat': 'inherit',
        'background_attachment': 'inherit',
        'background_image': 'inherit',
        'background_position': 'inherit',
        'background_size': 'inherit',
        'background_clip': 'inherit',
        'background_origin': 'inherit',
        'background_color': 'inherit'}),
    ('top', {
        'background_position': [('left', (50, '%'), 'top', (0, '%'))]}),
    ('top right', {
        'background_position': [('left', (100, '%'), 'top', (0, '%'))]}),
    ('top right 20px', {
        'background_position': [('right', (20, 'px'), 'top', (0, '%'))]}),
    ('top 1% right 20px', {
        'background_position': [('right', (20, 'px'), 'top', (1, '%'))]}),
    ('top no-repeat', {
        'background_repeat': [('no-repeat', 'no-repeat')],
        'background_position': [('left', (50, '%'), 'top', (0, '%'))]}),
    ('top right no-repeat', {
        'background_repeat': [('no-repeat', 'no-repeat')],
        'background_position': [('left', (100, '%'), 'top', (0, '%'))]}),
    ('top right 20px no-repeat', {
        'background_repeat': [('no-repeat', 'no-repeat')],
        'background_position': [('right', (20, 'px'), 'top', (0, '%'))]}),
    ('top 1% right 20px no-repeat', {
        'background_repeat': [('no-repeat', 'no-repeat')],
        'background_position': [('right', (20, 'px'), 'top', (1, '%'))]}),
    ('url(bar) #f00 repeat-y center left fixed', {
        'background_color': (1, 0, 0, 1),
        'background_image': [('url', 'https://weasyprint.org/foo/bar')],
        'background_repeat': [('no-repeat', 'repeat')],
        'background_attachment': ['fixed'],
        'background_position': [('left', (0, '%'), 'top', (50, '%'))]}),
    ('#00f 10% 200px', {
        'background_color': (0, 0, 1, 1),
        'background_position': [('left', (10, '%'), 'top', (200, 'px'))]}),
    ('right 78px fixed', {
        'background_attachment': ['fixed'],
        'background_position': [('left', (100, '%'), 'top', (78, 'px'))]}),
    ('center / cover red', {
        'background_size': ['cover'],
        'background_position': [('left', (50, '%'), 'top', (50, '%'))],
        'background_color': (1, 0, 0, 1)}),
    ('center / auto red', {
        'background_size': [('auto', 'auto')],
        'background_position': [('left', (50, '%'), 'top', (50, '%'))],
        'background_color': (1, 0, 0, 1)}),
    ('center / 42px', {
        'background_size': [((42, 'px'), 'auto')],
        'background_position': [('left', (50, '%'), 'top', (50, '%'))]}),
    ('center / 7% 4em', {
        'background_size': [((7, '%'), (4, 'em'))],
        'background_position': [('left', (50, '%'), 'top', (50, '%'))]}),
    ('red content-box', {
        'background_color': (1, 0, 0, 1),
        'background_origin': ['content-box'],
        'background_clip': ['content-box']}),
    ('red border-box content-box', {
        'background_color': (1, 0, 0, 1),
        'background_origin': ['border-box'],
        'background_clip': ['content-box']}),
    ('border-box red', {
        'background_color': (1, 0, 0, 1),
        'background_origin': ['border-box']}),
    ('url(bar) center, no-repeat', {
        'background_color': (0, 0, 0, 0),
        'background_image': [
            ('url', 'https://weasyprint.org/foo/bar'), ('none', None)],
        'background_position': [
            ('left', (50, '%'), 'top', (50, '%')),
            ('left', (0, '%'), 'top', (0, '%'))],
        'background_repeat': [
            ('repeat', 'repeat'), ('no-repeat', 'no-repeat')]}),
])
def test_background(rule, result):
    expanded = expand_to_dict(f'background: {rule}')
    assert expanded.pop('background_color') == result.pop(
        'background_color', parse_color(INITIAL_VALUES['background_color']))
    nb_layers = len(expanded['background_image'])
    for name, value in result.items():
        assert expanded.pop(name) == value
    for name, value in expanded.items():
        assert tuple(value) == INITIAL_VALUES[name] * nb_layers


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'red, url(foo)',
    '10px lipsum',
    'content-box red content-box',
])
def test_background_invalid(rule):
    assert_invalid(f'background: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('1px', {
        'border_top_left_radius': ((1, 'px'), (1, 'px')),
        'border_top_right_radius': ((1, 'px'), (1, 'px')),
        'border_bottom_right_radius': ((1, 'px'), (1, 'px')),
        'border_bottom_left_radius': ((1, 'px'), (1, 'px')),
    }),
    ('1px 2em', {
        'border_top_left_radius': ((1, 'px'), (1, 'px')),
        'border_top_right_radius': ((2, 'em'), (2, 'em')),
        'border_bottom_right_radius': ((1, 'px'), (1, 'px')),
        'border_bottom_left_radius': ((2, 'em'), (2, 'em')),
    }),
    ('1px / 2em', {
        'border_top_left_radius': ((1, 'px'), (2, 'em')),
        'border_top_right_radius': ((1, 'px'), (2, 'em')),
        'border_bottom_right_radius': ((1, 'px'), (2, 'em')),
        'border_bottom_left_radius': ((1, 'px'), (2, 'em')),
    }),
    ('1px 3px / 2em 4%', {
        'border_top_left_radius': ((1, 'px'), (2, 'em')),
        'border_top_right_radius': ((3, 'px'), (4, '%')),
        'border_bottom_right_radius': ((1, 'px'), (2, 'em')),
        'border_bottom_left_radius': ((3, 'px'), (4, '%')),
    }),
    ('1px 2em 3%', {
        'border_top_left_radius': ((1, 'px'), (1, 'px')),
        'border_top_right_radius': ((2, 'em'), (2, 'em')),
        'border_bottom_right_radius': ((3, '%'), (3, '%')),
        'border_bottom_left_radius': ((2, 'em'), (2, 'em')),
    }),
    ('1px 2em 3% 4rem', {
        'border_top_left_radius': ((1, 'px'), (1, 'px')),
        'border_top_right_radius': ((2, 'em'), (2, 'em')),
        'border_bottom_right_radius': ((3, '%'), (3, '%')),
        'border_bottom_left_radius': ((4, 'rem'), (4, 'rem')),
    }),
    ('inherit', {
        'border_top_left_radius': 'inherit',
        'border_top_right_radius': 'inherit',
        'border_bottom_right_radius': 'inherit',
        'border_bottom_left_radius': 'inherit',
    }),
])
def test_border_radius(rule, result):
    assert expand_to_dict(f'border-radius: {rule}') == result


@assert_no_logs
@pytest.mark.parametrize(('rule', 'message'), [
    ('1px 1px 1px 1px 1px', '1 to 4 token'),
    ('1px 1px 1px 1px 1px / 1px', '1 to 4 token'),
    ('1px / 1px / 1px', 'only one "/"'),
    ('12deg', 'invalid'),
    ('1px 1px 1px 12deg', 'invalid'),
    ('super', 'invalid'),
    ('1px, 1px', 'invalid'),
    ('1px /', 'value after "/"'),
])
def test_border_radius_invalid(rule, message):
    assert_invalid(f'border-radius: {rule}', message)


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('url(border.png) 27', {
        'border_image_source': ('url', 'https://weasyprint.org/foo/border.png'),
        'border_image_slice': ((27, None),),
    }),
    ('url(border.png) 10 / 4 / 2 round stretch', {
        'border_image_source': ('url', 'https://weasyprint.org/foo/border.png'),
        'border_image_slice': ((10, None),),
        'border_image_width': ((4, None),),
        'border_image_outset': ((2, None),),
        'border_image_repeat': (('round', 'stretch')),
    }),
    ('10 // 2', {
        'border_image_slice': ((10, None),),
        'border_image_outset': ((2, None),),
    }),
    ('5.5%', {
        'border_image_slice': ((5.5, '%'),),
    }),
    ('stretch 2 url("border.png")', {
        'border_image_source': ('url', 'https://weasyprint.org/foo/border.png'),
        'border_image_slice': ((2, None),),
        'border_image_repeat': (('stretch',)),
    }),
    ('1/2 round', {
        'border_image_slice': ((1, None),),
        'border_image_width': ((2, None),),
        'border_image_repeat': (('round',)),
    }),
    ('none', {
        'border_image_source': ('none', None),
    }),
])
def test_border_image(rule, result):
    assert expand_to_dict(f'border-image: {rule}') == result


@assert_no_logs
@pytest.mark.parametrize(('rule', 'reason'), [
    ('url(border.png) url(border.png)', 'multiple source'),
    ('10 10 10 10 10', 'multiple slice'),
    ('1 / 2 / 3 / 4', 'invalid'),
    ('/1', 'invalid'),
    ('round round round', 'invalid'),
    ('-1', 'invalid'),
    ('1 repeat 2', 'multiple slice'),
    ('1% // 1%', 'invalid'),
    ('1 / repeat', 'invalid'),
    ('', 'no value'),
])
def test_border_image_invalid(rule, reason):
    assert_invalid(f'border-image: {rule}', reason)


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('url(border.png) 27', {
        'mask_border_source': ('url', 'https://weasyprint.org/foo/border.png'),
        'mask_border_slice': ((27, None),),
    }),
    ('url(border.png) 10 / 4 / 2 round stretch', {
        'mask_border_source': ('url', 'https://weasyprint.org/foo/border.png'),
        'mask_border_slice': ((10, None),),
        'mask_border_width': ((4, None),),
        'mask_border_outset': ((2, None),),
        'mask_border_repeat': (('round', 'stretch')),
    }),
    ('10 // 2', {
        'mask_border_slice': ((10, None),),
        'mask_border_outset': ((2, None),),
    }),
    ('5.5%', {
        'mask_border_slice': ((5.5, '%'),),
    }),
    ('stretch 2 url("border.png")', {
        'mask_border_source': ('url', 'https://weasyprint.org/foo/border.png'),
        'mask_border_slice': ((2, None),),
        'mask_border_repeat': (('stretch',)),
    }),
    ('1/2 round', {
        'mask_border_slice': ((1, None),),
        'mask_border_width': ((2, None),),
        'mask_border_repeat': (('round',)),
    }),
    ('none', {
        'mask_border_source': ('none', None),
    }),
    ('url(border.png) 27 alpha', {
        'mask_border_source': ('url', 'https://weasyprint.org/foo/border.png'),
        'mask_border_slice': ((27, None),),
        'mask_border_mode': 'alpha',
    }),
    ('url(border.png) 27 luminance', {
        'mask_border_source': ('url', 'https://weasyprint.org/foo/border.png'),
        'mask_border_slice': ((27, None),),
        'mask_border_mode': 'luminance',
    }),
])
def test_mask_border(rule, result):
    assert expand_to_dict(f'mask-border: {rule}') == result


@assert_no_logs
@pytest.mark.parametrize(('rule', 'reason'), [
    ('url(border.png) url(border.png)', 'multiple source'),
    ('10 10 10 10 10', 'multiple slice'),
    ('1 / 2 / 3 / 4', 'invalid'),
    ('/1', 'invalid'),
    ('round round round', 'invalid'),
    ('-1', 'invalid'),
    ('1 repeat 2', 'multiple slice'),
    ('1% // 1%', 'invalid'),
    ('1 / repeat', 'invalid'),
    ('', 'no value'),
    ('alpha alpha', 'multiple mode'),
    ('alpha luminance', 'multiple mode'),
])
def test_mask_border_invalid(rule, reason):
    assert_invalid(f'mask-border: {rule}', reason)


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('12px My Fancy Font, serif', {
        'font_size': (12, 'px'),
        'font_family': ('My Fancy Font', 'serif'),
    }),
    ('small/1.2 "Some Font", serif', {
        'font_size': 'small',
        'line_height': (1.2, None),
        'font_family': ('Some Font', 'serif'),
    }),
    ('small-caps italic 700 large serif', {
        'font_style': 'italic',
        'font_variant_caps': 'small-caps',
        'font_weight': 700,
        'font_size': 'large',
        'font_family': ('serif',),
    }),
    ('small-caps condensed normal 700 large serif', {
        'font_stretch': 'condensed',
        'font_variant_caps': 'small-caps',
        'font_weight': 700,
        'font_size': 'large',
        'font_family': ('serif',),
    }),
])
def test_font(rule, result):
    assert expand_to_dict(f'font: {rule}') == result


@assert_no_logs
@pytest.mark.parametrize(('rule', 'message'), [
    ('menu', 'System fonts are not supported'),
    ('12deg My Fancy Font, serif', 'invalid'),
    ('12px', 'invalid'),
    ('12px/foo serif', 'invalid'),
    ('12px "Invalid" family', 'invalid'),
    ('normal normal normal normal normal large serif', 'invalid'),
    ('normal small-caps italic 700 condensed large serif', 'invalid'),
    ('small-caps italic 700 normal condensed large serif', 'invalid'),
    ('small-caps italic 700 condensed normal large serif', 'invalid'),
    ('normal normal normal normal', 'invalid'),
    ('normal normal normal italic', 'invalid'),
    ('caption', 'System fonts'),
])
def test_font_invalid(rule, message):
    assert_invalid(f'font: {rule}', message)


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('normal', {
        'font_variant_alternates': 'normal',
        'font_variant_caps': 'normal',
        'font_variant_east_asian': 'normal',
        'font_variant_ligatures': 'normal',
        'font_variant_numeric': 'normal',
        'font_variant_position': 'normal',
    }),
    ('none', {
        'font_variant_alternates': 'normal',
        'font_variant_caps': 'normal',
        'font_variant_east_asian': 'normal',
        'font_variant_ligatures': 'none',
        'font_variant_numeric': 'normal',
        'font_variant_position': 'normal',
    }),
    ('historical-forms petite-caps', {
        'font_variant_alternates': 'historical-forms',
        'font_variant_caps': 'petite-caps',
    }),
    ('lining-nums contextual small-caps common-ligatures', {
        'font_variant_ligatures': ('contextual', 'common-ligatures'),
        'font_variant_numeric': ('lining-nums',),
        'font_variant_caps': 'small-caps',
    }),
    ('jis78 ruby proportional-width', {
        'font_variant_east_asian': ('jis78', 'ruby', 'proportional-width'),
    }),
    # CSS2-style font-variant
    ('small-caps', {'font_variant_caps': 'small-caps'}),
])
def test_font_variant(rule, result):
    assert expand_to_dict(f'font-variant: {rule}') == result


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'normal normal',
    '2',
    '""',
    'extra',
    'jis78 jis04',
    'full-width lining-nums ordinal normal',
    'diagonal-fractions stacked-fractions',
    'common-ligatures contextual no-common-ligatures',
    'sub super',
    'slashed-zero slashed-zero',
])
def test_font_variant_invalid(rule):
    assert_invalid(f'font-variant: {rule}')


@assert_no_logs
def test_word_wrap():
    assert expand_to_dict('word-wrap: normal') == {
        'overflow_wrap': 'normal'}
    assert expand_to_dict('word-wrap: break-word') == {
        'overflow_wrap': 'break-word'}
    assert expand_to_dict('word-wrap: inherit') == {
        'overflow_wrap': 'inherit'}
    assert_invalid('word-wrap: none')
    assert_invalid('word-wrap: normal, break-word')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('auto', {'flex_grow': 1, 'flex_shrink': 1, 'flex_basis': 'auto'}),
    ('none', {'flex_grow': 0, 'flex_shrink': 0, 'flex_basis': 'auto'}),
    ('10', {'flex_grow': 10, 'flex_shrink': 1, 'flex_basis': ZERO_PIXELS}),
    ('2 2', {'flex_grow': 2, 'flex_shrink': 2, 'flex_basis': ZERO_PIXELS}),
    ('2 2 1px', {'flex_grow': 2, 'flex_shrink': 2, 'flex_basis': (1, 'px')}),
    ('2 2 auto', {'flex_grow': 2, 'flex_shrink': 2, 'flex_basis': 'auto'}),
    ('2 auto', {'flex_grow': 2, 'flex_shrink': 1, 'flex_basis': 'auto'}),
    ('0 auto', {'flex_grow': 0, 'flex_shrink': 1, 'flex_basis': 'auto'}),
    ('inherit', {
        'flex_grow': 'inherit',
        'flex_shrink': 'inherit',
        'flex_basis': 'inherit'}),
])
def test_flex(rule, result):
    assert expand_to_dict(f'flex: {rule}') == result


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'auto 0 0 0',
    '1px 2px',
    'auto auto',
    'auto 1 auto',
])
def test_flex_invalid(rule):
    assert_invalid(f'flex: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('column', {'flex_direction': 'column'}),
    ('wrap', {'flex_wrap': 'wrap'}),
    ('wrap column', {'flex_direction': 'column', 'flex_wrap': 'wrap'}),
    ('row wrap', {'flex_direction': 'row', 'flex_wrap': 'wrap'}),
    ('inherit', {'flex_direction': 'inherit', 'flex_wrap': 'inherit'}),
])
def test_flex_flow(rule, result):
    assert expand_to_dict(f'flex-flow: {rule}') == result


@assert_no_logs
@pytest.mark.parametrize('rule', [
    '1px',
    'wrap 1px',
    'row row',
    'wrap nowrap',
    'column wrap nowrap row',
])
def test_flex_flow_invalid(rule):
    assert_invalid(f'flex-flow: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('auto', {'start': 'auto', 'end': 'auto'}),
    ('auto / auto', {'start': 'auto', 'end': 'auto'}),
    ('4', {'start': (None, 4, None), 'end': 'auto'}),
    ('c', {'start': (None, None, 'c'), 'end': (None, None, 'c')}),
    ('4 / -4', {'start': (None, 4, None), 'end': (None, -4, None)}),
    ('c / d', {'start': (None, None, 'c'), 'end': (None, None, 'd')}),
    ('ab / cd 4', {'start': (None, None, 'ab'), 'end': (None, 4, 'cd')}),
    ('ab 2 span', {'start': ('span', 2, 'ab'), 'end': 'auto'}),
])
def test_grid_column_row(rule, result):
    assert expand_to_dict(f'grid-column: {rule}') == dict(
        (f'grid_column_{key}', value) for key, value in result.items())
    assert expand_to_dict(f'grid-row: {rule}') == dict(
        (f'grid_row_{key}', value) for key, value in result.items())


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'auto auto',
    '4 / 2 / c',
    'span',
    '4 / span',
    'c /',
    '/4',
    'col / 2.1',
])
def test_grid_column_row_invalid(rule):
    assert_invalid(f'grid-column: {rule}')
    assert_invalid(f'grid-row: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('auto', {
        'row_start': 'auto', 'row_end': 'auto',
        'column_start': 'auto', 'column_end': 'auto'}),
    ('auto / auto', {
        'row_start': 'auto', 'row_end': 'auto',
        'column_start': 'auto', 'column_end': 'auto'}),
    ('auto / auto / auto', {
        'row_start': 'auto', 'row_end': 'auto',
        'column_start': 'auto', 'column_end': 'auto'}),
    ('auto / auto / auto / auto', {
        'row_start': 'auto', 'row_end': 'auto',
        'column_start': 'auto', 'column_end': 'auto'}),
    ('1/c/2 d/span 2 ab', {
        'row_start': (None, 1, None), 'column_start': (None, None, 'c'),
        'row_end': (None, 2, 'd'), 'column_end': ('span', 2, 'ab')}),
    ('1  /  c', {
        'row_start': (None, 1, None), 'column_start': (None, None, 'c'),
        'row_end': 'auto', 'column_end': (None, None, 'c')}),
    ('a / c 2', {
        'row_start': (None, None, 'a'), 'column_start': (None, 2, 'c'),
        'row_end': (None, None, 'a'), 'column_end': 'auto'}),
    ('a', {
        'row_start': (None, None, 'a'), 'row_end': (None, None, 'a'),
        'column_start': (None, None, 'a'), 'column_end': (None, None, 'a')}),
    ('span 2', {
        'row_start': ('span', 2, None), 'row_end': 'auto',
        'column_start': 'auto', 'column_end': 'auto'}),
])
def test_grid_area(rule, result):
    assert expand_to_dict(f'grid-area: {rule}') == dict(
        (f'grid_{key}', value) for key, value in result.items())


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'auto auto',
    'auto / auto auto',
    '4 / 2 / c / d / e',
    'span',
    '4 / span',
    'c /',
    '/4',
    'c//4',
    '/',
    '1 / 2 / 4 / 0.5',
])
def test_grid_area_invalid(rule):
    assert_invalid(f'grid-area: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('none', {
        'rows': 'none', 'columns': 'none', 'areas': 'none',
    }),
    ('subgrid / [outer-edge] 20px [main-start]', {
        'rows': ('subgrid', ()),
        'columns': (('outer-edge',), (20, 'px'), ('main-start',)),
        'areas': 'none',
    }),
    ('repeat(2, [e] 40px) repeat(5, auto) / subgrid [a] repeat(auto-fill, [b])', {
        'rows': (
            (), ('repeat()', 2, (('e',), (40, 'px'), ())), (),
            ('repeat()', 5, ((), 'auto', ())), ()),
        'columns': ('subgrid', (('a',), ('repeat()', 'auto-fill', (('b',),)))),
        'areas': 'none',
    }),
    # TODO: support last syntax
    # ('[a b] "x y y" [c] [d] "x y y" 1fr [e] / auto 2fr auto', {
    #     'rows': 'none', 'columns': 'none', 'areas': 'none',
    # }),
    # ('[a b c] "x x x" 2fr', {
    #     'rows': 'none', 'columns': 'none', 'areas': 'none',
    # }),
])
def test_grid_template(rule, result):
    assert expand_to_dict(f'grid-template: {rule}') == dict(
        (f'grid_template_{key}', value) for key, value in result.items())


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none none',
    'auto',
    'subgrid / subgrid / subgrid',
    '[a] 1px [b] / none /',
    '[a] 1px [b] // none',
    '[a] 1px [b] none',
])
def test_grid_template_invalid(rule):
    assert_invalid(f'grid-template: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('none', {
        'template_rows': 'none', 'template_columns': 'none',
        'template_areas': 'none',
        'auto_rows': ('auto',), 'auto_columns': ('auto',),
        'auto_flow': ('row',),
    }),
    ('subgrid / [outer-edge] 20px [main-start]', {
        'template_rows': ('subgrid', ()),
        'template_columns': (('outer-edge',), (20, 'px'), ('main-start',)),
        'template_areas': 'none',
        'auto_rows': ('auto',), 'auto_columns': ('auto',),
        'auto_flow': ('row',),
    }),
    ('repeat(2, [e] 40px) repeat(5, auto) / subgrid [a] repeat(auto-fill, [b])', {
        'template_rows': (
            (), ('repeat()', 2, (('e',), (40, 'px'), ())), (),
            ('repeat()', 5, ((), 'auto', ())), ()),
        'template_columns': ('subgrid', (('a',), ('repeat()', 'auto-fill', (('b',),)))),
        'template_areas': 'none',
        'auto_rows': ('auto',), 'auto_columns': ('auto',),
        'auto_flow': ('row',),
    }),
    ('auto-flow 1fr / 100px', {
        'template_rows': 'none', 'template_columns': ((), (100, 'px'), ()),
        'template_areas': 'none',
        'auto_rows': ((1, 'fr'),), 'auto_columns': ('auto',),
        'auto_flow': ('row',),
    }),
    ('none / dense auto-flow 1fr', {
        'template_rows': 'none', 'template_columns': 'none',
        'template_areas': 'none',
        'auto_rows': ('auto',), 'auto_columns': ((1, 'fr'),),
        'auto_flow': ('column', 'dense'),
    }),
    # TODO: support last grid-template syntax
    # ('[a b] "x y y" [c] [d] "x y y" 1fr [e] / auto 2fr auto', {
    # }),
    # ('[a b c] "x x x" 2fr', {
    # }),
])
def test_grid(rule, result):
    assert expand_to_dict(f'grid: {rule}') == dict(
        (f'grid_{key}', value) for key, value in result.items())


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none none',
    'auto',
    'subgrid / subgrid / subgrid',
    '[a] 1px [b] / none /',
    '[a] 1px [b] // none',
    '[a] 1px [b] none',
    'none / auto-flow 1fr dense',
    'none / dense 1fr auto-flow',
    '100px auto-flow / none',
    'dense 100px / auto-flow 1fr'
])
def test_grid_invalid(rule):
    assert_invalid(f'grid: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('page-break-after: left', {'break_after': 'left'}),
    ('page-break-before: always', {'break_before': 'page'}),
    ('page-break-after: inherit', {'break_after': 'inherit'}),
    ('page-break-before: inherit', {'break_before': 'inherit'}),
])
def test_page_break(rule, result):
    assert expand_to_dict(rule) == result


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'page-break-after: top',
    'page-break-before: 1px',
])
def test_page_break_invalid(rule):
    assert_invalid(rule)


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('avoid', {'break_inside': 'avoid'}),
    ('inherit', {'break_inside': 'inherit'}),
])
def test_page_break_inside(rule, result):
    assert expand_to_dict(f'page-break-inside: {rule}') == result


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'top',
])
def test_page_break_inside_invalid(rule):
    assert_invalid(f'page-break-inside: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('1em', {'column_width': (1, 'em'), 'column_count': 'auto'}),
    ('auto', {'column_width': 'auto', 'column_count': 'auto'}),
    ('auto auto', {'column_width': 'auto', 'column_count': 'auto'}),
])
def test_columns(rule, result):
    assert expand_to_dict(f'columns: {rule}') == result


@assert_no_logs
@pytest.mark.parametrize(('rule', 'reason'), [
    ('1px 2px', 'invalid'),
    ('auto auto auto', 'multiple'),
])
def test_columns_invalid(rule, reason):
    assert_invalid(f'columns: {rule}', reason)


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('none', {
        'max_lines': 'none', 'continue': 'auto', 'block_ellipsis': 'none'}),
    ('2', {
        'max_lines': 2, 'continue': 'discard', 'block_ellipsis': 'auto'}),
    ('3 "…"', {
        'max_lines': 3, 'continue': 'discard',
        'block_ellipsis': ('string', '…')}),
    ('inherit', {
        'max_lines': 'inherit', 'continue': 'inherit',
        'block_ellipsis': 'inherit'}),
])
def test_line_clamp(rule, result):
    assert expand_to_dict(f'line-clamp: {rule}') == result


@assert_no_logs
@pytest.mark.parametrize(('rule', 'reason'), [
    ('none none none', 'invalid'),
    ('1px', 'invalid'),
    ('0 "…"', 'invalid'),
    ('1px 2px', 'invalid'),
])
def test_line_clamp_invalid(rule, reason):
    assert_invalid(f'line-clamp: {rule}', reason)


@assert_no_logs
@pytest.mark.parametrize(('rule', 'result'), [
    ('start', {'text_align_all': 'start', 'text_align_last': 'start'}),
    ('right', {'text_align_all': 'right', 'text_align_last': 'right'}),
    ('justify', {'text_align_all': 'justify', 'text_align_last': 'start'}),
    ('justify-all', {
        'text_align_all': 'justify', 'text_align_last': 'justify'}),
    ('inherit', {'text_align_all': 'inherit', 'text_align_last': 'inherit'}),
])
def test_text_align(rule, result):
    assert expand_to_dict(f'text-align: {rule}') == result


@assert_no_logs
@pytest.mark.parametrize(('rule', 'reason'), [
    ('none', 'invalid'),
    ('start end', 'invalid'),
    ('1', 'invalid'),
    ('left left', 'invalid'),
    ('top', 'invalid'),
    ('"right"', 'invalid'),
    ('1px', 'invalid'),
])
def test_text_align_invalid(rule, reason):
    assert_invalid(f'text-align: {rule}', reason)


================================================
FILE: tests/css/test_fonts.py
================================================
"""Test CSS font-related properties."""

from math import isclose

import pytest

from weasyprint import CSS
from weasyprint.css import get_all_computed_styles
from weasyprint.text.line_break import strut

from ..testing_utils import FakeHTML, assert_no_logs, render_pages


@assert_no_logs
@pytest.mark.parametrize(('parent_css', 'parent_size', 'child_css', 'child_size'), [
    ('10px', 10, '10px', 10),
    ('x-small', 12, 'xx-large', 32),
    ('x-large', 24, '2em', 48),
    ('1em', 16, '1em', 16),
    ('1em', 16, 'larger', 6 / 5 * 16),
    ('medium', 16, 'larger', 6 / 5 * 16),
    ('x-large', 24, 'larger', 32),
    ('xx-large', 32, 'larger', 1.2 * 32),
    ('1px', 1, 'larger', 3 / 5 * 16),
    ('28px', 28, 'larger', 32),
    ('100px', 100, 'larger', 120),
    ('xx-small', 3 / 5 * 16, 'larger', 12),
    ('1em', 16, 'smaller', 8 / 9 * 16),
    ('medium', 16, 'smaller', 8 / 9 * 16),
    ('x-large', 24, 'smaller', 6 / 5 * 16),
    ('xx-large', 32, 'smaller', 24),
    ('xx-small', 3 / 5 * 16, 'smaller', 0.8 * 3 / 5 * 16),
    ('1px', 1, 'smaller', 0.8),
    ('28px', 28, 'smaller', 24),
    ('100px', 100, 'smaller', 32),
])
def test_font_size(parent_css, parent_size, child_css, child_size):
    document = FakeHTML(string='<p>a<span>b')
    style_for = get_all_computed_styles(document, user_stylesheets=[CSS(
        string='p{font-size:%s}span{font-size:%s}' % (parent_css, child_css))])

    _head, body = document.etree_element
    p, = body
    span, = p
    assert isclose(style_for(p)['font_size'], parent_size)
    assert isclose(style_for(span)['font_size'], child_size)


@assert_no_logs
def test_line_height_inheritance():
    page, = render_pages('''
      <style>
        html { font-size: 10px; line-height: 140% }
        section { font-size: 10px; line-height: 1.4 }
        div, p { font-size: 20px; vertical-align: 50% }
      </style>
      <body><div><section><p></p></section></div></body>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    section, = div.children
    paragraph, = section.children
    assert html.style['font_size'] == 10
    assert div.style['font_size'] == 20
    # 140% of 10px = 14px is inherited from html
    assert strut(div.style)[0] == 14
    assert div.style['vertical_align'] == 7  # 50 % of 14px

    assert paragraph.style['font_size'] == 20
    # 1.4 is inherited from p, 1.4 * 20px on em = 28px
    assert strut(paragraph.style)[0] == 28
    assert paragraph.style['vertical_align'] == 14  # 50% of 28px


================================================
FILE: tests/css/test_layers.py
================================================
"""Test CSS layers."""

import pytest

from ..testing_utils import assert_no_logs, render_pages


@assert_no_logs
@pytest.mark.parametrize('style', [
    '@layer { div { width: 100px } }',
    '@layer a { div { width: 100px } }',
    '''
    div { width: 100px }
    @layer a { div { width: 200px } }
    ''',
    '''
    @layer { div { width: 200px } }
    @layer a { div { width: 100px } }
    ''',
    '''
    @layer a { div { width: 200px } }
    @layer { div { width: 100px } }
    ''',
    '''
    @layer a { div { width: 200px } }
    @layer a { div { width: 100px } }
    ''',
    '''
    @layer a { div { width: 100px } }
    @layer a.b { div { width: 200px } }
    ''',
    '''
    @layer a.b { div { width: 200px } }
    @layer a { div { width: 100px } }
    ''',
    '''
    @layer a { div { width: 200px } }
    @layer b { div { width: 100px } }
    ''',
    '''
    @layer b, a;
    @layer a { div { width: 100px } }
    @layer b { div { width: 200px } }
    ''',
    '''
    @layer b;
    @layer a { div { width: 100px } }
    @layer b { div { width: 200px } }
    ''',
    '''
    @import url(data:text/css,div{width:100px});
    @layer a { div { width: 200px } }
    ''',
    '''
    @import url(data:text/css,div{width:200px}) layer;
    @layer a { div { width: 100px } }
    ''',
    '''
    @import url(data:text/css,div{width:200px}) layer(b);
    @layer a { div { width: 100px } }
    ''',
    '''
    @import url(data:text/css,div{width:100px}) layer(a);
    @layer a.b { div { width: 200px } }
    ''',
    '''
    @import url(data:text/css,div{width:200px}) layer(a.b);
    @layer a { div { width: 100px } }
    ''',
    '''
    @layer a { div { width: 100px } }
    @import url(data:text/css,div{width:200px}) layer(a.b);
    ''',
])
def test_layers(style):
    page, = render_pages('''
      <style>
        %s
      </style>
      <div>abc</div>
    ''' % style)
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.width == 100


================================================
FILE: tests/css/test_math.py
================================================
"""Test CSS math functions."""

from math import isclose

import pytest

from weasyprint.css.validation.properties import PROPERTIES

from ..testing_utils import assert_no_logs, capture_logs, render_pages


@assert_no_logs
@pytest.mark.parametrize('width', [
    'calc(100px)',
    'calc(10em)',
    'calc(50vw)',
    'calc(20pvh)',
    'calc(50%)',
    'calc(10px + 90px)',
    'calc(5em + 50px)',
    'calc(2 * 5em)',
    'calc(2 * (3em + 20px))',
    'calc(25% * (1 + 1))',
    'calc(20% * (1 + 1) + 20px)',
    'calc(100px',
    'max(100px)',
    'max(30%, 2em, 100px)',
    'max(-30%, -2em, 10em)',
    'calc(max(-1, 1, 2) * 50px)',
    'min(100px)',
    'min(100%, 20em, 100px)',
    'calc(min(4, 2) * 50px)',
    'calc(sqrt(4) * 50px)',
    'calc(pow(2, 2) * 25px)',
    'calc(hypot(2) * 50px)',
    'calc(hypot(3, 4) * 20px)',
    'calc(hypot(2px) * 50)',
    'calc(hypot(3px, 4px) * 20)',
    'calc(log(e) * 100px)',
    'calc(log(100, 10) * 50px)',
    'calc(exp(1) / e * 100px)',
    'abs(-100px)',
    'calc(abs(-100) * 1px)',
    'calc(sign(-100) * -100px)',
    'calc(sign(-100px) * -100px)',
    'calc(sqrt(16) * min(25px, 100%))',
    'clamp(calc(-infinity * 1px), 10em, calc(infinity * 1px))',
    'clamp(50px, 10em, 500px)',
    'clamp(100px, 2em, 500px)',
    'clamp(10px, 100em, 10em)',
    'clamp(10px, 100%, 10em)',
    'round(100.4px)',
    'round(145.4px, 100px)',
    'round(nearest, 100px)',
    'round(down, 195px, 100px)',
    'round(up, 5px, 100px)',
    'round(to-zero, 195px, 100px)',
    'mod(300px, 200px)',
    'calc(mod(300px, -200px) * -1)',
    'calc(mod(-300px, -200px) * -1)',
    'rem(300px, 200px)',
    'rem(300px, -200px)',
    'calc(rem(-300px, -200px) * -1)',
    'calc(sin(30deg) * 200px)',
    'calc(cos(60deg) * 200px)',
    'calc(tan(45deg) * 100px)',
    'calc(tan(calc(pi / 4)) * 100px)',
    'calc(sin(asin(0.5)) * 200px)',
    'calc(cos(acos(0.5)) * 200px)',
    'calc(tan(atan(1)) * 100px)',
    'calc(tan(atan2(1, 1)) * 100px)',
    'calc(100px * var(--one))',
    'calc(50% * var(--one))',
    'calc(100px * sqrt(var(--one)))',
])
def test_math_functions(width):
    page, = render_pages('''
      <style>
        @page { size: 400px 500px; margin: 100px }
        body { font-size: 10px; width: 200px }
      </style>
      <div style="--one: 1; height: 1px; width: %s"></div>
    ''' % width)
    html, = page.children
    body, = html.children
    div, = body.children
    assert isclose(div.width, 100)


@assert_no_logs
@pytest.mark.parametrize('width', [
    'calc',
    '(calc)',
    'calc(',
    'calc()',
    'calc("100px")',
    'calc(100)',
    'calc(100px 100px)',
    'calc(100px, 100px)',
    'calc(100px * 100px)',
    'calc(100 * 100)',
    'calc(calc(100unknown))',
    'calc(0.1)',
    'calc(-1)',
    'min()',
    'min(10)',
    'min("10px")',
    'min(10, 5px)',
    'calc(min(1, 5px) * 10px)',
    'max()',
    'max(10)',
    'max("10px")',
    'max(10, 50px)',
    'calc(max(100, 5px) * 10px)',
    'calc(100* - max(56px, 1rem)',
    'clamp()',
    'clamp(10px)',
    'clamp(10px, 50px)',
    'clamp(10px, 50px, 100px, 200px)',
    'clamp(10px, "50px", 100px)',
    'round()',
    'round(100)',
    'round(100, 10)',
    'round(nearest, 100, 10)',
    'round(100px, 10)',
    'round(100px, "10px")',
    'round(nearest, 100px, 10)',
    'round(100px, 10px, 1)',
    'round(nearest, 100px, 10px, 1)',
    'round(unknown, 100px)',
    'round(unknown, 100px, 10px)',
    'mod()',
    'mod(10px)',
    'mod(100px, 10)',
    'mod(100px, "10px")',
    'calc(mod(300px, 200) * -1)',
    'mod(100px, 10px, 1px)',
    'rem()',
    'rem(10px)',
    'rem(100px, 10)',
    'rem(100px, "10px")',
    'calc(rem(300px, 200) * -1)',
    'rem(100px, 10px, 1px)',
    'sin()',
    'sin(10)',
    'sin(10%)',
    'sin(10deg)',
    'calc(sin(10) * 1)',
    'cos()',
    'cos(10)',
    'cos(10%)',
    'cos(10deg)',
    'calc(cos(10) * 1)',
    'tan()',
    'tan(10)',
    'tan(10%)',
    'tan(10deg)',
    'calc(tan(10) * 1)',
    'asin()',
    'asin(0)',
    'asin(0.5)',
    'asin(50deg)',
    'calc(sin(asin(50deg)) * 200px)',
    'calc(sin(asin(0.5)) * 200)',
    'calc(sin(asin(0.5, 2)) * 200px)',
    'calc(sin(asin(5)) * 200px)',
    'acos()',
    'acos(0)',
    'acos(0.5)',
    'acos(50deg)',
    'calc(cos(acos(50deg)) * 200px)',
    'calc(cos(acos(0.5)) * 200)',
    'calc(cos(acos(0.5, 2)) * 200px)',
    'calc(cos(acos(5)) * 200px)',
    'atan()',
    'atan(0)',
    'atan(0.5)',
    'atan(50deg)',
    'calc(tan(atan(50deg)) * 200px)',
    'calc(tan(atan(0.5)) * 200)',
    'calc(tan(atan(0.5, 2)) * 200px)',
    'atan2()',
    'atan2(0.5)',
    'atan2(0.5, 1)',
    'atan2(50deg, 1)',
    'calc(tan(atan2(50deg, 1)) * 200px)',
    'calc(tan(atan2(0.5, 1)) * 200)',
    'pow()',
    'pow(4, 3)',
    'pow(4px, 3)',
    'pow(4, 3, 4)',
    'sqrt()',
    'sqrt(4)',
    'sqrt(4px)',
    'sqrt(4, 2)',
    'hypoth()',
    'hypoth(3)',
    'hypoth(3, 4)',
    'log()',
    'log(10)',
    'log(10px)',
    'log(10, 10)',
    'log(10px, 10)',
    'log(10, 10, 10)',
    'exp()',
    'exp(10)',
    'exp(10px)',
    'exp(10, 10)',
    'exp(10px, 10)',
    'exp(10, 10, 10)',
    'abs()',
    'abs(10)',
    'abs(10px, 100)',
    'sign()',
    'sign(10)',
    'sign(10px)',
    'sign(10px, 10)',
])
def test_math_functions_error(width):
    with capture_logs() as logs:
        page, = render_pages('''
          <style>body { font-size: 10px; width: 200px }</style>
          <div style="--one: 1; height: 1px; width: %s"></div>
        ''' % width)
    assert len(logs) == 1


@pytest.mark.parametrize('css_property', PROPERTIES)
def test_math_functions_percentage_and_font_unit(css_property):
    with capture_logs() as math_logs:
        render_pages(f'''
          <div style="{css_property}: calc(50% + 1em)"></div>
        ''')
    with capture_logs() as logs:
        render_pages(f'''
          <div style="{css_property}: 50%"></div>
        ''')
        if not logs:
            # Happens when property accepts percentages but not lengths.
            render_pages(f'''
              <div style="{css_property}: 1em"></div>
            ''')
    assert len(math_logs) == len(logs)


@pytest.mark.parametrize('display', [
    'block', 'inline', 'flex', 'grid',
    'list', 'list-item',
    'table', 'table-row-group', 'table-cell',
    'inline-block', 'inline-table', 'inline-flex', 'inline-grid',
])
def test_math_functions_display_size(display):
    # Regression test for #2673.
    render_pages(f'''
    <div style="display: {display};
     min-width: calc(50% + 1em); max-width: calc(50% + 1em); width: calc(50% + 1em);
     min-height: calc(50% + 1em); max-height: calc(50% + 1em); height: calc(50% + 1em)
    ">
      <div style="
       min-width: calc(50% + 1em); max-width: calc(50% + 1em); width: calc(50% + 1em);
       min-height: calc(50% + 1em); max-height: calc(50% + 1em); height: calc(50% + 1em)
      "></div>
    </div>
    ''')


@assert_no_logs
def test_math_functions_hyphenate():
    render_pages('''
      <div lang="en"
        style="hyphens: auto; hyphenate-limit-zone: calc(1em + 100%); width: 2em">
        absolute
      </div>
    ''')


@assert_no_logs
def test_math_functions_gradient():
    render_pages('''
      <div style="width: 10px; height: 10px; background: linear-gradient(
        blue calc(20% + 1em),
        red calc(80% + 1em))"></div>
    ''')


@pytest.mark.xfail
@assert_no_logs
def test_math_functions_color():
    render_pages('''
      <div style="width: 10px; height: 10px;
                  background: rgba(10, 20, calc(30), calc(80%))"></div>
    ''')


@pytest.mark.xfail
@assert_no_logs
def test_math_functions_gradient_color():
    render_pages('''
      <div style="width: 10px; height: 10px; background: linear-gradient(
        rgba(10, 20, calc(30), calc(80%)) 10%,
        hsl(calc(10 + 10), 20%, 20%) 80%"></div>
    ''')


@assert_no_logs
def test_math_image_min_content_calc():
    render_pages('''
      <table>
        <td>
          <img src="pattern.png" style="
            height: calc(10% + 1em);
            width: calc(10% + 1em);
            max-height: calc(10% + 1em);
            max-width: calc(10% + 1em);
            min-height: calc(10% + 1em);
            min-width: calc(10% + 1em);
          ">
    ''')


@assert_no_logs
def test_math_image_min_content_auto_width_calc():
    render_pages('''
      <table>
        <td>
          <img src="pattern.png" style="
            height: calc(10% + 1em);
            max-height: calc(10% + 1em);
            max-width: calc(10% + 1em);
            min-height: calc(10% + 1em);
            min-width: calc(10% + 1em);
          ">
    ''')


@assert_no_logs
def test_math_image_min_content_auto_width_height_calc():
    render_pages('''
      <table>
        <td>
          <img src="pattern.png" style="
            max-height: calc(10% + 1em);
            max-width: calc(10% + 1em);
            min-height: calc(10% + 1em);
            min-width: calc(10% + 1em);
          ">
    ''')


@assert_no_logs
def test_math_table_margin():
    render_pages('<table style="margin: calc(1em + 10%)">')


@assert_no_logs
def test_math_grid_padding():
    render_pages('''
      <article style="display: grid">
        <div style="box-sizing: border-box; border: 1px solid;
                    padding: calc(2px + 10%); width: 7px">a</div>
      </article>
    ''')


@assert_no_logs
def test_math_table_column():
    render_pages('''
      <table style="width: 200px">
        <colgroup style="width: calc(1em + 10%)">
          <col />
        </colgroup>
        <col style="width: calc(1em + 10%)" />
        <tbody>
          <tr>
            <td>a</td>
            <td>a</td>
          </tr>
        </tbody>
      </table>
    ''')


================================================
FILE: tests/css/test_nesting.py
================================================
"""Test CSS nesting."""

import pytest

from ..testing_utils import assert_no_logs, render_pages


@assert_no_logs
@pytest.mark.parametrize('style', [
    'div { p { width: 10px } }',
    'p { div & { width: 10px } }',
    'p { width: 20px; div & { width: 10px } }',
    'p { div & { width: 10px } width: 20px }',
    'div { & { & { p { & { width: 10px } } } } }',
    '@media print { div { p { width: 10px } } }',
    'div { em, p { width: 10px } }',
    'p { a, div & { width: 10px } }',
])
def test_nesting_block(style):
    page, = render_pages('''
      <style>%s</style>
      <div><p></p></div><p></p>
    ''' % style)
    html, = page.children
    body, = html.children
    div, p = body.children
    div_p, = div.children
    assert div_p.width == 10
    assert p.width != 10


================================================
FILE: tests/css/test_pages.py
================================================
"""Test CSS pages."""

import pytest
import tinycss2

from weasyprint import CSS
from weasyprint.css import get_all_computed_styles, parse_page_selectors
from weasyprint.layout.page import PageType, set_page_type_computed_styles

from ..testing_utils import FakeHTML, assert_no_logs, render_pages, resource_path


@assert_no_logs
def test_page():
    document = FakeHTML(resource_path('doc1.html'))
    style_for = get_all_computed_styles(
        document, user_stylesheets=[CSS(string='''
          html { color: red }
          @page { margin: 10px }
          @page :right {
            color: blue;
            margin-bottom: 12pt;
            font-size: 20px;
            @top-left { width: 10em }
            @top-right { font-size: 10px}
          }
        ''')])

    page_type = PageType(side='left', blank=False, name='', index=0, groups=())
    set_page_type_computed_styles(page_type, document, style_for)
    style = style_for(page_type)
    assert style['margin_top'] == (5, 'px')
    assert style['margin_left'] == (10, 'px')
    assert style['margin_bottom'] == (10, 'px')
    assert style['color'] == (1, 0, 0, 1)  # red, inherited from html

    page_type = PageType(side='right', blank=False, name='', index=0, groups=())
    set_page_type_computed_styles(page_type, document, style_for)
    style = style_for(page_type)
    assert style['margin_top'] == (5, 'px')
    assert style['margin_left'] == (10, 'px')
    assert style['margin_bottom'] == (16, 'px')
    assert style['color'] == (0, 0, 1, 1)  # blue

    page_type = PageType(side='left', blank=False, name='', index=1, groups=())
    set_page_type_computed_styles(page_type, document, style_for)
    style = style_for(page_type)
    assert style['margin_top'] == (10, 'px')
    assert style['margin_left'] == (10, 'px')
    assert style['margin_bottom'] == (10, 'px')
    assert style['color'] == (1, 0, 0, 1)  # red, inherited from html

    page_type = PageType(side='right', blank=False, name='', index=1, groups=())
    set_page_type_computed_styles(page_type, document, style_for)
    style = style_for(page_type)
    assert style['margin_top'] == (10, 'px')
    assert style['margin_left'] == (10, 'px')
    assert style['margin_bottom'] == (16, 'px')
    assert style['color'] == (0, 0, 1, 1)  # blue

    page_type = PageType(side='left', blank=False, name='', index=0, groups=())
    set_page_type_computed_styles(page_type, document, style_for)
    style = style_for(page_type, '@top-left')
    assert style is None

    page_type = PageType(side='right', blank=False, name='', index=0, groups=())
    set_page_type_computed_styles(page_type, document, style_for)
    style = style_for(page_type, '@top-left')
    assert style['font_size'] == 20  # inherited from @page
    assert style['width'] == (200, 'px')

    page_type = PageType(side='right', blank=False, name='', index=0, groups=())
    set_page_type_computed_styles(page_type, document, style_for)
    style = style_for(page_type, '@top-right')
    assert style['font_size'] == 10


@assert_no_logs
@pytest.mark.parametrize(('style', 'selectors'), [
    ('@page {}', [{
        'side': None, 'blank': None, 'first': None, 'name': None,
        'index': None, 'specificity': [0, 0, 0]}]),
    ('@page :left {}', [{
        'side': 'left', 'blank': None, 'first': None, 'name': None,
        'index': None, 'specificity': [0, 0, 1]}]),
    ('@page:first:left {}', [{
        'side': 'left', 'blank': None, 'first': True, 'name': None,
        'index': None, 'specificity': [0, 1, 1]}]),
    ('@page pagename {}', [{
        'side': None, 'blank': None, 'first': None, 'name': 'pagename',
        'index': None, 'specificity': [1, 0, 0]}]),
    ('@page pagename:first:right:blank {}', [{
        'side': 'right', 'blank': True, 'first': True, 'name': 'pagename',
        'index': None, 'specificity': [1, 2, 1]}]),
    ('@page pagename, :first {}', [
        {'side': None, 'blank': None, 'first': None, 'name': 'pagename',
         'index': None, 'specificity': [1, 0, 0]},
        {'side': None, 'blank': None, 'first': True, 'name': None,
         'index': None, 'specificity': [0, 1, 0]}]),
    ('@page :first:first {}', [{
        'side': None, 'blank': None, 'first': True, 'name': None,
        'index': None, 'specificity': [0, 2, 0]}]),
    ('@page :left:left {}', [{
        'side': 'left', 'blank': None, 'first': None, 'name': None,
        'index': None, 'specificity': [0, 0, 2]}]),
    ('@page :nth(2) {}', [{
        'side': None, 'blank': None, 'first': None, 'name': None,
        'index': (0, 2, None), 'specificity': [0, 1, 0]}]),
    ('@page :nth(2n + 4) {}', [{
        'side': None, 'blank': None, 'first': None, 'name': None,
        'index': (2, 4, None), 'specificity': [0, 1, 0]}]),
    ('@page :nth(3n) {}', [{
        'side': None, 'blank': None, 'first': None, 'name': None,
        'index': (3, 0, None), 'specificity': [0, 1, 0]}]),
    ('@page :nth( n+2 ) {}', [{
        'side': None, 'blank': None, 'first': None, 'name': None,
        'index': (1, 2, None), 'specificity': [0, 1, 0]}]),
    ('@page :nth(even) {}', [{
        'side': None, 'blank': None, 'first': None, 'name': None,
        'index': (2, 0, None), 'specificity': [0, 1, 0]}]),
    ('@page pagename:nth(2) {}', [{
        'side': None, 'blank': None, 'first': None, 'name': 'pagename',
        'index': (0, 2, None), 'specificity': [1, 1, 0]}]),
    ('@page page page {}', None),
    ('@page :left page {}', None),
    ('@page :left, {}', None),
    ('@page , {}', None),
    ('@page :left, test, {}', None),
    ('@page :wrong {}', None),
    ('@page :left:wrong {}', None),
    ('@page :left:right {}', None),
])
def test_page_selectors(style, selectors):
    at_rule, = tinycss2.parse_stylesheet(style)
    assert parse_page_selectors(at_rule) == selectors


@assert_no_logs
def test_named_pages():
    page, = render_pages('''
      <style>
        @page NARRow { size: landscape }
        div { page: AUTO }
        p { page: NARRow }
      </style>
      <div><p><span>a</span></p></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    p, = div.children
    span, = p.children
    assert html.style['page'] == ''
    assert body.style['page'] == ''
    assert div.style['page'] == ''
    assert p.style['page'] == 'NARRow'
    assert span.style['page'] == 'NARRow'


================================================
FILE: tests/css/test_target.py
================================================
"""Test the CSS cross references using target-*() functions."""

from ..testing_utils import assert_no_logs, render_pages


@assert_no_logs
def test_target_counter():
    page, = render_pages('''
      <style>
        div:first-child { counter-reset: div }
        div { counter-increment: div }
        #id1::before { content: target-counter('#id4', div) }
        #id2::before { content: 'test ' target-counter('#id1', div) }
        #id3::before { content: target-counter(url(#id4), div, lower-roman) }
        #id4::before { content: target-counter('#id3', div) }
      </style>
      <body>
        <div id="id1"></div>
        <div id="id2"></div>
        <div id="id3"></div>
        <div id="id4"></div>
    ''')
    html, = page.children
    body, = html.children
    div1, div2, div3, div4 = body.children
    before = div1.children[0].children[0].children[0]
    assert before.text == '4'
    before = div2.children[0].children[0].children[0]
    assert before.text == 'test 1'
    before = div3.children[0].children[0].children[0]
    assert before.text == 'iv'
    before = div4.children[0].children[0].children[0]
    assert before.text == '3'


@assert_no_logs
def test_target_counter_attr():
    page, = render_pages('''
      <style>
        div:first-child { counter-reset: div }
        div { counter-increment: div }
        div::before { content: target-counter(attr(data-count), div) }
        #id2::before { content: target-counter(attr(data-count url), div) }
        #id4::before {
          content: target-counter(attr(data-count), div, lower-alpha) }
      </style>
      <body>
        <div id="id1" data-count="#id4"></div>
        <div id="id2" data-count="#id1"></div>
        <div id="id3" data-count="#id2"></div>
        <div id="id4" data-count="#id3"></div>
    ''')
    html, = page.children
    body, = html.children
    div1, div2, div3, div4 = body.children
    before = div1.children[0].children[0].children[0]
    assert before.text == '4'
    before = div2.children[0].children[0].children[0]
    assert before.text == '1'
    before = div3.children[0].children[0].children[0]
    assert before.text == '2'
    before = div4.children[0].children[0].children[0]
    assert before.text == 'c'


@assert_no_logs
def test_target_counters():
    page, = render_pages('''
      <style>
        div:first-child { counter-reset: div }
        div { counter-increment: div }
        #id1-2::before { content: target-counters('#id4-2', div, '.') }
        #id2-1::before { content: target-counters(url(#id3), div, '++') }
        #id3::before {
          content: target-counters('#id2-1', div, '.', lower-alpha) }
        #id4-2::before {
          content: target-counters(attr(data-count, url), div, '') }
      </style>
      <body>
        <div id="id1"><div></div><div id="id1-2"></div></div>
        <div id="id2"><div id="id2-1"></div><div></div></div>
        <div id="id3"></div>
        <div id="id4">
          <div></div><div id="id4-2" data-count="#id1-2"></div>
        </div>
    ''')
    html, = page.children
    body, = html.children
    div1, div2, div3, div4 = body.children
    before = div1.children[1].children[0].children[0].children[0]
    assert before.text == '4.2'
    before = div2.children[0].children[0].children[0].children[0]
    assert before.text == '3'
    before = div3.children[0].children[0].children[0]
    assert before.text == 'b.a'
    before = div4.children[1].children[0].children[0].children[0]
    assert before.text == '12'


@assert_no_logs
def test_target_text():
    page, = render_pages('''
      <style>
        a { display: block; color: red }
        div:first-child { counter-reset: div }
        div { counter-increment: div }
        #id2::before { content: 'wow' }
        #link1::before { content: 'test ' target-text('#id4') }
        #link2::before { content: target-text(attr(data-count, url), before) }
        #link3::before { content: target-text('#id3', after) }
        #link4::before { content: target-text(url(#id1), first-letter) }
      </style>
      <body>
        <a id="link1"></a>
        <div id="id1">1 Chapter 1</div>
        <a id="link2" data-count="#id2"></a>
        <div id="id2">2 Chapter 2</div>
        <div id="id3">3 Chapter 3</div>
        <a id="link3"></a>
        <div id="id4">4 Chapter 4</div>
        <a id="link4"></a>
    ''')
    html, = page.children
    body, = html.children
    a1, div1, a2, div2, div3, a3, div4, a4 = body.children
    before = a1.children[0].children[0].children[0]
    assert before.text == 'test 4 Chapter 4'
    before = a2.children[0].children[0].children[0]
    assert before.text == 'wow'
    assert len(a3.children[0].children[0].children) == 0
    before = a4.children[0].children[0].children[0]
    assert before.text == '1'


@assert_no_logs
def test_target_text_whitespace_around_target():
    # Regression test for #1875.
    page, = render_pages('''
      <style>
        a::before { content: target-text(attr(href)) }
      </style>
      <p>before <a href="#ref"></a> after</p>
      <h2 id="ref">text</h2>
    ''')
    html, = page.children
    body, = html.children
    p, h2 = body.children
    line, = p.children
    before, a, after = line.children
    assert before.text == 'before '
    assert after.text == ' after'
    assert a.children[0].children[0].text == 'text'


@assert_no_logs
def test_target_float():
    page, = render_pages('''
      <style>
        a::after {
          content: target-counter('#h', page);
          float: right;
        }
      </style>
      <div><a id="span">link</a></div>
      <h1 id="h">abc</h1>
    ''')
    html, = page.children
    body, = html.children
    div, h1 = body.children
    line, = div.children
    inline, = line.children
    text_box, after = inline.children
    assert text_box.text == 'link'
    assert after.children[0].children[0].text == '1'


@assert_no_logs
def test_target_absolute():
    page, = render_pages('''
      <style>
        a::after {
          content: target-counter('#h', page);
        }
        div {
          position: absolute;
        }
      </style>
      <div><a id="span">link</a></div>
      <h1 id="h">abc</h1>
    ''')
    html, = page.children
    body, = html.children
    div, h1 = body.children
    line, = div.children
    inline, = line.children
    text_box, after = inline.children
    assert text_box.text == 'link'
    assert after.children[0].text == '1'


@assert_no_logs
def test_target_absolute_non_root():
    page, = render_pages('''
      <style>
        a::after {
          content: target-counter('#h', page);
        }
        section {
          position: relative;
        }
        div {
          position: absolute;
        }
      </style>
      <section><div><a id="span">link</a></div></section>
      <h1 id="h">abc</h1>
    ''')
    html, = page.children
    body, = html.children
    section, h1 = body.children
    div, = section.children
    line, = div.children
    inline, = line.children
    text_box, after = inline.children
    assert text_box.text == 'link'
    assert after.children[0].text == '1'


================================================
FILE: tests/css/test_ua.py
================================================
"""Test the user-agent stylesheet."""

import pytest

from weasyprint.html import CSS, HTML5_PH, HTML5_UA, HTML5_UA_FORM

from ..testing_utils import assert_no_logs


@assert_no_logs
@pytest.mark.parametrize('css', [HTML5_UA, HTML5_UA_FORM, HTML5_PH])
def test_ua_stylesheets(css):
    CSS(string=css)


================================================
FILE: tests/css/test_validation.py
================================================
"""Test validation of properties."""

import logging
from math import pi

import pytest
import tinycss2

from weasyprint.css import preprocess_declarations
from weasyprint.css.validation.properties import PROPERTIES
from weasyprint.images import LinearGradient, RadialGradient

from ..testing_utils import assert_no_logs, capture_logs


def get_value(css, expected_error=None, level=None):
    declarations = tinycss2.parse_blocks_contents(css)

    with capture_logs(level=level) as logs:
        base_url = 'https://weasyprint.org/foo/'
        declarations = list(preprocess_declarations(base_url, declarations))

    if expected_error:
        assert len(logs) == 1
        assert expected_error in logs[0]
    else:
        assert not logs

    if declarations:
        assert len(declarations) == 1
        return declarations[0][1]


def get_default_value(values, index, default):
    if index > len(values) - 1:
        return default
    return values[index] or default


def assert_invalid(css, message='invalid', level=None):
    assert get_value(css, message, level) is None


@assert_no_logs
def test_not_print():
    assert_invalid('volume: 42', 'does not apply for the print media', logging.DEBUG)


@assert_no_logs
def test_unstable_prefix():
    assert get_value(
        '-weasy-max-lines: 3',
        'prefixes on unstable attributes are deprecated') == 3


@assert_no_logs
def test_normal_prefix():
    assert_invalid(
        '-weasy-display: block', 'prefix on this attribute is not supported')


@assert_no_logs
def test_unknown_prefix():
    assert_invalid(
        '-unknown-display: block',
        'prefixed selectors are ignored',
        logging.DEBUG)


@assert_no_logs
@pytest.mark.parametrize('prop', PROPERTIES)
def test_empty_property_value(prop):
    assert_invalid(f'{prop}:', message='Ignored')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('1px, 3EM, auto, auto', ((1, 'px'), (3, 'em'), 'auto', 'auto')),
    ('1px,3em,auto,1px', ((1, 'px'), (3, 'em'), 'auto', (1, 'px'))),
])
def test_clip(rule, value):
    assert get_value(f'clip: rect({rule})') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'clip: square(1px, 3em, auto, auto)',
    'clip: rect(1px 3em auto auto)',
    'clip: rect(1px, 3em, auto)',
    'clip: rect(1px, 3em / auto)',
])
def test_clip_invalid(rule):
    assert_invalid(rule)


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('counter-reset: foo bar 2 baz', (('foo', 0), ('bar', 2), ('baz', 0))),
    ('counter-increment: foo bar 2 baz', (('foo', 1), ('bar', 2), ('baz', 1))),
    ('counter-reset: foo', (('foo', 0),)),
    ('counter-set: FoO', (('FoO', 0),)),
    ('counter-increment: foo bAr 2 Bar', (('foo', 1), ('bAr', 2), ('Bar', 1))),
    ('counter-reset: none', ()),
])
def test_counters(rule, value):
    assert get_value(rule) == value


@pytest.mark.parametrize(('rule', 'warning'), [
    ('counter-reset: foo initial', 'Invalid counter name: initial.'),
    ('counter-reset: foo none', 'Invalid counter name: none.'),
])
def test_counters_warning(rule, warning):
    assert_invalid(rule, warning)


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'counter-reset: foo 3pX',
    'counter-reset: 3',
])
def test_counters_invalid(rule):
    assert_invalid(rule)


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('letter-spacing: normal', 'normal'),
    ('letter-spacing: 3px', (3, 'px')),
    ('word-spacing: normal', 'normal'),
    ('word-spacing: 3px', (3, 'px')),
])
def test_spacing(rule, value):
    assert get_value(rule) == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'letter-spacing: 3',
    'word-spacing: 3',
])
def test_spacing_invalid(rule):
    assert_invalid(rule)


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('none', 'none'),
    ('overline', {'overline'}),
    ('overline blink line-through', {'blink', 'line-through', 'overline'}),
])
def test_text_decoration_line(rule, value):
    assert get_value(f'text-decoration-line: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('solid', 'solid'),
    ('double', 'double'),
    ('dotted', 'dotted'),
    ('dashed', 'dashed'),
])
def test_text_decoration_style(rule, value):
    assert get_value(f'text-decoration-style: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('200px', ((200, 'px'), (200, 'px'))),
    ('200px 300pt', ((200, 'px'), (300, 'pt'))),
    ('auto', ((210, 'mm'), (297, 'mm'))),
    ('portrait', ((210, 'mm'), (297, 'mm'))),
    ('landscape', ((297, 'mm'), (210, 'mm'))),
    ('A3 portrait', ((297, 'mm'), (420, 'mm'))),
    ('A3 landscape', ((420, 'mm'), (297, 'mm'))),
    ('portrait A3', ((297, 'mm'), (420, 'mm'))),
    ('landscape A3', ((420, 'mm'), (297, 'mm'))),
])
def test_size(rule, value):
    assert get_value(f'size: {rule}') == value


@pytest.mark.parametrize('rule', [
    'A3 landscape A3',
    'A12',
    'foo',
    'foo bar',
    '20%',
])
def test_size_invalid(rule):
    assert_invalid(f'size: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('none', ()),
    ('translate(6px) rotate(90deg)', (
        ('translate', ((6, 'px'), (0, 'px'))), ('rotate', pi / 2))),
    ('rotate(0)', (('rotate', 0),)),
    ('translate(-4px, 0)', (('translate', ((-4, 'px'), (0, None))),)),
    ('translate(6px, 20%)', (('translate', ((6, 'px'), (20, '%'))),)),
    ('scale(2)', (('scale', (2, 2)),)),
])
def test_transform(rule, value):
    assert get_value(f'transform: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'lipsumize(6px)',
    'foo',
    'scale(2) foo',
    '6px',
    'translate(6px 20%)',
])
def test_transform_invalid(rule):
    assert_invalid(f'transform: {rule}')


@pytest.mark.parametrize('rule', [
    'inexistent-gradient(blue, green)',
])
def test_background_image_invalid(rule):
    assert_invalid(f'background-image: {rule}')


@pytest.mark.parametrize(('rule', 'value'), [
    # One token, vertical
    ('top', (('left', (50, '%'), 'top', (0, '%')),)),
    ('bottom', (('left', (50, '%'), 'top', (100, '%')),)),

    # Three tokens
    ('center top 10%', (('left', (50, '%'), 'top', (10, '%')),)),
    ('top 10% center', (('left', (50, '%'), 'top', (10, '%')),)),
    ('center bottom 10%', (('left', (50, '%'), 'bottom', (10, '%')),)),
    ('bottom 10% center', (('left', (50, '%'), 'bottom', (10, '%')),)),

    ('right top 10%', (('right', (0, '%'), 'top', (10, '%')),)),
    ('top 10% right', (('right', (0, '%'), 'top', (10, '%')),)),
    ('right bottom 10%', (('right', (0, '%'), 'bottom', (10, '%')),)),
    ('bottom 10% right', (('right', (0, '%'), 'bottom', (10, '%')),)),

    ('center left 10%', (('left', (10, '%'), 'top', (50, '%')),)),
    ('left 10% center', (('left', (10, '%'), 'top', (50, '%')),)),
    ('center right 10%', (('right', (10, '%'), 'top', (50, '%')),)),
    ('right 10% center', (('right', (10, '%'), 'top', (50, '%')),)),

    ('bottom left 10%', (('left', (10, '%'), 'bottom', (0, '%')),)),
    ('left 10% bottom', (('left', (10, '%'), 'bottom', (0, '%')),)),
    ('bottom right 10%', (('right', (10, '%'), 'bottom', (0, '%')),)),
    ('right 10% bottom', (('right', (10, '%'), 'bottom', (0, '%')),)),

    # Four tokens
    ('left 10% bottom 3PX', (('left', (10, '%'), 'bottom', (3, 'px')),)),
    ('bottom 3px left 10%', (('left', (10, '%'), 'bottom', (3, 'px')),)),
    ('right 10% top 3px', (('right', (10, '%'), 'top', (3, 'px')),)),
    ('top 3px right 10%', (('right', (10, '%'), 'top', (3, 'px')),)),
    *tuple(
        (css_x, (('left', val_x, 'top', (50, '%')),))
        for css_x, val_x in (
                ('left', (0, '%')), ('center', (50, '%')), ('right', (100, '%')),
                ('4.5%', (4.5, '%')), ('12px', (12, 'px')))
    ),
    *tuple(
        (f'{css_x} {css_y}', (('left', val_x, 'top', val_y),))
        for css_x, val_x in (
                ('left', (0, '%')), ('center', (50, '%')), ('right', (100, '%')),
                ('4.5%', (4.5, '%')), ('12px', (12, 'px')))
        for css_y, val_y in (
                ('top', (0, '%')), ('center', (50, '%')), ('bottom', (100, '%')),
                ('7%', (7, '%')), ('1.5px', (1.5, 'px')))
    ),
])
def test_background_position(rule, value):
    assert get_value(f'background-position: {rule}') == value


@pytest.mark.parametrize('rule', [
    '10px lipsum',
    'left center 3px',
    '3px left',
    'bottom 4%',
    'bottom top'
])
def test_background_position_invalid(rule):
    assert_invalid(f'background-position: {rule}')


@pytest.mark.parametrize('rule', [
    ('"My" Font, serif'),
    ('"My" "Font", serif'),
    ('"My", 12pt, serif'),
])
def test_font_family_invalid(rule):
    assert_invalid(f'font-family: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('1px', (1, 'px')),
    ('1.1%', (1.1, '%')),
    ('1Em', (1, 'em')),
    ('1', (1, None)),
    ('1.3', (1.3, None)),
    ('-0', (0, None)),
    ('0px', (0, 'px')),
])
def test_line_height(rule, value):
    assert get_value(f'line-height: {rule}') == value


@pytest.mark.parametrize('rule', [
    '1deg',
    '-1px',
    '-1',
    '-0.5%',
    '1px 1px',
])
def test_line_height_invalid(rule):
    assert_invalid(f'line-height: {rule}')


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'symbols()',
    'symbols(cyclic)',
    'symbols(symbolic)',
    'symbols(fixed)',
    'symbols(alphabetic "a")',
    'symbols(numeric "1")',
    'symbols(test "a" "b")',
    'symbols(fixed symbolic "a" "b")',
])
def test_list_style_type_invalid(rule):
    assert_invalid(f'list-style-type: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('none', 'none'),
    ('from-image', 'from-image'),
    ('90deg', (pi / 2, False)),
    ('30deg', (pi / 6, False)),
    ('180deg flip', (pi, True)),
    ('0deg flip', (0, True)),
    ('flip 90deg', (pi / 2, True)),
    ('flip', (0, True)),
])
def test_image_orientation(rule, value):
    assert get_value(f'image-orientation: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none none',
    'unknown',
    'none flip',
    'from-image flip',
    '10',
    '10 flip',
    'flip 10',
    'flip flip',
    '90deg flop',
    '90deg 180deg',
])
def test_image_orientation_invalid(rule):
    assert_invalid(f'image-orientation: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('1', ((1, None),)),
    ('1 2    3 4', ((1, None), (2, None), (3, None), (4, None))),
    ('50% 1000.1 0', ((50, '%'), (1000.1, None), (0, None))),
    ('1% 2% 3% 4%', ((1, '%'), (2, '%'), (3, '%'), (4, '%'))),
    ('fill 10% 20', ('fill', (10, '%'), (20, None))),
    ('0 1 0.5 fill', ((0, None), (1, None), (0.5, None), 'fill')),
])
def test_border_image_slice(rule, value):
    assert get_value(f'border-image-slice: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none',
    '1, 2',
    '-10',
    '-10%',
    '1 2 3 -10%',
    '-0.3',
    '1 fill 2',
    'fill 1 2 3 fill',
])
def test_border_image_slice_invalid(rule):
    assert_invalid(f'border-image-slice: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('1', ((1, None),)),
    ('1 2    3 4', ((1, None), (2, None), (3, None), (4, None))),
    ('50% 1000.1 0', ((50, '%'), (1000.1, None), (0, None))),
    ('1% 2px 3em 4', ((1, '%'), (2, 'px'), (3, 'em'), (4, None))),
    ('auto', ('auto',)),
    ('1 auto', ((1, None), 'auto')),
    ('auto auto', ('auto', 'auto')),
    ('auto auto auto 2', ('auto', 'auto', 'auto', (2, None))),
])
def test_border_image_width(rule, value):
    assert get_value(f'border-image-width: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none',
    '1, 2',
    '1 -2',
    '-10',
    '-10%',
    '1px 2px 3px -10%',
    '-3px',
    'auto auto auto auto auto',
    '1 2 3 4 5',
])
def test_border_image_width_invalid(rule):
    assert_invalid(f'border-image-width: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('1', ((1, None),)),
    ('1 2    3 4', ((1, None), (2, None), (3, None), (4, None))),
    ('50px 1000.1 0', ((50, 'px'), (1000.1, None), (0, None))),
    ('1in 2px 3em 4', ((1, 'in'), (2, 'px'), (3, 'em'), (4, None))),
])
def test_border_image_outset(rule, value):
    assert get_value(f'border-image-outset: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none',
    'auto',
    '1, 2',
    '-10',
    '1 -2',
    '10%',
    '1px 2px 3px -10px',
    '-3px',
    '1 2 3 4 5',
])
def test_border_image_outset_invalid(rule):
    assert_invalid(f'border-image-outset: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('stretch', ('stretch',)),
    ('repeat repeat', ('repeat', 'repeat')),
    ('round     space', ('round', 'space')),
])
def test_border_image_repeat(rule, value):
    assert get_value(f'border-image-repeat: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none',
    'test',
    'round round round',
    'stretch space round',
    'repeat test',
])
def test_border_image_repeat_invalid(rule):
    assert_invalid(f'border-image-repeat: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('1', ((1, None),)),
    ('1 2    3 4', ((1, None), (2, None), (3, None), (4, None))),
    ('50% 1000.1 0', ((50, '%'), (1000.1, None), (0, None))),
    ('1% 2% 3% 4%', ((1, '%'), (2, '%'), (3, '%'), (4, '%'))),
    ('fill 10% 20', ('fill', (10, '%'), (20, None))),
    ('0 1 0.5 fill', ((0, None), (1, None), (0.5, None), 'fill')),
])
def test_mask_border_slice(rule, value):
    assert get_value(f'mask-border-slice: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none',
    '1, 2',
    '-10',
    '-10%',
    '1 2 3 -10%',
    '-0.3',
    '1 fill 2',
    'fill 1 2 3 fill',
])
def test_mask_border_slice_invalid(rule):
    assert_invalid(f'mask-border-slice: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('1', ((1, None),)),
    ('1 2    3 4', ((1, None), (2, None), (3, None), (4, None))),
    ('50% 1000.1 0', ((50, '%'), (1000.1, None), (0, None))),
    ('1% 2px 3em 4', ((1, '%'), (2, 'px'), (3, 'em'), (4, None))),
    ('auto', ('auto',)),
    ('1 auto', ((1, None), 'auto')),
    ('auto auto', ('auto', 'auto')),
    ('auto auto auto 2', ('auto', 'auto', 'auto', (2, None))),
])
def test_mask_border_width(rule, value):
    assert get_value(f'mask-border-width: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none',
    '1, 2',
    '1 -2',
    '-10',
    '-10%',
    '1px 2px 3px -10%',
    '-3px',
    'auto auto auto auto auto',
    '1 2 3 4 5',
])
def test_mask_border_width_invalid(rule):
    assert_invalid(f'mask-border-width: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('1', ((1, None),)),
    ('1 2    3 4', ((1, None), (2, None), (3, None), (4, None))),
    ('50px 1000.1 0', ((50, 'px'), (1000.1, None), (0, None))),
    ('1in 2px 3em 4', ((1, 'in'), (2, 'px'), (3, 'em'), (4, None))),
])
def test_mask_border_outset(rule, value):
    assert get_value(f'mask-border-outset: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none',
    'auto',
    '1, 2',
    '-10',
    '1 -2',
    '10%',
    '1px 2px 3px -10px',
    '-3px',
    '1 2 3 4 5',
])
def test_mask_border_outset_invalid(rule):
    assert_invalid(f'mask-border-outset: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('stretch', ('stretch',)),
    ('repeat repeat', ('repeat', 'repeat')),
    ('round     space', ('round', 'space')),
])
def test_mask_border_repeat(rule, value):
    assert get_value(f'mask-border-repeat: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none',
    'test',
    'round round round',
    'stretch space round',
    'repeat test',
])
def test_mask_border_repeat_invalid(rule):
    assert_invalid(f'mask-border-repeat: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('alpha', 'alpha'),
    ('luminance', 'luminance'),
    ('alpha     ', 'alpha'),
])
def test_mask_border_mode(rule, value):
    assert get_value(f'mask-border-mode: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none',
    'test',
    'alpha alpha',
    'alpha luminance',
])
def test_mask_border_mode_invalid(rule):
    assert_invalid(f'mask-border-mode: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('test content(text)', (('test', (('content()', 'text'),)),)),
    ('test content(before)', (('test', (('content()', 'before'),)),)),
    ('test "string"', (('test', (('string', 'string'),)),)),
    ('test1 "string", test2 "string"', (
        ('test1', (('string', 'string'),)),
        ('test2', (('string', 'string'),)))),
    ('test attr(class)', (('test', (('attr()', ('class', 'string', '')),)),)),
    ('test attr(class url)', (('test', (('attr()', ('class', 'url', '')),)),)),
    ('test attr(class, "test")', (
        ('test', (('attr()', ('class', 'string', 'test')),)),)),
    ('test attr(class string, "test")', (
        ('test', (('attr()', ('class', 'string', 'test')),)),)),
    ('test counter(count)', (
        ('test', (('counter()', ('count', 'decimal')),)),)),
    ('test counter(count, upper-roman)', (
        ('test', (('counter()', ('count', 'upper-roman')),)),)),
    ('test counters(count, ".")', (
        ('test', (('counters()', ('count', '.', 'decimal')),)),)),
    ('test counters(count, ".", upper-roman)', (
        ('test', (('counters()', ('count', '.', 'upper-roman')),)),)),
    ('test content(text) "string" attr(title) attr(title) counter(count)', (
        ('test', (
            ('content()', 'text'), ('string', 'string'),
            ('attr()', ('title', 'string', '')),
            ('attr()', ('title', 'string', '')),
            ('counter()', ('count', 'decimal')))),)),
])
def test_string_set(rule, value):
    assert get_value(f'string-set: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'test',
    'test test1',
    'test content(test)',
    'test unknown()',
])
def test_string_set_invalid(rule):
    assert_invalid(f'string-set: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('normal', 'normal'),
    ('break-word', 'break-word'),
    ('inherit', 'inherit'),
])
def test_overflow_wrap(rule, value):
    assert get_value(f'overflow-wrap: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none',
    'normal, break-word',
])
def test_overflow_wrap_invalid(rule):
    assert_invalid(f'overflow-wrap: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('blue', ()),
    ('red', (None, ((1, 0, 0, 1),))),
    ('blue 1%, lime,red 2em ', (
        None,
        ((0, 0, 1, 1), (0, 1, 0, 1), (1, 0, 0, 1)),
        ((1, '%'), None, (2, 'em')))),
    ('18deg, blue', (('angle', pi / 10),)),
    ('4rad, blue', (('angle', 4),)),
    ('.25turn, blue', (('angle', pi / 2),)),
    ('100grad, blue', (('angle', pi / 2),)),
    ('12rad, blue 1%, lime,red 2em ', (
        ('angle', 12),
        ((0, 0, 1, 1), (0, 1, 0, 1), (1, 0, 0, 1)),
        ((1, '%'), None, (2, 'em')))),
    ('to top, blue', (('angle', 0),)),
    ('to right, blue', (('angle', pi / 2),)),
    ('to bottom, blue', (('angle', pi),)),
    ('to left, blue', (('angle', pi * 3 / 2),)),
    ('to right, blue 1%, lime,red 2em ', (
        ('angle', pi / 2),
        ((0, 0, 1, 1), (0, 1, 0, 1), (1, 0, 0, 1)),
        ((1, '%'), None, (2, 'em')))),
    ('to top left, blue', (('corner', 'top_left'),)),
    ('to left top, blue', (('corner', 'top_left'),)),
    ('to top right, blue', (('corner', 'top_right'),)),
    ('to right top, blue', (('corner', 'top_right'),)),
    ('to bottom left, blue', (('corner', 'bottom_left'),)),
    ('to left bottom, blue', (('corner', 'bottom_left'),)),
    ('to bottom right, blue', (('corner', 'bottom_right'),)),
    ('to right bottom, blue', (('corner', 'bottom_right'),)),
])
def test_linear_gradient(rule, value):
    direction = get_default_value(value, 0, ('angle', pi))
    colors = get_default_value(value, 1, ((0, 0, 1, 1),))
    stop_positions = get_default_value(value, 2, (None,))
    for repeating, prefix in ((False, ''), (True, 'repeating-')):
        (type_, image), = get_value(
            f'background-image: {prefix}linear-gradient({rule})')
        assert type_ == 'linear-gradient'
        assert isinstance(image, LinearGradient)
        assert image.repeating == repeating
        assert image.direction_type == direction[0]
        if isinstance(image.direction, str):
            image.direction == direction[1]
        else:
            assert image.direction == pytest.approx(direction[1])
        assert image.colors == tuple(colors)
        assert image.stop_positions == tuple(stop_positions)


@assert_no_logs
@pytest.mark.parametrize('rule', [
    ' ',
    '1% blue',
    'blue 10deg',
    'blue 4',
    'soylent-green 4px',
    'red 4px 2px',
    '18deg',
    '10arc-minutes, blue',
    '10px, blue',
    'to 90deg, blue',
    'to the top, blue',
    'to up, blue',
    'into top, blue',
    'top, blue',
    'to bottom up, blue',
    'bottom left, blue',
])
def test_linear_gradient_invalid(rule):
    assert_invalid(f'background-image: linear-gradient({rule})')
    assert_invalid(f'background-image: repeating-linear-gradient({rule})')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('blue', ()),
    ('red', (None, None, None, ((1, 0, 0, 1),))),
    ('blue 1%, lime,red 2em ', (
        None, None, None, ((0, 0, 1, 1), (0, 1, 0, 1), (1, 0, 0, 1)),
        ((1, '%'), None, (2, 'em')))),
    ('circle, blue', ('circle',)),
    ('ellipse, blue', ()),
    ('ellipse closest-corner, blue', (
        'ellipse', ('keyword', 'closest-corner'))),
    ('circle closest-side, blue', (
        'circle', ('keyword', 'closest-side'))),
    ('farthest-corner circle, blue', (
        'circle', ('keyword', 'farthest-corner'))),
    ('farthest-side, blue', (None, (('keyword', 'farthest-side')))),
    ('5ch, blue', ('circle', ('explicit', ((5, 'ch'), (5, 'ch'))))),
    ('5ch circle, blue', ('circle', ('explicit', ((5, 'ch'), (5, 'ch'))))),
    ('circle 5ch, blue', ('circle', ('explicit', ((5, 'ch'), (5, 'ch'))))),
    ('10px 50px, blue', (None, ('explicit', ((10, 'px'), (50, 'px'))))),
    ('10px 50px ellipse, blue', (
        None, ('explicit', ((10, 'px'), (50, 'px'))))),
    ('ellipse 10px 50px, blue', (
        None, ('explicit', ((10, 'px'), (50, 'px'))))),
    ('at top 10% right, blue', (
        None, None, ('right', (0, '%'), 'top', (10, '%')))),
    ('circle at bottom, blue', (
        'circle', None, ('left', (50, '%'), 'top', (100, '%')))),
    ('circle at 10px, blue', (
        'circle', None, ('left', (10, 'px'), 'top', (50, '%')))),
    ('closest-side circle at right 5em, blue', (
        'circle', ('keyword', 'closest-side'),
        ('left', (100, '%'), 'top', (5, 'em')))),
])
def test_radial_gradient(rule, value):
    shape = get_default_value(value, 0, 'ellipse')
    size = get_default_value(value, 1, ('keyword', 'farthest-corner'))
    center = get_default_value(value, 2, ('left', (50, '%'), 'top', (50, '%')))
    colors = get_default_value(value, 3, ((0, 0, 1, 1),))
    stop_positions = get_default_value(value, 4, (None,))
    for repeating, prefix in ((False, ''), (True, 'repeating-')):
        (type_, image), = get_value(
            f'background-image: {prefix}radial-gradient({rule})')
        assert type_ == 'radial-gradient'
        assert isinstance(image, RadialGradient)
        assert image.repeating == repeating
        assert image.shape == shape
        assert image.size_type == size[0]
        assert image.size == size[1]
        assert image.center == center
        assert image.colors == tuple(colors)
        assert image.stop_positions == tuple(stop_positions)


@assert_no_logs
@pytest.mark.parametrize('rule', [
    ' ',
    '1% blue',
    'blue 10deg',
    'blue 4',
    'soylent-green 4px',
    'red 4px 2px',
    'circle',
    'square, blue',
    'closest-triangle, blue',
    'center, blue',
    'ellipse 5ch',
    '5ch ellipse',
    'circle 10px 50px, blue',
    '10px 50px circle, blue',
    '10%, blue',
    '10% circle, blue',
    'circle 10%, blue',
    'at appex, blue',
])
def test_radial_gradient_invalid(rule):
    assert_invalid(f'background-image: radial-gradient({rule})')
    assert_invalid(f'background-image: repeating-radial-gradient({rule})')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('40px', ((40, 'px'),)),
    ('2fr', ((2, 'fr'),)),
    ('18%', ((18, '%'),)),
    ('auto', ('auto',)),
    ('min-content', ('min-content',)),
    ('max-content', ('max-content',)),
    ('fit-content(20%)', (('fit-content()', (20, '%')),)),
    ('minmax(20px, 25px)', (('minmax()', (20, 'px'), (25, 'px')),)),
    ('minmax(min-content, max-content)',
     (('minmax()', 'min-content', 'max-content'),)),
    ('min-content max-content', ('min-content', 'max-content')),
])
def test_grid_auto_columns_rows(rule, value):
    assert get_value(f'grid-auto-columns: {rule}') == value
    assert get_value(f'grid-auto-rows: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    '40',
    'coucou',
    'fit-content',
    'fit-content(min-content)',
    'minmax(40px)',
    'minmax(2fr, 1fr)',
    '1fr 1fr coucou',
    'fit-content()',
    'fit-content(2%, 18%)',
])
def test_grid_auto_columns_rows_invalid(rule):
    assert_invalid(f'grid-auto-columns: {rule}')
    assert_invalid(f'grid-auto-rows: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('row', ('row',)),
    ('column', ('column',)),
    ('row dense', ('row', 'dense')),
    ('column dense', ('column', 'dense')),
    ('dense row', ('dense', 'row')),
    ('dense column', ('dense', 'column')),
    ('dense', ('dense', 'row')),
])
def test_grid_auto_flow(rule, value):
    assert get_value(f'grid-auto-flow: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'row row',
    'column column',
    'dense dense',
    'coucou',
    'row column',
    'column row',
    'row coucou',
    'column coucou',
    'coucou row',
    'coucou column',
    'row column dense',
])
def test_grid_auto_flow_invalid(rule):
    assert_invalid(f'grid-auto-flow: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('none', 'none'),
    ('subgrid', ('subgrid', ())),
    ('subgrid [a] repeat(auto-fill, [b]) [c]',
     ('subgrid', (('a',), ('repeat()', 'auto-fill', (('b',),)), ('c',)))),
    ('subgrid [a] [a] [a] [a] repeat(auto-fill, [b]) [c] [c]',
     ('subgrid', (('a',), ('a',), ('a',), ('a',),
      ('repeat()', 'auto-fill', (('b',),)), ('c',), ('c',)))),
    ('subgrid [] [a]', ('subgrid', ((), ('a',)))),
    ('subgrid [a] [b] [c] [d] [e] [f]',
     ('subgrid', (('a',), ('b',), ('c',), ('d',), ('e',), ('f',)))),
    ('[outer-edge] 20px [main-start] 1fr [center] 1fr max-content [main-end]',
     (('outer-edge',), (20, 'px'), ('main-start',), (1, 'fr'), ('center',),
      (1, 'fr'), (), 'max-content', ('main-end',))),
    ('repeat(auto-fill, minmax(25ch, 1fr))',
     ((), ('repeat()', 'auto-fill', (
         (), ('minmax()', (25, 'ch'), (1, 'fr')), ())), ())),
    ('[a] auto [b] minmax(min-content, 1fr) [b c d] '
     'repeat(2, [e] 40px) repeat(5, auto)',
     (('a',), 'auto', ('b',), ('minmax()', 'min-content', (1, 'fr')),
      ('b', 'c', 'd'), ('repeat()', 2, (('e',), (40, 'px'), ())),
      (), ('repeat()', 5, ((), 'auto', ())), ())),
])
def test_grid_template_columns_rows(rule, value):
    assert get_value(f'grid-template-columns: {rule}') == value
    assert get_value(f'grid-template-rows: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'coucou',
    'subgrid subgrid',
    'subgrid coucou',
    'subgrid [coucou] repeat(0, [wow])',
    'subgrid [coucou] repeat(auto-fit [wow])',
    'fit-content(18%) repeat(auto-fill, 15em)',
    '[coucou] [wow]',
])
def test_grid_template_columns_rows_invalid(rule):
    assert_invalid(f'grid-template-columns: {rule}')
    assert_invalid(f'grid-template-rows: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('none', 'none'),
    ('"head head" "nav main" "foot ...."',
     (('head', 'head'), ('nav', 'main'), ('foot', None))),
    ('"title board" "stats board"',
     (('title', 'board'), ('stats', 'board'))),
    ('". a" "b a" ".a"',
     ((None, 'a'), ('b', 'a'), (None, 'a'))),
    ('"a b b" "c b b" "d e f"',
     (('a', 'b', 'b'), ('c', 'b', 'b'), ('d', 'e', 'f'))),
])
def test_grid_template_areas(rule, value):
    assert get_value(f'grid-template-areas: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    '"head head coucou" "nav main" "foot ...."',
    '". a" "b c" ". a"',
    '". a" "b a" "a a"',
    '"a a a a" "a b b a" "a a a a"',
    '" "',
])
def test_grid_template_areas_invalid(rule):
    assert_invalid(f'grid-template-areas: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('auto', 'auto'),
    ('4', (None, 4, None)),
    ('C', (None, None, 'C')),
    ('4 c', (None, 4, 'c')),
    ('col -4', (None, -4, 'col')),
    ('span c 4', ('span', 4, 'c')),
    ('span 4 c', ('span', 4, 'c')),
    ('4 span C', ('span', 4, 'C')),
    ('super 4 span', ('span', 4, 'super')),
])
def test_grid_line(rule, value):
    assert get_value(f'grid-row-start: {rule}') == value
    assert get_value(f'grid-row-end: {rule}') == value
    assert get_value(f'grid-column-start: {rule}') == value
    assert get_value(f'grid-column-end: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'span',
    '0',
    '1.1',
    'span 0',
    'span -1',
    'span 2.1',
    'span auto',
    'auto auto',
    '-4 cOL span',
    'span 1.1 col',
])
def test_grid_line_invalid(rule):
    assert_invalid(f'grid-row-start: {rule}')
    assert_invalid(f'grid-row-end: {rule}')
    assert_invalid(f'grid-column-start: {rule}')
    assert_invalid(f'grid-column-end: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('normal', ('normal',)),
    ('baseline', ('first', 'baseline')),
    ('first baseline', ('first', 'baseline')),
    ('last baseline', ('last', 'baseline')),
    ('baseline last', ('baseline', 'last')),
    ('space-between', ('space-between',)),
    ('space-around', ('space-around',)),
    ('space-evenly', ('space-evenly',)),
    ('stretch', ('stretch',)),
    ('center', ('center',)),
    ('start', ('start',)),
    ('end', ('end',)),
    ('flex-start', ('flex-start',)),
    ('flex-end', ('flex-end',)),
    ('safe center', ('safe', 'center')),
    ('unsafe start', ('unsafe', 'start')),
    ('safe end', ('safe', 'end')),
    ('safe flex-start', ('safe', 'flex-start')),
    ('unsafe flex-start', ('unsafe', 'flex-start')),
])
def test_align_content(rule, value):
    assert get_value(f'align-content: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'auto',
    'none',
    'auto auto',
    'first last',
    'baseline baseline',
    'start safe',
    'start end',
    'safe unsafe',
    'left',
    'right',
])
def test_align_content_invalid(rule):
    assert_invalid(f'align-content: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('normal', ('normal',)),
    ('stretch', ('stretch',)),
    ('baseline', ('first', 'baseline')),
    ('first baseline', ('first', 'baseline')),
    ('last baseline', ('last', 'baseline')),
    ('baseline last', ('baseline', 'last')),
    ('center', ('center',)),
    ('self-start', ('self-start',)),
    ('self-end', ('self-end',)),
    ('start', ('start',)),
    ('end', ('end',)),
    ('flex-start', ('flex-start',)),
    ('flex-end', ('flex-end',)),
    ('safe center', ('safe', 'center')),
    ('unsafe start', ('unsafe', 'start')),
    ('safe end', ('safe', 'end')),
    ('unsafe self-start', ('unsafe', 'self-start')),
    ('safe self-end', ('safe', 'self-end')),
    ('safe flex-start', ('safe', 'flex-start')),
    ('unsafe flex-start', ('unsafe', 'flex-start')),
])
def test_align_items(rule, value):
    assert get_value(f'align-items: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'auto',
    'none',
    'auto auto',
    'first last',
    'baseline baseline',
    'start safe',
    'start end',
    'safe unsafe',
    'left',
    'right',
    'space-between',
])
def test_align_items_invalid(rule):
    assert_invalid(f'align-items: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('auto', ('auto',)),
    ('normal', ('normal',)),
    ('stretch', ('stretch',)),
    ('baseline', ('first', 'baseline')),
    ('first baseline', ('first', 'baseline')),
    ('last baseline', ('last', 'baseline')),
    ('baseline last', ('baseline', 'last')),
    ('center', ('center',)),
    ('self-start', ('self-start',)),
    ('self-end', ('self-end',)),
    ('start', ('start',)),
    ('end', ('end',)),
    ('flex-start', ('flex-start',)),
    ('flex-end', ('flex-end',)),
    ('safe center', ('safe', 'center')),
    ('unsafe start', ('unsafe', 'start')),
    ('safe end', ('safe', 'end')),
    ('unsafe self-start', ('unsafe', 'self-start')),
    ('safe self-end', ('safe', 'self-end')),
    ('safe flex-start', ('safe', 'flex-start')),
    ('unsafe flex-start', ('unsafe', 'flex-start')),
])
def test_align_self(rule, value):
    assert get_value(f'align-self: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none',
    'auto auto',
    'first last',
    'baseline baseline',
    'start safe',
    'start end',
    'safe unsafe',
    'left',
    'right',
    'space-between',
])
def test_align_self_invalid(rule):
    assert_invalid(f'align-self: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('normal', ('normal',)),
    ('space-between', ('space-between',)),
    ('space-around', ('space-around',)),
    ('space-evenly', ('space-evenly',)),
    ('stretch', ('stretch',)),
    ('center', ('center',)),
    ('left', ('left',)),
    ('right', ('right',)),
    ('start', ('start',)),
    ('end', ('end',)),
    ('flex-start', ('flex-start',)),
    ('flex-end', ('flex-end',)),
    ('safe center', ('safe', 'center')),
    ('unsafe start', ('unsafe', 'start')),
    ('safe end', ('safe', 'end')),
    ('unsafe left', ('unsafe', 'left')),
    ('safe right', ('safe', 'right')),
    ('safe flex-start', ('safe', 'flex-start')),
    ('unsafe flex-start', ('unsafe', 'flex-start')),
])
def test_justify_content(rule, value):
    assert get_value(f'justify-content: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'auto',
    'none',
    'baseline',
    'auto auto',
    'first last',
    'baseline baseline',
    'start safe',
    'start end',
    'safe unsafe',
])
def test_justify_content_invalid(rule):
    assert_invalid(f'justify-content: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('normal', ('normal',)),
    ('stretch', ('stretch',)),
    ('baseline', ('first', 'baseline')),
    ('first baseline', ('first', 'baseline')),
    ('last baseline', ('last', 'baseline')),
    ('baseline last', ('baseline', 'last')),
    ('center', ('center',)),
    ('self-start', ('self-start',)),
    ('self-end', ('self-end',)),
    ('start', ('start',)),
    ('end', ('end',)),
    ('left', ('left',)),
    ('right', ('right',)),
    ('flex-start', ('flex-start',)),
    ('flex-end', ('flex-end',)),
    ('safe center', ('safe', 'center')),
    ('unsafe start', ('unsafe', 'start')),
    ('safe end', ('safe', 'end')),
    ('unsafe self-start', ('unsafe', 'self-start')),
    ('safe self-end', ('safe', 'self-end')),
    ('safe flex-start', ('safe', 'flex-start')),
    ('unsafe flex-start', ('unsafe', 'flex-start')),
    ('legacy', ('legacy',)),
    ('legacy left', ('legacy', 'left')),
    ('left legacy', ('left', 'legacy')),
    ('legacy center', ('legacy', 'center')),
])
def test_justify_items(rule, value):
    assert get_value(f'justify-items: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'auto',
    'none',
    'auto auto',
    'first last',
    'baseline baseline',
    'start safe',
    'start end',
    'safe unsafe',
    'space-between',
])
def test_justify_items_invalid(rule):
    assert_invalid(f'justify-items: {rule}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('auto', ('auto',)),
    ('normal', ('normal',)),
    ('stretch', ('stretch',)),
    ('baseline', ('first', 'baseline')),
    ('first baseline', ('first', 'baseline')),
    ('last baseline', ('last', 'baseline')),
    ('baseline last', ('baseline', 'last')),
    ('center', ('center',)),
    ('self-start', ('self-start',)),
    ('self-end', ('self-end',)),
    ('start', ('start',)),
    ('end', ('end',)),
    ('left', ('left',)),
    ('right', ('right',)),
    ('flex-start', ('flex-start',)),
    ('flex-end', ('flex-end',)),
    ('safe center', ('safe', 'center')),
    ('unsafe start', ('unsafe', 'start')),
    ('safe end', ('safe', 'end')),
    ('unsafe left', ('unsafe', 'left')),
    ('safe right', ('safe', 'right')),
    ('unsafe self-start', ('unsafe', 'self-start')),
    ('safe self-end', ('safe', 'self-end')),
    ('safe flex-start', ('safe', 'flex-start')),
    ('unsafe flex-start', ('unsafe', 'flex-start')),
])
def test_justify_self(rule, value):
    assert get_value(f'justify-self: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'none',
    'auto auto',
    'first last',
    'baseline baseline',
    'start safe',
    'start end',
    'safe unsafe',
    'space-between',
])
def test_justify_self_invalid(rule):
    assert_invalid(f'justify-self: {rule}')


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'color',
    'background',
    'background-color',
    'border-color',
    'border-left-color',
    'outline-color',
])
@pytest.mark.parametrize('value', [
    'rgb()',
    'device-cmyk(0%, 0%, 0%, 30%)',
    '#abcde',
])
def test_colors_invalid(rule, value):
    assert_invalid(f'{rule}: {value}')


@assert_no_logs
@pytest.mark.parametrize(('rule', 'value'), [
    ('normal', 'normal'),
    ('light', ('light',)),
    ('dark', ('dark',)),
    ('light dark', ('light', 'dark')),
    ('dark light', ('dark', 'light')),
    ('light only', ('light', 'only')),
    ('only light', ('light', 'only')),
    ('dark dark', ('dark', 'dark')),
    ('light something', ('light', 'something')),
    ('only dark light', ('dark', 'light', 'only')),
    ('only something light', ('something', 'light', 'only')),
])
def test_color_scheme(rule, value):
    assert get_value(f'color-scheme: {rule}') == value


@assert_no_logs
@pytest.mark.parametrize('rule', [
    'normal only',
    'normal something',
    'only',
    'only only',
    'light only dark',
])
def test_color_scheme_invalid(rule):
    assert_invalid(f'color-scheme: {rule}')


================================================
FILE: tests/css/test_variables.py
================================================
"""Test CSS custom properties, also known as CSS variables."""

import pytest

from weasyprint.css.properties import KNOWN_PROPERTIES

from ..testing_utils import assert_no_logs, capture_logs, render_pages

SIDES = ('top', 'right', 'bottom', 'left')


@assert_no_logs
def test_variable_simple():
    page, = render_pages('''
      <style>
        p { --var: 10px; width: var(--var) }
      </style>
      <p></p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == 10


@assert_no_logs
def test_variable_not_computed():
    page, = render_pages('''
      <style>
        p { --var: 1rem; width: var(--var) }
      </style>
      <p></p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == 16


@assert_no_logs
def test_variable_inherit():
    page, = render_pages('''
      <style>
        html { --var: 10px }
        p { width: var(--var) }
      </style>
      <p></p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == 10


@assert_no_logs
def test_variable_inherit_override():
    page, = render_pages('''
      <style>
        html { --var: 20px }
        p { width: var(--var); --var: 10px }
      </style>
      <p></p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == 10


@assert_no_logs
def test_variable_default_unknown():
    page, = render_pages('''
      <style>
        p { width: var(--x, 10px) }
      </style>
      <p></p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == 10


@assert_no_logs
def test_variable_default_var():
    page, = render_pages('''
      <style>
        p { --var: 10px; width: var(--x, var(--var)) }
      </style>
      <p></p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == 10


@assert_no_logs
def test_variable_case_sensitive():
    page, = render_pages('''
      <style>
        html { --var: 20px }
        body { --VAR: 10px }
        p { width: var(--VAR) }
      </style>
      <p></p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == 10


@assert_no_logs
def test_variable_chain():
    page, = render_pages('''
      <style>
        html { --foo: 10px }
        body { --var: var(--foo) }
        p { width: var(--var) }
      </style>
      <p></p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == 10


@assert_no_logs
def test_variable_double_chain():
    page, = render_pages('''
      <style>
        html { --foo: red }
        body { --var: var(--foo), var(--foo) }
        div { background-image: linear-gradient(var(--var)) }
      </style>
      <div></dib>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.style['background_image'][0][1].colors[0] == (1, 0, 0, 1)
    assert div.style['background_image'][0][1].colors[1] == (1, 0, 0, 1)


@assert_no_logs
def test_variable_chain_root():
    # Regression test for #1656.
    page, = render_pages('''
      <style>
        html { --var2: 10px; --var1: var(--var2); width: var(--var1) }
      </style>
    ''')
    html, = page.children
    assert html.width == 10


def test_variable_self():
    page, = render_pages('''
      <style>
        html { --var1: var(--var1) }
      </style>
    ''')


def test_variable_loop():
    page, = render_pages('''
      <style>
        html { --var1: var(--var2); --var2: var(--var1); padding: var(--var1) }
      </style>
    ''')


def test_variable_chain_root_missing():
    # Regression test for #1656.
    page, = render_pages('''
      <style>
        html { --var1: var(--var-missing); width: var(--var1) }
      </style>
    ''')


def test_variable_chain_root_missing_inherited():
    # Regression test for #2164.
    page, = render_pages('''
      <style>
        html { --var1: var(--var-missing); font: var(--var1) }
      </style>a
    ''')


@assert_no_logs
def test_variable_shorthand_margin():
    page, = render_pages('''
      <style>
        html { --var: 10px }
        div { margin: 0 0 0 var(--var) }
      </style>
      <div></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.margin_top == 0
    assert div.margin_right == 0
    assert div.margin_bottom == 0
    assert div.margin_left == 10


@assert_no_logs
def test_variable_shorthand_margin_multiple():
    page, = render_pages('''
      <style>
        html { --var1: 10px; --var2: 20px }
        div { margin: var(--var2) 0 0 var(--var1) }
      </style>
      <div></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.margin_top == 20
    assert div.margin_right == 0
    assert div.margin_bottom == 0
    assert div.margin_left == 10


@assert_no_logs
def test_variable_shorthand_margin_invalid():
    with capture_logs() as logs:
        page, = render_pages('''
          <style>
            html { --var: blue }
            div { margin: 0 0 0 var(--var) }
          </style>
          <div></div>
        ''')
        log, = logs
        assert 'invalid value' in log
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.margin_top == 0
    assert div.margin_right == 0
    assert div.margin_bottom == 0
    assert div.margin_left == 0


@assert_no_logs
def test_variable_shorthand_border():
    page, = render_pages('''
      <style>
        html { --var: 1px solid blue }
        div { border: var(--var) }
      </style>
      <div></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.border_top_width == 1
    assert div.border_right_width == 1
    assert div.border_bottom_width == 1
    assert div.border_left_width == 1


@assert_no_logs
def test_variable_shorthand_border_side():
    page, = render_pages('''
      <style>
        html { --var: 1px solid blue }
        div { border-top: var(--var) }
      </style>
      <div></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.border_top_width == 1
    assert div.border_right_width == 0
    assert div.border_bottom_width == 0
    assert div.border_left_width == 0


@assert_no_logs
def test_variable_shorthand_border_mixed():
    page, = render_pages('''
      <style>
        html { --var: 1px solid }
        div { border: blue var(--var) }
      </style>
      <div></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.border_top_width == 1
    assert div.border_right_width == 1
    assert div.border_bottom_width == 1
    assert div.border_left_width == 1


def test_variable_shorthand_border_mixed_invalid():
    with capture_logs() as logs:
        page, = render_pages('''
          <style>
            html { --var: 1px solid blue }
            div { border: blue var(--var) }
          </style>
          <div></div>
        ''')
        # TODO: we should only get one warning here
        assert 'multiple color values' in logs[0]
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.border_top_width == 0
    assert div.border_right_width == 0
    assert div.border_bottom_width == 0
    assert div.border_left_width == 0


@assert_no_logs
@pytest.mark.parametrize(('var', 'background'), [
    ('blue', 'var(--v)'),
    ('padding-box url(pattern.png)', 'var(--v)'),
    ('padding-box url(pattern.png)', 'white var(--v) center'),
    ('100%', 'url(pattern.png) var(--v) var(--v) / var(--v) var(--v)'),
    ('left / 100%', 'url(pattern.png) top var(--v) 100%'),
])
def test_variable_shorthand_background(var, background):
    page, = render_pages('''
      <style>
        html { --v: %s }
        div { background: %s }
      </style>
      <div></div>
    ''' % (var, background))


@pytest.mark.parametrize(('var', 'background'), [
    ('invalid', 'var(--v)'),
    ('blue', 'var(--v) var(--v)'),
    ('100%', 'url(pattern.png) var(--v) var(--v) var(--v)'),
])
def test_variable_shorthand_background_invalid(var, background):
    with capture_logs() as logs:
        page, = render_pages('''
          <style>
            html { --v: %s }
            div { background: %s }
          </style>
          <div></div>
        ''' % (var, background))
        log, = logs
        assert 'invalid value' in log


@assert_no_logs
def test_variable_initial():
    # Regression test for #2075.
    page, = render_pages('''
      <style>
        html { --var: initial }
        p { width: var(--var) }
      </style>
      <p></p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == body.width


@assert_no_logs
def test_variable_initial_default():
    # Regression test for #2075.
    page, = render_pages('''
      <style>
        p { --var: initial; width: var(--var, 10px) }
      </style>
      <p></p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == body.width


@assert_no_logs
def test_variable_initial_default_var():
    # Regression test for #2075.
    page, = render_pages('''
      <style>
        p { --var: initial; width: var(--var, var(--var)) }
      </style>
      <p></p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == body.width


@pytest.mark.parametrize('prop', sorted(KNOWN_PROPERTIES))
def test_variable_fallback(prop):
    render_pages('''
      <style>
        div {
          --var: improperValue;
          %s: var(--var);
        }
      </style>
      <div></div>
    ''' % prop)


@assert_no_logs
def test_variable_list_content():
    # Regression test for #1287.
    page, = render_pages('''
      <style>
        :root { --var: "Page " counter(page) "/" counter(pages) }
        div::before { content: var(--var) }
      </style>
      <div></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    line, = div.children
    before, = line.children
    text, = before.children
    assert text.text == 'Page 1/1'


@assert_no_logs
@pytest.mark.parametrize(('var', 'display'), [
    ('inline', 'var(--var)'),
    ('inline-block', 'var(--var)'),
    ('inline flow', 'var(--var)'),
    ('inline', 'var(--var) flow'),
    ('flow', 'inline var(--var)'),
])
def test_variable_list_display(var, display):
    page, = render_pages('''
      <style>
        html { --var: %s }
        div { display: %s }
      </style>
      <section><div></div></section>
    ''' % (var, display))
    html, = page.children
    body, = html.children
    section, = body.children
    child, = section.children
    assert type(child).__name__ == 'LineBox'


@assert_no_logs
@pytest.mark.parametrize(('var', 'font'), [
    ('weasyprint', 'var(--var)'),
    ('"weasyprint"', 'var(--var)'),
    ('weasyprint', 'var(--var), monospace'),
    ('weasyprint, monospace', 'var(--var)'),
    ('monospace', 'weasyprint, var(--var)'),
])
def test_variable_list_font(var, font):
    page, = render_pages('''
      <style>
        html { font-size: 2px; --var: %s }
        div { font-family: %s }
      </style>
      <div>aa</div>
    ''' % (var, font))
    html, = page.children
    body, = html.children
    div, = body.children
    line, = div.children
    text, = line.children
    assert text.width == 4


@assert_no_logs
def test_variable_in_function():
    page, = render_pages('''
      <style>
        html { --var: title }
        h1 { counter-increment: var(--var) }
        div::before { content: counter(var(--var)) }
      </style>
      <section>
        <h1></h1>
        <div></div>
        <h1></h1>
        <div></div>
      </section>
    ''')
    html, = page.children
    body, = html.children
    section, = body.children
    h11, div1, h12, div2 = section.children
    assert div1.children[0].children[0].children[0].text == '1'
    assert div2.children[0].children[0].children[0].text == '2'


@assert_no_logs
def test_same_variable_in_function():
    page, = render_pages('''
      <style>
        body { --var: red }
        div { background-image: linear-gradient(var(--var), var(--var)) }
      </style>
      <div></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.style['background_image'][0][1].colors[0] == (1, 0, 0, 1)
    assert div.style['background_image'][0][1].colors[1] == (1, 0, 0, 1)


@assert_no_logs
def test_variable_in_nested_function():
    page, = render_pages('''
      <style>
        body { --var: 255 0 0 }
        div { background-image: linear-gradient(rgba(var(--var))) }
      </style>
      <div></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.style['background_image'][0][1].colors[0] == (1, 0, 0, 1)


@assert_no_logs
def test_variable_in_function_multiple_values():
    page, = render_pages('''
      <style>
        html { --name: title; --counter: title, upper-roman }
        h1 { counter-increment: var(--name) }
        div::before { content: counter(var(--counter)) }
      </style>
      <section>
        <h1></h1>
        <div></div>
        <h1></h1>
        <div></div>
        <h1></h1>
        <div style="--counter: var(--name), lower-roman"></div>
      </section>
    ''')
    html, = page.children
    body, = html.children
    section, = body.children
    h11, div1, h12, div2, h13, div3 = section.children
    assert div1.children[0].children[0].children[0].text == 'I'
    assert div2.children[0].children[0].children[0].text == 'II'
    assert div3.children[0].children[0].children[0].text == 'iii'


@assert_no_logs
def test_variable_in_variable_in_function():
    page, = render_pages('''
      <style>
        html { --name: title; --counter: var(--name), upper-roman }
        h1 { counter-increment: var(--name) }
        div::before { content: counter(var(--counter)) }
      </style>
      <section>
        <h1></h1>
        <div></div>
        <h1></h1>
        <div></div>
        <h1></h1>
        <div style="--counter: var(--name), lower-roman"></div>
      </section>
    ''')
    html, = page.children
    body, = html.children
    section, = body.children
    h11, div1, h12, div2, h13, div3 = section.children
    assert div1.children[0].children[0].children[0].text == 'I'
    assert div2.children[0].children[0].children[0].text == 'II'
    assert div3.children[0].children[0].children[0].text == 'iii'


def test_variable_in_function_missing():
    with capture_logs() as logs:
        page, = render_pages('''
          <style>
            h1 { counter-increment: var(--var) }
            div::before { content: counter(var(--var)) }
          </style>
          <section>
            <h1></h1>
            <div></div>
            <h1></h1>
            <div></div>
          </section>
        ''')
        assert len(logs) == 2
        assert 'no value' in logs[0]
        assert 'invalid value' in logs[1]
    html, = page.children
    body, = html.children
    section, = body.children
    h11, div1, h12, div2 = section.children
    assert not div1.children
    assert not div2.children


@assert_no_logs
def test_variable_in_function_in_variable():
    page, = render_pages('''
      <style>
        html { --name: title; --counter: counter(var(--name), upper-roman) }
        h1 { counter-increment: var(--name) }
        div::before { content: var(--counter) }
      </style>
      <section>
        <h1></h1>
        <div></div>
        <h1></h1>
        <div></div>
        <h1></h1>
        <div style="--counter: counter(var(--name), lower-roman)"></div>
      </section>
    ''')
    html, = page.children
    body, = html.children
    section, = body.children
    h11, div1, h12, div2, h13, div3 = section.children
    assert div1.children[0].children[0].children[0].text == 'I'
    assert div2.children[0].children[0].children[0].text == 'II'
    assert div3.children[0].children[0].children[0].text == 'iii'


@assert_no_logs
def test_variable_and_function_in_function():
    page, = render_pages('''
      <style>
        html { --counter-name: page }
        a::after { content: target-counter(attr(href), var(--counter-name)) }
      </style>
      <a id="link" href="#link"></a>
    ''')
    html, = page.children
    body, = html.children
    line, = body.children
    a, _ = line.children
    after, = a.children
    textbox, = after.children
    assert textbox.text == '1'


================================================
FILE: tests/draw/__init__.py
================================================
"""Test the final, drawn results and compare PNG images pixel per pixel."""

import io
from itertools import zip_longest
from pathlib import Path

import pytest
from PIL import Image

from ..testing_utils import FakeHTML, resource_path

# NOTE: "r" is not half red on purpose. In the pixel strings it has
# better contrast with "B" than does "R". eg. "rBBBrrBrB" vs "RBBBRRBRB".
PIXELS_BY_CHAR = {
    '_': (255, 255, 255),  # white
    'R': (255, 0, 0),  # red
    'B': (0, 0, 255),  # blue
    'G': (0, 255, 0),  # lime green
    'V': (191, 0, 64),  # average of 1*B and 3*R
    'S': (255, 63, 63),  # R above R above _
    'C': (0, 255, 255),  # cyan
    'M': (255, 0, 255),  # magenta
    'Y': (255, 255, 0),  # yellow
    'K': (0, 0, 0),  # black
    'P': (50, 76, 103),  # blue CMYK with ICC
    'Q': (63, 88, 110),  # blue CMYK without ICC
    'r': (255, 0, 0),  # red
    'g': (0, 128, 0),  # half green
    'b': (0, 0, 128),  # half blue
    'v': (128, 0, 128),  # average of B and R
    's': (255, 127, 127),  # R above _
    't': (127, 255, 127),  # G above _
    'u': (128, 0, 127),  # r above B above _
    'h': (64, 0, 64),  # half average of B and R
    'a': (0, 0, 254),  # R in lossy JPG
    'p': (192, 0, 63),  # R above R above B above _
    'z': None,
}


def parse_pixels(pixels):
    lines = (line.split('#')[0].strip() for line in pixels.splitlines())
    lines = tuple(line for line in lines if line)
    widths = {len(line) for line in lines}
    assert len(widths) == 1, 'All lines of pixels must have the same width'
    width = widths.pop()
    height = len(lines)
    pixels = tuple(PIXELS_BY_CHAR[char] for line in lines for char in line)
    return width, height, pixels


def assert_pixels(name, expected_pixels, html):
    """Helper testing the size of the image and the pixels values."""
    expected_width, expected_height, expected_pixels = parse_pixels(
        expected_pixels)
    width, height, pixels = html_to_pixels(html)
    assert (expected_width, expected_height) == (width, height), (
        'Images do not have the same sizes:\n'
        f'- expected: {expected_width} × {expected_height}\n'
        f'- result: {width} × {height}')
    assert_pixels_equal(name, width, height, pixels, expected_pixels)


def assert_same_renderings(name, *documents, tolerance=0):
    """Render HTML documents to PNG and check that they're the same."""
    pixels_list = []

    for html in documents:
        width, height, pixels = html_to_pixels(html)
        pixels_list.append(pixels)

    reference = pixels_list[0]
    for i, pixels in enumerate(pixels_list[1:], start=1):
        assert_pixels_equal(
            f'{name}_{i}', width, height, pixels, reference, tolerance)


def assert_different_renderings(name, *documents):
    """Render HTML documents to PNG and check that they’re different."""
    pixels_list = []

    for html in documents:
        width, height, pixels = html_to_pixels(html)
        pixels_list.append(pixels)

    for i, pixels_1 in enumerate(pixels_list, start=1):
        for j, pixels_2 in enumerate(pixels_list[i:], start=i+1):
            if tuple(pixels_1) == tuple(pixels_2):  # pragma: no cover
                name_1, name_2 = f'{name}_{i}', f'{name}_{j}'
                write_png(name_1, pixels_1, width, height)
                pytest.fail(f'{name_1} and {name_2} are the same')


def assert_pixels_equal(name, width, height, raw, expected_raw, tolerance=0):
    """Take 2 matrices of pixels and assert that they are the same."""
    if raw != expected_raw:  # pragma: no cover
        pixels = zip_longest(raw, expected_raw, fillvalue=(-1, -1, -1))
        for i, (value, expected) in enumerate(pixels):
            if expected is None:
                continue
            if any(abs(value - expected) > tolerance
                   for value, expected in zip(value, expected)):
                actual_height = len(raw) // width
                write_png(name, raw, width, actual_height)
                expected_raw = [
                    pixel or (255, 255, 255) for pixel in expected_raw]
                write_png(f'{name}.expected', expected_raw, width, height)
                x = i % width
                y = i // width
                pytest.fail(
                    f'Pixel ({x}, {y}) in {name}: '
                    f'expected rgba{expected}, got rgba{value}')


def write_png(name, pixels, width, height):  # pragma: no cover
    """Take a pixel matrix and write a PNG file."""
    directory = Path(__file__).parent / 'results'
    directory.mkdir(exist_ok=True)
    image = Image.new('RGB', (width, height))
    image.putdata(pixels)
    image.save(directory / f'{name}.png')


def html_to_pixels(html):
    """Render an HTML document to PNG, checks its size and return pixel data.

    Also return the document to aid debugging.

    """
    document = FakeHTML(string=html, base_url=resource_path('<dummy>'))
    return document_to_pixels(document)


def document_to_pixels(document):
    """Render an HTML document to PNG, check its size and return pixel data."""
    image = Image.open(io.BytesIO(document.write_png()))
    return image.width, image.height, image.get_flattened_data()


================================================
FILE: tests/draw/svg/__init__.py
================================================


================================================
FILE: tests/draw/svg/test_bounding_box.py
================================================
"""Test how bounding boxes are defined for SVG tags."""

import pytest

from ...testing_utils import assert_no_logs


@assert_no_logs
def test_bounding_box_rect(assert_pixels):
    assert_pixels('''
        BBBBB
        BBBBR
        BBBRR
        BBRRR
        BRRRR
    ''', '''
      <style>
        @page { size: 5px }
        svg { display: block }
      </style>
      <svg width="5px" height="5px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="1" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="55%"></stop>
            <stop stop-color="red" offset="55%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="0" width="5" height="5" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_bounding_box_circle(assert_pixels):
    assert_pixels('''
        __________
        __BBBBBB__
        _BBBBBBBz_
        _BBBBBBzR_
        _BBBBBzRR_
        _BBBBzRRR_
        _BBBzRRRR_
        _BBzRRRRR_
        __zRRRRR__
        __________
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="1" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="55%"></stop>
            <stop stop-color="red" offset="55%"></stop>
          </linearGradient>
        </defs>
        <circle cx="5" cy="5" r="4" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_bounding_box_ellipse(assert_pixels):
    assert_pixels('''
        __________
        __BBBBBB__
        _BBBBBBBz_
        _BBBBBBzR_
        _BBBBBzRR_
        _BBBBzRRR_
        _BBBzRRRR_
        _BBzRRRRR_
        __zRRRRR__
        __________
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="1" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="55%"></stop>
            <stop stop-color="red" offset="55%"></stop>
          </linearGradient>
        </defs>
        <ellipse cx="5" cy="5" rx="4" ry="4" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_bounding_box_line(assert_pixels):
    assert_pixels('''
        BB___
        BBB__
        _BRR_
        __RRR
        ___RR
    ''', '''
      <style>
        @page { size: 5px }
        svg { display: block }
      </style>
      <svg width="5px" height="5px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="1" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="50%"></stop>
            <stop stop-color="red" offset="50%"></stop>
          </linearGradient>
        </defs>
        <line x1="0" y1="0" x2="5" y2="5"
              stroke-width="1" stroke="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_bounding_box_polygon(assert_pixels):
    assert_pixels('''
        BBBBB
        BBBBR
        BBBRR
        BBRRR
        BRRRR
    ''', '''
      <style>
        @page { size: 5px }
        svg { display: block }
      </style>
      <svg width="5px" height="5px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="1" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="55%"></stop>
            <stop stop-color="red" offset="55%"></stop>
          </linearGradient>
        </defs>
        <polygon points="0 0 0 5 5 5 5 0" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_bounding_box_polyline(assert_pixels):
    assert_pixels('''
        BBBBB
        BBBBR
        BBBRR
        BBRRR
        BRRRR
    ''', '''
      <style>
        @page { size: 5px }
        svg { display: block }
      </style>
      <svg width="5px" height="5px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="1" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="55%"></stop>
            <stop stop-color="red" offset="55%"></stop>
          </linearGradient>
        </defs>
        <polyline points="0 0 0 5 5 5 5 0" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_bounding_box_text(assert_pixels):
    assert_pixels('''
        BB
        BR
    ''', '''
      <style>
        @page { size: 2px }
        svg { display: block }
      </style>
      <svg width="2px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="1" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="65%"></stop>
            <stop stop-color="red" offset="65%"></stop>
          </linearGradient>
        </defs>
        <text x="0" y="2" font-family="weasyprint" font-size="2" fill="url(#grad)">
          A
        </text>
      </svg>
    ''')


@assert_no_logs
def test_bounding_box_path_hv(assert_pixels):
    assert_pixels('''
        BBBBB
        BBBBR
        BBBRR
        BBRRR
        BRRRR
    ''', '''
      <style>
        @page { size: 5px }
        svg { display: block }
      </style>
      <svg width="5px" height="5px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="1" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="55%"></stop>
            <stop stop-color="red" offset="55%"></stop>
          </linearGradient>
        </defs>
        <path d="m 5 0 v 5 h -5 V 0 H 5 z" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_bounding_box_path_l(assert_pixels):
    assert_pixels('''
        BBBBB
        BBBBR
        BBBRR
        BBRRR
        BRRRR
    ''', '''
      <style>
        @page { size: 5px }
        svg { display: block }
      </style>
      <svg width="5px" height="5px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="1" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="55%"></stop>
            <stop stop-color="red" offset="55%"></stop>
          </linearGradient>
        </defs>
        <path d="M 5 0 l 0 5 l -5 0 L 0 0 z" fill="url(#grad)" />
      </svg>
    ''')


@pytest.mark.xfail
@assert_no_logs
def test_bounding_box_path_c(assert_pixels):
    assert_pixels('''
        BBB__
        BBR__
        _____
        BBB__
        BBR__
    ''', '''
      <style>
        @page { size: 5px }
        svg { display: block }
      </style>
      <svg width="5px" height="5px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="1" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="55%"></stop>
            <stop stop-color="red" offset="55%"></stop>
          </linearGradient>
        </defs>
        <g fill="none" stroke="url(#grad)" stroke-width="2">
          <path d="M 0 1 C 0 1 1 1 3 1" />
          <path d="M 0 4 c 0 0 1 0 3 0" />
        </g>
      </svg>
    ''')


@pytest.mark.xfail
@assert_no_logs
def test_bounding_box_path_s(assert_pixels):
    assert_pixels('''
        BBB__
        BBR__
        _____
        BBB__
        BBR__
    ''', '''
      <style>
        @page { size: 5px }
        svg { display: block }
      </style>
      <svg width="5px" height="5px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="1" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="55%"></stop>
            <stop stop-color="red" offset="55%"></stop>
          </linearGradient>
        </defs>
        <g fill="none" stroke="url(#grad)" stroke-width="2">
          <path d="M 0 1 S 1 1 3 1" />
          <path d="M 0 4 s 1 0 3 0" />
        </g>
      </svg>
    ''')


@assert_no_logs
def test_svg_empty_size(assert_pixels):
    assert_pixels('''
        BBB__
        BBB__
        BBB__
        BBB__
        _____
    ''', '''
      <style>
        @page { size: 5px }
        svg { display: block }
      </style>
      <svg xmlns="http://www.w3.org/2000/svg">
        <rect x="0" y="0" width="3" height="4" fill="blue" />
      </svg>
    ''')


@assert_no_logs
def test_bounding_box_use_opacity(assert_pixels):
    assert_pixels('''
        sssss
        sssss
        sssss
        sssss
        sssss
    ''', '''
      <style>
        @page { size: 5px }
        svg { display: block }
      </style>
      <svg width="5px" height="5px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <rect id="rect" x="-10" y="-10" width="5" height="5" fill="red" />
        </defs>
        <use href="#rect" opacity="0.5" x="10" y="10" />
      </svg>
    ''')


================================================
FILE: tests/draw/svg/test_clip.py
================================================
"""Test clip-path attribute."""

import pytest

from ...testing_utils import assert_no_logs


@assert_no_logs
def test_clip_path(assert_pixels):
    assert_pixels('''
        _________
        _________
        __RRRRR__
        __RBBBR__
        __RBBBR__
        __RBBBR__
        __RRRRR__
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <clipPath id="clip">
            <rect x="2" y="2" width="5" height="5" />
          </clipPath>
        </defs>
        <rect x="2" y="2" width="5" height="5" stroke-width="2"
              stroke="red" fill="blue" clip-path="url(#clip)" />
      </svg>
    ''')


@assert_no_logs
def test_clip_path_on_group(assert_pixels):
    assert_pixels('''
        _________
        _________
        __BBBB___
        __BRRRR__
        __BRRRR__
        __BRRRR__
        ___RRRR__
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <clipPath id="clip">
            <rect x="2" y="2" width="5" height="5" />
          </clipPath>
        </defs>
        <g clip-path="url(#clip)">
          <rect x="1" y="1" width="5" height="5" fill="blue" />
          <rect x="3" y="3" width="5" height="5" fill="red" />
        </g>
      </svg>
    ''')


@pytest.mark.xfail
@assert_no_logs
def test_clip_path_group_on_group(assert_pixels):
    assert_pixels(9, 9, '''
        _________
        _________
        __BB_____
        __BR_____
        _________
        _____RR__
        _____RR__
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <clipPath id="clip">
            <rect x="2" y="2" width="2" height="2" />
            <rect x="3" y="3" width="2" height="2" />
          </clipPath>
        </defs>
        <g clip-path="url(#clip)">
          <rect x="1" y="1" width="5" height="5" fill="blue" />
          <rect x="3" y="3" width="5" height="5" fill="red" />
        </g>
      </svg>
    ''')


@assert_no_logs
def test_clip_path_outside_defs(assert_pixels):
    # Regression test for #2662.
    assert_pixels('''
        _________
        _________
        __RRRRR__
        __RBBBR__
        __RBBBR__
        __RBBBR__
        __RRRRR__
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <clipPath id="clip">
          <rect x="2" y="2" width="5" height="5" />
        </clipPath>
        <rect x="2" y="2" width="5" height="5" stroke-width="2"
              stroke="red" fill="blue" clip-path="url(#clip)" />
      </svg>
    ''')


================================================
FILE: tests/draw/svg/test_defs.py
================================================
"""Test how SVG definitions are drawn."""

from base64 import b64encode

from ...testing_utils import assert_no_logs

SVG = '''
<svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
  <defs>
    <rect id="rectangle" width="5" height="2" fill="red" />
    <symbol id="square">
      <rect width="2" height="2" fill="blue" />
    </symbol>
  </defs>
  <use href="#rectangle" />
  <use href="#square" x="3" y="3" />
  <use href="#rectangle" x="5" y="6" />
</svg>
'''

STYLE = '''
<style>
  @page { size: 10px }
  svg, img { display: block }
</style>
'''

RESULT = '''
  RRRRR_____
  RRRRR_____
  __________
  ___BB_____
  ___BB_____
  __________
  _____RRRRR
  _____RRRRR
  __________
  __________
'''


@assert_no_logs
def test_use(assert_pixels):
    assert_pixels(RESULT, STYLE + SVG)


@assert_no_logs
def test_use_base64(assert_pixels):
    base64_svg = b64encode(SVG.encode()).decode()
    assert_pixels(RESULT, f'{STYLE}<img src="data:image/svg+xml;base64,{base64_svg}"/>')


@assert_no_logs
def test_use_symbol_color(assert_pixels):
    # Regression test for #2676.
    svg = SVG.replace('fill="blue"', '')
    svg = svg.replace('href="#square"', 'href="#square" fill="blue"')
    assert_pixels(RESULT, STYLE + svg)


================================================
FILE: tests/draw/svg/test_gradients.py
================================================
"""Test how SVG simple gradients are drawn."""

import pytest

from ...testing_utils import assert_no_logs


@assert_no_logs
def test_linear_gradient(assert_pixels):
    assert_pixels('''
        __________
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _RRRRRRRR_
        _RRRRRRRR_
        _RRRRRRRR_
        _RRRRRRRR_
        __________
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="50%"></stop>
            <stop stop-color="red" offset="50%"></stop>
          </linearGradient>
        </defs>
        <rect x="1" y="1" width="8" height="8" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_userspace(assert_pixels):
    assert_pixels('''
        __________
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _RRRRRRRR_
        _RRRRRRRR_
        _RRRRRRRR_
        _RRRRRRRR_
        __________
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="10"
            gradientUnits="userSpaceOnUse">
            <stop stop-color="blue" offset="50%"></stop>
            <stop stop-color="red" offset="50%"></stop>
          </linearGradient>
        </defs>
        <rect x="1" y="1" width="8" height="8" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_multicolor(assert_pixels):
    assert_pixels('''
        __________
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        RRRRRRRRRR
        GGGGGGGGGG
        GGGGGGGGGG
        vvvvvvvvvv
        vvvvvvvvvv
        __________
    ''', '''
      <style>
        @page { size: 10px 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="lime" offset="50%"></stop>
            <stop stop-color="lime" offset="75%"></stop>
            <stop stop-color="rgb(128,0,128)" offset="75%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="1" width="10" height="8" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_multicolor_userspace(assert_pixels):
    assert_pixels('''
        __________
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        RRRRRRRRRR
        GGGGGGGGGG
        GGGGGGGGGG
        vvvvvvvvvv
        vvvvvvvvvv
        __________
    ''', '''
      <style>
        @page { size: 10px 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="10"
            gradientUnits="userSpaceOnUse">
            <stop stop-color="blue" offset="30%"></stop>
            <stop stop-color="red" offset="30%"></stop>
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="lime" offset="50%"></stop>
            <stop stop-color="lime" offset="70%"></stop>
            <stop stop-color="rgb(128,0,128)" offset="70%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="1" width="10" height="8" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_transform(assert_pixels):
    assert_pixels('''
        __________
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        GGGGGGGGGG
        vvvvvvvvvv
        __________
    ''', '''
      <style>
        @page { size: 10px 10px}
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="1"
            gradientUnits="objectBoundingBox"
            gradientTransform="matrix(0.5, 0, 0, 0.5, 0, 0.5)">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="lime" offset="50%"></stop>
            <stop stop-color="lime" offset="75%"></stop>
            <stop stop-color="rgb(128,0,128)" offset="75%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="1" width="10" height="8" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_transform_nested(assert_pixels):
    assert_pixels('''
        __________
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        GGGGGGGGGG
        vvvvvvvvvv
        __________
    ''', '''
      <style>
        @page { size: 10px 10px}
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="1"
            gradientUnits="objectBoundingBox"
            gradientTransform="matrix(0.5, 0, 0, 0.5, 0, 0.5)">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="lime" offset="50%"></stop>
            <stop stop-color="lime" offset="75%"></stop>
            <stop stop-color="rgb(128,0,128)" offset="75%"></stop>
          </linearGradient>
        </defs>
        <rect transform="matrix(-2, 0, 0, 1, 10, 100)"
              x="0" y="-99" width="20" height="8" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_transform_repeat(assert_pixels):
    assert_pixels('''
        __________
        BBBBBBBBBB
        RRRRRRRRRR
        GGGGGGGGGG
        zvvvvvvvvz
        BBBBBBBBBB
        RRRRRRRRRR
        GGGGGGGGGG
        vvvvvvvvvv
        __________
    ''', '''
      <style>
        @page { size: 10px 10px}
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="1"
            gradientUnits="objectBoundingBox" spreadMethod="repeat"
            gradientTransform="matrix(0.5, 0, 0, 0.5, 0, 0.5)">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="lime" offset="50%"></stop>
            <stop stop-color="lime" offset="75%"></stop>
            <stop stop-color="rgb(128,0,128)" offset="75%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="1" width="10" height="8" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_userspace_transform(assert_pixels):
    assert_pixels('''
        __________
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        GGGGGGGGGG
        vvvvvvvvvv
        __________
    ''', '''
      <style>
        @page { size: 10px 10px}
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="8"
            gradientUnits="userSpaceOnUse"
            gradientTransform="matrix(0.5, 0, 0, 0.5, 0, 5)">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="lime" offset="50%"></stop>
            <stop stop-color="lime" offset="75%"></stop>
            <stop stop-color="rgb(128,0,128)" offset="75%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="1" width="10" height="8" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_userspace_transform_nested(assert_pixels):
    assert_pixels('''
        __________
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        GGGGGGGGGG
        vvvvvvvvvv
        __________
    ''', '''
      <style>
        @page { size: 10px 10px}
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="8"
            gradientUnits="userSpaceOnUse"
            gradientTransform="matrix(0.5, 0, 0, 0.5, 0, 4)">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="lime" offset="50%"></stop>
            <stop stop-color="lime" offset="75%"></stop>
            <stop stop-color="rgb(128,0,128)" offset="75%"></stop>
          </linearGradient>
        </defs>
        <rect transform="matrix(-2, 0, 0, 1, 10, 1)"
              x="0" y="0" width="20" height="8" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_transform_repeat_userspace(assert_pixels):
    assert_pixels('''
        __________
        BBBBBBBBBB
        RRRRRRRRRR
        GGGGGGGGGG
        zvvvvvvvvz
        BBBBBBBBBB
        RRRRRRRRRR
        GGGGGGGGGG
        vvvvvvvvvv
        __________
    ''', '''
      <style>
        @page { size: 10px 10px}
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="8"
            gradientUnits="userSpaceOnUse" spreadMethod="repeat"
            gradientTransform="matrix(0.5, 0, 0, 0.5, 0, 5)">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="lime" offset="50%"></stop>
            <stop stop-color="lime" offset="75%"></stop>
            <stop stop-color="rgb(128,0,128)" offset="75%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="1" width="10" height="8" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_repeat(assert_pixels):
    assert_pixels('''
        __________
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        RRRRRRRRRR
        GGGGGGGGGG
        GGGGGGGGGG
        vvvvvvvvvv
        vvvvvvvvvv
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        RRRRRRRRRR
        GGGGGGGGGG
        GGGGGGGGGG
        vvvvvvvvvv
        vvvvvvvvvv
        __________
    ''', '''
      <style>
        @page { size: 10px 18px }
        svg { display: block }
      </style>
      <svg width="11px" height="18px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="0.5"
            gradientUnits="objectBoundingBox" spreadMethod="repeat">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="lime" offset="50%"></stop>
            <stop stop-color="lime" offset="75%"></stop>
            <stop stop-color="rgb(128,0,128)" offset="75%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="1" width="11" height="16" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_repeat_long(assert_pixels):
    assert_pixels('''
        __________
        BBBBBBBBBB
        RRRRRRRRRR
        GGGGGGGGGG
        vvvvvvvvvv
        BBBBBBBBBB
        RRRRRRRRRR
        GGGGGGGGGG
        vvvvvvvvvv
        BBBBBBBBBB
        RRRRRRRRRR
        GGGGGGGGGG
        vvvvvvvvvv
        BBBBBBBBBB
        RRRRRRRRRR
        GGGGGGGGGG
        vvvvvvvvvv
        __________
    ''', '''
      <style>
        @page { size: 10px 18px }
        svg { display: block }
      </style>
      <svg width="11px" height="18px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="0.25"
            gradientUnits="objectBoundingBox" spreadMethod="repeat">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="lime" offset="50%"></stop>
            <stop stop-color="lime" offset="75%"></stop>
            <stop stop-color="rgb(128,0,128)" offset="75%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="1" width="11" height="16" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_repeat_userspace(assert_pixels):
    assert_pixels('''
        __________
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        RRRRRRRRRR
        GGGGGGGGGG
        GGGGGGGGGG
        vvvvvvvvvv
        vvvvvvvvvv
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        RRRRRRRRRR
        GGGGGGGGGG
        GGGGGGGGGG
        vvvvvvvvvv
        vvvvvvvvvv
        __________
    ''', '''
      <style>
        @page { size: 10px 18px }
        svg { display: block }
      </style>
      <svg width="11px" height="18px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="1" x2="0" y2="9"
            gradientUnits="userSpaceOnUse" spreadMethod="repeat">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="lime" offset="50%"></stop>
            <stop stop-color="lime" offset="75%"></stop>
            <stop stop-color="rgb(128,0,128)" offset="75%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="1" width="11" height="16" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_reflect(assert_pixels):
    assert_pixels('''
        __________
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        RRRRRRRRRR
        GGGGGGGGGG
        GGGGGGGGGG
        vvvvvvvvvv
        vvvvvvvvvv
        vvvvvvvvvv
        vvvvvvvvvv
        GGGGGGGGGG
        GGGGGGGGGG
        RRRRRRRRRR
        RRRRRRRRRR
        BBBBBBBBBB
        BBBBBBBBBB
        __________
    ''', '''
      <style>
        @page { size: 10px 18px }
        svg { display: block }
      </style>
      <svg width="11px" height="18px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="0.5"
            gradientUnits="objectBoundingBox" spreadMethod="reflect">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="lime" offset="50%"></stop>
            <stop stop-color="lime" offset="75%"></stop>
            <stop stop-color="rgb(128,0,128)" offset="75%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="1" width="11" height="16" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_reflect_userspace(assert_pixels):
    assert_pixels('''
        __________
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        RRRRRRRRRR
        GGGGGGGGGG
        GGGGGGGGGG
        vvvvvvvvvv
        vvvvvvvvvv
        vvvvvvvvvv
        vvvvvvvvvv
        GGGGGGGGGG
        GGGGGGGGGG
        RRRRRRRRRR
        RRRRRRRRRR
        BBBBBBBBBB
        BBBBBBBBBB
        __________
    ''', '''
      <style>
        @page { size: 10px 18px }
        svg { display: block }
      </style>
      <svg width="11px" height="18px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="1" x2="0" y2="9"
            gradientUnits="userSpaceOnUse" spreadMethod="reflect">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="lime" offset="50%"></stop>
            <stop stop-color="lime" offset="75%"></stop>
            <stop stop-color="rgb(128,0,128)" offset="75%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="1" width="11" height="16" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_inherit_attributes(assert_pixels):
    assert_pixels('''
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        RRRRRRRRRR
        RRRRRRRRRR
        RRRRRRRRRR
        RRRRRRRRRR
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="parent" x1="0" y1="0" x2="0" y2="1"
            gradientUnits="objectBoundingBox">
          </linearGradient>
          <linearGradient id="grad" href="#parent">
            <stop stop-color="blue" offset="50%"></stop>
            <stop stop-color="red" offset="50%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="0" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_inherit_children(assert_pixels):
    assert_pixels('''
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        RRRRRRRRRR
        RRRRRRRRRR
        RRRRRRRRRR
        RRRRRRRRRR
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="parent">
            <stop stop-color="blue" offset="50%"></stop>
            <stop stop-color="red" offset="50%"></stop>
          </linearGradient>
          <linearGradient id="grad" href="#parent"
            x1="0" y1="0" x2="0" y2="1" gradientUnits="objectBoundingBox">
          </linearGradient>
        </defs>
        <rect x="0" y="0" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_linear_gradient_inherit_no_override(assert_pixels):
    assert_pixels('''
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        RRRRRRRRRR
        RRRRRRRRRR
        RRRRRRRRRR
        RRRRRRRRRR
        RRRRRRRRRR
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="parent"
            x1="1" y1="1" x2="1" y2="0" gradientUnits="userSpaceOnUse">
            <stop stop-color="red" offset="50%"></stop>
            <stop stop-color="blue" offset="50%"></stop>
          </linearGradient>
          <linearGradient id="grad" href="#parent"
            x1="0" y1="0" x2="0" y2="1" gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="50%"></stop>
            <stop stop-color="red" offset="50%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="0" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_radial_gradient(assert_pixels):
    assert_pixels('''
        ____________
        _rrrrrrrrrr_
        _rrrrrrrrrr_
        _rrrrBBrrrr_
        _rrrBBBBrrr_
        _rrBBBBBBrr_
        _rrBBBBBBrr_
        _rrrBBBBrrr_
        _rrrrBBrrrr_
        _rrrrrrrrrr_
        _rrrrrrrrrr_
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <radialGradient id="grad" cx="0.5" cy="0.5" r="0.5"
            fx="0.5" fy="0.5" fr="0.2"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
          </radialGradient>
        </defs>
        <rect x="1" y="1" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_radial_gradient_transform(assert_pixels):
    assert_pixels('''
        ____________
        _rrrrrrrrrr_
        _rrrrrrrrrr_
        _rrrrBBrrrr_
        _rrrBBBBrrr_
        _rrBBBBBBrr_
        _rrBBBBBBrr_
        _rrrBBBBrrr_
        _rrrrBBrrrr_
        _rrrrrrrrrr_
        _rrrrrrrrrr_
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <radialGradient id="grad" cx="-1" cy="-1" r="1"
            fx="-1" fy="-1" fr="0.4"
            gradientTransform="matrix(0.5, 0, 0, 0.5, 1, 1)"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
          </radialGradient>
        </defs>
        <rect x="1" y="1" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_radial_gradient_transform_nested(assert_pixels):
    assert_pixels('''
        ____________
        _rrrrrrrrrr_
        _rrrrrrrrrr_
        _rrrrBBrrrr_
        _rrrBBBBrrr_
        _rrBBBBBBrr_
        _rrBBBBBBrr_
        _rrrBBBBrrr_
        _rrrrBBrrrr_
        _rrrrrrrrrr_
        _rrrrrrrrrr_
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <radialGradient id="grad" cx="-1" cy="-1" r="1"
            fx="-1" fy="-1" fr="0.4"
            gradientTransform="matrix(0.5, 0, 0, 0.5, 1, 1)"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
          </radialGradient>
        </defs>
        <rect transform="matrix(1, 0, 0, 1, 10, 10)"
              x="-9" y="-9" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_radial_gradient_userspace(assert_pixels):
    assert_pixels('''
        ____________
        _rrrrrrrrrr_
        _rrrrrrrrrr_
        _rrrrBBrrrr_
        _rrrBBBBrrr_
        _rrBBBBBBrr_
        _rrBBBBBBrr_
        _rrrBBBBrrr_
        _rrrrBBrrrr_
        _rrrrrrrrrr_
        _rrrrrrrrrr_
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <radialGradient id="grad" cx="6" cy="6" r="5" fx="6" fy="6" fr="2"
            gradientUnits="userSpaceOnUse">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
          </radialGradient>
        </defs>
        <rect x="1" y="1" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_radial_gradient_userspace_transform(assert_pixels):
    assert_pixels('''
        ____________
        _rrrrrrrrrr_
        _rrrrrrrrrr_
        _rrrrBBrrrr_
        _rrrBBBBrrr_
        _rrBBBBBBrr_
        _rrBBBBBBrr_
        _rrrBBBBrrr_
        _rrrrBBrrrr_
        _rrrrrrrrrr_
        _rrrrrrrrrr_
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <radialGradient id="grad" cx="-8" cy="-8" r="10" fx="-8" fy="-8" fr="4"
            gradientTransform="matrix(0.5, 0, 0, 0.5, 10, 10)"
            gradientUnits="userSpaceOnUse">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
          </radialGradient>
        </defs>
        <rect x="1" y="1" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_radial_gradient_userspace_transform_nested(assert_pixels):
    assert_pixels('''
        ____________
        _rrrrrrrrrr_
        _rrrrrrrrrr_
        _rrrrBBrrrr_
        _rrrBBBBrrr_
        _rrBBBBBBrr_
        _rrBBBBBBrr_
        _rrrBBBBrrr_
        _rrrrBBrrrr_
        _rrrrrrrrrr_
        _rrrrrrrrrr_
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <radialGradient id="grad" cx="-28" cy="-28" r="10" fx="-28" fy="-28" fr="4"
            gradientTransform="matrix(0.5, 0, 0, 0.5, 10, 10)"
            gradientUnits="userSpaceOnUse">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
          </radialGradient>
        </defs>
        <rect transform="matrix(1, 0, 0, 1, 10, 10)"
              x="-9" y="-9" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_radial_gradient_multicolor(assert_pixels):
    assert_pixels('''
        ____________
        _rrrrrrrrrr_
        _rrrGGGGrrr_
        _rrGGBBGGrr_
        _rGGBBBBGGr_
        _rGBBBBBBGr_
        _rGBBBBBBGr_
        _rGGBBBBGGr_
        _rrGGBBGGrr_
        _rrrGGGGrrr_
        _rrrrrrrrrr_
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <radialGradient id="grad" cx="0.5" cy="0.5" r="0.5"
            fx="0.5" fy="0.5" fr="0.2"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="33%"></stop>
            <stop stop-color="lime" offset="33%"></stop>
            <stop stop-color="lime" offset="66%"></stop>
            <stop stop-color="red" offset="66%"></stop>
          </radialGradient>
        </defs>
        <rect x="1" y="1" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_radial_gradient_multicolor_userspace(assert_pixels):
    assert_pixels('''
        ____________
        _rrrrrrrrrr_
        _rrrGGGGrrr_
        _rrGGBBGGrr_
        _rGGBBBBGGr_
        _rGBBBBBBGr_
        _rGBBBBBBGr_
        _rGGBBBBGGr_
        _rrGGBBGGrr_
        _rrrGGGGrrr_
        _rrrrrrrrrr_
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <radialGradient id="grad" cx="6" cy="6" r="5"
            fx="6" fy="6" fr="2"
            gradientUnits="userSpaceOnUse">
            <stop stop-color="blue" offset="33%"></stop>
            <stop stop-color="lime" offset="33%"></stop>
            <stop stop-color="lime" offset="66%"></stop>
            <stop stop-color="red" offset="66%"></stop>
          </radialGradient>
        </defs>
        <rect x="1" y="1" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_radial_gradient_repeat(assert_pixels):
    assert_pixels('''
        ____________
        _GBBzzzzBBG_
        _BrrGGGGrrB_
        _BrGBBBBGrB_
        _zGBBrrBBGz_
        _zGBrGGrBGz_
        _zGBrGGrBGz_
        _zGBBrrBBGz_
        _BrGBBBBGrB_
        _BrrGGGGrrB_
        _GBBzzzzBBG_
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <radialGradient id="grad" cx="0.5" cy="0.5" r="0.5"
            fx="0.5" fy="0.5" fr="0.2"
            gradientUnits="objectBoundingBox" spreadMethod="repeat">
            <stop stop-color="blue" offset="33%"></stop>
            <stop stop-color="lime" offset="33%"></stop>
            <stop stop-color="lime" offset="66%"></stop>
            <stop stop-color="red" offset="66%"></stop>
          </radialGradient>
        </defs>
        <rect x="1" y="1" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_radial_gradient_reflect(assert_pixels):
    assert_pixels('''
        ____________
        _GrrzzzzrrG_
        _rrrGGGGrrr_
        _rrGBBBBGrr_
        _zGBBBBBBGz_
        _zGBBGGBBGz_
        _zGBBGGBBGz_
        _zGBBBBBBGz_
        _rrGBBBBGrr_
        _rrrGGGGrrr_
        _GrrzzzzrrG_
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <radialGradient id="grad" cx="0.5" cy="0.5" r="0.5"
            fx="0.5" fy="0.5" fr="0.2"
            gradientUnits="objectBoundingBox" spreadMethod="reflect">
            <stop stop-color="blue" offset="33%"></stop>
            <stop stop-color="lime" offset="33%"></stop>
            <stop stop-color="lime" offset="66%"></stop>
            <stop stop-color="red" offset="66%"></stop>
          </radialGradient>
        </defs>
        <rect x="1" y="1" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_radial_gradient_inherit_attributes(assert_pixels):
    assert_pixels('''
        rrrrrrrrrr
        rrrrrrrrrr
        rrrrBBrrrr
        rrrBBBBrrr
        rrBBBBBBrr
        rrBBBBBBrr
        rrrBBBBrrr
        rrrrBBrrrr
        rrrrrrrrrr
        rrrrrrrrrr
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <radialGradient id="parent" cx="0.5" cy="0.5" r="0.5"
            fx="0.5" fy="0.5" fr="0.2"
            gradientUnits="objectBoundingBox">
          </radialGradient>
          <radialGradient id="grad" href="#parent">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
          </radialGradient>
        </defs>
        <rect x="0" y="0" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_radial_gradient_inherit_children(assert_pixels):
    assert_pixels('''
        rrrrrrrrrr
        rrrrrrrrrr
        rrrrBBrrrr
        rrrBBBBrrr
        rrBBBBBBrr
        rrBBBBBBrr
        rrrBBBBrrr
        rrrrBBrrrr
        rrrrrrrrrr
        rrrrrrrrrr
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <radialGradient id="parent">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
          </radialGradient>
          <radialGradient id="grad" href="#parent"
            cx="0.5" cy="0.5" r="0.5" fx="0.5" fy="0.5" fr="0.2"
            gradientUnits="objectBoundingBox">
          </radialGradient>
        </defs>
        <rect x="0" y="0" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_radial_gradient_inherit_no_override(assert_pixels):
    assert_pixels('''
        rrrrrrrrrr
        rrrrrrrrrr
        rrrrBBrrrr
        rrrBBBBrrr
        rrBBBBBBrr
        rrBBBBBBrr
        rrrBBBBrrr
        rrrrBBrrrr
        rrrrrrrrrr
        rrrrrrrrrr
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <radialGradient id="parent" cx="5" cy="5" r="5" fx="5" fy="5" fr="2"
            gradientUnits="userSpaceOnUse">
            <stop stop-color="red" offset="25%"></stop>
            <stop stop-color="blue" offset="25%"></stop>
          </radialGradient>
          <radialGradient id="grad" href="#parent" cx="0.5" cy="0.5" r="0.5"
            fx="0.5" fy="0.5" fr="0.2"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="25%"></stop>
            <stop stop-color="red" offset="25%"></stop>
          </radialGradient>
        </defs>
        <rect x="0" y="0" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
def test_gradient_opacity(assert_pixels):
    assert_pixels('''
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        ssssssssss
        ssssssssss
        ssssssssss
        ssssssssss
        ssssssssss
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue" offset="50%"></stop>
            <stop stop-color="red" stop-opacity="0.502" offset="50%"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="0" width="10" height="10" fill="url(#grad)" />
      </svg>
    ''')


@assert_no_logs
@pytest.mark.parametrize('url', ["#grad'", "'#gra", '!', '#'])
def test_gradient_bad_url(assert_pixels, url):
    assert_pixels('''
        __________
        __________
        __________
        __________
        __________
        __________
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <linearGradient id="grad" x1="0" y1="0" x2="0" y2="1"
            gradientUnits="objectBoundingBox">
            <stop stop-color="blue"></stop>
          </linearGradient>
        </defs>
        <rect x="0" y="0" width="10" height="10" fill="url(%s)" />
      </svg>
    ''' % url)


================================================
FILE: tests/draw/svg/test_images.py
================================================
"""Test how images are drawn in SVG."""

import pytest

from weasyprint.urls import path2url

from ...testing_utils import assert_no_logs, resource_path


@assert_no_logs
def test_image_svg(assert_pixels):
    assert_pixels('''
        ____
        ____
        __B_
        ____
    ''', '''
      <style>
        @page { size: 4px 4px }
        svg { display: block }
      </style>
      <svg width="4px" height="4px" xmlns="http://www.w3.org/2000/svg">
        <svg x="1" y="1" width="2" height="2" viewBox="0 0 10 10">
          <rect x="5" y="5" width="5" height="5" fill="blue" />
        </svg>
      </svg>
    ''')


@assert_no_logs
def test_image_svg_viewbox(assert_pixels):
    assert_pixels('''
        ____
        ____
        __B_
        ____
    ''', '''
      <style>
        @page { size: 4px 4px }
        svg { display: block }
      </style>
      <svg viewBox="0 0 4 4" xmlns="http://www.w3.org/2000/svg">
        <svg x="1" y="1" width="2" height="2" viewBox="10 10 10 10">
          <rect x="15" y="15" width="5" height="5" fill="blue" />
        </svg>
      </svg>
    ''')


@assert_no_logs
def test_image_svg_align_default(assert_pixels):
    assert_pixels('''
        __BRRR__
        __BRRR__
        __RRRG__
        __RRRG__
        ________
        ________
        ________
        ________
    ''', '''
      <style>
        @page { size: 8px 8px }
        svg { display: block }
      </style>
      <svg width="8px" height="4px" viewBox="0 0 4 4"
           xmlns="http://www.w3.org/2000/svg">
        <rect width="4" height="4" fill="red" />
        <rect width="1" height="2" fill="blue" />
        <rect x="3" y="2" width="1" height="2" fill="lime" />
      </svg>
    ''')


@assert_no_logs
def test_image_svg_align_none(assert_pixels):
    assert_pixels('''
        BBRRRRRR
        BBRRRRRR
        RRRRRRGG
        RRRRRRGG
        ________
        ________
        ________
        ________
    ''', '''
      <style>
        @page { size: 8px 8px }
        svg { display: block }
      </style>
      <svg width="8px" height="4px" viewBox="0 0 4 4"
           preserveAspectRatio="none"
           xmlns="http://www.w3.org/2000/svg">
        <rect width="4" height="4" fill="red" />
        <rect width="1" height="2" fill="blue" />
        <rect x="3" y="2" width="1" height="2" fill="lime" />
      </svg>
    ''')


@assert_no_logs
def test_image_svg_align_no_viewbox(assert_pixels):
    assert_pixels('''
        BBRRRRRR
        BBRRRRRR
        RRRRRRGG
        RRRRRRGG
        ________
        ________
        ________
        ________
    ''', '''
      <style>
        @page { size: 8px 8px }
        svg { display: block; height: 4px; width: 8px }
      </style>
      <svg width="4px" height="4px"
           xmlns="http://www.w3.org/2000/svg">
        <rect width="4" height="4" fill="red" />
        <rect width="1" height="2" fill="blue" />
        <rect x="3" y="2" width="1" height="2" fill="lime" />
      </svg>
    ''')


@assert_no_logs
def test_image_svg_align_meet_x(assert_pixels):
    assert_pixels('''
        ____BRRR
        ____BRRR
        ____RRRG
        ____RRRG
        ________
        ________
        ________
        ________
    ''', '''
      <style>
        @page { size: 8px 8px }
        svg { display: block }
      </style>
      <svg width="8px" height="4px" viewBox="0 0 4 4"
           preserveAspectRatio="xMaxYMax meet"
           xmlns="http://www.w3.org/2000/svg">
        <rect width="4" height="4" fill="red" />
        <rect width="1" height="2" fill="blue" />
        <rect x="3" y="2" width="1" height="2" fill="lime" />
      </svg>
    ''')


@assert_no_logs
def test_image_svg_align_meet_y(assert_pixels):
    assert_pixels('''
        ________
        ________
        ________
        ________
        BRRR____
        BRRR____
        RRRG____
        RRRG____
    ''', '''
      <style>
        @page { size: 8px 8px }
        svg { display: block }
      </style>
      <svg width="4px" height="8px" viewBox="0 0 4 4"
           preserveAspectRatio="xMaxYMax meet"
           xmlns="http://www.w3.org/2000/svg">
        <rect width="4" height="4" fill="red" />
        <rect width="1" height="2" fill="blue" />
        <rect x="3" y="2" width="1" height="2" fill="lime" />
      </svg>
    ''')


@assert_no_logs
def test_image_svg_align_slice_x(assert_pixels):
    assert_pixels('''
        BBRRRRRR
        BBRRRRRR
        BBRRRRRR
        BBRRRRRR
        ________
        ________
        ________
        ________
    ''', '''
      <style>
        @page { size: 8px 8px }
        svg { display: block; overflow: hidden }
      </style>
      <svg width="8px" height="4px" viewBox="0 0 4 4"
           preserveAspectRatio="xMinYMin slice"
           xmlns="http://www.w3.org/2000/svg">
        <rect width="4" height="4" fill="red" />
        <rect width="1" height="2" fill="blue" />
        <rect x="3" y="2" width="1" height="2" fill="lime" />
      </svg>
    ''')


@assert_no_logs
def test_image_svg_align_slice_y(assert_pixels):
    assert_pixels('''
        BBRR____
        BBRR____
        BBRR____
        BBRR____
        RRRR____
        RRRR____
        RRRR____
        RRRR____
    ''', '''
      <style>
        @page { size: 8px 8px }
        svg { display: block; overflow: hidden }
      </style>
      <svg width="4px" height="8px" viewBox="0 0 4 4"
           preserveAspectRatio="xMinYMin slice"
           xmlns="http://www.w3.org/2000/svg">
        <rect width="4" height="4" fill="red" />
        <rect width="1" height="2" fill="blue" />
        <rect x="3" y="2" width="1" height="2" fill="lime" />
      </svg>
    ''')


@pytest.mark.xfail
@assert_no_logs
def test_image_svg_percentage(assert_pixels):
    assert_pixels('''
        ____
        ____
        __B_
        ____
    ''', '''
      <style>
        @page { size: 4px 4px }
        svg { display: block }
      </style>
      <svg width="100%" height="100%" xmlns="http://www.w3.org/2000/svg">
        <svg x="1" y="1" width="50%" height="50%" viewBox="0 0 10 10">
          <rect x="5" y="5" width="5" height="5" fill="blue" />
        </svg>
      </svg>
    ''')


def test_image_svg_wrong(assert_pixels):
    assert_pixels('''
        ____
        ____
        ____
        ____
    ''', '''
      <style>
        @page { size: 4px 4px }
        svg { display: block }
      </style>
      <svg width="4px" height="4px" xmlns="http://www.w3.org/2000/svg">
        <That’s bad!
      </svg>
    ''')


@assert_no_logs
def test_image_image(assert_pixels):
    assert_pixels('''
        rBBB
        BBBB
        BBBB
        BBBB
    ''', '''
      <style>
        @page { size: 4px 4px }
        svg { display: block }
      </style>
      <svg width="4px" height="4px" xmlns="http://www.w3.org/2000/svg">
        <image xlink:href="%s" />
      </svg>
    ''' % path2url(resource_path('pattern.png')))


@assert_no_logs
def test_image_image_rendering(assert_pixels):
    assert_pixels('''
        rrBBBBBB
        rrBBBBBB
        BBBBBBBB
        BBBBBBBB
        BBBBBBBB
        BBBBBBBB
        BBBBBBBB
        BBBBBBBB
    ''', '''
      <style>
        @page { size: 8px 8px }
        svg { display: block }
      </style>
      <svg width="8px" height="8px" xmlns="http://www.w3.org/2000/svg">
        <image width="8px" height="8px" xlink:href="%s"
            style="image-rendering:pixelated"/>
      </svg>
    ''' % path2url(resource_path('pattern.png')))


def test_image_image_wrong(assert_pixels):
    assert_pixels('''
        ____
        ____
        ____
        ____
    ''', '''
      <style>
        @page { size: 4px 4px }
        svg { display: block }
      </style>
      <svg width="4px" height="4px" xmlns="http://www.w3.org/2000/svg">
        <image xlink:href="it doesn’t exist, mouhahahaha" />
      </svg>
    ''')


@assert_no_logs
def test_image_in_g_height_only(assert_pixels):
    """Test that image inside g with only height set preserves aspect ratio."""
    assert_pixels('''
        rrBBBBBB
        rrBBBBBB
        BBBBBBBB
        BBBBBBBB
        BBBBBBBB
        BBBBBBBB
        BBBBBBBB
        BBBBBBBB
    ''', '''
      <style>
        @page { size: 8px 8px }
        svg { display: block }
      </style>
      <svg width="8px" height="8px" xmlns="http://www.w3.org/2000/svg">
        <g>
          <image image-rendering="pixelated" href="%s" height="8px"/>
        </g>
      </svg>
    ''' % path2url(resource_path('pattern.png')))


@assert_no_logs
def test_image_in_g_width_only(assert_pixels):
    """Test that image inside g with only width set preserves aspect ratio."""
    assert_pixels('''
        rrBBBBBB
        rrBBBBBB
        BBBBBBBB
        BBBBBBBB
        BBBBBBBB
        BBBBBBBB
        BBBBBBBB
        BBBBBBBB
    ''', '''
      <style>
        @page { size: 8px 8px }
        svg { display: block }
      </style>
      <svg width="8px" height="8px" xmlns="http://www.w3.org/2000/svg">
        <g>
          <image image-rendering="pixelated" href="%s" width="8px"/>
        </g>
      </svg>
    ''' % path2url(resource_path('pattern.png')))


================================================
FILE: tests/draw/svg/test_markers.py
================================================
"""Test how SVG markers are drawn."""

from ...testing_utils import assert_no_logs


@assert_no_logs
def test_markers(assert_pixels):
    assert_pixels('''
        ___________
        ___________
        _____RRR___
        _____RRR___
        _____RRR___
        ___________
        _____RRR___
        _____RRR___
        _____RRR___
        ___________
        _____RRR___
        _____RRR___
        _____RRR___
    ''', '''
      <style>
        @page { size: 11px 13px }
        svg { display: block }
      </style>
      <svg width="11px" height="13px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <marker id="rectangle">
            <rect width="3" height="3" fill="red" />
          </marker>
        </defs>
        <path
          d="M 5 2 v 4 v 4"
          marker-start="url(#rectangle)"
          marker-mid="url(#rectangle)"
          marker-end="url(#rectangle)" />
      </svg>
    ''')


@assert_no_logs
def test_markers_viewbox(assert_pixels):
    assert_pixels('''
        ___________
        ____RRR____
        ____RRR____
        ____RRR____
        ___________
        ____RRR____
        ____RRR____
        ____RRR____
        ___________
        ____RRR____
        ____RRR____
        ____RRR____
        ___________
    ''', '''
      <style>
        @page { size: 11px 13px }
        svg { display: block }
      </style>
      <svg width="11px" height="13px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <marker id="rectangle" viewBox="-1 -1 3 3">
            <rect x="-10" y="-10" width="20" height="20" fill="red" />
          </marker>
        </defs>
        <path
          d="M 5 2 v 4 v 4"
          marker-start="url(#rectangle)"
          marker-mid="url(#rectangle)"
          marker-end="url(#rectangle)" />
      </svg>
    ''')


@assert_no_logs
def test_markers_size(assert_pixels):
    assert_pixels('''
        ___________
        ____BBR____
        ____BBR____
        ____RRR____
        ___________
        ____BBR____
        ____BBR____
        ____RRR____
        ___________
        ____BBR____
        ____BBR____
        ____RRR____
        ___________
    ''', '''
      <style>
        @page { size: 11px 13px }
        svg { display: block }
      </style>
      <svg width="11px" height="13px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <marker id="rectangle"
                  refX="1" refY="1" markerWidth="3" markerHeight="3">
            <rect width="6" height="6" fill="red" />
            <rect width="2" height="2" fill="blue" />
          </marker>
        </defs>
        <path
          d="M 5 2 v 4 v 4"
          marker-start="url(#rectangle)"
          marker-mid="url(#rectangle)"
          marker-end="url(#rectangle)" />
      </svg>
    ''')


@assert_no_logs
def test_markers_viewbox_size(assert_pixels):
    assert_pixels('''
        ___________
        ____RRR____
        ____RRR____
        ____RRR____
        ___________
        ____RRR____
        ____RRR____
        ____RRR____
        ___________
        ____RRR____
        ____RRR____
        ____RRR____
        ___________
    ''', '''
      <style>
        @page { size: 11px 13px }
        svg { display: block }
      </style>
      <svg width="11px" height="13px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <marker id="rectangle" viewBox="-10 -10 6 6"
                  refX="-8" refY="-8" markerWidth="3" markerHeight="3">
            <rect x="-10" y="-10" width="6" height="6" fill="red" />
          </marker>
        </defs>
        <path
          d="M 5 2 v 4 v 4"
          marker-start="url(#rectangle)"
          marker-mid="url(#rectangle)"
          marker-end="url(#rectangle)" />
      </svg>
    ''')


def test_markers_overflow(assert_pixels):
    assert_pixels('''
        ___________
        ____BBRR___
        ____BBRR___
        ____RRRR___
        ____RRRR___
        ____BBRR___
        ____BBRR___
        ____RRRR___
        ____RRRR___
        ____BBRR___
        ____BBRR___
        ____RRRR___
        ____RRRR___
    ''', '''
      <style>
        @page { size: 11px 13px }
        svg { display: block }
      </style>
      <svg width="11px" height="13px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <marker id="rectangle" overflow="visible"
                  refX="1" refY="1" markerWidth="3" markerHeight="3">
            <rect width="4" height="4" fill="red" />
            <rect width="2" height="2" fill="blue" />
          </marker>
        </defs>
        <path
          d="M 5 2 v 4 v 4"
          marker-start="url(#rectangle)"
          marker-mid="url(#rectangle)"
          marker-end="url(#rectangle)" />
      </svg>
    ''')


@assert_no_logs
def test_markers_userspace(assert_pixels):
    assert_pixels('''
        ___________
        ___________
        _____R_____
        ___________
        ___________
        ___________
        _____R_____
        ___________
        ___________
        ___________
        _____R_____
        ___________
        ___________
    ''', '''
      <style>
        @page { size: 11px 13px }
        svg { display: block }
      </style>
      <svg width="11px" height="13px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <marker id="rectangle" markerUnits="userSpaceOnUse">
            <rect width="1" height="1" fill="red" />
          </marker>
        </defs>
        <path
          d="M 5 2 v 4 v 4"
          stroke-width="10"
          marker-start="url(#rectangle)"
          marker-mid="url(#rectangle)"
          marker-end="url(#rectangle)" />
      </svg>
    ''')


@assert_no_logs
def test_markers_stroke_width(assert_pixels):
    assert_pixels('''
        ___________
        ___________
        _____RRR___
        _____RRR___
        _____RRR___
        ___________
        _____RRR___
        _____RRR___
        _____RRR___
        ___________
        _____RRR___
        _____RRR___
        _____RRR___
    ''', '''
      <style>
        @page { size: 11px 13px }
        svg { display: block }
      </style>
      <svg width="11px" height="13px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <marker id="rectangle">
            <rect width="1" height="1" fill="red" />
          </marker>
        </defs>
        <path
          d="M 5 2 v 4 v 4"
          stroke-width="3"
          marker-start="url(#rectangle)"
          marker-mid="url(#rectangle)"
          marker-end="url(#rectangle)" />
      </svg>
    ''')


@assert_no_logs
def test_markers_viewbox_stroke_width(assert_pixels):
    assert_pixels('''
        ___________
        ____BRR____
        ____RRR____
        ____RRR____
        ___________
        ____BRR____
        ____RRR____
        ____RRR____
        ___________
        ____BRR____
        ____RRR____
        ____RRR____
        ___________
    ''', '''
      <style>
        @page { size: 11px 13px }
        svg { display: block }
      </style>
      <svg width="11px" height="13px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <marker id="rectangle" viewBox="-1 -1 3 3"
                  markerWidth="1.5" markerHeight="1.5">
            <rect x="-10" y="-10" width="20" height="20" fill="red" />
            <rect x="-1" y="-1" width="1" height="1" fill="blue" />
          </marker>
        </defs>
        <path
          d="M 5 2 v 4 v 4"
          stroke-width="2"
          marker-start="url(#rectangle)"
          marker-mid="url(#rectangle)"
          marker-end="url(#rectangle)" />
      </svg>
    ''')


================================================
FILE: tests/draw/svg/test_opacity.py
================================================
"""Test how opacity is handled for SVG."""

import pytest

from ...testing_utils import assert_no_logs

opacity_source = '''
  <style>
    @page { size: 9px }
    svg { display: block }
  </style>
  <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">%s</svg>'''


@assert_no_logs
def test_opacity(assert_same_renderings):
    assert_same_renderings(
        opacity_source % '''
            <rect x="2" y="2" width="5" height="5" stroke-width="2"
                  stroke="rgb(127, 255, 127)" fill="rgb(127, 127, 255)" />
        ''',
        opacity_source % '''
            <rect x="2" y="2" width="5" height="5" stroke-width="2"
                  stroke="lime" fill="blue" opacity="0.5" />
        ''',
    )


@assert_no_logs
def test_fill_opacity(assert_same_renderings):
    assert_same_renderings(
        opacity_source % '''
            <rect x="2" y="2" width="5" height="5"
                  fill="blue" opacity="50%" />
            <rect x="2" y="2" width="5" height="5" stroke-width="2"
                  stroke="lime" fill="transparent" />
        ''',
        opacity_source % '''
            <rect x="2" y="2" width="5" height="5" stroke-width="2"
                  stroke="lime" fill="blue" fill-opacity="0.5" />
        ''',
    )


@pytest.mark.xfail
@assert_no_logs
def test_stroke_opacity(assert_same_renderings):
    # TODO: This test (and the other ones) fail because of a difference between
    # the PDF and the SVG specifications: transparent borders have to be drawn
    # on top of the shape filling in SVG but not in PDF. See:
    # - PDF-1.7 11.7.4.4 Note 2
    # - https://www.w3.org/TR/SVG2/render.html#PaintingShapesAndText
    assert_same_renderings(
        '''
            <rect x="2" y="2" width="5" height="5"
                  fill="blue" />
            <rect x="2" y="2" width="5" height="5" stroke-width="2"
                  stroke="lime" fill="transparent" opacity="0.5" />
        ''',
        opacity_source % '''
            <rect x="2" y="2" width="5" height="5" stroke-width="2"
                  stroke="lime" fill="blue" stroke-opacity="50%" />
        ''',
    )


@pytest.mark.xfail
@assert_no_logs
def test_stroke_fill_opacity(assert_same_renderings):
    assert_same_renderings(
        opacity_source % '''
            <rect x="2" y="2" width="5" height="5"
                  fill="blue" opacity="0.5" />
            <rect x="2" y="2" width="5" height="5" stroke-width="2"
                  stroke="lime" fill="transparent" opacity="0.5" />
        ''',
        opacity_source % '''
            <rect x="2" y="2" width="5" height="5" stroke-width="2"
                  stroke="lime" fill="blue"
                  stroke-opacity="0.5" fill-opacity="0.5" />
        ''',
    )


@assert_no_logs
def test_pattern_gradient_stroke_fill_opacity(assert_same_renderings):
    assert_same_renderings(
        opacity_source % '''
            <defs>
              <linearGradient id="grad" x1="0" y1="0" x2="0" y2="1"
                              gradientUnits="objectBoundingBox">
                <stop stop-color="black" offset="42.86%"></stop>
                <stop stop-color="green" offset="42.86%"></stop>
              </linearGradient>
              <pattern id="pat" x="0" y="0" width="2" height="2"
                       patternUnits="userSpaceOnUse"
                       patternContentUnits="userSpaceOnUse">
                <rect x="0" y="0" width="1" height="1" fill="blue" />
                <rect x="0" y="1" width="1" height="1" fill="red" />
                <rect x="1" y="0" width="1" height="1" fill="red" />
                <rect x="1" y="1" width="1" height="1" fill="blue" />
              </pattern>
            </defs>
            <rect x="2" y="2" width="5" height="5"
                  fill="url(#pat)" opacity="0.5" />
            <rect x="2" y="2" width="5" height="5" stroke-width="2"
                  stroke="url(#grad)" fill="transparent" opacity="0.5" />
        ''',
        opacity_source % '''
            <defs>
              <linearGradient id="grad" x1="0" y1="0" x2="0" y2="1"
                              gradientUnits="objectBoundingBox">
                <stop stop-color="black" offset="42.86%"></stop>
                <stop stop-color="green" offset="42.86%"></stop>
              </linearGradient>
              <pattern id="pat" x="0" y="0" width="2" height="2"
                       patternUnits="userSpaceOnUse"
                       patternContentUnits="userSpaceOnUse">
                <rect x="0" y="0" width="1" height="1" fill="blue" />
                <rect x="0" y="1" width="1" height="1" fill="red" />
                <rect x="1" y="0" width="1" height="1" fill="red" />
                <rect x="1" y="1" width="1" height="1" fill="blue" />
              </pattern>
            </defs>
            <rect x="2" y="2" width="5" height="5" stroke-width="2"
                  stroke="url(#grad)" fill="url(#pat)"
                  stroke-opacity="0.5" fill-opacity="0.5" />
        ''',
        tolerance=1,
    )


@assert_no_logs
def test_translate_opacity(assert_same_renderings):
    # Regression test for #1976.
    assert_same_renderings(
        opacity_source % '''
            <rect transform="translate(2, 2)" width="5" height="5"
                  fill="blue" opacity="0.5" />
        ''',
        opacity_source % '''
            <rect x="2" y="2" width="5" height="5"
                  fill="blue" opacity="50%" />
        ''',
    )


@assert_no_logs
def test_translate_use_opacity(assert_same_renderings):
    # Regression test for #1976.
    assert_same_renderings(
        opacity_source % '''
            <defs>
              <rect id="rect" x="-10" y="-10" width="5" height="5" fill="blue" />
            </defs>
            <use href="#rect" transform="translate(12, 12)" opacity="0.5" />
        ''',
        opacity_source % '''
            <rect x="2" y="2" width="5" height="5" fill="blue" opacity="50%" />
        ''',
    )


================================================
FILE: tests/draw/svg/test_paths.py
================================================
"""Test how SVG simple paths are drawn."""

from ...testing_utils import assert_no_logs


@assert_no_logs
def test_path_h(assert_pixels):
    assert_pixels('''
        BBBBBBBB__
        BBBBBBBB__
        __________
        RRRRRRRR__
        RRRRRRRR__
        __________
        GGGGGGGG__
        GGGGGGGG__
        BBBBBBBB__
        BBBBBBBB__
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 0 1 H 8 H 1"
          stroke="blue" stroke-width="2" fill="none"/>
        <path d="M 0 4 H 8 4"
          stroke="red" stroke-width="2" fill="none"/>
        <path d="M 0 7 h 8 h 0"
          stroke="lime" stroke-width="2" fill="none"/>
        <path d="M 0 9 h 8 0"
          stroke="blue" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_v(assert_pixels):
    assert_pixels('''
        BB____GG__
        BB____GG__
        BB____GG__
        BB____GG__
        ___RR_____
        ___RR_____
        ___RR___BB
        ___RR___BB
        ___RR___BB
        ___RR___BB
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 1 0 V 1 V 4"
          stroke="blue" stroke-width="2" fill="none"/>
        <path d="M 4 6 V 4 10"
          stroke="red" stroke-width="2" fill="none"/>
        <path d="M 7 0 v 0 v 4"
          stroke="lime" stroke-width="2" fill="none"/>
        <path d="M 9 6 v 0 4"
          stroke="blue" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_l(assert_pixels):
    assert_pixels('''
        ______RR__
        ______RR__
        ______RR__
        ___BB_RR__
        ___BB_RR__
        ___BB_RR__
        ___BB_____
        ___BB_____
        ___BB_____
        ___BB_____
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 4 3 L 4 10"
          stroke="blue" stroke-width="2" fill="none"/>
        <path d="M 7 0 l 0 6"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_z(assert_pixels):
    assert_pixels('''
        BBBBBBB___
        BBBBBBB___
        BB___BB___
        BB___BB___
        BBBBBBB___
        BBBBBBB___
        ____RRRRRR
        ____RRRRRR
        ____RR__RR
        ____RRRRRR
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 1 1 H 6 V 5 H 1 Z"
          stroke="blue" stroke-width="2" fill="none"/>
        <path d="M 9 10 V 7 H 5 V 10 z"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_z_fill(assert_pixels):
    assert_pixels('''
        BBBBBBB___
        BBBBBBB___
        BBGGGBB___
        BBGGGBB___
        BBBBBBB___
        BBBBBBB___
        ____RRRRRR
        ____RRRRRR
        ____RRGGRR
        ____RRRRRR
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 1 1 H 6 V 5 H 1 Z"
          stroke="blue" stroke-width="2" fill="lime"/>
        <path d="M 9 10 V 7 H 5 V 10 z"
          stroke="red" stroke-width="2" fill="lime"/>
      </svg>
    ''')


@assert_no_logs
def test_path_c(assert_pixels):
    assert_pixels('''
        __________
        __________
        __________
        __________
        __BBB_____
        __BBB_____
        __________
        __RRR_____
        __RRR_____
        __________
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 2 5 C 2 5 3 5 5 5"
          stroke="blue" stroke-width="2" fill="none"/>
        <path d="M 2 8 c 0 0 1 0 3 0"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_s(assert_pixels):
    assert_pixels('''
        __________
        __________
        __________
        __________
        __BBB_____
        __BBB_____
        __________
        __RRR_____
        __RRR_____
        __________
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 2 5 S 3 5 5 5"
          stroke="blue" stroke-width="2" fill="none"/>
        <path d="M 2 8 s 1 0 3 0"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_cs(assert_pixels):
    assert_pixels('''
        __BBBBBB__
        __BBBBBBB_
        _____BBBB_
        __RRRRRR__
        __RRRRRRR_
        _____RRRR_
        __GGGGGG__
        __GGGGGGG_
        _____GGGG_
        __BBBBBB__
        __BBBBBBB_
        _____BBBB_
    ''', '''
      <style>
        @page { size: 10px 12px }
        svg { display: block }
      </style>
      <svg width="10px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 2 1 C 2 1 3 1 5 1 S 8 3 8 1"
          stroke="blue" stroke-width="2" fill="none"/>
        <path d="M 2 4 C 2 4 3 4 5 4 s 3 2 1 0"
          stroke="red" stroke-width="2" fill="none"/>
        <path d="M 2 7 c 0 0 1 0 3 0 S 8 9 8 7"
          stroke="lime" stroke-width="2" fill="none"/>
        <path d="M 2 10 c 0 0 1 0 3 0 s 3 2 1 0"
          stroke="blue" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_q(assert_pixels):
    assert_pixels('''
        __________
        __________
        __________
        __________
        __BBBB____
        __BBBB____
        __________
        __RRRR____
        __RRRR____
        __________
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 2 5 Q 4 5 6 5"
          stroke="blue" stroke-width="2" fill="none"/>
        <path d="M 2 8 q 2 0 4 0"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_t(assert_pixels):
    assert_pixels('''
        __________
        __________
        __________
        __________
        __BBBB____
        __BBBB____
        __________
        __RRRR____
        __RRRR____
        __________
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 2 5 T 6 5"
          stroke="blue" stroke-width="2" fill="none"/>
        <path d="M 2 8 t 4 0"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_qt(assert_pixels):
    assert_pixels('''
        _BBBB_______
        BBBBBBB_____
        BBBBBBBB__BB
        BB__BBBBBBBB
        _____BBBBBBB
        _______BBBB_
        _RRRR_______
        RRRRRRR_____
        RRRRRRRR__RR
        RR__RRRRRRRR
        _____RRRRRRR
        _______RRRR_
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 0 3 Q 3 0 6 3 T 12 3"
          stroke="blue" stroke-width="2" fill="none"/>
        <path d="M 0 9 Q 3 6 6 9 t 6 0"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_qt2(assert_pixels):
    assert_pixels('''
        _BBBB_______
        BBBBBBB_____
        BBBBBBBB__BB
        BB__BBBBBBBB
        _____BBBBBBB
        _______BBBB_
        _RRRR_______
        RRRRRRR_____
        RRRRRRRR__RR
        RR__RRRRRRRR
        _____RRRRRRR
        _______RRRR_
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 0 3 q 3 -3 6 0 T 12 3"
          stroke="blue" stroke-width="2" fill="none"/>
        <path d="M 0 9 q 3 -3 6 0 t 6 0"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_a(assert_pixels):
    assert_pixels('''
        __BBBB______
        _BBBBB______
        BBBBBB______
        BBBB________
        BBB_________
        BBB____RRRR_
        ______RRRRR_
        _____RRRRRR_
        _____RRRR___
        _____RRR____
        _____RRR____
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 1 6 A 5 5 0 0 1 6 1"
          stroke="blue" stroke-width="2" fill="none"/>
        <path d="M 6 11 a 5 5 0 0 1 5 -5"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_a2(assert_pixels):
    assert_pixels('''
        ______GGGG__
        ______GGGGG_
        ______GGGGGG
        ________GGGG
        _________GGG
        _________GGG
        GGG______GGG
        GGG______GGG
        GGGG____GGGG
        GGGGGGGGGGGG
        _GGGGGGGGGG_
        __GGGGGGGG__
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 1 6 A 5 5 0 1 0 6 1"
          stroke="lime" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_a3(assert_pixels):
    assert_pixels('''
        ______GGGG__
        ______GGGGG_
        ______GGGGGG
        ________GGGG
        _________GGG
        _________GGG
        GGG______GGG
        GGG______GGG
        GGGG____GGGG
        GGGGGGGGGGGG
        _GGGGGGGGGG_
        __GGGGGGGG__
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 1 6 a 5 5 0 1 0 5 -5"
          stroke="lime" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_a4(assert_pixels):
    assert_pixels('''
        ____________
        ____BBB_____
        ____BBB_____
        ___BBBB_____
        _BBBBBB_____
        _BBBBB______
        _BBBB____RRR
        _________RRR
        ________RRRR
        ______RRRRRR
        ______RRRRR_
        ______RRRR__
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 1 6 A 5 5 0 0 0 6 1"
          stroke="blue" stroke-width="2" fill="none"/>
        <path d="M 6 11 a 5 5 0 0 0 5 -5"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_a5(assert_pixels):
    assert_pixels('''
        __BBBBBBBB__
        _BBBBBBBBBB_
        BBBBBBBBBBBB
        BBBB____BBBB
        BBB______BBB
        BBB______BBB
        BBB_________
        BBB_________
        BBBB________
        BBBBBB______
        _BBBBB______
        __BBBB______
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 6 11 A 5 5 0 1 1 11 6"
          stroke="blue" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_a6(assert_pixels):
    assert_pixels('''
        __BBBBBBBB__
        _BBBBBBBBBB_
        BBBBBBBBBBBB
        BBBB____BBBB
        BBB______BBB
        BBB______BBB
        BBB_________
        BBB_________
        BBBB________
        BBBBBB______
        _BBBBB______
        __BBBB______
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 6 11 a 5 5 0 1 1 5 -5"
          stroke="blue" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_a7(assert_pixels):
    assert_pixels('''
        ____________
        ____________
        ____________
        ____________
        ____________
        ____________
        GGG______GGG
        GGG______GGG
        GGGG____GGGG
        GGGGGGGGGGGG
        _GGGGGGGGGG_
        __GGGGGGGG__
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 1 6 A 5 5 0 0 0 11 6"
          stroke="lime" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_wrong_point(assert_pixels):
    assert_pixels('''
        ____________
        GG__________
        GG__________
        GG__________
        GG__________
        ____________
        ____________
        ____________
        ____________
        ____________
        ____________
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <path d="M 1 1 L 1 5 L"
          stroke="lime" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_path_markers_l(assert_pixels):
    assert_pixels('''
        _________zz_
        _RR_____zzRz
        _RRGGGGzzRzz
        _RRGGGzzRzz_
        _RR___zRzz__
        ________zG__
        _______RRRR_
        _______RRRR_
        ________GG__
        _______RRRR_
        _______RRRR_
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <marker id="line"
          viewBox="0 0 1 2" refX="0.5" refY="1"
          markerUnits="strokeWidth"
          markerWidth="1" markerHeight="2"
          orient="auto">
          <rect x="0" y="0" width="1" height="2" fill="red" />
        </marker>
        <path d="M 2 3 l 7 0 l 0 4 l 0 3"
          stroke="lime" stroke-width="2" fill="none" marker="url('#line')"/>
      </svg>
    ''')


@assert_no_logs
def test_path_markers_hv(assert_pixels):
    assert_pixels('''
        _________zz_
        _RR_____zzRz
        _RRGGGGzzRzz
        _RRGGGzzRzz_
        _RR___zRzz__
        ________zG__
        _______RRRR_
        _______RRRR_
        ________GG__
        _______RRRR_
        _______RRRR_
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        svg { display: block }
      </style>
      <svg width="12px" height="12px" xmlns="http://www.w3.org/2000/svg">
        <marker id="line"
          viewBox="0 0 1 2" refX="0.5" refY="1"
          markerUnits="strokeWidth"
          markerWidth="1" markerHeight="2"
          orient="auto">
          <rect x="0" y="0" width="1" height="2" fill="red" />
        </marker>
        <path d="M 2 3 h 7 v 4 v 3"
          stroke="lime" stroke-width="2" fill="none" marker="url(#line)"/>
      </svg>
    ''')


================================================
FILE: tests/draw/svg/test_patterns.py
================================================
"""Test how SVG simple patterns are drawn."""

from ...testing_utils import assert_no_logs


@assert_no_logs
def test_pattern(assert_pixels):
    assert_pixels('''
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
    ''', '''
      <style>
        @page { size: 8px }
        svg { display: block }
      </style>
      <svg width="8px" height="8px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <pattern id="pat" x="0" y="0" width="4" height="4"
            patternUnits="userSpaceOnUse"
            patternContentUnits="userSpaceOnUse">
            <rect x="0" y="0" width="2" height="2" fill="blue" />
            <rect x="0" y="2" width="2" height="2" fill="red" />
            <rect x="2" y="0" width="2" height="2" fill="red" />
            <rect x="2" y="2" width="2" height="2" fill="blue" />
          </pattern>
        </defs>
        <rect x="0" y="0" width="8" height="8" fill="url(#pat)" />
      </svg>
    ''')


@assert_no_logs
def test_pattern_2(assert_pixels):
    assert_pixels('''
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
    ''', '''
      <style>
        @page { size: 8px }
        svg { display: block }
      </style>
      <svg width="8px" height="8px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <pattern id="pat" x="0" y="0" width="50%" height="50%"
            patternUnits="objectBoundingBox"
            patternContentUnits="userSpaceOnUse">
            <rect x="0" y="0" width="2" height="2" fill="blue" />
            <rect x="0" y="2" width="2" height="2" fill="red" />
            <rect x="2" y="0" width="2" height="2" fill="red" />
            <rect x="2" y="2" width="2" height="2" fill="blue" />
          </pattern>
        </defs>
        <rect x="0" y="0" width="8" height="8" fill="url(#pat)" />
      </svg>
    ''')


@assert_no_logs
def test_pattern_3(assert_pixels):
    assert_pixels('''
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
    ''', '''
      <style>
        @page { size: 8px }
        svg { display: block }
      </style>
      <svg width="8px" height="8px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <pattern id="pat" x="0" y="0" width="4" height="4"
            patternUnits="userSpaceOnUse"
            patternContentUnits="userSpaceOnUse">
            <rect x="0" y="0" width="2" height="2" fill="blue" />
            <rect x="0" y="2" width="2" height="2" fill="red" />
            <rect x="2" y="0" width="2" height="2" fill="red" />
            <rect x="2" y="2" width="2" height="2" fill="blue" />
          </pattern>
        </defs>
        <rect x="0" y="0" width="8" height="8" fill="url(#pat)" />
      </svg>
    ''')


@assert_no_logs
def test_pattern_4(assert_pixels):
    assert_pixels('''
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
    ''', '''
      <style>
        @page { size: 8px }
        svg { display: block }
      </style>
      <svg width="8px" height="8px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <pattern id="pat" x="0" y="0" width="4" height="4"
            patternUnits="userSpaceOnUse"
            patternContentUnits="objectBoundingBox">
            <rect x="0" y="0" width="50%" height="50%" fill="blue" />
            <rect x="0" y="50%" width="50%" height="50%" fill="red" />
            <rect x="50%" y="0" width="50%" height="50%" fill="red" />
            <rect x="50%" y="50%" width="50%" height="50%" fill="blue" />
          </pattern>
        </defs>
        <rect x="0" y="0" width="8" height="8" fill="url(#pat)" />
      </svg>
    ''')


@assert_no_logs
def test_pattern_inherit_attributes(assert_pixels):
    assert_pixels('''
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
    ''', '''
      <style>
        @page { size: 8px }
        svg { display: block }
      </style>
      <svg width="8px" height="8px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <pattern id="parent" x="0" y="0" width="4" height="4"
            patternUnits="userSpaceOnUse"
            patternContentUnits="userSpaceOnUse">
          </pattern>
          <pattern id="pat" href="#parent">
            <rect x="0" y="0" width="2" height="2" fill="blue" />
            <rect x="0" y="2" width="2" height="2" fill="red" />
            <rect x="2" y="0" width="2" height="2" fill="red" />
            <rect x="2" y="2" width="2" height="2" fill="blue" />
          </pattern>
        </defs>
        <rect x="0" y="0" width="8" height="8" fill="url(#pat)" />
      </svg>
    ''')


@assert_no_logs
def test_pattern_inherit_children(assert_pixels):
    assert_pixels('''
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
    ''', '''
      <style>
        @page { size: 8px }
        svg { display: block }
      </style>
      <svg width="8px" height="8px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <pattern id="parent">
            <rect x="0" y="0" width="2" height="2" fill="blue" />
            <rect x="0" y="2" width="2" height="2" fill="red" />
            <rect x="2" y="0" width="2" height="2" fill="red" />
            <rect x="2" y="2" width="2" height="2" fill="blue" />
          </pattern>
          <pattern id="pat" href="#parent" x="0" y="0" width="4" height="4"
            patternUnits="userSpaceOnUse" patternContentUnits="userSpaceOnUse">
          </pattern>
        </defs>
        <rect x="0" y="0" width="8" height="8" fill="url(#pat)" />
      </svg>
    ''')


@assert_no_logs
def test_pattern_inherit_no_override(assert_pixels):
    assert_pixels('''
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
        BBrrBBrr
        BBrrBBrr
        rrBBrrBB
        rrBBrrBB
    ''', '''
      <style>
        @page { size: 8px }
        svg { display: block }
      </style>
      <svg width="8px" height="8px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <pattern id="parent" x="1" y="1" width="3" height="3"
            patternUnits="objectBoundingBox"
            patternContentUnits="objectBoundingBox">
            <rect x="0" y="0" width="2" height="2" fill="green" />
            <rect x="0" y="2" width="2" height="2" fill="green" />
            <rect x="2" y="0" width="2" height="2" fill="yellow" />
            <rect x="2" y="2" width="2" height="2" fill="yellow" />
          </pattern>
          <pattern id="pat" href="#parent" x="0" y="0" width="4" height="4"
            patternUnits="userSpaceOnUse" patternContentUnits="userSpaceOnUse">
            <rect x="0" y="0" width="2" height="2" fill="blue" />
            <rect x="0" y="2" width="2" height="2" fill="red" />
            <rect x="2" y="0" width="2" height="2" fill="red" />
            <rect x="2" y="2" width="2" height="2" fill="blue" />
          </pattern>
        </defs>
        <rect x="0" y="0" width="8" height="8" fill="url(#pat)" />
      </svg>
    ''')


================================================
FILE: tests/draw/svg/test_shapes.py
================================================
"""Test how SVG simple shapes are drawn."""

from ...testing_utils import assert_no_logs


@assert_no_logs
def test_rect_stroke(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RR___RR_
        _RR___RR_
        _RR___RR_
        _RRRRRRR_
        _RRRRRRR_
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="2" width="5" height="5"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_rect_fill(assert_pixels):
    assert_pixels('''
        _________
        _________
        __RRRRR__
        __RRRRR__
        __RRRRR__
        __RRRRR__
        __RRRRR__
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="2" width="5" height="5" fill="red" />
      </svg>
    ''')


@assert_no_logs
def test_rect_stroke_fill(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RRBBBRR_
        _RRBBBRR_
        _RRBBBRR_
        _RRRRRRR_
        _RRRRRRR_
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="2" width="5" height="5"
              stroke-width="2" stroke="red" fill="blue" />
      </svg>
    ''')


@assert_no_logs
def test_rect_round(assert_pixels):
    assert_pixels('''
        _zzzzzzz_
        zzzzzzzzz
        zzRRRRRzz
        zzRRRRRzz
        zzRRRRRzz
        zzRRRRRzz
        zzRRRRRzz
        zzzzzzzzz
        _zzzzzzz_
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect width="9" height="9" fill="red" rx="4" ry="4" />
      </svg>
    ''')


@assert_no_logs
def test_rect_round_zero(assert_pixels):
    assert_pixels('''
        RRRRRRRRR
        RRRRRRRRR
        RRRRRRRRR
        RRRRRRRRR
        RRRRRRRRR
        RRRRRRRRR
        RRRRRRRRR
        RRRRRRRRR
        RRRRRRRRR
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect width="9" height="9" fill="red" rx="0" ry="4" />
      </svg>
    ''')


@assert_no_logs
def test_line(assert_pixels):
    assert_pixels('''
        _________
        _________
        _________
        _________
        RRRRRR___
        RRRRRR___
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <line x1="0" y1="5" x2="6" y2="5"
          stroke="red" stroke-width="2"/>
      </svg>
    ''')


@assert_no_logs
def test_polyline(assert_pixels):
    assert_pixels('''
        _________
        RRRRRR___
        RRRRRR___
        RR__RR___
        RR__RR___
        RR__RR___
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <polyline points="1,6, 1,2, 5,2, 5,6"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_polyline_fill(assert_pixels):
    assert_pixels('''
        _________
        RRRRRR___
        RRRRRR___
        RRBBRR___
        RRBBRR___
        RRBBRR___
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <polyline points="1,6, 1,2, 5,2, 5,6"
          stroke="red" stroke-width="2" fill="blue"/>
      </svg>
    ''')


@assert_no_logs
def test_polygon(assert_pixels):
    assert_pixels('''
        _________
        RRRRRR___
        RRRRRR___
        RR__RR___
        RR__RR___
        RRRRRR___
        RRRRRR___
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <polygon points="1,6, 1,2, 5,2, 5,6"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_polygon_fill(assert_pixels):
    assert_pixels('''
        _________
        RRRRRR___
        RRRRRR___
        RRBBRR___
        RRBBRR___
        RRRRRR___
        RRRRRR___
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <polygon points="1,6, 1,2, 5,2, 5,6"
          stroke="red" stroke-width="2" fill="blue"/>
      </svg>
    ''')


@assert_no_logs
def test_circle_stroke(assert_pixels):
    assert_pixels('''
        __________
        __RRRRRR__
        _RRRRRRRR_
        _RRRRRRRR_
        _RRR__RRR_
        _RRR__RRR_
        _RRRRRRRR_
        _RRRRRRRR_
        __RRRRRR__
        __________
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <circle cx="5" cy="5" r="3"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_circle_fill(assert_pixels):
    assert_pixels('''
        __________
        __RRRRRR__
        _RRRRRRRR_
        _RRRRRRRR_
        _RRRBBRRR_
        _RRRBBRRR_
        _RRRRRRRR_
        _RRRRRRRR_
        __RRRRRR__
        __________
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <circle cx="5" cy="5" r="3"
          stroke="red" stroke-width="2" fill="blue"/>
      </svg>
    ''')


@assert_no_logs
def test_ellipse_stroke(assert_pixels):
    assert_pixels('''
        __________
        __RRRRRR__
        _RRRRRRRR_
        _RRRRRRRR_
        _RRR__RRR_
        _RRR__RRR_
        _RRRRRRRR_
        _RRRRRRRR_
        __RRRRRR__
        __________
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <ellipse cx="5" cy="5" rx="3" ry="3"
          stroke="red" stroke-width="2" fill="none"/>
      </svg>
    ''')


@assert_no_logs
def test_ellipse_fill(assert_pixels):
    assert_pixels('''
        __________
        __RRRRRR__
        _RRRRRRRR_
        _RRRRRRRR_
        _RRRBBRRR_
        _RRRBBRRR_
        _RRRRRRRR_
        _RRRRRRRR_
        __RRRRRR__
        __________
    ''', '''
      <style>
        @page { size: 10px }
        svg { display: block }
      </style>
      <svg width="10px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <ellipse cx="5" cy="5" rx="3" ry="3"
          stroke="red" stroke-width="2" fill="blue"/>
      </svg>
    ''')


@assert_no_logs
def test_rect_in_g(assert_pixels):
    assert_pixels('''
        RRRRR____
        RRRRR____
        RRRRR____
        RRRRR____
        RRRRR____
        _________
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <g x="5" y="5">
          <rect width="5" height="5" fill="red" />
        </g>
      </svg>
    ''')


@assert_no_logs
def test_rect_x_y_in_g(assert_pixels):
    assert_pixels('''
        _________
        _________
        __RRRRR__
        __RRRRR__
        __RRRRR__
        __RRRRR__
        __RRRRR__
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <g x="5" y="5">
          <rect x="2" y="2" width="5" height="5" fill="red" />
        </g>
      </svg>
    ''')


@assert_no_logs
def test_rect_stroke_zero(assert_pixels):
    assert_pixels('''
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="2" width="5" height="5"
              stroke-width="0" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_rect_width_height_zero(assert_pixels):
    assert_pixels('''
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
    ''', '''
        <style>
            @page { size: 9px }
            svg { display: block }
        </style>
        <svg width="0" height="0" xmlns="http://www.w3.org/2000/svg">
            <rect x="2" y="2" width="5" height="5" fill="red" />
        </svg>
    ''')


@assert_no_logs
def test_rect_fill_inherit(assert_pixels):
    assert_pixels('''
        _________
        _________
        __KKKKK__
        __KKKKK__
        __KKKKK__
        __KKKKK__
        __KKKKK__
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="2" width="5" height="5" fill="inherit" />
      </svg>
    ''')


================================================
FILE: tests/draw/svg/test_text.py
================================================
"""Test how SVG text is drawn."""

from ...testing_utils import assert_no_logs


@assert_no_logs
def test_text_fill(assert_pixels):
    assert_pixels('''
        BBBBBB__BBBBBB______
        BBBBBB__BBBBBB______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <text x="0" y="1.5" font-family="weasyprint" font-size="2" fill="blue">
          ABC DEF
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_stroke(assert_pixels):
    assert_pixels('''
        _BBBBBBBBBBBB_______
        _BBBBBBBBBBBB_______
        _BBBBBBBBBBBB_______
        _BBBBBBBBBBBB_______
    ''', '''
      <style>
        @page { font-size: 1px; size: 20em 4em }
        svg { display: block }
      </style>
      <svg width="20px" height="4px" xmlns="http://www.w3.org/2000/svg">
        <text x="2" y="2.5" font-family="weasyprint" font-size="2"
              fill="transparent" stroke="blue" stroke-width="1ex">
          A B C
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_x(assert_pixels):
    assert_pixels('''
        BB__BB_BBBB_________
        BB__BB_BBBB_________
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <text x="0 4 7" y="1.5" font-family="weasyprint" font-size="2"
              fill="blue">
          ABCD
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_y(assert_pixels):
    assert_pixels('''
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        BBBBBBBBBB_____BBBBB__________
        BBBBBBBBBB_____BBBBB__________
        BBBBBBBBBB_____BBBBB__________
        BBBBBBBBBB_____BBBBB__________
        BBBBBBBBBB_____BBBBB__________
    ''', '''
      <style>
        @page { size: 30px 10px }
        svg { display: block }
      </style>
      <svg width="30px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <text x="0" y="9 9 4 9 4" font-family="weasyprint" font-size="5"
              fill="blue">
          ABCDEF
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_xy(assert_pixels):
    assert_pixels('''
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        BBBBB__________BBBBB__________
        BBBBB__________BBBBB__________
        BBBBB__________BBBBB__________
        BBBBB__________BBBBB__________
        BBBBB__________BBBBB__________
    ''', '''
      <style>
        @page { size: 30px 10px }
        svg { display: block }
      </style>
      <svg width="30px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <text x="0 10" y="9 4 9 4" font-family="weasyprint" font-size="5"
              fill="blue">
          ABCDE
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_dx(assert_pixels):
    assert_pixels('''
        BB__BB_BBBB_________
        BB__BB_BBBB_________
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <text dx="0 2 1" y="1.5" font-family="weasyprint" font-size="2"
              fill="blue">
          ABCD
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_dy(assert_pixels):
    assert_pixels('''
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        BBBBBBBBBB_____BBBBB__________
        BBBBBBBBBB_____BBBBB__________
        BBBBBBBBBB_____BBBBB__________
        BBBBBBBBBB_____BBBBB__________
        BBBBBBBBBB_____BBBBB__________
    ''', '''
      <style>
        @page { size: 30px 10px }
        svg { display: block }
      </style>
      <svg width="30px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <text x="0" dy="9 0 -5 5 -5" font-family="weasyprint" font-size="5"
              fill="blue">
          ABCDEF
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_dx_dy(assert_pixels):
    assert_pixels('''
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        __________BBBBB_____BBBBBBBBBB
        BBBBB__________BBBBB__________
        BBBBB__________BBBBB__________
        BBBBB__________BBBBB__________
        BBBBB__________BBBBB__________
        BBBBB__________BBBBB__________
    ''', '''
      <style>
        @page { size: 30px 10px }
        svg { display: block }
      </style>
      <svg width="30px" height="10px" xmlns="http://www.w3.org/2000/svg">
        <text dx="0 5" dy="9 -5 5 -5" font-family="weasyprint" font-size="5"
              fill="blue">
          ABCDE
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_anchor_start(assert_pixels):
    assert_pixels('''
        __BBBBBB____________
        __BBBBBB____________
        ____BBBBBB__________
        ____BBBBBB__________
    ''', '''
      <style>
        @page { size: 20px 4px }
        svg { display: block }
      </style>
      <svg width="20px" height="4px" xmlns="http://www.w3.org/2000/svg">
        <text x="2" y="1.5" font-family="weasyprint" font-size="2"
              fill="blue">
          ABC
        </text>
        <text x="4" y="3.5" font-family="weasyprint" font-size="2"
              fill="blue" text-anchor="start">
          ABC
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_anchor_middle(assert_pixels):
    assert_pixels('''
        _______BBBBBB_______
        _______BBBBBB_______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <text x="10" y="1.5" font-family="weasyprint" font-size="2"
              fill="blue" text-anchor="middle">
          ABC
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_anchor_end(assert_pixels):
    assert_pixels('''
        ____________BBBBBB__
        ____________BBBBBB__
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <text x="18" y="1.5" font-family="weasyprint" font-size="2"
              fill="blue" text-anchor="end">
          ABC
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_tspan(assert_pixels):
    assert_pixels('''
        BBBBBB__BBBBBB______
        BBBBBB__BBBBBB______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <text x="10" y="10" font-family="weasyprint" font-size="2" fill="blue">
          <tspan x="0" y="1.5">ABC DEF</tspan>
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_tspan_anchor_middle(assert_pixels):
    assert_pixels('''
        _______BBBBBB_______
        _______BBBBBB_______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <text x="10" y="10" font-family="weasyprint" font-size="2" fill="blue">
          <tspan x="10" y="1.5" text-anchor="middle">ABC</tspan>
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_tspan_anchor_end(assert_pixels):
    assert_pixels('''
        ____________BBBBBB__
        ____________BBBBBB__
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <text x="10" y="10" font-family="weasyprint" font-size="2" fill="blue">
          <tspan x="18" y="1.5" text-anchor="end">ABC</tspan>
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_anchor_middle_tspan(assert_pixels):
    assert_pixels('''
        _______BBBBBB_______
        _______BBBBBB_______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <text x="10" y="10" font-family="weasyprint" font-size="2" fill="blue"
              text-anchor="middle">
          <tspan x="10" y="1.5">ABC</tspan>
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_anchor_end_tspan(assert_pixels):
    assert_pixels('''
        ____________BBBBBB__
        ____________BBBBBB__
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <text x="10" y="10" font-family="weasyprint" font-size="2" fill="blue"
              text-anchor="end">
          <tspan x="18" y="1.5">ABC</tspan>
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_anchor_middle_tspan_head_tail(assert_pixels):
    assert_pixels('''
        ____BBBBRRRRRRBB____
        ____BBBBRRRRRRBB____
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <text x="10" y="1.5" font-family="weasyprint" font-size="2" fill="blue"
              text-anchor="middle">
          AA<tspan fill="red">ABC</tspan>A
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_anchor_end_tspan_head_tail(assert_pixels):
    assert_pixels('''
        ______BBBBRRRRRRBB__
        ______BBBBRRRRRRBB__
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <text x="18" y="1.5" font-family="weasyprint" font-size="2" fill="blue"
              text-anchor="end">
          AA<tspan fill="red">ABC</tspan>A
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_anchor_middle_end_tspan(assert_pixels):
    assert_pixels('''
        _______BBBBBB_______
        _______BBBBBB_______
        ____________BBBBBB__
        ____________BBBBBB__
    ''', '''
      <style>
        @page { size: 20px 4px }
        svg { display: block }
      </style>
      <svg width="20px" height="4px" xmlns="http://www.w3.org/2000/svg">
        <text x="10" y="10" font-family="weasyprint" font-size="2" fill="blue">
          <tspan x="10" y="1.5" text-anchor="middle">ABC</tspan>
          <tspan x="18" y="3.5" text-anchor="end">ABC</tspan>
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_tspan_anchor_non_text(assert_pixels):
    # Regression test for #2375.
    assert_pixels('''
        _______BBBBBB_______
        _______BBBBBB_______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" text-anchor="end"
           xmlns="http://www.w3.org/2000/svg">
        <text x="10" y="10" font-family="weasyprint" font-size="2" text-anchor="start">
          <tspan x="10" y="1.5" text-anchor="middle" fill="blue">ABC</tspan>
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_rotate(assert_pixels):
    assert_pixels('''
        __RR__RR__RR________
        __RR__RR__RR________
        BB__BB__BB__________
        BB__BB__BB__________
    ''', '''
      <style>
        @page { size: 20px 4px }
        svg { display: block }
      </style>
      <svg width="20px" height="4px" xmlns="http://www.w3.org/2000/svg">
        <text x="2" y="1.5" font-family="weasyprint" font-size="2" fill="red"
          letter-spacing="2">abc</text>
        <text x="2" y="1.5" font-family="weasyprint" font-size="2" fill="blue"
          rotate="180" letter-spacing="2">abc</text>
      </svg>
    ''')


@assert_no_logs
def test_text_text_length(assert_pixels):
    assert_pixels('''
        __RRRRRR____________
        __RRRRRR____________
        __BB__BB__BB________
        __BB__BB__BB________
    ''', '''
      <style>
        @page { size: 20px 4px }
        svg { display: block }
      </style>
      <svg width="20px" height="4px" xmlns="http://www.w3.org/2000/svg">
        <text x="2" y="1.5" font-family="weasyprint" font-size="2" fill="red">
          abc
        </text>
        <text x="2" y="3.5" font-family="weasyprint" font-size="2" fill="blue"
          textLength="10">abc</text>
      </svg>
    ''')


@assert_no_logs
def test_text_length_adjust_glyphs_only(assert_pixels):
    assert_pixels('''
        __RRRRRR____________
        __RRRRRR____________
        __BBBBBBBBBBBB______
        __BBBBBBBBBBBB______
    ''', '''
      <style>
        @page { size: 20px 4px }
        svg { display: block }
      </style>
      <svg width="20px" height="4px" xmlns="http://www.w3.org/2000/svg">
        <text x="2" y="1.5" font-family="weasyprint" font-size="2" fill="red">
          abc
        </text>
        <text x="2" y="3.5" font-family="weasyprint" font-size="2" fill="blue"
          textLength="12" lengthAdjust="spacingAndGlyphs">abc</text>
      </svg>
    ''')


@assert_no_logs
def test_text_font_face(assert_pixels):
    assert_pixels('''
        BBBBBB__BBBBBB______
        BBBBBB__BBBBBB______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <style>
            @font-face {
              font-family: "SVGFont";
              src: url(weasyprint.otf);
            }
          </style>
        </defs>
        <text x="0" y="1.5" font-family="SVGFont" font-size="2" fill="blue">
          ABC DEF
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_font_face_css(assert_pixels):
    assert_pixels('''
        BBBBBB__BBBBBB______
        BBBBBB__BBBBBB______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <defs>
          <style>
            @font-face {
              font-family: "SVGFont";
              src: url(weasyprint.otf);
            }
            text { font-family: "SVGFont" }
          </style>
        </defs>
        <text x="0" y="1.5" font-size="2" fill="blue">
          ABC DEF
        </text>
      </svg>
    ''')


@assert_no_logs
def test_text_length_adjust_spacing_and_glyphs(assert_pixels):
    assert_pixels('''
        __RR_RR_RR__________
        __RR_RR_RR__________
        __BBBB__BBBB__BBBB__
        __BBBB__BBBB__BBBB__
    ''', '''
      <style>
        @page { size: 20px 4px }
        svg { display: block }
      </style>
      <svg width="20px" height="4px" xmlns="http://www.w3.org/2000/svg">
        <text x="2" y="1.5" font-family="weasyprint" font-size="2" fill="red"
          letter-spacing="1">abc</text>
        <text x="2" y="3.5" font-family="weasyprint" font-size="2" fill="blue"
          letter-spacing="1" textLength="16" lengthAdjust="spacingAndGlyphs">
          abc
        </text>
      </svg>
    ''')


@assert_no_logs
def test_font_shorthand(assert_pixels):
    assert_pixels('''
        BBBBBB__BBBBBB______
        BBBBBB__BBBBBB______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <text x="0" y="1.5" style="font: 2px 'weasyprint'" fill="blue">
          ABC DEF
        </text>
      </svg>
    ''',
    )


@assert_no_logs
def test_font_shorthand_inheritance_from_parent(assert_pixels):
    assert_pixels('''
        BBBBBB__BBBBBB______
        BBBBBB__BBBBBB______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <g style="font: 2px weasyprint">
          <text x="0" y="1.5" fill="blue" font="bad">
            <tspan>ABC DEF</tspan>
          </text>
        </g>
      </svg>
    ''',
    )


@assert_no_logs
def test_explicit_properties_override_parent_shorthand(assert_pixels):
    assert_pixels('''
        BBBBBB__BBBBBB______
        BBBBBB__BBBBBB______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <g font="  28px Times New Roman  ">
          <text x="0" y="1.5" font-size="2px" font-family="weasyprint" fill="blue">
            ABC DEF
          </text>
        </g>
      </svg>
    ''',
    )


@assert_no_logs
def test_font_shorthand_overrides_explicit_parent_properties(assert_pixels):
    assert_pixels('''
        BBBBBB__BBBBBB______
        BBBBBB__BBBBBB______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <g font-size="18px" font-family="weasyprint">
          <text x="0" y="1.5" style="font: 2px weasyprint" fill="blue">
            ABC DEF
          </text>
        </g>
      </svg>
    ''',
    )


@assert_no_logs
def test_child_font_shorthand_overrides_parent_shorthand(assert_pixels):
    assert_pixels('''
        BBBBBB__BBBBBB______
        BBBBBB__BBBBBB______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <g font="   34px    sans   ">
          <text x="0" y="1.5" style="font: 2px    weasyprint" fill="blue">
            ABC DEF
          </text>
        </g>
      </svg>
    ''',
    )


@assert_no_logs
def test_mixed_explicit_and_shorthand_across_levels(assert_pixels):
    assert_pixels('''
        BBBBBB__BBBBBB______
        BBBBBB__BBBBBB______
    ''', '''
      <style>
        @page { size: 20px 2px }
        svg { display: block }
      </style>
      <svg width="20px" height="2px" xmlns="http://www.w3.org/2000/svg">
        <g font-size="40px" font-family="sans-serif">
          <g style="font: 30px sans">
            <text x="0" y="1.5" font-size="2px" font-family="weasyprint" fill="blue">
              ABC DEF
            </text>
          </g>
        </g>
      </svg>
    ''',
    )


@assert_no_logs
def test_text_fill_opacity(assert_pixels):
    # Regression text for #2665.
    assert_pixels('''
        ______
        _ssss_
        _ssss_
        _ssss_
        _ssss_
        ______
    ''', '''
      <style>
        @page { size: 6px 6px }
        svg { display: block }
      </style>
      <svg width="6px" height="6px" xmlns="http://www.w3.org/2000/svg">
        <text x="1" y="4" font="4px weasyprint" fill="red" opacity="0.5">
          A
        </text>
      </svg>
    ''')


@assert_no_logs
def test_emoji_text_svg(assert_pixels):
    # Regression text for #2683.
    assert_pixels('''
        zzzzz
        zzzzz
        zzzzz
        zzzzz
        zzzzz
    ''', '''
      <style>
        @page { size: 5px 5px }
        svg { display: block }
      </style>
      <svg viewBox="0 0 5 5">
        <text>🚀</text>
      </svg>
    ''')


================================================
FILE: tests/draw/svg/test_transform.py
================================================
"""Test how SVG shapes are transformed."""

from ...testing_utils import assert_no_logs


@assert_no_logs
def test_transform_translate(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RR___RR_
        _RR___RR_
        _RR___RR_
        _RRRRRRR_
        _RRRRRRR_
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="0" y="4" width="5" height="5" transform="translate(2, -2)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_translate_one(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RR___RR_
        _RR___RR_
        _RR___RR_
        _RRRRRRR_
        _RRRRRRR_
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="0" y="2" width="5" height="5" transform="translate(2)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_translatex(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RR___RR_
        _RR___RR_
        _RR___RR_
        _RRRRRRR_
        _RRRRRRR_
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="0" y="2" width="5" height="5" transform="translateX(2)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_translatey(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RR___RR_
        _RR___RR_
        _RR___RR_
        _RRRRRRR_
        _RRRRRRR_
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="0" width="5" height="5" transform="translateY(2)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_rotate(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RR___RR_
        _RR___RR_
        _RRRRRRR_
        _RRRRRRR_
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="-7" width="4" height="5" transform="rotate(90)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_rotate_cx_cy(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RR___RR_
        _RR___RR_
        _RRRRRRR_
        _RRRRRRR_
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="7" y="2" width="4" height="5" transform="rotate(90 7 2)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_skew(assert_pixels):
    assert_pixels('''
        _________
        _RRR_____
        _RRRRRR__
        __RRRRR__
        __RRRRR__
        __RRRRRR_
        ____RRRR_
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="2" width="2" height="2" transform="skew(20 20)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_skew_one(assert_pixels):
    assert_pixels('''
        _________
        _RRRRR___
        _RRRRRR__
        __RRRRR__
        __RRRRR__
        _________
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="2" width="2" height="2" transform="skew(20)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_skewx(assert_pixels):
    assert_pixels('''
        _________
        _RRRRR___
        _RRRRRR__
        __RRRRR__
        __RRRRR__
        _________
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="2" width="2" height="2" transform="skewX(20)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_skewy(assert_pixels):
    assert_pixels('''
        _________
        _RR______
        _RRRR____
        _RRRR____
        _RRRR____
        _RRRR____
        __RRR____
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="2" width="2" height="2" transform="skewY(20)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_scale(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="2" width="2" height="2" transform="scale(1.5)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_scale_2(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="2" width="2" height="2" transform="scale(1.5 1.5)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_scalex(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _________
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="2" width="2" height="2" transform="scaleX(1.5)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_scaley(assert_pixels):
    assert_pixels('''
        _________
        _RRRR____
        _RRRR____
        _RRRR____
        _RRRR____
        _RRRR____
        _RRRR____
        _RRRR____
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2" y="2" width="2" height="2" transform="scaleY(1.5)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_matrix(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _RRRRRRR_
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="0" y="0" width="2" height="2"
              transform="matrix(1.5 0 0 1.5 3 3)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_multiple(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RR___RR_
        _RR___RR_
        _RRRRRRR_
        _RRRRRRR_
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="0" y="0" width="4" height="5"
              transform="rotate(90) translateY(-7) translateX(2)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_unknown(assert_pixels):
    assert_pixels('''
        RRRRR____
        R__RR____
        R__RR____
        R__RR____
        RRRRR____
        RRRRR____
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="0" y="0" width="4" height="5" transform="unknown(2)"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_transform_origin(assert_pixels):
    assert_pixels('''
        ___RRRRRR
        ___RRRRRR
        ___RR___R
        ___RR___R
        ___RRRRRR
        ___RRRRRR
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="0" y="0" width="4" height="5"
              transform="rotate(90)" transform-origin="4 5"
              stroke-width="2" stroke="red" fill="none" />
      </svg>
    ''')


================================================
FILE: tests/draw/svg/test_units.py
================================================
"""Test SVG units."""

from ...testing_utils import assert_no_logs


@assert_no_logs
def test_units_px(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RR___RR_
        _RR___RR_
        _RR___RR_
        _RRRRRRR_
        _RRRRRRR_
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2px" y="2px" width="5px" height="5px"
              stroke-width="2px" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_units_em(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RR___RR_
        _RR___RR_
        _RR___RR_
        _RRRRRRR_
        _RRRRRRR_
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" font-size="1px"
           xmlns="http://www.w3.org/2000/svg">
        <rect x="2em" y="2em" width="5em" height="5em"
              stroke-width="2em" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_units_ex(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _RR___RR_
        _RR___RR_
        _RR___RR_
        _RRRRRRR_
        _RRRRRRR_
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" font-size="1px"
           xmlns="http://www.w3.org/2000/svg">
        <rect x="4ex" y="4ex" width="10ex" height="10ex"
              stroke-width="4ex" stroke="red" fill="none" />
      </svg>
    ''')


@assert_no_logs
def test_units_unknown(assert_pixels):
    assert_pixels('''
        _RRRRRRR_
        _RR___RR_
        _RR___RR_
        _RR___RR_
        _RRRRRRR_
        _RRRRRRR_
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect x="2px" y="2unk" width="5px" height="5px"
              stroke-width="2px" stroke="red" fill="none" />
      </svg>
    ''')


================================================
FILE: tests/draw/svg/test_visibility.py
================================================
"""Test how the visibility is controlled with "visibility" and "display"."""

from ...testing_utils import assert_no_logs


@assert_no_logs
def test_visibility_visible(assert_pixels):
    assert_pixels('''
        _________
        _________
        __RRRRR__
        __RRRRR__
        __RRRRR__
        __RRRRR__
        __RRRRR__
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect visibility="visible"
              x="2" y="2" width="5" height="5" fill="red" />
      </svg>
    ''')


@assert_no_logs
def test_visibility_hidden(assert_pixels):
    assert_pixels('''
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect visibility="hidden"
              x="2" y="2" width="5" height="5" fill="red" />
      </svg>
    ''')


@assert_no_logs
def test_visibility_inherit_hidden(assert_pixels):
    assert_pixels('''
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <g visibility="hidden">
          <rect x="2" y="2" width="5" height="5" fill="red" />
        </g>
      </svg>
    ''')


@assert_no_logs
def test_visibility_inherit_visible(assert_pixels):
    assert_pixels('''
        _________
        _________
        __RRRRR__
        __RRRRR__
        __RRRRR__
        __RRRRR__
        __RRRRR__
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <g visibility="hidden">
          <rect visibility="visible"
                x="2" y="2" width="5" height="5" fill="red" />
        </g>
      </svg>
    ''')


@assert_no_logs
def test_display_inline(assert_pixels):
    assert_pixels('''
        _________
        _________
        __RRRRR__
        __RRRRR__
        __RRRRR__
        __RRRRR__
        __RRRRR__
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect display="inline"
              x="2" y="2" width="5" height="5" fill="red" />
      </svg>
    ''')


@assert_no_logs
def test_display_none(assert_pixels):
    assert_pixels('''
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <rect display="none"
              x="2" y="2" width="5" height="5" fill="red" />
      </svg>
    ''')


@assert_no_logs
def test_display_inherit_none(assert_pixels):
    assert_pixels('''
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <g display="none">
          <rect x="2" y="2" width="5" height="5" fill="red" />
        </g>
      </svg>
    ''')


@assert_no_logs
def test_display_inherit_inline(assert_pixels):
    assert_pixels('''
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
    ''', '''
      <style>
        @page { size: 9px }
        svg { display: block }
      </style>
      <svg width="9px" height="9px" xmlns="http://www.w3.org/2000/svg">
        <g display="none">
          <rect display="inline"
                x="2" y="2" width="5" height="5" fill="red" />
        </g>
      </svg>
    ''')


================================================
FILE: tests/draw/test_absolute.py
================================================
"""Test how absolutes are drawn."""

import pytest

from ..testing_utils import assert_no_logs


@assert_no_logs
def test_absolute_split_1(assert_pixels):
    assert_pixels('''
        BBBBRRRRRRRR____
        BBBBRRRRRRRR____
        BBBBRR__________
        BBBBRR__________
    ''', '''
        <style>
            @page {
                size: 16px 2Px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                left: 0;
                position: absolute;
                top: 0;
                width: 4px;
            }
        </style>
        <div class="split">aa aa</div>
        <div>bbbbbb bbb</div>
    ''')


@assert_no_logs
def test_absolute_split_2(assert_pixels):
    assert_pixels('''
        RRRRRRRRRRRRBBBB
        RRRRRRRRRRRRBBBB
        RRRR________BBBB
        RRRR________BBBB
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                position: absolute;
                top: 0;
                right: 0;
                width: 4px;
            }
        </style>
        <div class="split">aa aa</div>
        <div>bbbbbb bb</div>
    ''')


@assert_no_logs
def test_absolute_split_3(assert_pixels):
    assert_pixels('''
        BBBBRRRRRRRR____
        BBBBRRRRRRRR____
        RRRRRRRRRR______
        RRRRRRRRRR______
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2PX;
                line-height: 1;
            }
            div.split {
                color: blue;
                position: absolute;
                top: 0;
                left: 0;
                width: 4px;
            }
        </style>
        <div class="split">aa</div>
        <div>bbbbbb bbbbb</div>
    ''')


@assert_no_logs
def test_absolute_split_4(assert_pixels):
    assert_pixels('''
        RRRRRRRRRRRRBBBB
        RRRRRRRRRRRRBBBB
        RRRRRRRRRR______
        RRRRRRRRRR______
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                position: absolute;
                top: 0;
                right: 0;
                width: 4px;
            }
        </style>
        <div class="split">aa</div>
        <div>bbbbbb bbbbb</div>
    ''')


@assert_no_logs
def test_absolute_split_5(assert_pixels):
    assert_pixels('''
        BBBBRRRR____gggg
        BBBBRRRR____gggg
        BBBBRRRRRR__gggg
        BBBBRRRRRR__gggg
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                position: absolute;
                top: 0;
                left: 0;
                width: 4px;
            }
            div.split2 {
                color: green;
                position: absolute;
                top: 0;
                right: 0;
                width: 4px;
        </style>
        <div class="split">aa aa</div>
        <div class="split2">cc cc</div>
        <div>bbbb bbbbb</div>
    ''')


@assert_no_logs
def test_absolute_split_6(assert_pixels):
    assert_pixels('''
        BBBBRRRR____gggg
        BBBBRRRR____gggg
        BBBBRRRRRR______
        BBBBRRRRRR______
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                position: absolute;
                width: 4px;
            }
            div.split2 {
                color: green;
                position: absolute;
                top: 0;
                right: 0;
                width: 4px;
        </style>
        <div class="split">aa aa</div>
        <div class="split2">cc</div>
        <div>bbbb bbbbb</div>
    ''')


@assert_no_logs
def test_absolute_split_7(assert_pixels):
    assert_pixels('''
        BBBBRRRRRRRRgggg
        BBBBRRRRRRRRgggg
        ____RRRR____gggg
        ____RRRR____gggg
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                position: absolute;
                width: 4px;
            }
            div.split2 {
                color: green;
                position: absolute;
                top: 0;
                right: 0;
                width: 4px;
            }
            div.push {
                margin-left: 4px;
            }
        </style>
        <div class="split">aa</div>
        <div class="split2">cc cc</div>
        <div class="push">bbbb bb</div>
    ''')


@assert_no_logs
def test_absolute_split_8(assert_pixels):
    assert_pixels('''
        ______
        ______
        ______
        ______
        __RR__
        __RR__
        ______
        ______
    ''', '''
        <style>
            @page {
                margin: 2px 0;
                size: 6px 8px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div {
                position: absolute;
                left: 2px;
                top: 2px;
                width: 2px;
            }
        </style>
        <div>a a a a</div>
    ''')


@assert_no_logs
def test_absolute_split_9(assert_pixels):
    assert_pixels('''
        ______
        ______
        BBRRBB
        BBRRBB
        BBRR__
        BBRR__
        ______
        ______
    ''', '''
        <style>
            @page {
                margin: 2px 0;
                size: 6px 8px;
            }
            body {
                color: blue;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div {
                color: red;
                position: absolute;
                left: 2px;
                top: 0;
                width: 2px;
            }
        </style>
        aaa a<div>a a a a</div>
    ''')


@assert_no_logs
def test_absolute_split_10(assert_pixels):
    assert_pixels('''
        BB____
        BB____
        __RR__
        __RR__
        __RR__
        __RR__

        BBRR__
        BBRR__
        __RR__
        __RR__
        ______
        ______
    ''', '''
        <style>
            @page {
                size: 6px;
            }
            body {
                color: blue;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div {
                color: red;
                position: absolute;
                left: 2px;
                top: 2px;
                width: 2px;
            }
            div + article {
                break-before: page;
            }
        </style>
        <article>a</article>
        <div>a a a a</div>
        <article>a</article>
    ''')


@assert_no_logs
def test_absolute_split_11(assert_pixels):
    assert_pixels('''
        BBBBBB
        BBBBBB
        BBRRBB
        BBRRBB
        __RR__
        __RR__
    ''', '''
        <style>
            @page {
                size: 6px;
            }
            body {
                color: blue;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div {
                bottom: 0;
                color: red;
                position: absolute;
                left: 2px;
                width: 2px;
            }
        </style>
        aaa aaa<div>a a</div>
    ''')


@assert_no_logs
def test_absolute_split_12(assert_pixels):
    assert_pixels('''
        BBBBBB__
        BBBBBB__
        ________
        ________
        ________
        ________
        ________
        ________
        BB______
        BB______
        BBRR____
        BBRR____
        BBRRRR__
        BBRRRR__
        BBRRRRRR
        BBRRRRRR
    ''', '''
        <style>
            @page {
                size: 8px;
            }
            body {
                color: blue;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div {
                break-inside: avoid;
            }
            section {
                left: 2px;
                position: absolute;
                color: red;
            }
        </style>
        aaa
        <div>
          a
          <section>x<br>xx<br>xxx</section>
          <br>
          a<br>
          a<br>
          a
        </div>
    ''')


@pytest.mark.xfail
@assert_no_logs
def test_absolute_next_page(assert_pixels):
    # TODO: currently, the layout of absolute boxes forces to render a box,
    # even when it doesn’t fit in the page. This workaround avoids placeholders
    # with no box. Instead, we should remove these placeholders, or avoid
    # crashes when they’re rendered.
    assert_pixels('''
        RRRRRRRRRR______
        RRRRRRRRRR______
        RRRRRRRRRR______
        RRRRRRRRRR______
        BBBBBBRRRR______
        BBBBBBRRRR______
        BBBBBB__________
        ________________
    ''', '''
        <style>
            @page {
                size: 16px 4px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                position: absolute;
                font-size: 3px;
            }
        </style>
        aaaaa aaaaa
        <div class="split">bb</div>
        aaaaa
    ''')


@assert_no_logs
def test_absolute_rtl_1(assert_pixels):
    assert_pixels('''
        __________RRRRRR
        __________RRRRRR
        ________________
    ''', '''
        <style>
            @page {
                size: 16px 3px;
            }
            body {
                direction: rtl;
            }
            div {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
                position: absolute;
            }
        </style>
        <div>bbb</div>
    ''')


@assert_no_logs
def test_absolute_rtl_2(assert_pixels):
    assert_pixels('''
        ________________
        _________RRRRRR_
        _________RRRRRR_
    ''', '''
        <style>
            @page {
                size: 16px 3px;
            }
            body {
                direction: rtl;
            }
            div {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
                padding: 1px;
                position: absolute;
            }
        </style>
        <div>bbb</div>
    ''')


@assert_no_logs
def test_absolute_rtl_3(assert_pixels):
    assert_pixels('''
        ________________
        RRRRRR__________
        RRRRRR__________
    ''', '''
        <style>
            @page {
                size: 16px 3px;
            }
            body {
                direction: rtl;
            }
            div {
                bottom: 0;
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                left: 0;
                line-height: 1;
                position: absolute;
            }
        </style>
        <div>bbb</div>
    ''')


@assert_no_logs
def test_absolute_rtl_4(assert_pixels):
    assert_pixels('''
        ________________
        _________RRRRRR_
        _________RRRRRR_
    ''', '''
        <style>
            @page {
                size: 16px 3px;
            }
            body {
                direction: rtl;
            }
            div {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
                position: absolute;
                right: 1px;
                top: 1px;
            }
        </style>
        <div>bbb</div>
    ''')


@assert_no_logs
def test_absolute_rtl_5(assert_pixels):
    assert_pixels('''
        RRRRRR__________
        RRRRRR__________
        ________________
    ''', '''
        <style>
            @page {
                size: 16px 3px;
            }
            div {
                color: red;
                direction: rtl;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
                position: absolute;
            }
        </style>
        <div>bbb</div>
    ''')


@assert_no_logs
def test_absolute_pages_counter(assert_pixels):
    assert_pixels('''
        ______
        _RR___
        _RR___
        _RR___
        _RR___
        _____B
        ______
        _RR___
        _RR___
        _BB___
        _BB___
        _____B
    ''', '''
        <style>
            @page {
                font-family: weasyprint;
                margin: 1px;
                size: 6px 6px;
                @bottom-right-corner {
                    color: blue;
                    content: counter(pages);
                    font-size: 1px;
                }
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div {
                color: blue;
                position: absolute;
            }
        </style>
        a a a <div>a a</div>
    ''')


@assert_no_logs
def test_absolute_pages_counter_orphans(assert_pixels):
    assert_pixels('''
        ______
        _RR___
        _RR___
        _RR___
        _RR___
        ______
        ______
        ______
        _____B
        ______
        _RR___
        _RR___
        _BB___
        _BB___
        _GG___
        _GG___
        ______
        _____B
    ''', '''
        <style>
            @page {
                font-family: weasyprint;
                margin: 1px;
                size: 6px 9px;
                @bottom-right-corner {
                    color: blue;
                    content: counter(pages);
                    font-size: 1PX;
                }
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
                orphans: 2;
                widows: 2;
            }
            div {
                color: blue;
                position: absolute;
            }
            div ~ div {
                color: lime;
            }
        </style>
        a a a <div>a a a</div> a <div>a a a</div>
    ''')


@assert_no_logs
def test_absolute_in_inline(assert_pixels):
    assert_pixels('''
        ______
        _GG___
        _GG___
        _GG___
        _GG___
        ______
        ______
        ______
        ______

        ______
        _RR___
        _RR___
        _RR___
        _RR___
        _BB___
        _BB___
        ______
        ______
    ''', '''
        <style>
            @page {
                margin: 1px;
                size: 6px 9px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
                orphans: 2;
                widows: 2;
            }
            p {
                color: lime;
            }
            div {
                color: blue;
                position: absolute;
            }
        </style>
        <p>a a</p> a a <div>a</div>
    ''')


@assert_no_logs
def test_fixed_in_inline(assert_pixels):
    assert_pixels('''
        ______
        _GG___
        _GG___
        _GG___
        _GG___
        _BB___
        _BB___
        ______
        ______

        ______
        _RR___
        _RR___
        _RR___
        _RR___
        _BB___
        _BB___
        ______
        ______
    ''', '''
        <style>
            @page {
                margin: 1px;
                size: 6px 9px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2PX;
                line-height: 1;
                orphans: 2;
                widows: 2;
            }
            p {
                color: lime;
            }
            div {
                color: blue;
                position: fixed;
            }
        </style>
        <p>a a</p> a a <div>a</div>
    ''')


@assert_no_logs
def test_absolute_image_background(assert_pixels):
    assert_pixels('''
        ____
        _RBB
        _BBB
        _BBB
    ''', '''
        <style>
          @page {
            size: 4px;
          }
          img {
            background: blue;
            position: absolute;
            top: 1px;
            left: 1px;
          }
        </style>
        <img src="pattern-transparent.svg" />
    ''')


@assert_no_logs
def test_absolute_in_absolute_break(assert_pixels):
    # Regression test for #2134.
    assert_pixels('''
        BBBB
        BBBB
        BBBB
        BBBB
        BBBB

        BBBB
        BBBB
        BBBB
        BBBB
        BBBB

        BBBB
        BBBB
        RRRR
        RRRR
        RRRR

        RRRR
        RRRR
        ____
        ____
        ____
    ''', '''
        <style>
          @page {
            size: 4px 5px;
          }
          body {
            font-size: 2px;
            line-height: 1;
          }
          div {
            position: absolute;
            width: 100%;
          }
        </style>
        <div style="background: blue">
          <br><br><br><br><br>
          <div style="background: red">
            <br><br>
          </div>
        </div>
        <br><br><br><br><br><br><br>
    ''')


@assert_no_logs
@pytest.mark.parametrize(('position', 'display'), [
    ('absolute', 'grid'),
    ('absolute', 'flex'),
    ('relative', 'grid'),
    ('relative', 'flex'),
])
def test_absolute_alternative_layout(assert_pixels, position, display):
    # Regression test for #2450.
    assert_pixels('''
        ______
        _RRRR_
        _RBBR_
        _RBBR_
        _RRRR_
        ______
    ''', '''
        <style>
          @page {
            size: 6px;
          }
          div {
            background: blue;
            position: %s;
            display: %s;
            top: 1px;
            left: 1px;
            border: 1px solid red;
            font: 2px weasyprint;
            color: transparent;
            width: 2px;
          }
        </style>
        <div>a</div>
    ''' % (position, display))


================================================
FILE: tests/draw/test_background.py
================================================
"""Test how backgrounds are drawn."""

import pytest

from ..testing_utils import assert_no_logs


@assert_no_logs
@pytest.mark.parametrize(
    ('expected_pixels', 'html'), [
        ((10 * (10 * 'B' + '\n')), '''
           <style>
             @page { size: 10px }
             /* body’s background propagates to the whole canvas */
             body { margin: 2px; background: #00f; height: 5Px }
           </style>
         <body>'''),
        ('''
             rrrrrrrrrr
             rrrrrrrrrr
             rrBBBBBBrr
             rrBBBBBBrr
             rrBBBBBBrr
             rrBBBBBBrr
             rrBBBBBBrr
             rrrrrrrrrr
             rrrrrrrrrr
             rrrrrrrrrr
         ''', '''
           <style>
             @page { size: 10px }
             /* html’s background propagates to the whole canvas */
             html { padding: 1px; background: #f00 }
             /* html has a background, so body’s does not propagate */
             body { margin: 1px; background: #00f; height: 5px }
          </style>
          <body>'''),
    ])
def test_canvas_background(assert_pixels, expected_pixels, html):
    assert_pixels(expected_pixels, html)


def test_canvas_background_size(assert_pixels):
    assert_pixels('''
        __________
        __________
        __RRRRRR__
        __RGGGGR__
        __zzzzzz__
        __zzzzzz__
        __BBBBBB__
        __BBBBBB__
        __________
        __________
    ''', '''
      <style>
         @page { size: 10px; margin: 2px }
         /* html’s background propagates to the whole canvas */
         html { background: linear-gradient(
           red 0, red 50%, blue 50%, blue 100%); }
         /* html has a background, so body’s does not propagate */
         body { margin: 1px; background: lime; height: 1px }
      </style>
      <body>
    ''')


@assert_no_logs
@pytest.mark.parametrize(('css', 'pixels'), [
    ('url(pattern.png)', '''
        ______________
        ______________
        __rBBBrBBBrB__
        __BBBBBBBBBB__
        __BBBBBBBBBB__
        __BBBBBBBBBB__
        __rBBBrBBBrB__
        __BBBBBBBBBB__
        __BBBBBBBBBB__
        __BBBBBBBBBB__
        __rBBBrBBBrB__
        __BBBBBBBBBB__
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) repeat-x', '''
        ______________
        ______________
        __rBBBrBBBrB__
        __BBBBBBBBBB__
        __BBBBBBBBBB__
        __BBBBBBBBBB__
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) repeat-y', '''
        ______________
        ______________
        __rBBB________
        __BBBB________
        __BBBB________
        __BBBB________
        __rBBB________
        __BBBB________
        __BBBB________
        __BBBB________
        __rBBB________
        __BBBB________
        ______________
        ______________
        ______________
        ______________
    '''),

    ('url(pattern.png) no-repeat 0 0%', '''
        ______________
        ______________
        __rBBB________
        __BBBB________
        __BBBB________
        __BBBB________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat 50% 0px', '''
        ______________
        ______________
        _____rBBB_____
        _____BBBB_____
        _____BBBB_____
        _____BBBB_____
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat 6px top', '''
        ______________
        ______________
        ________rBBB__
        ________BBBB__
        ________BBBB__
        ________BBBB__
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat bottom 6PX right 0', '''
        ______________
        ______________
        ________rBBB__
        ________BBBB__
        ________BBBB__
        ________BBBB__
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat left center', '''
        ______________
        ______________
        ______________
        ______________
        ______________
        __rBBB________
        __BBBB________
        __BBBB________
        __BBBB________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat center left', '''
        ______________
        ______________
        ______________
        ______________
        ______________
        __rBBB________
        __BBBB________
        __BBBB________
        __BBBB________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat 3px 3px', '''
        ______________
        ______________
        ______________
        ______________
        ______________
        _____rBBB_____
        _____BBBB_____
        _____BBBB_____
        _____BBBB_____
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat 100% 50%', '''
        ______________
        ______________
        ______________
        ______________
        ______________
        ________rBBB__
        ________BBBB__
        ________BBBB__
        ________BBBB__
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),

    ('url(pattern.png) no-repeat 0% bottom', '''
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        __rBBB________
        __BBBB________
        __BBBB________
        __BBBB________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat center 6px', '''
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        _____rBBB_____
        _____BBBB_____
        _____BBBB_____
        _____BBBB_____
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat bottom center', '''
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        _____rBBB_____
        _____BBBB_____
        _____BBBB_____
        _____BBBB_____
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat 6px 100%', '''
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ________rBBB__
        ________BBBB__
        ________BBBB__
        ________BBBB__
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) repeat-x 1px 2px', '''
        ______________
        ______________
        ______________
        ______________
        __BrBBBrBBBr__
        __BBBBBBBBBB__
        __BBBBBBBBBB__
        __BBBBBBBBBB__
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) repeat-y local 2pX 1px', '''
        ______________
        ______________
        ____BBBB______
        ____rBBB______
        ____BBBB______
        ____BBBB______
        ____BBBB______
        ____rBBB______
        ____BBBB______
        ____BBBB______
        ____BBBB______
        ____rBBB______
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat fixed', '''
        # The image is actually here:
        #######
        ______________
        ______________
        __BB__________
        __BB__________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat fixed right 3px', '''
        #                   x x x x
        ______________
        ______________
        ______________
        __________rB__   #
        __________BB__   #
        __________BB__   #
        __________BB__   #
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png)no-repeat fixed 50%center', '''
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        _____rBBB_____
        _____BBBB_____
        _____BBBB_____
        _____BBBB_____
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat, url(pattern.png) no-repeat 2px 1px', '''
        ______________
        ______________
        __rBBB________
        __BBBBBB______
        __BBBBBB______
        __BBBBBB______
        ____BBBB______
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    ('url(pattern.png) no-repeat 2px 1px, url(pattern.png) no-repeat', '''
        ______________
        ______________
        __rBBB________
        __BBrBBB______
        __BBBBBB______
        __BBBBBB______
        ____BBBB______
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
])
def test_background_image(assert_pixels, css, pixels):
    assert_pixels(pixels, '''
      <style>
        @page { size: 14px 16px }
        html { background: #fff }
        body { margin: 2px; height: 10px; background: %s }
        p { background: none }
      </style>
      <body>
      <p>&nbsp;
    ''' % css)


@assert_no_logs
def test_background_image_zero_size_background(assert_pixels):
    # Regression test for #217.
    assert_pixels('''
        __________
        __________
        __________
        __________
        __________
        __________
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page { size: 10px }
        html { background: #fff }
        body { background: url(pattern.png);
               background-size: cover;
               display: inline-block }
      </style>
      <body>
    ''')


@assert_no_logs
@pytest.mark.parametrize(('css', 'pixels'), [
    ('border-box', '''
        ____________
        ____________
        ____________
        ____________
        ____________
        ____________
        ____________
        _______rBBB_
        _______BBBB_
        _______BBBB_
        _______BBBB_
        ____________
    '''),
    ('padding-box', '''
        ____________
        ____________
        ____________
        ____________
        ____________
        ____________
        ______rBBB__
        ______BBBB__
        ______BBBB__
        ______BBBB__
        ____________
        ____________
    '''),
    ('content-box', '''
        ____________
        ____________
        ____________
        ____________
        ____________
        _____rBBB___
        _____BBBB___
        _____BBBB___
        _____BBBB___
        ____________
        ____________
        ____________
    '''),
    ('border-box; background-clip: content-box', '''
        ____________
        ____________
        ____________
        ____________
        ____________
        ____________
        ____________
        _______rB___
        _______BB___
        ____________
        ____________
        ____________
    ''')
])
def test_background_origin(assert_pixels, css, pixels):
    """Test the background-origin property."""
    assert_pixels(pixels, '''
      <style>
        @page { size: 12px }
        html { background: #fff }
        body { margin: 1px; padding: 1px; height: 6px;
               border: 1px solid transparent;
               background: url(pattern.png) bottom right no-repeat;
               background-origin: %s }
      </style>
      <body>''' % css)


@assert_no_logs
def test_background_transform(assert_pixels):
    # Regression test for #1809.
    assert_pixels('''
        _______
        _RRRRR_
        _RRRRR_
        _RRRRR_
        _RRRRR_
        _RRRRR_
        _______
    ''', '''
      <style>
        @page { size: 7px 7px }
        html { background: #fff }
        body { position: absolute;
               width: 5px; height: 5px;
               top: -5px; left: -5px;
               transform: translate(6px,6px);
               background: red }
      </style>
      <body>''')


@assert_no_logs
def test_background_repeat_space_1(assert_pixels):
    assert_pixels('''
        ____________
        _rBBB__rBBB_
        _BBBB__BBBB_
        _BBBB__BBBB_
        _BBBB__BBBB_
        ____________
        _rBBB__rBBB_
        _BBBB__BBBB_
        _BBBB__BBBB_
        _BBBB__BBBB_
        ____________
        _rBBB__rBBB_
        _BBBB__BBBB_
        _BBBB__BBBB_
        _BBBB__BBBB_
        ____________
    ''', '''
      <style>
        @page { size: 12px 16px }
        html { background: #fff }
        body { margin: 1px; height: 14px;
               background: url(pattern.png) space }
      </style>
      <body>''')


@assert_no_logs
def test_background_repeat_space_2(assert_pixels):
    assert_pixels('''
        ____________
        _rBBB__rBBB_
        _BBBB__BBBB_
        _BBBB__BBBB_
        _BBBB__BBBB_
        _rBBB__rBBB_
        _BBBB__BBBB_
        _BBBB__BBBB_
        _BBBB__BBBB_
        _rBBB__rBBB_
        _BBBB__BBBB_
        _BBBB__BBBB_
        _BBBB__BBBB_
        ____________
    ''', '''
      <style>
        @page { size: 12px 14px }
        html { background: #fff }
        body { margin: 1px; height: 12px;
               background: url(pattern.png) space }
      </style>
      <body>''')


@assert_no_logs
def test_background_repeat_space_3(assert_pixels):
    assert_pixels('''
        ____________
        _rBBBrBBBrB_
        _BBBBBBBBBB_
        _BBBBBBBBBB_
        _BBBBBBBBBB_
        ____________
        ____________
        ____________
        _rBBBrBBBrB_
        _BBBBBBBBBB_
        _BBBBBBBBBB_
        _BBBBBBBBBB_
        ____________
    ''', '''
      <style>
        @page { size: 12px 13px }
        html { background: #fff }
        body { margin: 1px; height: 11px;
               background: url(pattern.png) repeat space }
      </style>
      <body>''')


@assert_no_logs
def test_background_repeat_space_4(assert_pixels):
    assert_pixels('''
        ________
        _rBBBGG_
        _BBBBGG_
        _BBBBGG_
        _BBBBGG_
        _GGGGGG_
        _GGGGGG_
        ________
    ''', '''
      <style>
        @page { size: 8px }
        html { background: #fff }
        body { margin: 1px; height: 6Px;
               background: url(pattern.png) space lime }
      </style>
      <body>''')


@assert_no_logs
def test_background_repeat_round_1(assert_pixels):
    assert_pixels('''
        __________
        _rrBBBBBB_
        _rrBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _rrBBBBBB_
        _rrBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        __________
    ''', '''
      <style>
        @page { size: 10px 14px }
        html { background: #fff }
        body { margin: 1px; height: 12px;
               image-rendering: pixelated;
               background: url(pattern.png) top/6px round repeat; }
      </style>
      <body>''')


@assert_no_logs
def test_background_repeat_round_2(assert_pixels):
    assert_pixels('''
        __________
        _rrBBBBBB_
        _rrBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _rrBBBBBB_
        _rrBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        __________
    ''', '''
      <style>
        @page { size: 10px 18px }
        html { background: #fff }
        body { margin: 1px; height: 16px;
               image-rendering: pixelated;
               background: url(pattern.png) center/auto 8px repeat round; }
      </style>
      <body>''')


@assert_no_logs
def test_background_repeat_round_3(assert_pixels):
    assert_pixels('''
        __________
        _rrBBBBBB_
        _rrBBBBBB_
        _rrBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        __________
    ''', '''
      <style>
        @page { size: 10px 14px }
        html { background: #fff }
        body { margin: 1px; height: 12px;
               image-rendering: pixelated;
               background: url(pattern.png) center/6px 9px round; }
      </style>
      <body>''')


@assert_no_logs
def test_background_repeat_round_4(assert_pixels):
    assert_pixels('''
        __________
        _rBBBrBBB_
        _rBBBrBBB_
        _rBBBrBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        __________
    ''', '''
      <style>
        @page { size: 10px 14px }
        html { background: #fff }
        body { margin: 1px; height: 12px;
               image-rendering: pixelated;
               background: url(pattern.png) center/5px 9px round; }
      </style>
      <body>''')


@assert_no_logs
@pytest.mark.parametrize(('css', 'pixels'), [
    ('#00f border-box', '''
        ________
        _BBBBBB_
        _BBBBBB_
        _BBBBBB_
        _BBBBBB_
        _BBBBBB_
        _BBBBBB_
        ________
    '''),
    ('#00f padding-box', '''
        ________
        ________
        __BBBB__
        __BBBB__
        __BBBB__
        __BBBB__
        ________
        ________
    '''),
    ('#00f content-box', '''
        ________
        ________
        ________
        ___BB___
        ___BB___
        ________
        ________
        ________
    '''),
    ('url(pattern.png) padding-box, #0f0', '''
        ________
        _GGGGGG_
        _GrBBBG_
        _GBBBBG_
        _GBBBBG_
        _GBBBBG_
        _GGGGGG_
        ________
    '''),
])
def test_background_clip(assert_pixels, css, pixels):
    assert_pixels(pixels, '''
      <style>
        @page { size: 8px }
        html { background: #fff }
        body { margin: 1px; padding: 1px; height: 2px;
               border: 1px solid transparent;
               background: %s }
      </style>
      <body>''' % css)


@assert_no_logs
@pytest.mark.parametrize(('expected_pixels', 'html'), [
    ('''
         ____________
         ____________
         ____________
         ___rrBBBBBB_
         ___rrBBBBBB_
         ___BBBBBBBB_
         ___BBBBBBBB_
         ___BBBBBBBB_
         ___BBBBBBBB_
         ___BBBBBBBB_
         ___BBBBBBBB_
         ____________
     ''', '''
       <style>
         @page { size: 12px }
         html { background: #fff }
         body { margin: 1px; height: 10px;
                /* Use nearest neighbor algorithm for image resizing: */
                image-rendering: pixelated;
                background: url(pattern.png) no-repeat
                            bottom right / 80% 8px; }
       </style>
       <body>'''),
    ('''
         ____________
         ____________
         ____________
         ____________
         ____________
         ____________
         ____________
         _______rBBB_
         _______BBBB_
         _______BBBB_
         _______BBBB_
         ____________
     ''', '''
       <style>
         @page { size: 12px }
         html { background: #fff }
         body { margin: 1px; height: 10px;
                /* Use nearest neighbor algorithm for image resizing: */
                image-rendering: pixelated;
                background: url(pattern.png) bottom right/auto no-repeat }
       </style>
       <body>'''),
    ('''
         ______________
         _rrBBBBBB_____
         _rrBBBBBB_____
         _BBBBBBBB_____
         _BBBBBBBB_____
         _BBBBBBBB_____
         _BBBBBBBB_____
         _BBBBBBBB_____
         _BBBBBBBB_____
         ______________
     ''', '''
       <style>
         @page { size: 14px 10px }
         html { background: #fff }
         body { margin: 1px; height: 8px;
                /* Use nearest neighbor algorithm for image resizing: */
                image-rendering: pixelated;
                background: url(pattern.png) no-repeat;
                background-size: contain }
       </style>
       <body>'''),

    ('''
         ______________
         _rrBBBBBB_____
         _rrBBBBBB_____
         _BBBBBBBB_____
         _BBBBBBBB_____
         _BBBBBBBB_____
         _BBBBBBBB_____
         _BBBBBBBB_____
         _BBBBBBBB_____
         ______________
     ''', '''
       <style>
         @page { size: 14px 10px }
         html { background: #fff }
         body { margin: 1px; height: 8px;
                /* Use nearest neighbor algorithm for image resizing: */
                image-rendering: pixelated;
                background: url(pattern.png) no-repeat left / auto 8px;
                clip: auto; /* no-op to cover more validation */ }
       </style>
       <body>'''),
    ('''
         ______________
         _rrBBBBBB_____
         _BBBBBBBB_____
         _BBBBBBBB_____
         _BBBBBBBB_____
         ______________
         ______________
         ______________
         ______________
         ______________
     ''', '''
       <style>
         @page { size: 14px 10px }
         html { background: #fff }
         body { margin: 1px; height: 8px;
                /* Use nearest neighbor algorithm for image resizing: */
                image-rendering: pixelated;
                background: url(pattern.png) no-repeat 0 0 / 8px 4px;
                clip: auto; /* no-op to cover more validation */ }
       </style>
       <body>'''),
    ('''
         ______________
         _rrrBBBBBBBBB_
         _rrrBBBBBBBBB_
         _rrrBBBBBBBBB_
         _BBBBBBBBBBBB_
         _BBBBBBBBBBBB_
         _BBBBBBBBBBBB_
         _BBBBBBBBBBBB_
         _BBBBBBBBBBBB_
         ______________
     ''', '''
       <style>
         @page { size: 14px 10px }
         html { background: #fff }
         body { margin: 1px; height: 8px;
                /* Use nearest neighbor algorithm for image resizing: */
                image-rendering: pixelated;
                background: url(pattern.png) no-repeat right 0/cover }
       </style>
       <body>'''),
    ]
)
def test_background_size(assert_pixels, expected_pixels, html):
    assert_pixels(expected_pixels, html)


@assert_no_logs
def test_bleed_background_size(assert_pixels):
    assert_pixels('''
        RRRR
        RRRR
        RRRR
        RRRR
    ''', '''
      <style>
         @page { size: 2px; bleed: 1px; background: red }
      </style>
      <body>''')


@assert_no_logs
def test_background_size_clip(assert_pixels):
    assert_pixels('''
        BBBB
        BRBB
        BBBB
        BBBB
    ''', '''
      <style>
         @page { size: 4px; margin: 1px;
                 background: url(pattern.png) red;
                 background-clip: content-box }
      </style>
      <body>''')


@assert_no_logs
def test_page_background_fixed(assert_pixels):
    # Regression test for #1993.
    assert_pixels('''
        RBBB
        BBBB
        BBBB
        BBBB
    ''', '''
      <style>
         @page { size: 4px; margin: 1px;
                 background: url(pattern.png) red;
                 background-attachment: fixed; }
      </style>
      <body>''')


@assert_no_logs
def test_page_background_fixed_bleed(assert_pixels):
    # Regression test for #1993.
    assert_pixels('''
        RRRRRR
        RRBBBR
        RBBBBR
        RBBBBR
        RBBBBR
        RRRRRR
    ''', '''
      <style>
         @page { size: 4px; margin: 1px; bleed: 1px;
                 background: url(pattern.png) no-repeat red;
                 background-attachment: fixed; }
      </style>
      <body>''')


@assert_no_logs
def test_bleed_background_size_clip(assert_pixels):
    # Regression test for #1943.
    assert_pixels('''
        BBBBBB
        BBBBBB
        BBRBBB
        BBBBBB
        BBBBBB
        BBBBBB
    ''', '''
      <style>
         @page { size: 4px; bleed: 1px; margin: 1px;
                 background: url(pattern.png) red;
                 background-clip: content-box }
      </style>
      <body>''')


@assert_no_logs
def test_marks_crop(assert_pixels):
    assert_pixels('''
        KK__KK
        K____K
        ______
        ______
        K____K
        KK__KK
    ''', '''
      <style>
         @page { size: 4px; bleed: 1px; margin: 1px; marks: crop }
      </style>
      <body>''')


@assert_no_logs
def test_marks_cross(assert_pixels):
    assert_pixels('''
        __KK__
        ______
        K____K
        K____K
        ______
        __KK__
    ''', '''
      <style>
         @page { size: 4px; bleed: 1px; margin: 1px; marks: cross }
      </style>
      <body>''')


@assert_no_logs
def test_marks_crop_cross(assert_pixels):
    assert_pixels('''
        KKKKKK
        K____K
        K____K
        K____K
        K____K
        KKKKKK
    ''', '''
      <style>
         @page { size: 4px; bleed: 1px; margin: 1px; marks: crop cross }
      </style>
      <body>''')


================================================
FILE: tests/draw/test_before_after.py
================================================
"""Test how before and after pseudo elements are drawn."""

from ..testing_utils import assert_no_logs


@assert_no_logs
def test_before_after_1(assert_same_renderings):
    assert_same_renderings(
        '''
            <style>
                @page { size: 300px 30px }
                body { margin: 0 }
                a[href]:before { content: '[' attr(href) '] ' }
            </style>
            <p><a href="some url">some content</a></p>
        ''',
        '''
            <style>
                @page { size: 300px 30PX }
                body { margin: 0 }
            </style>
            <p><a href="another url"><span>[some url] </span>some content</p>
        ''', tolerance=10)


@assert_no_logs
def test_before_after_2(assert_same_renderings):
    assert_same_renderings(
        '''
            <style>
                @page { size: 500px 30px }
                body { margin: 0; quotes: '«' '»' '“' '”' }
                q:before { content: open-quote ' '}
                q:after { content: ' ' close-quote }
            </style>
            <p><q>Lorem ipsum <q>dolor</q> sit amet</q></p>
        ''',
        '''
            <style>
                @page { size: 500px 30Px }
                body { margin: 0 }
                q:before, q:after { content: none }
            </style>
            <p><span><span>« </span>Lorem ipsum
                <span><span>“ </span>dolor<span> ”</span></span>
                sit amet<span> »</span></span></p>
        ''', tolerance=10)


@assert_no_logs
def test_before_after_3(assert_same_renderings):
    assert_same_renderings(
        '''
            <style>
                @page { size: 100px 30px }
                body { margin: 0; }
                p:before { content: 'a' url(pattern.png) 'b'}
            </style>
            <p>c</p>
        ''',
        '''
            <style>
                @page { size: 100PX 30px }
                body { margin: 0 }
            </style>
            <p><span>a<img src="pattern.png" alt="Missing image">b</span>c</p>
        ''', tolerance=10)


================================================
FILE: tests/draw/test_box.py
================================================
"""Test how boxes, borders, outlines are drawn."""

import itertools

import pytest

from weasyprint import HTML

from ..testing_utils import assert_no_logs


@assert_no_logs
@pytest.mark.parametrize(('margin', 'prop'), [
    ('10px', 'border'),
    ('20px', 'outline'),
])
def test_outlines_and_borders(assert_pixels, assert_different_renderings, margin, prop):
    """Test the rendering of outlines and borders."""
    source = '''
      <style>
        @page { size: 140px 110px }
        body { width: 100px; height: 70px; margin: %s; %s: 10PX %s blue }
      </style>
      <body>'''

    # Do not test the exact rendering of earch border style but at least
    # check that they do not do the same.
    documents = (
        source % (margin, prop, border_style)
        for border_style in (
            'none', 'solid', 'dashed', 'dotted', 'double',
            'inset', 'outset', 'groove', 'ridge'))
    assert_different_renderings(*documents)

    css_margin = margin
    width = 140
    height = 110
    margin = 10
    border = 10
    solid_pixels = [['_'] * width for _ in range(height)]
    for x in range(margin, width - margin):
        for y in itertools.chain(
                range(margin, margin + border),
                range(height - margin - border, height - margin)):
            solid_pixels[y][x] = 'B'
    for y in range(margin, height - margin):
        for x in itertools.chain(
                range(margin, margin + border),
                range(width - margin - border, width - margin)):
            solid_pixels[y][x] = 'B'
    pixels = '\n'.join(''.join(chars) for chars in solid_pixels)
    html = source % (css_margin, prop, 'solid')
    assert_pixels(pixels, html)


@assert_no_logs
def test_borders_table_collapse(assert_different_renderings):
    """Test the rendering of collapsing borders."""
    source = '''
      <style>
        @page { size: 140px 110px }
        table { width: 100px; height: 70px; margin: 10px;
                border-collapse: collapse; border: 10px %s blue }
      </style>
      <table><td>abc</td>'''

    # Do not test the exact rendering of earch border style but at least
    # check that they do not do the same.
    documents = (
        source % border_style
        for border_style in (
            'none', 'solid', 'dashed', 'dotted', 'double',
            'inset', 'groove'))
    assert_different_renderings(*documents)


@assert_no_logs
@pytest.mark.parametrize('styles', [
    ('groove', 'outset'),
    ('ridge', 'inset'),
])
def test_borders_table_collapse_equivalent(assert_same_renderings, styles):
    """Test the rendering of equivalent collapsing borders."""
    source = '''
      <style>
        @page { size: 140px 110px }
        table { width: 100px; height: 70px; margin: 10px;
                border-collapse: collapse; border: 10pX %s blue }
      </style>
      <table><td>abc</td>'''

    documents = (source % border_style for border_style in styles)
    assert_same_renderings(*documents)


@assert_no_logs
@pytest.mark.parametrize('border_style', ['none', 'solid', 'dashed', 'dotted'])
def test_small_borders_1(border_style):
    # Regression test for #49.
    html = '''
      <style>
        @page { size: 50px 50px }
        body { margin: 5px; height: 0; border: 10px %s blue }
      </style>
      <body>''' % border_style
    HTML(string=html).write_pdf()


@assert_no_logs
@pytest.mark.parametrize('border_style', ['none', 'solid', 'dashed', 'dotted'])
def test_small_borders_2(border_style):
    # Regression test for #146.
    html = '''
      <style>
        @page { size: 50Px 50px }
        body { height: 0; width: 0; border-width: 1px 0; border-style: %s }
      </style>
      <body>''' % border_style
    HTML(string=html).write_pdf()


@assert_no_logs
def test_em_borders():
    # Regression test for #1378.
    html = '<body style="border: 1em solid">'
    HTML(string=html).write_pdf()


@assert_no_logs
def test_borders_box_sizing(assert_pixels):
    assert_pixels('''
        ________
        _RRRRRR_
        _R____R_
        _RRRRRR_
        ________
    ''', '''
      <style>
        @page {
          size: 8px 5px;
        }
        div {
          border: 1px solid red;
          box-sizing: border-box;
          height: 3px;
          margin: 1px;
          min-height: auto;
          min-width: auto;
          width: 6px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_margin_boxes(assert_pixels):
    assert_pixels('''
        _______________
        _GGG______BBBB_
        _GGG______BBBB_
        _______________
        _____RRRR______
        _____RRRR______
        _____RRRR______
        _____RRRR______
        _______________
        _bbb______gggg_
        _bbb______gggg_
        _bbb______gggg_
        _bbb______gggg_
        _bbb______gggg_
        _______________
    ''', '''
      <style>
        html { height: 100% }
        body { background: #f00; height: 100% }
        @page {
          size: 15px;
          margin: 4px 6Px 7px 5px;

          @top-left-corner {
            margin: 1px;
            content: " ";
            background: #0f0;
          }
          @top-right-corner {
            margin: 1px;
            content: " ";
            background: #00f;
          }
          @bottom-right-corner {
            margin: 1px;
            content: " ";
            background: #008000;
          }
          @bottom-left-corner {
            margin: 1px;
            content: " ";
            background: #000080;
          }
        }
      </style>
      <body>''')


@assert_no_logs
def test_display_inline_block_twice():
    # Regression test for #880.
    html = '<div style="background: red; display: inline-block">'
    document = HTML(string=html).render()
    assert document.write_pdf() == document.write_pdf()


@assert_no_logs
def test_draw_border_radius(assert_pixels):
    assert_pixels('''
        ___zzzzz
        __zzzzzz
        _zzzzzzz
        zzzzzzzz
        zzzzzzzz
        zzzzzzzR
        zzzzzzRR
        zzzzzRRR
    ''', '''
      <style>
        @page {
          size: 8px 8px;
        }
        div {
          background: Red;
          border-radius: 50% 0 0 0;
          height: 16px;
          width: 16PX;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_draw_split_border_radius(assert_pixels):
    assert_pixels('''
        ___zzzzz
        __zzzzzz
        _zzzzzzz
        zzzzzzzz
        zzzzzzzz
        zzzzzzzz
        zzzzzzRR
        zzzzzRRR

        RRRRRRRR
        RRRRRRRR
        RRRRRRRR
        RRRRRRRR
        RRRRRRRR
        RRRRRRRR
        RRRRRRRR
        RRRRRRRR

        zzzzzzRR
        zzzzzzzR
        zzzzzzzz
        zzzzzzzz
        zzzzzzzz
        zzzzzzzz
        _zzzzzzz
        __zzzzzz
    ''', '''
      <style>
        @page {
          size: 8px 8px;
        }
        div {
          background: red;
          color: transparent;
          border-radius: 8px;
          line-height: 9px;
          width: 16px;
        }
      </style>
      <div>a b c</div>
    ''')


@assert_no_logs
def test_border_image_stretch(assert_pixels):
    assert_pixels('''
        __________
        _RYYYMMMG_
        _M______C_
        _M______C_
        _Y______Y_
        _Y______Y_
        _BYYYCCCK_
        __________
    ''', '''
      <style>
        @page {
          size: 10px 8px;
        }
        div {
          border: 1px solid black;
          border-image-source: url(border.svg);
          border-image-slice: 25%;
          height: 4px;
          margin: 1px;
          width: 6px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_border_image_fill(assert_pixels):
    assert_pixels('''
        __________
        _RYYYMMMG_
        _MbbbgggC_
        _MbbbgggC_
        _YgggbbbY_
        _YgggbbbY_
        _BYYYCCCK_
        __________
    ''', '''
      <style>
        @page {
          size: 10px 8px;
        }
        div {
          border: 1px solid black;
          border-image-source: url(border.svg);
          border-image-slice: 25% fill;
          height: 4px;
          margin: 1px;
          width: 6px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_border_image_default_slice(assert_pixels):
    assert_pixels('''
        _____________
        _RYMG___RYMG_
        _MbgC___MbgC_
        _YgbY___YgbY_
        _BYCK___BYCK_
        _____________
        _____________
        _RYMG___RYMG_
        _MbgC___MbgC_
        _YgbY___YgbY_
        _BYCK___BYCK_
        _____________
    ''', '''
      <style>
        @page {
          size: 13px 12px;
        }
        div {
          border: 4px solid black;
          border-image-source: url(border.svg);
          height: 2px;
          margin: 1px;
          width: 3px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_border_image_uneven_width(assert_pixels):
    assert_pixels('''
        ____________
        _RRRYYYMMMG_
        _MMM______C_
        _MMM______C_
        _YYY______Y_
        _YYY______Y_
        _BBBYYYCCCK_
        ____________
    ''', '''
      <style>
        @page {
          size: 12px 8px;
        }
        div {
          border: 1px solid black;
          border-left-width: 3px;
          border-image-source: url(border.svg);
          border-image-slice: 25%;
          height: 4px;
          margin: 1px;
          width: 6px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_border_image_not_percent(assert_pixels):
    assert_pixels('''
        __________
        _RYYYMMMG_
        _M______C_
        _M______C_
        _Y______Y_
        _Y______Y_
        _BYYYCCCK_
        __________
    ''', '''
      <style>
        @page {
          size: 10px 8px;
        }
        div {
          border: 1px solid black;
          border-image-source: url(border.svg);
          border-image-slice: 1;
          height: 4px;
          margin: 1px;
          width: 6px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_border_image_repeat(assert_pixels):
    assert_pixels('''
        ___________
        _RYMYMYMYG_
        _M_______C_
        _Y_______Y_
        _M_______C_
        _Y_______Y_
        _BYCYCYCYK_
        ___________
    ''', '''
      <style>
        @page {
          size: 11px 8px;
        }
        div {
          border: 1px solid black;
          border-image-source: url(border.svg);
          border-image-slice: 25%;
          border-image-repeat: repeat;
          height: 4px;
          margin: 1px;
          width: 7px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_border_image_space(assert_pixels):
    assert_pixels('''
        _________
        _R_YMC_G_
        _________
        _M_____C_
        _Y_____Y_
        _C_____M_
        _________
        _B_YCM_K_
        _________
    ''', '''
      <style>
        @page {
          size: 9px 9px;
        }
        div {
          border: 1px solid black;
          border-image-source: url(border2.svg);
          border-image-slice: 20%;
          border-image-repeat: space;
          height: 5px;
          margin: 1px;
          width: 5px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_border_image_outset(assert_pixels):
    assert_pixels('''
        ____________
        _RYYYYMMMMG_
        _M________C_
        _M_bbbbbb_C_
        _M_bbbbbb_C_
        _Y_bbbbbb_Y_
        _Y_bbbbbb_Y_
        _Y________Y_
        _BYYYYCCCCK_
        ____________
    ''', '''
      <style>
        @page {
          size: 12px 10px;
        }
        div {
          border: 1px solid black;
          border-image-source: url(border.svg);
          border-image-slice: 25%;
          border-image-outset: 2px;
          height: 2px;
          margin: 3px;
          width: 4px;
          background: #000080
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_border_image_width(assert_pixels):
    assert_pixels('''
        __________
        _RRYYMMGG_
        _RRYYMMGG_
        _MM____CC_
        _YY____YY_
        _BBYYCCKK_
        _BBYYCCKK_
        __________
    ''', '''
      <style>
        @page {
          size: 10px 8px;
        }
        div {
          border: 1px solid black;
          border-image-source: url(border.svg);
          border-image-slice: 25%;
          border-image-width: 2;
          height: 4px;
          margin: 1PX;
          width: 6px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_border_image_gradient(assert_pixels):
    assert_pixels('''
        __________
        _RRRRRRRR_
        _RRRRRRRR_
        _RR____RR_
        _BB____BB_
        _BBBBBBBB_
        _BBBBBBBB_
        __________
    ''', '''
      <style>
        @page {
          size: 10px 8px;
        }
        div {
          border: 1px solid black;
          border-image-source: linear-gradient(to bottom, red, red 50%, blue 50%, blue);
          border-image-slice: 25%;
          border-image-width: 2;
          height: 4px;
          margin: 1px;
          width: 6px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_border_image_gradient_units(assert_pixels):
    # Regression test for #2690.
    assert_pixels('''
        __________
        _RRRRRRRR_
        _RRRRRRRR_
        _RR____RR_
        _BB____BB_
        _BBBBBBBB_
        _BBBBBBBB_
        __________
    ''', '''
      <style>
        @page {
          size: 10px 8px;
        }
        div {
          border: 1px solid black;
          border-image-source: linear-gradient(
            to bottom, red 0, red 50%, blue 0.5em, blue);
          border-image-slice: 25%;
          border-image-width: 2;
          font-size: 6px;
          height: 4px;
          margin: 1px;
          width: 6px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_mask_border(assert_pixels):
    assert_pixels('''
        __________
        __RR__RRR_
        _R______R_
        _R______R_
        _s______R_
        _s______R_
        _R______R_
        _R______R_
        __RRRRRRR_
        __________
    ''', '''
      <style>
        @page {
          size: 10px 10px;
        }
        div {
          background: red;
          mask-border-source: url(mask.svg);
          mask-border-slice: 20%;
          height: 8px;
          width: 8px;
          margin: 1px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_mask_border_fill(assert_pixels):
    assert_pixels('''
        __________
        __RR__RRR_
        _RRRRRRRR_
        _RRRRRRRR_
        _sRR__RRR_
        _sRR__RRR_
        _RRRRRRRR_
        _RRRRRRRR_
        __RRRRRRR_
        __________
    ''', '''
      <style>
        @page {
          size: 10px 10px;
        }
        div {
          background: red;
          mask-border-source: url(mask.svg);
          mask-border-slice: 20% fill;
          height: 8px;
          width: 8px;
          margin: 1px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_outline_and_border(assert_pixels):
    assert_pixels('''
        __________
        _BBBBBBBB_
        _BRRRRRRB_
        _BR____RB_
        _BRRRRRRB_
        _BBBBBBBB_
        __________
    ''', '''
      <style>
        @page {
          size: 10px 7px;
        }
        div {
          border: 1px solid red;
          outline: 1px solid blue;
          height: 1px;
          margin: 2px;
          min-height: auto;
          min-width: auto;
          width: 4px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_outline_offset(assert_pixels):
    assert_pixels('''
        ____________
        _BBBBBBBBBB_
        _B________B_
        _B_RRRRRR_B_
        _B_R____R_B_
        _B_RRRRRR_B_
        _B________B_
        _BBBBBBBBBB_
        ____________
    ''', '''
      <style>
        @page {
          size: 12px 9px;
        }
        div {
          border: 1px solid red;
          outline: 1px solid blue;
          outline-offset: 1px;
          height: 1px;
          margin: 3px;
          min-height: auto;
          min-width: auto;
          width: 4px;
        }
      </style>
      <div></div>
    ''')


@assert_no_logs
def test_infinite_border_radius(assert_pixels):
    # Regression test for #2706.
    assert_pixels('''
        __________
        __zzzzzz__
        _zzzzzzzz_
        _zzzRRzzz_
        _zzRRRRzz_
        _zzRRRRzz_
        _zzzRRzzz_
        _zzzzzzzz_
        __zzzzzz__
        __________
    ''', '''
      <style>
        @page {
          size: 10px;
        }
        div {
          background-color: red;
          border-radius: calc(infinity * 1px);
          height: 8px;
          margin: 1px;
          width: 8px;
        }
      </style>
      <div></div>
    ''')


================================================
FILE: tests/draw/test_cmyk_color_profiles.py
================================================
"""Test CMYK and Color Profiles."""

from ..testing_utils import assert_no_logs


@assert_no_logs
def test_device_cmyk_with_icc(assert_pixels):
    assert_pixels('PP\nPP', '''
      <style>
        @color-profile device-cmyk {
          src: url(cmyk.icc);
          components: C, M, Y, K;
        }
        @page { size: 2px }
        html, body { height: 100%; margin: 0 }
        html { background: device-cmyk(0.8 0.6 0.4 0.2) }
      </style>
      <body>''')


@assert_no_logs
def test_device_cmyk_without_icc(assert_pixels):
    assert_pixels('QQ\nQQ', '''
      <style>
        @page { size: 2px }
        html, body { height: 100%; margin: 0 }
        html { background: device-cmyk(0.8 0.6 0.4 0.2) }
      </style>
      <body>''')


@assert_no_logs
def test_custom_cmyk_with_icc(assert_pixels):
    assert_pixels('PP\nPP', '''
      <style>
        @color-profile --custom-cmyk {
          src: url(cmyk.icc);
          components: C, M, Y, K;
        }
        @page { size: 2px }
        html, body { height: 100%; margin: 0 }
        html { background: color(--custom-cmyk 0.8 0.6 0.4 0.2) }
      </style>
      <body>''')


@assert_no_logs
def test_image_cmyk_without_icc(assert_pixels):
    assert_pixels('QQ\nQQ', '''
      <style>
        @page { size: 2px }
        img { display: block; }
      </style>
      <img src="cmyk_without_icc.jpg">''')


@assert_no_logs
def test_image_cmyk_with_external_icc(assert_pixels):
    assert_pixels('PP\nPP', '''
      <style>
        @color-profile device-cmyk {
          src: url(cmyk.icc);
          components: C, M, Y, K;
        }
        @page { size: 2px }
        img { display: block; }
      </style>
      <img src="cmyk_without_icc.jpg">''')


@assert_no_logs
def test_image_cmyk_with_icc(assert_pixels):
    assert_pixels('QQ\nQQ', '''
      <style>
        @page { size: 2px }
        img { display: block; }
      </style>
      <img src="cmyk_with_icc.jpg">''')


================================================
FILE: tests/draw/test_column.py
================================================
"""Test how columns are drawn."""

from ..testing_utils import assert_no_logs


@assert_no_logs
def test_column_rule_1(assert_pixels):
    assert_pixels('''
        a_r_a
        a_r_a
        _____
    ''', '''
      <style>
        img { display: inline-block; width: 1px; height: 1px }
        div { columns: 2; column-rule-style: solid;
              column-rule-width: 1px; column-gap: 3px;
              column-rule-color: red }
        body { margin: 0; font-size: 0 }
        @page { margin: 0; size: 5px 3Px }
      </style>
      <div>
        <img src=blue.jpg>
        <img src=blue.jpg>
        <img src=blue.jpg>
        <img src=blue.jpg>
      </div>''')


@assert_no_logs
def test_column_rule_2(assert_pixels):
    assert_pixels('''
        a_r_a
        a___a
        a_r_a
    ''', '''
      <style>
        img { display: inline-block; width: 1px; height: 1px }
        div { columns: 2; column-rule-style: dotted;
              column-rule-width: 1px; column-gap: 3px;
              column-rule-color: red }
        body { margin: 0; font-size: 0 }
        @page { margin: 0; size: 5px 3px }
      </style>
      <div>
        <img src=blue.jpg>
        <img src=blue.jpg>
        <img src=blue.jpg>
        <img src=blue.jpg>
        <img src=blue.jpg>
        <img src=blue.jpg>
      </div>''')


@assert_no_logs
def test_column_rule_span(assert_pixels):
    assert_pixels('''
        ___________
        ___________
        ___________
        ___a_______
        ___a_r_a___
        ___a_r_a___
        ___________
        ___________
        ___________
    ''', '''
      <style>
        img { display: inline-block; width: 1px; height: 1px }
        div { columns: 2; column-rule: 1px solid red; column-gap: 3px }
        article { column-span: all }
        body { margin: 0; font-size: 0 }
        @page { margin: 3px; size: 11px 9px }
      </style>
      <div>
        <article>
          <img src=blue.jpg>
        </article>
        <img src=blue.jpg>
        <img src=blue.jpg>
        <img src=blue.jpg>
        <img src=blue.jpg>
      </div>''')


@assert_no_logs
def test_column_rule_normal(assert_pixels):
    # Regression test for #2217.
    assert_pixels('''
        a___a
        a___a
        _____
    ''', '''
      <style>
        img { display: inline-block; width: 1px; height: 1px }
        div { columns: 2; column-gap: normal }
        body { margin: 0; font: 3px/0 weasyprint }
        @page { margin: 0; size: 5PX 3px }
      </style>
      <div>
        <img src=blue.jpg>
        <img src=blue.jpg>
        <img src=blue.jpg>
        <img src=blue.jpg>
      </div>''')


================================================
FILE: tests/draw/test_current_color.py
================================================
"""Test the currentColor value."""

import pytest

from ..testing_utils import assert_no_logs


@assert_no_logs
def test_current_color_1(assert_pixels):
    assert_pixels('GG\nGG', '''
      <style>
        @page { size: 2px }
        html, body { height: 100%; margin: 0 }
        html { color: red; background: currentColor }
        body { color: lime; background: inherit }
      </style>
      <body>''')


@assert_no_logs
def test_current_color_2(assert_pixels):
    assert_pixels('GG\nGG', '''
      <style>
        @page { size: 2px }
        html { color: red; border-color: currentColor }
        body { color: lime; border: 1Px solid; border-color: inherit;
               margin: 0 }
      </style>
      <body>''')


@assert_no_logs
def test_current_color_3(assert_pixels):
    assert_pixels('GG\nGG', '''
      <style>
        @page { size: 2px }
        html { color: red; outline-color: currentColor }
        body { color: lime; outline: 1px solid; outline-color: inherit;
               margin: 1px }
      </style>
      <body>''')


@assert_no_logs
def test_current_color_4(assert_pixels):
    assert_pixels('GG\nGG', '''
      <style>
        @page { size: 2px }
        html { color: red; border-color: currentColor; }
        body { margin: 0 }
        table { border-collapse: collapse;
                color: lime; border: 1PX solid; border-color: inherit }
      </style>
      <table><td>''')


@assert_no_logs
def test_current_color_svg_1(assert_pixels):
    assert_pixels('KK\nKK', '''
      <style>
        @page { size: 2px }
        svg { display: block }
      </style>
      <svg xmlns="http://www.w3.org/2000/svg"
           width="2" height="2" fill="currentColor">
        <rect width="2" height="2"></rect>
      </svg>''')


@pytest.mark.xfail
@assert_no_logs
def test_current_color_svg_2(assert_pixels):
    assert_pixels('GG\nGG', '''
      <style>
        @page { size: 2px }
        svg { display: block }
        body { color: lime }
      </style>
      <svg xmlns="http://www.w3.org/2000/svg"
           width="2" height="2">
        <rect width="2" height="2" fill="currentColor"></rect>
      </svg>''')


@assert_no_logs
def test_current_color_variable(assert_pixels):
    # Regression test for #2010.
    assert_pixels('GG\nGG', '''
      <style>
        @page { size: 2px }
        html { color: lime; font-family: weasyprint; --var: currentColor }
        div { color: var(--var); font-size: 2px; line-height: 1 }
      </style>
      <div>aa''')


@assert_no_logs
def test_current_color_variable_border(assert_pixels):
    # Regression test for #2010.
    assert_pixels('GG\nGG', '''
      <style>
        @page { size: 2px }
        html { color: lime; --var: currentColor }
        div { color: var(--var); width: 0; height: 0; border: 1px solid }
      </style>
      <div>''')


================================================
FILE: tests/draw/test_float.py
================================================
"""Test how floats are drawn."""

import pytest

from ..testing_utils import assert_no_logs


@assert_no_logs
def test_float(assert_pixels):
    assert_pixels('''
        rBBB__aaaa
        BBBB__aaaa
        BBBB__aaaa
        BBBB__aaaa
        __________
    ''', '''
      <style>
        @page { size: 10px 5px }
      </style>
      <div>
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="blue.jpg">
      </div>
    ''')


@assert_no_logs
def test_float_rtl(assert_pixels):
    assert_pixels('''
        rBBB__aaaa
        BBBB__aaaa
        BBBB__aaaa
        BBBB__aaaa
        __________
    ''', '''
      <style>
        @page { size: 10px 5Px }
      </style>
      <div style="direction: rtl">
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="blue.jpg">
      </div>
    ''')


@assert_no_logs
def test_float_inline(assert_pixels):
    assert_pixels('''
        rBBBGG_____aaaa
        BBBBGG_____aaaa
        BBBB_______aaaa
        BBBB_______aaaa
        _______________
    ''', '''
      <style>
        @page { size: 15px 5px }
        body { font-family: weasyprint; font-size: 2px; line-height: 1;
               color: lime }
      </style>
      <div>
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="blue.jpg">
        <span>a</span>
      </div>
    ''')


@assert_no_logs
def test_float_inline_rtl(assert_pixels):
    assert_pixels('''
        rBBB_____GGaaaa
        BBBB_____GGaaaa
        BBBB_______aaaa
        BBBB_______aaaa
        _______________
    ''', '''
      <style>
        @page { size: 15px 5px }
        body { font-family: weasyprint; font-size: 2px; line-height: 1;
               color: lime }
      </style>
      <div style="direction: rtl">
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="blue.jpg">
        <span>a</span>
      </div>
    ''')


@assert_no_logs
def test_float_inline_block(assert_pixels):
    assert_pixels('''
        rBBBGG_____aaaa
        BBBBGG_____aaaa
        BBBB_______aaaa
        BBBB_______aaaa
        _______________
    ''', '''
      <style>
        @page { size: 15px 5px }
        body { font-family: weasyprint; font-size: 2px; line-height: 1;
               color: lime }
      </style>
      <div>
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="blue.jpg">
        <span style="display: inline-block">a</span>
      </div>
    ''')


@assert_no_logs
def test_float_inline_block_rtl(assert_pixels):
    assert_pixels('''
        rBBB_____GGaaaa
        BBBB_____GGaaaa
        BBBB_______aaaa
        BBBB_______aaaa
        _______________
    ''', '''
      <style>
        @page { size: 15Px 5px }
        body { font-family: weasyprint; font-size: 2px; line-height: 1;
               color: lime }
      </style>
      <div style="direction: rtl">
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="blue.jpg">
        <span style="display: inline-block">a</span>
      </div>
    ''')


@assert_no_logs
def test_float_table(assert_pixels):
    assert_pixels('''
        rBBBGG_____aaaa
        BBBBGG_____aaaa
        BBBB_______aaaa
        BBBB_______aaaa
        _______________
    ''', '''
      <style>
        @page { size: 15px 5px }
        body { font-family: weasyprint; font-size: 2px; line-height: 1;
               color: lime }
      </style>
      <div>
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="blue.jpg">
        <table><tbody><tr><td>a</td></tr></tbody></table>
      </div>
    ''')


@assert_no_logs
def test_float_table_rtl(assert_pixels):
    assert_pixels('''
        rBBB_____GGaaaa
        BBBB_____GGaaaa
        BBBB_______aaaa
        BBBB_______aaaa
        _______________
    ''', '''
      <style>
        @page { size: 15px 5px }
        body { font-family: weasyprint; font-size: 2px; line-height: 1;
               color: lime }
      </style>
      <div style="direction: rtl">
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="blue.jpg">
        <table><tbody><tr><td>a</td></tr></tbody></table>
      </div>
    ''')


@assert_no_logs
def test_float_inline_table(assert_pixels):
    assert_pixels('''
        rBBBGG_____aaaa
        BBBBGG_____aaaa
        BBBB_______aaaa
        BBBB_______aaaa
        _______________
    ''', '''
      <style>
        @page { size: 15PX 5px }
        table { display: inline-table }
        body { font-family: weasyprint; font-size: 2px; line-height: 1;
               color: lime }
      </style>
      <div>
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="blue.jpg">
        <table><tbody><tr><td>a</td></tr></tbody></table>
      </div>
    ''')


@assert_no_logs
def test_float_inline_table_rtl(assert_pixels):
    assert_pixels('''
        rBBB_____GGaaaa
        BBBB_____GGaaaa
        BBBB_______aaaa
        BBBB_______aaaa
        _______________
    ''', '''
      <style>
        @page { size: 15px 5px }
        table { display: inline-table }
        body { font-family: weasyprint; font-size: 2px; line-height: 1;
               color: lime }
      </style>
      <div style="direction: rtl">
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="blue.jpg">
        <table><tbody><tr><td>a</td></tr></tbody></table>
      </div>
    ''')


@assert_no_logs
def test_float_replaced_block(assert_pixels):
    assert_pixels('''
        rBBBaaaa___rBBB
        BBBBaaaa___BBBB
        BBBBaaaa___BBBB
        BBBBaaaa___BBBB
        _______________
    ''', '''
      <style>
        @page { size: 15px 5px }
      </style>
      <div>
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="pattern.png">
        <img style="display: block" src="blue.jpg">
      </div>
    ''')


@assert_no_logs
def test_float_replaced_block_rtl(assert_pixels):
    assert_pixels('''
        rBBB___aaaarBBB
        BBBB___aaaaBBBB
        BBBB___aaaaBBBB
        BBBB___aaaaBBBB
        _______________
    ''', '''
      <style>
        @page { size: 15px 5px }
      </style>
      <div style="direction: rtl">
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="pattern.png">
        <img style="display: block" src="blue.jpg">
      </div>
    ''')


@pytest.mark.xfail
@assert_no_logs
def test_float_replaced_inline(assert_pixels):
    assert_pixels('''
        rBBBaaaa___rBBB
        BBBBaaaa___BBBB
        BBBBaaaa___BBBB
        BBBBaaaa___BBBB
        _______________
    ''', '''
      <style>
        @page { size: 15px 5px }
        body { line-height: 1px }
      </style>
      <div>
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="pattern.png">
        <img src="blue.jpg">
      </div>
    ''')


@pytest.mark.xfail
@assert_no_logs
def test_float_replaced_inline_rtl(assert_pixels):
    assert_pixels('''
        rBBB___aaaarBBB
        BBBB___aaaaBBBB
        BBBB___aaaaBBBB
        BBBB___aaaaBBBB
        _______________
    ''', '''
      <style>
        @page { size: 15px 5px }
        body { line-height: 1px }
      </style>
      <div style="direction: rtl">
        <img style="float: left" src="pattern.png">
        <img style="float: right" src="pattern.png">
        <img src="blue.jpg">
      </div>
    ''')


@assert_no_logs
def test_float_margin(assert_pixels):
    assert_pixels('''
        BBBBRRRRRRRRRR__
        BBBBRRRRRRRRRR__
        __RRRRRRRRRR____
        __RRRRRRRRRR____
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                float: left;
                width: 4px;
            }
            div.pushed {
                margin-left: 2px;
            }
        </style>
        <div class="split">aa</div>
        <div class="pushed">bbbbb bbbbb</div>''')


@assert_no_logs
def test_float_split_1(assert_pixels):
    assert_pixels('''
        BBBBRRRRRRRRRRRR
        BBBBRRRRRRRRRRRR
        BBBBRRRR________
        BBBBRRRR________
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                float: left;
                width: 4px;
            }
        </style>
        <div class="split">aa aa</div>
        <div>bbbbbb bb</div>''')


@assert_no_logs
def test_float_split_2(assert_pixels):
    assert_pixels('''
        RRRRRRRRRRRRBBBB
        RRRRRRRRRRRRBBBB
        RRRR________BBBB
        RRRR________BBBB
    ''', '''
        <style>
          @page {
            size: 16px 2px;
          }
          body {
            color: red;
            font-family: weasyprint;
            font-size: 2px;
            line-height: 1;
          }
          div.split {
            color: blue;
            float: right;
            width: 4px;
          }
        </style>
        <div class="split">aa aa</div>
        <div>bbbbbb bb</div>''')


@assert_no_logs
def test_float_split_3(assert_pixels):
    assert_pixels('''
        BBBBRRRRRRRRRRRR
        BBBBRRRRRRRRRRRR
        RRRRRRRRRR______
        RRRRRRRRRR______
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                float: left;
                width: 4px;
            }
        </style>
        <div class="split">aa</div>
        <div>bbbbbb bbbbb</div>''')


@assert_no_logs
def test_float_split_4(assert_pixels):
    assert_pixels('''
        RRRRRRRRRRRRBBBB
        RRRRRRRRRRRRBBBB
        RRRRRRRRRR______
        RRRRRRRRRR______
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                float: right;
                width: 4px;
            }
        </style>
        <div class="split">aa</div>
        <div>bbbbbb bbbbb</div>''')


@assert_no_logs
def test_float_split_5(assert_pixels):
    assert_pixels('''
        BBBBRRRRRRRRgggg
        BBBBRRRRRRRRgggg
        BBBBRRRR____gggg
        BBBBRRRR____gggg
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                float: left;
                width: 4px;
            }
            div.split2 {
                color: green;
                float: right;
                width: 4px;
        </style>
        <div class="split">aa aa</div>
        <div class="split2">cc cc</div>
        <div>bbbb bb</div>''')


@assert_no_logs
def test_float_split_6(assert_pixels):
    assert_pixels('''
        BBBBRRRRRRRRgggg
        BBBBRRRRRRRRgggg
        BBBBRRRR________
        BBBBRRRR________
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                float: left;
                width: 4px;
            }
            div.split2 {
                color: green;
                float: right;
                width: 4px;
        </style>
        <div class="split">aa aa</div>
        <div class="split2">cc</div>
        <div>bbbb bb</div>''')


@assert_no_logs
def test_float_split_7(assert_pixels):
    assert_pixels('''
        BBBBRRRRRRRRgggg
        BBBBRRRRRRRRgggg
        RRRR________gggg
        RRRR________gggg
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                float: left;
                width: 4px;
            }
            div.split2 {
                color: green;
                float: right;
                width: 4px;
        </style>
        <div class="split">aa</div>
        <div class="split2">cc cc</div>
        <div>bbbb bb</div>''')


@assert_no_logs
def test_float_split_8(assert_pixels):
    assert_pixels('''
        BBBB__RRRRRRRRRR
        BBBB__RRRRRRRRRR
        BBBB__RRRR______
        BBBB__RRRR______
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                float: left;
                margin-right: 2px;
                width: 4px;
            }
        </style>
        <div class="split">aa aa</div>
        <div>bbbbb bb</div>''')


@assert_no_logs
def test_float_split_9(assert_pixels):
    assert_pixels('''
        RRRRRRRRRRBBBB__
        RRRRRRRRRRBBBB__
        RRRR______BBBB__
        RRRR______BBBB__
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                float: right;
                margin-right: 2px;
                width: 4px;
            }
        </style>
        <div class="split">aa aa</div>
        <div>bbbbb bb</div>''')


@assert_no_logs
def test_float_split_10(assert_pixels):
    assert_pixels('''
        RRRRRRRRRR______
        RRRRRRRRRR______
        RRRRRRRRRR______
        RRRRRRRRRR______
        ________________
        RRRRRR____BBBB__
        RRRRRR____BBBB__
        RRRRRR____BBBB__
        RRRRRR____BBBB__
        ________________
    ''', '''
        <style>
            @page {
                size: 16px 5px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                float: right;
                margin-right: 2px;
                width: 4px;
            }
        </style>
        <div>bbbbb bbbbb</div>
        <div class="split">aa aa</div>
        <div>bbb bbb</div>''')


@assert_no_logs
def test_float_split_11(assert_pixels):
    assert_pixels('''
        ________________
        _BBBBBBBBBB_____
        _BBBBBBBBBB_____
        _BBBBBBBBBB_____
        _BBBBBBBBBB_____
        ________________
        ________________
        ________________
        _BBBB___________
        _BBBB___________
        _rrrrrrrrrrrrrr_
        _rrrrrrrrrrrrrr_
        ________________
        ________________
    ''', '''
        <style>
            @page {
                margin: 1px;
                size: 16px 7px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div.split {
                color: blue;
                float: right;
            }
        </style>
        <div class="split">aaaaa aaaaa aa</div>
        bbbbbbb''')


@assert_no_logs
def test_float_split_12(assert_pixels):
    assert_pixels('''
        BBBBBBBBBBBBBBBB
        BBBBBBBBBBBBBBBB
        BBBBBBBBBBBBBBBB
        BBBBBBBBBBBBBBBB
        BBBBBBBBBBBBBBBB
        BBBBGG______BBBB
        BBBBGG______BBBB
        BBBB________BBBB
        BBBB________BBBB
        ________________
    ''', '''
        <style>
            @page {
                size: 16px 5px;
            }
            body {
                color: lime;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            article {
                background: blue;
                height: 5px;
            }
            div {
                background: red;
                color: blue;
            }
        </style>
        <article></article>
        <section>
          a
          <div style="float: left"><p>aa<p>aa</div>
          <div style="float: right"><p>bb<p>bb</div>''')


@pytest.mark.xfail
@assert_no_logs
def test_float_split_13(assert_pixels):
    assert_pixels('''
        BBBBBBBBBBBBBBBB
        BBBBBBBBBBBBBBBB
        BBBBBBBBBBBBBBBB
        BBBBBBBBBBBBBBBB
        BBBBBBBBBBBBBBBB
        BBBBGG______BBBB
        BBBBGG______BBBB
        BBBB________BBBB
        BBBB________BBBB
        ________________
    ''', '''
        <style>
            @page {
                size: 16px 5px;
            }
            body {
                color: lime;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            article {
                background: blue;
                height: 5px;
            }
            div {
                background: red;
                color: blue;
            }
        </style>
        <article></article>
        <section>
          <div style="float: left"><p>a<p>aa</div>
          a
          <div style="float: right"><p>bb<p>bb</div>''')


@assert_no_logs
def test_float_split_14(assert_pixels):
    assert_pixels('''
        BBBBBBBBBBBBBBBB
        BBBBBBBBBBBBBBBB
        BBBBBBBBBBBBBBBB
        BBBBBBBBBBBBBBBB
        BBBBBBBBBBBBBBBB
        BBBBGG______BBBB
        BBBBGG______BBBB
        BBBB________BBBB
        BBBB________BBBB
        ________________
    ''', '''
        <style>
            @page {
                size: 16px 5px;
            }
            body {
                color: lime;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            article {
                background: blue;
                height: 5px;
            }
            div {
                background: red;
                color: blue;
            }
        </style>
        <article></article>
        a
        <div style="float: left"><p>aa<p>aa</div>
        <div style="float: right"><p>bb<p>bb</div>''')


@pytest.mark.xfail
@assert_no_logs
def test_float_split_15(assert_pixels):
    assert_pixels('''
        BB__RRRRRRRRRR__
        BB__RRRRRRRRRR__
        BB__RRRRRRRRRR__
        BB__RRRRRRRRRR__
        GGBBRRRRRRRRRR__
        GGBBRRRRRRRRRR__
        GGBBRRRRRRRRRR__
        GGBBRRRRRRRRRR__
        RRRRRRRRRR______
        RRRRRRRRRR______
    ''', '''
        <style>
            @page {
                size: 16px 2px;
            }
            body {
                color: red;
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
        </style>
        <div style="float: left; position: relative; color: blue; width: 4px">
          a a a
          <div style="float: left; color: lime; width: 2px">
            a a
          </div>
          a a
        </div>
        <div>bbbbb bbbbb bbbbb bbbbb bbbbb</div>''')


@assert_no_logs
def test_float_split_clear(assert_pixels):
    assert_pixels('''
        BBBB
        BBBB
        BBBB
        BBBB
        BBBB
        BBBB
        BBBB
        BBBB
        BBBB
        BBBB
        rrrr
        rrrr
    ''', '''
        <style>
            @page {
                size: 4px;
            }
            body {
                color: red;
                font: 2px / 1 weasyprint;
            }
            div {
                color: blue;
                float: left;
            }
            article {
                clear: left;
            }
        </style>
        <div>bb bb bb bb bb</div>
        <article>aa</article>''')


@assert_no_logs
def test_float_split_clear_empty(assert_pixels):
    assert_pixels('''
        BBBB
        BBBB
        BBBB
        BBBB
        BBBB
        BBBB
        BBBB
        BBBB
        BBBB
        BBBB
        ____
        ____
    ''', '''
        <style>
            @page {
                size: 4px;
            }
            body {
                color: red;
                font: 2px / 1 weasyprint;
            }
            div {
                color: blue;
                float: left;
            }
            article {
                clear: left;
            }
        </style>
        <div>bb bb bb bb bb</div>
        <article></article>''')


@assert_no_logs
def test_float_split_large_parent(assert_pixels):
    assert_pixels('''
        BBBB
        BBBB
        BBBB
        BBBB
        GGGG

        BBBB
        BBBB
        BBBB
        BBBB
        GGGG

        BBBB
        BBBB
        GGGG
        GGGG
        GGGG

        rrrr
        rrrr
        GGGG
        GGGG
        GGGG
    ''', '''
        <style>
            @page {
                size: 4px 5px;
            }
            body {
                color: red;
                font: 2px / 1 weasyprint;
            }
            section {
                background: lime;
                height: 100px;
            }
            div {
                color: blue;
                float: left;
            }
            article {
                clear: left;
            }
        </style>
        <section>
        <div>bb bb bb bb bb</div>
        <article>aa</article>''')


@assert_no_logs
def test_float_split_in_stacking_context(assert_pixels):
    assert_pixels('''
        RRRR
        RRRR
        BBBB
        BBBB
        ____

        BBBB
        BBBB
        RRRR
        RRRR
        ____

        RRRR
        RRRR
        ____
        ____
        ____
    ''', '''
        <style>
            @page {
                size: 4px 5px;
            }
            body {
                color: red;
                font: 2px / 1 weasyprint;
            }
            section {
                display: flow-root;
            }
            div {
                color: blue;
                float: left;
            }
            article {
                clear: left;
            }
        </style>
        <section>
        aa
        <div>bb bb</div>
        cc cc''')


================================================
FILE: tests/draw/test_footnote.py
================================================
"""Test how footnotes are drawn."""

from ..testing_utils import assert_no_logs


@assert_no_logs
def test_inline_footnote(assert_pixels):
    assert_pixels('''
        RRRRRRRR_
        RRRRRRRR_
        _________
        _________
        _________
        RRRRRRRR_
        RRRRRRRR_
    ''', '''
    <style>
        @page {
            size: 9px 7px;
        }
        div {
            color: red;
            font-family: weasyprint;
            font-size: 2px;
            line-height: 1;
        }
        span {
            float: footnote;
        }
    </style>
    <div>abc<span>de</span></div>''')


@assert_no_logs
def test_block_footnote(assert_pixels):
    assert_pixels('''
        RRRRRRRR_
        RRRRRRRR_
        _________
        _________
        _________
        RRRRRRRR_
        RRRRRRRR_
    ''', '''
    <style>
        @page {
            size: 9Px 7px;
        }
        div {
            color: red;
            font-family: weasyprint;
            font-size: 2px;
            line-height: 1;
        }
        div.footnote {
            float: footnote;
        }
    </style>
    <div>abc<div class="footnote">de</div></div>''')


@assert_no_logs
def test_long_footnote(assert_pixels):
    assert_pixels('''
        RRRRRRRR_
        RRRRRRRR_
        _________
        RRRRRRRR_
        RRRRRRRR_
        RR_______
        RR_______
    ''', '''
    <style>
        @page {
            size: 9px 7px;
        }
        div {
            color: red;
            font-family: weasyprint;
            font-size: 2PX;
            line-height: 1;
        }
        span {
            float: footnote;
        }
    </style>
    <div>abc<span>de f</span></div>''')


@assert_no_logs
def test_footnote_margin(assert_pixels):
    assert_pixels('''
        RRRRRRRR_
        RRRRRRRR_
        _________
        _________
        _RRRRRR__
        _RRRRRR__
        _________
    ''', '''
    <style>
        @page {
            size: 9px 7px;

            @footnote {
                margin: 1px;
            }
        }
        div {
            color: red;
            font-family: weasyprint;
            font-size: 2px;
            line-height: 1;
        }
        span {
            float: footnote;
        }
    </style>
    <div>abc<span>d</span></div>''')


@assert_no_logs
def test_footnote_multiple_margin(assert_pixels):
    assert_pixels('''
        RRRR___
        RRRR___
        RRRR___
        RRRR___
        RRRR___
        RRRR___
        RRRRRR_
        RRRRRR_
        _______
        _______

        RRRR___
        RRRR___
        _______
        _______
        _______
        _______
        RRRRRR_
        RRRRRR_
        RRRRRR_
        RRRRRR_
    ''', '''
    <style>
        @page {
            size: 7px 10Px;

            @footnote {
                margin-top: 1px;
            }
        }
        div {
            color: red;
            font-family: weasyprint;
            font-size: 2px;
            line-height: 1;
        }
        span {
            float: footnote;
        }
    </style>
    <div>ab</div>
    <div>ab</div>
    <div>ab</div>
    <div>a<span>d</span><span>e</span></div>
    <div>ab</div>''')


@assert_no_logs
def test_footnote_with_absolute(assert_pixels):
    assert_pixels('''
        _RRRR____
        _RRRR____
        _________
        _RRRR____
        _RRRR____
        BB_______
        BB_______
    ''', '''
    <style>
        @page {
            size: 9px 7px;
            margin: 0 1px 2px;
        }
        div {
            color: red;
            font-family: weasyprint;
            font-size: 2px;
            line-height: 1;
        }
        span {
            float: footnote;
        }
        mark {
            display: block;
            position: absolute;
            left: -1px;
            color: blue;
        }
    </style>
    <div>a<span><mark>d</mark></span></div>''')


@assert_no_logs
def test_footnote_max_height_1(assert_pixels):
    assert_pixels('''
        RRRRKKKK_
        RRRRKKKK_
        RRRR_____
        RRRR_____
        _GGGGBB__
        _GGGGBB__
        _________
        _________
        _________
        _________
        _GGGGBB__
        _GGGGBB__
    ''', '''
    <style>
        @page {
            size: 9px 6px;

            @footnote {
                margin-left: 1px;
                max-height: 3px;
            }
        }
        div {
            color: red;
            font-family: weasyprint;
            font-size: 2px;
            line-height: 1;
        }
        div.footnote {
            float: footnote;
            color: blue;
            &::footnote-call { color: black }
            &::footnote-marker { color: lime }
        }
    </style>
    <div>ab<div class="footnote">c</div><div class="footnote">d</div></div>
    <div>ef</div>''')


@assert_no_logs
def test_footnote_max_height_2(assert_pixels):
    assert_pixels('''
        RRRRRRRR_
        RRRRRRRR_
        _________
        _________
        _BBBBBB__
        _BBBBBB__
        _________
        _________
        _________
        _________
        _BBBBBB__
        _BBBBBB__
    ''', '''
    <style>
        @page {
            size: 9px 6px;

            @footnote {
                margin-left: 1px;
                max-height: 3px;
            }
        }
        div {
            color: red;
            font-family: weasyprint;
            font-size: 2px;
            line-height: 1;
        }
        div.footnote {
            float: footnote;
            color: blue;
            &::footnote-call { color: red }
        }
    </style>
    <div>ab<div class="footnote">c</div><div class="footnote">d</div></div>''')


@assert_no_logs
def test_footnote_max_height_3(assert_pixels):
    # This case is crazy and the rendering is not really defined, but this test
    # is useful to check that there’s no endless loop.
    assert_pixels('''
        RRRRRRRR_
        RRRRRRRR_
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _BBBBBB__
        _________
        _________
        _________
        _________
        _________
        _BBBBBB__
    ''', '''
    <style>
        @page {
            size: 9px 6px;

            @footnote {
                margin-left: 1px;
                max-height: 1px;
            }
        }
        div {
            color: red;
            font-family: weasyprint;
            font-size: 2px;
            line-height: 1;
        }
        div.footnote {
            float: footnote;
            color: blue;
            &::footnote-call { color: red }
        }
    </style>
    <div>ab<div class="footnote">c</div><div class="footnote">d</div></div>''')


@assert_no_logs
def test_footnote_max_height_4(assert_pixels):
    assert_pixels('''
        RRRRRRRR_
        RRRRRRRR_
        RRRR_____
        RRRR_____
        _BBBBBB__
        _BBBBBB__
        RRRR_____
        RRRR_____
        _________
        _________
        _BBBBBB__
        _BBBBBB__
    ''', '''
    <style>
        @page {
            size: 9px 6px;

            @footnote {
                margin-left: 1px;
                max-height: 3px;
            }
        }
        div {
            color: red;
            font-family: weasyprint;
            font-size: 2px;
            line-height: 1;
        }
        div.footnote {
            float: footnote;
            color: blue;
            &::footnote-call { color: red }
        }
    </style>
    <div>ab<div class="footnote">c</div><div class="footnote">d</div></div>
    <div>ef</div>
    <div>gh</div>''')


@assert_no_logs
def test_footnote_max_height_5(assert_pixels):
    assert_pixels('''
        RRRRRRRR__RR
        RRRRRRRR__RR
        _BBBBBB_____
        _BBBBBB_____
        _BBBBBB_____
        _BBBBBB_____
        RRRR________
        RRRR________
        ____________
        ____________
        _BBBBBB_____
        _BBBBBB_____
    ''', '''
    <style>
        @page {
            size: 12px 6px;

            @footnote {
                margin-left: 1px;
                max-height: 4px;
            }
        }
        div {
            color: red;
            font-family: weasyprint;
            font-size: 2px;
            line-height: 1;
        }
        div.footnote {
            float: footnote;
            color: blue;
            &::footnote-call { color: red }
        }
    </style>
    <div>ab<div class="footnote">c</div><div class="footnote">d</div>
    <div class="footnote">e</div></div>
    <div>fg</div>''')


================================================
FILE: tests/draw/test_footnote_column.py
================================================
"""Test how footnotes in columns are drawn."""

import pytest

from ..testing_utils import assert_no_logs


@assert_no_logs
def test_footnote_column_margin_top(assert_pixels):
    assert_pixels('''
        RRRR_RRRR
        RRRR_RRRR
        _________
        _________
        _________
        RRRRRRRR_
        RRRRRRRR_
        RRRR_RRRR
        RRRR_RRRR
        RRRR_RRRR
        RRRR_RRRR
        RRRR_____
        RRRR_____
        _________
    ''', '''
    <style>
      @page {
        size: 9px 7px;
        @footnote {
          margin-top: 2Px;
        }
      }
      div {
        color: red;
        columns: 2;
        column-gap: 1px;
        font-family: weasyprint;
        font-size: 2px;
        line-height: 1;
      }
      span {
        float: footnote;
      }
    </style>
    <div>a<span>de</span> ab ab ab ab ab ab</div>''')


@assert_no_logs
def test_footnote_column_fill_auto(assert_pixels):
    assert_pixels('''
        RRRR_____
        RRRR_____
        RRRR_____
        RRRR_____
        RRRR_____
        RRRR_____
        _________
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
    ''', '''
    <style>
      @page {
        size: 9px 13px;
      }
      div {
        color: red;
        columns: 2;
        column-fill: auto;
        column-gap: 1px;
        font-family: weasyprint;
        font-size: 2px;
        line-height: 1;
      }
      span {
        float: footnote;
      }
    </style>
    <div>a<span>de</span> a<span>de</span> a<span>de</span></div>''')


@assert_no_logs
def test_footnote_column_fill_auto_break_inside_avoid(assert_pixels):
    assert_pixels('''
        RRRR_RRRR
        RRRR_RRRR
        RRRR_RRRR
        RRRR_RRRR
        RRRR_RRRR
        RRRR_RRRR
        _________
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
    ''', '''
    <style>
      @page {
        size: 9px 13px;
      }
      div {
        color: red;
        columns: 2;
        column-fill: auto;
        column-gap: 1px;
        font-family: weasyprint;
        font-size: 2pX;
        line-height: 1;
      }
      article {
        break-inside: avoid;
      }
      span {
        float: footnote;
      }
    </style>
    <div>
      <article>a<span>de</span> a<span>de</span></article>
      <article>ab</article>
      <article>a<span>de</span> ab</article>
      <article>ab</article>
    </div>''')


@assert_no_logs
def test_footnote_column_p_after(assert_pixels):
    assert_pixels('''
        RRRR_RRRR
        RRRR_RRRR
        RRRR_RRRR
        RRRR_RRRR
        KK__KK___
        KK__KK___
        _________
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        KK__KK___
        KK__KK___
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
    ''', '''
    <style>
      @page {
        size: 9px 11px;
      }
      body {
        font-family: weasyprint;
        font-size: 2px;
        line-height: 1;
      }
      div {
        color: red;
        columns: 2;
        column-gap: 1px;
      }
      span {
        float: footnote;
      }
    </style>
    <div>a<span>de</span> a<span>de</span> ab ab</div>
    <p>a a a a</p>''')


@assert_no_logs
def test_footnote_column_p_before(assert_pixels):
    assert_pixels('''
        KKKK_____
        KKKK_____
        RRRR_RRRR
        RRRR_RRRR
        RRRR_RR__
        RRRR_RR__
        _________
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRR_RR__
        RRRR_RR__
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
        _________
    ''', '''
    <style>
      @page {
        size: 9px 13px;
      }
      body {
        font-family: weasyprint;
        font-size: 2px;
        line-height: 1;
      }
      div {
        color: red;
        columns: 2;
        column-gap: 1px;
      }
      span {
        float: footnote;
      }
    </style>
    <p>ab</p>
    <div>
    a<span>de</span> a<span>de</span>
    a<span>de</span> a ab a </div>''')


@assert_no_logs
def test_footnote_column_3(assert_pixels):
    assert_pixels('''
        RRRR_RRRR_RRRR
        RRRR_RRRR_RRRR
        ______________
        RRRRRRRR______
        RRRRRRRR______
        RRRR_RRRR_____
        RRRR_RRRR_____
        ______________
        ______________
        ______________
    ''', '''
    <style>
      @page {
        size: 14px 5px;
      }
      body {
        font-family: weasyprint;
        font-size: 2px;
        line-height: 1;
      }
      div {
        color: red;
        columns: 3;
        column-gap: 1Px;
      }
      span {
        float: footnote;
      }
    </style>
    <div>ab ab a<span>de</span> ab ab </div>''')


@assert_no_logs
def test_footnote_column_3_p_before(assert_pixels):
    assert_pixels('''
        KKKK__________
        KKKK__________
        RRRR_RRRR_RRRR
        RRRR_RRRR_RRRR
        RRRR_RRRR_RRRR
        RRRR_RRRR_RRRR
        ______________
        RRRRRRRR______
        RRRRRRRR______
        RRRR_RRRR_____
        RRRR_RRRR_____
        ______________
        ______________
        ______________
        ______________
        ______________
        RRRRRRRR______
        RRRRRRRR______
    ''', '''
    <style>
      @page {
        size: 14px 9px;
      }
      body {
        font-family: weasyprint;
        font-size: 2px;
        line-height: 1;
      }
      div {
        color: red;
        columns: 3;
        column-gap: 1px;
      }
      span {
        float: footnote;
      }
    </style>
    <p>ab</p>
    <div>ab ab a<span>de</span> ab ab ab a<span>de</span> ab </div>''')


@assert_no_logs
def test_footnote_column_clone_decoration(assert_pixels):
    assert_pixels('''
        _________
        RRRR_RRRR
        RRRR_RRRR
        _________
        _________
        RRRRRRRR_
        RRRRRRRR_
        _________
        RRRR_RRRR
        RRRR_RRRR
        _________
        _________
        _________
        _________
    ''', '''
    <style>
      @page {
        size: 9px 7px;
      }
      div {
        box-decoration-break: clone;
        color: red;
        columns: 2;
        column-gap: 1px;
        font-family: weasyprint;
        font-size: 2px;
        line-height: 1;
        padding: 1px 0;
      }
      span {
        float: footnote;
      }
    </style>
    <div>a<span>de</span> ab ab ab</div>''')


@assert_no_logs
def test_footnote_column_max_height(assert_pixels):
    assert_pixels('''
        RRRR_RRRR
        RRRR_RRRR
        RRRR_RRRR
        RRRR_RRRR
        _________
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRR_RRRR
        RRRR_RRRR
        _________
        _________
        _________
        _________
        _________
        RRRRRRRR_
        RRRRRRRR_
    ''', '''
    <style>
      @page {
        size: 9px 9px;
        @footnote {
          max-height: 2em;
        }
      }
      div {
        color: red;
        columns: 2;
        column-gap: 1px;
        font-family: weasyprint;
        font-size: 2px;
        line-height: 1;
      }
      span {
        float: footnote;
      }
    </style>
    <div>
      a<span>de</span> a<span>de</span>
      a<span>de</span> ab
      ab ab
    </div>''')


@pytest.mark.xfail
@assert_no_logs
def test_footnote_column_reported_split(assert_pixels):
    # When calling block_container_layout() in remove_placeholders(), we should
    # use the whole skip stack and not just [skip:]
    assert_pixels('''
        RRRR_RRRR
        RRRR_RRRR
        RRRR_RRRR
        RRRR_RRRR
        _________
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRRRRRR_
        RRRR_____
        RRRR_____
        _________
        _________
        _________
        _________
        _________
        RRRRRRRR_
        RRRRRRRR_
    ''', '''
    <style>
      @page {
        size: 9px 9px;
      }
      div {
        color: red;
        columns: 2;
        column-gap: 1px;
        font-family: weasyprint;
        font-size: 2px;
        line-height: 1;
      }
      span {
        float: footnote;
      }
    </style>
    <div>
      <article>a<span>de</span> a<span>de</span></article>
      <article>a<span>de</span> ab ab</article>
    </div>''')


================================================
FILE: tests/draw/test_gradient.py
================================================
"""Test how gradients are drawn."""

from ..testing_utils import assert_no_logs


@assert_no_logs
def test_linear_gradients_1(assert_pixels):
    assert_pixels('''
        _____
        _____
        _____
        BBBBB
        BBBBB
        RRRRR
        RRRRR
        RRRRR
        RRRRR
    ''', '''<style>@page { size: 5px 9px; background: linear-gradient(
      white, white 3px, blue 0, blue 5px, red 0, red
    )''')


@assert_no_logs
def test_linear_gradients_2(assert_pixels):
    assert_pixels('''
        _____
        _____
        _____
        BBBBB
        BBBBB
        RRRRR
        RRRRR
        RRRRR
        RRRRR
    ''', '''<style>@page { size: 5px 9px; background: linear-gradient(
      white 3px, blue 0, blue 5px, red 0
    )''')


@assert_no_logs
def test_linear_gradients_3(assert_pixels):
    assert_pixels('''
        ___BBrrrr
        ___BBrrrr
        ___BBrrrr
        ___BBrrrr
        ___BBrrrr
    ''', '''<style>@page { size: 9px 5px; background: linear-gradient(
      to right, white 3px, blue 0, blue 5px, red 0
    )''')


@assert_no_logs
def test_linear_gradients_4(assert_pixels):
    assert_pixels('''
        BBBBBBrrrr
        BBBBBBrrrr
        BBBBBBrrrr
        BBBBBBrrrr
        BBBBBBrrrr
    ''', '''<style>@page { size: 10px 5px; background: linear-gradient(
      to right, blue 5px, blue 6px, red 6px, red 9px
    )''')


@assert_no_logs
def test_linear_gradients_5(assert_pixels):
    assert_pixels('''
        rBrrzBrrrB
        rBrrrBrrrB
        rBrrrBrrrB
        rBrrrBrrrB
        rBrrzBrrrB
    ''', '''
      <style>@page { size: 10px 5px; background: repeating-linear-gradient(
      to right, blue 50%, blue 60%, red 60%, red 90%
    )''')


@assert_no_logs
def test_linear_gradients_6(assert_pixels):
    assert_pixels('''
        BBBrrrrrr
        BBBrrrrrr
        BBBrrrrrr
        BBBrrrrrr
        BBBrrrrrr
    ''', '''<style>@page { size: 9px 5px; background: linear-gradient(
      to right, blue 3px, blue 3px, red 3px, red 3px
    )''')


@assert_no_logs
def test_linear_gradients_7(assert_pixels):
    assert_pixels('''
        hhhhhhhhh
        hhhhhhhhh
        hhhhhhhhh
        hhhhhhhhh
        hhhhhhhhh
    ''', '''<style>@page { size: 9px 5px; background:
    repeating-linear-gradient(
      to right, black 3px, black 3px, #800080 3px, #800080 3px
    )''')


@assert_no_logs
def test_linear_gradients_8(assert_pixels):
    assert_pixels('''
        BBBBBBBBB
        BBBBBBBBB
        BBBBBBBBB
        BBBBBBBBB
        BBBBBBBBB
    ''', '''<style>@page { size: 9px 5px; background:
      repeating-linear-gradient(to right, blue 3px)''')


@assert_no_logs
def test_linear_gradients_9(assert_pixels):
    assert_pixels('''
        BBBBBBBBB
        BBBBBBBBB
        BBBBBBBBB
        BBBBBBBBB
        BBBBBBBBB
    ''', '''<style>@page { size: 9px 5px; background:
      repeating-linear-gradient(45deg, blue 3px)''')


@assert_no_logs
def test_linear_gradients_10(assert_pixels):
    assert_pixels('''
        BBBBBBBBB
        BBBBBBBBB
        BBBBBBBBB
        BBBBBBBBB
        BBBBBBBBB
    ''', '''<style>@page { size: 9px 5px; background: linear-gradient(
      45deg, blue 3px, red 3px, red 3px, blue 3px
    )''')


@assert_no_logs
def test_linear_gradients_11(assert_pixels):
    assert_pixels('''
        BBBrBBBBB
        BBBrBBBBB
        BBBrBBBBB
        BBBrBBBBB
        BBBrBBBBB
    ''', '''<style>@page { size: 9px 5px; background: linear-gradient(
      to right, blue 3px, red 3px, red 4px, blue 4px
    )''')


@assert_no_logs
def test_linear_gradients_12(assert_pixels):
    assert_pixels('''
        BBBBBBBBB
        BBBBBBBBB
        BBBBBBBBB
        BBBBBBBBB
        BBBBBBBBB
    ''', '''<style>@page { size: 9px 5px; background:
      repeating-linear-gradient(to right, red 3px, blue 3px, blue 4px, red 4px
    )''')


@assert_no_logs
def test_linear_gradients_13(assert_pixels):
    assert_pixels('''
        _____
        _____
        _____
        SSSSS
        SSSSS
        RRRRR
        RRRRR
        RRRRR
        RRRRR
    ''', '''<style>@page { size: 5px 9px; background: linear-gradient(
      white, white 3px, rgba(255, 0, 0, 0.751) 0, rgba(255, 0, 0, 0.751) 5px,
      red 0, red
    )''')


@assert_no_logs
def test_linear_gradients_currentcolor(assert_pixels):
    # Regression test for #1561.
    assert_pixels('''
        KKKKK
        KKKKK
        KKKKK
        KKKKK
        KKKKK
    ''', '<style>@page { size: 5px 5px; background: linear-gradient(currentcolor)')


@assert_no_logs
def test_linear_gradients_hints(assert_pixels):
    assert_pixels('''
        _____
        _____
        _____
        _____
        _____
        _____
        _____
        _____
        zzzzz
    ''', '''<style>@page { size: 5px 9px; background: linear-gradient(
      white, 8.9px, red
    )''')


@assert_no_logs
def test_linear_gradients_hints_percentage(assert_pixels):
    assert_pixels('''
        _____
        _____
        _____
        _____
        _____
        _____
        _____
        _____
        zzzzz
    ''', '''<style>@page { size: 5px 9px; background: linear-gradient(
      white, 99%, red
    )''')


@assert_no_logs
def test_radial_gradients_1(assert_pixels):
    assert_pixels('''
        BBBBBB
        BBBBBB
        BBBBBB
        BBBBBB
        BBBBBB
        BBBBBB
    ''', '''<style>@page { size: 6px; background:
      radial-gradient(red -30%, blue -10%)''')


@assert_no_logs
def test_radial_gradients_2(assert_pixels):
    assert_pixels('''
        RRRRRR
        RRRRRR
        RRRRRR
        RRRRRR
        RRRRRR
        RRRRRR
    ''', '''<style>@page { size: 6px; background:
      radial-gradient(red 110%, blue 130%)''')


@assert_no_logs
def test_radial_gradients_3(assert_pixels):
    assert_pixels('''
        BzzzzzzzzB
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzRRzzzz
        zzzzRRzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        BzzzzzzzzB
    ''', '''<style>@page { size: 10px 16px; background:
      radial-gradient(red 20%, blue 80%)''')


@assert_no_logs
def test_radial_gradients_4(assert_pixels):
    assert_pixels('''
        BzzzzzzzzB
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzRRzzzz
        zzzzRRzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        BzzzzzzzzB
    ''', '''<style>@page { size: 10px 16px; background:
      radial-gradient(red 50%, blue 50%)''')


@assert_no_logs
def test_radial_gradients_5(assert_pixels):
    assert_pixels('''
        SzzzzzzzzS
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzRRzzzz
        zzzzRRzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        SzzzzzzzzS
    ''', '''<style>@page { size: 10px 16px; background:
      radial-gradient(red 50%, rgba(255, 0, 0, 0.751) 50%)''')


@assert_no_logs
def test_radial_gradients_negative(assert_pixels):
    assert_pixels('''
        BzzzzzzzzB
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzBBzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        BzzzRRzzzB
        BzzzRRzzzB
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzBBzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        BzzzzzzzzB
    ''', '''<style>@page { size: 10px 16px; background:
      radial-gradient(circle, red -1px, red 3px, blue 3px, blue 6px)''')


@assert_no_logs
def test_radial_gradients_repeating(assert_pixels):
    assert_pixels('''
        RzzzzzzzzR
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzBBzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zBzzRRzzBz
        zBzzRRzzBz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzBBzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        RzzzzzzzzR
    ''', '''<style>@page { size: 10px 16px; background:
      repeating-radial-gradient(circle, red 0, red 3px, blue 3px, blue 6px)''')


@assert_no_logs
def test_radial_gradients_repeating_outer(assert_pixels):
    assert_pixels('''
        RzzzzzzzzR
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzBBzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zBzzRRzzBz
        zBzzRRzzBz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzBBzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        RzzzzzzzzR
    ''', '''<style>@page { size: 10px 16px; background:
      repeating-radial-gradient(circle, red 6px, red 9px, blue 9px, blue 12px)''')


@assert_no_logs
def test_radial_gradients_repeating_outer_partial(assert_pixels):
    assert_pixels('''
        RzzzzzzzzR
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzBBzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zBzzRRzzBz
        zBzzRRzzBz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzBBzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        RzzzzzzzzR
    ''', '''<style>@page { size: 10px 16px; background:
      repeating-radial-gradient(circle, blue 3px, blue 6px, red 6px, red 9px)''')


@assert_no_logs
def test_radial_gradients_repeating_negative(assert_pixels):
    assert_pixels('''
        RzzzzzzzzR
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzBBzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zBzzRRzzBz
        zBzzRRzzBz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzBBzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        zzzzzzzzzz
        RzzzzzzzzR
    ''', '''<style>@page { size: 10px 16px; background:
      repeating-radial-gradient(circle, blue -3px, blue 0, red 0, red 3px)''')


@assert_no_logs
def test_radial_gradients_hints(assert_pixels):
    assert_pixels('''
        zzzzzz
        zzBBzz
        zBBBBz
        zBBBBz
        zzBBzz
        zzzzzz
    ''', '''<style>@page { size: 6px; background:
      radial-gradient(blue, 4px, white)''')


@assert_no_logs
def test_radial_gradients_hints_percentage(assert_pixels):
    assert_pixels('''
        zzzzzz
        zzBBzz
        zBBBBz
        zBBBBz
        zzBBzz
        zzzzzz
    ''', '''<style>@page { size: 6px; background:
      radial-gradient(blue, 99%, white)''')


================================================
FILE: tests/draw/test_image.py
================================================
"""Test how images are drawn."""

import pytest

from ..testing_utils import FakeHTML, assert_no_logs, capture_logs, resource_path

centered_image = '''
    ________
    ________
    __rBBB__
    __BBBB__
    __BBBB__
    __BBBB__
    ________
    ________
'''

centered_image_overflow = '''
    ________
    ________
    __rBBBBB
    __BBBBBB
    __BBBBBB
    __BBBBBB
    __BBBBBB
    __BBBBBB
'''

resized_image = '''
    ____________
    ____________
    __rrBBBBBB__
    __rrBBBBBB__
    __BBBBBBBB__
    __BBBBBBBB__
    __BBBBBBBB__
    __BBBBBBBB__
    __BBBBBBBB__
    __BBBBBBBB__
    ____________
    ____________
'''

small_resized_image = '''
    ____________
    ____________
    __rBBB______
    __BBBB______
    __BBBB______
    __BBBB______
    ____________
    ____________
    ____________
    ____________
    ____________
    ____________
'''

blue_image = '''
    ________
    ________
    __aaaa__
    __aaaa__
    __aaaa__
    __aaaa__
    ________
    ________
'''

no_image = '''
    ________
    ________
    ________
    ________
    ________
    ________
    ________
    ________
'''

page_break = '''
    ________
    ________
    __rBBB__
    __BBBB__
    __BBBB__
    __BBBB__
    ________
    ________

    ________
    ________
    ________
    ________
    ________
    ________
    ________
    ________

    ________
    ________
    __rBBB__
    __BBBB__
    __BBBB__
    __BBBB__
    ________
    ________
'''

table = '''
    ________
    ________
    __rBBB__
    __BBBB__
    __BBBB__
    __BBBB__
    ________
    ________

    __rBBB__
    __BBBB__
    __BBBB__
    __BBBB__
    ________
    ________
    ________
    ________
'''

cover_image = '''
    ________
    ________
    __BB____
    __BB____
    __BB____
    __BB____
    ________
    ________
'''

border_image = '''
    ________
    _GGGGGG_
    _GrBBBG_
    _GBBBBG_
    _GBBBBG_
    _GBBBBG_
    _GGGGGG_
    ________
'''


@assert_no_logs
@pytest.mark.parametrize(('filename', 'image'), [
    ('pattern.svg', centered_image),
    ('pattern.png', centered_image),
    ('pattern.palette.png', centered_image),
    ('pattern.gif', centered_image),
    ('blue.jpg', blue_image)
])
def test_images(assert_pixels, filename, image):
    assert_pixels(image, '''
      <style>
        @page { size: 8px }
        body { margin: 2px 0 0 2px; font-size: 0 }
        img { overflow: hidden }
      </style>
      <div><img src="%s"></div>''' % filename)


@assert_no_logs
@pytest.mark.parametrize('filename', [
    'pattern.svg',
    'pattern.png',
    'pattern.palette.png',
    'pattern.gif',
])
def test_resized_images(assert_pixels, filename):
    assert_pixels(resized_image, '''
      <style>
        @page { size: 12px }
        body { margin: 2px 0 0 2px; font-size: 0 }
        img { display: block; width: 8px; image-rendering: pixelated;
              overflow: hidden }
      </style>
      <div><img src="%s"></div>''' % filename)


def test_image_overflow(assert_pixels):
    assert_pixels(centered_image_overflow, '''
      <style>
        @page { size: 8px }
        body { margin: 2px 0 0 2px; font-size: 0 }
      </style>
      <div><img src="pattern.svg"></div>''')


@assert_no_logs
@pytest.mark.parametrize(('viewbox', 'width', 'height'), [
    (None, None, None),
    (None, 4, None),
    (None, None, 4),
    (None, 4, 4),
    ('0 0 4 4', 4, None),
    ('0 0 4 4', None, 4),
    ('0 0 4 4', 4, 4),
])
def test_svg_sizing(assert_pixels, viewbox, width, height):
    assert_pixels(centered_image, '''
      <style>
        @page { size: 8px }
        body { margin: 2px 0 0 2px; font-size: 0 }
        svg { display: block }
      </style>
      <svg %s %s %s>
        <rect width="4px" height="4px" fill="#00f" />
        <rect width="1px" height="1px" fill="#f00" />
      </svg>''' % (
          f'width="{width}"' if width else '',
          f'height="{height}px"' if height else '',
          f'viewbox="{viewbox}"' if viewbox else ''))


@assert_no_logs
@pytest.mark.parametrize(('viewbox', 'width', 'height', 'image'), [
    (None, None, None, small_resized_image),
    (None, 8, None, small_resized_image),
    (None, None, 8, small_resized_image),
    (None, 8, 8, small_resized_image),
    ('0 0 4 4', None, None, resized_image),
    ('0 0 4 4', 8, None, resized_image),
    ('0 0 4 4', None, 8, resized_image),
    ('0 0 4 4', 8, 8, resized_image),
    ('0 0 4 4', 800, 800, resized_image),
])
def test_svg_resizing(assert_pixels, viewbox, width, height, image):
    assert_pixels(image, '''
      <style>
        @page { size: 12px }
        body { margin: 2px 0 0 2px; font-size: 0 }
        svg { display: block; width: 8px }
      </style>
      <svg %s %s %s>
        <rect width="4" height="4" fill="#00f" />
        <rect width="1" height="1" fill="#f00" />
      </svg>''' % (
          f'width="{width}"' if width else '',
          f'height="{height}px"' if height else '',
          f'viewbox="{viewbox}"' if viewbox else ''))


@assert_no_logs
def test_images_block(assert_pixels):
    assert_pixels(centered_image, '''
      <style>
        @page { size: 8px }
        body { margin: 0; font-size: 0 }
        img { display: block; margin: 2px auto 0 }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_images_not_found(assert_pixels):
    with capture_logs() as logs:
        assert_pixels(no_image, '''
          <style>
            @page { size: 8px }
            body { margin: 0; font-size: 0 }
            img { display: block; margin: 2px auto 0 }
          </style>
          <div><img src="inexistent1.png" alt=""></div>''')
    assert len(logs) == 1
    assert 'ERROR: Failed to load image' in logs[0]
    assert 'inexistent1.png' in logs[0]


@assert_no_logs
def test_images_no_src(assert_pixels):
    assert_pixels(no_image, '''
      <style>
        @page { size: 8px }
        body { margin: 0; font-size: 0 }
        img { display: block; margin: 2px auto 0 }
      </style>
      <div><img alt=""></div>''')


@assert_no_logs
def test_images_alt(assert_same_renderings):
    with capture_logs() as logs:
        documents = (
            '''
              <style>
                @page { size: 200px 30px }
                body { margin: 0; font-size: 0 }
              </style>
              <div>%s</div>''' % html
            for html in (
                'Hello',
                '<img src="inexistent2.png" alt="Hello">',
                '<img alt="Hello">',
                '<img src="data:image/svg+xml,<svg></svg>" alt="Hello">',
            ))
        assert_same_renderings(*documents)
    assert len(logs) == 1
    assert 'ERROR: Failed to load image' in logs[0]
    assert 'inexistent2.png' in logs[0]


@assert_no_logs
def test_images_repeat_transparent(assert_pixels):
    # Regression test for #1440.
    assert_pixels('_\n_\n_', '''
      <style>
        @page { size: 1px }
        div { height: 100px; width: 100px; background: url(logo_small.png) }
      </style>
      <div></div><div></div><div></div>''')


@assert_no_logs
def test_images_no_width(assert_pixels):
    assert_pixels(no_image, '''
      <style>
        @page { size: 8px }
        body { margin: 2px; font-size: 0 }
      </style>
      <div><img src="pattern.png" alt="not shown"
                style="width: 0; height: 1px"></div>''')


@assert_no_logs
def test_images_no_height(assert_pixels):
    assert_pixels(no_image, '''
      <style>
        @page { size: 8px }
        body { margin: 2px; font-size: 0 }
      </style>
      <div><img src="pattern.png" alt="not shown"
                style="width: 1px; height: 0"></div>''')


@assert_no_logs
def test_images_no_width_height(assert_pixels):
    assert_pixels(no_image, '''
      <style>
        @page { size: 8px }
        body { margin: 2px; font-size: 0 }
      </style>
      <div><img src="pattern.png" alt="not shown"
                style="width: 0; height: 0"></div>''')


@assert_no_logs
def test_images_page_break(assert_pixels):
    assert_pixels(page_break, '''
      <style>
        @page { size: 8px; margin: 2px }
        body { font-size: 0 }
      </style>
      <div><img src="pattern.png"></div>
      <div style="page-break-before: right"><img src="pattern.png"></div>''')


@assert_no_logs
def test_image_repeat_inline(assert_pixels):
    # Regression test for #808.
    assert_pixels(table, '''
      <style>
        @page { size: 8px; margin: 0 }
        table { border-collapse: collapse; margin: 2px }
        th, td { border: none; padding: 0 }
        th { height: 4px; line-height: 4px }
        td { height: 2px }
        img { vertical-align: top }
      </style>
      <table>
        <thead>
          <tr><th><img src="pattern.png"></th></tr>
        </thead>
        <tbody>
          <tr><td></td></tr>
          <tr><td></td></tr>
        </tbody>
      </table>''')


@assert_no_logs
def test_image_repeat_block(assert_pixels):
    # Regression test for #808.
    assert_pixels(table, '''
      <style>
        @page { size: 8px; margin: 0 }
        table { border-collapse: collapse; margin: 2px }
        th, td { border: none; padding: 0 }
        th { height: 4px }
        td { height: 2px }
        img { display: block }
      </style>
      <table>
        <thead>
          <tr><th><img src="pattern.png"></th></tr>
        </thead>
        <tbody>
          <tr><td></td></tr>
          <tr><td></td></tr>
        </tbody>
      </table>''')


@assert_no_logs
def test_images_padding(assert_pixels):
    # Regression test.
    assert_pixels(centered_image, '''
      <style>
        @page { size: 8px }
        body { font-size: 0 }
      </style>
      <div style="line-height: 1px">
        <img src=pattern.png style="padding: 2px 0 0 2px">
      </div>''')


@assert_no_logs
def test_images_in_inline_block(assert_pixels):
    # Regression test.
    assert_pixels(centered_image, '''
      <style>
        @page { size: 8px }
        body { margin: 2px 0 0 2px; font-size: 0 }
      </style>
      <div style="display: inline-block">
        <p><img src=pattern.png></p>
      </div>''')


@assert_no_logs
def test_images_transparent_text(assert_pixels):
    # Regression test for #2131.
    assert_pixels(centered_image, '''<style>
        @page { size: 8px }
        body { margin: 2px 0 0 2px; font-size: 2px; line-height: 0 }
      </style>
      <div style="color: #0001">123</div>
      <img src=pattern.png>
    ''')


@assert_no_logs
def test_images_shared_pattern(assert_pixels):
    # The same image is used in a repeating background,
    # then in a non-repating <img>.
    # If Pattern objects are shared carelessly, the image will be repeated.
    assert_pixels('''
        ____________
        ____________
        __aaaaaaaa__
        __aaaaaaaa__
        ____________
        __aaaa______
        __aaaa______
        __aaaa______
        __aaaa______
        ____________
        ____________
        ____________
    ''', '''
      <style>
        @page { size: 12px }
        body { margin: 2px; font-size: 0 }
      </style>
      <div style="background: url(blue.jpg);
                  height: 2px; margin-bottom: 1px"></div>
      <img src=blue.jpg>
    ''')


@assert_no_logs
def test_image_resolution(assert_same_renderings):
    assert_same_renderings(
        '''
            <style>@page { size: 20px; margin: 2px }</style>
            <div style="font-size: 0">
                <img src="pattern.png" style="width: 8px"></div>
        ''',
        '''
            <style>@page { size: 20px; margin: 2px }</style>
            <div style="image-resolution: .5dppx; font-size: 0">
                <img src="pattern.png"></div>
        ''',
        '''
            <style>@page { size: 20px; margin: 2px }
                   div::before { content: url(pattern.png) }
            </style>
            <div style="image-resolution: .5x; font-size: 0"></div>
        ''',
        '''
            <style>@page { size: 20px; margin: 2px }
            </style>
            <div style="height: 16px; image-resolution: .5dppx;
                        background: url(pattern.png) no-repeat"></div>
        ''',
    )


@assert_no_logs
def test_image_cover(assert_pixels):
    assert_pixels(cover_image, '''
      <style>
        @page { size: 8px }
        body { margin: 2px 0 0 2px; font-size: 0 }
        img { object-fit: cover; height: 4px; width: 2px; overflow: hidden }
      </style>
      <img src="pattern.png">''')


@assert_no_logs
def test_image_contain(assert_pixels):
    assert_pixels(centered_image, '''
      <style>
        @page { size: 8px }
        body { margin: 1px 0 0 2px; font-size: 0 }
        img { object-fit: contain; height: 6px; width: 4px; overflow: hidden }
      </style>
      <img src="pattern.png">''')


@assert_no_logs
def test_image_none(assert_pixels):
    assert_pixels(centered_image, '''
      <style>
        @page { size: 8px }
        body { margin: 1px 0 0 1px; font-size: 0 }
        img { object-fit: none; height: 6px; width: 6px }
      </style>
      <img src="pattern.png">''')


@assert_no_logs
def test_image_scale_down(assert_pixels):
    assert_pixels(centered_image, '''
      <style>
        @page { size: 8px }
        body { margin: 1px 0 0 1px; font-size: 0 }
        img { object-fit: scale-down; height: 6px; width: 6px }
      </style>
      <img src="pattern.png">''')


@assert_no_logs
def test_image_position(assert_pixels):
    assert_pixels(centered_image, '''
      <style>
        @page { size: 8px }
        body { margin: 1px 0 0 1px; font-size: 0 }
        img { object-fit: none; height: 6px; width: 6px;
              object-position: bottom 50% right 50% }
      </style>
      <img src="pattern.png">''')


@assert_no_logs
def test_images_border(assert_pixels):
    assert_pixels(border_image, '''
      <style>
        @page { size: 8px }
        body { margin: 0; font-size: 0 }
        img { margin: 1px; border: 1px solid lime }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_images_border_absolute(assert_pixels):
    assert_pixels(border_image, '''
      <style>
        @page { size: 8px }
        body { margin: 0; font-size: 0 }
        img { margin: 1px; border: 1px solid lime; position: absolute }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_image_exif(assert_same_renderings):
    assert_same_renderings(
        '''
            <style>@page { size: 10px }</style>
            <img style="display: block" src="not-optimized.jpg">
        ''',
        '''
            <style>@page { size: 10px }</style>
            <img style="display: block" src="not-optimized-exif.jpg">
        ''',
        tolerance=25,
    )


@assert_no_logs
def test_image_exif_image_orientation(assert_same_renderings):
    assert_same_renderings(
        '''
            <style>@page { size: 10px }</style>
            <img style="display: block; image-orientation: 180deg"
                 src="not-optimized-exif.jpg">
        ''',
        '''
            <style>@page { size: 10px }</style>
            <img style="display: block" src="not-optimized-exif.jpg">
        ''',
        tolerance=25,
    )


@assert_no_logs
def test_image_exif_image_orientation_keep_format():
    # Regression test for #1755.
    pdf = FakeHTML(
        string='''
          <style>@page { size: 10px }</style>
          <img style="display: block; image-orientation: 180deg"
               src="not-optimized-exif.jpg">''',
        base_url=resource_path('<inline HTML>')).write_pdf()
    assert b'DCTDecode' in pdf


================================================
FILE: tests/draw/test_leader.py
================================================
"""Test how leaders are drawn."""

import pytest

from ..testing_utils import assert_no_logs


@assert_no_logs
def test_leader_simple(assert_pixels):
    assert_pixels('''
        RR__BBBBBBBB__BB
        RR__BBBBBBBB__BB
        RRRR__BBBB__BBBB
        RRRR__BBBB__BBBB
        RR__BBBB__BBBBBB
        RR__BBBB__BBBBBB
    ''', '''
      <style>
        @page {
          size: 16px 6px;
        }
        body {
          color: red;
          counter-reset: count;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        div::after {
          color: blue;
          content: ' ' leader(dotted) ' ' counter(count, lower-roman);
          counter-increment: count;
        }
      </style>
      <div>a</div>
      <div>bb</div>
      <div>c</div>
    ''')


@assert_no_logs
def test_leader_too_long(assert_pixels):
    assert_pixels('''
        RRRRRRRRRR______
        RRRRRRRRRR______
        BBBBBBBBBBBB__BB
        BBBBBBBBBBBB__BB
        RR__RR__RR__RR__
        RR__RR__RR__RR__
        RR__RR__RR______
        RR__RR__RR______
        BBBBBBBBBB__BBBB
        BBBBBBBBBB__BBBB
        RR__RR__RR__RR__
        RR__RR__RR__RR__
        RR__BBBB__BBBBBB
        RR__BBBB__BBBBBB
    ''', '''
      <style>
        @page {
          size: 16px 14px;
        }
        body {
          color: red;
          counter-reset: count;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        div::after {
          color: blue;
          content: ' ' leader(dotted) ' ' counter(count, lower-roman);
          counter-increment: count;
        }
      </style>
      <div>aaaaa</div>
      <div>a a a a a a a</div>
      <div>a a a a a</div>
    ''')


@assert_no_logs
def test_leader_alone(assert_pixels):
    assert_pixels('''
        RRBBBBBBBBBBBBBB
        RRBBBBBBBBBBBBBB
    ''', '''
      <style>
        @page {
          size: 16px 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        div::after {
          color: blue;
          content: leader(dotted);
        }
      </style>
      <div>a</div>
    ''')


@assert_no_logs
def test_leader_content(assert_pixels):
    assert_pixels('''
        RR____BB______BB
        RR____BB______BB
    ''', '''
      <style>
        @page {
          size: 16px 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        div::after {
          color: blue;
          content: leader(' . ') 'a';
        }
      </style>
      <div>a</div>
    ''')


@pytest.mark.xfail
@assert_no_logs
def test_leader_float(assert_pixels):
    assert_pixels('''
        bbGRR___BB____BB
        bbGRR___BB____BB
        GGGRR___BB____BB
        ___RR___BB____BB
    ''', '''
      <style>
        @page {
          size: 16px 4px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        article {
          background: lime;
          color: navy;
          float: left;
          height: 3px;
          width: 3px;
        }
        div::after {
          color: blue;
          content: leader('. ') 'a';
        }
      </style>
      <div>a<article>a</article></div>
      <div>a</div>
    ''')


@pytest.mark.xfail
@assert_no_logs
def test_leader_float_small(assert_pixels):
    assert_pixels('''
        bbRRBB__BB____BB
        bbRRBB__BB____BB
        RR__BB__BB____BB
        RR__BB__BB____BB
    ''', '''
      <style>
        @page {
          size: 16px 4px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        article {
          background: lime;
          color: navy;
          float: left;
        }
        div::after {
          color: blue;
          content: leader('. ') 'a';
        }
      </style>
      <div>a<article>a</article></div>
      <div>a</div>
    ''')


@assert_no_logs
def test_leader_in_inline(assert_pixels):
    assert_pixels('''
        RR__GGBBBBBB__RR
        RR__GGBBBBBB__RR
    ''', '''
      <style>
        @page {
          size: 16px 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        span {
          color: lime;
        }
        span::after {
          color: blue;
          content: leader('-');
        }
      </style>
      <div>a <span>a</span> a</div>
    ''')


@pytest.mark.xfail
@assert_no_logs
def test_leader_bad_alignment(assert_pixels):
    assert_pixels('''
        RRRRRR__________
        RRRRRR__________
        ______BB______RR
        ______BB______RR
    ''', '''
      <style>
        @page {
          size: 16px 4px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        div::after {
          color: blue;
          content: leader(' - ') 'a';
        }
      </style>
      <div>aaa</div>
    ''')


@assert_no_logs
def test_leader_simple_rtl(assert_pixels):
    assert_pixels('''
        BB__BBBBBBBB__RR
        BB__BBBBBBBB__RR
        BBBB__BBBB__RRRR
        BBBB__BBBB__RRRR
        BBBBBB__BBBB__RR
        BBBBBB__BBBB__RR
    ''', '''
      <style>
        @page {
          size: 16px 6px;
        }
        body {
          color: red;
          counter-reset: count;
          direction: rtl;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        div::after {
          color: blue;
          /* RTL Mark used in second space */
          content: ' ' leader(dotted) '‏ ' counter(count, lower-roman);
          counter-increment: count;
        }
      </style>
      <div>a</div>
      <div>bb</div>
      <div>c</div>
    ''')


@assert_no_logs
def test_leader_too_long_rtl(assert_pixels):
    assert_pixels('''
        ______RRRRRRRRRR
        ______RRRRRRRRRR
        BB__BBBBBBBBBBBB
        BB__BBBBBBBBBBBB
        __RR__RR__RR__RR
        __RR__RR__RR__RR
        ______RR__RR__RR
        ______RR__RR__RR
        BBBB__BBBBBBBBBB
        BBBB__BBBBBBBBBB
        __RR__RR__RR__RR
        __RR__RR__RR__RR
        BBBBBB__BBBB__RR
        BBBBBB__BBBB__RR
    ''', '''
      <style>
        @page {
          size: 16px 14px;
        }
        body {
          color: red;
          counter-reset: count;
          direction: rtl;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        div::after {
          color: blue;
          /* RTL Mark used in second space */
          content: ' ' leader(dotted) '‏ ' counter(count, lower-roman);
          counter-increment: count;
        }
      </style>
      <div>aaaaa</div>
      <div>a a a a a a a</div>
      <div>a a a a a</div>
    ''')


@assert_no_logs
def test_leader_float_leader(assert_pixels):
    # Regression test for #1409.
    # Leaders in floats are not displayed at all in many cases with the current
    # implementation, and this case is not really specified. So…
    assert_pixels('''
        RR____________BB
        RR____________BB
        RRRR__________BB
        RRRR__________BB
        RR____________BB
        RR____________BB
    ''', '''
      <style>
        @page {
          size: 16px 6px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        div::after {
          color: blue;
          content: leader(' . ') 'a';
          float: right;
        }
      </style>
      <div>a</div>
      <div>bb</div>
      <div>c</div>
    ''')


@assert_no_logs
def test_leader_empty_string(assert_pixels):
    assert_pixels('''
        RRRR____
        ________
    ''', '''
      <style>
        @page {
          size: 8px 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 1px;
          line-height: 1;
        }
        div::after {
          color: blue;
          content: leader('');
        }
      </style>
      <div>aaaa</div>
    ''')


@assert_no_logs
def test_leader_zero_width_string(assert_pixels):
    assert_pixels('''
        RRRR____
        ________
    ''', '''
      <style>
        @page {
          size: 8px 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 1px;
          line-height: 1;
        }
        div::after {
          color: blue;
          content: leader('​');  /* zero-width space */
        }
      </style>
      <div>aaaa</div>
    ''')


@assert_no_logs
def test_leader_absolute(assert_pixels):
    assert_pixels('''
        BBBBRRRR
        ______GG
    ''', '''
      <style>
        @page {
          size: 8px 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 1px;
          line-height: 1;
        }
        div::before {
          color: blue;
          content: leader('z');
        }
        article {
          bottom: 0;
          color: lime;
          position: absolute;
          right: 0;
        }
      </style>
      <div>aa<article>bb</article>aa</div>
    ''')


@assert_no_logs
def test_leader_padding(assert_pixels):
    assert_pixels('''
        RR__BBBBBBBB__BB
        RR__BBBBBBBB__BB
        __RR__BBBB__BBBB
        __RR__BBBB__BBBB
    ''', '''
      <style>
        @page {
          size: 16px 4px;
        }
        body {
          color: red;
          counter-reset: count;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        div::after {
          color: blue;
          content: ' ' leader(dotted) ' ' counter(count, lower-roman);
          counter-increment: count;
        }
        div + div {
          padding-left: 2px;
        }
      </style>
      <div>a</div>
      <div>b</div>
    ''')


@assert_no_logs
def test_leader_inline_padding(assert_pixels):
    assert_pixels('''
        RR__BBBBBBBB__BB
        RR__BBBBBBBB__BB
        __RR__BBBB__BBBB
        __RR__BBBB__BBBB
    ''', '''
      <style>
        @page {
          size: 16px 4px;
        }
        body {
          color: red;
          counter-reset: count;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        span::after {
          color: blue;
          content: ' ' leader(dotted) ' ' counter(count, lower-roman);
          counter-increment: count;
        }
        div + div span {
          padding-left: 2px;
        }
      </style>
      <div><span>a</span></div>
      <div><span>b</span></div>
    ''')


@assert_no_logs
def test_leader_margin(assert_pixels):
    assert_pixels('''
        RR__BBBBBBBB__BB
        RR__BBBBBBBB__BB
        __RR__BBBB__BBBB
        __RR__BBBB__BBBB
    ''', '''
      <style>
        @page {
          size: 16px 4px;
        }
        body {
          color: red;
          counter-reset: count;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        div::after {
          color: blue;
          content: ' ' leader(dotted) ' ' counter(count, lower-roman);
          counter-increment: count;
        }
        div + div {
          margin-left: 2px;
        }
      </style>
      <div>a</div>
      <div>b</div>
    ''')


@assert_no_logs
def test_leader_inline_margin(assert_pixels):
    assert_pixels('''
        RR__BBBBBBBB__BB
        RR__BBBBBBBB__BB
        __RR__BBBB__BBBB
        __RR__BBBB__BBBB
    ''', '''
      <style>
        @page {
          size: 16px 4px;
        }
        body {
          color: red;
          counter-reset: count;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        span::after {
          color: blue;
          content: ' ' leader(dotted) ' ' counter(count, lower-roman);
          counter-increment: count;
        }
        div + div span {
          margin-left: 2px;
        }
      </style>
      <div><span>a</span></div>
      <div><span>b</span></div>
    ''')


================================================
FILE: tests/draw/test_list.py
================================================
"""Test how lists are drawn."""

import pytest

from ..testing_utils import SANS_FONTS, assert_no_logs


@assert_no_logs
@pytest.mark.parametrize(('position', 'pixels'), [
    ('outside',
     #  ++++++++++++++      ++++  <li> horizontal margins: 7px 2px
     #                ######      <li> width: 12 - 7 - 2 = 3px
     #              --            list marker margin: 0.5em = 2px
     #      ********              list marker image is 4px wide
     '''
        ____________
        ____________
        ___rBBB_____
        ___BBBB_____
        ___BBBB_____
        ___BBBB_____
        ____________
        ____________
        ____________
        ____________
     '''),
    ('inside',
     #  ++++++++++++++      ++++  <li> horizontal margins: 7px 2px
     #                ######      <li> width: 12 - 7 - 2 = 3px
     #                ********    list marker image is 4px wide: overflow
     '''
        ____________
        ____________
        _______rBBB_
        _______BBBB_
        _______BBBB_
        _______BBBB_
        ____________
        ____________
        ____________
        ____________
     ''')
])
def test_list_style_image(assert_pixels, position, pixels):
    assert_pixels(pixels, '''
      <style>
        @page { size: 12px 10px }
        body { margin: 0; font-family: %s }
        ul { margin: 2px 2px 0 7px; list-style: url(pattern.png) %s;
             font-size: 2px }
      </style>
      <ul><li></li></ul>''' % (SANS_FONTS, position))


@assert_no_logs
def test_list_style_image_none(assert_pixels):
    assert_pixels('''
        __________
        __________
        __________
        __________
        __________
        __________
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page { size: 10px }
        body { margin: 0; font-family: %s }
        ul { margin: 0 0 0 5px; list-style: none; font-size: 2px; }
      </style>
      <ul><li>''' % (SANS_FONTS,))


================================================
FILE: tests/draw/test_opacity.py
================================================
"""Test opacity."""

from ..testing_utils import assert_no_logs

opacity_source = '''
    <style>
        @page { size: 60px 60px }
        div { background: #000; width: 20px; height: 20px }
    </style>
    %s'''


@assert_no_logs
def test_opacity_zero(assert_same_renderings):
    assert_same_renderings(
        opacity_source % '<div></div>',
        opacity_source % '<div></div><div style="opacity: 0"></div>',
        opacity_source % '<div></div><div style="opacity: 0%"></div>',
    )


@assert_no_logs
def test_opacity_normal_range(assert_same_renderings):
    assert_same_renderings(
        opacity_source % '<div style="background: rgb(102, 102, 102)"></div>',
        opacity_source % '<div style="opacity: 0.6"></div>',
        opacity_source % '<div style="opacity: 60%"></div>',
        opacity_source % '<div style="opacity: 60.0%"></div>',
    )


@assert_no_logs
def test_opacity_nested(assert_same_renderings):
    assert_same_renderings(
        opacity_source % '<div style="background: rgb(102, 102, 102)"></div>',
        opacity_source % '<div style="opacity: 0.6"></div>',
        opacity_source % '''
          <div style="background: none; opacity: 0.666666">
            <div style="opacity: 0.9"></div>
          </div>
        ''',  # 0.9 * 0.666666 == 0.6
    )


@assert_no_logs
def test_opacity_percent_clamp_down(assert_same_renderings):
    assert_same_renderings(
        opacity_source % '<div></div>',
        opacity_source % '<div style="opacity: 1.2"></div>',
        opacity_source % '<div style="opacity: 120%"></div>',
    )


@assert_no_logs
def test_opacity_percent_clamp_up(assert_same_renderings):
    assert_same_renderings(
        opacity_source % '<div></div>',
        opacity_source % '<div></div><div style="opacity: -0.2"></div>',
        opacity_source % '<div></div><div style="opacity: -20%"></div>',
    )


@assert_no_logs
def test_opacity_black(assert_same_renderings):
    # Regression test for #2302.
    assert_same_renderings(
        opacity_source % 'a<span style="color: rgb(0, 0, 0, 0.5)">b</span>',
        opacity_source % 'a<span style="opacity: 0.5">b</span>',
    )


================================================
FILE: tests/draw/test_overflow.py
================================================
"""Test overflow and clipping."""

import pytest

from ..testing_utils import assert_no_logs


@assert_no_logs
def test_overflow_1(assert_pixels):
    # See test_images
    assert_pixels('''
        ________
        ________
        __rBBB__
        __BBBB__
        ________
        ________
        ________
        ________
    ''', '''
      <style>
        @page { size: 8px }
        body { margin: 2px 0 0 2px; font-size: 0 }
        div { height: 2px; overflow: hidden }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_overflow_2(assert_pixels):
    # <body> is only 1px high, but its overflow is propageted to the viewport
    # ie. the padding edge of the page box.
    assert_pixels('''
        ________
        ________
        __rBBB__
        __BBBB__
        __BBBB__
        ________
        ________
        ________
    ''', '''
      <style>
        @page { size: 8px; margin: 2px 2px 3px 2px }
        body { height: 1px; overflow: hidden; font-size: 0 }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_overflow_3(assert_pixels):
    # Assert that the border is not clipped by overflow: hidden
    assert_pixels('''
        ________
        ________
        __BBBB__
        __B__B__
        __B__B__
        __BBBB__
        ________
        ________
    ''', '''
      <style>
        @page { size: 8px; margin: 2px; }
        div { width: 2px; height: 2px; overflow: hidden;
              border: 1px solid blue; }
      </style>
      <div></div>''')


@assert_no_logs
def test_overflow_4(assert_pixels):
    # Assert that the page margins aren't clipped by body's overflow
    assert_pixels('''
        rr______
        rr______
        __BBBB__
        __BBBB__
        __BBBB__
        __BBBB__
        ________
        ________
    ''', '''
      <style>
        @page {
          size: 8px;
          margin: 2px;
          background:#fff;
          @top-left-corner { content: ''; background:#f00; } }
        body { overflow: auto; background:#00f; }
      </style>
      ''')


@assert_no_logs
def test_overflow_5(assert_pixels):
    # Regression test for #2026.
    assert_pixels('''
        BBBBBB__
        BBBBBB__
        BBBB____
        BBBB____
        BBBB____
        ________
        ________
        ________
    ''', '''
      <style>
        @page { size: 8px }
        body { font-family: weasyprint; line-height: 1; font-size: 2px }
        p { color: blue }
      </style>
      <p>abc</p>
      <p style="height: 3px; overflow: hidden">ab<br>ab<br>ab<br>ab</p>
      ''')


@assert_no_logs
@pytest.mark.parametrize(('number', 'css', 'pixels'), [
    (1, '5px, 5px, 9px, auto', '''
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______rBBBrBg_
        ______BBBBBBg_
        ______BBBBBBg_
        ______BBBBBBg_
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    (2, '5px, 5px, auto, 10px', '''
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        ______rBBBr___
        ______BBBBB___
        ______BBBBB___
        ______BBBBB___
        ______rBBBr___
        ______BBBBB___
        ______ggggg___
        ______________
        ______________
        ______________
    '''),
    (3, '5px, auto, 9px, 10px', '''
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
        _grBBBrBBBr___
        _gBBBBBBBBB___
        _gBBBBBBBBB___
        _gBBBBBBBBB___
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
    (4, 'auto, 5px, 9px, 10px', '''
        ______________
        ______ggggg___
        ______rBBBr___
        ______BBBBB___
        ______BBBBB___
        ______BBBBB___
        ______rBBBr___
        ______BBBBB___
        ______BBBBB___
        ______BBBBB___
        ______________
        ______________
        ______________
        ______________
        ______________
        ______________
    '''),
])
def test_clip(assert_pixels, number, css, pixels):
    assert_pixels(pixels, '''
      <style>
        @page { size: 14px 16px }
        div { margin: 1px; border: 1px green solid;
              background: url(pattern.png);
              position: absolute; /* clip only applies on abspos */
              top: 0; bottom: 2px; left: 0; right: 0;
              clip: rect(%s); }
      </style>
      <div>''' % css)


================================================
FILE: tests/draw/test_page.py
================================================
"""Test how pages are drawn."""

import pytest

from ..testing_utils import assert_no_logs


@assert_no_logs
@pytest.mark.parametrize(('rule', 'pixels'), [
    ('2n', '_R_R_R_R_R'),
    ('even', '_R_R_R_R_R'),
    ('2n+1', 'R_R_R_R_R_'),
    ('odd', 'R_R_R_R_R_'),
    ('2n+3', '__R_R_R_R_'),
    ('n', 'RRRRRRRRRR'),
    ('n-1', 'RRRRRRRRRR'),
    ('-n+3', 'RRR_______'),
    ('-2n+3', 'R_R_______'),
    ('-n-3', '__________'),
    ('3', '__R_______'),
    ('0n+0', '__________'),
])
def test_nth_page(assert_pixels, rule, pixels):
    assert_pixels('\n'.join(pixels), '''
      <style>
        @page { size: 1px 1px }
        @page:nth(%s) { background: red }
        p { break-after: page }
      </style>
    ''' % rule + 10 * '<p></p>')


================================================
FILE: tests/draw/test_table.py
================================================
"""Test how tables are drawn."""

import pytest

from ..testing_utils import assert_no_logs

tables_source = '''
  <style>
    @page { size: 28px }
    table { margin: 1px; padding: 1px; border-spacing: 1px;
            border: 1px solid transparent }
    td { width: 2px; height: 2px; padding: 1px; border: 1px solid transparent }
    %(extra_css)s
  </style>
  <table>
    <colgroup class=colgroup>
      <col></col>
      <col></col>
    </colgroup>
    <col></col>
    <tbody id=tbody>
      <tr>
        <td></td>
        <td rowspan=2></td>
        <td></td>
      </tr>
      <tr>
        <td colspan=2></td>
        <td></td>
      </tr>
    </tbody>
    <tr>
      <td></td>
      <td></td>
    </tr>
  </table>
'''


@assert_no_logs
def test_tables_1(assert_pixels):
    assert_pixels('''
        ____________________________
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        _B________________________B_
        _B________________________B_
        _B__ssssss_ssssss_ssssss__B_
        _B__s____s_s____s_s____s__B_
        _B__s____s_s____s_s____s__B_
        _B__s____s_s____s_s____s__B_
        _B__s____s_s____s_s____s__B_
        _B__ssssss_s____s_ssssss__B_
        _B_________s____s_________B_
        _B__sssssssSssssS_ssssss__B_
        _B__s______s____S_s____s__B_
        _B__s______s____S_s____s__B_
        _B__s______s____S_s____s__B_
        _B__s______s____S_s____s__B_
        _B__sssssssSSSSSS_ssssss__B_
        _B________________________B_
        _B__ssssss_ssssss_________B_
        _B__s____s_s____s_________B_
        _B__s____s_s____s_________B_
        _B__s____s_s____s_________B_
        _B__s____s_s____s_________B_
        _B__ssssss_ssssss_________B_
        _B________________________B_
        _B________________________B_
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border-color: #00f; table-layout: fixed }
      td { border-color: rgba(255, 0, 0, 0.5) }
    '''})


@assert_no_logs
def test_tables_1_rtl(assert_pixels):
    assert_pixels('''
        ____________________________
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        _B________________________B_
        _B________________________B_
        _B__ssssss_ssssss_ssssss__B_
        _B__s____s_s____s_s____s__B_
        _B__s____s_s____s_s____s__B_
        _B__s____s_s____s_s____s__B_
        _B__s____s_s____s_s____s__B_
        _B__ssssss_s____s_ssssss__B_
        _B_________s____s_________B_
        _B__ssssss_SssssSsssssss__B_
        _B__s____s_S____s______s__B_
        _B__s____s_S____s______s__B_
        _B__s____s_S____s______s__B_
        _B__s____s_S____s______s__B_
        _B__ssssss_SSSSSSsssssss__B_
        _B________________________B_
        _B_________ssssss_ssssss__B_
        _B_________s____s_s____s__B_
        _B_________s____s_s____s__B_
        _B_________s____s_s____s__B_
        _B_________s____s_s____s__B_
        _B_________ssssss_ssssss__B_
        _B________________________B_
        _B________________________B_
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border-color: #00f; table-layout: fixed;
                direction: rtl; }
      td { border-color: rgba(255, 0, 0, 0.5) }
    '''})


@assert_no_logs
def test_tables_2(assert_pixels):
    assert_pixels('''
        ____________________________
        _BBBBBBBBBBBBBBBBBB_________
        _BBBBBBBBBBBBBBBBBB_________
        _BB____s____s____BB_________
        _BB____s____s____BB_________
        _BB____s____s____BB_________
        _BB____s____s____BB_________
        _BBsssss____sssssBB_________
        _BB_________s____BB_________
        _BB_________s____BB_________
        _BB_________s____BB_________
        _BB_________s____BB_________
        _BBssssssssssssssBB_________
        _BB____s____s____BB_________
        _BB____s____s____BB_________
        _BB____s____s____BB_________
        _BB____s____s____BB_________
        _BBBBBBBBBBBBBBBBBB_________
        _BBBBBBBBBBBBBBBBBB_________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border: 2px solid #00f; table-layout: fixed;
                border-collapse: collapse }
      td { border-color: #ff7f7f }
    '''})


@assert_no_logs
def test_tables_2_rtl(assert_pixels):
    assert_pixels('''
        ____________________________
        _________BBBBBBBBBBBBBBBBBB_
        _________BBBBBBBBBBBBBBBBBB_
        _________BB____s____s____BB_
        _________BB____s____s____BB_
        _________BB____s____s____BB_
        _________BB____s____s____BB_
        _________BBsssss____sssssBB_
        _________BB____s_________BB_
        _________BB____s_________BB_
        _________BB____s_________BB_
        _________BB____s_________BB_
        _________BBssssssssssssssBB_
        _________BB____s____s____BB_
        _________BB____s____s____BB_
        _________BB____s____s____BB_
        _________BB____s____s____BB_
        _________BBBBBBBBBBBBBBBBBB_
        _________BBBBBBBBBBBBBBBBBB_
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
    ''', tables_source % {'extra_css': '''
      body { direction: rtl; }
      table { border: 2px solid #00f; table-layout: fixed; border-collapse: collapse }
      td { border-color: #ff7f7f }
    '''})


@assert_no_logs
def test_tables_3(assert_pixels):
    assert_pixels('''
        ____________________________
        _tttttttttttttttttttttttttt_
        _t________________________t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BB____s____s____BB_____t_
        _t_BB____s____s____BB_____t_
        _t_BB____s____s____BB_____t_
        _t_BB____s____s____BB_____t_
        _t_BBsssss____sssssBB_____t_
        _t_BB_________s____BB_____t_
        _t_BB_________s____BB_____t_
        _t_BB_________s____BB_____t_
        _t_BB_________s____BB_____t_
        _t_BBssssssssssssssBB_____t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _tttttttttttttttttttttttttt_
        ____________________________
        ____________________________
        _tttttttttttttttttttttttttt_
        _t_BBssssssssssssssBB_____t_
        _t_BB____s____s____BB_____t_
        _t_BB____s____s____BB_____t_
        _t_BB____s____s____BB_____t_
        _t_BB____s____s____BB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t_BBBBBBBBBBBBBBBBBB_____t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _tttttttttttttttttttttttttt_
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border: solid #00f; border-width: 8px 2px;
              table-layout: fixed; border-collapse: collapse }
      td { border-color: #ff7f7f }
      @page { size: 28px 26px; margin: 1px;
              border: 1px solid rgba(0, 255, 0, 0.5); }
    '''})


@assert_no_logs
def test_tables_3_rtl(assert_pixels):
    assert_pixels('''
        ____________________________
        _tttttttttttttttttttttttttt_
        _t________________________t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BB____s____s____BB_t_
        _t_____BB____s____s____BB_t_
        _t_____BB____s____s____BB_t_
        _t_____BB____s____s____BB_t_
        _t_____BBsssss____sssssBB_t_
        _t_____BB____s_________BB_t_
        _t_____BB____s_________BB_t_
        _t_____BB____s_________BB_t_
        _t_____BB____s_________BB_t_
        _t_____BBssssssssssssssBB_t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _tttttttttttttttttttttttttt_
        ____________________________
        ____________________________
        _tttttttttttttttttttttttttt_
        _t_____BBssssssssssssssBB_t_
        _t_____BB____s____s____BB_t_
        _t_____BB____s____s____BB_t_
        _t_____BB____s____s____BB_t_
        _t_____BB____s____s____BB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _tttttttttttttttttttttttttt_
        ____________________________
    ''', tables_source % {'extra_css': '''
      body { direction: rtl; }
      table { border: solid #00f; border-width: 8px 2px;
              table-layout: fixed; border-collapse: collapse }
      td { border-color: #ff7f7f }
      @page { size: 28px 26px; margin: 1px;
              border: 1px solid rgba(0, 255, 0, 0.5); }
    '''})


@assert_no_logs
def test_tables_4(assert_pixels):
    assert_pixels('''
        ____________________________
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        _B________________________B_
        _B________________________B_
        _B__ssssss_ssssss_ssssss__B_
        _B__ssssss_ssssss_ssssss__B_
        _B__ssssss_ssssss_ssssss__B_
        _B__ssssss_ssssss_ssssss__B_
        _B__ssssss_ssssss_ssssss__B_
        _B__ssssss_ssssss_ssssss__B_
        _B_________ssssss_________B_
        _B__sssssssSSSSSS_ssssss__B_
        _B__sssssssSSSSSS_ssssss__B_
        _B__sssssssSSSSSS_ssssss__B_
        _B__sssssssSSSSSS_ssssss__B_
        _B__sssssssSSSSSS_ssssss__B_
        _B__sssssssSSSSSS_ssssss__B_
        _B________________________B_
        _B__ssssss_ssssss_________B_
        _B__ssssss_ssssss_________B_
        _B__ssssss_ssssss_________B_
        _B__ssssss_ssssss_________B_
        _B__ssssss_ssssss_________B_
        _B__ssssss_ssssss_________B_
        _B________________________B_
        _B________________________B_
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border-color: #00f; table-layout: fixed }
      td { background: rgba(255, 0, 0, 0.5) }
    '''})


@assert_no_logs
def test_tables_4_rtl(assert_pixels):
    assert_pixels('''
        ____________________________
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        _B________________________B_
        _B________________________B_
        _B__ssssss_ssssss_ssssss__B_
        _B__ssssss_ssssss_ssssss__B_
        _B__ssssss_ssssss_ssssss__B_
        _B__ssssss_ssssss_ssssss__B_
        _B__ssssss_ssssss_ssssss__B_
        _B__ssssss_ssssss_ssssss__B_
        _B_________ssssss_________B_
        _B__ssssss_SSSSSSsssssss__B_
        _B__ssssss_SSSSSSsssssss__B_
        _B__ssssss_SSSSSSsssssss__B_
        _B__ssssss_SSSSSSsssssss__B_
        _B__ssssss_SSSSSSsssssss__B_
        _B__ssssss_SSSSSSsssssss__B_
        _B________________________B_
        _B_________ssssss_ssssss__B_
        _B_________ssssss_ssssss__B_
        _B_________ssssss_ssssss__B_
        _B_________ssssss_ssssss__B_
        _B_________ssssss_ssssss__B_
        _B_________ssssss_ssssss__B_
        _B________________________B_
        _B________________________B_
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border-color: #00f; table-layout: fixed; direction: rtl }
      td { background: rgba(255, 0, 0, 0.5) }
    '''})


@assert_no_logs
def test_tables_5(assert_pixels):
    assert_pixels('''
        ____________________________
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        _B________________________B_
        _B________________________B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B_________uuuuuu_________B_
        _B__uuuuuuupppppp_uuuuuu__B_
        _B__uuuuuuupppppp_uuuuuu__B_
        _B__uuuuuuupppppp_uuuuuu__B_
        _B__uuuuuuupppppp_uuuuuu__B_
        _B__uuuuuuupppppp_uuuuuu__B_
        _B__uuuuuuupppppp_uuuuuu__B_
        _B________________________B_
        _B__ssssss_ssssss_________B_
        _B__ssssss_ssssss_________B_
        _B__ssssss_ssssss_________B_
        _B__ssssss_ssssss_________B_
        _B__ssssss_ssssss_________B_
        _B__ssssss_ssssss_________B_
        _B________________________B_
        _B________________________B_
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border-color: #00f; table-layout: fixed }
      #tbody { background: rgba(0, 0, 255, 1) }
      tr { background: rgba(255, 0, 0, 0.5) }
    '''})


@assert_no_logs
def test_tables_5_rtl(assert_pixels):
    assert_pixels('''
        ____________________________
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        _B________________________B_
        _B________________________B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B_________uuuuuu_________B_
        _B__uuuuuu_ppppppuuuuuuu__B_
        _B__uuuuuu_ppppppuuuuuuu__B_
        _B__uuuuuu_ppppppuuuuuuu__B_
        _B__uuuuuu_ppppppuuuuuuu__B_
        _B__uuuuuu_ppppppuuuuuuu__B_
        _B__uuuuuu_ppppppuuuuuuu__B_
        _B________________________B_
        _B_________ssssss_ssssss__B_
        _B_________ssssss_ssssss__B_
        _B_________ssssss_ssssss__B_
        _B_________ssssss_ssssss__B_
        _B_________ssssss_ssssss__B_
        _B_________ssssss_ssssss__B_
        _B________________________B_
        _B________________________B_
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border-color: #00f; table-layout: fixed; direction: rtl }
      #tbody { background: rgba(0, 0, 255, 1) }
      tr { background: rgba(255, 0, 0, 0.5) }
    '''})


@assert_no_logs
def test_tables_6(assert_pixels):
    assert_pixels('''
        ____________________________
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        _B________________________B_
        _B________________________B_
        _B__uuuuuu_uuuuuu_ssssss__B_
        _B__uuuuuu_uuuuuu_ssssss__B_
        _B__uuuuuu_uuuuuu_ssssss__B_
        _B__uuuuuu_uuuuuu_ssssss__B_
        _B__uuuuuu_uuuuuu_ssssss__B_
        _B__uuuuuu_uuuuuu_ssssss__B_
        _B_________uuuuuu_________B_
        _B__uuuuuuupppppp_ssssss__B_
        _B__uuuuuuupppppp_ssssss__B_
        _B__uuuuuuupppppp_ssssss__B_
        _B__uuuuuuupppppp_ssssss__B_
        _B__uuuuuuupppppp_ssssss__B_
        _B__uuuuuuupppppp_ssssss__B_
        _B________________________B_
        _B__uuuuuu_uuuuuu_________B_
        _B__uuuuuu_uuuuuu_________B_
        _B__uuuuuu_uuuuuu_________B_
        _B__uuuuuu_uuuuuu_________B_
        _B__uuuuuu_uuuuuu_________B_
        _B__uuuuuu_uuuuuu_________B_
        _B________________________B_
        _B________________________B_
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border-color: #00f; table-layout: fixed;}
      .colgroup { background: rgba(0, 0, 255, 1) }
      col { background: rgba(255, 0, 0, 0.5) }
    '''})


@assert_no_logs
def test_tables_6_rtl(assert_pixels):
    assert_pixels('''
        ____________________________
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        _B________________________B_
        _B________________________B_
        _B__ssssss_uuuuuu_uuuuuu__B_
        _B__ssssss_uuuuuu_uuuuuu__B_
        _B__ssssss_uuuuuu_uuuuuu__B_
        _B__ssssss_uuuuuu_uuuuuu__B_
        _B__ssssss_uuuuuu_uuuuuu__B_
        _B__ssssss_uuuuuu_uuuuuu__B_
        _B_________uuuuuu_________B_
        _B__ssssss_ppppppuuuuuuu__B_
        _B__ssssss_ppppppuuuuuuu__B_
        _B__ssssss_ppppppuuuuuuu__B_
        _B__ssssss_ppppppuuuuuuu__B_
        _B__ssssss_ppppppuuuuuuu__B_
        _B__ssssss_ppppppuuuuuuu__B_
        _B________________________B_
        _B_________uuuuuu_uuuuuu__B_
        _B_________uuuuuu_uuuuuu__B_
        _B_________uuuuuu_uuuuuu__B_
        _B_________uuuuuu_uuuuuu__B_
        _B_________uuuuuu_uuuuuu__B_
        _B_________uuuuuu_uuuuuu__B_
        _B________________________B_
        _B________________________B_
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border-color: #00f; table-layout: fixed; direction: rtl }
      .colgroup { background: rgba(0, 0, 255, 1) }
      col { background: rgba(255, 0, 0, 0.5) }
    '''})


@assert_no_logs
def test_tables_7(assert_pixels):
    assert_pixels('''
        ____________________________
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        _B________________________B_
        _B________________________B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B__uBBBBu_uBBBBu_uBBBBu__B_
        _B__uBBBBu_uBBBBu_uBBBBu__B_
        _B__uBBBBu_uBBBBu_uBBBBu__B_
        _B__uBBBBu_uBBBBu_uBBBBu__B_
        _B__uuuuuu_uBBBBu_uuuuuu__B_
        _B_________uBBBBu_________B_
        _B__ssssssspuuuup_ssssss__B_
        _B__s______uBBBBp_s____s__B_
        _B__s______uBBBBp_s____s__B_
        _B__s______uBBBBp_s____s__B_
        _B__s______uBBBBp_s____s__B_
        _B__ssssssspppppp_ssssss__B_
        _B________________________B_
        _B__ssssss_ssssss_________B_
        _B__s____s_s____s_________B_
        _B__s____s_s____s_________B_
        _B__s____s_s____s_________B_
        _B__s____s_s____s_________B_
        _B__ssssss_ssssss_________B_
        _B________________________B_
        _B________________________B_
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border-color: #00f; table-layout: fixed }
      #tbody tr:first-child { background: blue }
      td { border-color: rgba(255, 0, 0, 0.5) }
    '''})


@assert_no_logs
def test_tables_7_rtl(assert_pixels):
    assert_pixels('''
        ____________________________
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        _B________________________B_
        _B________________________B_
        _B__uuuuuu_uuuuuu_uuuuuu__B_
        _B__uBBBBu_uBBBBu_uBBBBu__B_
        _B__uBBBBu_uBBBBu_uBBBBu__B_
        _B__uBBBBu_uBBBBu_uBBBBu__B_
        _B__uBBBBu_uBBBBu_uBBBBu__B_
        _B__uuuuuu_uBBBBu_uuuuuu__B_
        _B_________uBBBBu_________B_
        _B__ssssss_puuuupsssssss__B_
        _B__s____s_pBBBBu______s__B_
        _B__s____s_pBBBBu______s__B_
        _B__s____s_pBBBBu______s__B_
        _B__s____s_pBBBBu______s__B_
        _B__ssssss_ppppppsssssss__B_
        _B________________________B_
        _B_________ssssss_ssssss__B_
        _B_________s____s_s____s__B_
        _B_________s____s_s____s__B_
        _B_________s____s_s____s__B_
        _B_________s____s_s____s__B_
        _B_________ssssss_ssssss__B_
        _B________________________B_
        _B________________________B_
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border-color: #00f; table-layout: fixed; direction: rtl }
      #tbody tr:first-child { background: blue }
      td { border-color: rgba(255, 0, 0, 0.5) }
    '''})


@assert_no_logs
def test_tables_8(assert_pixels):
    assert_pixels('''
        ____________________________
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        _B________________________B_
        _B________________________B_
        _B__uuuuuu_ssssss_ssssss__B_
        _B__uBBBBu_s____s_s____s__B_
        _B__uBBBBu_s____s_s____s__B_
        _B__uBBBBu_s____s_s____s__B_
        _B__uBBBBu_s____s_s____s__B_
        _B__uuuuuu_s____s_ssssss__B_
        _B_________s____s_________B_
        _B__uuuuuuupuuuup_ssssss__B_
        _B__uBBBBBBuBBBBp_s____s__B_
        _B__uBBBBBBuBBBBp_s____s__B_
        _B__uBBBBBBuBBBBp_s____s__B_
        _B__uBBBBBBuBBBBp_s____s__B_
        _B__uuuuuuupppppp_ssssss__B_
        _B________________________B_
        _B__uuuuuu_ssssss_________B_
        _B__uBBBBu_s____s_________B_
        _B__uBBBBu_s____s_________B_
        _B__uBBBBu_s____s_________B_
        _B__uBBBBu_s____s_________B_
        _B__uuuuuu_ssssss_________B_
        _B________________________B_
        _B________________________B_
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border-color: #00f; table-layout: fixed }
      .colgroup col:first-child { background: blue }
      td { border-color: rgba(255, 0, 0, 0.5) }
    '''})


@assert_no_logs
def test_tables_8_rtl(assert_pixels):
    assert_pixels('''
        ____________________________
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        _B________________________B_
        _B________________________B_
        _B__ssssss_ssssss_uuuuuu__B_
        _B__s____s_s____s_uBBBBu__B_
        _B__s____s_s____s_uBBBBu__B_
        _B__s____s_s____s_uBBBBu__B_
        _B__s____s_s____s_uBBBBu__B_
        _B__ssssss_s____s_uuuuuu__B_
        _B_________s____s_________B_
        _B__ssssss_puuuupuuuuuuu__B_
        _B__s____s_pBBBBuBBBBBBu__B_
        _B__s____s_pBBBBuBBBBBBu__B_
        _B__s____s_pBBBBuBBBBBBu__B_
        _B__s____s_pBBBBuBBBBBBu__B_
        _B__ssssss_ppppppuuuuuuu__B_
        _B________________________B_
        _B_________ssssss_uuuuuu__B_
        _B_________s____s_uBBBBu__B_
        _B_________s____s_uBBBBu__B_
        _B_________s____s_uBBBBu__B_
        _B_________s____s_uBBBBu__B_
        _B_________ssssss_uuuuuu__B_
        _B________________________B_
        _B________________________B_
        _BBBBBBBBBBBBBBBBBBBBBBBBBB_
        ____________________________
    ''', tables_source % {'extra_css': '''
      table { border-color: #00f; table-layout: fixed; direction: rtl }
      .colgroup col:first-child { background: blue }
      td { border-color: rgba(255, 0, 0, 0.5) }
    '''})


@assert_no_logs
def test_tables_9(assert_pixels):
    assert_pixels('''
        ______________________
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBB____R____R____BBB_
        _BBB____R____R____BBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        __R_____R____R_____R__
        __R_____R____R_____R__
        __RRRRRRRRRRRRRRRRRR__
        __R_____R____R_____R__
        __R_____R____R_____R__
        __RRRRRRRRRRRRRRRRRR__
        ______________________
        ______________________
        ______________________
        ______________________
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBB____R____R____BBB_
        _BBB____R____R____BBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        __R_____R____R_____R__
        __RRRRRRRRRRRRRRRRRR__
        ______________________
        ______________________
        ______________________
        ______________________
        ______________________
        ______________________
        ______________________
    ''', '''
      <style>
        @page { size: 22px 18px; margin: 1px }
        td { border: 1px red solid; width: 4px; height: 2px; }
      </style>
      <table style="table-layout: fixed; border-collapse: collapse">
        <thead style="border: blue solid; border-width: 3px;
            "><td></td><td></td><td></td></thead>
        <tr><td></td><td></td><td></td></tr>
        <tr><td></td><td></td><td></td></tr>
        <tr><td></td><td></td><td></td></tr>''')


@assert_no_logs
def test_tables_10(assert_pixels):
    assert_pixels('''
        ______________________
        __RRRRRRRRRRRRRRRRRR__
        __R_____R____R_____R__
        __R_____R____R_____R__
        __RRRRRRRRRRRRRRRRRR__
        __R_____R____R_____R__
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBB____R____R____BBB_
        _BBB____R____R____BBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        ______________________
        ______________________
        ______________________
        ______________________
        __RRRRRRRRRRRRRRRRRR__
        __R_____R____R_____R__
        __R_____R____R_____R__
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBB____R____R____BBB_
        _BBB____R____R____BBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        ______________________
        ______________________
        ______________________
        ______________________
        ______________________
    ''', '''
      <style>
        @page { size: 22px 17px; margin: 1px }
        td { border: 1px red solid; width: 4px; height: 2px; }
      </style>
      <table style="table-layout: fixed; margin-left: 1px; border-collapse: collapse">
        <tr><td></td><td></td><td></td></tr>
        <tr><td></td><td></td><td></td></tr>
        <tr><td></td><td></td><td></td></tr>
        <tfoot style="border: blue solid; border-width: 3px;
            "><td></td><td></td><td></td></tfoot>''')


@assert_no_logs
def test_tables_11(assert_pixels):
    # Regression test for #82.
    assert_pixels('''
      ____________________
      ________RRRRRRRRRRR_
      ________R____R____R_
      ________R____R____R_
      ________R____R____R_
      ________RRRRRRRRRRR_
      ____________________
      ____________________
      ____________________
      ____________________
    ''', '''
      <style>
        @page { size: 20px 10px; margin: 1px }
        body { text-align: right; font-size: 0 }
        table { display: inline-table; width: 11px }
        td { border: 1px red solid; width: 4px; height: 3px }
      </style>
      <table style="table-layout: fixed; border-collapse: collapse">
        <tr><td></td><td></td></tr>''')


@assert_no_logs
def test_tables_12(assert_pixels):
    assert_pixels('''
        ____________________________
        _________BBBBBBBBBBBBBBBBBB_
        _________BBBBBBBBBBBBBBBBBB_
        _________BB____s____s____BB_
        _________BB____s____s____BB_
        _________BB____s____s____BB_
        _________BB____s____s____BB_
        _________BBsssss____sssssBB_
        _________BB____s_________BB_
        _________BB____s_________BB_
        _________BB____s_________BB_
        _________BB____s_________BB_
        _________BBssssssssssssssBB_
        _________BB____s____s____BB_
        _________BB____s____s____BB_
        _________BB____s____s____BB_
        _________BB____s____s____BB_
        _________BBBBBBBBBBBBBBBBBB_
        _________BBBBBBBBBBBBBBBBBB_
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
    ''', tables_source % {'extra_css': '''
      body { direction: rtl }
      table { border: 2px solid #00f; table-layout: fixed; border-collapse: collapse }
      td { border-color: #ff7f7f }
    '''})


@assert_no_logs
def test_tables_13(assert_pixels):
    assert_pixels('''
        ____________________________
        _tttttttttttttttttttttttttt_
        _t________________________t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BB____s____s____BB_t_
        _t_____BB____s____s____BB_t_
        _t_____BB____s____s____BB_t_
        _t_____BB____s____s____BB_t_
        _t_____BBsssss____sssssBB_t_
        _t_____BB____s_________BB_t_
        _t_____BB____s_________BB_t_
        _t_____BB____s_________BB_t_
        _t_____BB____s_________BB_t_
        _t_____BBssssssssssssssBB_t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _tttttttttttttttttttttttttt_
        ____________________________
        ____________________________
        _tttttttttttttttttttttttttt_
        _t_____BBssssssssssssssBB_t_
        _t_____BB____s____s____BB_t_
        _t_____BB____s____s____BB_t_
        _t_____BB____s____s____BB_t_
        _t_____BB____s____s____BB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t_____BBBBBBBBBBBBBBBBBB_t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _t________________________t_
        _tttttttttttttttttttttttttt_
        ____________________________
    ''', tables_source % {'extra_css': '''
      body { direction: rtl }
      table { border: solid #00f; border-width: 8px 2px;
              table-layout: fixed; border-collapse: collapse }
      td { border-color: #ff7f7f }
      @page { size: 28px 26px; margin: 1px;
              border: 1px solid rgba(0, 255, 0, 0.5); }
    '''})


@pytest.mark.xfail
@assert_no_logs
def test_tables_14(assert_pixels):
    assert_pixels('''
        ____________________________
        _RRR_RRR_RRR________________
        _RRR_RRR_RRR________________
        _RRR_RRR_RRR________________
        _RRR_RRR_RRR________________
        _RRR_RRR_RRR________________
        _RRR_RRR_RRR________________
        _RRR_RRR_RRR________________
        _RRR_RRR_RRR________________
        _RRR_RRR_RRR________________
        _RRR_RRR_RRR________________
        _____RRR____________________
        _RRRRRRR_RRR________________
        _RRRRRRR_RRR________________
        _RRRRRRR_RRR________________
        _RRRRRRR_RRR________________
        _RRRRRRR_RRR________________
        _RRRRRRR_RRR________________
        _RRRRRRR_RRR________________
        _RRRRRRR_RRR________________
        _RRRRRRR_RRR________________
        _RRRRRRR_RRR________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        _RRR_RRR____________________
        _RRR_RRR____________________
        _RRR_RRR____________________
        _RRR_RRR____________________
        _RRR_RRR____________________
        _RRR_RRR____________________
        _RRR_RRR____________________
        _RRR_RRR____________________
        _RRR_RRR____________________
        _RRR_RRR____________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
        ____________________________
    ''', tables_source % {'extra_css': '''
      @page { size: 28px 26px }
      table { margin: 0; padding: 0; border: 0 }
      col { background: red }
      td { padding: 0; width: 1px; height: 8px }
    '''})


@assert_no_logs
def test_tables_15(assert_pixels):
    # Regression test for #1250.
    assert_pixels('''
        ______________________
        __RRRRRRRRRRRRRRRRRR__
        __R_____R____R_____R__
        __R_____R____R_____R__
        __R_____R____R_____R__
        __RRRRRRRRRRRRRRRRRR__
        __R_____R____R_____R__
        __R_____R____R_____R__
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBB____R____R____BBB_
        _BBB____R____R____BBB_
        _BBB____R____R____BBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        ______________________
        ______________________
        __RRRRRRRRRRRRRRRRRR__
        __R________________R__
        __R________________R__
        __R________________R__
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBB____R____R____BBB_
        _BBB____R____R____BBB_
        _BBB____R____R____BBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        _BBBBBBBBBBBBBBBBBBBB_
        ______________________
        ______________________
        ______________________
        ______________________
    ''', '''
      <style>
        @page { size: 22px 18px; margin: 1px }
        td { border: 1px red solid; width: 4px; height: 3px; }
      </style>
      <table style="table-layout: fixed; margin-left: 1px; border-collapse: collapse">
        <tr><td></td><td></td><td></td></tr>
        <tr><td></td><td></td><td></td></tr>
        <tr><td colspan="3"></td></tr>
        <tfoot style="border: blue solid; border-width: 3px;
            "><td></td><td></td><td></td></tfoot>''')


@assert_no_logs
def test_tables_16(assert_pixels):
    assert_pixels('''
      ____________________
      _RRRRRRRRRRR________
      _R____R____R________
      _R____R____R________
      _R____R_RRRRRRRRRRR_
      _RRRRRRRRRRR_R____R_
      ________R____R____R_
      ________R____R____R_
      ________RRRRRRRRRRR_
      ____________________
    ''', '''
      <style>
        @page { size: 20px 10px; margin: 1px }
        body { text-align: right; font-size: 0 }
        table { position: absolute; width: 11px;
                table-layout: fixed; border-collapse: collapse }
        td { border: 1px red solid; width: 4px; height: 3px }
      </style>
      <table style="top: 0; left: 0">
        <tr><td></td><td></td></tr>
      <table style="bottom: 0; right: 0">
        <tr><td></td><td></td></tr>''')


@assert_no_logs
def test_tables_17(assert_pixels):
    assert_pixels('''
      ________________
      _RRRRRRRRRRRRRR_
      _RRRRRRRRRRRRRR_
      _RR____RR____RR_
      _RR_BB_RR_BB_RR_
      _RR_BB_RR_BB_RR_
      _RR_BB_RR____RR_
      _RR_BB_RR____RR_
      _RR____RR____RR_
      ________________
      ________________
      _RR_BB_RR____RR_
      _RR_BB_RR____RR_
      _RR_BB_RR____RR_
      _RR_BB_RR____RR_
      _RR____RR____RR_
      _RRRRRRRRRRRRRR_
      _RRRRRRRRRRRRRR_
      ________________
      ________________
    ''', '''
      <style>
        @page { size: 16px 10px; margin: 1px }
        table { border-collapse: collapse; font-size: 2px; line-height: 1;
                color: blue; font-family: weasyprint }
        td { border: 2px red solid; padding: 1px; line-height: 1 }
      </style>
      <table><tr><td>a a a a</td><td>a</td></tr>''')


@assert_no_logs
def test_tables_18(assert_pixels):
    assert_pixels('''
      ____________
      _RRRRRRRRRR_
      _R________R_
      _R_RRRRRR_R_
      _R_R____R_R_
      _R_R_BB_R_R_
      _R_R_BB_R_R_
      _R_R_BB_R_R_
      _R_R_BB_R_R_
      _R_R____R_R_
      ____________
      ____________
      _R_R_BB_R_R_
      _R_R_BB_R_R_
      _R_R_BB_R_R_
      _R_R_BB_R_R_
      _R_R____R_R_
      _R_RRRRRR_R_
      _R________R_
      _RRRRRRRRRR_
      ____________
      ____________
    ''', '''
      <style>
        @page { size: 12px 11px; margin: 1px }
        table { border: 1px red solid; border-spacing: 1px; font-size: 2px;
                line-height: 1; color: blue; font-family: weasyprint }
        td { border: 1px red solid; padding: 1px; line-height: 1; }
      </style>
      <table><tr><td>a a a a</td></tr>''')


@assert_no_logs
def test_tables_19(assert_pixels):
    # Regression test for #1523.
    assert_pixels('''
      RR
      RR
      RR
      RR
      RR
      RR
      RR
      RR
    ''', '''
      <style>
        @page { size: 2px 4px }
        table { border-collapse: collapse; color: red }
        body { font-size: 2px; font-family: weasyprint; line-height: 1 }
      </style>
      <table><tr><td>a a a a</td></tr></table>''')


@assert_no_logs
def test_tables_20(assert_pixels):
    assert_pixels('''
      ____________________
      _RRRRRRRRRRRR_______
      _RBBBBBBBBBBR_______
      _RRRRRRRRRRRR_______
      ____________________
    ''', '''
      <style>
        @page { size: 20px 5px; margin: 1px }
        table { width: 10px; border: 1px red solid }
        td { height: 1px; background: blue }
        col, tr, tbody, tfoot { background: lime }
      </style>
      <table>
      <col></col><col></col>
      <tbody><tr></tr><tr><td></td></tr></tbody>
      <tfoot></tfoot>''')


@assert_no_logs
def test_tables_21(assert_pixels):
    assert_pixels('''
      _________________________
      _rrrrrrrrrrrrrrrrrrrrrrr_
      _rBBBBBBBBBBrBBBBBBBBBBr_
      _rBKKKKKKBBBrBKKKKKKBBBr_
      _rBKKKKKKBBBrBKKKKKKBBBr_
      _rBBBBBBBBBBrBBBBBBBBBBr_
      _rrrrrrrrrrrrrrrrrrrrrrr_
      _________________________
      _________________________
      _________________________
      _________________________
      _________________________
      _rrrrrrrrrrrrrrrrrrrrrrr_
      _rBBBBBBBBBBrBBBBBBBBBBr_
      _rBKKKKKKBBBrBBBBBBBBBBr_
      _rBKKKKKKBBBrBBBBBBBBBBr_
      _rBBBBBBBBBBrBBBBBBBBBBr_
      _rrrrrrrrrrrrrrrrrrrrrrr_
      _________________________
      _________________________
      _________________________
      _________________________
    ''', '''
      <style>
        @page { size: 25px 11px; margin: 1px }
        table { border-collapse: collapse; font: 2px weasyprint; width: 100% }
        td { background: blue; padding: 1px; border: 1px solid red }
      </style>
      <table>
        <tr><td>abc</td><td>abc</td></tr>
        <tr><td>abc</td><td></td></tr>''')


@assert_no_logs
def test_tables_22(assert_pixels):
    assert_pixels('''
      _________________________
      _rrrrrrrrrrrrrrrrrrrrrrr_
      _rKKKKKKKKKKrKKKKKKKKKKr_
      _rKKKKKKKKKKrKKKKKKKKKKr_
      _rrrrrrrrrrrrrrrrrrrrrrr_
      _rKKKKKKBBBBrBBBBBBBBBBr_
      _rKKKKKKBBBBrBBBBBBBBBBr_
      _rBBBBBBBBBBrBBBBBBBBBBr_
      _________________________
      _________________________
      _rrrrrrrrrrrrrrrrrrrrrrr_
      _rKKKKKKKKKKrKKKKKKKKKKr_
      _rKKKKKKKKKKrKKKKKKKKKKr_
      _rrrrrrrrrrrrrrrrrrrrrrr_
      _rKKKKKKBBBBrBBBBBBBBBBr_
      _rKKKKKKBBBBrBBBBBBBBBBr_
      _rrrrrrrrrrrrrrrrrrrrrrr_
      _________________________
    ''', '''
      <style>
        @page { size: 25px 9px; margin: 1px }
        table { border-collapse: collapse; font: 2px/1 weasyprint }
        td { background: blue; border: 1px solid red }
      </style>
      <table>
        <thead><tr><td>abcde</td><td>abcde</td></tr></thead>
        <tbody><tr><td>abc abc</td><td></td></tr></tbody>''')


@pytest.mark.xfail
@assert_no_logs
def test_tables_23(assert_pixels):
    assert_pixels('''
      _________________________
      _rrrrrrrrrrrrrrrrrrrrrrr_
      _rKKKKKKKKKKrKKKKKKKKKKr_
      _rKKKKKKKKKKrKKKKKKKKKKr_
      _rrrrrrrrrrrrrrrrrrrrrrr_
      _rKKKKKKBBBBrBBBBBBBBBBr_
      _rKKKKKKBBBBrBBBBBBBBBBr_
      _rBBBBBBBBBBrBBBBBBBBBBr_
      _________________________
      _________________________
      _rrrrrrrrrrrrrrrrrrrrrrr_
      _rKKKKKKKKKKrKKKKKKKKKKr_
      _rKKKKKKKKKKrKKKKKKKKKKr_
      _rKKKKKKBBBBrBBBBBBBBBBr_
      _rKKKKKKBBBBrBBBBBBBBBBr_
      _rrrrrrrrrrrrrrrrrrrrrrr_
      _________________________
      _________________________
    ''', '''
      <style>
        @page { size: 25px 9px; margin: 1px }
        table { border-collapse: collapse; font: 2px/1 weasyprint }
        td { background: blue; border: 1px solid red }
        thead td { border-bottom: none }
      </style>
      <table>
        <thead><tr><td>abcde</td><td>abcde</td></tr></thead>
        <tbody><tr><td>abc abc</td><td></td></tr></tbody>''')


@assert_no_logs
def test_tables_24(assert_pixels):
    assert_pixels('''
        __________________
        _RKKKKgYYYYYYGGG__
        _RKKKKgKKYYKKGGG__
        _BBBBBBKKYYKKGGG__
        _BBBBBBYYYYYYGGG__
        _BBBBBBCCCCCCGGG__
        _BBBBBB___________
        _BBBBBB___________
        __________________
        __________________
    ''', '''
      <style>
        @page { size: 18px 10px }
        table {
          border-collapse: collapse;
          font: 2px/1 weasyprint;
          margin: 1px;
        }
        tr {
          border-left: 1px solid red;
          border-right: 3px solid lime;
        }
        td.left {
          background-color: magenta;
          border-bottom: 5px solid blue;
          border-right: 1px solid green;
        }
        td.right {
          background-color: yellow;
          border-bottom: 1px solid cyan;
          border-left: 1px dotted orange;
        }
        td {
          vertical-align: middle;
        }
      </style>
      <table>
        <tr>
          <td class="left">XX</td>
          <td class="right">X X</td>
        </tr>
      </table>
    ''')


@assert_no_logs
def test_tables_24_rtl(assert_pixels):
    assert_pixels('''
        __________________
        _RKKKKgYYYYYYGGG__
        _RKKKKgKKYYKKGGG__
        _BBBBBBKKYYKKGGG__
        _BBBBBBYYYYYYGGG__
        _BBBBBBCCCCCCGGG__
        _BBBBBB___________
        _BBBBBB___________
        __________________
        __________________
    ''', '''
      <style>
        @page { size: 18px 10px }
        table {
          border-collapse: collapse;
          direction: rtl;
          font: 2px/1 weasyprint;
          margin: 1px;
        }
        tr {
          border-left: 1px solid red;
          border-right: 3px solid lime;
        }
        td.left {
          background-color: magenta;
          border-bottom: 5px solid blue;
          border-right: 1px solid green;
        }
        td.right {
          background-color: yellow;
          border-bottom: 1px solid cyan;
          border-left: 1px dotted orange;
        }
        td {
          vertical-align: middle;
        }
      </style>
      <table>
        <tr>
          <td class="right">X X</td>
          <td class="left">XX</td>
        </tr>
      </table>
    ''')


@assert_no_logs
def test_running_elements_table_border_collapse(assert_pixels):
    assert_pixels(2 * '''
      KK_____________
      KK_____________
      _______________
      _______________
      _______________
      KKKKKKK________
      KRRKRRK________
      KRRKRRK________
      KKKKKKK________
      KRRKRRK________
      KRRKRRK________
      KKKKKKK________
      _______________
      _______________
      _______________
    ''', '''
      <style>
        @page {
          margin: 0 0 10px 0;
          size: 15px;
          @bottom-left { content: element(table) }
        }
        body { font: 2px/1 weasyprint }
        table {
          border: 1px solid black;
          border-collapse: collapse;
          color: red;
          position: running(table);
        }
        td { border: 1px solid black }
        div { page-break-after: always }
      </style>
      <table>
        <tr> <td>A</td> <td>B</td> </tr>
        <tr> <td>C</td> <td>D</td> </tr>
      </table>
      <div>1</div>
      <div>2</div>
    ''')


@assert_no_logs
def test_running_elements_table_border_collapse_empty(assert_pixels):
    assert_pixels(2 * '''
      KK________
      KK________
      __________
      __________
      __________
      __________
      __________
      __________
      __________
      __________
    ''', '''
      <style>
        @page {
          margin: 0 0 5px 0;
          size: 10px;
          @bottom-left { content: element(table) }
        }
        body { font: 2px/1 weasyprint }
        table {
          border: 1px solid black;
          border-collapse: collapse;
          color: red;
          position: running(table);
        }
        td { border: 1px solid black }
        div { page-break-after: always }
      </style>
      <table></table>
      <div>1</div>
      <div>2</div>
    ''')


@pytest.mark.xfail
@assert_no_logs
def test_running_elements_table_border_collapse_border_style(assert_pixels):
    assert_pixels(2 * '''
      KK_____________
      KK_____________
      _______________
      _______________
      _______________
      KKKZ___________
      KRR_RR_________
      KRR_RR_________
      KKKK__Z________
      KRRKRRK________
      KRRKRRK________
      KKKKKKK________
      _______________
      _______________
      _______________
    ''', '''
      <style>
        @page {
          margin: 0 0 10px 0;
          size: 15px;
          @bottom-left { content: element(table) }
        }
        body { font: 2px/1 weasyprint }
        table {
          border: 1px solid black;
          border-collapse: collapse;
          color: red;
          position: running(table);
        }
        td { border: 1px solid black }
        div { page-break-after: always }
      </style>
      <table>
        <tr> <td>A</td> <td style="border-style: hidden">B</td> </tr>
        <tr> <td>C</td> <td style="border-style: none">D</td> </tr>
      </table>
      <div>1</div>
      <div>2</div>
    ''')


@assert_no_logs
def test_running_elements_table_border_collapse_span(assert_pixels):
    assert_pixels(2 * '''
      KK_____________
      KK_____________
      _______________
      _______________
      _______________
      KKKKKKKKKK_____
      KRRKRRKRRK_____
      KRRKRRKRRK_____
      K__KKKKKKK_____
      K__KRR___K_____
      K__KRR___K_____
      KKKKKKKKKK_____
      _______________
      _______________
      _______________
    ''', '''
      <style>
        @page {
          margin: 0 0 10px 0;
          size: 15px;
          @bottom-left { content: element(table) }
        }
        body { font: 2px/1 weasyprint }
        table {
          border: 1px solid black;
          border-collapse: collapse;
          color: red;
          position: running(table);
        }
        td { border: 1px solid black }
        div { page-break-after: always }
      </style>
      <table>
        <tr> <td rowspan=2>A</td> <td>B</td> <td>C</td> </tr>
        <tr> <td colspan=2>D</td> </tr>
      </table>
      <div>1</div>
      <div>2</div>
    ''')


@assert_no_logs
def test_running_elements_table_border_collapse_margin(assert_pixels):
    assert_pixels(2 * '''
      KK_____________
      KK_____________
      _______________
      _______________
      _______________
      _______________
      ____KKKKKKK____
      ____KRRKRRK____
      ____KRRKRRK____
      ____KKKKKKK____
      ____KRRKRRK____
      ____KRRKRRK____
      ____KKKKKKK____
      _______________
      _______________
    ''', '''
      <style>
        @page {
          margin: 0 0 10px 0;
          size: 15px;
          @bottom-center { content: element(table); width: 100% }
        }
        body { font: 2px/1 weasyprint }
        table {
          border: 1px solid black;
          border-collapse: collapse;
          color: red;
          margin: 1px auto;
          position: running(table);
        }
        td { border: 1px solid black }
        div { page-break-after: always }
      </style>
      <table>
        <tr> <td>A</td> <td>B</td> </tr>
        <tr> <td>C</td> <td>D</td> </tr>
      </table>
      <div>1</div>
      <div>2</div>
    ''')


@assert_no_logs
def test_tables_split_row(assert_pixels):
    assert_pixels('''
      KKKKKKKK
      KRRKKRRK
      KRRKKRRK
      K__KK__K

      K__KKRRK
      K__KKRRK
      KKKKKKKK
      ________
    ''', '''
      <style>
        @page { margin: 0; size: 8px 4px }
        td { border: 1px solid black; color: red; vertical-align: top;
             font-family: weasyprint; font-size: 2px; line-height: 1 }
      </style>
      <table>
        <tr>
          <td>a</td>
          <td>a<br>a</td>
        </tr>
      </table>''')


@assert_no_logs
def test_tables_column_background(assert_pixels):
    # Regression test for #2296.
    assert_pixels('''
      KKKKKKKK
      KRRBBRRK
      KRRBBRRK
      KKKKKKKK

      KKKKKKKK
      KRRBBRRK
      KRRBBRRK
      KKKKKKKK
    ''', '''
      <style>
        @page { margin: 0; size: 8px 4px }
        col { background: blue }
        td { border: 1px solid black; color: red; vertical-align: top;
             font-family: weasyprint; font-size: 2px; line-height: 1 }
      </style>
      <table>
        <colgroup>
          <col>
        </colgroup>
        <tr>
          <td>a a</td>
        </tr>
        <tr>
          <td>a a</td>
        </tr>
      </table>''')


================================================
FILE: tests/draw/test_text.py
================================================
"""Test how text is drawn."""

import pytest

from weasyprint.text.ffi import pango

from ..testing_utils import SANS_FONTS


def test_text_overflow_clip(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRRR_
        _RRRRRRR_
        _________
        _RR__RRR_
        _RR__RRR_
        _________
    ''', '''
      <style>
        @page {
          size: 9px 7px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
        }
        div {
          line-height: 1;
          margin: 1px;
          overflow: hidden;
          width: 3.5em;
        }
      </style>
      <div>abcde</div>
      <div style="white-space: nowrap">a bcde</div>''')


def test_text_overflow_ellipsis(assert_pixels):
    assert_pixels('''
        _________
        _RRRRRR__
        _RRRRRR__
        _________
        _RR__RR__
        _RR__RR__
        _________
        _RRRRRR__
        _RRRRRR__
        _________
        _RRRRRRR_
        _RRRRRRR_
        _________
        _RRRRRRR_
        _RRRRRRR_
        _________
    ''', '''
      <style>
        @page {
          size: 9px 16px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
        }
        div {
          line-height: 1;
          margin: 1px;
          overflow: hidden;
          text-overflow: ellipsis;
          width: 3.5em;
        }
        div div {
          margin: 0;
        }
      </style>
      <div>abcde</div>
      <div style="white-space: nowrap">a bcde</div>
      <div><span>a<span>b</span>cd</span>e</div>
      <div><div style="text-overflow: clip">abcde</div></div>
      <div><div style="overflow: visible">abcde</div></div>
''')


def test_text_align_rtl_trailing_whitespace(assert_pixels):
    # Test text alignment for rtl text with trailing space.
    # Regression test for #1111.
    assert_pixels('''
        _________
        _rrrrBBB_
        _________
        _rrrrBBB_
        _________
        _BBBrrrr_
        _________
        _BBBrrrr_
        _________
    ''', '''
      <style>
        @page { size: 9px }
        body { font-family: weasyprint; color: blue; font-size: 1px }
        p { background: red; line-height: 1; width: 7em; margin: 1em }
      </style>
      <!-- &#8207 forces Unicode RTL direction for the following chars -->
      <p style="direction: rtl"> abc </p>
      <p style="direction: rtl"> &#8207;abc </p>
      <p style="direction: ltr"> abc </p>
      <p style="direction: ltr"> &#8207;abc </p>
    ''')


def test_rtl_default_direction(assert_pixels):
    assert_pixels('''
        _____BBBBB_____
        _____BBBBB_____
        _____BBBBB_____
        _____BBBBB_____
        BBBBBBBBBB_____
    ''', '''
      <style>
        @page { size: 15px 5px }
        body { font-family: weasyprint; color: blue; font-size: 5px; line-height: 1 }
      </style>
      اب
    ''')


def test_rtl_forced_direction(assert_pixels):
    assert_pixels('''
        __________BBBBB
        __________BBBBB
        __________BBBBB
        __________BBBBB
        _____BBBBBBBBBB
    ''', '''
      <style>
        @page { size: 15px 5px }
        body { font-family: weasyprint; color: blue; font-size: 5px; line-height: 1 }
      </style>
      <div style="direction: rtl">اب</div>
    ''')


def test_rtl_nested_inline(assert_pixels):
    assert_pixels('''
        RRRRR________________BBBBB___________RRRRR___________BBBBB
        RRRRR________________BBBBB___________RRRRR___________BBBBB
        RRRRR________________BBBBB___________RRRRR___________BBBBB
        RRRRR________________BBBBB___________RRRRR___________BBBBB
        RRRRRRRRRR______BBBBBBBBBB______RRRRRRRRRR______BBBBBBBBBB
        ______________________________________BBBBB__________RRRRR
        ______________________________________BBBBB__________RRRRR
        ______________________________________BBBBB__________RRRRR
        ______________________________________BBBBB__________RRRRR
        _________________________________BBBBBBBBBB_____RRRRRRRRRR
    ''', '''
      <style>
        @page { size: 58px 10px }
        body { font-family: weasyprint; color: blue; font-size: 5px; line-height: 1 }
        span { color: red }
      </style>
      <div style="direction: rtl; text-align: justify">
        اب <span>اب</span> اب <span>با اب</span> اب
      </div>
    ''')


def test_max_lines_ellipsis(assert_pixels):
    assert_pixels('''
        BBBBBBBB__
        BBBBBBBB__
        BBBBBBBBBB
        BBBBBBBBBB
        __________
        __________
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page {size: 10px 10px;}
        p {
          block-ellipsis: auto;
          color: blue;
          font-family: weasyprint;
          font-size: 2px;
          max-lines: 2;
        }
      </style>
      <p>
        abcd efgh ijkl
      </p>
    ''')


@pytest.mark.xfail
def test_max_lines_nested(assert_pixels):
    assert_pixels('''
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        BBBBBBBBBB
        rrrrrrrrrr
        rrrrrrrrrr
        rrrrrrrrrr
        rrrrrrrrrr
        BBBBBBBBBB
        BBBBBBBBBB
        __________
        __________
    ''', '''
      <style>
        @page {size: 10px 12px;}
        div {
          continue: discard;
          font-family: weasyprint;
          font-size: 2px;
        }
        #a {
          color: blue;
          max-lines: 5;
        }
        #b {
          color: red
          max-lines: 2;
        }
      </style>
      <div id=a>
        aaaaa
        aaaaa
        <div id=b>
          bbbbb
          bbbbb
          bbbbb
          bbbbb
        </div>
        aaaaa
        aaaaa
      </div>
    ''')


def test_line_clamp(assert_pixels):
    assert_pixels('''
        BBBB__BB__
        BBBB__BB__
        BBBB__BB__
        BBBB__BB__
        BBBBBBBBBB
        BBBBBBBBBB
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page {size: 10px 10px;}
        p {
          color: blue;
          font-family: weasyprint;
          font-size: 2px;
          line-clamp: 3 "(…)";
        }
      </style>

      <p>
        aa a
        bb b
        cc c
        dddd
        eeee
        ffff
        gggg
        hhhh
      </p>
    ''')


def test_line_clamp_none(assert_pixels):
    assert_pixels('''
        BBBB__BB__
        BBBB__BB__
        BBBB__BB__
        BBBB__BB__
        BBBB__BB__
        BBBB__BB__
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page {size: 10px 10px;}
        p {
          color: blue;
          font-family: weasyprint;
          font-size: 2px;
          max-lines: 1;
          continue: discard;
          block-ellipsis: "…";
          line-clamp: none;
        }
      </style>

      <p>
        aa a
        bb b
        cc c
      </p>
    ''')


def test_line_clamp_number(assert_pixels):
    assert_pixels('''
        BBBB__BB__
        BBBB__BB__
        BBBB__BB__
        BBBB__BB__
        BBBB__BBBB
        BBBB__BBBB
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page {size: 10px 10px;}
        p {
          color: blue;
          font-family: weasyprint;
          font-size: 2px;
          line-clamp: 3;
        }
      </style>

      <p>
        aa a
        bb b
        cc c
        dddd
        eeee
      </p>
    ''')


def test_line_clamp_nested(assert_pixels):
    assert_pixels('''
        BBBB__BB__
        BBBB__BB__
        BBBB__BB__
        BBBB__BB__
        BBBBBBBBBB
        BBBBBBBBBB
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page {size: 10px 10px;}
        div {
          color: blue;
          font-family: weasyprint;
          font-size: 2px;
          line-clamp: 3 "(…)";
        }
      </style>

      <div>
        aa a
        <p>
          bb b
          cc c
          dddd
          eeee
          ffff
          gggg
          hhhh
        </p>
      </div>
    ''')


def test_line_clamp_nested_after(assert_pixels):
    assert_pixels('''
        BBBB__BB__
        BBBB__BB__
        BBBB__BB__
        BBBB__BB__
        BBBBBBBBBB
        BBBBBBBBBB
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page {size: 10px 10px;}
        div {
          color: blue;
          font-family: weasyprint;
          font-size: 2px;
          line-clamp: 3 "(…)";
        }
      </style>

      <div>
        aa a
        <p>
          bb b
        </p>
        cc c
        dddd
        eeee
        ffff
        gggg
        hhhh
      </div>
    ''')


@pytest.mark.xfail
def test_ellipsis_nested(assert_pixels):
    assert_pixels('''
        BBBBBB____
        BBBBBB____
        BBBBBB____
        BBBBBB____
        BBBBBB____
        BBBBBB____
        BBBBBB____
        BBBBBB____
        BBBBBBBB__
        BBBBBBBB__
    ''', '''
      <style>
        @page {size: 10px 10px;}
        div {
          block-ellipsis: auto;
          color: blue;
          continue: discard;
          font-family: weasyprint;
          font-size: 2px;
        }
      </style>
      <div>
        <p>aaa</p>
        <p>aaa</p>
        <p>aaa</p>
        <p>aaa</p>
        <p>aaa</p>
        <p>aaa</p>
      </div>
    ''')


def test_text_align_right(assert_pixels):
    assert_pixels('''
        _________
        __RR__RR_
        __RR__RR_
        ______RR_
        ______RR_
        _________
    ''', '''
      <style>
        @page {
          size: 9px 6px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
        }
        div {
          line-height: 1;
          margin: 1px;
          text-align: right;
        }
      </style>
      <div>a c e</div>''')


def test_text_align_justify(assert_pixels):
    assert_pixels('''
        _________
        _RR___RR_
        _RR___RR_
        _RR______
        _RR______
        _________
    ''', '''
      <style>
        @page {
          size: 9px 6px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
        }
        div {
          line-height: 1;
          margin: 1px;
          text-align: justify;
        }
      </style>
      <div>a c e</div>''')


def test_text_align_justify_nbsp(assert_pixels):
    assert_pixels('''
        ___________________
        _RR___RR___RR___RR_
        _RR___RR___RR___RR_
        ___________________
    ''', '''
      <style>
        @page {
          size: 19px 4px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
        }
        div {
          line-height: 1;
          margin: 1px;
          text-align: justify-all;
        }
      </style>
      <div>a b&nbsp;c&nbsp;d</div>''')


def test_text_word_spacing(assert_pixels):
    assert_pixels('''
        ___________________
        _RR____RR____RR____
        _RR____RR____RR____
        ___________________
    ''', '''
      <style>
        @page {
          size: 19px 4px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
        }
        div {
          line-height: 1;
          margin: 1px;
          word-spacing: 1em;
        }
      </style>
      <div>a c e</div>''')


def test_text_letter_spacing(assert_pixels):
    assert_pixels('''
        ___________________
        _RR____RR____RR____
        _RR____RR____RR____
        ___________________
    ''', '''
      <style>
        @page {
          size: 19px 4px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
        }
        div {
          line-height: 1;
          margin: 1px;
          letter-spacing: 2em;
        }
      </style>
      <div>ace</div>''')


def test_text_underline(assert_pixels):
    assert_pixels('''
        _____________
        _zzzzzzzzzzz_
        _zsssssssssz_
        _zsssssssssz_
        _zuuuuuuuuuz_
        _zzzzzzzzzzz_
        _____________
    ''', '''
      <style>
        @page {
          size: 13px 7px;
          margin: 2px;
        }
        body {
          color: rgba(255, 0, 0, 0.5);
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: underline blue auto;
        }
      </style>
      <div>abc</div>''')


def test_text_underline_offset(assert_pixels):
    assert_pixels('''
        _____________
        _zzzzzzzzzzz_
        _zRRRRRRRRRz_
        _zRRRRRRRRRz_
        _zzzzzzzzzzz_
        _zzzzzzzzzzz_
        _zBBBBBBBBBz_
        _zzzzzzzzzzz_
        _____________
    ''', '''
      <style>
        @page {
          size: 13px 9px;
          margin: 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: underline blue;
          text-underline-offset: 2px;
        }
      </style>
      <div>abc</div>''')


def test_text_underline_offset_percentage(assert_pixels):
    assert_pixels('''
        _____________
        _zzzzzzzzzzz_
        _zRRRRRRRRRz_
        _zRRRRRRRRRz_
        _zzzzzzzzzzz_
        _zzzzzzzzzzz_
        _zBBBBBBBBBz_
        _zzzzzzzzzzz_
        _____________
    ''', '''
      <style>
        @page {
          size: 13px 9px;
          margin: 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: underline blue;
          text-underline-offset: 70%;
        }
      </style>
      <div>abc</div>''')


def test_text_underline_offset_calc(assert_pixels):
    assert_pixels('''
        _____________
        _zzzzzzzzzzz_
        _zRRRRRRRRRz_
        _zRRRRRRRRRz_
        _zzzzzzzzzzz_
        _zzzzzzzzzzz_
        _zBBBBBBBBBz_
        _zzzzzzzzzzz_
        _____________
    ''', '''
      <style>
        @page {
          size: 13px 9px;
          margin: 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: underline blue;
          text-underline-offset: calc(0.5em + 20%);
        }
      </style>
      <div>abc</div>''')


def test_text_underline_thickness(assert_pixels):
    assert_pixels('''
        _____________
        _zzzzzzzzzzz_
        _zRRRRRRRRRz_
        _zRRRRRRRRRz_
        _zzzzzzzzzzz_
        _zzzzzzzzzzz_
        _zBBBBBBBBBz_
        _zBBBBBBBBBz_
        _zzzzzzzzzzz_
    ''', '''
      <style>
        @page {
          size: 13px 9px;
          margin: 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: underline blue 3px;
          text-underline-offset: 2px;
        }
      </style>
      <div>abc</div>''')


def test_text_underline_thickness_percentage(assert_pixels):
    assert_pixels('''
        _____________
        _zzzzzzzzzzz_
        _zRRRRRRRRRz_
        _zRRRRRRRRRz_
        _zzzzzzzzzzz_
        _zzzzzzzzzzz_
        _zBBBBBBBBBz_
        _zBBBBBBBBBz_
        _zzzzzzzzzzz_
    ''', '''
      <style>
        @page {
          size: 13px 9px;
          margin: 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: underline blue 100%;
          text-underline-offset: 2px;
        }
      </style>
      <div>abc</div>''')


def test_text_underline_thickness_calc(assert_pixels):
    assert_pixels('''
        _____________
        _zzzzzzzzzzz_
        _zRRRRRRRRRz_
        _zRRRRRRRRRz_
        _zzzzzzzzzzz_
        _zzzzzzzzzzz_
        _zBBBBBBBBBz_
        _zBBBBBBBBBz_
        _zzzzzzzzzzz_
    ''', '''
      <style>
        @page {
          size: 13px 9px;
          margin: 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: underline blue calc(0.5em + 50%);
          text-underline-offset: 2px;
        }
      </style>
      <div>abc</div>''')


def test_text_overline(assert_pixels):
    # Ascent value seems to be a bit random, don’t try to get the exact
    # position of the line
    assert_pixels('''
        _____________
        _zzzzzzzzzzz_
        _zzzzzzzzzzz_
        _zsssssssssz_
        _zsssssssssz_
        _zzzzzzzzzzz_
        _____________
    ''', '''
      <style>
        @page {
          size: 13px 7px;
          margin: 2px;
        }
        body {
          color: rgba(255, 0, 0, 0.5);
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: overline blue;
        }
      </style>
      <div>abc</div>''')


def test_text_line_through(assert_pixels):
    assert_pixels('''
        _____________
        _zzzzzzzzzzz_
        _zBBBBBBBBBz_
        _zuuuuuuuuuz_
        _zBBBBBBBBBz_
        _zzzzzzzzzzz_
        _____________
    ''', '''
      <style>
        @page {
          size: 13px 7px;
          margin: 2px;
        }
        body {
          color: blue;
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: line-through rgba(255, 0, 0, 0.5);
        }
      </style>
      <div>abc</div>''')


def test_text_multiple_text_decoration(assert_pixels):
    # Regression test for #1621.
    assert_pixels('''
        _____________
        _zzzzzzzzzzz_
        _zsssssssssz_
        _zBBBBBBBBBz_
        _zuuuuuuuuuz_
        _zzzzzzzzzzz_
        _____________
    ''', '''
      <style>
        @page {
          size: 13px 7px;
          margin: 2px;
        }
        body {
          color: rgba(255, 0, 0, 0.5);
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: underline line-through blue;
        }
      </style>
      <div>abc</div>''')


def test_text_nested_text_decoration(assert_pixels):
    # Regression test for #1621.
    assert_pixels('''
        _____________
        _zzzzzzzzzzz_
        _zsssssssssz_
        _zsssBBBsssz_
        _zuuuuuuuuuz_
        _zzzzzzzzzzz_
        _____________
    ''', '''
      <style>
        @page {
          size: 13px 7px;
          margin: 2px;
        }
        body {
          color: rgba(255, 0, 0, 0.5);
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: underline blue;
        }
        span {
          text-decoration: line-through blue;
        }
      </style>
      <div>a<span>b</span>c</div>''')


@pytest.mark.xfail
def test_text_nested_text_decoration_color(assert_pixels):
    # See weasyprint.css.text_decoration’s TODO
    assert_pixels('''
        _____________
        _zzzzzzzzzzz_
        _zRRRRRRRRRz_
        _zRRRGGGRRRz_
        _zBBBBBBBBBz_
        _zzzzzzzzzzz_
        _____________
    ''', '''
      <style>
        @page {
          size: 13px 7px;
          margin: 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: underline blue;
        }
        span {
          text-decoration: line-through lime;
        }
      </style>
      <div>a<span>b</span>c</div>''')


@pytest.mark.xfail
def test_text_nested_block_text_decoration(assert_pixels):
    # See weasyprint.css.text_decoration’s TODO
    assert_pixels('''
        _______
        _zzzzz_
        _zRRRz_
        _zRRRz_
        _zBBBz_
        _zRRRz_
        _zGGGz_
        _zBBBz_
        _zRRRz_
        _zRRRz_
        _zBBBz_
        _zzzzz_
        _______
    ''', '''
      <style>
        @page {
          size: 7px 13px;
          margin: 2px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: underline blue;
        }
        article {
          text-decoration: line-through lime;
        }
      </style>
      <div>a<article>b</article>c</div>''')


@pytest.mark.xfail
def test_text_float_text_decoration(assert_pixels):
    # See weasyprint.css.text_decoration’s TODO
    assert_pixels('''
        _____________
        _zzzzz_______
        _zRRRz__RRR__
        _zRRRz__RRR__
        _zBBBz__RRR__
        _zzzzz_______
        _____________
    ''', '''
      <style>
        @page {
          size: 13px 7px;
          margin: 2px;
        }
        div {
          color: red;
          font-family: weasyprint;
          font-size: 3px;
          text-decoration: underline blue;
        }
        span {
          float: right;
        }
      </style>
      <div>a<span>b</span></div>''')


def test_text_decoration_var(assert_pixels):
    # Regression test for #1697.
    assert_pixels('''
        _____________
        _zzzzzzzzzzz_
        _zRRRRRRRRRz_
        _zBBBBBBBBBz_
        _zRRRRRRRRRz_
        _zzzzzzzzzzz_
        _____________
    ''', '''
      <style>
        @page {
          size: 13px 7px;
          margin: 2px;
        }
        body {
          --blue: blue;
          color: red;
          font-family: weasyprint;
          font-size: 3px;
          text-decoration-color: var(--blue);
          text-decoration-line: line-through;
        }
      </style>
      <div>abc</div>''')


def test_zero_width_character(assert_pixels):
    # Regression test for #1508.
    assert_pixels('''
        ______
        _RRRR_
        _RRRR_
        ______
    ''', '''
      <style>
        @page {
          size: 6px 4px;
          margin: 1px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
      </style>
      <div>a&zwnj;b</div>''')


def test_font_size_very_small(assert_pixels):
    assert_pixels('''
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page {
          size: 10px 4px;
          margin: 1px;
        }
        body {
          font-family: weasyprint;
          font-size: 0.00000001px;
        }
      </style>
      test font size zero
    ''')


def test_missing_glyph_fallback(assert_pixels):
    # The apostrophe is not included in weasyprint.otf
    assert_pixels('''
        ___zzzzzzzzzzzzzzzzz
        _RRzzzzzzzzzzzzzzzzz
        _RRzzzzzzzzzzzzzzzzz
        ___zzzzzzzzzzzzzzzzz
    ''', '''
      <style>
        @page {
          size: 20px 4px;
        }
        body {
          color: red;
          font-family: weasyprint, %s;
          font-size: 2px;
          line-height: 0;
          margin: 2px 1px;
        }
      </style>a\'''' % SANS_FONTS)


def test_tabulation_character(assert_pixels):
    # Regression test for #1515.
    assert_pixels('''
        __________
        _RR____RR_
        _RR____RR_
        __________
    ''', '''
      <style>
        @page {
          size: 10px 4px;
          margin: 1px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
          tab-size: 3;
        }
      </style>
      <pre>a&Tab;b</pre>''')


def test_otb_font(assert_pixels):
    assert_pixels('''
        ____________________
        __RR______RR________
        __RR__RR__RR________
        __RR__RR__RR________
        ____________________
        ____________________
    ''', '''
      <style>
        @page {
          size: 20px 6px;
          margin: 1px;
        }
        @font-face {
          src: url(weasyprint.otb);
          font-family: weasyprint-otb;
        }
        body {
          color: red;
          font-family: weasyprint-otb;
          font-size: 4px;
          line-height: 0.8;
        }
      </style>
      AaA''')


def test_huge_justification(assert_pixels):
    # Regression test for #2262.
    assert_pixels('''
        ____
        _RR_
        _RR_
        ____
    ''', '''
      <style>
        @page {
          size: 4px 4px;
          margin: 1px;
        }
        body {
          color: red;
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
          text-align: justify-all;
          width: 100000px;
        }
      </style>
      A B''')


def test_font_variant_caps_small(assert_pixels):
    assert_pixels('''
        ________
        _BB_BB__
        _BB_B_B_
        _B__BB__
        _B__B___
        ________
    ''', '''
      <style>
        @page {size: 8px 6px}
        p {
          color: blue;
          font-variant-caps: small-caps;
          font-family: %s;
          font-size: 6px;
          line-height: 1;
        }
      </style>
      <p>Pp</p>
    ''' % SANS_FONTS)


def test_font_variant_caps_all_small(assert_pixels):
    assert_pixels('''
        ________
        BB_BB___
        B_BB_B__
        BB_BB___
        B__B____
        ________
    ''', '''
      <style>
        @page {size: 8px 6px}
        p {
          color: blue;
          font-variant-caps: all-small-caps;
          font-family: %s;
          font-size: 6px;
          line-height: 1;
        }
      </style>
      <p>Pp</p>
    ''' % SANS_FONTS)


def test_font_variant_caps_petite(assert_pixels):
    assert_pixels('''
        ________
        _BB_BB__
        _BB_B_B_
        _B__BB__
        _B__B___
        ________
    ''', '''
      <style>
        @page {size: 8px 6px}
        p {
          color: blue;
          font-variant-caps: petite-caps;
          font-family: %s;
          font-size: 6px;
          line-height: 1;
        }
      </style>
      <p>Pp</p>
    ''' % SANS_FONTS)


# Bug in Pango: https://gitlab.gnome.org/GNOME/pango/-/merge_requests/875
@pytest.mark.xfail(pango.pango_version() == 15604, reason='Bug in Pango 1.56.4')
def test_font_variant_caps_all_petite(assert_pixels):
    assert_pixels('''
        ________
        BB_BB___
        B_BB_B__
        BB_BB___
        B__B____
        ________
    ''', '''
      <style>
        @page {size: 8px 6px}
        p {
          color: blue;
          font-variant-caps: all-petite-caps;
          font-family: %s;
          font-size: 6px;
          line-height: 1;
        }
      </style>
      <p>Pp</p>
    ''' % SANS_FONTS)


def test_font_variant_caps_unicase(assert_pixels):
    assert_pixels('''
        ________
        BB______
        B_B_BB__
        BB__B_B_
        B___BB__
        ____B___
    ''', '''
      <style>
        @page {size: 8px 6px}
        p {
          color: blue;
          font-variant-caps: unicase;
          font-family: %s;
          font-size: 6px;
          line-height: 1;
        }
      </style>
      <p>Pp</p>
    ''' % SANS_FONTS)


def test_font_variant_caps_titling(assert_pixels):
    assert_pixels('''
        _BB_____
        _BB_____
        _BB__BB_
        _B___B_B
        _____BB_
        _____B__
    ''', '''
      <style>
        @page {size: 8px 6px}
        p {
          color: blue;
          font-family: %s;
          font-size: 6px;
          line-height: 1;
        }
      </style>
      <p>Pp</p>
    ''' % SANS_FONTS)


def test_unicode_range(assert_pixels):
    assert_pixels('''
        __________
        _RRRRRR___
        _RRRRRRzz_
        __________
    ''', '''
      <style>
        @font-face {
          font-family: uni;
          src: url(weasyprint.otf);
          unicode-range: u+41, u+043-045, u+005?;
        }
        @page {
          size: 10px 4px;
        }
        body {
          color: red;
          font-family: uni;
          font-size: 2px;
          line-height: 0;
          margin: 2px 1px;
        }
      </style>ADZB''')


================================================
FILE: tests/draw/test_transform.py
================================================
"""Test transformations."""

from ..testing_utils import assert_no_logs


@assert_no_logs
def test_2d_transform_1(assert_pixels):
    assert_pixels('''
        __________
        __________
        __BBBr____
        __BBBB____
        __BBBB____
        __BBBB____
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page { size: 10px; margin: 2px }
        body { font-size: 0 }
        img { transform: rotate(90deg) }
      </style>
      <body><img src="pattern.png">''')


@assert_no_logs
def test_2d_transform_2(assert_pixels):
    assert_pixels('''
        __________
        __________
        _____BBBr_
        _____BBBB_
        _____BBBB_
        _____BBBB_
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page { size: 10px; margin: 2px }
        body { font-size: 0 }
        img { transform: translateX(3px) rotate(90deg) }
      </style>
      <body><img src="pattern.png">''')


@assert_no_logs
def test_2d_transform_3(assert_pixels):
    # A translateX after the rotation is actually a translateY
    assert_pixels('''
        __________
        __________
        __________
        __________
        __________
        __BBBr____
        __BBBB____
        __BBBB____
        __BBBB____
        __________
    ''', '''
      <style>
        @page { size: 10px; margin: 2px }
        body { font-size: 0 }
        img { transform: rotate(90deg) translateX(3px) }
      </style>
      <body><img src="pattern.png">''')


@assert_no_logs
def test_2d_transform_4(assert_pixels):
    assert_pixels('''
        __________
        __________
        __________
        __________
        __________
        __BBBr____
        __BBBB____
        __BBBB____
        __BBBB____
        __________
    ''', '''
      <style>
        @page { size: 10px; margin: 2px }
        div { transform: rotate(90deg); font-size: 0; width: 4px }
        img { transform: translateX(3px) }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_2d_transform_5(assert_pixels):
    assert_pixels('''
        ________
        ________
        __BBBr__
        __BBBB__
        __BBBB__
        __BBBB__
        ________
        ________
    ''', '''
      <style>
        @page { size: 8px; margin: 2px; }
        div { transform: matrix(-1, 0, 0, 1, 0, 0); font-size: 0 }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_2d_transform_6(assert_pixels):
    assert_pixels('''
        ________
        ________
        ________
        ________
        ___rBBB_
        ___BBBB_
        ___BBBB_
        ___BBBB_
    ''', '''
      <style>
        @page { size: 8px; margin: 2px; }
        div { transform: translate(1px, 2px); font-size: 0 }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_2d_transform_7(assert_pixels):
    assert_pixels('''
        ________
        ________
        ___rBBB_
        ___BBBB_
        ___BBBB_
        ___BBBB_
        ________
        ________
    ''', '''
      <style>
        @page { size: 8px; margin: 2px; }
        div { transform: translate(25%, 0); font-size: 0 }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_2d_transform_8(assert_pixels):
    assert_pixels('''
        ________
        ________
        _____rBB
        _____BBB
        _____BBB
        _____BBB
        ________
        ________
    ''', '''
      <style>
        @page { size: 8px; margin: 2px; }
        div { transform: translateX(0.25em); font-size: 12px }
        div div { font-size: 0 }
      </style>
      <div><div><img src="pattern.png"></div></div>''')


@assert_no_logs
def test_2d_transform_9(assert_pixels):
    assert_pixels('''
        ________
        __rBBB__
        __BBBB__
        __BBBB__
        __BBBB__
        ________
        ________
        ________
    ''', '''
      <style>
        @page { size: 8px; margin: 2px; }
        div { transform: translateY(-1px); font-size: 0 }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_2d_transform_10(assert_pixels):
    assert_pixels('''
        __________
        _rrBBBBBB_
        _rrBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        __________
    ''', '''
      <style>
        @page { size: 10px; margin: 2px; }
        div { transform: scale(2, 2);
              transform-origin: 1px 1px 1px;
              image-rendering: pixelated;
              font-size: 0 }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_2d_transform_11(assert_pixels):
    assert_pixels('''
        __________
        __rBBB____
        __rBBB____
        __BBBB____
        __BBBB____
        __BBBB____
        __BBBB____
        __BBBB____
        __BBBB____
        __________
    ''', '''
      <style>
        @page { size: 10px; margin: 2px; }
        div { transform: scale(1, 2);
              transform-origin: 1px 1px;
              image-rendering: pixelated;
              font-size: 0 }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_2d_transform_12(assert_pixels):
    assert_pixels('''
        __________
        __rBBB____
        __rBBB____
        __BBBB____
        __BBBB____
        __BBBB____
        __BBBB____
        __BBBB____
        __BBBB____
        __________
    ''', '''
      <style>
        @page { size: 10px; margin: 2px; }
        div { transform: scaleY(2);
              transform-origin: 1px 1px 0;
              image-rendering: pixelated;
              font-size: 0 }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_2d_transform_13(assert_pixels):
    assert_pixels('''
        __________
        __________
        _rrBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        _BBBBBBBB_
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page { size: 10px; margin: 2px; }
        div { transform: scaleX(2);
              transform-origin: 1px 1px;
              image-rendering: pixelated;
              font-size: 0 }
      </style>
      <div><img src="pattern.png"></div>''')


@assert_no_logs
def test_2d_transform_opacity(assert_pixels):
    assert_pixels('''
        __________
        __________
        __________
        _ss_______
        _ss_______
        __________
        __________
        __________
        __________
        __________
    ''', '''
      <style>
        @page { size: 10px; margin: 2px; }
        div { transform: translate(-1px, 1px); background: red;
              height: 2px; width: 2px; opacity: 0.5 }
      </style>
      <div></div>''')


================================================
FILE: tests/draw/test_visibility.py
================================================
"""Test visibility."""

from ..testing_utils import assert_no_logs

visibility_source = '''
  <style>
    @page { size: 12px 7px }
    body { font-size: 0; line-height: 0 }
    img { margin: 1px 0 0 1px }
    %s
  </style>
  <div>
    <img src="pattern.png">
    <span><img src="pattern.png"></span>
  </div>'''


@assert_no_logs
def test_visibility_1(assert_pixels):
    assert_pixels('''
        ____________
        _rBBB_rBBB__
        _BBBB_BBBB__
        _BBBB_BBBB__
        _BBBB_BBBB__
        ____________
        ____________
    ''', visibility_source % '')


@assert_no_logs
def test_visibility_2(assert_pixels):
    assert_pixels('''
        ____________
        ____________
        ____________
        ____________
        ____________
        ____________
        ____________
    ''', visibility_source % 'div { visibility: hidden }')


@assert_no_logs
def test_visibility_3(assert_pixels):
    assert_pixels('''
        ____________
        ______rBBB__
        ______BBBB__
        ______BBBB__
        ______BBBB__
        ____________
        ____________
    ''', visibility_source % 'div { visibility: hidden } '
                             'span { visibility: visible }')


@assert_no_logs
def test_visibility_4(assert_pixels):
    assert_pixels('''
        ____________
        _rBBB_rBBB__
        _BBBB_BBBB__
        _BBBB_BBBB__
        _BBBB_BBBB__
        ____________
        ____________
    ''', visibility_source % '@page { visibility: hidden; background: red }')


================================================
FILE: tests/draw/test_whitespace.py
================================================
"""Test how white spaces collapse."""

from ..testing_utils import assert_no_logs


@assert_no_logs
def test_whitespace_inline(assert_pixels):
    assert_pixels('''
        RRRR__RRRR____
        RRRR__RRRR____
        ______________
        ______________
    ''', '''
        <style>
            @page {size: 14px 4px}
            body {
              color: red;
              font-family: weasyprint;
              font-size: 2px;
              line-height: 1;
            }
        </style>
        <span>aa </span><span> aa</span>
    ''')


@assert_no_logs
def test_whitespace_nested_inline(assert_pixels):
    assert_pixels('''
        RRRR__RRRR____
        RRRR__RRRR____
        ______________
        ______________
    ''', '''
        <style>
            @page {size: 14px 4px}
            body {
              color: red;
              font-family: weasyprint;
              font-size: 2px;
              line-height: 1;
            }
        </style>
        <span><span>aa </span></span><span><span> aa</span></span>
    ''')


@assert_no_logs
def test_whitespace_inline_space_between(assert_pixels):
    assert_pixels('''
        RRRR__RRRR____
        RRRR__RRRR____
        ______________
        ______________
    ''', '''
        <style>
            @page {size: 14px 4px}
            body {
              color: red;
              font-family: weasyprint;
              font-size: 2px;
              line-height: 1;
            }
        </style>
        <span>aa </span> <span> aa</span>
    ''')


@assert_no_logs
def test_whitespace_float_between(assert_pixels):
    assert_pixels('''
        RRRR__RRRR__BB
        RRRR__RRRR__BB
        ______________
        ______________
    ''', '''
        <style>
            @page {size: 14px 4px}
            body {
              color: red;
              font-family: weasyprint;
              font-size: 2px;
              line-height: 1;
            }
            div {float: right; color: blue}
        </style>
        <span>aa </span><div>a</div><span> aa</span>
    ''')


@assert_no_logs
def test_whitespace_in_float(assert_pixels):
    assert_pixels('''
        RRRRRRRR____BB
        RRRRRRRR____BB
        ______________
        ______________
    ''', '''
        <style>
            @page {size: 14px 4px}
            body {
              color: red;
              font-family: weasyprint;
              font-size: 2px;
              line-height: 1;
            }
            div {
              color: blue;
              float: right;
            }
        </style>
        <span>aa</span><div> a </div><span>aa</span>
    ''')


@assert_no_logs
def test_whitespace_absolute_between(assert_pixels):
    assert_pixels('''
        RRRR__RRRR__BB
        RRRR__RRRR__BB
        ______________
        ______________
    ''', '''
        <style>
            @page {size: 14px 4px}
            body {
              color: red;
              font-family: weasyprint;
              font-size: 2px;
              line-height: 1;
            }
            div {
              color: blue;
              position: absolute;
              right: 0;
              top: 0;
            }
        </style>
        <span>aa </span><div>a</div><span> aa</span>
    ''')


@assert_no_logs
def test_whitespace_in_absolute(assert_pixels):
    assert_pixels('''
        RRRRRRRR____BB
        RRRRRRRR____BB
        ______________
        ______________
    ''', '''
        <style>
            @page {size: 14px 4px}
            body {
              color: red;
              font-family: weasyprint;
              font-size: 2px;
              line-height: 1;
            }
            div {
              color: blue;
              position: absolute;
              right: 0;
              top: 0;
            }
        </style>
        <span>aa</span><div> a </div><span>aa</span>
    ''')


@assert_no_logs
def test_whitespace_running_between(assert_pixels):
    assert_pixels('''
        RRRR__RRRR____
        RRRR__RRRR____
        ______BB______
        ______BB______
    ''', '''
        <style>
            @page {
              size: 14px 4px;
              margin: 0 0 2px;
              @bottom-center {
                content: element(test);
              }
            }
            body {
              color: red;
              font-family: weasyprint;
              font-size: 2px;
              line-height: 1;
            }
            div {
              background: green;
              color: blue;
              position: running(test);
            }
        </style>
        <span>aa </span><div>a</div><span> aa</span>
    ''')


@assert_no_logs
def test_whitespace_in_running(assert_pixels):
    assert_pixels('''
        RRRRRRRR______
        RRRRRRRR______
        ______BB______
        ______BB______
    ''', '''
        <style>
            @page {
              size: 14px 4px;
              margin: 0 0 2px;
              @bottom-center {
                content: element(test);
              }
            }
            body {
              color: red;
              font-family: weasyprint;
              font-size: 2px;
              line-height: 1;
            }
            div {
              background: green;
              color: blue;
              position: running(test);
            }
        </style>
        <span>aa</span><div> a </div><span>aa</span>
    ''')


================================================
FILE: tests/layout/__init__.py
================================================
"""Tests for layout.

Includes positioning and dimensioning of boxes, line breaks, page breaks.

"""


================================================
FILE: tests/layout/test_block.py
================================================
"""Tests for blocks layout."""

import pytest

from weasyprint.formatting_structure import boxes

from ..testing_utils import assert_no_logs, render_pages


@assert_no_logs
def test_block_widths():
    page, = render_pages('''
      <style>
        @page { margin: 0; size: 120px 2000px }
        body { margin: 0 }
        div { margin: 10px }
        p { padding: 2px; border-width: 1px; border-style: solid }
      </style>
      <div>
        <p></p>
        <p style="width: 50px"></p>
      </div>
      <div style="direction: rtl">
        <p style="width: 50px; direction: rtl"></p>
      </div>
      <div>
        <p style="margin: 0 10px 0 20px"></p>
        <p style="width: 50px; margin-left: 20px; margin-right: auto"></p>
        <p style="width: 50px; margin-left: auto; margin-right: 20px"></p>
        <p style="width: 50px; margin: auto"></p>

        <p style="margin-left: 20px; margin-right: auto"></p>
        <p style="margin-left: auto; margin-right: 20px"></p>
        <p style="margin: auto"></p>

        <p style="width: 200px; margin: auto"></p>

        <p style="min-width: 200px; margin: auto"></p>
        <p style="max-width: 50px; margin: auto"></p>
        <p style="min-width: 50px; margin: auto"></p>

        <p style="width: 70%"></p>
      </div>
    ''')
    html, = page.children
    assert html.element_tag == 'html'
    body, = html.children
    assert body.element_tag == 'body'
    assert body.width == 120

    divs = body.children

    paragraphs = []
    for div in divs:
        assert isinstance(div, boxes.BlockBox)
        assert div.element_tag == 'div'
        assert div.width == 100
        for paragraph in div.children:
            assert isinstance(paragraph, boxes.BlockBox)
            assert paragraph.element_tag == 'p'
            assert paragraph.padding_left == 2
            assert paragraph.padding_right == 2
            assert paragraph.border_left_width == 1
            assert paragraph.border_right_width == 1
            paragraphs.append(paragraph)

    assert len(paragraphs) == 15

    # width is 'auto'
    assert paragraphs[0].width == 94
    assert paragraphs[0].margin_left == 0
    assert paragraphs[0].margin_right == 0

    # No 'auto', over-constrained equation with ltr, the initial
    # 'margin-right: 0' was ignored.
    assert paragraphs[1].width == 50
    assert paragraphs[1].margin_left == 0

    # No 'auto', over-constrained equation with rtl, the initial
    # 'margin-left: 0' was ignored.
    assert paragraphs[2].width == 50
    assert paragraphs[2].margin_right == 0

    # width is 'auto'
    assert paragraphs[3].width == 64
    assert paragraphs[3].margin_left == 20

    # margin-right is 'auto'
    assert paragraphs[4].width == 50
    assert paragraphs[4].margin_left == 20

    # margin-left is 'auto'
    assert paragraphs[5].width == 50
    assert paragraphs[5].margin_left == 24

    # Both margins are 'auto', remaining space is split in half
    assert paragraphs[6].width == 50
    assert paragraphs[6].margin_left == 22

    # width is 'auto', other 'auto' are set to 0
    assert paragraphs[7].width == 74
    assert paragraphs[7].margin_left == 20

    # width is 'auto', other 'auto' are set to 0
    assert paragraphs[8].width == 74
    assert paragraphs[8].margin_left == 0

    # width is 'auto', other 'auto' are set to 0
    assert paragraphs[9].width == 94
    assert paragraphs[9].margin_left == 0

    # sum of non-auto initially is too wide, set auto values to 0
    assert paragraphs[10].width == 200
    assert paragraphs[10].margin_left == 0

    # Constrained by min-width, same as above
    assert paragraphs[11].width == 200
    assert paragraphs[11].margin_left == 0

    # Constrained by max-width, same as paragraphs[6]
    assert paragraphs[12].width == 50
    assert paragraphs[12].margin_left == 22

    # NOT constrained by min-width
    assert paragraphs[13].width == 94
    assert paragraphs[13].margin_left == 0

    # 70%
    assert paragraphs[14].width == 70
    assert paragraphs[14].margin_left == 0


@assert_no_logs
def test_block_heights_p():
    page, = render_pages('''
      <style>
        @page { margin: 0; size: 100px 20000px }
        html, body { margin: 0 }
        div { margin: 4px; border: 2px solid; padding: 4px }
        /* Use top margins so that margin collapsing doesn't change result */
        p { margin: 16px 0 0; border: 4px solid; padding: 8px; height: 50px }
      </style>
      <div>
        <p></p>
        <!-- Not in normal flow: don't contribute to the parent’s height -->
        <p style="position: absolute"></p>
        <p style="float: left"></p>
      </div>
      <div> <p></p> <p></p> <p></p> </div>
      <div style="height: 20px"> <p></p> </div>
      <div style="height: 120px"> <p></p> </div>
      <div style="max-height: 20px"> <p></p> </div>
      <div style="min-height: 120px"> <p></p> </div>
      <div style="min-height: 20px"> <p></p> </div>
      <div style="max-height: 120px"> <p></p> </div>
    ''')
    html, = page.children
    body, = html.children
    heights = [div.height for div in body.children]
    assert heights == [90, 90 * 3, 20, 120, 20, 120, 90, 90]


@assert_no_logs
def test_block_heights_img():
    page, = render_pages('''
      <style>
        body { height: 200px; font-size: 0 }
      </style>
      <div>
        <img src=pattern.png style="height: 40px">
      </div>
      <div style="height: 10%">
        <img src=pattern.png style="height: 40px">
      </div>
      <div style="max-height: 20px">
        <img src=pattern.png style="height: 40px">
      </div>
      <div style="max-height: 10%">
        <img src=pattern.png style="height: 40px">
      </div>
      <div style="min-height: 20px"></div>
      <div style="min-height: 10%"></div>
    ''')
    html, = page.children
    body, = html.children
    heights = [div.height for div in body.children]
    assert heights == [40, 20, 20, 20, 20, 20]


@assert_no_logs
def test_block_heights_img_no_body_height():
    # Same but with no height on body: percentage *-height is ignored
    page, = render_pages('''
      <style>
        body { font-size: 0 }
      </style>
        <div>
          <img src=pattern.png style="height: 40px">
        </div>
        <div style="height: 10%">
          <img src=pattern.png style="height: 40px">
        </div>
        <div style="max-height: 20px">
          <img src=pattern.png style="height: 40px">
        </div>
        <div style="max-height: 10%">
          <img src=pattern.png style="height: 40px">
        </div>
        <div style="min-height: 20px"></div>
        <div style="min-height: 10%"></div>
    ''')
    html, = page.children
    body, = html.children
    heights = [div.height for div in body.children]
    assert heights == [40, 40, 20, 40, 20, 0]


@assert_no_logs
def test_block_percentage_heights_no_html_height():
    page, = render_pages('''
      <style>
        html, body { margin: 0 }
        body { height: 50% }
      </style>
    ''')
    html, = page.children
    assert html.element_tag == 'html'
    body, = html.children
    assert body.element_tag == 'body'

    # Since html’s height depend on body’s, body’s 50% means 'auto'
    assert body.height == 0


@assert_no_logs
def test_block_percentage_heights():
    page, = render_pages('''
      <style>
        html, body { margin: 0 }
        html { height: 300px }
        body { height: 50% }
      </style>
    ''')
    html, = page.children
    assert html.element_tag == 'html'
    body, = html.children
    assert body.element_tag == 'body'

    # This time the percentage makes sense
    assert body.height == 150


@assert_no_logs
@pytest.mark.parametrize('size', [
    ('width: 10%; height: 1000px',),
    ('max-width: 10%; max-height: 1000px; height: 2000px',),
    ('width: 5%; min-width: 10%; min-height: 1000px',),
    ('width: 10%; height: 1000px; min-width: auto; max-height: none',),
])
def test_box_sizing(size):
    # https://www.w3.org/TR/css-ui-3/#box-sizing
    page, = render_pages('''
      <style>
        @page { size: 100000px }
        body { width: 10000px; margin: 0 }
        div { %s; margin: 100px; padding: 10px; border: 1px solid }
      </style>
      <div></div>

      <div style="box-sizing: content-box"></div>
      <div style="box-sizing: padding-box"></div>
      <div style="box-sizing: border-box"></div>
    ''' % size)
    html, = page.children
    body, = html.children
    div_1, div_2, div_3, div_4 = body.children
    for div in div_1, div_2:
        assert div.style['box_sizing'] == 'content-box'
        assert div.width == 1000
        assert div.height == 1000
        assert div.padding_width() == 1020
        assert div.padding_height() == 1020
        assert div.border_width() == 1022
        assert div.border_height() == 1022
        assert div.margin_height() == 1222
        # margin_width() is the width of the containing block

    # padding-box
    assert div_3.style['box_sizing'] == 'padding-box'
    assert div_3.width == 980  # 1000 - 20
    assert div_3.height == 980
    assert div_3.padding_width() == 1000
    assert div_3.padding_height() == 1000
    assert div_3.border_width() == 1002
    assert div_3.border_height() == 1002
    assert div_3.margin_height() == 1202

    # border-box
    assert div_4.style['box_sizing'] == 'border-box'
    assert div_4.width == 978  # 1000 - 20 - 2
    assert div_4.height == 978
    assert div_4.padding_width() == 998
    assert div_4.padding_height() == 998
    assert div_4.border_width() == 1000
    assert div_4.border_height() == 1000
    assert div_4.margin_height() == 1200


@assert_no_logs
@pytest.mark.parametrize('size', [
    ('width: 0; height: 0'),
    ('max-width: 0; max-height: 0'),
    ('min-width: 0; min-height: 0; width: 0; height: 0'),
])
def test_box_sizing_zero(size):
    # https://www.w3.org/TR/css-ui-3/#box-sizing
    page, = render_pages('''
      <style>
        @page { size: 100000px }
        body { width: 10000px; margin: 0 }
        div { %s; margin: 100px; padding: 10px; border: 1px solid }
      </style>
      <div></div>

      <div style="box-sizing: content-box"></div>
      <div style="box-sizing: padding-box"></div>
      <div style="box-sizing: border-box"></div>
    ''' % size)
    html, = page.children
    body, = html.children
    for div in body.children:
        assert div.width == 0
        assert div.height == 0
        assert div.padding_width() == 20
        assert div.padding_height() == 20
        assert div.border_width() == 22
        assert div.border_height() == 22
        assert div.margin_height() == 222
        # margin_width() is the width of the containing block


COLLAPSING = (
    ('10px', '15px', 15),  # not 25
    # "The maximum of the absolute values of the negative adjoining margins is
    # deducted from the maximum of the positive adjoining margins"
    ('-10px', '15px', 5),
    ('10px', '-15px', -5),
    ('-10px', '-15px', -15),
    ('10px', 'auto', 10),  # 'auto' is 0
)
NOT_COLLAPSING = (
    ('10px', '15px', 25),
    ('-10px', '15px', 5),
    ('10px', '-15px', -5),
    ('-10px', '-15px', -25),
    ('10px', 'auto', 10),  # 'auto' is 0
)


@pytest.mark.parametrize(('margin_1', 'margin_2', 'result'), COLLAPSING)
def test_vertical_space_1(margin_1, margin_2, result):
    # Siblings
    page, = render_pages('''
      <style>
        p { font: 20px/1 serif } /* block height == 20px */
        #p1 { margin-bottom: %s }
        #p2 { margin-top: %s }
      </style>
      <p id=p1>Lorem ipsum
      <p id=p2>dolor sit amet
    ''' % (margin_1, margin_2))
    html, = page.children
    body, = html.children
    p1, p2 = body.children
    p1_bottom = p1.content_box_y() + p1.height
    p2_top = p2.content_box_y()
    assert p2_top - p1_bottom == result


@pytest.mark.parametrize(('margin_1', 'margin_2', 'result'), COLLAPSING)
def test_vertical_space_2(margin_1, margin_2, result):
    # Not siblings, first is nested
    page, = render_pages('''
      <style>
        p { font: 20px/1 serif } /* block height == 20px */
        #p1 { margin-bottom: %s }
        #p2 { margin-top: %s }
      </style>
      <div>
        <p id=p1>Lorem ipsum
      </div>
      <p id=p2>dolor sit amet
    ''' % (margin_1, margin_2))
    html, = page.children
    body, = html.children
    div, p2 = body.children
    p1, = div.children
    p1_bottom = p1.content_box_y() + p1.height
    p2_top = p2.content_box_y()
    assert p2_top - p1_bottom == result


@pytest.mark.parametrize(('margin_1', 'margin_2', 'result'), COLLAPSING)
def test_vertical_space_3(margin_1, margin_2, result):
    # Not siblings, second is nested
    page, = render_pages('''
      <style>
        p { font: 20px/1 serif } /* block height == 20px */
        #p1 { margin-bottom: %s }
        #p2 { margin-top: %s }
      </style>
      <p id=p1>Lorem ipsum
      <div>
        <p id=p2>dolor sit amet
      </div>
    ''' % (margin_1, margin_2))
    html, = page.children
    body, = html.children
    p1, div = body.children
    p2, = div.children
    p1_bottom = p1.content_box_y() + p1.height
    p2_top = p2.content_box_y()
    assert p2_top - p1_bottom == result


@pytest.mark.parametrize(('margin_1', 'margin_2', 'result'), COLLAPSING)
def test_vertical_space_4(margin_1, margin_2, result):
    # Not siblings, second is doubly nested
    page, = render_pages('''
      <style>
        p { font: 20px/1 serif } /* block height == 20px */
        #p1 { margin-bottom: %s }
        #p2 { margin-top: %s }
      </style>
      <p id=p1>Lorem ipsum
      <div>
        <div>
            <p id=p2>dolor sit amet
        </div>
      </div>
    ''' % (margin_1, margin_2))
    html, = page.children
    body, = html.children
    p1, div1 = body.children
    div2, = div1.children
    p2, = div2.children
    p1_bottom = p1.content_box_y() + p1.height
    p2_top = p2.content_box_y()
    assert p2_top - p1_bottom == result


@pytest.mark.parametrize(('margin_1', 'margin_2', 'result'), COLLAPSING)
def test_vertical_space_5(margin_1, margin_2, result):
    # Collapsing with children
    page, = render_pages('''
      <style>
        p { font: 20px/1 serif } /* block height == 20px */
        #div1 { margin-top: %s }
        #div2 { margin-top: %s }
      </style>
      <p>Lorem ipsum
      <div id=div1>
        <div id=div2>
          <p id=p2>dolor sit amet
        </div>
      </div>
    ''' % (margin_1, margin_2))
    html, = page.children
    body, = html.children
    p1, div1 = body.children
    div2, = div1.children
    p2, = div2.children
    p1_bottom = p1.content_box_y() + p1.height
    p2_top = p2.content_box_y()
    # Parent and element edge are the same:
    assert div1.border_box_y() == p2.border_box_y()
    assert div2.border_box_y() == p2.border_box_y()
    assert p2_top - p1_bottom == result


@pytest.mark.parametrize(('margin_1', 'margin_2', 'result'), NOT_COLLAPSING)
def test_vertical_space_6(margin_1, margin_2, result):
    # Block formatting context: Not collapsing with children
    page, = render_pages('''
      <style>
        p { font: 20px/1 serif } /* block height == 20px */
        #div1 { margin-top: %s; overflow: hidden }
        #div2 { margin-top: %s }
      </style>
      <p>Lorem ipsum
      <div id=div1>
        <div id=div2>
          <p id=p2>dolor sit amet
        </div>
      </div>
    ''' % (margin_1, margin_2))
    html, = page.children
    body, = html.children
    p1, div1 = body.children
    div2, = div1.children
    p2, = div2.children
    p1_bottom = p1.content_box_y() + p1.height
    p2_top = p2.content_box_y()
    assert p2_top - p1_bottom == result


@pytest.mark.parametrize(('margin_1', 'margin_2', 'result'), COLLAPSING)
def test_vertical_space_7(margin_1, margin_2, result):
    # Collapsing through an empty div
    page, = render_pages('''
      <style>
        p { font: 20px/1 serif } /* block height == 20px */
        #p1 { margin-bottom: %s }
        #p2 { margin-top: %s }
        div { margin-bottom: %s; margin-top: %s }
      </style>
      <p id=p1>Lorem ipsum
      <div></div>
      <p id=p2>dolor sit amet
    ''' % (2 * (margin_1, margin_2)))
    html, = page.children
    body, = html.children
    p1, div, p2 = body.children
    p1_bottom = p1.content_box_y() + p1.height
    p2_top = p2.content_box_y()
    assert p2_top - p1_bottom == result


@pytest.mark.parametrize(('margin_1', 'margin_2', 'result'), NOT_COLLAPSING)
def test_vertical_space_8(margin_1, margin_2, result):
    # The root element does not collapse
    page, = render_pages('''
      <style>
        html { margin-top: %s }
        body { margin-top: %s }
      </style>
      <p>Lorem ipsum
    ''' % (margin_1, margin_2))
    html, = page.children
    body, = html.children
    p1, = body.children
    p1_top = p1.content_box_y()
    # Vertical space from y=0
    assert p1_top == result


@pytest.mark.parametrize(('margin_1', 'margin_2', 'result'), COLLAPSING)
def test_vertical_space_9(margin_1, margin_2, result):
    # <body> DOES collapse
    page, = render_pages('''
      <style>
        body { margin-top: %s }
        div { margin-top: %s }
      </style>
      <div>
        <p>Lorem ipsum
    ''' % (margin_1, margin_2))
    html, = page.children
    body, = html.children
    div, = body.children
    p1, = div.children
    p1_top = p1.content_box_y()
    # Vertical space from y=0
    assert p1_top == result


@assert_no_logs
def test_box_decoration_break_block_slice():
    # https://www.w3.org/TR/css-backgrounds-3/#the-box-decoration-break
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 100px }
        p { padding: 2px; border: 3px solid; margin: 5px }
        img { display: block; height: 40px }
      </style>
      <p>
        <img src=pattern.png>
        <img src=pattern.png>
        <img src=pattern.png>
        <img src=pattern.png>''')
    html, = page_1.children
    body, = html.children
    paragraph, = body.children
    img_1, img_2 = paragraph.children
    assert paragraph.position_y == 0
    assert paragraph.margin_top == 5
    assert paragraph.border_top_width == 3
    assert paragraph.padding_top == 2
    assert paragraph.content_box_y() == 10
    assert img_1.position_y == 10
    assert img_2.position_y == 50
    assert paragraph.height == 90
    assert paragraph.margin_bottom == 0
    assert paragraph.border_bottom_width == 0
    assert paragraph.padding_bottom == 0
    assert paragraph.margin_height() == 100

    html, = page_2.children
    body, = html.children
    paragraph, = body.children
    img_1, img_2 = paragraph.children
    assert paragraph.position_y == 0
    assert paragraph.margin_top == 0
    assert paragraph.border_top_width == 0
    assert paragraph.padding_top == 0
    assert paragraph.content_box_y() == 0
    assert img_1.position_y == 0
    assert img_2.position_y == 40
    assert paragraph.height == 80
    assert paragraph.padding_bottom == 2
    assert paragraph.border_bottom_width == 3
    assert paragraph.margin_bottom == 5
    assert paragraph.margin_height() == 90


@assert_no_logs
def test_box_decoration_break_block_clone():
    # https://www.w3.org/TR/css-backgrounds-3/#the-box-decoration-break
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 100px }
        p { padding: 2px; border: 3px solid; margin: 5px;
            box-decoration-break: clone }
        img { display: block; height: 40px }
      </style>
      <p>
        <img src=pattern.png>
        <img src=pattern.png>
        <img src=pattern.png>
        <img src=pattern.png>''')
    html, = page_1.children
    body, = html.children
    paragraph, = body.children
    img_1, img_2 = paragraph.children
    assert paragraph.position_y == 0
    assert paragraph.margin_top == 5
    assert paragraph.border_top_width == 3
    assert paragraph.padding_top == 2
    assert paragraph.content_box_y() == 10
    assert img_1.position_y == 10
    assert img_2.position_y == 50
    assert paragraph.height == 80
    # TODO: bottom margin should be 0
    # https://www.w3.org/TR/css-break-3/#valdef-box-decoration-break-clone
    # "Cloned margins are truncated on block-level boxes."
    # See issue #115.
    assert paragraph.margin_bottom == 5
    assert paragraph.border_bottom_width == 3
    assert paragraph.padding_bottom == 2
    assert paragraph.margin_height() == 100

    html, = page_2.children
    body, = html.children
    paragraph, = body.children
    img_1, img_2 = paragraph.children
    assert paragraph.position_y == 0
    assert paragraph.margin_top == 0
    assert paragraph.border_top_width == 3
    assert paragraph.padding_top == 2
    assert paragraph.content_box_y() == 5
    assert img_1.position_y == 5
    assert img_2.position_y == 45
    assert paragraph.height == 80
    assert paragraph.padding_bottom == 2
    assert paragraph.border_bottom_width == 3
    assert paragraph.margin_bottom == 5
    assert paragraph.margin_height() == 95


@assert_no_logs
def test_box_decoration_break_clone_bottom_padding():
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 80px; margin: 0 }
        div { height: 20px }
        article { padding: 12px; box-decoration-break: clone }
      </style>
      <article>
        <div>a</div>
        <div>b</div>
        <div>c</div>
      </article>''')
    html, = page_1.children
    body, = html.children
    article, = body.children
    assert article.height == 80 - 2 * 12
    div_1, div_2 = article.children
    assert div_1.position_y == 12
    assert div_2.position_y == 12 + 20

    html, = page_2.children
    body, = html.children
    article, = body.children
    assert article.height == 20
    div, = article.children
    assert div.position_y == 12


@pytest.mark.xfail
@assert_no_logs
def test_box_decoration_break_slice_bottom_padding():  # pragma: no cover
    # Last div fits in first, but not article's padding. As it is impossible to
    # break between a parent and its last child, put last child on next page.
    # TODO: at the end of block_container_layout, we should check that the box
    # with its bottom border/padding doesn't cross the bottom line. If it does,
    # we should re-render the box with a bottom_space including the bottom
    # border/padding.
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 80px; margin: 0 }
        div { height: 20px }
        article { padding: 12px; box-decoration-break: slice }
      </style>
      <article>
        <div>a</div>
        <div>b</div>
        <div>c</div>
      </article>''')
    html, = page_1.children
    body, = html.children
    article, = body.children
    assert article.height == 80 - 12
    div_1, div_2 = article.children
    assert div_1.position_y == 12
    assert div_2.position_y == 12 + 20

    html, = page_2.children
    body, = html.children
    article, = body.children
    assert article.height == 20
    div, = article.children
    assert div.position_y == 0


@pytest.mark.xfail
@assert_no_logs
def test_nested_blocks_padding_border():  # pragma: no cover
    # Same as previous issue, with nested blocks.
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 4px 12px; margin: 0 }
        html { font: 2px/1 weasyprint }
        article, section, div {
          border-top: 1px solid; border-bottom: 1px solid;
          padding-top: 1px; padding-bottom: 1px;
        }
      </style>
      <article>
        <section>
          <div>
            aaa
            bbb
          </div>
        </section>
      </article>''')
    html, = page_1.children
    body, = html.children
    div_1, = body.children
    div_2, = div_1.children
    div_3, = div_2.children

    html, = page_2.children
    body, = html.children
    div_1, = body.children
    div_2, = div_1.children
    div_3, = div_2.children


@assert_no_logs
def test_overflow_non_collapsing_parent():
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 6px 10px; margin: 0 }
        html { font: 2px/1 weasyprint }
        div { border-bottom: 3px solid }
        p { margin-bottom: 2px }
      </style>
      abc
      def
      <div>
        <p>
          aaa
        </p>
      </div>
      ghi''')
    html, = page_1.children
    body, = html.children
    lines, = body.children
    line_1, line_2 = lines.children

    html, = page_2.children
    body, = html.children
    section, lines = body.children


@assert_no_logs
def test_overflow_auto():
    page, = render_pages('''
      <article style="overflow: auto">
        <div style="float: left; height: 50px; margin: 10px">bla bla bla</div>
          toto toto''')
    html, = page.children
    body, = html.children
    article, = body.children
    assert article.height == 50 + 10 + 10


@assert_no_logs
def test_overflow_hidden_in_flow_layout():
    page, = render_pages('''
      <div style="overflow: hidden; height: 3px;">
        <div>abc</div>
        <div style="height: 100px; margin: 50px;">def</div>
      </div>
    ''')
    html, = page.children
    body, = html.children
    parent_div, = body.children
    assert parent_div.height == 3


@assert_no_logs
def test_overflow_hidden_out_of_flow_layout():
    page, = render_pages('''
      <div style="overflow: hidden; height: 3px;">
        <div style="float: left;">abc</div>
        <div style="float: right; height: 100px; margin: 50px;">def</div>
      </div>
    ''')
    html, = page.children
    body, = html.children
    parent_div, = body.children
    assert parent_div.height == 3


@assert_no_logs
def test_box_margin_top_repagination():
    # Regression test for #943.
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 50px }
        :root { line-height: 1; font-size: 10px }
        a::before { content: target-counter(attr(href), page) }
        div { margin: 20px 0 0; background: yellow }
      </style>
      <p><a href="#title"></a></p>
      <div>1<br/>1<br/>2<br/>2</div>
      <h1 id="title">title</h1>
    ''')
    html, = page_1.children
    body, = html.children
    p, div = body.children
    assert div.margin_top == 20
    assert div.padding_box_y() == 10 + 20

    html, = page_2.children
    body, = html.children
    div, h1 = body.children
    assert div.margin_top == 0
    assert div.padding_box_y() == 0


@assert_no_logs
def test_continue_discard():
    page_1, = render_pages('''
      <style>
        @page { size: 80px; margin: 0 }
        div { display: inline-block; width: 100%; height: 25px }
        article { continue: discard; border: 1px solid; line-height: 1 }
      </style>
      <article>
        <div>a</div>
        <div>b</div>
        <div>c</div>
        <div>d</div>
        <div>e</div>
        <div>f</div>
      </article>''')
    html, = page_1.children
    body, = html.children
    article, = body.children
    assert article.height == 3 * 25
    div_1, div_2, div_3 = article.children
    assert div_1.position_y == 1
    assert div_2.position_y == 1 + 25
    assert div_3.position_y == 1 + 25 * 2
    assert article.border_bottom_width == 1


@assert_no_logs
def test_continue_discard_children():
    page_1, = render_pages('''
      <style>
        @page { size: 80px; margin: 0 }
        div { display: inline-block; width: 100%; height: 25px }
        section { border: 1px solid }
        article { continue: discard; border: 1px solid; line-height: 1 }
      </style>
      <article>
        <section>
          <div>a</div>
          <div>b</div>
          <div>c</div>
          <div>d</div>
          <div>e</div>
          <div>f</div>
        </section>
      </article>''')
    html, = page_1.children
    body, = html.children
    article, = body.children
    assert article.height == 2 + 3 * 25
    section, = article.children
    assert section.height == 3 * 25
    div_1, div_2, div_3 = section.children
    assert div_1.position_y == 2
    assert div_2.position_y == 2 + 25
    assert div_3.position_y == 2 + 25 * 2
    assert article.border_bottom_width == 1


@assert_no_logs
def test_block_in_block_with_bottom_padding():
    # Regression test for #1476.
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 8em 3.5em }
        body { line-height: 1; font-family: weasyprint }
        div { padding-bottom: 1em }
      </style>
      abc def
      <div>
        <p>
          ghi jkl
          mno pqr
        </p>
      </div>
      stu vwx''')

    html, = page_1.children
    body, = html.children
    anon_body, div = body.children
    line, = anon_body.children
    assert line.height == 16
    assert line.children[0].text == 'abc def'
    p, = div.children
    line, = p.children
    assert line.height == 16
    assert line.children[0].text == 'ghi jkl'

    html, = page_2.children
    body, = html.children
    div, anon_body = body.children
    p, = div.children
    line, = p.children
    assert line.height == 16
    assert line.children[0].text == 'mno pqr'
    line, = anon_body.children
    assert line.height == 16
    assert line.content_box_y() == 16 + 16  # p content + div padding
    assert line.children[0].text == 'stu vwx'


@assert_no_logs
def test_page_breaks_1():
    # last div does not fit, pushed to next page
    pages = render_pages('''
      <style>
        @page{
          size: 110px;
          margin: 10px;
          padding: 0;
        }
        .large {
          width: 10px;
          height: 60px;
        }
        .small {
          width: 10px;
          height: 20px;
        }
      </style>
      <body>
        <div class="large"></div>
        <div class="small"></div>
        <div class="large"></div>
    ''')

    assert len(pages) == 2
    page_divs = []
    for page in pages:
        divs = [div for div in page.descendants() if div.element_tag == 'div']
        assert all([div.element_tag == 'div' for div in divs])
        page_divs.append(divs)
    positions_y = [[div.position_y for div in divs] for divs in page_divs]
    assert positions_y == [[10, 70], [10]]


@assert_no_logs
def test_page_breaks_2():
    # last div does not fit, pushed to next page
    # center div must not
    pages = render_pages('''
      <style>
        @page{
          size: 110px;
          margin: 10px;
          padding: 0;
        }
        .large {
          width: 10px;
          height: 60px;
        }
        .small {
          width: 10px;
          height: 20px;
          page-break-after: avoid;
        }
      </style>
      <body>
        <div class="large"></div>
        <div class="small"></div>
        <div class="large"></div>
    ''')

    assert len(pages) == 2
    page_divs = []
    for page in pages:
        divs = [div for div in page.descendants() if div.element_tag == 'div']
        assert all([div.element_tag == 'div' for div in divs])
        page_divs.append(divs)
    positions_y = [[div.position_y for div in divs] for divs in page_divs]
    assert positions_y == [[10], [10, 30]]


@assert_no_logs
def test_page_breaks_3():
    # center div must be the last element,
    # but div won't fit and will get pushed anyway
    pages = render_pages('''
      <style>
        @page{
          size: 110px;
          margin: 10px;
          padding: 0;
        }
        .large {
          width: 10px;
          height: 80px;
        }
        .small {
          width: 10px;
          height: 20px;
          page-break-after: avoid;
        }
      </style>
      <body>
        <div class="large"></div>
        <div class="small"></div>
        <div class="large"></div>
    ''')

    assert len(pages) == 3
    page_divs = []
    for page in pages:
        divs = [div for div in page.descendants() if div.element_tag == 'div']
        assert all([div.element_tag == 'div' for div in divs])
        page_divs.append(divs)
    positions_y = [[div.position_y for div in divs] for divs in page_divs]
    assert positions_y == [[10], [10], [10]]


@assert_no_logs
def test_page_break_child_margin_no_collapse():
    # Regression test for #2453.
    page1, page2 = render_pages('''
      <style>
        @page{ size: 6px }
      </style>
      <body>
        <div style="height: 2px"></div>
        <section>
          <div style="height: 3px; margin-bottom: 2px"></div>
          <div style="display: flex">
            <span style="font: 2px weasyprint">a</span>
          </div>
        </section>
      </body>
    ''')
    html, = page1.children
    body, = html.children
    div, section = body.children
    div, = section.children

    html, = page2.children
    body, = html.children
    section, = body.children
    div, = section.children


@assert_no_logs
def test_min_max_rtl():
    page1, = render_pages('''
      <style>
        @page{ size: 10px }
      </style>
      <body style="direction: rtl">
        <div style="height: 5px; width: 1px; max-height: 4px; min-width: 3px"></div>
        <div style="height: 1px; width: 5px; min-height: 4px; max-width: 3px"></div>
      </body>
    ''')
    html, = page1.children
    body, = html.children
    div1, div2 = body.children
    assert div1.position_x == 7
    assert div1.position_y == 0
    assert div1.height == 4
    assert div1.width == 3
    assert div2.position_x == 7
    assert div2.position_y == 4
    assert div2.height == 4
    assert div2.width == 3


================================================
FILE: tests/layout/test_column.py
================================================
"""Tests for multicolumn layout."""

import pytest

from ..testing_utils import assert_no_logs, render_pages


@assert_no_logs
@pytest.mark.parametrize('css', [
    'columns: 4',
    'columns: 100px',
    'columns: 4 100px',
    'columns: 100px 4',
    'column-width: 100px',
    'column-count: 4',
])
def test_columns(css):
    page, = render_pages('''
      <style>
        div { %s; column-gap: 0 }
        body { margin: 0; font-family: weasyprint }
        @page { margin: 0; size: 400px 1000px }
      </style>
      <div>
        Ipsum dolor sit amet,
        consectetur adipiscing elit.
        Sed sollicitudin nibh
        et turpis molestie tristique.
      </div>
    ''' % css)
    html, = page.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 4
    assert [column.width for column in columns] == [100, 100, 100, 100]
    assert [column.position_x for column in columns] == [0, 100, 200, 300]
    assert [column.position_y for column in columns] == [0, 0, 0, 0]


@pytest.mark.parametrize(('value', 'width'), [
    ('normal', 16),  # "normal" is 1em = 16px
    ('unknown', 16),  # default value is normal
    ('15px', 15),
    ('5%', 15),
    ('-1em', 16),  # negative values are not allowed
])
def test_column_gap(value, width):
    page, = render_pages('''
      <style>
        div { columns: 3; column-gap: %s }
        body { margin: 0; font-family: weasyprint }
        @page { margin: 0; size: 300px 1000px }
      </style>
      <div>
        Ipsum dolor sit amet,
        consectetur adipiscing elit.
        Sed sollicitudin nibh
        et turpis molestie tristique.
      </div>
    ''' % value)
    html, = page.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 3
    assert [column.width for column in columns] == (
        3 * [100 - 2 * width / 3])
    assert [column.position_x for column in columns] == (
        [0, 100 + width / 3, 200 + 2 * width / 3])
    assert [column.position_y for column in columns] == [0, 0, 0]


@assert_no_logs
def test_column_span_1():
    page, = render_pages('''
      <style>
        body { margin: 0; font-family: weasyprint; line-height: 1 }
        div { columns: 2; width: 10em; column-gap: 0 }
        section { column-span: all; margin: 1em 0 }
      </style>

      <div>
        abc def
        <section>test</section>
        <section>test</section>
        ghi jkl
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    column1, column2, section1, section2, column3, column4 = div.children
    assert (column1.position_x, column1.position_y) == (0, 0)
    assert (column2.position_x, column2.position_y) == (5 * 16, 0)
    assert (section1.content_box_x(), section1.content_box_y()) == (0, 32)
    assert (section2.content_box_x(), section2.content_box_y()) == (0, 64)
    assert (column3.position_x, column3.position_y) == (0, 96)
    assert (column4.position_x, column4.position_y) == (5 * 16, 96)

    assert column1.height == 16


@assert_no_logs
def test_column_span_2():
    page, = render_pages('''
      <style>
        body { margin: 0; font-family: weasyprint; line-height: 1 }
        div { columns: 2; width: 10em; column-gap: 0 }
        section { column-span: all; margin: 1em 0 }
      </style>

      <div>
        <section>test</section>
        abc def
        ghi jkl
        mno pqr
        stu vwx
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    section1, column1, column2 = div.children
    assert (section1.content_box_x(), section1.content_box_y()) == (0, 16)
    assert (column1.position_x, column1.position_y) == (0, 3 * 16)
    assert (column2.position_x, column2.position_y) == (5 * 16, 3 * 16)

    assert column1.height == column2.height == 16 * 4


@assert_no_logs
def test_column_span_3():
    page1, page2 = render_pages('''
      <style>
        @page { margin: 0; size: 8px 3px }
        body { font-family: weasyprint; font-size: 1px }
        div { columns: 2; column-gap: 0; line-height: 1 }
        section { column-span: all }
      </style>
      <div>
        abc def
        ghi jkl
        <section>line1 line2</section>
        mno pqr
      </div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    column1, column2, section = div.children
    assert (column1.position_x, column1.position_y) == (0, 0)
    assert (column2.position_x, column2.position_y) == (4, 0)
    assert (section.position_x, section.position_y) == (0, 2)

    assert column1.children[0].children[0].children[0].text == 'abc'
    assert column1.children[0].children[1].children[0].text == 'def'
    assert column2.children[0].children[0].children[0].text == 'ghi'
    assert column2.children[0].children[1].children[0].text == 'jkl'
    assert section.children[0].children[0].text == 'line1'

    html, = page2.children
    body, = html.children
    div, = body.children
    section, column1, column2 = div.children
    assert (section.position_x, section.position_y) == (0, 0)
    assert (column1.position_x, column1.position_y) == (0, 1)
    assert (column2.position_x, column2.position_y) == (4, 1)

    assert section.children[0].children[0].text == 'line2'
    assert column1.children[0].children[0].children[0].text == 'mno'
    assert column2.children[0].children[0].children[0].text == 'pqr'


@assert_no_logs
def test_column_span_4():
    page1, page2 = render_pages('''
      <style>
        @page { margin: 0; size: 8px 3px }
        body { font-family: weasyprint; font-size: 1px }
        div { columns: 2; column-gap: 0; line-height: 1 }
        section { column-span: all }
      </style>
      <div>
        abc def
        <section>line1</section>
        ghi jkl
        mno pqr
      </div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    column1, column2, section, column3, column4 = div.children
    assert (column1.position_x, column1.position_y) == (0, 0)
    assert (column2.position_x, column2.position_y) == (4, 0)
    assert (section.position_x, section.position_y) == (0, 1)
    assert (column3.position_x, column3.position_y) == (0, 2)
    assert (column4.position_x, column4.position_y) == (4, 2)

    assert column1.children[0].children[0].children[0].text == 'abc'
    assert column2.children[0].children[0].children[0].text == 'def'
    assert section.children[0].children[0].text == 'line1'
    assert column3.children[0].children[0].children[0].text == 'ghi'
    assert column4.children[0].children[0].children[0].text == 'jkl'

    html, = page2.children
    body, = html.children
    div, = body.children
    column1, column2 = div.children
    assert (column1.position_x, column1.position_y) == (0, 0)
    assert (column2.position_x, column2.position_y) == (4, 0)

    assert column1.children[0].children[0].children[0].text == 'mno'
    assert column2.children[0].children[0].children[0].text == 'pqr'


@assert_no_logs
def test_column_span_5():
    page1, page2 = render_pages('''
      <style>
        @page { margin: 0; size: 8px 3px }
        body { font-family: weasyprint; font-size: 1px }
        div { columns: 2; column-gap: 0; line-height: 1 }
        section { column-span: all }
      </style>
      <div>
        abc def
        ghi jkl
        <section>line1</section>
        mno pqr
      </div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    column1, column2, section = div.children
    assert (column1.position_x, column1.position_y) == (0, 0)
    assert (column2.position_x, column2.position_y) == (4, 0)
    assert (section.position_x, section.position_y) == (0, 2)

    assert column1.children[0].children[0].children[0].text == 'abc'
    assert column1.children[0].children[1].children[0].text == 'def'
    assert column2.children[0].children[0].children[0].text == 'ghi'
    assert column2.children[0].children[1].children[0].text == 'jkl'
    assert section.children[0].children[0].text == 'line1'

    html, = page2.children
    body, = html.children
    div, = body.children
    column1, column2 = div.children
    assert (column1.position_x, column1.position_y) == (0, 0)
    assert (column2.position_x, column2.position_y) == (4, 0)

    assert column1.children[0].children[0].children[0].text == 'mno'
    assert column2.children[0].children[0].children[0].text == 'pqr'


@assert_no_logs
def test_column_span_6():
    page1, page2 = render_pages('''
      <style>
        @page { margin: 0; size: 8px 3px }
        body { font-family: weasyprint; font-size: 1px }
        div { columns: 2; column-gap: 0; line-height: 1 }
        section { column-span: all }
      </style>
      <div>
        abc def
        ghi jkl
        mno pqr
        <section>line1</section>
      </div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    column1, column2 = div.children
    assert (column1.position_x, column1.position_y) == (0, 0)
    assert (column2.position_x, column2.position_y) == (4, 0)

    assert column1.children[0].children[0].children[0].text == 'abc'
    assert column1.children[0].children[1].children[0].text == 'def'
    assert column1.children[0].children[2].children[0].text == 'ghi'
    assert column2.children[0].children[0].children[0].text == 'jkl'
    assert column2.children[0].children[1].children[0].text == 'mno'
    assert column2.children[0].children[2].children[0].text == 'pqr'

    html, = page2.children
    body, = html.children
    div, = body.children
    section, = div.children
    assert section.children[0].children[0].text == 'line1'
    assert (section.position_x, section.position_y) == (0, 0)


@assert_no_logs
def test_column_span_7():
    page1, page2 = render_pages('''
      <style>
        @page { margin: 0; size: 8px 3px }
        body { font-family: weasyprint; font-size: 1px }
        div { columns: 2; column-gap: 0; line-height: 1 }
        section { column-span: all; font-size: 2px }
      </style>
      <div>
        abc def
        ghi jkl
        <section>l1</section>
        mno pqr
      </div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    column1, column2 = div.children
    assert (column1.position_x, column1.position_y) == (0, 0)
    assert (column2.position_x, column2.position_y) == (4, 0)

    assert column1.children[0].children[0].children[0].text == 'abc'
    assert column1.children[0].children[1].children[0].text == 'def'
    assert column2.children[0].children[0].children[0].text == 'ghi'
    assert column2.children[0].children[1].children[0].text == 'jkl'

    html, = page2.children
    body, = html.children
    div, = body.children
    section, column1, column2 = div.children
    assert (section.position_x, section.position_y) == (0, 0)
    assert (column1.position_x, column1.position_y) == (0, 2)
    assert (column2.position_x, column2.position_y) == (4, 2)

    assert section.children[0].children[0].text == 'l1'
    assert column1.children[0].children[0].children[0].text == 'mno'
    assert column2.children[0].children[0].children[0].text == 'pqr'


@assert_no_logs
def test_column_span_8():
    page1, page2 = render_pages('''
      <style>
        @page { margin: 0; size: 8px 2px }
        body { font-family: weasyprint; font-size: 1px }
        div { columns: 2; column-gap: 0; line-height: 1 }
        section { column-span: all }
      </style>
      <div>
        abc def
        ghi jkl
        mno pqr
        <section>line1</section>
      </div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    column1, column2 = div.children
    assert (column1.position_x, column1.position_y) == (0, 0)
    assert (column2.position_x, column2.position_y) == (4, 0)

    assert column1.children[0].children[0].children[0].text == 'abc'
    assert column1.children[0].children[1].children[0].text == 'def'
    assert column2.children[0].children[0].children[0].text == 'ghi'
    assert column2.children[0].children[1].children[0].text == 'jkl'

    html, = page2.children
    body, = html.children
    div, = body.children
    column1, column2, section = div.children
    assert (column1.position_x, column1.position_y) == (0, 0)
    assert (column2.position_x, column2.position_y) == (4, 0)
    assert (section.position_x, section.position_y) == (0, 1)

    assert column1.children[0].children[0].children[0].text == 'mno'
    assert column2.children[0].children[0].children[0].text == 'pqr'
    assert section.children[0].children[0].text == 'line1'


@assert_no_logs
def test_column_span_9():
    page1, = render_pages('''
      <style>
        @page { margin: 0; size: 8px 3px }
        body { font-family: weasyprint; font-size: 1px }
        div { columns: 2; column-gap: 0; line-height: 1 }
        section { column-span: all }
      </style>
      <div>
        abc
        <section>line1</section>
        def ghi
      </div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    column1, section, column2, column3 = div.children
    assert (column1.position_x, column1.position_y) == (0, 0)
    assert (section.position_x, section.position_y) == (0, 1)
    assert (column2.position_x, column2.position_y) == (0, 2)
    assert (column3.position_x, column3.position_y) == (4, 2)

    assert column1.children[0].children[0].children[0].text == 'abc'
    assert section.children[0].children[0].text == 'line1'
    assert column2.children[0].children[0].children[0].text == 'def'
    assert column3.children[0].children[0].children[0].text == 'ghi'


@assert_no_logs
def test_column_span_balance():
    page, = render_pages('''
      <style>
        @page { margin: 0; size: 8px 5px }
        body { font-family: weasyprint; font-size: 1px }
        div { columns: 2; column-gap: 0; line-height: 1; column-fill: auto }
        section { column-span: all }
      </style>
      <div>
        abc def
        <section>line1</section>
        ghi jkl
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    column1, column2, section, column3 = div.children
    assert (column1.position_x, column1.position_y) == (0, 0)
    assert (column2.position_x, column2.position_y) == (4, 0)
    assert (section.position_x, section.position_y) == (0, 1)
    assert (column3.position_x, column3.position_y) == (0, 2)

    assert column1.children[0].children[0].children[0].text == 'abc'
    assert column2.children[0].children[0].children[0].text == 'def'
    assert section.children[0].children[0].text == 'line1'
    assert column3.children[0].children[0].children[0].text == 'ghi'
    assert column3.children[0].children[1].children[0].text == 'jkl'


@assert_no_logs
def test_columns_multipage():
    page1, page2 = render_pages('''
      <style>
        div { columns: 2; column-gap: 1px }
        body { margin: 0; font-family: weasyprint;
               font-size: 1px; line-height: 1px }
        @page { margin: 0; size: 3px 2px }
      </style>
      <div>a b c d e f g</div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 2
    assert len(columns[0].children) == 2
    assert len(columns[1].children) == 2
    assert columns[0].children[0].children[0].text == 'a'
    assert columns[0].children[1].children[0].text == 'b'
    assert columns[1].children[0].children[0].text == 'c'
    assert columns[1].children[1].children[0].text == 'd'

    html, = page2.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 2
    assert len(columns[0].children) == 2
    assert len(columns[1].children) == 1
    assert columns[0].children[0].children[0].text == 'e'
    assert columns[0].children[1].children[0].text == 'f'
    assert columns[1].children[0].children[0].text == 'g'


@assert_no_logs
def test_columns_breaks():
    page1, page2 = render_pages('''
      <style>
        div { columns: 2; column-gap: 1px }
        body { margin: 0; font-family: weasyprint;
               font-size: 1px; line-height: 1px }
        @page { margin: 0; size: 3px 2px }
        section { break-before: always; }
      </style>
      <div>a<section>b</section><section>c</section></div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 2
    assert len(columns[0].children) == 1
    assert len(columns[1].children) == 1
    assert columns[0].children[0].children[0].children[0].text == 'a'
    assert columns[1].children[0].children[0].children[0].text == 'b'

    html, = page2.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 1
    assert len(columns[0].children) == 1
    assert columns[0].children[0].children[0].children[0].text == 'c'


@assert_no_logs
def test_columns_break_after_column_1():
    page1, = render_pages('''
      <style>
        div { columns: 2; column-gap: 1px }
        body { margin: 0; font-family: weasyprint;
               font-size: 1px; line-height: 1px }
        @page { margin: 0; size: 3px 10px }
        section { break-after: column }
      </style>
      <div>a b <section>c</section> d</div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 2
    assert columns[0].children[0].children[0].children[0].text == 'a'
    assert columns[0].children[0].children[1].children[0].text == 'b'
    assert columns[0].children[1].children[0].children[0].text == 'c'
    assert columns[1].children[0].children[0].children[0].text == 'd'


@assert_no_logs
def test_columns_break_after_column_2():
    page1, = render_pages('''
      <style>
        div { columns: 2; column-gap: 1px }
        body { margin: 0; font-family: weasyprint;
               font-size: 1px; line-height: 1px }
        @page { margin: 0; size: 3px 10px }
        section { break-after: column }
      </style>
      <div><section>a</section> b c d</div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 2
    assert columns[0].children[0].children[0].children[0].text == 'a'
    assert columns[1].children[0].children[0].children[0].text == 'b'
    assert columns[1].children[0].children[1].children[0].text == 'c'
    assert columns[1].children[0].children[2].children[0].text == 'd'


@assert_no_logs
def test_columns_break_after_avoid_column():
    page1, = render_pages('''
      <style>
        div { columns: 2; column-gap: 1px }
        body { margin: 0; font-family: weasyprint;
               font-size: 1px; line-height: 1px }
        @page { margin: 0; size: 3px 10px }
        section { break-after: avoid-column }
      </style>
      <div>a <section>b</section> c d</div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 2
    assert columns[0].children[0].children[0].children[0].text == 'a'
    assert columns[0].children[1].children[0].children[0].text == 'b'
    assert columns[0].children[2].children[0].children[0].text == 'c'
    assert columns[1].children[0].children[0].children[0].text == 'd'


@assert_no_logs
def test_columns_break_before_column_1():
    page1, = render_pages('''
      <style>
        div { columns: 2; column-gap: 1px }
        body { margin: 0; font-family: weasyprint;
               font-size: 1px; line-height: 1px }
        @page { margin: 0; size: 3px 10px }
        section { break-before: column }
      </style>
      <div>a b c <section>d</section></div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 2
    assert columns[0].children[0].children[0].children[0].text == 'a'
    assert columns[0].children[0].children[1].children[0].text == 'b'
    assert columns[0].children[0].children[2].children[0].text == 'c'
    assert columns[1].children[0].children[0].children[0].text == 'd'


@assert_no_logs
def test_columns_break_before_column_2():
    page1, = render_pages('''
      <style>
        div { columns: 2; column-gap: 1px }
        body { margin: 0; font-family: weasyprint;
               font-size: 1px; line-height: 1px }
        @page { margin: 0; size: 3px 10px }
        section { break-before: column }
      </style>
      <div>a <section>b</section> c d</div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 2
    assert columns[0].children[0].children[0].children[0].text == 'a'
    assert columns[1].children[0].children[0].children[0].text == 'b'
    assert columns[1].children[1].children[0].children[0].text == 'c'
    assert columns[1].children[1].children[1].children[0].text == 'd'


@assert_no_logs
def test_columns_break_before_avoid_column():
    page1, = render_pages('''
      <style>
        div { columns: 2; column-gap: 1px }
        body { margin: 0; font-family: weasyprint;
               font-size: 1px; line-height: 1px }
        @page { margin: 0; size: 3px 10px }
        section { break-before: avoid-column }
      </style>
      <div>a b <section>c</section> d</div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 2
    assert columns[0].children[0].children[0].children[0].text == 'a'
    assert columns[0].children[0].children[1].children[0].text == 'b'
    assert columns[0].children[1].children[0].children[0].text == 'c'
    assert columns[1].children[0].children[0].children[0].text == 'd'


@assert_no_logs
def test_columns_break_inside_column_1():
    page1, = render_pages('''
      <style>
        div { columns: 2; column-gap: 1px }
        body { margin: 0; font-family: weasyprint;
               font-size: 1px; line-height: 1px }
        @page { margin: 0; size: 3px 10px }
        section { break-inside: avoid-column }
      </style>
      <div><section>a b c</section> d</div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 2
    assert columns[0].children[0].children[0].children[0].text == 'a'
    assert columns[0].children[0].children[1].children[0].text == 'b'
    assert columns[0].children[0].children[2].children[0].text == 'c'
    assert columns[1].children[0].children[0].children[0].text == 'd'


@assert_no_logs
def test_columns_break_inside_column_2():
    page1, = render_pages('''
      <style>
        div { columns: 2; column-gap: 1px }
        body { margin: 0; font-family: weasyprint;
               font-size: 1px; line-height: 1px }
        @page { margin: 0; size: 3px 10px }
        section { break-inside: avoid-column }
      </style>
      <div>a <section>b c d</section></div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    columns = div.children
    assert len(columns) == 2
    assert columns[0].children[0].children[0].children[0].text == 'a'
    assert columns[1].children[0].children[0].children[0].text == 'b'
    assert columns[1].children[0].children[1].children[0].text == 'c'
    assert columns[1].children[0].children[2].children[0].text == 'd'


@assert_no_logs
def test_columns_break_inside_column_not_empty_page():
    page1, = render_pages('''
      <style>
        div { columns: 2; column-gap: 1px }
        body { margin: 0; font-family: weasyprint;
               font-size: 1px; line-height: 1px }
        @page { margin: 0; size: 3px 10px }
        section { break-inside: avoid-column }
      </style>
      <p>p</p>
      <div><section>a b c</section> d</div>
    ''')
    html, = page1.children
    body, = html.children
    p, div, = body.children
    assert p.children[0].children[0].text == 'p'
    columns = div.children
    assert len(columns) == 2
    assert columns[0].children[0].children[0].children[0].text == 'a'
    assert columns[0].children[0].children[1].children[0].text == 'b'
    assert columns[0].children[0].children[2].children[0].text == 'c'
    assert columns[1].children[0].children[0].children[0].text == 'd'


@assert_no_logs
def test_columns_not_enough_content():
    page, = render_pages('''
      <style>
        div { columns: 5; column-gap: 0 }
        body { margin: 0; font-family: weasyprint; font-size: 1px }
        @page { margin: 0; size: 5px }
      </style>
      <div>a b c</div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.width == 5
    columns = div.children
    assert len(columns) == 3
    assert [column.width for column in columns] == [1, 1, 1]
    assert [column.position_x for column in columns] == [0, 1, 2]
    assert [column.position_y for column in columns] == [0, 0, 0]


@assert_no_logs
def test_columns_higher_than_page():
    page1, page2 = render_pages('''
      <style>
        div { columns: 5; column-gap: 0 }
        body { margin: 0; font-family: weasyprint; font-size: 2px }
        @page { margin: 0; size: 5px 1px }
      </style>
      <div>a b c d e f g h</div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    assert div.width == 5
    columns = div.children
    assert len(columns) == 5
    assert columns[0].children[0].children[0].text == 'a'
    assert columns[1].children[0].children[0].text == 'b'
    assert columns[2].children[0].children[0].text == 'c'
    assert columns[3].children[0].children[0].text == 'd'
    assert columns[4].children[0].children[0].text == 'e'

    html, = page2.children
    body, = html.children
    div, = body.children
    assert div.width == 5
    columns = div.children
    assert len(columns) == 3
    assert columns[0].children[0].children[0].text == 'f'
    assert columns[1].children[0].children[0].text == 'g'
    assert columns[2].children[0].children[0].text == 'h'


@assert_no_logs
def test_columns_empty():
    page, = render_pages('''
      <style>
        div { columns: 3 }
        body { margin: 0; font-family: weasyprint }
        @page { margin: 0; size: 3px; font-size: 1px }
      </style>
      <div></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.width == 3
    assert div.height == 0
    columns = div.children
    assert len(columns) == 0


@assert_no_logs
@pytest.mark.parametrize('prop', ['height', 'min-height'])
def test_columns_fixed_height(prop):
    # TODO: we should test when the height is too small
    page, = render_pages('''
      <style>
        div { columns: 4; column-gap: 0; %s: 10px }
        body { margin: 0; font-family: weasyprint; line-height: 1px }
        @page { margin: 0; size: 4px 50px; font-size: 1px }
      </style>
      <div>a b c</div>
    ''' % prop)
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.width == 4
    columns = div.children
    assert len(columns) == 3
    assert [column.width for column in columns] == [1, 1, 1]
    assert [column.height for column in columns] == [10, 10, 10]
    assert [column.position_x for column in columns] == [0, 1, 2]
    assert [column.position_y for column in columns] == [0, 0, 0]


@assert_no_logs
def test_columns_padding():
    page, = render_pages('''
      <style>
        div { columns: 4; column-gap: 0; padding: 1px }
        body { margin: 0; font-family: weasyprint; line-height: 1px }
        @page { margin: 0; size: 6px 50px; font-size: 1px }
      </style>
      <div>a b c</div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.width == 4
    assert div.height == 1
    assert div.padding_width() == 6
    assert div.padding_height() == 3
    columns = div.children
    assert len(columns) == 3
    assert [column.width for column in columns] == [1, 1, 1]
    assert [column.height for column in columns] == [1, 1, 1]
    assert [column.position_x for column in columns] == [1, 2, 3]
    assert [column.position_y for column in columns] == [1, 1, 1]


@assert_no_logs
def test_columns_bottom_margin():
    page, = render_pages('''
      <style>
        div { columns: 2; column-gap: 1px }
        body { margin: 0; font: 2px / 1 weasyprint }
        p { margin-bottom: 1em }
        @page { margin: 0; size: 5px 7px; font-size: 1px }
      </style>
      <div><p>a b c</p></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    column1, column2 = div.children
    p, = column1.children
    line1, line2 = p.children
    assert line1.children[0].text == 'a'
    assert line2.children[0].text == 'b'
    p, = column2.children
    line1, = p.children
    assert line1.children[0].text == 'c'


@assert_no_logs
def test_columns_relative():
    page, = render_pages('''
      <style>
        article { position: absolute; top: 3px }
        div { columns: 4; column-gap: 0; position: relative;
              top: 1px; left: 2px }
        body { margin: 0; font-family: weasyprint; line-height: 1px }
        @page { margin: 0; size: 4px 50px; font-size: 1px }
      </style>
      <div>a b c d<article>e</article></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.width == 4
    columns = div.children
    assert [column.width for column in columns] == [1, 1, 1, 1]
    assert [column.position_x for column in columns] == [2, 3, 4, 5]
    assert [column.position_y for column in columns] == [1, 1, 1, 1]
    column4 = columns[-1]
    column_line, = column4.children
    _, absolute_article = column_line.children
    absolute_line, = absolute_article.children
    span, = absolute_line.children
    assert span.position_x == 5  # Default position of the 4th column
    assert span.position_y == 4  # div's 1px + span's 3px


@assert_no_logs
def test_columns_regression_1():
    # Regression test for #659.
    page1, page2, page3 = render_pages('''
      <style>
        @page {margin: 0; width: 100px; height: 100px}
        body {margin: 0; font-size: 1px}
      </style>
      <div style="height:95px">A</div>
      <div style="column-count:2">
        <div style="height:20px">B1</div>
        <div style="height:20px">B2</div>
        <div style="height:20px">B3</div>
      </div>
      <div style="height:95px">C</div>
    ''')

    html, = page1.children
    body, = html.children
    div, = body.children
    assert div.position_y == 0
    assert div.children[0].children[0].text == 'A'

    html, = page2.children
    body, = html.children
    div, = body.children
    assert div.position_y == 0
    column1, column2 = div.children
    assert column1.position_y == column2.position_y == 0
    div1, div2 = column1.children
    div3, = column2.children
    assert div1.position_y == div3.position_y == 0
    assert div2.position_y == 20
    assert div1.children[0].children[0].text == 'B1'
    assert div2.children[0].children[0].text == 'B2'
    assert div3.children[0].children[0].text == 'B3'

    html, = page3.children
    body, = html.children
    div, = body.children
    assert div.position_y == 0
    assert div.children[0].children[0].text == 'C'


@assert_no_logs
def test_columns_regression_2():
    # Regression test for #659.
    page1, page2 = render_pages('''
      <style>
        @page {margin: 0; width: 100px; height: 100px}
        body {margin: 0; font-size: 1px}
      </style>
      <div style="column-count:2">
        <div style="height:20px">B1</div>
        <div style="height:60px">B2</div>
        <div style="height:60px">B3</div>
        <div style="height:60px">B4</div>
      </div>
    ''')

    html, = page1.children
    body, = html.children
    div, = body.children
    assert div.position_y == 0
    column1, column2 = div.children
    assert column1.position_y == column2.position_y == 0
    div1, div2 = column1.children
    div3, = column2.children
    assert div1.position_y == div3.position_y == 0
    assert div2.position_y == 20
    assert div1.children[0].children[0].text == 'B1'
    assert div2.children[0].children[0].text == 'B2'
    assert div3.children[0].children[0].text == 'B3'

    html, = page2.children
    body, = html.children
    div, = body.children
    assert div.position_y == 0
    column1, = div.children
    assert column1.position_y == 0
    div1, = column1.children
    assert div1.position_y == div3.position_y == 0
    assert div1.children[0].children[0].text == 'B4'


@assert_no_logs
def test_columns_regression_3():
    # Regression test for #659.
    page, = render_pages('''
      <style>
        @page {margin: 0; width: 100px; height: 100px}
        body {margin: 0; font-size: 10px}
      </style>
      <div style="column-count:2">
        <div style="height:20px; margin:5px">B1</div>
        <div style="height:60px">B2</div>
        <div style="height:60px">B3</div>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.position_y == 0
    column1, column2 = div.children
    assert column1.position_y == column2.position_y == 0
    div1, div2 = column1.children
    div3, = column2.children
    assert div1.position_y == div3.position_y == 0
    assert div2.position_y == 30
    assert div.height == 5 + 20 + 5 + 60
    assert div1.children[0].children[0].text == 'B1'
    assert div2.children[0].children[0].text == 'B2'
    assert div3.children[0].children[0].text == 'B3'


@assert_no_logs
def test_columns_regression_4():
    # Regression test for #897.
    page, = render_pages('''
      <div style="position:absolute">
        <div style="column-count:2">
          <div>a</div>
        </div>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.position_y == 0
    column1, = div.children
    assert column1.position_y == 0
    div1, = column1.children
    assert div1.position_y == 0


@assert_no_logs
def test_columns_regression_5():
    # Regression test for #1191.
    render_pages('''
      <style>
        @page {width: 100px; height: 100px}
      </style>
      <div style="height: 1px"></div>
      <div style="columns: 2">
        <div style="break-after: avoid">
          <div style="height: 50px"></div>
        </div>
        <div style="break-after: avoid">
          <div style="height: 50px"></div>
          <p>a</p>
        </div>
      </div>
      <div style="height: 50px"></div>
    ''')


@assert_no_logs
def test_columns_regression_6():
    # Regression test for #2103.
    render_pages('''
      <style>
        @page {width: 100px; height: 100px}
      </style>
      <div style="columns: 2; column-width: 100px; width: 10px">abc def</div>
    ''')


@assert_no_logs
def test_columns_regression_7():
    page1, page2 = render_pages('''
      <style>
        @page { size: 50px 10px }
        body { font-size: 2px; line-height: 1 }
      </style>
      <div style="height: 8px"></div>
      <div style="column-count: 2">
        <div>a</div>
        <div style="break-inside: avoid">b<br>c<br>d</div>
      </div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    assert div.position_y == 0
    assert not div.children
    html, = page2.children
    body, = html.children
    div, = body.children
    column1, column2 = div.children
    assert column1.position_y == 0
    assert column2.position_y == 0


@assert_no_logs
def test_columns_margin_top():
    page1, = render_pages('''
      <style>
        @page { size: 50px 10px }
        body { font-size: 2px; line-height: 1 }
      </style>
      <div style="column-count: 2; margin-top: 1em">
        a<br>b
      </div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    assert div.position_y == 0
    column1, column2 = div.children
    assert column1.position_y == column2.position_y == 2
    assert column1.children[0].position_y == column2.children[0].position_y == 2


@assert_no_logs
def test_columns_grid():
    # Regression test for #2680.
    page1, = render_pages('''
      <div style="columns: 2">
        <div>1</div>
        <div style="display: grid">2</div>
      </div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    column1, column2 = div.children


================================================
FILE: tests/layout/test_flex.py
================================================
"""Tests for flex layout."""

import pytest

from ..testing_utils import assert_no_logs, render_pages


@assert_no_logs
def test_flex_direction_row():
    page, = render_pages('''
      <article style="display: flex">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_y == div2.position_y == div3.position_y == article.position_y
    assert div1.position_x == article.position_x
    assert div1.position_x < div2.position_x < div3.position_x


@assert_no_logs
def test_flex_direction_row_max_width():
    page, = render_pages('''
      <article style="display: flex; max-width: 100px">
        <div></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    assert article.width == 100


@assert_no_logs
def test_flex_direction_row_min_height():
    page, = render_pages('''
      <article style="display: flex; min-height: 100px">
        <div></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    assert article.height == 100


@assert_no_logs
def test_flex_direction_row_rtl():
    page, = render_pages('''
      <article style="display: flex; direction: rtl">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_y == div2.position_y == div3.position_y == article.position_y
    assert div1.position_x + div1.width == article.position_x + article.width
    assert div1.position_x > div2.position_x > div3.position_x


@assert_no_logs
def test_flex_direction_row_rtl_gap():
    page, = render_pages('''
      <article style="display: flex; direction: rtl; gap: 10px">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_y == div2.position_y == div3.position_y == article.position_y
    assert div1.position_x + div1.width == article.position_x + article.width
    assert div1.position_x == div2.position_x + div2.width + 10
    assert div2.position_x == div3.position_x + div3.width + 10


@assert_no_logs
def test_flex_direction_row_reverse():
    page, = render_pages('''
      <article style="display: flex; flex-direction: row-reverse">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'C'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'A'
    assert div1.position_y == div2.position_y == div3.position_y == article.position_y
    assert div3.position_x + div3.width == article.position_x + article.width
    assert div1.position_x < div2.position_x < div3.position_x


@assert_no_logs
def test_flex_direction_row_reverse_rtl():
    page, = render_pages('''
      <article style="display: flex; flex-direction: row-reverse;
      direction: rtl">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'C'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'A'
    assert div1.position_y == div2.position_y == div3.position_y == article.position_y
    assert div3.position_x == article.position_x
    assert div1.position_x > div2.position_x > div3.position_x


@assert_no_logs
def test_flex_direction_column():
    page, = render_pages('''
      <article style="display: flex; flex-direction: column">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_x == div2.position_x == div3.position_x == article.position_x
    assert div1.position_y == article.position_y
    assert div1.position_y < div2.position_y < div3.position_y


@assert_no_logs
def test_flex_direction_column_min_width():
    page, = render_pages('''
      <article style="display: flex; flex-direction: column; min-height: 100px">
        <div></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    assert article.height == 100


@assert_no_logs
def test_flex_direction_column_max_height():
    page, = render_pages('''
      <article style="display: flex; flex-flow: column wrap; max-height: 100px">
        <div style="height: 40px">A</div>
        <div style="height: 40px">B</div>
        <div style="height: 40px">C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    assert article.height == 100
    div1, div2, div3 = article.children
    assert div1.height == 40
    assert div1.position_x == 0
    assert div1.position_y == 0
    assert div2.height == 40
    assert div2.position_x == 0
    assert div2.position_y == 40
    assert div3.height == 40
    assert div3.position_x == div1.width
    assert div3.position_y == 0


@assert_no_logs
def test_flex_direction_column_rtl():
    page, = render_pages('''
      <article style="display: flex; flex-direction: column;
      direction: rtl">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_x == div2.position_x == div3.position_x == article.position_x
    assert div1.position_y == article.position_y
    assert div1.position_y < div2.position_y < div3.position_y


@assert_no_logs
def test_flex_direction_column_reverse():
    page, = render_pages('''
      <article style="display: flex; flex-direction: column-reverse">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'C'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'A'
    assert div1.position_x == div2.position_x == div3.position_x == article.position_x
    assert div3.position_y + div3.height == article.position_y + article.height
    assert div1.position_y < div2.position_y < div3.position_y


@assert_no_logs
def test_flex_direction_column_reverse_rtl():
    page, = render_pages('''
      <article style="display: flex; flex-direction: column-reverse;
      direction: rtl">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'C'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'A'
    assert div1.position_x == div2.position_x == div3.position_x == article.position_x
    assert div3.position_y + div3.height == article.position_y + article.height
    assert div1.position_y < div2.position_y < div3.position_y


@assert_no_logs
def test_flex_direction_column_box_sizing():
    page, = render_pages('''
      <style>
        article {
          box-sizing: border-box;
          display: flex;
          flex-direction: column;
          height: 10px;
          padding-top: 5px;
          width: 10px;
        }
      </style>
      <article></article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    assert article.width == 10
    assert article.height == 5
    assert article.padding_top == 5


@assert_no_logs
def test_flex_row_wrap():
    page, = render_pages('''
      <article style="display: flex; flex-flow: wrap; width: 50px">
        <div style="width: 20px">A</div>
        <div style="width: 20px">B</div>
        <div style="width: 20px">C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_y == div2.position_y == article.position_y
    assert div3.position_y == article.position_y + div2.height
    assert div1.position_x == div3.position_x == article.position_x
    assert div1.position_x < div2.position_x


@assert_no_logs
def test_flex_column_wrap():
    page, = render_pages('''
      <article style="display: flex; flex-flow: column wrap; height: 50px">
        <div style="height: 20px">A</div>
        <div style="height: 20px">B</div>
        <div style="height: 20px">C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_x == div2.position_x == article.position_x
    assert div3.position_x == article.position_x + div2.width
    assert div1.position_y == div3.position_y == article.position_y
    assert div1.position_y < div2.position_y


@assert_no_logs
def test_flex_row_wrap_reverse():
    page, = render_pages('''
      <article style="display: flex; flex-flow: wrap-reverse; width: 50px">
        <div style="width: 20px">A</div>
        <div style="width: 20px">B</div>
        <div style="width: 20px">C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'C'
    assert div2.children[0].children[0].text == 'A'
    assert div3.children[0].children[0].text == 'B'
    assert div1.position_y == article.position_y
    assert div2.position_y == div3.position_y == article.position_y + div1.height
    assert div1.position_x == div2.position_x == article.position_x
    assert div2.position_x < div3.position_x


@assert_no_logs
def test_flex_column_wrap_reverse():
    page, = render_pages('''
      <article style="display: flex; flex-flow: column wrap-reverse;
                      height: 50px">
        <div style="height: 20px">A</div>
        <div style="height: 20px">B</div>
        <div style="height: 20px">C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'C'
    assert div2.children[0].children[0].text == 'A'
    assert div3.children[0].children[0].text == 'B'
    assert div1.position_x == article.position_x
    assert div2.position_x == div3.position_x == article.position_x + div1.width
    assert div1.position_y == div2.position_y == article.position_y
    assert div2.position_y < div3.position_y


@assert_no_logs
def test_flex_direction_column_fixed_height_container():
    page, = render_pages('''
      <section style="height: 10px">
        <article style="display: flex; flex-direction: column">
          <div>A</div>
          <div>B</div>
          <div>C</div>
        </article>
      </section>
    ''')
    html, = page.children
    body, = html.children
    section, = body.children
    article, = section.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_x == div2.position_x == div3.position_x == article.position_x
    assert div1.position_y == article.position_y
    assert div1.position_y < div2.position_y < div3.position_y
    assert section.height == 10
    assert article.height > 10


@assert_no_logs
def test_flex_direction_column_fixed_height():
    page, = render_pages('''
      <article style="display: flex; flex-direction: column; height: 10px">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_x == div2.position_x == div3.position_x == article.position_x
    assert div1.position_y == article.position_y
    assert div1.position_y < div2.position_y < div3.position_y
    assert article.height == 10
    assert div3.position_y > 10


@assert_no_logs
def test_flex_direction_column_fixed_height_wrap():
    page, = render_pages('''
      <article style="display: flex; flex-direction: column; height: 10px;
                      flex-wrap: wrap">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_x < div2.position_x < div3.position_x
    assert div1.position_y == article.position_y
    assert div1.position_y == div2.position_y == div3.position_y == article.position_y
    assert article.height == 10


@assert_no_logs
def test_flex_direction_column_break():
    # Regression test for issue #2066.
    page1, page2 = render_pages('''
      <style>
        @page { size: 4px 5px }
      </style>
      <article style="display: flex; flex-direction: column; font: 2px weasyprint">
        <div>A<br>B<br>C</div>
      </article>
    ''')
    html, = page1.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.children[0].children[0].text == 'A'
    assert div.children[1].children[0].text == 'B'
    assert div.height == 5
    html, = page2.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.children[0].children[0].text == 'C'
    assert div.height == 2


@assert_no_logs
def test_flex_direction_column_break_margin():
    # Regression test for issue #1967.
    page1, page2 = render_pages('''
      <style>
        @page { size: 4px 7px }
      </style>
      <body style="font: 2px weasyprint">
        <p style="margin: 1px 0">a</p>
        <article style="display: flex; flex-direction: column">
          <div>A<br>B<br>C</div>
        </article>
      </body>
    ''')
    html, = page1.children
    body, = html.children
    p, article = body.children
    assert p.margin_height() == 4
    assert article.position_y == 4
    div, = article.children
    assert div.children[0].children[0].text == 'A'
    assert div.height == 3
    html, = page2.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.children[0].children[0].text == 'B'
    assert div.children[1].children[0].text == 'C'
    assert div.height == 4


@assert_no_logs
def test_flex_direction_column_break_border():
    page1, page2 = render_pages('''
      <style>
        @page { size: 8px 7px }
        article, div { border: 1px solid black }
      </style>
      <article style="display: flex; flex-direction: column; font: 2px weasyprint">
        <div>A B C</div>
      </article>
    ''')
    html, = page1.children
    body, = html.children
    article, = body.children
    assert article.border_height() == 7
    assert article.border_top_width == 1
    assert article.border_bottom_width == 0
    div, = article.children
    assert div.children[0].children[0].text == 'A'
    assert div.children[1].children[0].text == 'B'
    assert div.border_height() == 6
    assert div.border_top_width == 1
    assert div.border_bottom_width == 0
    html, = page2.children
    body, = html.children
    article, = body.children
    assert article.border_height() == 4
    assert article.border_top_width == 0
    assert article.border_bottom_width == 1
    div, = article.children
    assert div.children[0].children[0].text == 'C'
    assert div.border_height() == 3
    assert div.border_top_width == 0
    assert div.border_bottom_width == 1


@assert_no_logs
def test_flex_direction_column_break_multiple_children():
    page1, page2 = render_pages('''
      <style>
        @page { size: 4px 5px }
      </style>
      <article style="display: flex; flex-direction: column; font: 2px weasyprint">
        <div>A</div>
        <div>B<br>C</div>
      </article>
    ''')
    html, = page1.children
    body, = html.children
    article, = body.children
    div1, div2 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div1.height == 2
    assert div2.children[0].children[0].text == 'B'
    assert div2.height == 3
    html, = page2.children
    body, = html.children
    article, = body.children
    div2, = article.children
    assert div2.children[0].children[0].text == 'C'
    assert div2.height == 2


@assert_no_logs
def test_flex_item_min_width():
    page, = render_pages('''
      <article style="display: flex">
        <div style="min-width: 30px">A</div>
        <div style="min-width: 50px">B</div>
        <div style="min-width: 5px">C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_x == 0
    assert div1.width == 30
    assert div2.position_x == 30
    assert div2.width == 50
    assert div3.position_x == 80
    assert div3.width > 5
    assert div1.position_y == div2.position_y == div3.position_y == article.position_y


@assert_no_logs
def test_flex_item_min_height():
    page, = render_pages('''
      <article style="display: flex">
        <div style="min-height: 30px">A</div>
        <div style="min-height: 50px">B</div>
        <div style="min-height: 5px">C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.height == div2.height == div3.height == article.height == 50


@assert_no_logs
def test_flex_auto_margin():
    # Regression test for issue #800.
    page, = render_pages('<div style="display: flex; margin: auto"><div>')
    page, = render_pages(
        '<div style="display: flex; flex-direction: column; margin: auto"><div>')


@assert_no_logs
def test_flex_item_auto_margin_sized():
    # Regression test for issue #2054.
    page, = render_pages('''
      <style>
        div {
          margin: auto;
          display: flex;
          width: 160px;
          height: 160px;
        }
      </style>
      <article>
        <div></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.margin_left != 0


@assert_no_logs
def test_flex_no_baseline():
    # Regression test for issue #765.
    page, = render_pages('''
      <div class="references" style="display: flex; align-items: baseline;">
        <div></div>
      </div>''')


@assert_no_logs
@pytest.mark.parametrize(('align', 'height', 'y1', 'y2'), [
    ('flex-start', 50, 0, 10),
    ('flex-end', 50, 30, 40),
    ('space-around', 60, 10, 40),
    ('space-between', 50, 0, 40),
    ('space-evenly', 50, 10, 30),
])
def test_flex_align_content(align, height, y1, y2):
    # Regression test for issue #811.
    page, = render_pages('''
      <style>
        article {
          align-content: %s;
          display: flex;
          flex-wrap: wrap;
          font-family: weasyprint;
          font-size: 10px;
          height: %dpx;
          line-height: 1;
        }
        section {
          width: 100%%;
        }
      </style>
      <article>
        <section><span>Lorem</span></section>
        <section><span>Lorem</span></section>
      </article>
    ''' % (align, height))
    html, = page.children
    body, = html.children
    article, = body.children
    section1, section2 = article.children
    line1, = section1.children
    line2, = section2.children
    span1, = line1.children
    span2, = line2.children
    assert section1.position_x == span1.position_x == 0
    assert section1.position_y == span1.position_y == y1
    assert section2.position_x == span2.position_x == 0
    assert section2.position_y == span2.position_y == y2


@assert_no_logs
def test_flex_item_percentage():
    # Regression test for issue #885.
    page, = render_pages('''
      <div style="display: flex; font-size: 15px; line-height: 1">
        <div style="height: 100%">a</div>
      </div>''')
    html, = page.children
    body, = html.children
    flex, = body.children
    flex_item, = flex.children
    assert flex_item.height == 15


@assert_no_logs
def test_flex_undefined_percentage_height_multiple_lines():
    # Regression test for issue #1204.
    page, = render_pages('''
      <div style="display: flex; flex-wrap: wrap; height: 100%">
        <div style="width: 100%">a</div>
        <div style="width: 100%">b</div>
      </div>''')


@assert_no_logs
def test_flex_absolute():
    # Regression test for issue #1536.
    page, = render_pages('''
      <div style="display: flex; position: absolute">
        <div>a</div>
      </div>''')


@assert_no_logs
def test_flex_percent_height():
    page, = render_pages('''
      <style>
        .a { height: 10px; width: 10px; }
        .b { height: 10%; width: 100%; display: flex; flex-direction: column; }
      </style>
      <div class="a"">
        <div class="b"></div>
      </div>''')
    html, = page.children
    body, = html.children
    a, = body.children
    b, = a.children
    assert a.height == 10
    assert b.height == 1


@assert_no_logs
def test_flex_percent_height_auto():
    # Regression test for issue #2146.
    page, = render_pages('''
      <style>
        .a { width: 10px; }
        .b { height: 10%; width: 100%; display: flex; flex-direction: column; }
      </style>
      <div class="a"">
        <div class="b"></div>
      </div>''')


@assert_no_logs
def test_flex_break_inside_avoid():
    # Regression test for issue #2183.
    page1, page2 = render_pages('''
      <style>
        @page { size: 6px 4px }
        html { font-family: weasyprint; font-size: 2px }
      </style>
      <article style="display: flex; flex-wrap: wrap">
        <div>ABC</div>
        <div style="break-inside: avoid">abc def</div>
      </article>''')
    html, = page1.children
    body, = html.children
    article, = body.children
    div, = article.children
    html, = page2.children
    body, = html.children
    article, = body.children
    div, = article.children


@assert_no_logs
def test_flex_absolute_content():
    # Regression test for issue #996.
    page, = render_pages('''
      <section style="display: flex; position: relative">
         <h1 style="position: absolute; top: 0; right: 0">TEST</h1>
         <p>Hello world!</p>
      </section>''')
    html, = page.children
    body, = html.children
    section, = body.children
    h1, p = section.children
    assert h1.position_x != 0
    assert h1.position_y == 0
    assert p.position_x == 0
    assert p.position_y == 0


@assert_no_logs
def test_flex_column_height():
    # Regression test for issue #2222.
    page, = render_pages('''
      <section style="display: flex; width: 10em">
        <article style="display: flex; flex-direction: column">
          <div>
            Lorem ipsum dolor sit amet
          </div>
        </article>
        <article style="display: flex; flex-direction: column">
          <div>
            Lorem ipsum dolor sit amet
          </div>
        </article>
      </section>
    ''')
    html, = page.children
    body, = html.children
    section, = body.children
    article1, article2 = section.children
    assert article1.height == section.height
    assert article2.height == section.height


@assert_no_logs
def test_flex_column_height_margin():
    # Regression test for issue #2222.
    page, = render_pages('''
      <section style="display: flex; flex-direction: column; width: 10em">
        <article style="margin: 5px">
          Lorem ipsum dolor sit amet
        </article>
        <article style="margin: 10px">
          Lorem ipsum dolor sit amet
        </article>
      </section>
    ''')
    html, = page.children
    body, = html.children
    section, = body.children
    article1, article2 = section.children
    assert section.height == article1.margin_height() + article2.margin_height()


@assert_no_logs
def test_flex_column_width():
    # Regression test for issue #1171.
    page, = render_pages('''
      <main style="display: flex; flex-direction: column;
                   width: 40px; height: 50px; font: 2px weasyprint">
        <section style="width: 100%; height: 5px">a</section>
        <section style="display: flex; flex: auto; flex-direction: column;
                        justify-content: space-between; width: 100%">
          <div>b</div>
          <div>c</div>
        </section>
      </main>
    ''')
    html, = page.children
    body, = html.children
    main, = body.children
    section1, section2 = main.children
    div1, div2 = section2.children
    assert section1.width == section2.width == main.width
    assert div1.width == div2.width
    assert div1.position_y == 5
    assert div2.position_y == 48


@assert_no_logs
def test_flex_column_in_flex_row():
    page, = render_pages('''
      <body style="display: flex; flex-wrap: wrap; font: 2px weasyprint">
        <article>1</article>
        <section style="display: flex; flex-direction: column">
          <div>2</div>
        </section>
      </body>
    ''')
    html, = page.children
    body, = html.children
    article, section = body.children
    assert article.position_y == section.position_y == 0
    assert article.position_x == 0
    assert section.position_x == 2


@assert_no_logs
def test_flex_overflow():
    # Regression test for issue #2292.
    page, = render_pages('''
      <style>
        article {
          display: flex;
        }
        section {
          overflow: hidden;
          width: 5px;
        }
      </style>
      <article>
        <section>A</section>
        <section>B</section>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    section_1 = article.children[0]
    section_2 = article.children[1]
    assert section_1.position_x == 0
    assert section_2.position_x == 5


@assert_no_logs
def test_flex_column_overflow():
    # Regression test for issue #2304.
    render_pages('''
      <style>
        @page {size: 20px}
      </style>
      <div style="display: flex; flex-direction: column">
        <div></div>
        <div><div style="height: 40px"></div></div>
        <div><div style="height: 5px"></div></div>
      </div>
    ''')


@assert_no_logs
def test_inline_flex():
    render_pages('''
      <style>
        @page {size: 20px}
      </style>
      <div style="display: inline-flex; flex-direction: column">
        <div>test</div>
      </div>
    ''')


@assert_no_logs
def test_inline_flex_empty_child():
    render_pages('''
      <style>
        @page {size: 20px}
      </style>
      <div style="display: inline-flex; flex-direction: column">
        <div></div>
      </div>
    ''')


@assert_no_logs
def test_inline_flex_absolute_baseline():
    render_pages('''
      <style>
        @page {size: 20px}
      </style>
      <div style="display: inline-flex; flex-direction: column">
        <div style="position: absolute">abs</div>
      </div>
    ''')


@assert_no_logs
def test_flex_item_overflow():
    # Regression test for issue #2359.
    page, = render_pages('''
      <div style="display: flex; font: 2px weasyprint; width: 12px">
        <div>ab</div>
        <div>c d e</div>
        <div>f</div>
      </div>''')
    html, = page.children
    body, = html.children
    flex, = body.children
    div1, div2, div3 = flex.children
    assert div1.width == 4
    assert div2.width == 6
    assert div3.width == 2
    line1, line2 = div2.children
    text1, = line1.children
    text2, = line2.children
    assert text1.text == 'c d'
    assert text2.text == 'e'


@assert_no_logs
@pytest.mark.parametrize('direction', ['row', 'column'])
def test_flex_item_child_bottom_margin(direction):
    # Regression test for issue #2449.
    page, = render_pages('''
      <div style="display: flex; font: 2px weasyprint; flex-direction: %s">
        <section>
          <div style="margin: 2px 0">ab</div>
        </section>
      </div>''' % direction)
    html, = page.children
    body, = html.children
    flex, = body.children
    assert flex.content_box_y() == 0
    assert flex.height == 6
    section, = flex.children
    assert section.content_box_y() == 0
    assert section.height == 6
    div, = section.children
    assert div.content_box_y() == 2
    assert div.height == 2


@assert_no_logs
def test_flex_direction_row_inline_block():
    # Regression test for issue #1652.
    page, = render_pages('''
      <article style="display: flex; font: 2px weasyprint; width: 14px">
        <div style="display: inline-block">A B C D E F</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.width == 14
    assert div.children[0].children[0].text == 'A B C D'
    assert div.children[1].children[0].text == 'E F'


@assert_no_logs
def test_flex_float():
    page, = render_pages('''
      <article style="display: flex">
        <div style="float: left">A</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.children[0].children[0].text == 'A'


@assert_no_logs
def test_flex_float_in_flex_item():
    # Regression test for issue #1356.
    page, = render_pages('''
      <article style="display: flex; font: 2px weasyprint">
        <div style="width: 10px"><span style="float: right">abc</span></div>
        <div style="width: 10px"><span style="float: right">abc</span></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2 = article.children
    span1, = div1.children
    assert span1.position_y == 0
    assert span1.position_x + span1.width == 10
    span2, = div2.children
    assert span2.position_y == 0
    assert span2.position_x + span2.width == 20


@assert_no_logs
def test_flex_direction_row_defined_main():
    page, = render_pages('''
      <article style="display: flex">
        <div style="width: 10px; padding: 1px"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.width == 10
    assert div.margin_width() == 12


@assert_no_logs
def test_flex_direction_row_defined_main_border_box():
    page, = render_pages('''
      <article style="display: flex">
        <div style="box-sizing: border-box; width: 10px; padding: 1px"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.width == 8
    assert div.margin_width() == 10


@assert_no_logs
def test_flex_direction_column_defined_main():
    page, = render_pages('''
      <article style="display: flex; flex-direction: column">
        <div style="height: 10px; padding: 1px"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.height == 10
    assert div.margin_height() == 12


@assert_no_logs
def test_flex_direction_column_defined_main_border_box():
    page, = render_pages('''
      <article style="display: flex; flex-direction: column">
        <div style="box-sizing: border-box; height: 10px; padding: 1px"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.height == 8
    assert div.margin_height() == 10


@assert_no_logs
def test_flex_item_negative_margin():
    page, = render_pages('''
      <article style="display: flex">
        <div style="margin-left: -20px; height: 10px; width: 10px"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.height == 10
    assert div.width == 10


@assert_no_logs
def test_flex_item_auto_margin_main():
    page, = render_pages('''
      <article style="display: flex; width: 100px">
        <div style="margin-left: auto; height: 10px; width: 10px"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.height == 10
    assert div.width == 10
    assert div.margin_left == 90


@assert_no_logs
def test_flex_item_auto_margin_cross():
    page, = render_pages('''
      <article style="display: flex; height: 100px">
        <div style="margin-top: auto; height: 10px; width: 10px"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.height == 10
    assert div.width == 10
    assert div.margin_top == 90


@assert_no_logs
def test_flex_direction_column_item_auto_margin():
    page, = render_pages('''
      <div style="font: 2px weasyprint; width: 30px; display: flex;
                  flex-direction: column; align-items: flex-start">
          <article style="margin: 0 auto">XXXX</article>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    article, = div.children
    assert article.width == 8
    assert article.margin_left == 11


@assert_no_logs
def test_flex_item_auto_margin_flex_basis():
    page, = render_pages('''
      <article style="display: flex">
        <div style="margin-left: auto; height: 10px; flex-basis: 10px"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert div.height == 10
    assert div.width == 10


@assert_no_logs
@pytest.mark.parametrize(('align', 'x1', 'x2', 'x3'), [
    ('start', 0, 2, 4),
    ('flex-start', 0, 2, 4),
    ('left', 0, 2, 4),
    ('end', 6, 8, 10),
    ('flex-end', 6, 8, 10),
    ('right', 6, 8, 10),
    ('center', 3, 5, 7),
    ('space-between', 0, 5, 10),
    ('space-around', 1, 5, 9),
    ('space-evenly', 1.5, 5, 8.5),
])
def test_flex_direction_row_justify(align, x1, x2, x3):
    page, = render_pages(f'''
      <article style="width: 12px; font: 2px weasyprint;
                      display: flex; justify-content: {align}">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_y == div2.position_y == div3.position_y == article.position_y
    assert article.position_x == 0
    assert div1.position_x == x1
    assert div2.position_x == x2
    assert div3.position_x == x3


@assert_no_logs
@pytest.mark.parametrize(('align', 'y1', 'y2', 'y3'), [
    ('start', 0, 2, 4),
    ('flex-start', 0, 2, 4),
    ('left', 0, 2, 4),
    ('end', 6, 8, 10),
    ('flex-end', 6, 8, 10),
    ('right', 6, 8, 10),
    ('center', 3, 5, 7),
    ('space-between', 0, 5, 10),
    ('space-around', 1, 5, 9),
    ('space-evenly', 1.5, 5, 8.5),
])
def test_flex_direction_column_justify(align, y1, y2, y3):
    page, = render_pages(f'''
      <article style="height: 12px; font: 2px weasyprint;
                      display: flex; flex-direction: column; justify-content: {align}">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_x == div2.position_x == div3.position_x == article.position_x
    assert article.position_y == 0
    assert div1.position_y == y1
    assert div2.position_y == y2
    assert div3.position_y == y3


@assert_no_logs
@pytest.mark.parametrize(('align', 'x1', 'x2', 'x3'), [
    ('start', 0, 4, 8),
    ('flex-start', 0, 4, 8),
    ('left', 0, 4, 8),
    ('end', 6, 10, 14),
    ('flex-end', 6, 10, 14),
    ('right', 6, 10, 14),
    ('center', 3, 7, 11),
    ('space-between', 0, 7, 14),
    ('space-around', 1, 7, 13),
    ('space-evenly', 1.5, 7, 12.5),
])
def test_flex_direction_row_justify_gap(align, x1, x2, x3):
    page, = render_pages(f'''
      <article style="width: 16px; font: 2px weasyprint; gap: 2px;
                      display: flex; justify-content: {align}">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_y == div2.position_y == div3.position_y == article.position_y
    assert article.position_x == 0
    assert div1.position_x == x1
    assert div2.position_x == x2
    assert div3.position_x == x3


@assert_no_logs
@pytest.mark.parametrize(('align', 'y1', 'y2', 'y3'), [
    ('start', 0, 4, 8),
    ('flex-start', 0, 4, 8),
    ('left', 0, 4, 8),
    ('end', 6, 10, 14),
    ('flex-end', 6, 10, 14),
    ('right', 6, 10, 14),
    ('center', 3, 7, 11),
    ('space-between', 0, 7, 14),
    ('space-around', 1, 7, 13),
    ('space-evenly', 1.5, 7, 12.5),
])
def test_flex_direction_column_justify_gap(align, y1, y2, y3):
    page, = render_pages(f'''
      <article style="height: 16px; font: 2px weasyprint; gap: 2px;
                      display: flex; flex-direction: column; justify-content: {align}">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_x == div2.position_x == div3.position_x == article.position_x
    assert article.position_y == 0
    assert div1.position_y == y1
    assert div2.position_y == y2
    assert div3.position_y == y3


@assert_no_logs
@pytest.mark.parametrize(('align', 'x1', 'x2', 'x3'), [
    ('start', 0, 4, 0),
    ('flex-start', 0, 4, 0),
    ('left', 0, 4, 0),
    ('end', 3, 7, 7),
    ('flex-end', 3, 7, 7),
    ('right', 3, 7, 7),
    ('center', 1.5, 5.5, 3.5),
    ('space-between', 0, 7, 0),
    ('space-around', 0.75, 6.25, 3.5),
    ('space-evenly', 1, 6, 3.5),
])
def test_flex_direction_row_justify_gap_wrap(align, x1, x2, x3):
    page, = render_pages(f'''
      <article style="width: 9px; font: 2px weasyprint; gap: 1px 2px;
                      display: flex; flex-wrap: wrap; justify-content: {align}">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_y == div2.position_y == article.position_y == 0
    assert div3.position_y == 3
    assert article.position_x == 0
    assert div1.position_x == x1
    assert div2.position_x == x2
    assert div3.position_x == x3


@assert_no_logs
@pytest.mark.parametrize(('align', 'y1', 'y2', 'y3'), [
    ('start', 0, 4, 0),
    ('flex-start', 0, 4, 0),
    ('left', 0, 4, 0),
    ('end', 3, 7, 7),
    ('flex-end', 3, 7, 7),
    ('right', 3, 7, 7),
    ('center', 1.5, 5.5, 3.5),
    ('space-between', 0, 7, 0),
    ('space-around', 0.75, 6.25, 3.5),
    ('space-evenly', 1, 6, 3.5),
])
def test_flex_direction_column_justify_gap_wrap(align, y1, y2, y3):
    page, = render_pages(f'''
      <article style="height: 9px; width: 9px; font: 2px weasyprint; gap: 2px 1px;
                      display: flex; flex-wrap: wrap; flex-direction: column;
                      justify-content: {align}">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_x == div2.position_x == article.position_x == 0
    assert div3.position_x == 5
    assert article.position_y == 0
    assert div1.position_y == y1
    assert div2.position_y == y2
    assert div3.position_y == y3


@assert_no_logs
def test_flex_direction_row_stretch_no_grow():
    page, = render_pages('''
      <article style="font: 2px weasyprint; width: 10px;
                      display: flex; justify-content: stretch">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_y == div2.position_y == div3.position_y == article.position_y
    assert div1.width == div2.width == div3.width == 2
    assert div1.position_x == article.position_x == 0
    assert div2.position_x == 2
    assert div3.position_x == 4


@assert_no_logs
def test_flex_direction_row_stretch_grow():
    page, = render_pages('''
      <article style="font: 2px weasyprint; width: 10px;
                      display: flex; justify-content: stretch">
        <div>A</div>
        <div style="flex-grow: 3">B</div>
        <div style="flex-grow: 1">C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_y == div2.position_y == div3.position_y == article.position_y
    assert div1.width == 2
    assert div2.width == 5
    assert div3.width == 3
    assert div1.position_x == article.position_x == 0
    assert div2.position_x == 2
    assert div3.position_x == 7


@assert_no_logs
@pytest.mark.parametrize(('align', 'x1', 'x2', 'x3'), [
    ('start', 0, 6, 12),
    ('flex-start', 0, 6, 12),
    ('left', 0, 6, 12),
    ('end', 6, 12, 18),
    ('flex-end', 6, 12, 18),
    ('right', 6, 12, 18),
    ('center', 3, 9, 15),
    ('space-between', 0, 9, 18),
    ('space-around', 1, 9, 17),
    ('space-evenly', 1.5, 9, 16.5),
])
def test_flex_direction_row_justify_margin_padding(align, x1, x2, x3):
    page, = render_pages(f'''
      <article style="width: 20px; font: 2px weasyprint;
                      display: flex; justify-content: {align}">
        <div style="margin: 0 1em">A</div>
        <div style="padding: 0 1em">B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_y == div2.position_y == div3.position_y == article.position_y
    assert article.position_x == 0
    assert article.width == 20
    assert div1.position_x == x1
    assert div2.position_x == x2
    assert div3.position_x == x3
    assert div1.margin_width() == 6
    assert div2.margin_width() == 6
    assert div3.margin_width() == 2


@assert_no_logs
@pytest.mark.parametrize(('align', 'y1', 'y2', 'y3'), [
    ('start', 0, 6, 12),
    ('flex-start', 0, 6, 12),
    ('left', 0, 6, 12),
    ('end', 6, 12, 18),
    ('flex-end', 6, 12, 18),
    ('right', 6, 12, 18),
    ('center', 3, 9, 15),
    ('space-between', 0, 9, 18),
    ('space-around', 1, 9, 17),
    ('space-evenly', 1.5, 9, 16.5),
])
def test_flex_direction_column_justify_margin_padding(align, y1, y2, y3):
    page, = render_pages(f'''
      <article style="height: 20px; font: 2px weasyprint;
                      display: flex; flex-direction: column; justify-content: {align}">
        <div style="margin: 1em 0">A</div>
        <div style="padding: 1em 0">B</div>
        <div>C</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2, div3 = article.children
    assert div1.children[0].children[0].text == 'A'
    assert div2.children[0].children[0].text == 'B'
    assert div3.children[0].children[0].text == 'C'
    assert div1.position_x == div2.position_x == div3.position_x == article.position_x
    assert article.position_y == 0
    assert article.height == 20
    assert div1.position_y == y1
    assert div2.position_y == y2
    assert div3.position_y == y3
    assert div1.margin_height() == 6
    assert div2.margin_height() == 6
    assert div3.margin_height() == 2


@assert_no_logs
def test_flex_item_table():
    # Regression test for issue #1805.
    page, = render_pages('''
      <article style="display: flex; font: 2px weasyprint">
        <table><tr><td>A</tr></td></table>
        <table><tr><td>B</tr></td></table>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    table_wrapper1, table_wrapper2 = article.children
    assert table_wrapper1.width == table_wrapper2.width == 2
    assert table_wrapper1.position_x == 0
    assert table_wrapper2.position_x == 2


@assert_no_logs
def test_flex_item_table_width():
    # Regression test for issue #1805.
    page, = render_pages('''
      <article style="display: flex; font: 2px weasyprint; width: 40px">
        <table style="width: 25%"><tr><td>A</tr></td></table>
        <table style="width: 25%"><tr><td>B</tr></td></table>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    table_wrapper1, table_wrapper2 = article.children
    assert table_wrapper1.width == table_wrapper2.width == 10
    assert table_wrapper1.position_x == 0
    assert table_wrapper2.position_x == 10


@assert_no_logs
def test_flex_width_on_parent():
    page, = render_pages('''
      <div style="font: 2px weasyprint; width: 30px; display: flex;
                  flex-direction: column; align-items: flex-start">
          <article>XXXX</article>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    article, = div.children
    assert article.width == 8


@assert_no_logs
def test_flex_column_item_flex_1():
    page, = render_pages('''
      <div style="font: 2px weasyprint; display: flex; flex-direction: column">
          <article>XXXX</article>
          <article style="flex: 1">XXXX</article>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.height == 4


@assert_no_logs
def test_flex_row_item_flex_0():
    page, = render_pages('''
      <div style="font: 2px weasyprint; display: flex">
          <article style="flex: 0">XXXX</article>
          <article style="flex: 0">XXXX</article>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    article1, article2 = div.children
    assert article1.position_x == 0
    assert article1.width == 8
    assert article2.position_x == 8
    assert article2.width == 8


@assert_no_logs
def test_flex_item_intrinsic_width():
    page, = render_pages('''
      <div style="width: 100px; height: 100px;
                  display: flex; flex-direction: column; align-items: center">
        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 200 100">
          <rect width="200" height="100" fill="red" />
        </svg>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    svg, = div.children
    assert svg.width == 100


@assert_no_logs
def test_flex_align_content_negative():
    page, = render_pages('''
      <div style="height: 6px; width: 20px;
                  display: flex; flex-wrap: wrap; align-content: center">
        <span style="height: 2px; flex: none; margin: 1px; width: 8px"></span>
        <span style="height: 2px; flex: none; margin: 1px; width: 8px"></span>
        <span style="height: 2px; flex: none; margin: 1px; width: 8px"></span>
        <span style="height: 2px; flex: none; margin: 1px; width: 8px"></span>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    span1, span2, span3, span4 = div.children
    span1.height == span2.height == span3.height == span4.height == 2
    span1.width == span2.width == span3.width == span4.width == 8
    assert span1.position_x == span3.position_x == 0
    assert span2.position_x == span4.position_x == 10
    assert span1.position_y == span2.position_y == -1
    assert span3.position_y == span4.position_y == 3


@assert_no_logs
def test_flex_shrink():
    page, = render_pages('''
      <article style="display: flex; width: 300px">
        <div style="flex: 0 2 auto; width: 300px"></div>
        <div style="width: 200px"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2 = article.children
    assert div1.width == div2.width == 150


@assert_no_logs
def test_flex_item_intrinsic_width_shrink():
    page, = render_pages('''
      <div style="width: 10px; height: 100px; display: flex; flex-direction: column">
        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" width="100">
          <rect width="100" height="100" fill="red" />
        </svg>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    svg, = div.children
    assert svg.width == 100


@assert_no_logs
def test_flex_item_intrinsic_height_shrink():
    page, = render_pages('''
      <div style="width: 100px; height: 10px; display: flex; line-height: 0">
        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" height="100">
          <rect width="100" height="100" fill="red" />
        </svg>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    svg, = div.children
    assert svg.height == 100


@assert_no_logs
def test_flex_wrap_in_flex():
    page, = render_pages('''
      <main style="display: flex; font: 2px weasyprint">
        <div style="display: flex; flex-wrap: wrap">
          <section style="width: 25%">A</section>
          <section style="flex: 1 75%">B</section>
        </div>
      </main>
    ''')
    html, = page.children
    body, = html.children
    main, = body.children
    div, = main.children
    section1, section2 = div.children
    assert section1.position_y == section2.position_y == 0
    assert section1.position_x == 0
    assert section2.position_x == 1  # 25% * 4


@assert_no_logs
def test_flex_auto_break_before():
    page1, page2 = render_pages('''
      <style>
        @page { size: 4px 5px }
        body { font: 2px weasyprint }
      </style>
      <p>A<br>B</p>
      <article style="display: flex">
        <div>A</div>
      </article>
    ''')
    html, = page1.children
    body, = html.children
    p, = body.children
    assert p.height == 4
    html, = page2.children
    body, = html.children
    article, = body.children
    assert article.height == 2


@assert_no_logs
def test_flex_grow_in_flex_column():
    page, = render_pages('''
      <html style="width: 14px">
        <body style="display: flex; flex-direction: column;
                     border: 1px solid; padding: 1px">
          <main style="flex: 1 1 auto; min-height: 0">
            <div style="height: 5px">
    ''')
    html, = page.children
    body, = html.children
    main, = body.children
    _, div, _ = main.children
    assert body.height == div.height == 5
    assert body.width == div.width == 10
    assert body.margin_width() == 14
    assert body.margin_height() == 9


@assert_no_logs
def test_flex_collapsing_margin():
    page, = render_pages('''
      <p style="margin-bottom: 20px; height: 100px">ABC</p>
      <article style="display: flex; margin-top: 10px">
        <div>A</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    p, article = body.children
    div, = article.children
    assert p.position_y == 0
    assert p.height == 100
    assert article.position_y == 110
    assert div.position_y == 120


@assert_no_logs
def test_flex_direction_column_next_page():
    # Regression test for issue #2414.
    page1, page2 = render_pages('''
      <style>
        @page { size: 4px 5px }
        html { font: 2px/1 weasyprint }
      </style>
      <div>1</div>
      <article style="display: flex; flex-direction: column">
        <div>A</div>
        <div>B</div>
        <div>C</div>
      </article>
    ''')
    html, = page1.children
    body, = html.children
    div, article = body.children
    assert div.children[0].children[0].text == '1'
    assert div.children[0].children[0].position_y == 0
    assert article.children[0].children[0].children[0].text == 'A'
    assert article.children[0].children[0].children[0].position_y == 2
    html, = page2.children
    body, = html.children
    article, = body.children
    assert article.children[0].children[0].children[0].text == 'B'
    assert article.children[0].children[0].children[0].position_y == 0
    assert article.children[1].children[0].children[0].text == 'C'
    assert article.children[1].children[0].children[0].position_y == 2


@assert_no_logs
def test_flex_1_item_padding():
    page, = render_pages('''
      <article style="display: flex; width: 100px; font: 2px weasyprint">
        <div>abc</div>
        <div style="flex: 1; padding-right: 5em">def</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2 = article.children
    assert div1.border_width() + div2.border_width() == article.width


@assert_no_logs
def test_flex_1_item_padding_direction_column():
    page, = render_pages('''
      <article style="display: flex; flex-direction: column; height: 100px;
                      font: 2px weasyprint">
        <div>abc</div>
        <div style="flex: 1; padding-top: 5em">def</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2 = article.children
    assert div1.border_height() + div2.border_height() == article.height


@assert_no_logs
def test_flex_item_replaced():
    page, = render_pages('''
      <div style="display: flex">
        <svg style="display: block" height="100" width="100" xmlns="http://www.w3.org/2000/svg">
          <circle r="45" cx="50" cy="50" fill="red" />
        </svg>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    svg, = div.children
    assert svg.width == svg.height == 100


@assert_no_logs
def test_flex_nested_column():
    # Regression test for issue #2442.
    page, = render_pages('''
      <section style="display: flex; flex-direction: column; width: 200px">
        <div style="display: flex; flex-direction: column">
          <p>
            A
          </p>
        </div>
      </section>
    ''')
    html, = page.children
    body, = html.children
    section, = body.children
    div, = section.children
    p, = div.children
    assert p.width == 200


@assert_no_logs
def test_flex_blockify_image():
    page, = render_pages('''
      <article style="display: flex; line-height: 2">
        <img src="pattern.png">
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    img, = article.children
    assert article.height == img.height == 4


@assert_no_logs
def test_flex_image_max_width():
    page, = render_pages('''
      <article style="display: flex">
        <img src="pattern.png" style="max-width: 2px">
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    img, = article.children
    assert article.height == img.height == img.width == 2


@assert_no_logs
def test_flex_image_max_height():
    page, = render_pages('''
      <article style="display: flex">
        <img src="pattern.png" style="max-height: 2px">
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    img, = article.children
    assert article.height == img.height == img.width == 2


@assert_no_logs
def test_flex_image_min_width():
    page, = render_pages('''
      <article style="display: flex; width: 20px">
        <img style="min-width: 10px; flex: 1 0 auto" src="pattern.png">
        <div style="flex: 1 0 1px"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    img, div = article.children
    assert article.height == img.height == img.width == div.height == 10


@assert_no_logs
def test_flex_image_justify_content():
    page, = render_pages('''
      <article style="width: 100px; display: flex; justify-content: end">
        <img src="pattern.png">
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    img, = article.children
    assert article.height == img.height == img.width == 4
    assert article.width == 100
    assert img.position_x == 96


@assert_no_logs
def test_flex_root_formatting_context():
    page, = render_pages('''
      <html style="display: flex">
        <div>A</div>
      </html>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.children[0].children[0].text == 'A'
    assert div.position_y == body.position_y
    assert div.position_x == body.position_x


@assert_no_logs
def test_flex_height_page_overflow():
    # Regression test for #2689.
    page, = render_pages('''
      <style>
        @page { size: 4px 6px }
      </style>
      <section style="display: flex; font: 2px weasyprint; height: 2px">
        <div style="width: 100%; display: flex; align-content: flex-start">a b c d</div>
      </section>
    ''')
    html, = page.children
    body, = html.children
    section, = body.children
    div, = section.children
    assert len(div.children[0].children) == 3


@assert_no_logs
def test_flex_break_after_page():
    # Regression test for #2469.
    page1, page2, page3 = render_pages('''
      <style>
        @page { size: 5px }
        body {
          display: flex; flex-direction: column;
          font: 2px/1 weasyprint; margin-top: 1px;
        }
      </style>
      <div style="height: 10px">a</div>
      <section>
        <div style="break-after: page">b</div>
        <div>c</div>
      </section>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    assert div.position_y == 1
    assert div.height == 10
    assert div.children[0].children[0].text == 'a'
    html, = page2.children
    body, = html.children
    assert body.position_y == 0
    assert body.height == 5
    section, = body.children
    div, = section.children
    assert div.position_y == 0
    assert div.height == 2
    assert div.children[0].children[0].text == 'b'
    html, = page3.children
    body, = html.children
    assert body.position_y == 0
    assert body.height == 2
    section, = body.children
    div, = section.children
    assert div.position_y == 0
    assert div.height == 2
    assert div.children[0].children[0].text == 'c'


================================================
FILE: tests/layout/test_float.py
================================================
"""Tests for floating boxes layout."""

import pytest

from weasyprint.formatting_structure import boxes

from ..testing_utils import assert_no_logs, render_pages


def outer_area(box):
    """Return the (x, y, w, h) rectangle for the outer area of a box."""
    return (box.position_x, box.position_y,
            box.margin_width(), box.margin_height())


@assert_no_logs
def test_floats_1():
    # adjacent-floats-001
    page, = render_pages('''
      <style>
        div { float: left }
        img { width: 100px; vertical-align: top }
      </style>
      <div><img src=pattern.png /></div>
      <div><img src=pattern.png /></div>''')
    html, = page.children
    body, = html.children
    div_1, div_2 = body.children
    assert outer_area(div_1) == (0, 0, 100, 100)
    assert outer_area(div_2) == (100, 0, 100, 100)


@assert_no_logs
def test_floats_2():
    # c414-flt-fit-000
    page, = render_pages('''
      <style>
        body { width: 290px }
        div { float: left; width: 100px;  }
        img { width: 60px; vertical-align: top }
      </style>
      <div><img src=pattern.png /><!-- 1 --></div>
      <div><img src=pattern.png /><!-- 2 --></div>
      <div><img src=pattern.png /><!-- 4 --></div>
      <img src=pattern.png /><!-- 3
      --><img src=pattern.png /><!-- 5 -->''')
    html, = page.children
    body, = html.children
    div_1, div_2, div_4, anon_block = body.children
    line_3, line_5 = anon_block.children
    img_3, = line_3.children
    img_5, = line_5.children
    assert outer_area(div_1) == (0, 0, 100, 60)
    assert outer_area(div_2) == (100, 0, 100, 60)
    assert outer_area(img_3) == (200, 0, 60, 60)

    assert outer_area(div_4) == (0, 60, 100, 60)
    assert outer_area(img_5) == (100, 60, 60, 60)


@assert_no_logs
def test_floats_3():
    # c414-flt-fit-002
    page, = render_pages('''
      <style type="text/css">
        body { width: 200px }
        p { width: 70px; height: 20px }
        .left { float: left }
        .right { float: right }
      </style>
      <p class="left"> ⇦ A 1 </p>
      <p class="left"> ⇦ B 2 </p>
      <p class="left"> ⇦ A 3 </p>
      <p class="right"> B 4 ⇨ </p>
      <p class="left"> ⇦ A 5 </p>
      <p class="right"> B 6 ⇨ </p>
      <p class="right"> B 8 ⇨ </p>
      <p class="left"> ⇦ A 7 </p>
      <p class="left"> ⇦ A 9 </p>
      <p class="left"> ⇦ B 10 </p>
    ''')
    html, = page.children
    body, = html.children
    positions = [(paragraph.position_x, paragraph.position_y)
                 for paragraph in body.children]
    assert positions == [
        (0, 0), (70, 0), (0, 20), (130, 20), (0, 40), (130, 40),
        (130, 60), (0, 60), (0, 80), (70, 80), ]


@assert_no_logs
def test_floats_4():
    # c414-flt-wrap-000 ... more or less
    page, = render_pages('''
      <style>
        body { width: 100px }
        p { float: left; height: 100px }
        img { width: 60px; vertical-align: top }
      </style>
      <p style="width: 20px"></p>
      <p style="width: 100%"></p>
      <img src=pattern.png /><img src=pattern.png />
    ''')
    html, = page.children
    body, = html.children
    p_1, p_2, anon_block = body.children
    line_1, line_2 = anon_block.children
    assert anon_block.position_y == 0
    assert (line_1.position_x, line_1.position_y) == (20, 0)
    assert (line_2.position_x, line_2.position_y) == (0, 200)


@assert_no_logs
def test_floats_5():
    # c414-flt-wrap-000 with text ... more or less
    page, = render_pages('''
      <style>
        body { width: 100px; font: 60px weasyprint; }
        p { float: left; height: 100px }
        img { width: 60px; vertical-align: top }
      </style>
      <p style="width: 20px"></p>
      <p style="width: 100%"></p>
      A B
    ''')
    html, = page.children
    body, = html.children
    p_1, p_2, anon_block = body.children
    line_1, line_2 = anon_block.children
    assert anon_block.position_y == 0
    assert (line_1.position_x, line_1.position_y) == (20, 0)
    assert (line_2.position_x, line_2.position_y) == (0, 200)


@assert_no_logs
def test_floats_6():
    # floats-placement-vertical-001b
    page, = render_pages('''
      <style>
        body { width: 90px; font-size: 0 }
        img { vertical-align: top }
      </style>
      <body>
      <span>
        <img src=pattern.png style="width: 50px" />
        <img src=pattern.png style="width: 50px" />
        <img src=pattern.png style="float: left; width: 30px" />
      </span>
    ''')
    html, = page.children
    body, = html.children
    line_1, line_2 = body.children
    span_1, = line_1.children
    span_2, = line_2.children
    img_1, = span_1.children
    img_2, img_3 = span_2.children
    assert outer_area(img_1) == (0, 0, 50, 50)
    assert outer_area(img_2) == (30, 50, 50, 50)
    assert outer_area(img_3) == (0, 50, 30, 30)


@assert_no_logs
def test_floats_7():
    # Variant of the above: no <span>
    page, = render_pages('''
      <style>
        body { width: 90px; font-size: 0 }
        img { vertical-align: top }
      </style>
      <body>
      <img src=pattern.png style="width: 50px" />
      <img src=pattern.png style="width: 50px" />
      <img src=pattern.png style="float: left; width: 30px" />
    ''')
    html, = page.children
    body, = html.children
    line_1, line_2 = body.children
    img_1, = line_1.children
    img_2, img_3 = line_2.children
    assert outer_area(img_1) == (0, 0, 50, 50)
    assert outer_area(img_2) == (30, 50, 50, 50)
    assert outer_area(img_3) == (0, 50, 30, 30)


@assert_no_logs
def test_floats_8():
    # Floats do no affect other pages
    page_1, page_2 = render_pages('''
      <style>
        body { width: 90px; font-size: 0 }
        img { vertical-align: top }
      </style>
      <body>
      <img src=pattern.png style="float: left; width: 30px" />
      <img src=pattern.png style="width: 50px" />
      <div style="page-break-before: always"></div>
      <img src=pattern.png style="width: 50px" />
    ''')
    html, = page_1.children
    body, = html.children
    float_img, anon_block, = body.children
    line, = anon_block.children
    img_1, = line.children
    assert outer_area(float_img) == (0, 0, 30, 30)
    assert outer_area(img_1) == (30, 0, 50, 50)

    html, = page_2.children
    body, = html.children
    div, anon_block = body.children
    line, = anon_block.children
    img_2, = line.children


@assert_no_logs
def test_floats_9():
    # Regression test for #263.
    page, = render_pages('''<div style="top:100%; float:left">''')


@assert_no_logs
def test_floats_page_breaks_1():
    # Tests floated images shorter than the page
    pages = render_pages('''
      <style>
        @page { size: 100px; margin: 10px }
        img { height: 45px; width:70px; float: left;}
      </style>
      <body>
        <img src=pattern.png>
          <!-- page break should be here !!! -->
        <img src=pattern.png>
    ''')

    assert len(pages) == 2

    page_images = []
    for page in pages:
        images = [d for d in page.descendants() if d.element_tag == 'img']
        assert all([img.element_tag == 'img' for img in images])
        assert all([img.position_x == 10 for img in images])
        page_images.append(images)
    positions_y = [[img.position_y for img in images]
                   for images in page_images]
    assert positions_y == [[10], [10]]


@assert_no_logs
def test_floats_page_breaks_2():
    # Tests floated images taller than the page
    pages = render_pages('''
      <style>
        @page { size: 100px; margin: 10px }
        img { height: 81px; width:70px; float: left;}
      </style>
      <body>
        <img src=pattern.png>
          <!-- page break should be here !!! -->
        <img src=pattern.png>
    ''')

    assert len(pages) == 2

    page_images = []
    for page in pages:
        images = [d for d in page.descendants() if d.element_tag == 'img']
        assert all([img.element_tag == 'img' for img in images])
        assert all([img.position_x == 10 for img in images])
        page_images.append(images)
    positions_y = [[img.position_y for img in images]
                   for images in page_images]
    assert positions_y == [[10], [10]]


@assert_no_logs
def test_floats_page_breaks_3():
    # Tests floated images shorter than the page
    pages = render_pages('''
      <style>
        @page { size: 100px; margin: 10px }
        img { height: 30px; width:70px; float: left;}
      </style>
      <body>
        <img src=pattern.png>
        <img src=pattern.png>
          <!-- page break should be here !!! -->
        <img src=pattern.png>
        <img src=pattern.png>
          <!-- page break should be here !!! -->
        <img src=pattern.png>
    ''')

    assert len(pages) == 3

    page_images = []
    for page in pages:
        images = [d for d in page.descendants() if d.element_tag == 'img']
        assert all([img.element_tag == 'img' for img in images])
        assert all([img.position_x == 10 for img in images])
        page_images.append(images)
    positions_y = [[img.position_y for img in images]
                   for images in page_images]
    assert positions_y == [[10, 40], [10, 40], [10]]


@assert_no_logs
def test_preferred_widths_1():
    def get_float_width(body_width):
        page, = render_pages('''
          <body style="width: %spx; font-family: weasyprint">
          <p style="white-space: pre-line; float: left">
            Lorem ipsum dolor sit amet,
              consectetur elit
          </p>
                   <!--  ^  No-break space here  -->
        ''' % body_width)
        html, = page.children
        body, = html.children
        paragraph, = body.children
        return paragraph.width
    # Preferred minimum width:
    assert get_float_width(10) == len('consectetur elit') * 16
    # Preferred width:
    assert get_float_width(1000000) == len('Lorem ipsum dolor sit amet,') * 16


@assert_no_logs
def test_preferred_widths_2():
    # Non-regression test:
    # Incorrect whitespace handling in preferred width used to cause
    # unnecessary line break.
    page, = render_pages('''
      <p style="float: left">Lorem <em>ipsum</em> dolor.</p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert len(paragraph.children) == 1
    assert isinstance(paragraph.children[0], boxes.LineBox)


@assert_no_logs
def test_preferred_widths_3():
    page, = render_pages('''
      <style>img { width: 20px }</style>
      <p style="float: left">
        <img src=pattern.png><img src=pattern.png><br>
        <img src=pattern.png></p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == 40


@assert_no_logs
def test_preferred_widths_4():
    page, = render_pages(
        '<style>'
        '  p { font: 20px weasyprint }'
        '</style>'
        '<p style="float: left">XX<br>XX<br>X</p>')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == 40


@assert_no_logs
def test_preferred_widths_5():
    # The space is the start of the line is collapsed.
    page, = render_pages(
        '<style>'
        '  p { font: 20px weasyprint }'
        '</style>'
        '<p style="float: left">XX<br> XX<br>X</p>')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.width == 40


@assert_no_logs
def test_float_in_inline_1():
    page, = render_pages('''
      <style>
        body {
          font-family: weasyprint;
          font-size: 20px;
        }
        p {
          width: 14em;
          text-align: justify;
        }
        span {
          float: right;
        }
      </style>
      <p>
        aa bb <a><span>cc</span> ddd</a> ee ff
      </p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line1, line2 = paragraph.children

    p1, a, p2 = line1.children
    assert p1.width == 6 * 20
    assert p1.text == 'aa bb '
    assert p1.position_x == 0 * 20
    assert p2.width == 3 * 20
    assert p2.text == ' ee'
    assert p2.position_x == 9 * 20
    span, a_text = a.children
    assert a_text.width == 3 * 20  # leading space collapse
    assert a_text.text == 'ddd'
    assert a_text.position_x == 6 * 20
    assert span.width == 2 * 20
    assert span.children[0].children[0].text == 'cc'
    assert span.position_x == 12 * 20

    p3, = line2.children
    assert p3.width == 2 * 20


@assert_no_logs
def test_float_in_inline_2():
    page, = render_pages('''
      <style>
        @page {
          size: 10em;
        }
        article {
          font-family: weasyprint;
          line-height: 1;
        }
        div {
          float: left;
          width: 50%;
        }
      </style>
      <article>
        <span>
          <div>a b c</div>
          1 2 3 4 5 6
        </span>
      </article>''')
    html, = page.children
    body, = html.children
    article, = body.children
    line1, line2 = article.children
    span1, = line1.children
    div, text = span1.children
    assert div.children[0].children[0].text.strip() == 'a b c'
    assert text.text.strip() == '1 2 3'
    span2, = line2.children
    text, = span2.children
    assert text.text.strip() == '4 5 6'


@assert_no_logs
def test_float_in_inline_3():
    page, = render_pages('''
      <style>
        @page {
          size: 10em;
        }
        article {
          font-family: weasyprint;
          line-height: 1;
        }
        div {
          float: left;
          width: 50%;
        }
      </style>
      <article>
        <span>
          1 2 3 <div>a b c</div> 4 5 6
        </span>
      </article>''')
    html, = page.children
    body, = html.children
    article, = body.children
    line1, line2 = article.children
    span1, = line1.children
    text, div = span1.children
    assert text.text.strip() == '1 2 3'
    assert div.children[0].children[0].text.strip() == 'a b c'
    span2, = line2.children
    text, = span2.children
    assert text.text.strip() == '4 5 6'


@assert_no_logs
def test_float_in_inline_4():
    page, = render_pages('''
      <style>
        @page {
          size: 10em;
        }
        article {
          font-family: weasyprint;
          line-height: 1;
        }
        div {
          float: left;
          width: 50%;
        }
      </style>
      <article>
        <span>
          1 2 3 4 <div>a b c</div> 5 6
        </span>
      </article>''')
    html, = page.children
    body, = html.children
    article, = body.children
    line1, line2 = article.children
    span1, div = line1.children
    text1, text2 = span1.children
    assert text1.text.strip() == '1 2 3 4'
    assert text2.text.strip() == '5'
    assert div.position_y == 16
    assert div.children[0].children[0].text.strip() == 'a b c'
    span2, = line2.children
    text, = span2.children
    assert text.text.strip() == '6'


@assert_no_logs
def test_float_next_line():
    page, = render_pages('''
      <style>
        body {
          font-family: weasyprint;
          font-size: 20px;
        }
        p {
          text-align: justify;
          width: 13em;
        }
        span {
          float: left;
        }
      </style>
      <p>pp pp pp pp <a><span>ppppp</span> aa</a> pp pp pp pp pp</p>''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line1, line2, line3 = paragraph.children
    assert len(line1.children) == 1
    assert len(line3.children) == 1
    a, p = line2.children
    span, a_text = a.children
    assert span.position_x == 0
    assert span.width == 5 * 20
    assert a_text.position_x == a.position_x == 5 * 20
    assert a_text.width == a.width == 2 * 20
    assert p.position_x == 7 * 20


@assert_no_logs
def test_float_text_indent_1():
    page, = render_pages('''
      <style>
        body {
          font-family: weasyprint;
          font-size: 20px;
        }
        p {
          text-align: justify;
          text-indent: 1em;
          width: 14em;
        }
        span {
          float: left;
        }
      </style>
      <p><a>aa <span>float</span> aa</a></p>''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line1, = paragraph.children
    a, = line1.children
    a1, span, a2 = a.children
    span_text, = span.children
    assert span.position_x == span_text.position_x == 0
    assert span.width == span_text.width == (
        (1 + 5) * 20)  # text-indent + span text
    assert a1.width == 3 * 20
    assert a1.position_x == (1 + 5 + 1) * 20  # span + a1 text-indent
    assert a2.width == 2 * 20  # leading space collapse
    assert a2.position_x == (1 + 5 + 1 + 3) * 20  # span + a1 t-i + a1


@assert_no_logs
def test_float_text_indent_2():
    page, = render_pages('''
      <style>
        body {
          font-family: weasyprint;
          font-size: 20px;
        }
        p {
          text-align: justify;
          text-indent: 1em;
          width: 14em;
        }
        span {
          float: left;
        }
      </style>
      <p>
        oooooooooooo
        <a>aa <span>float</span> aa</a></p>''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line1, line2 = paragraph.children

    p1, = line1.children
    assert p1.position_x == 1 * 20  # text-indent
    assert p1.width == 12 * 20  # p text

    a, = line2.children
    a1, span, a2 = a.children
    span_text, = span.children
    assert span.position_x == span_text.position_x == 0
    assert span.width == span_text.width == (
        (1 + 5) * 20)  # text-indent + span text
    assert a1.width == 3 * 20
    assert a1.position_x == (1 + 5) * 20  # span
    assert a2.width == 2 * 20  # leading space collapse
    assert a2.position_x == (1 + 5 + 3) * 20  # span + a1


@assert_no_logs
def test_float_text_indent_3():
    page, = render_pages('''
      <style>
        body {
          font-family: weasyprint;
          font-size: 20px;
        }
        p {
          text-align: justify;
          text-indent: 1em;
          width: 14em;
        }
        span {
          float: right;
        }
      </style>
      <p>
        oooooooooooo
        <a>aa <span>float</span> aa</a>
        oooooooooooo
      </p>''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line1, line2, line3 = paragraph.children

    p1, = line1.children
    assert p1.position_x == 1 * 20  # text-indent
    assert p1.width == 12 * 20  # p text

    a, = line2.children
    a1, span, a2 = a.children
    span_text, = span.children
    assert span.position_x == span_text.position_x == (14 - 5 - 1) * 20
    assert span.width == span_text.width == (
        (1 + 5) * 20)  # text-indent + span text
    assert a1.position_x == 0  # span
    assert a2.width == 2 * 20  # leading space collapse
    assert a2.position_x == (14 - 5 - 1 - 2) * 20

    p2, = line3.children
    assert p2.position_x == 0
    assert p2.width == 12 * 20  # p text


@assert_no_logs
def test_float_previous_break():
    page1, page2 = render_pages('''
      <style>
        @page {
          size: 13px;
        }
        body {
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        p {
          break-after: avoid;
        }
        section {
          break-inside: avoid;
          float: left;
        }
      </style>
      <article>
        oooooo
        oooooo
        oooooo
        oooooo
      </article>
      <p>xxxxxx</p>
      <p>yyyyyy</p>
      <section>
        <div>aaaaaa</div>
        <div>cccccc</div>
      </section>
      <article>
        dddddd
      </article>''')

    html, = page1.children
    body, = html.children
    article, = body.children

    html, = page2.children
    body, = html.children
    p1, p2, section, article = body.children


@pytest.mark.xfail
@assert_no_logs
def test_float_fail():
    page, = render_pages('''
      <style>
        body {
          font-family: weasyprint;
          font-size: 20px;
        }
        p {
          text-align: justify;
          width: 12em;
        }
        span {
          float: left;
          background: red;
        }
        a {
          background: yellow;
        }
      </style>
      <p>bb bb pp bb pp pb <a><span>pp pp</span> apa</a> bb bb</p>''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line1, line2, line3 = paragraph.children


def test_float_table_aborted_row():
    page1, page2 = render_pages('''
      <style>
        @page {size: 10px 7px}
        body {font-family: weasyprint; font-size: 2px; line-height: 1}
        div {float: right; orphans: 1}
        td {break-inside: avoid}
      </style>
      <table><tbody>
        <tr><td>abc</td></tr>
        <tr><td>abc</td></tr>
        <tr><td>def <div>f<br>g</div> ghi</td></tr>
      </tbody></table>
    ''')

    html, = page1.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    tbody, = table.children
    for tr in tbody.children:
        td, = tr.children
        line, = td.children
        textbox, = line.children
        assert textbox.text == 'abc'

    html, = page2.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    tbody, = table.children
    tr, = tbody.children
    td, = tr.children
    line1, line2 = td.children
    textbox, div = line1.children
    assert textbox.text == 'def '
    textbox, = line2.children
    assert textbox.text == 'ghi'
    line1, line2 = div.children
    textbox, br = line1.children
    assert textbox.text == 'f'
    textbox, = line2.children
    assert textbox.text == 'g'


def test_formatting_context_avoid_rtl():
    render_pages('''
      <div style="direction: rtl">
        <div style="overflow: hidden"></div>
      </div>
    ''')


@assert_no_logs
def test_nested_right_float():
    # Regression test for #1510.
    page, = render_pages('''
      <style>
        body { width: 100px; font: 20px weasyprint }
        div { float: right; width: 50px }
      </style>
      <b><i><div></div></i></b>ab c''')
    html, = page.children
    body, = html.children
    line1, line2 = body.children
    assert line1.width == 40
    assert line2.width == 20


@assert_no_logs
def test_first_letter_float():
    # Regression test for #1859.
    page, = render_pages('''
      <style>
        body { width: 100px; font: 20px weasyprint }
        p:first-letter { float: left }
      </style>
      <p>Lor''')
    html, = page.children
    body, = html.children
    p, = body.children
    line1, = p.children
    first_letter, text = line1.children
    assert first_letter.position_x == 0
    # TODO: fix problem described in #1859.
    # assert text.position_x == 20


================================================
FILE: tests/layout/test_footnotes.py
================================================
"""Tests for footnotes layout."""

import pytest

from ..testing_utils import assert_no_logs, render_pages, tree_position


@assert_no_logs
def test_inline_footnote():
    page, = render_pages('''
        <style>
            @page {
                size: 9px 7px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
            }
        </style>
        <div>abc<span>de</span></div>''')
    html, footnote_area = page.children
    body, = html.children
    div, = body.children
    div_textbox, footnote_call = div.children[0].children
    assert div_textbox.text == 'abc'
    assert footnote_call.children[0].text == '1'
    assert div_textbox.position_y == 0

    footnote_marker, footnote_textbox = (
        footnote_area.children[0].children[0].children)
    assert footnote_marker.children[0].text == '1.'
    assert footnote_textbox.text == 'de'
    assert footnote_area.position_y == 5


@assert_no_logs
def test_block_footnote():
    page, = render_pages('''
        <style>
          @page {
              size: 9px 7px;
          }
          div {
              font-family: weasyprint;
              font-size: 2px;
              line-height: 1;
          }
          div.footnote {
              float: footnote;
          }
        </style>
        <div>abc<div class="footnote">de</div></div>''')
    html, footnote_area = page.children
    body, = html.children
    div, = body.children
    div_textbox, footnote_call = div.children[0].children
    assert div_textbox.text == 'abc'
    assert footnote_call.children[0].text == '1'
    assert div_textbox.position_y == 0
    footnote_marker, footnote_textbox = (
     footnote_area.children[0].children[0].children)
    assert footnote_marker.children[0].text == '1.'
    assert footnote_textbox.text == 'de'
    assert footnote_area.position_y == 5


@assert_no_logs
def test_long_footnote():
    page, = render_pages('''
        <style>
            @page {
                size: 9px 7px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
            }
        </style>
        <div>abc<span>de f</span></div>''')
    html, footnote_area = page.children
    body, = html.children
    div, = body.children
    div_textbox, footnote_call = div.children[0].children
    assert div_textbox.text == 'abc'
    assert footnote_call.children[0].text == '1'
    assert div_textbox.position_y == 0
    footnote_line1, footnote_line2 = footnote_area.children[0].children
    footnote_marker, footnote_content1 = footnote_line1.children
    footnote_content2 = footnote_line2.children[0]
    assert footnote_marker.children[0].text == '1.'
    assert footnote_content1.text == 'de'
    assert footnote_area.position_y == 3
    assert footnote_content2.text == 'f'
    assert footnote_content2.position_y == 5


@pytest.mark.xfail
@assert_no_logs
def test_after_marker_footnote():
    # TODO: this syntax is in the specification, but we’re currently limited to
    # one pseudo element per selector, according to CSS 2.1:
    # https://drafts.csswg.org/css2/#selector-syntax
    # and Selectors Level 3:
    # https://drafts.csswg.org/selectors-3/#selector-syntax
    # This limitation doesn’t exist anymore in Selectors Level 4:
    # https://drafts.csswg.org/selectors-4/#typedef-compound-selector
    page, = render_pages('''
        <style>
            @page {
                size: 9px 7px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
            }
            ::footnote-marker::after {
                content: '|';
            }
        </style>
        <div>abc<span>de</span></div>''')
    html, footnote_area = page.children
    footnote_marker, _ = footnote_area.children[0].children[0].children
    assert footnote_marker.children[0].text == '1.|'


@assert_no_logs
def test_several_footnote():
    page1, page2, = render_pages('''
        <style>
            @page {
                size: 9px 7px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
            }
        </style>
        <div>abcd e<span>fg</span> hijk l<span>mn</span></div>''')
    html1, footnote_area1 = page1.children
    body1, = html1.children
    div1, = body1.children
    div1_line1, div1_line2 = div1.children
    assert div1_line1.children[0].text == 'abcd'
    div1_line2_text, div1_footnote_call = div1.children[1].children
    assert div1_line2_text.text == 'e'
    assert div1_footnote_call.children[0].text == '1'
    footnote_marker1, footnote_textbox1 = (
        footnote_area1.children[0].children[0].children)
    assert footnote_marker1.children[0].text == '1.'
    assert footnote_textbox1.text == 'fg'

    html2, footnote_area2 = page2.children
    body2, = html2.children
    div2, = body2.children
    div2_line1, div2_line2 = div2.children
    assert div2_line1.children[0].text == 'hijk'
    div2_line2_text, div2_footnote_call = div2.children[1].children
    assert div2_line2_text.text == 'l'
    assert div2_footnote_call.children[0].text == '2'
    footnote_marker2, footnote_textbox2 = (
        footnote_area2.children[0].children[0].children)
    assert footnote_marker2.children[0].text == '2.'
    assert footnote_textbox2.text == 'mn'


@assert_no_logs
def test_reported_footnote_1():
    page1, page2, = render_pages('''
        <style>
            @page {
                size: 9px 7px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
            }
        </style>
        <div>abc<span>f1</span> hij<span>f2</span></div>''')
    html1, footnote_area1 = page1.children
    body1, = html1.children
    div1, = body1.children
    div_line1, div_line2 = div1.children
    div_line1_text, div_footnote_call1 = div_line1.children
    assert div_line1_text.text == 'abc'
    assert div_footnote_call1.children[0].text == '1'
    div_line2_text, div_footnote_call2 = div_line2.children
    assert div_line2_text.text == 'hij'
    assert div_footnote_call2.children[0].text == '2'

    footnote_marker1, footnote_textbox1 = (
        footnote_area1.children[0].children[0].children)
    assert footnote_marker1.children[0].text == '1.'
    assert footnote_textbox1.text == 'f1'

    html2, footnote_area2 = page2.children
    assert not html2.children
    footnote_marker2, footnote_textbox2 = (
        footnote_area2.children[0].children[0].children)
    assert footnote_marker2.children[0].text == '2.'
    assert footnote_textbox2.text == 'f2'


@assert_no_logs
def test_reported_footnote_2():
    page1, page2, = render_pages('''
        <style>
            @page {
                size: 9px 7px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
            }
        </style>
        <div>abc<span>f1</span> hij<span>f2</span> wow</div>''')
    html1, footnote_area1 = page1.children
    body1, = html1.children
    div1, = body1.children
    div_line1, div_line2 = div1.children
    div_line1_text, div_footnote_call1 = div_line1.children
    assert div_line1_text.text == 'abc'
    assert div_footnote_call1.children[0].text == '1'
    div_line2_text, div_footnote_call2 = div_line2.children
    assert div_line2_text.text == 'hij'
    assert div_footnote_call2.children[0].text == '2'
    footnote_marker1, footnote_textbox1 = (
        footnote_area1.children[0].children[0].children)
    assert footnote_marker1.children[0].text == '1.'
    assert footnote_textbox1.text == 'f1'

    html2, footnote_area2 = page2.children
    body2, = html2.children
    div2, = body2.children
    div2_line, = div2.children
    assert div2_line.children[0].text == 'wow'
    footnote_marker2, footnote_textbox2 = (
        footnote_area2.children[0].children[0].children)
    assert footnote_marker2.children[0].text == '2.'
    assert footnote_textbox2.text == 'f2'


@assert_no_logs
def test_reported_footnote_3():
    page1, page2, = render_pages('''
        <style>
            @page {
                size: 9px 10px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
            }
        </style>
        <div>
          abc<span>1</span>
          def<span>v long 2</span>
          ghi<span>3</span>
        </div>''')
    html1, footnote_area1 = page1.children
    body1, = html1.children
    div1, = body1.children
    line1, line2, line3 = div1.children
    assert line1.children[0].text == 'abc'
    assert line1.children[1].children[0].text == '1'
    assert line2.children[0].text == 'def'
    assert line2.children[1].children[0].text == '2'
    assert line3.children[0].text == 'ghi'
    assert line3.children[1].children[0].text == '3'
    footnote1, = footnote_area1.children
    assert footnote1.children[0].children[0].children[0].text == '1.'
    assert footnote1.children[0].children[1].text == '1'

    html2, footnote_area2 = page2.children
    footnote2, footnote3 = footnote_area2.children
    assert footnote2.children[0].children[0].children[0].text == '2.'
    assert footnote2.children[0].children[1].text == 'v'
    assert footnote2.children[1].children[0].text == 'long'
    assert footnote2.children[2].children[0].text == '2'
    assert footnote3.children[0].children[0].children[0].text == '3.'
    assert footnote3.children[0].children[1].text == '3'


@assert_no_logs
def test_reported_sequential_footnote():
    pages = render_pages('''
        <style>
            @page {
                size: 9px 7px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
            }
        </style>
        <div>
            a<span>b</span><span>c</span><span>d</span><span>e</span>
        </div>''')

    positions = [
        tree_position(pages, lambda box: getattr(box, 'text', None) == letter)
        for letter in 'abcde']
    assert sorted(positions) == positions


@assert_no_logs
def test_reported_sequential_footnote_second_line():
    pages = render_pages('''
        <style>
            @page {
                size: 9px 7px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
            }
        </style>
        <div>
            aaa a<span>b</span><span>c</span><span>d</span><span>e</span>
        </div>''')

    positions = [
        tree_position(pages, lambda box: getattr(box, 'text', None) == letter)
        for letter in 'abc']
    assert sorted(positions) == positions


@assert_no_logs
def test_footnote_report_orphans():
    page1, page2 = render_pages('''
      <style>
        @page {
          font-family: weasyprint;
          size: 20px;
        }
        body {
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
          orphans: 2;
          widows: 2;
        }
        span {
          float: footnote;
        }
      </style>
      <div>
        a<br>
        b<br>
        c<br>
        d<br>
        e
      </div>
      <div>
        f<span>1</span><span>2</span><span>3</span><span>4</span><br>
        g<br>
        h<br>
        i
      </div>''')
    html, footnote_area = page1.children
    body, = html.children
    div1, div2 = body.children
    assert len(div1.children) == 5
    assert len(div2.children) == 2
    assert len(footnote_area.children) == 3
    html, footnote_area = page2.children
    body, = html.children
    div, = body.children
    assert len(div.children) == 2
    assert len(footnote_area.children) == 1


@assert_no_logs
@pytest.mark.parametrize(('css', 'tail'), [
    ('p { break-inside: avoid }', '<br>e<br>f'),
    ('p { widows: 4 }', '<br>e<br>f'),
    ('p + p { break-before: avoid }', '</p><p>e<br>f'),
    ('p + p { break-before: avoid }', '<span>y</span><span>z</span></p><p>e'),
])
def test_footnote_area_after_call(css, tail):
    pages = render_pages('''
        <style>
            @page {
                size: 9px 10px;
                margin: 0;
            }
            body {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
                orphans: 2;
                widows: 2;
                margin: 0;
            }
            span {
                float: footnote;
            }
            %s
        </style>
        <div>a<br>b</div>
        <p>c<br>d<span>x</span>%s</p>''' % (css, tail))

    footnote_call = tree_position(
        pages, lambda box: box.element_tag == 'span::footnote-call')
    footnote_area = tree_position(
        pages, lambda box: type(box).__name__ == 'FootnoteAreaBox')
    assert footnote_call < footnote_area


@assert_no_logs
def test_footnote_display_inline():
    page, = render_pages('''
        <style>
            @page {
                size: 9px 50px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
                footnote-display: inline;
            }
        </style>
        <div>abc<span>d</span> fgh<span>i</span></div>''')
    html, footnote_area = page.children
    body, = html.children
    div, = body.children
    div_line1, div_line2 = div.children
    div_textbox1, footnote_call1 = div_line1.children
    div_textbox2, footnote_call2 = div_line2.children
    assert div_textbox1.text == 'abc'
    assert div_textbox2.text == 'fgh'
    assert footnote_call1.children[0].text == '1'
    assert footnote_call2.children[0].text == '2'
    line = footnote_area.children[0]
    footnote_mark1, footnote_textbox1 = line.children[0].children
    footnote_mark2, footnote_textbox2 = line.children[1].children
    assert footnote_mark1.children[0].text == '1.'
    assert footnote_textbox1.text == 'd'
    assert footnote_mark2.children[0].text == '2.'
    assert footnote_textbox2.text == 'i'


@assert_no_logs
def test_footnote_longer_than_space_left():
    page1, page2 = render_pages('''
        <style>
            @page {
                size: 9px 7px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
            }
        </style>
        <div>abc<span>def ghi jkl</span></div>''')
    html1, = page1.children
    body1, = html1.children
    div, = body1.children
    div_textbox, footnote_call = div.children[0].children
    assert div_textbox.text == 'abc'
    assert footnote_call.children[0].text == '1'

    html2, footnote_area = page2.children
    assert not html2.children
    footnote_line1, footnote_line2, footnote_line3 = (
        footnote_area.children[0].children)
    footnote_marker, footnote_content1 = footnote_line1.children
    footnote_content2 = footnote_line2.children[0]
    footnote_content3 = footnote_line3.children[0]
    assert footnote_marker.children[0].text == '1.'
    assert footnote_content1.text == 'def'
    assert footnote_content2.text == 'ghi'
    assert footnote_content3.text == 'jkl'


@assert_no_logs
def test_footnote_longer_than_page():
    # Nothing is defined for this use case in the specification. In WeasyPrint,
    # the content simply overflows.
    page1, page2 = render_pages('''
        <style>
            @page {
                size: 9px 7px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
            }
        </style>
        <div>abc<span>def ghi jkl mno</span></div>''')
    html1, = page1.children
    body1, = html1.children
    div, = body1.children
    div_textbox, footnote_call = div.children[0].children
    assert div_textbox.text == 'abc'
    assert footnote_call.children[0].text == '1'

    html2, footnote_area2 = page2.children
    assert not html2.children
    footnote_line1, footnote_line2, footnote_line3, footnote_line4 = (
        footnote_area2.children[0].children)
    footnote_marker1, footnote_content1 = footnote_line1.children
    footnote_content2 = footnote_line2.children[0]
    footnote_content3 = footnote_line3.children[0]
    footnote_content4 = footnote_line4.children[0]
    assert footnote_marker1.children[0].text == '1.'
    assert footnote_content1.text == 'def'
    assert footnote_content2.text == 'ghi'
    assert footnote_content3.text == 'jkl'
    assert footnote_content4.text == 'mno'


@assert_no_logs
def test_footnote_policy_line():
    page1, page2 = render_pages('''
        <style>
            @page {
                size: 9px 9px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
                orphans: 2;
                widows: 2;
            }
            span {
                float: footnote;
                footnote-policy: line;
            }
        </style>
        <div>abc def ghi jkl<span>1</span></div>''')
    html, = page1.children
    body, = html.children
    div, = body.children
    linebox1, linebox2 = div.children
    assert linebox1.children[0].text == 'abc'
    assert linebox2.children[0].text == 'def'

    html, footnote_area = page2.children
    body, = html.children
    div, = body.children
    linebox1, linebox2 = div.children
    assert linebox1.children[0].text == 'ghi'
    assert linebox2.children[0].text == 'jkl'
    assert linebox2.children[1].children[0].text == '1'

    footnote_marker, footnote_textbox = (
        footnote_area.children[0].children[0].children)
    assert footnote_marker.children[0].text == '1.'
    assert footnote_textbox.text == '1'


@assert_no_logs
def test_footnote_policy_block():
    page1, page2 = render_pages('''
        <style>
            @page {
                size: 9px 9px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
                footnote-policy: block;
            }
        </style>
        <div>abc</div><div>def ghi jkl<span>1</span></div>''')
    html, = page1.children
    body, = html.children
    div, = body.children
    linebox1, = div.children
    assert linebox1.children[0].text == 'abc'

    html, footnote_area = page2.children
    body, = html.children
    div, = body.children
    linebox1, linebox2, linebox3 = div.children
    assert linebox1.children[0].text == 'def'
    assert linebox2.children[0].text == 'ghi'
    assert linebox3.children[0].text == 'jkl'
    assert linebox3.children[1].children[0].text == '1'

    footnote_marker, footnote_textbox = (
        footnote_area.children[0].children[0].children)
    assert footnote_marker.children[0].text == '1.'
    assert footnote_textbox.text == '1'


@assert_no_logs
def test_footnote_repagination():
    page, = render_pages('''
        <style>
            @page {
                size: 9px 7px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            div::after {
                content: counter(pages);
            }
            span {
                float: footnote;
            }
        </style>
        <div>ab<span>de</span></div>''')
    html, footnote_area = page.children
    body, = html.children
    div, = body.children
    div_textbox, footnote_call, div_after = div.children[0].children
    assert div_textbox.text == 'ab'
    assert footnote_call.children[0].text == '1'
    assert div_textbox.position_y == 0
    assert div_after.children[0].text == '1'

    footnote_marker, footnote_textbox = (
        footnote_area.children[0].children[0].children)
    assert footnote_marker.children[0].text == '1.'
    assert footnote_textbox.text == 'de'
    assert footnote_area.position_y == 5


@assert_no_logs
def test_reported_footnote_repagination():
    # Regression test for #1700.
    page1, page2 = render_pages('''
        <style>
            @page {
                size: 5px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
            }
            a::after {
                content: target-counter(attr(href), page);
            }
        </style>
        <div><a href="#i">a</a> bb<span>de</span> <i id="i">fg</i></div>''')
    html, = page1.children
    body, = html.children
    div, = body.children
    line1, line2 = div.children
    a, = line1.children
    assert a.children[0].text == 'a'
    assert a.children[1].children[0].text == '2'
    b, footnote_call, _ = line2.children
    assert b.text == 'bb'
    assert footnote_call.children[0].text == '1'

    html, footnote_area = page2.children
    body, = html.children
    div, = body.children
    line1, = div.children
    i, = line1.children
    assert i.children[0].text == 'fg'

    footnote_marker, footnote_textbox = (
        footnote_area.children[0].children[0].children)
    assert footnote_marker.children[0].text == '1.'
    assert footnote_textbox.text == 'de'
    assert footnote_area.position_y == 3


@assert_no_logs
def test_footnote_max_height():
    page1, page2 = render_pages('''
      <style>
        @page {
            size: 12px 6px;

            @footnote {
                margin-left: 1px;
                max-height: 4px;
            }
        }
        div {
            font-family: weasyprint;
            font-size: 2px;
            line-height: 1;
        }
        div.footnote {
            float: footnote;
        }
      </style>
      <div>ab<div class="footnote">c</div><div class="footnote">d</div>
      <div class="footnote">e</div></div>
      <div>fg</div>''')
    html1, footnote_area1 = page1.children
    body1, = html1.children
    div, = body1.children
    div_textbox, footnote_call1, footnote_call2, space, footnote_call3 = (
        div.children[0].children)
    assert div_textbox.text == 'ab'
    assert footnote_call1.children[0].text == '1'
    assert footnote_call2.children[0].text == '2'
    assert space.text == ' '
    assert footnote_call3.children[0].text == '3'
    footnote1, footnote2 = footnote_area1.children
    footnote_line1, = footnote1.children
    footnote_marker1, footnote_content1 = footnote_line1.children
    assert footnote_marker1.children[0].text == '1.'
    assert footnote_content1.text == 'c'
    footnote_line2, = footnote2.children
    footnote_marker2, footnote_content2 = footnote_line2.children
    assert footnote_marker2.children[0].text == '2.'
    assert footnote_content2.text == 'd'

    html2, footnote_area2 = page2.children
    body2, = html2.children
    div2, = body2.children
    div_textbox2, = div2.children[0].children
    assert div_textbox2.text == 'fg'
    footnote_line3, = footnote_area2.children[0].children
    footnote_marker3, footnote_content3 = footnote_line3.children
    assert footnote_marker3.children[0].text == '3.'
    assert footnote_content3.text == 'e'


def test_footnote_table_aborted_row():
    page1, page2 = render_pages('''
      <style>
        @page {size: 10px 35px}
        body {font-family: weasyprint; font-size: 2px}
        tr {height: 10px}
        .footnote {float: footnote}
      </style>
      <table><tbody>
        <tr><td>abc</td></tr>
        <tr><td>abc</td></tr>
        <tr><td>abc</td></tr>
        <tr><td>def<div class="footnote">f</div></td></tr>
      </tbody></table>
    ''')

    html, = page1.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    tbody, = table.children
    for tr in tbody.children:
        td, = tr.children
        line, = td.children
        textbox, = line.children
        assert textbox.text == 'abc'

    html, footnote_area = page2.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    tbody, = table.children
    tr, = tbody.children
    td, = tr.children
    line, = td.children
    textbox, call = line.children
    assert textbox.text == 'def'
    footnote, = footnote_area.children
    line, = footnote.children
    marker, textbox = line.children
    assert textbox.text == 'f'


def test_footnote_table_aborted_group():
    page1, page2 = render_pages('''
      <style>
        @page {size: 10px 35px}
        body {font-family: weasyprint; font-size: 2px}
        tr {height: 10px}
        tbody {break-inside: avoid}
        .footnote {float: footnote}
      </style>
      <table>
        <tbody>
          <tr><td>abc</td></tr>
          <tr><td>abc</td></tr>
        </tbody>
        <tbody>
          <tr><td>def<div class="footnote">f</div></td></tr>
          <tr><td>ghi</td></tr>
        </tbody>
      </table>
    ''')

    html, = page1.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    tbody, = table.children
    for tr in tbody.children:
        td, = tr.children
        line, = td.children
        textbox, = line.children
        assert textbox.text == 'abc'

    html, footnote_area = page2.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    tbody, = table.children
    tr1, tr2 = tbody.children
    td, = tr1.children
    line, = td.children
    textbox, call = line.children
    assert textbox.text == 'def'
    td, = tr2.children
    line, = td.children
    textbox, = line.children
    assert textbox.text == 'ghi'
    footnote, = footnote_area.children
    line, = footnote.children
    marker, textbox = line.children
    assert textbox.text == 'f'


@assert_no_logs
def test_footnote_bottom_margin():
    page, = render_pages('''
        <style>
            @page {
                size: 9px 7px;
            }
            div {
                font-family: weasyprint;
                font-size: 2px;
                line-height: 1;
            }
            span {
                float: footnote;
                margin-bottom: 1px;
            }
        </style>
        <div>abc<span>de</span></div>''')
    html, footnote_area = page.children
    body, = html.children
    div, = body.children
    div_textbox, footnote_call = div.children[0].children
    assert div_textbox.text == 'abc'
    assert footnote_call.children[0].text == '1'
    assert div_textbox.position_y == 0

    footnote_marker, footnote_textbox = (
        footnote_area.children[0].children[0].children)
    assert footnote_marker.children[0].text == '1.'
    assert footnote_textbox.text == 'de'
    assert footnote_area.position_y == 5


@assert_no_logs
def test_footnotes_column_converge_end():
    page1, page2 = render_pages('''
        <style>
            @page {
                size: 9px;
            }
            html {
                font: 2px/1 weasyprint;
            }
            div {
                columns: 2;
            }
            span {
                float: footnote;
            }
        </style>
        <div>
            a<span>1</span>
            b<span>2</span>
            c
            d<span>3</span>
        </div>
        <p>e</p>
    ''')

    # Page 1 contains a b c d 1 2.
    html, footnote_area = page1.children
    body, = html.children
    div, = body.children
    column1, column2 = div.children
    assert column1.height == column2.height == 4
    assert footnote_area.height == 4

    # Page 2 contains e 3.
    html, footnote_area = page2.children
    body, = html.children
    p, = body.children
    assert p.height == 2
    assert footnote_area.height == 2


@assert_no_logs
def test_footnotes_column_converge():
    page1, page2 = render_pages('''
        <style>
            @page {
                size: 9px;
            }
            html {
                font: 2px/1 weasyprint;
            }
            div {
                columns: 2;
            }
            span {
                float: footnote;
            }
        </style>
        <div>
            a<span>1</span>
            b<span>2</span>
            c
            d<span>3</span>
            e
            f
        </div>
        <p>g</p>
    ''')

    # Page 1 contains a b c d 1 2.
    html, footnote_area = page1.children
    body, = html.children
    div, = body.children
    column1, column2 = div.children
    assert column1.height == column2.height == 4
    assert footnote_area.height == 4

    # Page 2 contains e f g 3.
    html, footnote_area = page2.children
    body, = html.children
    div, p = body.children
    column1, column2 = div.children
    assert column1.height == column2.height == p.height == 2
    assert footnote_area.height == 2


================================================
FILE: tests/layout/test_grid.py
================================================
"""Tests for grid layout."""

from math import isclose

import pytest

from ..testing_utils import assert_no_logs, render_pages


@assert_no_logs
def test_grid_empty():
    page, = render_pages('''
      <article style="display: grid">
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    assert article.position_x == 0
    assert article.position_y == 0
    assert article.width == html.width
    assert article.height == 0


@assert_no_logs
def test_grid_single_item():
    page, = render_pages('''
      <article style="display: grid">
        <div>a</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert article.position_x == div.position_x == 0
    assert article.position_y == div.position_y == 0
    assert article.width == div.width == html.width


@assert_no_logs
def test_grid_single_auto_width():
    page, = render_pages('''
      <article style="display: grid">
        <div style="padding: 0 2px; justify-self: start"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert article.position_x == div.position_x == 0
    assert article.position_y == div.position_y == 0
    assert article.width == html.width
    assert div.width == 0
    assert div.padding_width() == 4


@assert_no_logs
def test_grid_single_percentage_width():
    page, = render_pages('''
      <article style="display: grid">
        <div style="justify-self: start; width: 100%"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div, = article.children
    assert article.position_x == div.position_x == 0
    assert article.position_y == div.position_y == 0
    assert article.width == html.width == div.padding_width()


@assert_no_logs
def test_grid_rows():
    page, = render_pages('''
      <article style="display: grid">
        <div>a</div>
        <div>b</div>
        <div>c</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c = article.children
    assert div_a.position_x == div_b.position_x == div_c.position_x == 0
    assert div_a.position_y < div_b.position_y < div_c.position_y
    assert div_a.height == div_b.height == div_c.height
    assert div_a.width == div_b.width == div_c.width == html.width == article.width


@assert_no_logs
def test_grid_template_fr():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-rows: auto 1fr;
          grid-template-columns: auto 1fr;
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div>a</div> <div>b</div>
        <div>c</div> <div>d</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d = article.children
    assert div_a.position_x == div_c.position_x == 0
    assert div_b.position_x == div_d.position_x == 2
    assert div_a.height == div_b.height == div_c.height == div_d.height == 2
    assert div_a.width == div_c.width == 2
    assert div_b.width == div_d.width == 8
    assert article.width == 10


@assert_no_logs
def test_grid_template_areas():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-areas: 'a b' 'c d';
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div>a</div> <div>b</div>
        <div>c</div> <div>d</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d = article.children
    assert div_a.position_x == div_c.position_x == 0
    assert div_b.position_x == div_d.position_x == 5
    assert div_a.position_y == div_b.position_y == 0
    assert div_c.position_y == div_d.position_y == 2
    assert div_a.height == div_b.height == div_c.height == div_d.height == 2
    assert div_a.width == div_b.width == div_c.width == div_d.width == 5
    assert article.width == 10


@assert_no_logs
def test_grid_template_areas_grid_area():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-areas: 'b a' 'd c';
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div style="grid-area: a">a</div> <div style="grid-area: b">b</div>
        <div style="grid-area: c">c</div> <div style="grid-area: d">d</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d = article.children
    assert div_b.position_x == div_d.position_x == 0
    assert div_a.position_x == div_c.position_x == 5
    assert div_a.position_y == div_b.position_y == 0
    assert div_c.position_y == div_d.position_y == 2
    assert div_a.height == div_b.height == div_c.height == div_d.height == 2
    assert div_a.width == div_b.width == div_c.width == div_d.width == 5
    assert article.width == 10


@assert_no_logs
def test_grid_template_areas_empty_row():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-areas: 'b a' 'd a' 'd c';
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div style="grid-area: a">a</div> <div style="grid-area: b">b</div>
        <div style="grid-area: c">c</div> <div style="grid-area: d">d</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d = article.children
    assert div_b.position_x == div_d.position_x == 0
    assert div_a.position_x == div_c.position_x == 5
    assert div_a.position_y == div_b.position_y == 0
    assert div_c.position_y == div_d.position_y == 2
    assert div_a.height == div_b.height == div_c.height == div_d.height == 2
    assert div_a.width == div_b.width == div_c.width == div_d.width == 5
    assert article.width == 10


@assert_no_logs
def test_grid_template_areas_multiple_rows():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-areas: 'b a' 'd a' '. c';
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div style="grid-area: a">a</div> <div style="grid-area: b">b</div>
        <div style="grid-area: c">c</div> <div style="grid-area: d">d</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d = article.children
    assert div_b.position_x == div_d.position_x == 0
    assert div_a.position_x == div_c.position_x == 5
    assert div_a.position_y == div_b.position_y == 0
    assert div_c.position_y == 4
    assert div_d.position_y == 2
    assert div_a.height == 4
    assert div_b.height == div_c.height == div_d.height == 2
    assert div_a.width == div_b.width == div_c.width == div_d.width == 5
    assert article.width == 10


@assert_no_logs
def test_grid_template_areas_multiple_columns():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-areas: 'b b' 'c a';
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div style="grid-area: a">a</div>
        <div style="grid-area: b">b</div>
        <div style="grid-area: c">c</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c = article.children
    assert div_b.position_x == div_c.position_x == 0
    assert div_a.position_x == 5
    assert div_a.position_y == div_c.position_y == 2
    assert div_b.position_y == 0
    assert div_a.height == div_b.height == div_c.height == 2
    assert div_a.width == div_c.width == 5
    assert div_b.width == 10
    assert article.width == 10


@assert_no_logs
def test_grid_template_areas_overlap():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-areas: 'a b' 'c d';
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div style="grid-area: a">a</div>
        <div style="grid-area: a">a</div>
        <div style="grid-area: a">a</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a1, div_a2, div_a3 = article.children
    assert div_a1.position_x == div_a2.position_x == div_a3.position_x == 0
    assert div_a1.position_y == div_a2.position_y == div_a3.position_y == 0
    assert div_a1.width == div_a2.width == div_a3.width == 6  # 2 + (10-2) / 2
    assert div_a1.height == div_a2.height == div_a3.height == 2
    assert article.width == 10


@assert_no_logs
def test_grid_template_big_span():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-columns: 50% 50%;
          line-height: 1;
          width: 6px;
        }
      </style>
      <article>
        <div>a</div>
        <div style="grid-row: span 2">b b b b</div>
        <div>a</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_1, div_2, div_3 = article.children
    assert div_1.position_x == div_3.position_x == 0
    assert div_2.position_x == 3
    assert div_1.position_y == div_2.position_y == 0
    assert div_3.position_y == 4
    assert div_1.width == div_2.width == div_3.width == 3
    assert div_1.height == div_3.height == 4
    assert div_2.height == article.height == 8
    assert article.width == 6


@assert_no_logs
def test_grid_template_multiple_big_span():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-columns: 50% 50%;
          line-height: 1;
          width: 6px;
        }
      </style>
      <article>
        <div>a</div>
        <div style="grid-row: span 3">b b b b b b</div>
        <div>a</div>
        <div>a</div>
        <div style="grid-row: span 2">c</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_1, div_2, div_3, div_4, div_5 = article.children
    assert div_1.position_x == div_3.position_x == div_4.position_x == 0
    assert div_5.position_x == 0
    assert div_2.position_x == 3
    assert div_1.position_y == div_2.position_y == 0
    assert div_3.position_y == 4
    assert div_4.position_y == 8
    assert div_5.position_y == 12
    assert div_1.width == div_2.width == div_3.width == div_5.width == 3
    assert div_4.width == 3
    assert div_1.height == div_3.height == div_4.height == 4
    assert div_2.height == 12
    assert div_5.height == 2
    assert article.height == 14
    assert article.width == 6


@assert_no_logs
def test_grid_template_areas_span_overflow():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-columns: 50% 50%;
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div style="">a</div>
        <div style="grid-column: span 2">a</div>
        <div style="">a</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a1, div_a2, div_a3 = article.children
    assert div_a1.position_x == div_a2.position_x == div_a3.position_x == 0
    assert div_a1.position_y == 0
    assert div_a2.position_y == 2
    assert div_a3.position_y == 4
    assert div_a1.width == div_a3.width == 5
    assert div_a2.width == 10
    assert div_a1.height == div_a2.height == div_a3.height == 2
    assert article.width == 10


@assert_no_logs
def test_grid_template_areas_extra_span():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-areas: 'a . b' 'c d d';
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div style="grid-area: a">a</div>
        <div style="grid-area: b">b</div>
        <div style="grid-area: c">c</div>
        <div style="grid-area: d">d</div>
        <div style="grid-row: span 2; grid-column: span 2">e</div>
        <div>f</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d, div_e, div_f = article.children
    assert div_a.position_x == div_c.position_x == div_e.position_x == 0
    assert div_d.position_x == 4  # 2 + (10 - 2×3) / 2
    assert div_b.position_x == div_f.position_x == 6
    assert div_a.position_y == div_b.position_y == 0
    assert div_c.position_y == div_d.position_y == 2
    assert div_e.position_y == div_f.position_y == 4
    assert div_a.width == div_b.width == div_c.width == div_f.width == 4
    assert div_d.width == div_e.width == 6
    assert {div.height for div in article.children} == {2}
    assert article.width == 10


@assert_no_logs
def test_grid_template_areas_extra_span_dense():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-auto-flow: dense;
          grid-template-areas: 'a . b' 'c d d';
          line-height: 1;
          width: 9px;
        }
      </style>
      <article>
        <div style="grid-area: a">a</div>
        <div style="grid-area: b">b</div>
        <div style="grid-area: c">c</div>
        <div style="grid-area: d">d</div>
        <div style="grid-row: span 2; grid-column: span 2">e</div>
        <div>f</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d, div_e, div_f = article.children
    assert div_a.position_x == div_c.position_x == div_e.position_x == 0
    assert div_d.position_x == div_f.position_x == 3
    assert div_b.position_x == 6
    assert div_a.position_y == div_b.position_y == div_f.position_y == 0
    assert div_c.position_y == div_d.position_y == 2
    assert div_e.position_y == 4
    assert div_a.width == div_b.width == div_c.width == div_f.width == 3
    assert div_d.width == div_e.width == 6
    assert {div.height for div in article.children} == {2}
    assert article.height == 6
    assert article.width == 9


@assert_no_logs
def test_grid_area_multiple_values():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-columns: 5px 5px;
          grid-template-rows: 2px 2px;
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div style="grid-area: 2 / 1 / 3 / 2">a</div>
        <div style="grid-area: 1 / 1 / 2 / 3">b</div>
        <div style="grid-area: 2 / 2 / 3 / 3">c</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c = article.children
    assert div_a.position_x == div_b.position_x == 0
    assert div_c.position_x == 5
    assert div_b.position_y == 0
    assert div_a.position_y == div_c.position_y == 2
    assert div_a.height == div_b.height == div_c.height == 2
    assert div_a.width == div_c.width == 5
    assert div_b.width == 10
    assert article.width == 10


@assert_no_logs
def test_grid_template_repeat_fr():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-columns: repeat(2, 1fr 2fr);
          line-height: 1;
          width: 12px;
        }
      </style>
      <article>
        <div>a</div>
        <div>b</div>
        <div>c</div>
        <div>d</div>
        <div>e</div>
        <div>f</div>
        <div>g</div>
        <div>h</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d, div_e, div_f, div_g, div_h = article.children
    assert div_a.position_x == div_e.position_x == 0
    assert div_b.position_x == div_f.position_x == 2
    assert div_c.position_x == div_g.position_x == 6
    assert div_d.position_x == div_h.position_x == 8
    assert div_a.position_y == div_b.position_y == 0
    assert div_c.position_y == div_d.position_y == 0
    assert div_e.position_y == div_f.position_y == 2
    assert div_g.position_y == div_h.position_y == 2
    assert div_a.width == div_c.width == div_e.width == div_g.width == 2
    assert div_b.width == div_d.width == div_f.width == div_h.width == 4
    assert {div.height for div in article.children} == {2}
    assert article.width == 12


@assert_no_logs
def test_grid_template_shorthand_fr():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template: auto 1fr / auto 1fr auto;
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div>a</div>
        <div>b</div>
        <div>c</div>
        <div>d</div>
        <div>e</div>
        <div>f</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d, div_e, div_f = article.children
    assert div_a.position_x == div_d.position_x == 0
    assert div_b.position_x == div_e.position_x == 2
    assert div_c.position_x == div_f.position_x == 8
    assert div_a.position_y == div_b.position_y == div_c.position_y == 0
    assert div_d.position_y == div_e.position_y == div_f.position_y == 2
    assert div_a.width == div_c.width == div_d.width == div_f.width == 2
    assert div_b.width == div_e.width == 6
    assert {div.height for div in article.children} == {2}
    assert article.width == 10


@assert_no_logs
def test_grid_shorthand_auto_flow_rows_fr_size():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid: auto-flow 1fr / 6px;
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div>a</div>
        <div>b</div>
        <div>c</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c = article.children
    assert div_a.position_x == div_b.position_x == div_c.position_x == 0
    assert div_a.position_y == 0
    assert div_b.position_y == 2
    assert div_c.position_y == 4
    assert div_a.width == div_b.width == div_c.width == 6
    assert {div.height for div in article.children} == {2}
    assert article.width == 10


@assert_no_logs
def test_grid_template_fr_too_large():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-columns: 1fr 1fr;
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div>a</div><div>bbb</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b = article.children
    assert div_a.position_x == 0
    assert div_b.position_x == 4
    assert div_a.position_y == div_b.position_y == 0
    assert div_a.height == div_b.height == 2
    assert div_a.width == 4
    assert div_b.width == 6
    assert article.width == 10


def test_grid_shorthand_auto_flow_columns_none_dense():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid: none / auto-flow dense 1fr;
          line-height: 1;
          width: 12px;
        }
      </style>
      <article>
        <div>a</div>
        <div>b</div>
        <div>c</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c = article.children
    assert div_a.position_x == 0
    assert div_b.position_x == 4
    assert div_c.position_x == 8
    assert div_a.position_y == div_b.position_y == div_c.position_y == 0
    assert div_a.height == div_b.height == div_c.height == 2
    assert {div.width for div in article.children} == {4}
    assert article.width == 12


@assert_no_logs
def test_grid_template_fr_undefined_free_space():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-rows: 1fr 1fr;
          grid-template-columns: 1fr 1fr;
          line-height: 1;
          width: 10px;
        }
      </style>
      <article>
        <div>a</div> <div>b<br>b<br>b<br>b</div>
        <div>c</div> <div>d</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d = article.children
    assert div_a.position_x == div_c.position_x == 0
    assert div_b.position_x == div_d.position_x == 5
    assert div_a.height == div_b.height == div_c.height == div_d.height == 8
    assert div_a.width == div_c.width == 5
    assert div_b.width == div_d.width == 5
    assert article.width == 10
    assert article.height == 16


@assert_no_logs
def test_grid_column_start():
    page, = render_pages('''
      <style>
        dl {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-columns: max-content auto;
          line-height: 1;
          width: 10px;
        }
        dt {
          display: block;
          grid-column-start: 1;
        }
        dd {
          display: block;
          grid-column-start: 2;
        }
      </style>
      <dl>
        <dt>A</dt>
        <dd>A1</dd>
        <dd>A2</dd>
        <dt>B</dt>
        <dd>B1</dd>
        <dd>B2</dd>
      </dl>
    ''')
    html, = page.children
    body, = html.children
    dl, = body.children
    dt_a, dd_a1, dd_a2, dt_b, dd_b1, dd_b2 = dl.children
    assert dt_a.position_y == dd_a1.position_y == 0
    assert dd_a2.position_y == 2
    assert dt_b.position_y == dd_b1.position_y == 4
    assert dd_b2.position_y == 6
    assert dt_a.position_x == dt_b.position_x == 0
    assert dd_a1.position_x == dd_a2.position_x == 2
    assert dd_b1.position_x == dd_b2.position_x == 2


@assert_no_logs
def test_grid_column_start_blockified():
    page, = render_pages('''
      <style>
        dl {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-columns: max-content auto;
          line-height: 1;
          width: 10px;
        }
        dt {
          display: inline;
          grid-column-start: 1;
        }
        dd {
          display: inline;
          grid-column-start: 2;
        }
      </style>
      <dl>
        <dt>A</dt>
        <dd>A1</dd>
        <dd>A2</dd>
        <dt>B</dt>
        <dd>B1</dd>
        <dd>B2</dd>
      </dl>
    ''')
    html, = page.children
    body, = html.children
    dl, = body.children
    dt_a, dd_a1, dd_a2, dt_b, dd_b1, dd_b2 = dl.children
    assert dt_a.position_y == dd_a1.position_y == 0
    assert dd_a2.position_y == 2
    assert dt_b.position_y == dd_b1.position_y == 4
    assert dd_b2.position_y == 6
    assert dt_a.position_x == dt_b.position_x == 0
    assert dd_a1.position_x == dd_a2.position_x == 2
    assert dd_b1.position_x == dd_b2.position_x == 2


@assert_no_logs
def test_grid_undefined_free_space():
    page, = render_pages('''
      <style>
        body {
          font-family: weasyprint;
          font-size: 2px;
          line-height: 1;
        }
        .columns {
          display: grid;
          grid-template-columns: 1fr 1fr;
          width: 8px;
        }
        .rows {
          display: grid;
          grid-template-rows: 1fr 1fr;
        }
      </style>
      <div class="columns">
        <div class="rows">
          <div>aa</div>
          <div>b</div>
        </div>
        <div class="rows">
          <div>c<br>c</div>
          <div>d</div>
        </div>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div_c, = body.children
    div_c1, div_c2 = div_c.children
    div_r11, div_r12 = div_c1.children
    div_r21, div_r22 = div_c2.children
    assert div_r11.position_x == div_r12.position_x == 0
    assert div_r21.position_x == div_r22.position_x == 4
    assert div_r11.position_y == div_r21.position_y == 0
    assert div_r12.position_y == div_r22.position_y == 4
    assert div_r11.height == div_r12.height == div_r21.height == div_r22.height == 4
    assert div_r11.width == div_r12.width == div_r21.width == div_r22.width == 4
    assert div_c.width == 8


@assert_no_logs
def test_grid_padding():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-rows: auto 1fr;
          grid-template-columns: auto 1fr;
          line-height: 1;
          width: 14px;
        }
      </style>
      <article>
        <div style="padding: 1px">a</div> <div>b</div>
        <div>c</div> <div style="padding: 2px">d</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d = article.children
    assert div_a.position_x == div_c.position_x == div_c.content_box_x() == 0
    assert div_a.content_box_x() == 1
    assert div_b.position_x == div_b.content_box_x() == div_d.position_x == 4
    assert div_d.content_box_x() == 6
    assert div_a.width == 2
    assert div_b.width == 10
    assert div_c.width == 4
    assert div_d.width == 6
    assert article.width == 14
    assert div_a.position_y == div_b.position_y == div_b.content_box_y() == 0
    assert div_a.content_box_y() == 1
    assert div_c.position_y == div_c.content_box_y() == div_d.position_y == 4
    assert div_d.content_box_y() == 6
    assert div_a.height == div_d.height == 2
    assert div_b.height == 4
    assert div_c.height == 6
    assert article.height == 10


@assert_no_logs
def test_grid_border():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-rows: auto 1fr;
          grid-template-columns: auto 1fr;
          line-height: 1;
          width: 14px;
        }
      </style>
      <article>
        <div style="border: 1px solid">a</div> <div>b</div>
        <div>c</div> <div style="border: 2px solid">d</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d = article.children
    assert div_a.position_x == div_c.position_x == div_c.padding_box_x() == 0
    assert div_a.padding_box_x() == 1
    assert div_b.position_x == div_b.padding_box_x() == div_d.position_x == 4
    assert div_d.padding_box_x() == 6
    assert div_a.width == 2
    assert div_b.width == 10
    assert div_c.width == 4
    assert div_d.width == 6
    assert article.width == 14
    assert div_a.position_y == div_b.position_y == div_b.padding_box_y() == 0
    assert div_a.padding_box_y() == 1
    assert div_c.position_y == div_c.padding_box_y() == div_d.position_y == 4
    assert div_d.padding_box_y() == 6
    assert div_a.height == div_d.height == 2
    assert div_b.height == 4
    assert div_c.height == 6
    assert article.height == 10


@assert_no_logs
def test_grid_border_box():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-rows: auto 1fr;
          grid-template-columns: auto 1fr;
          line-height: 1;
          width: 14px;
        }
        div { box-sizing: border-box }
      </style>
      <article>
        <div style="border: 1px solid; width: 7px">a</div> <div>b</div>
        <div>c</div> <div style="padding: 2px; height: 7px">d</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d = article.children
    assert div_a.position_x == div_c.position_x == div_c.padding_box_x() == 0
    assert div_a.padding_box_x() == 1
    assert div_b.position_x == div_b.padding_box_x() == div_d.position_x == 7
    assert div_d.content_box_x() == 9
    assert div_a.width == 5
    assert div_b.width == 7
    assert div_c.width == 7
    assert div_d.width == 3
    assert article.width == 14
    assert div_a.position_y == div_b.position_y == div_b.padding_box_y() == 0
    assert div_a.padding_box_y() == 1
    assert div_c.position_y == div_c.padding_box_y() == div_d.position_y == 4
    assert div_d.content_box_y() == 6
    assert div_a.height == 2
    assert div_b.height == 4
    assert div_c.height == 7
    assert div_d.height == 3
    assert article.height == 11


@assert_no_logs
def test_grid_item_border_box():
    page, = render_pages('''
      <style>
        @page { size: 50px }
      </style>
      <article style="display: grid">
        <section style="box-sizing: border-box; padding: 5px">
          <div>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    section, = article.children
    assert section.margin_width() == 50
    assert section.width == 40
    assert section.position_x == section.position_y == 0
    div, = section.children
    assert div.width == div.margin_width() == 40
    assert div.position_x == div.position_y == 5


@assert_no_logs
def test_grid_border_split():
    page1, page2 = render_pages('''
      <style>
        @page { size: 5px }
        body { font: 2px / 1 weasyprint }
      </style>
      <article style="display: grid; border-top: 1px solid; border-bottom: 1px solid;
                      margin: 1px 0; padding: 1px 0">
        <div>a<br>b</div>
      </article>
    ''')
    html, = page1.children
    body, = html.children
    article, = body.children
    assert article.border_top_width == 1
    assert article.border_bottom_width == 0
    assert article.margin_height() == 5
    section, = article.children
    assert section.position_x == 0
    assert section.position_y == 3
    assert section.width == html.width
    assert section.height == 2

    html, = page2.children
    body, = html.children
    article, = body.children
    assert article.border_top_width == 0
    assert article.border_bottom_width == 1
    assert article.margin_height() == 5
    section, = article.children
    assert section.position_x == 0
    assert section.position_y == 0
    assert section.width == html.width
    assert section.height == 2


@assert_no_logs
def test_grid_margin():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-template-rows: auto 1fr;
          grid-template-columns: auto 1fr;
          line-height: 1;
          width: 14px;
        }
      </style>
      <article>
        <div style="margin: 1px">a</div> <div>b</div>
        <div>c</div> <div style="margin: 2px">d</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d = article.children
    assert div_a.position_x == div_c.position_x == div_c.border_box_x() == 0
    assert div_a.border_box_x() == 1
    assert div_b.position_x == div_b.border_box_x() == div_d.position_x == 4
    assert div_d.border_box_x() == 6
    assert div_a.width == 2
    assert div_b.width == 10
    assert div_c.width == 4
    assert div_d.width == 6
    assert article.width == 14
    assert div_a.position_y == div_b.position_y == div_b.border_box_y() == 0
    assert div_a.border_box_y() == 1
    assert div_c.position_y == div_c.border_box_y() == div_d.position_y == 4
    assert div_d.border_box_y() == 6
    assert div_a.height == div_d.height == 2
    assert div_b.height == 4
    assert div_c.height == 6
    assert article.height == 10


@assert_no_logs
def test_grid_item_margin():
    # Regression test for #2154.
    page, = render_pages('''
      <style>
        article { display: grid }
        div { margin: auto }
      </style>
      <article>
        <div>a</div>
        <div>b</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b = article.children
    # TODO: Test auto margin values.


@assert_no_logs
def test_grid_auto_flow_column():
    page, = render_pages('''
      <article style="display: grid; grid-auto-flow: column">
        <div>a</div>
        <div>a</div>
        <div>a</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c = article.children
    assert div_a.position_x < div_b.position_x < div_c.position_x
    assert div_a.position_y == div_b.position_y == div_c.position_y == 0
    assert div_a.width == div_b.width == div_c.width
    assert div_a.height == div_b.height == div_c.height == html.height == article.height


@assert_no_logs
def test_grid_template_areas_extra_span_column_dense():
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          grid-auto-flow: column dense;
          grid-template-areas: 'a . b' 'c d d';
          line-height: 1;
          width: 12px;
        }
      </style>
      <article>
        <div style="grid-area: a">a</div>
        <div style="grid-area: b">b</div>
        <div style="grid-area: c">c</div>
        <div style="grid-area: d">d</div>
        <div style="grid-row: span 2">e</div>
        <div>f</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b, div_c, div_d, div_e, div_f = article.children
    assert div_a.position_x == div_c.position_x == 0
    assert div_d.position_x == div_f.position_x == 3
    assert div_b.position_x == 6
    assert div_e.position_x == 9
    assert (
        div_a.position_y == div_b.position_y ==
        div_e.position_y == div_f.position_y == 0)
    assert div_c.position_y == div_d.position_y == 2
    assert (
        div_a.width == div_b.width == div_c.width ==
        div_e.width == div_f.width == 3)
    assert div_d.width == 6
    assert (
        div_a.height == div_b.height == div_c.height ==
        div_d.height == div_f.height == 2)
    assert div_e.height == 4
    assert article.height == 4
    assert article.width == 12


@assert_no_logs
def test_grid_gap_explicit_grid_column():
    # Regression test for #2187.
    page, = render_pages('''
      <style>
        article {
          display: grid;
          font-family: weasyprint;
          font-size: 2px;
          gap: 2px;
          grid-template-columns: 1fr;
          line-height: 1;
          width: 12px;
        }
      </style>
      <article>
        <div>a</div>
        <div style="grid-column: 1">b</div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div_a, div_b = article.children
    assert div_a.position_x == div_b.position_x == 0
    assert div_a.position_y == 0
    assert div_b.position_y == 4
    assert article.height == 6
    assert article.width == 12


@assert_no_logs
def test_grid_break():
    page1, page2 = render_pages('''
      <style>
        @page { size: 10px 11px }
        body { font: 2px / 1 weasyprint }
        section { display: grid; grid-template-columns: 1fr 1fr }
      </style>
      <section>
        <div>1</div>
        <div>2</div>
        <div>3</div>
        <div>4</div>
        <div>5</div>
        <div>6</div>
        <div>7a<br>7b<br>7c</div>
        <div>8</div>
        <div>9</div>
        <div>10</div>
      </section>
    ''')
    html, = page1.children
    body, = html.children
    section, = body.children
    assert section.height == 11
    div1, div2, div3, div4, div5, div6, div7, div8 = section.children
    assert div1.position_x == div3.position_x == div5.position_x == div7.position_x == 0
    assert div2.position_x == div4.position_x == div6.position_x == div8.position_x == 5
    assert div1.position_y == div2.position_y == 0
    assert div1.height == div2.height == 2
    assert div3.position_y == div4.position_y == 2
    assert div3.height == div4.height == 2
    assert div5.position_y == div6.position_y == 4
    assert div5.height == div6.height == 2
    assert div7.position_y == div8.position_y == 6
    assert div7.height == div8.height == 5
    line1, line2 = div7.children
    text, br = line1.children
    assert text.text == '7a'
    text, br = line2.children
    assert text.text == '7b'
    line, = div8.children
    text, = line.children
    assert text.text == '8'

    html, = page2.children
    body, = html.children
    section, = body.children
    assert section.height == 4
    div7, div8, div9, div10 = section.children
    assert div7.position_x == div9.position_x == 0
    assert div8.position_x == div10.position_x == 5
    assert div7.position_y == div8.position_y == 0
    assert div9.position_y == div10.position_y == 2
    assert div7.height == div8.height == div9.height == div10.height == 2
    line, = div7.children
    text, = line.children
    assert text.text == '7c'
    assert not div8.children


@assert_no_logs
def test_grid_break_order_negative():
    page1, page2 = render_pages('''
      <style>
        @page { size: 10px 11px }
        body { font: 2px / 1 weasyprint }
        section { display: grid; grid-template-columns: 1fr 1fr }
      </style>
      <section>
        <div>3</div>
        <div>4</div>
        <div>5</div>
        <div>6</div>
        <div>7a<br>7b<br>7c</div>
        <div>8</div>
        <div>9</div>
        <div>10</div>
        <div style="order: -2">1</div>
        <div style="order: -1">2</div>
      </section>
    ''')
    html, = page1.children
    body, = html.children
    section, = body.children
    assert section.height == 11
    div1, div2, div3, div4, div5, div6, div7, div8 = section.children
    assert div1.position_x == div3.position_x == div5.position_x == div7.position_x == 0
    assert div2.position_x == div4.position_x == div6.position_x == div8.position_x == 5
    assert div1.position_y == div2.position_y == 0
    assert div1.height == div2.height == 2
    assert div3.position_y == div4.position_y == 2
    assert div3.height == div4.height == 2
    assert div5.position_y == div6.position_y == 4
    assert div5.height == div6.height == 2
    assert div7.position_y == div8.position_y == 6
    assert div7.height == div8.height == 5
    line1, line2 = div7.children
    text, br = line1.children
    assert text.text == '7a'
    text, br = line2.children
    assert text.text == '7b'
    line, = div8.children
    text, = line.children
    assert text.text == '8'

    html, = page2.children
    body, = html.children
    section, = body.children
    assert section.height == 4
    div7, div8, div9, div10 = section.children
    assert div7.position_x == div9.position_x == 0
    assert div8.position_x == div10.position_x == 5
    assert div7.position_y == div8.position_y == 0
    assert div9.position_y == div10.position_y == 2
    assert div7.height == div8.height == div9.height == div10.height == 2
    line, = div7.children
    text, = line.children
    assert text.text == '7c'
    assert not div8.children


@assert_no_logs
def test_grid_break_order_positive():
    page1, page2 = render_pages('''
      <style>
        @page { size: 10px 11px }
        body { font: 2px / 1 weasyprint }
        section { display: grid; grid-template-columns: 1fr 1fr }
      </style>
      <section>
        <div>1</div>
        <div>2</div>
        <div style="order: 9">9</div>
        <div style="order: 10">10</div>
        <div>3</div>
        <div>4</div>
        <div>5</div>
        <div>6</div>
        <div>7a<br>7b<br>7c</div>
        <div>8</div>
      </section>
    ''')
    html, = page1.children
    body, = html.children
    section, = body.children
    assert section.height == 11
    div1, div2, div3, div4, div5, div6, div7, div8 = section.children
    assert div1.position_x == div3.position_x == div5.position_x == div7.position_x == 0
    assert div2.position_x == div4.position_x == div6.position_x == div8.position_x == 5
    assert div1.position_y == div2.position_y == 0
    assert div1.height == div2.height == 2
    assert div3.position_y == div4.position_y == 2
    assert div3.height == div4.height == 2
    assert div5.position_y == div6.position_y == 4
    assert div5.height == div6.height == 2
    assert div7.position_y == div8.position_y == 6
    assert div7.height == div8.height == 5
    line1, line2 = div7.children
    text, br = line1.children
    assert text.text == '7a'
    text, br = line2.children
    assert text.text == '7b'
    line, = div8.children
    text, = line.children
    assert text.text == '8'

    html, = page2.children
    body, = html.children
    section, = body.children
    assert section.height == 4
    div7, div8, div9, div10 = section.children
    assert div7.position_x == div9.position_x == 0
    assert div8.position_x == div10.position_x == 5
    assert div7.position_y == div8.position_y == 0
    assert div9.position_y == div10.position_y == 2
    assert div7.height == div8.height == div9.height == div10.height == 2
    line, = div7.children
    text, = line.children
    assert text.text == '7c'
    assert not div8.children
    line, = div9.children
    text, = line.children
    assert text.text == '9'
    line, = div10.children
    text, = line.children
    assert text.text == '10'


@assert_no_logs
def test_grid_break_border():
    page1, page2 = render_pages('''
      <style>
        @page { size: 12px 18px }
        body { font: 2px / 1 weasyprint }
        section { display: grid; grid-template-columns: 1fr 1fr }
        div { border: 1px solid }
      </style>
      <section>
        <div>1</div>
        <div>2</div>
        <div>3</div>
        <div>4</div>
        <div>5</div>
        <div>6</div>
        <div>7a<br>7b<br>7c</div>
        <div>8</div>
        <div>9</div>
        <div>10</div>
      </section>
    ''')
    html, = page1.children
    body, = html.children
    section, = body.children
    assert section.height == 18
    div1, div2, div3, div4, div5, div6, div7, div8 = section.children
    for div in section.children:
        assert div.border_top_width == 1
        assert div.border_left_width == 1
        assert div.border_right_width == 1
    for div in div1, div2, div3, div4, div5, div6:
        assert div.border_bottom_width == 1
    for div in div7, div8:
        assert div.border_bottom_width == 0
    assert div1.position_x == div3.position_x == div5.position_x == div7.position_x == 0
    assert div2.position_x == div4.position_x == div6.position_x == div8.position_x == 6
    assert div1.position_y == div2.position_y == 0
    assert div1.height == div2.height == 2
    assert div1.width == div2.width == 4
    assert div3.position_y == div4.position_y == 4
    assert div3.height == div4.height == 2
    assert div5.position_y == div6.position_y == 8
    assert div5.height == div6.height == 2
    assert div7.position_y == div8.position_y == 12
    assert div7.height == div8.height == 5
    line1, line2 = div7.children
    text, br = line1.children
    assert text.text == '7a'
    text, br = line2.children
    assert text.text == '7b'
    line, = div8.children
    text, = line.children
    assert text.text == '8'

    html, = page2.children
    body, = html.children
    section, = body.children
    # assert section.height == 7
    div7, div8, div9, div10 = section.children
    for div in section.children:
        assert div.border_bottom_width == 1
        assert div.border_left_width == 1
        assert div.border_right_width == 1
    for div in div7, div8:
        assert div.border_top_width == 0
    for div in div9, div10:
        assert div.border_top_width == 1
    assert div7.position_x == div9.position_x == 0
    assert div8.position_x == div10.position_x == 6
    assert div7.position_y == div8.position_y == 0
    assert div9.position_y == div10.position_y == 3
    assert div7.height == div8.height == div9.height == div10.height == 2
    assert div7.width == div8.width == div9.width == div10.width == 4
    line, = div7.children
    text, = line.children
    assert text.text == '7c'
    assert not div8.children


@assert_no_logs
def test_grid_break_multiple():
    page1, page2, page3 = render_pages('''
      <style>
        @page { size: 10px 11px }
        body { font: 2px / 1 weasyprint }
        section { display: grid; grid-template-columns: 1fr 1fr }
      </style>
      <section>
        <div>1</div>
        <div>2</div>
        <div>3</div>
        <div>4</div>
        <div>5</div>
        <div>6</div>
        <div>7a<br>7b<br>7c<br>7d<br>7e<br>7f<br>7g<br>7h</div>
        <div>8</div>
        <div>9</div>
        <div>10</div>
      </section>
    ''')
    html, = page1.children
    body, = html.children
    section, = body.children
    assert section.height == 11
    div1, div2, div3, div4, div5, div6, div7, div8 = section.children
    assert div1.position_x == div3.position_x == div5.position_x == div7.position_x == 0
    assert div2.position_x == div4.position_x == div6.position_x == div8.position_x == 5
    assert div1.position_y == div2.position_y == 0
    assert div1.height == div2.height == 2
    assert div3.position_y == div4.position_y == 2
    assert div3.height == div4.height == 2
    assert div5.position_y == div6.position_y == 4
    assert div5.height == div6.height == 2
    assert div7.position_y == div8.position_y == 6
    assert div7.height == div8.height == 5
    line1, line2 = div7.children
    text, br = line1.children
    assert text.text == '7a'
    text, br = line2.children
    assert text.text == '7b'
    line, = div8.children
    text, = line.children
    assert text.text == '8'

    html, = page2.children
    body, = html.children
    section, = body.children
    assert section.height == 11
    div7, div8 = section.children
    assert div7.position_x == 0
    assert div8.position_x == 5
    assert div7.height == div8.height == 11
    line1, line2, line3, line4, line5 = div7.children
    text, _ = line1.children
    assert text.text == '7c'
    text, _ = line2.children
    assert text.text == '7d'
    text, _ = line3.children
    assert text.text == '7e'
    text, _ = line4.children
    assert text.text == '7f'
    text, _ = line5.children
    assert text.text == '7g'
    assert not div8.children

    html, = page3.children
    body, = html.children
    section, = body.children
    assert section.height == 4
    div7, div8, div9, div10 = section.children
    assert div7.position_x == div9.position_x == 0
    assert div8.position_x == div10.position_x == 5
    assert div7.position_y == div8.position_y == 0
    assert div9.position_y == div10.position_y == 2
    assert div7.height == div8.height == div9.height == div10.height == 2
    line, = div7.children
    text, = line.children
    assert text.text == '7h'
    assert not div8.children


@assert_no_logs
def test_grid_break_span():
    page1, page2 = render_pages('''
      <style>
        @page { size: 10px 11px }
        body { font: 2px / 1 weasyprint }
        section { display: grid; grid-template-columns: 1fr 1fr }
      </style>
      <section>
        <div>1</div>
        <div>2</div>
        <div>3</div>
        <div>4</div>
        <div>5</div>
        <div>6</div>
        <div style="grid-row: span 3">7a<br>7b<br>7c<br>7d</div>
        <div>8</div>
        <div>9</div>
        <div>10</div>
        <div>11</div>
        <div>12</div>
      </section>
    ''')
    html, = page1.children
    body, = html.children
    section, = body.children
    assert section.height == 11
    div1, div2, div3, div4, div5, div6, div7, div8, div9 = section.children
    assert div1.position_x == div3.position_x == div5.position_x == div7.position_x == 0
    assert div2.position_x == div4.position_x == div6.position_x == div8.position_x == 5
    assert div1.position_y == div2.position_y == 0
    assert div1.height == div2.height == 2
    assert div3.position_y == div4.position_y == 2
    assert div3.height == div4.height == 2
    assert div5.position_y == div6.position_y == 4
    assert div5.height == div6.height == 2
    assert div7.position_y == div8.position_y == 6
    assert div7.height == 5
    assert isclose(div8.height, 8 / 3)
    assert isclose(div9.height, 7 / 3)
    line1, line2 = div7.children
    text, br = line1.children
    assert text.text == '7a'
    text, br = line2.children
    assert text.text == '7b'
    line, = div8.children
    text, = line.children
    assert text.text == '8'
    line, = div9.children
    text, = line.children
    assert text.text == '9'

    html, = page2.children
    body, = html.children
    section, = body.children
    assert isclose(section.height, 6)
    div7, div9, div10, div11, div12 = section.children
    assert div7.position_x == 0
    assert div8.position_x == 5
    assert div7.height == 4
    line1, line2 = div7.children
    text, br = line1.children
    assert text.text == '7c'
    text, = line2.children
    assert text.text == '7d'
    assert not div9.children
    assert div10.position_x == 5
    assert isclose(div10.position_y, 4 / 3)
    line, = div10.children
    text, = line.children
    assert text.text == '10'
    assert div11.position_x == 0
    assert div12.position_x == 5
    assert div11.position_y == div12.position_y
    assert isclose(div11.position_y, 4)
    line, = div11.children
    text, = line.children
    assert text.text == '11'
    line, = div12.children
    text, = line.children
    assert text.text == '12'


@assert_no_logs
def test_grid_break_item_avoid():
    page1, page2 = render_pages('''
      <style>
        @page { size: 10px 11px }
        body { font: 2px / 1 weasyprint }
        section { display: grid; grid-template-columns: 1fr 1fr }
      </style>
      <section>
        <div>1</div>
        <div>2</div>
        <div>3</div>
        <div>4</div>
        <div>5</div>
        <div>6</div>
        <div>7a<br>7b<br>7c</div>
        <div style="break-inside: avoid">8</div>
        <div>9</div>
        <div>10</div>
      </section>
    ''')
    html, = page1.children
    body, = html.children
    section, = body.children
    assert section.height == 11
    div1, div2, div3, div4, div5, div6 = section.children
    assert div1.position_x == div3.position_x == div5.position_x == 0
    assert div2.position_x == div4.position_x == div6.position_x == 5
    assert div1.position_y == div2.position_y == 0
    assert div1.height == div2.height == 2
    assert div3.position_y == div4.position_y == 2
    assert div3.height == div4.height == 2
    assert div5.position_y == div6.position_y == 4
    assert div5.height == div6.height == 2

    html, = page2.children
    body, = html.children
    section, = body.children
    assert section.height == 8
    div7, div8, div9, div10 = section.children
    assert div7.position_x == div9.position_x == 0
    assert div8.position_x == div10.position_x == 5
    assert div7.position_y == div8.position_y == 0
    assert div9.position_y == div10.position_y == 6
    assert div7.height == div8.height == 6
    assert div9.height == div10.height == 2
    assert len(div7.children) == 3
    assert len(div8.children) == 1


@assert_no_logs
def test_grid_break_item_avoid_auto():
    page1, page2 = render_pages('''
      <style>
        @page { size: 10px 11px }
        body { font: 2px / 1 weasyprint }
        section { display: grid; grid-template-columns: 1fr 1fr }
      </style>
      <section>
        <div>1</div>
        <div>2</div>
        <div>3</div>
        <div>4</div>
        <div>5</div>
        <div>6</div>
        <div style="break-inside: avoid">7a<br>7b<br>7c</div>
        <div style="break-inside: auto">8</div>
        <div>9</div>
        <div>10</div>
      </section>
    ''')
    html, = page1.children
    body, = html.children
    section, = body.children
    assert section.height == 11
    div1, div2, div3, div4, div5, div6 = section.children
    assert div1.position_x == div3.position_x == div5.position_x == 0
    assert div2.position_x == div4.position_x == div6.position_x == 5
    assert div1.position_y == div2.position_y == 0
    assert div1.height == div2.height == 2
    assert div3.position_y == div4.position_y == 2
    assert div3.height == div4.height == 2
    assert div5.position_y == div6.position_y == 4
    assert div5.height == div6.height == 2

    html, = page2.children
    body, = html.children
    section, = body.children
    assert section.height == 8
    div7, div8, div9, div10 = section.children
    assert div7.position_x == div9.position_x == 0
    assert div8.position_x == div10.position_x == 5
    assert div7.position_y == div8.position_y == 0
    assert div9.position_y == div10.position_y == 6
    assert div7.height == div8.height == 6
    assert div9.height == div10.height == 2
    assert len(div7.children) == 3
    assert len(div8.children) == 1


@assert_no_logs
def test_grid_break_container():
    page1, page2 = render_pages('''
      <style>
        @page { size: 10px 11px }
        body { font: 2px / 1 weasyprint }
        section { display: grid; grid-template-columns: 1fr 1fr }
      </style>
      <p>1<br>2<br>3<br>4</p>
      <section style="break-inside: avoid">
        <div>5</div>
        <div>6</div>
        <div>7</div>
        <div>8</div>
        <div>9</div>
        <div>10</div>
      </section>
    ''')
    html, = page1.children
    body, = html.children
    p, = body.children
    assert len(p.children) == 4
    html, = page2.children
    body, = html.children
    section, = body.children
    assert len(section.children) == 6


@assert_no_logs
def test_grid_bottom_page():
    page1, page2 = render_pages('''
      <style>
        @page { size: 10px }
        body { font: 2px / 1 weasyprint }
        section { display: grid; grid-template-columns: 1fr 1fr }
      </style>
      <div style="height: 9px"></div>
      <section>
        <div>1</div>
        <div>2</div>
      </section>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children

    html, = page2.children
    body, = html.children
    section, = body.children


@assert_no_logs
def test_grid_in_grid():
    # Regression test for #2626.
    page1, page2, = render_pages('''
      <style>
        @page { size: 10px }
        body { font: 2px / 1 weasyprint }
        section { display: grid; grid-template-columns: 1fr 1fr }
      </style>
      <div style="height: 7px"></div>
      <section>
        <section>
          <div>1 2</div>
          <div>3 4</div>
        </section>
        <section>
          <div>5 6</div>
          <div>7 8</div>
        </section>
      </section>
    ''')
    html, = page1.children
    body, = html.children
    div, section = body.children
    subsection1, subsection2 = section.children
    div1, div2 = subsection1.children
    assert div1.children[0].children[0].text == '1'
    assert div2.children[0].children[0].text == '3'
    div3, div4 = subsection2.children
    assert div3.children[0].children[0].text == '5'
    assert div4.children[0].children[0].text == '7'

    html, = page2.children
    body, = html.children
    section, = body.children
    subsection1, subsection2 = section.children
    div1, div2 = subsection1.children
    assert div1.children[0].children[0].text == '2'
    assert div2.children[0].children[0].text == '4'
    div3, div4 = subsection2.children
    assert div3.children[0].children[0].text == '6'
    assert div4.children[0].children[0].text == '8'


@assert_no_logs
def test_grid_in_flex_after_full_height():
    # Regression test for #2629.
    page1, page2, = render_pages('''
      <style>
        @page { size: 10px }
      </style>
      <div style="height: 15px"></div>
      <div style="display: flex; flex-direction: column">
        <div style="display: grid">
          <div></div>
        </div>
      </div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    assert not div.children

    html, = page2.children
    body, = html.children
    flex, = body.children
    grid, = flex.children
    grid_item, = grid.children
    assert not grid_item.children


@assert_no_logs
def test_grid_in_columns():
    # Regression test for #2691.
    page1, page2, = render_pages('''
      <style>
        @page { size: 12cm }
        section { height: 10cm }
      </style>
      <div style="columns: 2">
        <div style="display: grid">
          <div>
            <section></section>
            <section></section>
            <section></section>
          </div>
        </div>
      </div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    column1, column2 = div.children
    grid, = column1.children
    assert len(grid.children) == 1
    grid, = column2.children
    assert len(grid.children) == 1

    html, = page2.children
    body, = html.children
    div, = body.children
    column1, column2 = div.children
    grid, = column1.children
    assert len(grid.children) == 1
    grid, = column2.children
    assert len(grid.children) == 0


@pytest.mark.xfail
@assert_no_logs
def test_grid_in_columns_with_break():
    # Regression test for #2695.
    page1, page2, = render_pages('''
      <style>
        @page { size: 12px }
        section { height: 4px }
      </style>
      <div style="columns: 1">
        <div style="display: grid; margin-top: 6px">
          <div>
            <section></section>
            <section></section>
            <section></section>
          </div>
        </div>
      </div>
    ''')
    html, = page1.children
    body, = html.children
    div, = body.children
    column1, = div.children
    grid, = column1.children
    section1, = grid.children
    assert section1.position_y == 6

    html, = page2.children
    body, = html.children
    div, = body.children
    column1, = div.children
    grid, = column1.children
    section2, section3 = grid.children
    assert section2.position_y == 0
    assert section3.position_y == 4


================================================
FILE: tests/layout/test_image.py
================================================
"""Tests for images layout."""

import pytest

from weasyprint.formatting_structure import boxes

from ..testing_utils import assert_no_logs, capture_logs, render_pages


def get_img(html):
    page, = render_pages(html)
    html, = page.children
    body, = html.children
    if body.children:
        line, = body.children
        img, = line.children
    else:
        img = None
    return body, img


@pytest.mark.parametrize('html', [
    '<img src="%s">' % url for url in (
        'pattern.png', 'pattern.gif', 'blue.jpg', 'pattern.svg',
        "data:image/svg+xml,<svg width='4' height='4'></svg>",
        "DatA:image/svg+xml,<svg width='4px' height='4px'></svg>",
    )] + [
        '<embed src=pattern.png>',
        '<embed src=pattern.svg>',
        '<embed src=really-a-png.svg type=image/png>',
        '<embed src=really-a-svg.png type=image/svg+xml>',

        '<object data=pattern.png>',
        '<object data=pattern.svg>',
        '<object data=really-a-png.svg type=image/png>',
        '<object data=really-a-svg.png type=image/svg+xml>',
    ]
)
@assert_no_logs
def test_images_1(html):
    body, img = get_img(html)
    assert img.width == 4
    assert img.height == 4


@assert_no_logs
def test_images_2():
    # With physical units
    url = "data:image/svg+xml,<svg width='2.54cm' height='0.5in'></svg>"
    body, img = get_img('<img src="%s">' % url)
    assert img.width == 96
    assert img.height == 48


@pytest.mark.parametrize('url', [
    'nonexistent.png',
    'unknownprotocol://weasyprint.org/foo.png',
    'data:image/unknowntype,Not an image',
    # Invalid protocol
    'datå:image/svg+xml,<svg width="4" height="4"></svg>',
    # zero-byte images
    'data:image/png,',
    'data:image/jpeg,',
    'data:image/svg+xml,',
    # Incorrect format
    'data:image/png,Not a PNG',
    'data:image/jpeg,Not a JPEG',
    'data:image/svg+xml,<svg>invalid xml',
])
@assert_no_logs
def test_images_3(url):
    # Invalid images
    with capture_logs() as logs:
        body, img = get_img(f"<img src='{url}' alt='invalid image'>")
    assert len(logs) == 1
    assert 'ERROR: Failed to load image' in logs[0]
    assert isinstance(img, boxes.InlineBox)  # not a replaced box
    text, = img.children
    assert text.text == 'invalid image', url


@pytest.mark.parametrize('url', [
    # GIF with JPEG mimetype
    'data:image/jpeg;base64,'
    'R0lGODlhAQABAIABAP///wAAACwAAAAAAQABAAACAkQBADs=',
    # GIF with PNG mimetype
    'data:image/png;base64,'
    'R0lGODlhAQABAIABAP///wAAACwAAAAAAQABAAACAkQBADs=',
    # PNG with JPEG mimetype
    'data:image/jpeg;base64,'
    'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC'
    '0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=',
    # SVG with PNG mimetype
    'data:image/png,<svg width="1" height="1"></svg>',
    'really-a-svg.png',
    # PNG with SVG
    'data:image/svg+xml;base64,'
    'R0lGODlhAQABAIABAP///wAAACwAAAAAAQABAAACAkQBADs=',
    'really-a-png.svg',
])
@assert_no_logs
def test_images_4(url):
    # Sniffing, no logs
    body, img = get_img("<img src='%s'>" % url)


@assert_no_logs
def test_images_5():
    with capture_logs() as logs:
        render_pages('<img src=nonexistent.png><img src=nonexistent.png>')
    # Failures are cached too: only one error
    assert len(logs) == 1
    assert 'ERROR: Failed to load image' in logs[0]


@assert_no_logs
def test_images_6():
    # Layout rules try to preserve the ratio, so the height should be 40px too:
    body, img = get_img('''<body style="font-size: 0">
        <img src="pattern.png" style="width: 40px">''')
    assert body.height == 40
    assert img.position_y == 0
    assert img.width == 40
    assert img.height == 40


@assert_no_logs
def test_images_7():
    body, img = get_img('''<body style="font-size: 0">
        <img src="pattern.png" style="height: 40px">''')
    assert body.height == 40
    assert img.position_y == 0
    assert img.width == 40
    assert img.height == 40


@assert_no_logs
def test_images_8():
    # Same with percentages
    body, img = get_img('''<body style="font-size: 0"><p style="width: 200px">
        <img src="pattern.png" style="width: 20%">''')
    assert body.height == 40
    assert img.position_y == 0
    assert img.width == 40
    assert img.height == 40


@assert_no_logs
def test_images_9():
    body, img = get_img('''<body style="font-size: 0">
        <img src="pattern.png" style="min-width: 40px">''')
    assert body.height == 40
    assert img.position_y == 0
    assert img.width == 40
    assert img.height == 40


@assert_no_logs
def test_images_10():
    body, img = get_img('<img src="pattern.png" style="max-width: 2px">')
    assert img.width == 2
    assert img.height == 2


@assert_no_logs
def test_images_11():
    # display: table-cell is ignored. XXX Should it?
    page, = render_pages('''<body style="font-size: 0">
        <img src="pattern.png" style="width: 40px">
        <img src="pattern.png" style="width: 60px; display: table-cell">
    ''')
    html, = page.children
    body, = html.children
    line, = body.children
    img_1, img_2 = line.children
    assert body.height == 60
    assert img_1.width == 40
    assert img_1.height == 40
    assert img_2.width == 60
    assert img_2.height == 60
    assert img_1.position_y == 20
    assert img_2.position_y == 0


@assert_no_logs
def test_images_12():
    # Block-level image:
    page, = render_pages('''
        <style>
            @page { size: 100px }
            img { width: 40px; margin: 10px auto; display: block }
        </style>
        <body>
            <img src="pattern.png">
    ''')
    html, = page.children
    body, = html.children
    img, = body.children
    assert img.element_tag == 'img'
    assert img.position_x == 0
    assert img.position_y == 0
    assert img.width == 40
    assert img.height == 40
    assert img.content_box_x() == 30  # (100 - 40) / 2 == 30px for margin-left
    assert img.content_box_y() == 10


@assert_no_logs
def test_images_13():
    page, = render_pages('''
        <style>
            @page { size: 100px }
            img { min-width: 40%; margin: 10px auto; display: block }
        </style>
        <body>
            <img src="pattern.png">
    ''')
    html, = page.children
    body, = html.children
    img, = body.children
    assert img.element_tag == 'img'
    assert img.position_x == 0
    assert img.position_y == 0
    assert img.width == 40
    assert img.height == 40
    assert img.content_box_x() == 30  # (100 - 40) / 2 == 30px for margin-left
    assert img.content_box_y() == 10


@assert_no_logs
def test_images_14():
    page, = render_pages('''
        <style>
            @page { size: 100px }
            img { min-width: 40px; margin: 10px auto; display: block }
        </style>
        <body>
            <img src="pattern.png">
    ''')
    html, = page.children
    body, = html.children
    img, = body.children
    assert img.element_tag == 'img'
    assert img.position_x == 0
    assert img.position_y == 0
    assert img.width == 40
    assert img.height == 40
    assert img.content_box_x() == 30  # (100 - 40) / 2 == 30px for margin-left
    assert img.content_box_y() == 10


@assert_no_logs
def test_images_15():
    page, = render_pages('''
        <style>
            @page { size: 100px }
            img { min-height: 30px; max-width: 2px;
                  margin: 10px auto; display: block }
        </style>
        <body>
            <img src="pattern.png">
    ''')
    html, = page.children
    body, = html.children
    img, = body.children
    assert img.element_tag == 'img'
    assert img.position_x == 0
    assert img.position_y == 0
    assert img.width == 2
    assert img.height == 30
    assert img.content_box_x() == 49  # (100 - 2) / 2 == 49px for margin-left
    assert img.content_box_y() == 10


@assert_no_logs
def test_images_16():
    page, = render_pages('''
        <body style="float: left">
        <img style="height: 200px; margin: 10px; display: block" src="
            data:image/svg+xml,
            <svg width='150' height='100'></svg>
        ">
    ''')
    html, = page.children
    body, = html.children
    img, = body.children
    assert body.width == 320
    assert body.height == 220
    assert img.element_tag == 'img'
    assert img.width == 300
    assert img.height == 200


@assert_no_logs
def test_images_17():
    page, = render_pages('''
        <div style="width: 300px; height: 300px">
        <img src="
            data:image/svg+xml,
            <svg viewBox='0 0 20 10'></svg>
        ">''')
    html, = page.children
    body, = html.children
    div, = body.children
    line, = div.children
    img, = line.children
    assert div.width == 300
    assert div.height == 300
    assert img.element_tag == 'img'
    assert img.width == 300
    assert img.height == 150


@assert_no_logs
def test_images_18():
    # Regression test for #1050.
    page, = render_pages('''
        <img style="position: absolute" src="
            data:image/svg+xml,
            <svg viewBox='0 0 20 10'></svg>
        ">''')


@pytest.mark.parametrize(('html', 'children'), [
    ('<embed>', []),
    ('<embed src="unknown">', []),
    ('<object></object>', []),
    ('<object data="unknown"></object>', []),
    ('<object>abc</object>', ['TextBox']),
    ('<object data="unknown">abc</object>', ['TextBox']),
])
def test_images_19(html, children):
    body, img = get_img(html)
    img_children = [
        type(child).__name__ for child in getattr(img, 'children', [])]
    assert img_children == children


@assert_no_logs
def test_linear_gradient():
    red = (1, 0, 0, 1)
    lime = (0, 1, 0, 1)
    blue = (0, 0, 1, 1)

    def layout(gradient_css, type_='linear', init=(),
               positions=[0, 1], colors=[blue, lime]):
        page, = render_pages('<style>@page { background: ' + gradient_css)
        layer, = page.background.layers
        result = layer.image.layout(400, 300, {})
        assert result[0] == 1
        assert result[1] == type_
        assert result[2] == (None if init is None else pytest.approx(init))
        assert result[3] == pytest.approx(positions)
        for color1, color2 in zip(result[4], colors):
            assert tuple(color1) == pytest.approx(color2)

    layout('linear-gradient(blue)', 'solid', None, [], [blue])
    layout('repeating-linear-gradient(blue)', 'solid', None, [], [blue])
    layout('linear-gradient(blue, lime)', init=(200, 0, 200, 300))
    layout('repeating-linear-gradient(blue, lime)', init=(200, 0, 200, 300))
    layout('repeating-linear-gradient(blue, lime 100px)',
           positions=[0, 1, 1, 2, 2, 3], init=(200, 0, 200, 300))

    layout('linear-gradient(to bottom, blue, lime)', init=(200, 0, 200, 300))
    layout('linear-gradient(to top, blue, lime)', init=(200, 300, 200, 0))
    layout('linear-gradient(to right, blue, lime)', init=(0, 150, 400, 150))
    layout('linear-gradient(to left, blue, lime)', init=(400, 150, 0, 150))

    layout('linear-gradient(to top left, blue, lime)',
           init=(344, 342, 56, -42))
    layout('linear-gradient(to top right, blue, lime)',
           init=(56, 342, 344, -42))
    layout('linear-gradient(to bottom left, blue, lime)',
           init=(344, -42, 56, 342))
    layout('linear-gradient(to bottom right, blue, lime)',
           init=(56, -42, 344, 342))

    layout('linear-gradient(270deg, blue, lime)', init=(400, 150, 0, 150))
    layout('linear-gradient(.75turn, blue, lime)', init=(400, 150, 0, 150))
    layout('linear-gradient(45deg, blue, lime)', init=(25, 325, 375, -25))
    layout('linear-gradient(.125turn, blue, lime)', init=(25, 325, 375, -25))
    layout('linear-gradient(.375turn, blue, lime)', init=(25, -25, 375, 325))
    layout('linear-gradient(.625turn, blue, lime)', init=(375, -25, 25, 325))
    layout('linear-gradient(.875turn, blue, lime)', init=(375, 325, 25, -25))

    layout('linear-gradient(blue 2em, lime 20%)', init=(200, 32, 200, 60))
    layout('linear-gradient(blue 100px, red, blue, red 160px, lime)',
           init=(200, 100, 200, 300), colors=[blue, red, blue, red, lime],
           positions=[0, .1, .2, .3, 1])
    layout('linear-gradient(blue -100px, blue 0, red -12px, lime 50%)',
           init=(200, -100, 200, 150), colors=[blue, blue, red, lime],
           positions=[0, .4, .4, 1])
    layout('linear-gradient(blue, blue, red, lime -7px)',
           init=(200, -1, 200, 1), colors=[blue, blue, blue, red, lime, lime],
           positions=[0, 0.5, 0.5, 0.5, 0.5, 1])
    layout('repeating-linear-gradient(blue, blue, lime, lime -7px)',
           'solid', None, [], [(0, .5, .5, 1)])


@assert_no_logs
def test_radial_gradient():
    red = (1, 0, 0, 1)
    lime = (0, 1, 0, 1)
    blue = (0, 0, 1, 1)

    def layout(gradient_css, type_='radial', init=(),
               positions=[0, 1], colors=[blue, lime], scale_y=1):
        if type_ == 'radial':
            center_x, center_y, radius0, radius1 = init
            init = (center_x, center_y / scale_y, radius0,
                    center_x, center_y / scale_y, radius1)
        page, = render_pages('<style>@page { background: ' + gradient_css)
        layer, = page.background.layers
        result = layer.image.layout(400, 300, {})
        assert result[0] == scale_y
        assert result[1] == type_
        assert result[2] == (None if init is None else pytest.approx(init))
        assert result[3] == pytest.approx(positions)
        for color1, color2 in zip(result[4], colors):
            assert tuple(color1) == pytest.approx(color2)

    layout('radial-gradient(blue)', 'solid', None, [], [blue])
    layout('repeating-radial-gradient(blue)', 'solid', None, [], [blue])
    layout('radial-gradient(100px, blue, lime)',
           init=(200, 150, 0, 100))

    layout('radial-gradient(100px at right 20px bottom 30px, lime, red)',
           init=(380, 270, 0, 100), colors=[lime, red])
    layout('radial-gradient(0 0, blue, lime)',
           init=(200, 150, 0, 1e-7))
    layout('radial-gradient(1px 0, blue, lime)',
           init=(200, 150, 0, 1e7), scale_y=1e-14)
    layout('radial-gradient(0 1px, blue, lime)',
           init=(200, 150, 0, 1e-7), scale_y=1e14)
    layout('repeating-radial-gradient(100px 200px, blue, lime)',
           positions=[0, 1, 1, 2, 2, 3], init=(200, 150, 0, 300),
           scale_y=(200 / 100))
    layout('repeating-radial-gradient(42px, blue -100px, lime 100px)',
           positions=[-0.5, 0, 0, 1], init=(200, 150, 0, 300),
           colors=[(0, 0.5, 0.5, 1), lime, blue, lime])
    layout('radial-gradient(42px, blue -20px, lime -1px)',
           'solid', None, [], [lime])
    layout('radial-gradient(42px, blue -20px, lime 0)',
           'solid', None, [], [lime])
    layout('radial-gradient(42px, blue -20px, lime 20px)',
           init=(200, 150, 0, 20), colors=[(0, .5, .5, 1), lime])

    layout('radial-gradient(100px 120px, blue, lime)',
           init=(200, 150, 0, 100), scale_y=(120 / 100))
    layout('radial-gradient(25% 40%, blue, lime)',
           init=(200, 150, 0, 100), scale_y=(120 / 100))

    layout('radial-gradient(circle closest-side, blue, lime)',
           init=(200, 150, 0, 150))
    layout('radial-gradient(circle closest-side at 150px 50px, blue, lime)',
           init=(150, 50, 0, 50))
    layout('radial-gradient(circle closest-side at 45px 50px, blue, lime)',
           init=(45, 50, 0, 45))
    layout('radial-gradient(circle closest-side at 420px 50px, blue, lime)',
           init=(420, 50, 0, 20))
    layout('radial-gradient(circle closest-side at 420px 281px, blue, lime)',
           init=(420, 281, 0, 19))

    layout('radial-gradient(closest-side, blue 20%, lime)',
           init=(200, 150, 40, 200), scale_y=(150 / 200))
    layout('radial-gradient(closest-side at 300px 20%, blue, lime)',
           init=(300, 60, 0, 100), scale_y=(60 / 100))
    layout('radial-gradient(closest-side at 10% 230px, blue, lime)',
           init=(40, 230, 0, 40), scale_y=(70 / 40))

    layout('radial-gradient(circle farthest-side, blue, lime)',
           init=(200, 150, 0, 200))
    layout('radial-gradient(circle farthest-side at 150px 50px, blue, lime)',
           init=(150, 50, 0, 250))
    layout('radial-gradient(circle farthest-side at 45px 50px, blue, lime)',
           init=(45, 50, 0, 355))
    layout('radial-gradient(circle farthest-side at 420px 50px, blue, lime)',
           init=(420, 50, 0, 420))
    layout('radial-gradient(circle farthest-side at 220px 310px, blue, lime)',
           init=(220, 310, 0, 310))

    layout('radial-gradient(farthest-side, blue, lime)',
           init=(200, 150, 0, 200), scale_y=(150 / 200))
    layout('radial-gradient(farthest-side at 300px 20%, blue, lime)',
           init=(300, 60, 0, 300), scale_y=(240 / 300))
    layout('radial-gradient(farthest-side at 10% 230px, blue, lime)',
           init=(40, 230, 0, 360), scale_y=(230 / 360))

    layout('radial-gradient(circle closest-corner, blue, lime)',
           init=(200, 150, 0, 250))
    layout('radial-gradient(circle closest-corner at 340px 80px, blue, lime)',
           init=(340, 80, 0, 100))
    layout('radial-gradient(circle closest-corner at 0 342px, blue, lime)',
           init=(0, 342, 0, 42))

    layout('radial-gradient(closest-corner, blue, lime)',
           init=(200, 150, 0, 200 * 2 ** 0.5), scale_y=(150 / 200))
    layout('radial-gradient(closest-corner at 450px 100px, blue, lime)',
           init=(450, 100, 0, 50 * 2 ** 0.5), scale_y=(100 / 50))
    layout('radial-gradient(closest-corner at 40px 210px, blue, lime)',
           init=(40, 210, 0, 40 * 2 ** 0.5), scale_y=(90 / 40))

    layout('radial-gradient(circle farthest-corner, blue, lime)',
           init=(200, 150, 0, 250))
    layout('radial-gradient(circle farthest-corner'
           ' at 300px -100px, blue, lime)',
           init=(300, -100, 0, 500))
    layout('radial-gradient(circle farthest-corner at 400px 0, blue, lime)',
           init=(400, 0, 0, 500))

    layout('radial-gradient(farthest-corner, blue, lime)',
           init=(200, 150, 0, 200 * 2 ** 0.5), scale_y=(150 / 200))
    layout('radial-gradient(farthest-corner at 450px 100px, blue, lime)',
           init=(450, 100, 0, 450 * 2 ** 0.5), scale_y=(200 / 450))
    layout('radial-gradient(farthest-corner at 40px 210px, blue, lime)',
           init=(40, 210, 0, 360 * 2 ** 0.5), scale_y=(210 / 360))


@pytest.mark.parametrize(('props', 'div_width'), [
    ({}, 4),
    ({'min-width': '10px'}, 10),
    ({'max-width': '1px'}, 1),
    ({'width': '10px'}, 10),
    ({'width': '1px'}, 1),
    ({'min-height': '10px'}, 10),
    ({'max-height': '1px'}, 1),
    ({'height': '10px'}, 10),
    ({'height': '1px'}, 1),
    ({'min-width': '10px', 'min-height': '1px'}, 10),
    ({'min-width': '1px', 'min-height': '10px'}, 10),
    ({'max-width': '10px', 'max-height': '1px'}, 1),
    ({'max-width': '1px', 'max-height': '10px'}, 1),
])
def test_image_min_max_width(props, div_width):
    default = {
        'min-width': 'auto', 'max-width': 'none', 'width': 'auto',
        'min-height': 'auto', 'max-height': 'none', 'height': 'auto'}
    page, = render_pages('''
      <style> img { display: block; %s } </style>
      <div style="display: inline-block">
        <img src="pattern.png"><img src="pattern.svg">
      </div>''' % ';'.join(
          f'{key}: {props.get(key, value)}' for key, value in default.items()))
    html, = page.children
    body, = html.children
    line, = body.children
    div, = line.children
    assert div.width == div_width


@pytest.mark.parametrize(('css', 'width'), [
    ('width: 10px', 10),
    ('width: 1px', 1),
    ('height: 10px', 20),
    ('height: 1px', 2),
])
def test_svg_no_size_width(css, width):
    # Size is undefined when both width and heigh are not set.
    # https://drafts.csswg.org/css2/#inline-replaced-width
    page, = render_pages('''
      <style> svg { %s } </style>
      <div style="display: inline-block">
        <svg viewBox="0 0 8 4"></svg>
      </div>''' % css)
    html, = page.children
    body, = html.children
    line, = body.children
    div, = line.children
    assert div.width == width


@pytest.mark.parametrize(('css', 'width'), [
    ('width: 10px', 10),
    ('width: 1px', 1),
    ('height: 10px', 20),
    ('height: 1px', 2),
])
def test_svg_no_size_min_width(css, width):
    # Size is undefined when both width and heigh are not set.
    # https://drafts.csswg.org/css2/#inline-replaced-width
    page, = render_pages('''
      <style> svg { %s } </style>
      <table>
        <tr>
          <td><svg viewBox="0 0 8 4"></svg></td>
          <td style="width: 1000mm"></td>
        </tr>
      </table>''' % css)
    html, = page.children
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    row_group, = table.children
    row, = row_group.children
    td1, td2 = row.children
    assert td1.width == width


================================================
FILE: tests/layout/test_inline.py
================================================
"""Tests for inlines layout."""

import pytest

from weasyprint.formatting_structure import boxes

from ..testing_utils import SANS_FONTS, assert_no_logs, render_pages


@assert_no_logs
def test_empty_linebox():
    page, = render_pages('<p> </p>')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert len(paragraph.children) == 0
    assert paragraph.height == 0


@pytest.mark.xfail
@assert_no_logs
def test_empty_linebox_removed_space():
    # Whitespace removed at the beginning of the line => empty line => no line
    page, = render_pages('''
      <style>
        p { width: 1px }
      </style>
      <p><br>  </p>
    ''')
    page, = render_pages('<p> </p>')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    # TODO: The second line should be removed
    assert len(paragraph.children) == 1


@assert_no_logs
def test_breaking_linebox():
    page, = render_pages('''
      <style>
      p { font-size: 13px;
          width: 300px;
          font-family: %(fonts)s;
          background-color: #393939;
          color: #FFFFFF;
          line-height: 1;
          text-decoration: underline overline line-through;}
      </style>
      <p><em>Lorem<strong> Ipsum <span>is very</span>simply</strong><em>
      dummy</em>text of the printing and. naaaa </em> naaaa naaaa naaaa
      naaaa naaaa naaaa naaaa naaaa</p>
    ''' % {'fonts': SANS_FONTS})
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert len(list(paragraph.children)) == 3

    lines = paragraph.children
    for line in lines:
        assert line.style['font_size'] == 13
        assert line.element_tag == 'p'
        for child in line.children:
            assert child.element_tag in ('em', 'p')
            assert child.style['font_size'] == 13
            for child_child in child.children:
                assert child.element_tag in ('em', 'strong', 'span')
                assert child.style['font_size'] == 13


@assert_no_logs
def test_position_x_ltr():
    page, = render_pages('''
      <style>
        span {
          padding: 0 10px 0 15px;
          margin: 0 2px 0 3px;
          border: 1px solid;
         }
      </style>
      <body><span>a<br>b<br>c</span>''')
    html, = page.children
    body, = html.children
    line1, line2, line3 = body.children
    span1, = line1.children
    assert span1.position_x == 0
    text1, br1 = span1.children
    assert text1.position_x == 15 + 3 + 1
    span2, = line2.children
    assert span2.position_x == 0
    text2, br2 = span2.children
    assert text2.position_x == 0
    span3, = line3.children
    assert span3.position_x == 0
    text3, = span3.children
    assert text3.position_x == 0


@assert_no_logs
def test_position_x_rtl():
    page, = render_pages('''
      <style>
        body {
          direction: rtl;
          width: 100px;
        }
        span {
          padding: 0 10px 0 15px;
          margin: 0 2px 0 3px;
          border: 1px solid;
         }
      </style>
      <body><span>a<br>b<br>c</span>''')
    html, = page.children
    body, = html.children
    line1, line2, line3 = body.children
    span1, = line1.children
    text1, br1 = span1.children
    assert span1.position_x == 100 - text1.width - (10 + 2 + 1)
    assert text1.position_x == 100 - text1.width - (10 + 2 + 1)
    span2, = line2.children
    text2, br2 = span2.children
    assert span2.position_x == 100 - text2.width
    assert text2.position_x == 100 - text2.width
    span3, = line3.children
    text3, = span3.children
    assert span3.position_x == 100 - text3.width - (15 + 3 + 1)
    assert text3.position_x == 100 - text3.width


@assert_no_logs
def test_breaking_linebox_regression_1():
    # See https://unicode.org/reports/tr14/
    page, = render_pages('<pre>a\nb\rc\r\nd\u2029e</pre>')
    html, = page.children
    body, = html.children
    pre, = body.children
    lines = pre.children
    texts = []
    for line in lines:
        text_box, = line.children
        texts.append(text_box.text)
    assert texts == ['a', 'b', 'c', 'd', 'e']


@assert_no_logs
def test_breaking_linebox_regression_2():
    html_sample = '''
      <p style="width: %d.5em; font-family: weasyprint">ab
      <span style="padding-right: 1em; margin-right: 1em">c def</span>g
      hi</p>'''
    for i in range(16):
        page, = render_pages(html_sample % i)
        html, = page.children
        body, = html.children
        p, = body.children
        lines = p.children

        if i in (0, 1, 2, 3):
            line_1, line_2, line_3, line_4 = lines

            textbox_1, = line_1.children
            assert textbox_1.text == 'ab'

            span_1, = line_2.children
            textbox_1, = span_1.children
            assert textbox_1.text == 'c'

            span_1, textbox_2 = line_3.children
            textbox_1, = span_1.children
            assert textbox_1.text == 'def'
            assert textbox_2.text == 'g'

            textbox_1, = line_4.children
            assert textbox_1.text == 'hi'
        elif i in (4, 5, 6, 7, 8):
            line_1, line_2, line_3 = lines

            textbox_1, span_1 = line_1.children
            assert textbox_1.text == 'ab '
            textbox_2, = span_1.children
            assert textbox_2.text == 'c'

            span_1, textbox_2 = line_2.children
            textbox_1, = span_1.children
            assert textbox_1.text == 'def'
            assert textbox_2.text == 'g'

            textbox_1, = line_3.children
            assert textbox_1.text == 'hi'
        elif i in (9, 10):
            line_1, line_2 = lines

            textbox_1, span_1 = line_1.children
            assert textbox_1.text == 'ab '
            textbox_2, = span_1.children
            assert textbox_2.text == 'c'

            span_1, textbox_2 = line_2.children
            textbox_1, = span_1.children
            assert textbox_1.text == 'def'
            assert textbox_2.text == 'g hi'
        elif i in (11, 12, 13):
            line_1, line_2 = lines

            textbox_1, span_1, textbox_3 = line_1.children
            assert textbox_1.text == 'ab '
            textbox_2, = span_1.children
            assert textbox_2.text == 'c def'
            assert textbox_3.text == 'g'

            textbox_1, = line_2.children
            assert textbox_1.text == 'hi'
        else:
            line_1, = lines

            textbox_1, span_1, textbox_3 = line_1.children
            assert textbox_1.text == 'ab '
            textbox_2, = span_1.children
            assert textbox_2.text == 'c def'
            assert textbox_3.text == 'g hi'


@assert_no_logs
def test_breaking_linebox_regression_3():
    # Regression test for #560.
    page, = render_pages(
        '<div style="width: 5.5em; font-family: weasyprint">'
        'aaaa aaaa a [<span>aaa</span>]')
    html, = page.children
    body, = html.children
    div, = body.children
    line1, line2, line3, line4 = div.children
    assert line1.children[0].text == line2.children[0].text == 'aaaa'
    assert line3.children[0].text == 'a'
    text1, span, text2 = line4.children
    assert text1.text == '['
    assert text2.text == ']'
    assert span.children[0].text == 'aaa'


@assert_no_logs
def test_breaking_linebox_regression_4():
    # Regression test for #560.
    page, = render_pages(
        '<div style="width: 5.5em; font-family: weasyprint">'
        'aaaa a <span>b c</span>d')
    html, = page.children
    body, = html.children
    div, = body.children
    line1, line2, line3 = div.children
    assert line1.children[0].text == 'aaaa'
    assert line2.children[0].text == 'a '
    assert line2.children[1].children[0].text == 'b'
    assert line3.children[0].children[0].text == 'c'
    assert line3.children[1].text == 'd'


@assert_no_logs
def test_breaking_linebox_regression_5():
    # Regression test for #580.
    page, = render_pages(
        '<div style="width: 5.5em; font-family: weasyprint">'
        '<span>aaaa aaaa a a a</span><span>bc</span>')
    html, = page.children
    body, = html.children
    div, = body.children
    line1, line2, line3, line4 = div.children
    assert line1.children[0].children[0].text == 'aaaa'
    assert line2.children[0].children[0].text == 'aaaa'
    assert line3.children[0].children[0].text == 'a a'
    assert line4.children[0].children[0].text == 'a'
    assert line4.children[1].children[0].text == 'bc'


@assert_no_logs
def test_breaking_linebox_regression_6():
    # Regression test for #586.
    page, = render_pages(
        '<div style="width: 5.5em; font-family: weasyprint">'
        'a a <span style="white-space: nowrap">/ccc</span>')
    html, = page.children
    body, = html.children
    div, = body.children
    line1, line2 = div.children
    assert line1.children[0].text == 'a a'
    assert line2.children[0].children[0].text == '/ccc'


@assert_no_logs
def test_breaking_linebox_regression_7():
    # Regression test for #660.
    page, = render_pages(
        '<div style="width: 3.5em; font-family: weasyprint">'
        '<span><span>abc d e</span></span><span>f')
    html, = page.children
    body, = html.children
    div, = body.children
    line1, line2, line3 = div.children
    assert line1.children[0].children[0].children[0].text == 'abc'
    assert line2.children[0].children[0].children[0].text == 'd'
    assert line3.children[0].children[0].children[0].text == 'e'
    assert line3.children[1].children[0].text == 'f'


@assert_no_logs
def test_breaking_linebox_regression_8():
    # Regression test for #783.
    page, = render_pages(
        '<p style="font-family: weasyprint"><span>\n'
        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n'
        'bbbbbbbbbbb\n'
        '<b>cccc</b></span>ddd</p>')
    html, = page.children
    body, = html.children
    p, = body.children
    line1, line2 = p.children
    assert line1.children[0].children[0].text == (
        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbb')
    assert line2.children[0].children[0].children[0].text == 'cccc'
    assert line2.children[1].text == 'ddd'


@pytest.mark.xfail
@assert_no_logs
def test_breaking_linebox_regression_9():
    # Regression test for #783.
    # TODO: inlines.can_break_inside return False for span but we can break
    # before the <b> tag. can_break_inside should be fixed.
    page, = render_pages(
        '<p style="font-family: weasyprint"><span>\n'
        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbb\n'
        '<b>cccc</b></span>ddd</p>')
    html, = page.children
    body, = html.children
    p, = body.children
    line1, line2 = p.children
    assert line1.children[0].children[0].text == (
        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbb')
    assert line2.children[0].children[0].children[0].text == 'cccc'
    assert line2.children[1].text == 'ddd'


@assert_no_logs
def test_breaking_linebox_regression_10():
    # Regression test for #923.
    page, = render_pages(
        '<p style="width:195px; font-family: weasyprint">'
        '  <span>'
        '    <span>xxxxxx YYY yyyyyy yyy</span>'
        '    ZZZZZZ zzzzz'
        '  </span> )x '
        '</p>')
    html, = page.children
    body, = html.children
    p, = body.children
    line1, line2, line3, line4 = p.children
    assert line1.children[0].children[0].children[0].text == 'xxxxxx YYY'
    assert line2.children[0].children[0].children[0].text == 'yyyyyy yyy'
    assert line3.children[0].children[0].text == 'ZZZZZZ zzzzz'
    assert line4.children[0].text == ')x'


@assert_no_logs
def test_breaking_linebox_regression_11():
    # Regression test for #953.
    page, = render_pages(
        '<p style="width:10em; font-family: weasyprint">'
        '  line 1<br><span>123 567 90</span>x'
        '</p>')
    html, = page.children
    body, = html.children
    p, = body.children
    line1, line2, line3 = p.children
    assert line1.children[0].text == 'line 1'
    assert line2.children[0].children[0].text == '123 567'
    assert line3.children[0].children[0].text == '90'
    assert line3.children[1].text == 'x'


@assert_no_logs
def test_breaking_linebox_regression_12():
    # Regression test for #953.
    page, = render_pages(
        '<p style="width:10em; font-family: weasyprint">'
        '  <br><span>123 567 90</span>x'
        '</p>')
    html, = page.children
    body, = html.children
    p, = body.children
    line1, line2, line3 = p.children
    assert line2.children[0].children[0].text == '123 567'
    assert line3.children[0].children[0].text == '90'
    assert line3.children[1].text == 'x'


@assert_no_logs
def test_breaking_linebox_regression_13():
    # Regression test for #953.
    page, = render_pages(
        '<p style="width:10em; font-family: weasyprint">'
        '  123 567 90 <span>123 567 90</span>x'
        '</p>')
    html, = page.children
    body, = html.children
    p, = body.children
    line1, line2, line3 = p.children
    assert line1.children[0].text == '123 567 90'
    assert line2.children[0].children[0].text == '123 567'
    assert line3.children[0].children[0].text == '90'
    assert line3.children[1].text == 'x'


@assert_no_logs
def test_breaking_linebox_regression_14():
    # Regression test for #1638.
    page, = render_pages(
        '<style>'
        '  body {font-family: weasyprint; width: 3em}'
        '</style>'
        '<span> <span>a</span> b</span><span>c</span>')
    html, = page.children
    body, = html.children
    line1, line2 = body.children
    assert line1.children[0].children[0].children[0].text == 'a'
    assert line2.children[0].children[0].text == 'b'
    assert line2.children[1].children[0].text == 'c'


@assert_no_logs
def test_breaking_linebox_regression_15():
    # Regression test for #5507.
    page, = render_pages(
        '<style>'
        '  body {font-family: weasyprint; font-size: 4px}'
        '  pre {float: left}'
        '</style>'
        '<pre>ab©\n'
        'déf\n'
        'ghïj\n'
        'klm</pre>')
    html, = page.children
    body, = html.children
    pre, = body.children
    line1, line2, line3, line4 = pre.children
    assert line1.children[0].text == 'ab©'
    assert line2.children[0].text == 'déf'
    assert line3.children[0].text == 'ghïj'
    assert line4.children[0].text == 'klm'
    assert line1.children[0].width == 4 * 3
    assert line2.children[0].width == 4 * 3
    assert line3.children[0].width == 4 * 4
    assert line4.children[0].width == 4 * 3
    assert pre.width == 4 * 4


@assert_no_logs
def test_breaking_linebox_regression_16():
    # Regression test for #1973.
    page, = render_pages(
        '<style>'
        '  body {font-family: weasyprint; font-size: 4px}'
        '  p {float: left}'
        '</style>'
        '<p>tést</p>'
        '<pre>ab©\n'
        'déf\n'
        'ghïj\n'
        'klm</pre>')
    html, = page.children
    body, = html.children
    p, pre = body.children
    line1, = p.children
    assert line1.children[0].text == 'tést'
    assert p.width == 4 * 4
    line1, line2, line3, line4 = pre.children
    assert line1.children[0].text == 'ab©'
    assert line2.children[0].text == 'déf'
    assert line3.children[0].text == 'ghïj'
    assert line4.children[0].text == 'klm'
    assert line1.children[0].width == 4 * 3
    assert line2.children[0].width == 4 * 3
    assert line3.children[0].width == 4 * 4
    assert line4.children[0].width == 4 * 3


@assert_no_logs
def test_linebox_text():
    page, = render_pages('''
      <style>
        p { width: 165px; font-family:%(fonts)s;}
      </style>
      <p><em>Lorem Ipsum</em>is very <strong>coool</strong></p>
    ''' % {'fonts': SANS_FONTS})
    html, = page.children
    body, = html.children
    paragraph, = body.children
    lines = list(paragraph.children)
    assert len(lines) == 2

    text = ' '.join(
        (''.join(box.text for box in line.descendants()
                 if isinstance(box, boxes.TextBox)))
        for line in lines)
    assert text == 'Lorem Ipsumis very coool'


@assert_no_logs
def test_linebox_positions():
    for width, expected_lines in [(165, 2), (1, 5), (0, 5)]:
        page = '''
          <style>
            p { width:%(width)spx; font-family:%(fonts)s;
                line-height: 20px }
          </style>
          <p>this is test for <strong>Weasyprint</strong></p>'''
        page, = render_pages(page % {'fonts': SANS_FONTS, 'width': width})
        html, = page.children
        body, = html.children
        paragraph, = body.children
        lines = list(paragraph.children)
        assert len(lines) == expected_lines

        ref_position_y = lines[0].position_y
        ref_position_x = lines[0].position_x
        for line in lines:
            assert ref_position_y == line.position_y
            assert ref_position_x == line.position_x
            for box in line.children:
                assert ref_position_x == box.position_x
                ref_position_x += box.width
                assert ref_position_y == box.position_y
            assert ref_position_x - line.position_x <= line.width
            ref_position_x = line.position_x
            ref_position_y += line.height


@assert_no_logs
def test_forced_line_breaks_pre():
    # These lines should be small enough to fit on the default A4 page
    # with the default 12pt font-size.
    page, = render_pages('''
      <style> pre { line-height: 42px }</style>
      <pre>Lorem ipsum dolor sit amet,
          consectetur adipiscing elit.


          Sed sollicitudin nibh

          et turpis molestie tristique.</pre>
    ''')
    html, = page.children
    body, = html.children
    pre, = body.children
    assert pre.element_tag == 'pre'
    lines = pre.children
    assert all(isinstance(line, boxes.LineBox) for line in lines)
    assert len(lines) == 7
    assert [line.height for line in lines] == [42] * 7


@assert_no_logs
def test_forced_line_breaks_paragraph():
    page, = render_pages('''
      <style> p { line-height: 42px }</style>
      <p>Lorem ipsum dolor sit amet,<br>
        consectetur adipiscing elit.<br><br><br>
        Sed sollicitudin nibh<br>
        <br>

        et turpis molestie tristique.</p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    assert paragraph.element_tag == 'p'
    lines = paragraph.children
    assert all(isinstance(line, boxes.LineBox) for line in lines)
    assert len(lines) == 7
    assert [line.height for line in lines] == [42] * 7


@assert_no_logs
def test_inlinebox_splitting():
    # Regression test for #389.
    # The text is strange to test some corner cases.
    for width in [10000, 100, 10, 0]:
        page, = render_pages('''
          <style>p { font-family:%(fonts)s; width: %(width)spx; }</style>
          <p><strong>WeasyPrint is a frée softwäre ./ visual rendèring enginè
                     for HTML !!! and CSS.</strong></p>
        ''' % {'fonts': SANS_FONTS, 'width': width})
        html, = page.children
        body, = html.children
        paragraph, = body.children
        lines = paragraph.children
        if width == 10000:
            assert len(lines) == 1
        else:
            assert len(lines) > 1
        text_parts = []
        for line in lines:
            strong, = line.children
            text, = strong.children
            text_parts.append(text.text)
        assert ' '.join(text_parts) == (
            'WeasyPrint is a frée softwäre ./ visual '
            'rendèring enginè for HTML !!! and CSS.')


@assert_no_logs
def test_whitespace_processing():
    for source in ['a', '  a  ', ' \n  \ta', ' a\t ']:
        page, = render_pages('<p><em>%s</em></p>' % source)
        html, = page.children
        body, = html.children
        p, = body.children
        line, = p.children
        em, = line.children
        text, = em.children
        assert text.text == 'a', 'source was %r' % (source,)

        page, = render_pages(
            '<p style="white-space: pre-line">\n\n<em>%s</em></pre>' %
            source.replace('\n', ' '))
        html, = page.children
        body, = html.children
        p, = body.children
        _line1, _line2, line3 = p.children
        em, = line3.children
        text, = em.children
        assert text.text == 'a', 'source was %r' % (source,)


@assert_no_logs
def test_inline_replaced_auto_margins():
    page, = render_pages('''
      <style>
        @page { size: 200px }
        img { display: inline; margin: auto; width: 50px }
      </style>
      <body><img src="pattern.png" />''')
    html, = page.children
    body, = html.children
    line, = body.children
    img, = line.children
    assert img.margin_top == 0
    assert img.margin_right == 0
    assert img.margin_bottom == 0
    assert img.margin_left == 0


@assert_no_logs
def test_empty_inline_auto_margins():
    page, = render_pages('''
      <style>
        @page { size: 200px }
        span { margin: auto }
      </style>
      <body><span></span>''')
    html, = page.children
    body, = html.children
    block, = body.children
    span, = block.children
    assert span.margin_top != 0
    assert span.margin_right == 0
    assert span.margin_bottom != 0
    assert span.margin_left == 0


@assert_no_logs
def test_font_stretch():
    page, = render_pages('''
      <style>
        p { float: left; font-family: %s }
      </style>
      <p>Hello, world!</p>
      <p style="font-stretch: condensed">Hello, world!</p>
    ''' % SANS_FONTS)
    html, = page.children
    body, = html.children
    p_1, p_2 = body.children
    normal = p_1.width
    condensed = p_2.width
    assert condensed < normal


@assert_no_logs
@pytest.mark.parametrize(('source', 'lines_count'), [
    ('<body>hyphénation', 1),  # Default: no hyphenation
    ('<body lang=fr>hyphénation', 1),  # lang only: no hyphenation
    ('<body style="hyphens: auto">hyphénation', 1),  # hyphens only: no hyph.
    ('<body style="hyphens: auto" lang=fr>hyphénation', 4),  # both: hyph.
    ('<body>hyp&shy;hénation', 2),  # Hyphenation with soft hyphens
    ('<body style="hyphens: none">hyp&shy;hénation', 1),  # … unless disabled
])
def test_line_count(source, lines_count):
    page, = render_pages('<html style="width: 5em; font-family: weasyprint">' + source)
    html, = page.children
    body, = html.children
    lines = body.children
    assert len(lines) == lines_count


@assert_no_logs
def test_vertical_align_1():
    #            +-------+      <- position_y = 0
    #      +-----+       |
    # 40px |     |       | 60px
    #      |     |       |
    #      +-----+-------+      <- baseline
    page, = render_pages('''
      <span>
        <img src="pattern.png" style="width: 40px"
        ><img src="pattern.png" style="width: 60px"
      ></span>''')
    html, = page.children
    body, = html.children
    line, = body.children
    span, = line.children
    img_1, img_2 = span.children
    assert img_1.height == 40
    assert img_2.height == 60
    assert img_1.position_y == 20
    assert img_2.position_y == 0
    # 60px + the descent of the font below the baseline
    assert 60 < line.height < 70
    assert body.height == line.height


@assert_no_logs
def test_vertical_align_2():
    #            +-------+      <- position_y = 0
    #       35px |       |
    #      +-----+       | 60px
    # 40px |     |       |
    #      |     +-------+      <- baseline
    #      +-----+  15px
    page, = render_pages('''
      <span>
        <img src="pattern.png" style="width: 40px; vertical-align: -15px"
        ><img src="pattern.png" style="width: 60px"></span>''')
    html, = page.children
    body, = html.children
    line, = body.children
    span, = line.children
    img_1, img_2 = span.children
    assert img_1.height == 40
    assert img_2.height == 60
    assert img_1.position_y == 35
    assert img_2.position_y == 0
    assert line.height == 75
    assert body.height == line.height


@assert_no_logs
def test_vertical_align_3():
    # Same as previously, but with percentages
    page, = render_pages('''
      <span style="line-height: 10px">
        <img src="pattern.png" style="width: 40px; vertical-align: -150%"
        ><img src="pattern.png" style="width: 60px"></span>''')
    html, = page.children
    body, = html.children
    line, = body.children
    span, = line.children
    img_1, img_2 = span.children
    assert img_1.height == 40
    assert img_2.height == 60
    assert img_1.position_y == 35
    assert img_2.position_y == 0
    assert line.height == 75
    assert body.height == line.height


@assert_no_logs
def test_vertical_align_4():
    # Same again, but have the vertical-align on an inline box.
    page, = render_pages('''
      <span style="line-height: 10px">
        <span style="line-height: 10px; vertical-align: -15px">
          <img src="pattern.png" style="width: 40px"></span>
        <img src="pattern.png" style="width: 60px"></span>''')
    html, = page.children
    body, = html.children
    line, = body.children
    span_1, = line.children
    span_2, _whitespace, img_2 = span_1.children
    img_1, = span_2.children
    assert img_1.height == 40
    assert img_2.height == 60
    assert img_1.position_y == 35
    assert img_2.position_y == 0
    assert line.height == 75
    assert body.height == line.height


@assert_no_logs
def test_vertical_align_5():
    # Same as previously, but with percentages
    page, = render_pages(
        '<span style="line-height: 12px; font-size: 12px; font-family: weasyprint">'
        '<img src="pattern.png" style="width: 40px; vertical-align: middle">'
        '<img src="pattern.png" style="width: 60px"></span>')
    html, = page.children
    body, = html.children
    line, = body.children
    span, = line.children
    img_1, img_2 = span.children
    assert img_1.height == 40
    assert img_2.height == 60
    # middle of the image (position_y + 20) is at half the ex-height above
    # the baseline of the parent. The ex-height of weasyprint.otf is 0.8em
    # TODO: ex unit doesn't work with @font-face fonts, see computed_values.py
    # assert img_1.position_y == 35.2  # 60 - 0.5 * 0.8 * font-size - 40/2
    assert img_2.position_y == 0
    # assert line.height == 75.2
    assert body.height == line.height


@assert_no_logs
def test_vertical_align_6():
    # sup and sub currently mean +/- 0.5 em
    # With the initial 16px font-size, that’s 8px.
    page, = render_pages('''
      <span style="line-height: 10px">
        <img src="pattern.png" style="width: 60px"
        ><img src="pattern.png" style="width: 40px; vertical-align: super"
        ><img src="pattern.png" style="width: 40px; vertical-align: sub"
      ></span>''')
    html, = page.children
    body, = html.children
    line, = body.children
    span, = line.children
    img_1, img_2, img_3 = span.children
    assert img_1.height == 60
    assert img_2.height == 40
    assert img_3.height == 40
    assert img_1.position_y == 0
    assert img_2.position_y == 12  # 20 - 16 * 0.5
    assert img_3.position_y == 28  # 20 + 16 * 0.5
    assert line.height == 68
    assert body.height == line.height


@assert_no_logs
def test_vertical_align_7():
    page, = render_pages('''
      <body style="line-height: 10px">
        <span>
          <img src="pattern.png" style="vertical-align: text-top"
          ><img src="pattern.png" style="vertical-align: text-bottom"
        ></span>''')
    html, = page.children
    body, = html.children
    line, = body.children
    span, = line.children
    img_1, img_2 = span.children
    assert img_1.height == 4
    assert img_2.height == 4
    assert img_1.position_y == 0
    assert img_2.position_y == 12  # 16 - 4
    assert line.height == 16
    assert body.height == line.height


@assert_no_logs
def test_vertical_align_8():
    # This case used to cause an exception:
    # The second span has no children but should count for line heights
    # since it has padding.
    page, = render_pages('''<span style="line-height: 1.5">
      <span style="padding: 1px"></span></span>''')
    html, = page.children
    body, = html.children
    line, = body.children
    span_1, = line.children
    span_2, = span_1.children
    assert span_1.height == 16
    assert span_2.height == 16
    # The line’s strut does not has 'line-height: normal' but the result should
    # be smaller than 1.5.
    assert span_1.margin_height() == 24
    assert span_2.margin_height() == 24
    assert line.height == 24


@assert_no_logs
def test_vertical_align_9():
    page, = render_pages('''
      <span>
        <img src="pattern.png" style="width: 40px; vertical-align: -15px"
        ><img src="pattern.png" style="width: 60px"
      ></span><div style="display: inline-block; vertical-align: 3px">
        <div>
          <div style="height: 100px">foo</div>
          <div>
            <img src="pattern.png" style="
                 width: 40px; vertical-align: -15px"
            ><img src="pattern.png" style="width: 60px"
          ></div>
        </div>
      </div>''')
    html, = page.children
    body, = html.children
    line, = body.children
    span, div_1 = line.children
    assert line.height == 178
    assert body.height == line.height

    # Same as earlier
    img_1, img_2 = span.children
    assert img_1.height == 40
    assert img_2.height == 60
    assert img_1.position_y == 138
    assert img_2.position_y == 103

    div_2, = div_1.children
    div_3, div_4 = div_2.children
    div_line, = div_4.children
    div_img_1, div_img_2 = div_line.children
    assert div_1.position_y == 0
    assert div_1.height == 175
    assert div_3.height == 100
    assert div_line.height == 75
    assert div_img_1.height == 40
    assert div_img_2.height == 60
    assert div_img_1.position_y == 135
    assert div_img_2.position_y == 100


@assert_no_logs
def test_vertical_align_10():
    # The first two images bring the top of the line box 30px above
    # the baseline and 10px below.
    # Each of the inner span
    page, = render_pages('''
      <span style="font-size: 0">
        <img src="pattern.png" style="vertical-align: 26px">
        <img src="pattern.png" style="vertical-align: -10px">
        <span style="vertical-align: top">
          <img src="pattern.png" style="vertical-align: -10px">
          <span style="vertical-align: -10px">
            <img src="pattern.png" style="vertical-align: bottom">
          </span>
        </span>
        <span style="vertical-align: bottom">
          <img src="pattern.png" style="vertical-align: 6px">
        </span>
      </span>''')
    html, = page.children
    body, = html.children
    line, = body.children
    span_1, = line.children
    img_1, img_2, span_2, span_4 = span_1.children
    img_3, span_3 = span_2.children
    img_4, = span_3.children
    img_5, = span_4.children
    assert body.height == line.height
    assert line.height == 40
    assert img_1.position_y == 0
    assert img_2.position_y == 36
    assert img_3.position_y == 6
    assert img_4.position_y == 36
    assert img_5.position_y == 30


@assert_no_logs
def test_vertical_align_11():
    page, = render_pages('''
      <span style="font-size: 0">
        <img src="pattern.png" style="vertical-align: bottom">
        <img src="pattern.png" style="vertical-align: top; height: 100px">
      </span>
    ''')
    html, = page.children
    body, = html.children
    line, = body.children
    span, = line.children
    img_1, img_2 = span.children
    assert img_1.position_y == 96
    assert img_2.position_y == 0


@assert_no_logs
def test_vertical_align_12():
    # Reference for the next test
    page, = render_pages('''
      <span style="font-size: 0; vertical-align: top">
        <img src="pattern.png">
      </span>
    ''')
    html, = page.children
    body, = html.children
    line, = body.children
    span, = line.children
    img_1, = span.children
    assert img_1.position_y == 0


@assert_no_logs
def test_vertical_align_13():
    # Should be the same as above
    page, = render_pages('''
      <span style="font-size: 0; vertical-align: top; display: inline-block">
        <img src="pattern.png">
      </span>''')
    html, = page.children
    body, = html.children
    line_1, = body.children
    span, = line_1.children
    line_2, = span.children
    img_1, = line_2.children
    assert img_1.element_tag == 'img'
    assert img_1.position_y == 0


@assert_no_logs
def test_box_decoration_break_inline_slice():
    # https://www.w3.org/TR/css-backgrounds-3/#the-box-decoration-break
    page_1, = render_pages('''
      <style>
        @page { size: 100px }
        span { font-family: weasyprint; box-decoration-break: slice;
               padding: 5px; border: 1px solid black }
      </style>
      <span>a<br/>b<br/>c</span>''')
    html, = page_1.children
    body, = html.children
    line_1, line_2, line_3 = body.children
    span, = line_1.children
    assert span.width == 16
    assert span.margin_width() == 16 + 5 + 1
    text, br = span.children
    assert text.position_x == 5 + 1
    span, = line_2.children
    assert span.width == 16
    assert span.margin_width() == 16
    text, br = span.children
    assert text.position_x == 0
    span, = line_3.children
    assert span.width == 16
    assert span.margin_width() == 16 + 5 + 1
    text, = span.children
    assert text.position_x == 0


@assert_no_logs
def test_box_decoration_break_inline_clone():
    # https://www.w3.org/TR/css-backgrounds-3/#the-box-decoration-break
    page_1, = render_pages('''
      <style>
        @page { size: 100px }
        span { font-size: 12pt; font-family: weasyprint;
               box-decoration-break: clone;
               padding: 5px; border: 1px solid black }
      </style>
      <span>a<br/>b<br/>c</span>''')
    html, = page_1.children
    body, = html.children
    line_1, line_2, line_3 = body.children
    span, = line_1.children
    assert span.width == 16
    assert span.margin_width() == 16 + 2 * (5 + 1)
    text, br = span.children
    assert text.position_x == 5 + 1
    span, = line_2.children
    assert span.width == 16
    assert span.margin_width() == 16 + 2 * (5 + 1)
    text, br = span.children
    assert text.position_x == 5 + 1
    span, = line_3.children
    assert span.width == 16
    assert span.margin_width() == 16 + 2 * (5 + 1)
    text, = span.children
    assert text.position_x == 5 + 1


@assert_no_logs
def test_bidi_position_x_invariant():
    page, = render_pages('''
      <style>
        .float-border {
          float: left;
          border-right: 100px solid black;
        }
      </style>
      <div class="float-border" style="direction: ltr">abc</div>
      <div>&nbsp;</div>
      <div class="float-border" style="direction: rtl">abc</div>
    ''')
    html, = page.children
    body, = html.children
    block_ltr, _, block_rtl = body.children

    line_ltr, = block_ltr.children
    text_ltr, = line_ltr.children

    line_rtl, = block_rtl.children
    text_rtl, = line_rtl.children

    assert block_ltr.position_x == block_rtl.position_x
    assert line_ltr.position_x == line_rtl.position_x
    assert text_ltr.position_x == text_rtl.position_x


@assert_no_logs
def test_nested_waiting_children_width():
    # Regression test for #2275.
    page, = render_pages(
        '<body style="width: 3em; font-family: weasyprint">'
        '<b><i style="width: 100%">a b</i>c')
    html, = page.children
    body, = html.children
    line1, line2 = body.children
    assert line1.children[0].children[0].children[0].text == 'a'
    assert line2.children[0].children[0].children[0].text == 'b'
    assert line2.children[0].children[1].text == 'c'


================================================
FILE: tests/layout/test_inline_block.py
================================================
"""Tests for inline blocks layout."""

from ..testing_utils import assert_no_logs, render_pages


@assert_no_logs
def test_inline_block_sizes():
    page, = render_pages('''
      <style>
        @page { margin: 0; size: 200px 2000px }
        body { margin: 0 }
        div { display: inline-block; }
      </style>
      <div> </div>
      <div>a</div>
      <div style="margin: 10px; height: 100px"></div>
      <div style="margin-left: 10px; margin-top: -50px;
                  padding-right: 20px;"></div>
      <div>
        Ipsum dolor sit amet,
        consectetur adipiscing elit.
        Sed sollicitudin nibh
        et turpis molestie tristique.
      </div>
      <div style="width: 100px; height: 100px;
                  padding-left: 10px; margin-right: 10px;
                  margin-top: -10px; margin-bottom: 50px"></div>
      <div style="font-size: 0">
        <div style="min-width: 10px; height: 10px"></div>
        <div style="width: 10%">
          <div style="width: 10px; height: 10px"></div>
        </div>
      </div>
      <div style="min-width: 150px">foo</div>
      <div style="max-width: 10px
        ">Supercalifragilisticexpialidocious</div>''')
    html, = page.children
    assert html.element_tag == 'html'
    body, = html.children
    assert body.element_tag == 'body'
    assert body.width == 200

    line_1, line_2, line_3, line_4 = body.children

    # First line:
    # White space in-between divs ends up preserved in TextBoxes
    div_1, _, div_2, _, div_3, _, div_4, _ = line_1.children

    # First div, one ignored space collapsing with next space
    assert div_1.element_tag == 'div'
    assert div_1.width == 0

    # Second div, one letter
    assert div_2.element_tag == 'div'
    assert 0 < div_2.width < 20

    # Third div, empty with margin
    assert div_3.element_tag == 'div'
    assert div_3.width == 0
    assert div_3.margin_width() == 20
    assert div_3.height == 100

    # Fourth div, empty with margin and padding
    assert div_4.element_tag == 'div'
    assert div_4.width == 0
    assert div_4.margin_width() == 30

    # Second line:
    div_5, _ = line_2.children

    # Fifth div, long text, full-width div
    assert div_5.element_tag == 'div'
    assert len(div_5.children) > 1
    assert div_5.width == 200

    # Third line:
    div_6, _, div_7, _ = line_3.children

    # Sixth div, empty div with fixed width and height
    assert div_6.element_tag == 'div'
    assert div_6.width == 100
    assert div_6.margin_width() == 120
    assert div_6.height == 100
    assert div_6.margin_height() == 140

    # Seventh div
    assert div_7.element_tag == 'div'
    assert div_7.width == 20
    child_line, = div_7.children
    # Spaces have font-size: 0, they get removed
    child_div_1, child_div_2 = child_line.children
    assert child_div_1.element_tag == 'div'
    assert child_div_1.width == 10
    assert child_div_2.element_tag == 'div'
    assert child_div_2.width == 2
    grandchild, = child_div_2.children
    assert grandchild.element_tag == 'div'
    assert grandchild.width == 10

    div_8, _, div_9 = line_4.children
    assert div_8.width == 150
    assert div_9.width == 10


@assert_no_logs
def test_inline_block_with_margin():
    # Regression test for #1235.
    page_1, = render_pages('''
      <style>
        @page { size: 100px }
        span { font-family: weasyprint; display: inline-block; margin: 0 30px }
      </style>
      <span>a b c d e f g h i j k l</span>''')
    html, = page_1.children
    body, = html.children
    line_1, = body.children
    span, = line_1.children
    assert span.width == 40  # 100 - 2 * 30


================================================
FILE: tests/layout/test_list.py
================================================
"""Tests for lists layout."""

import pytest

from ..testing_utils import assert_no_logs, render_pages


@assert_no_logs
@pytest.mark.parametrize('inside', ['inside', '',])
@pytest.mark.parametrize(('style', 'character'), [
    ('circle', '◦ '),
    ('disc', '• '),
    ('square', '▪ '),
])
def test_lists_style(inside, style, character):
    page, = render_pages('''
      <style>
        body { margin: 0 }
        ul { margin-left: 50px; list-style: %s %s }
      </style>
      <ul>
        <li>abc</li>
      </ul>
    ''' % (inside, style))
    html, = page.children
    body, = html.children
    unordered_list, = body.children
    list_item, = unordered_list.children
    if inside:
        line, = list_item.children
        marker, content = line.children
        marker_text, = marker.children
    else:
        marker, line_container, = list_item.children
        assert marker.position_x == list_item.position_x - marker.width
        assert marker.position_y == list_item.position_y
        line, = line_container.children
        content, = line.children
        marker_line, = marker.children
        marker_text, = marker_line.children
    assert marker_text.text == character
    assert content.text == 'abc'


def test_lists_empty_item():
    # Regression test for #873.
    page, = render_pages('''
      <ul>
        <li>a</li>
        <li></li>
        <li>a</li>
      </ul>
    ''')
    html, = page.children
    body, = html.children
    unordered_list, = body.children
    li1, li2, li3 = unordered_list.children
    assert li1.position_y != li2.position_y != li3.position_y


@pytest.mark.xfail
def test_lists_whitespace_item():
    # Regression test for #873.
    page, = render_pages('''
      <ul>
        <li>a</li>
        <li> </li>
        <li>a</li>
      </ul>
    ''')
    html, = page.children
    body, = html.children
    unordered_list, = body.children
    li1, li2, li3 = unordered_list.children
    assert li1.position_y != li2.position_y != li3.position_y


def test_lists_page_break():
    # Regression test for #945.
    page1, page2 = render_pages('''
      <style>
        @page { size: 300px 100px }
        ul { font-size: 30px; font-family: weasyprint; margin: 0 }
      </style>
      <ul>
        <li>a</li>
        <li>a</li>
        <li>a</li>
        <li>a</li>
      </ul>
    ''')
    html, = page1.children
    body, = html.children
    ul, = body.children
    assert len(ul.children) == 3
    for li in ul.children:
        assert len(li.children) == 2

    html, = page2.children
    body, = html.children
    ul, = body.children
    assert len(ul.children) == 1
    for li in ul.children:
        assert len(li.children) == 2


def test_lists_page_break_margin():
    # Regression test for #1058.
    page1, page2 = render_pages('''
      <style>
        @page { size: 300px 100px }
        ul { font-size: 30px; font-family: weasyprint; margin: 0 }
        p { margin: 10px 0 }
      </style>
      <ul>
        <li><p>a</p></li>
        <li><p>a</p></li>
        <li><p>a</p></li>
        <li><p>a</p></li>
      </ul>
    ''')
    for page in (page1, page2):
        html, = page.children
        body, = html.children
        ul, = body.children
        assert len(ul.children) == 2
        for li in ul.children:
            assert len(li.children) == 2
            assert (
                li.children[0].position_y ==
                li.children[1].children[0].position_y)


================================================
FILE: tests/layout/test_logical.py
================================================
"""Tests for logical properties."""

import pytest

from ..testing_utils import assert_no_logs


@assert_no_logs
@pytest.mark.parametrize('documents', [
    (
        '<div style="border-top: 1px solid">',
        '<div style="border-block-start: 1px solid">',
    ), (
        '<div style="border-left: 1px solid">',
        '<div style="border-inline-start: 1px solid">',
    ), (
        '<div style="border-inline-start: 1px solid">',
        '<article style="direction: rtl">'
        '  <div style="border-inline-end: 1px solid">',
    ), (
        '<div style="border-style: solid; border-width: 1px 2px">',
        '<div style="border-style: solid; border-width: logical 1px 2px">',
    ), (
        '<div style="padding-top: 1px">',
        '<div style="padding-block-start: 1px">',
    ), (
        '<div style="padding: 1px 2px 3px 4px">',
        '<div style="padding: logical 1px 4px 3px 2px">',
        '<div style="padding: 1px 2px;'
        '            padding-inline-start: 4px; padding-block-end: 3px">',
    ), (
        '<div style="margin-right: 1px">',
        '<div style="margin-inline-end: 1px">',
        '<article style="direction: rtl">'
        '  <div style="margin-inline-start: 1px">',
        '<article style="direction: rtl">'
        '  <div style="margin: logical 0 1px 0 0">',
    ), (
        '<div style="border-radius: 0 0 0 4px">',
        '<div style="border-bottom-left-radius: 4px">',
        '<div style="border-end-start-radius: 4px">',
        '<article style="direction: rtl">'
        '  <div style="border-end-end-radius: 4px">',
    ), (
        '<div style="width: 5px">',
        '<div style="inline-size: 5px">',
        '<div style="max-inline-size: 5px">',
        '<div style="max-inline-size: 5px; min-block-size: 2px">',
    ), (
        '<div style="height: 6px">',
        '<div style="block-size: 6px">',
        '<div style="min-block-size: 6px">',
        '<div style="min-block-size: 6px; max-inline-size: 10px">',
    ), (
        '<div style="position: absolute; width: 5px; inset: auto 1px auto auto">',
        '<div style="position: absolute; width: 5px; right: 1px">',
        '<div style="position: absolute; width: 5px; inset-inline-end: 1px">',
        '<div style="position: absolute; width: 5px; inset-inline: auto 1px">',
    ), (
        '<div style="float: left; width: 5px">',
        '<div style="float: inline-start; width: 5px">',
        '<article style="direction: rtl">'
        '  <div style="float: inline-end; width: 5px">',
    ), (
        '<div style="float: left; width: 5px"></div>'
        '<div style="float: left; width: 3px"></div>',
        '<div style="float: left; width: 5px"></div>'
        '<div style="float: left; width: 3px; clear: right"></div>',
        '<div style="float: inline-start; width: 5px"></div>'
        '<div style="float: left; width: 3px; clear: inline-end"></div>',
        '<div style="float: left; width: 5px"></div>'
        '<div style="float: inline-start; width: 3px; clear: inline-end"></div>',
        '<article style="direction: rtl">'
        '  <div style="float: left; width: 5px"></div>'
        '  <div style="float: inline-end; width: 3px; clear: inline-start"></div>',
    ), (
        '<div style="float: left; width: 5px"></div>'
        '<div style="float: left; width: 3px; clear: left"></div>',
        '<div style="float: inline-start; width: 5px"></div>'
        '<div style="float: left; width: 3px; clear: inline-start"></div>',
        '<div style="float: inline-start; width: 5px"></div>'
        '<div style="float: inline-start; width: 3px; clear: left"></div>',
        '<div style="float: inline-start; width: 5px"></div>'
        '<div style="float: inline-start; width: 3px; clear: both"></div>',
        '<article style="direction: rtl">'
        '  <div style="float: inline-end; width: 5px"></div>'
        '  <div style="float: inline-end; width: 3px; clear: left"></div>',
        '<article style="direction: rtl">'
        '  <div style="float: left; width: 5px"></div>'
        '  <div style="float: inline-end; width: 3px; clear: inline-end"></div>',
    ),
])
def test_logical(assert_same_renderings, documents):
    base_style = '''
    <style>
      @page { size: 10px }
      div { background: pink; background-clip: padding-box; height: 5px }
    </style>
    '''
    assert_same_renderings(*(base_style + document for document in documents))



================================================
FILE: tests/layout/test_page.py
================================================
"""Tests for pages layout."""

import pytest

from weasyprint.formatting_structure import boxes

from ..testing_utils import assert_no_logs, render_pages


@assert_no_logs
@pytest.mark.parametrize(('size', 'width', 'height'), [
    ('auto', 793, 1122),
    ('2in 10in', 192, 960),
    ('242px', 242, 242),
    ('letter', 816, 1056),
    ('letter portrait', 816, 1056),
    ('letter landscape', 1056, 816),
    ('portrait', 793, 1122),
    ('landscape', 1122, 793),
])
def test_page_size_basic(size, width, height):
    """Test the layout for ``@page`` properties."""
    page, = render_pages('<style>@page { size: %s; }</style>' % size)
    assert int(page.margin_width()) == width
    assert int(page.margin_height()) == height


@assert_no_logs
def test_page_size_with_margin():
    page, = render_pages('''<style>
      @page { size: 200px 300px; margin: 10px 10% 20% 1in }
      body { margin: 8px }
    </style>
    <p style="margin: 0">''')
    assert page.margin_width() == 200
    assert page.margin_height() == 300
    assert page.position_x == 0
    assert page.position_y == 0
    assert page.width == 84  # 200px - 10% - 1 inch
    assert page.height == 230  # 300px - 10px - 20%

    html, = page.children
    assert html.element_tag == 'html'
    assert html.position_x == 96  # 1in
    assert html.position_y == 10  # root element’s margins do not collapse
    assert html.width == 84

    body, = html.children
    assert body.element_tag == 'body'
    assert body.position_x == 96  # 1in
    assert body.position_y == 10
    # body has margins in the UA stylesheet
    assert body.margin_left == 8
    assert body.margin_right == 8
    assert body.margin_top == 8
    assert body.margin_bottom == 8
    assert body.width == 68

    paragraph, = body.children
    assert paragraph.element_tag == 'p'
    assert paragraph.position_x == 104  # 1in + 8px
    assert paragraph.position_y == 18  # 10px + 8px
    assert paragraph.width == 68


@assert_no_logs
def test_page_size_with_margin_border_padding():
    page, = render_pages('''<style> @page {
      size: 100px; margin: 1px 2px; padding: 4px 8px;
      border-width: 16px 32px; border-style: solid;
    }</style>''')
    assert page.width == 16  # 100 - 2 * 42
    assert page.height == 58  # 100 - 2 * 21
    html, = page.children
    assert html.element_tag == 'html'
    assert html.position_x == 42  # 2 + 8 + 32
    assert html.position_y == 21  # 1 + 4 + 16


@assert_no_logs
@pytest.mark.parametrize(('margin', 'top', 'right', 'bottom', 'left'), [
    ('auto', 15, 10, 15, 10),
    ('5px 5px auto auto', 5, 5, 25, 15),
])
def test_page_size_margins(margin, top, right, bottom, left):
    page, = render_pages('''<style>@page {
      size: 106px 206px; width: 80px; height: 170px;
      padding: 1px; border: 2px solid; margin: %s }</style>''' % margin)
    assert page.margin_top == top
    assert page.margin_right == right
    assert page.margin_bottom == bottom
    assert page.margin_left == left


@assert_no_logs
@pytest.mark.parametrize(('style', 'width', 'height'), [
    ('size: 4px 10000px; width: 100px; height: 100px;'
     'padding: 1px; border: 2px solid; margin: 3px',
     112, 112),
    ('size: 1000px; margin: 100px; max-width: 500px; min-height: 1500px',
     700, 1700),
    ('size: 1000px; margin: 100px; min-width: 1500px; max-height: 500px',
     1700, 700),
])
def test_page_size_over_constrained(style, width, height):
    page, = render_pages('<style>@page { %s }</style>' % style)
    assert page.margin_width() == width
    assert page.margin_height() == height


@assert_no_logs
@pytest.mark.parametrize('html', [
    '<div>1</div>',
    '<div></div>',
    '<img src=pattern.png>'
])
def test_page_breaks(html):
    pages = render_pages('''
      <style>
        @page { size: 100px; margin: 10px }
        body { margin: 0 }
        div { height: 30px; font-size: 20px }
        img { height: 30px; display: block }
      </style>
      %s''' % (5 * html))
    page_children = []
    for page in pages:
        html, = page.children
        body, = html.children
        children = body.children
        assert all([child.element_tag in ('div', 'img') for child in children])
        assert all([child.position_x == 10 for child in children])
        page_children.append(children)
    assert [
        [child.position_y for child in page_child]
        for page_child in page_children] == [[10, 40], [10, 40], [10]]


@assert_no_logs
def test_page_breaks_box_split():
    # If floats round the wrong way, a block that gets filled to the end of a
    # page due to breaking over the page may be forced onto the next page
    # because it is slightly taller than can fit on the previous page, even if
    # it wouldn't have been without being filled. These numbers aren't ideal,
    # but they do seem to trigger the issue.
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 982.4146981627297px; margin: 0 }
        div { font-size: 5px; height: 200.0123456789px; margin: 0; padding: 0 }
        figure { margin: 0; padding: 0 }
      </style>
      <div>text</div>
      <div>text</div><!-- no page break here -->
      <section>
        <div>line1</div>
        <div>line2</div><!-- page break here -->
        <div>line3</div>
        <div>line4</div>
      </section>
    ''')
    html, = page_1.children
    body, = html.children
    assert len(body.children) == 3
    div1, div2, section = body.children
    assert len(section.children) == 2

    html, = page_2.children
    body, = html.children
    section, = body.children
    assert len(section.children) == 2


@assert_no_logs
def test_page_breaks_complex_1():
    page_1, page_2, page_3, page_4 = render_pages('''
      <style>
        @page { margin: 10px }
        @page :left { margin-left: 50px }
        @page :right { margin-right: 50px }
        html { page-break-before: left }
        div { page-break-after: left }
        ul { page-break-before: always }
      </style>
      <div>1</div>
      <p>2</p>
      <p>3</p>
      <article>
        <section>
          <ul><li>4</li></ul>
        </section>
      </article>
    ''')

    # The first page is a right page on rtl, but not here because of
    # page-break-before on the root element.
    assert page_1.margin_left == 50  # left page
    assert page_1.margin_right == 10
    html, = page_1.children
    body, = html.children
    div, = body.children
    line, = div.children
    text, = line.children
    assert div.element_tag == 'div'
    assert text.text == '1'

    html, = page_2.children
    assert page_2.margin_left == 10
    assert page_2.margin_right == 50  # right page
    assert not html.children  # empty page to get to a left page

    assert page_3.margin_left == 50  # left page
    assert page_3.margin_right == 10
    html, = page_3.children
    body, = html.children
    p_1, p_2 = body.children
    assert p_1.element_tag == 'p'
    assert p_2.element_tag == 'p'

    assert page_4.margin_left == 10
    assert page_4.margin_right == 50  # right page
    html, = page_4.children
    body, = html.children
    article, = body.children
    section, = article.children
    ulist, = section.children
    assert ulist.element_tag == 'ul'


@assert_no_logs
def test_page_breaks_complex_2():
    # Reference for the following test:
    # Without any 'avoid', this breaks after the <div>
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 140px; margin: 0 }
        img { height: 25px; vertical-align: top }
      </style>
      <img src=pattern.png>
      <div>
        <p><img src=pattern.png><br/><img src=pattern.png><p>
        <p><img src=pattern.png><br/><img src=pattern.png><p>
      </div><!-- page break here -->
      <img src=pattern.png>
    ''')
    html, = page_1.children
    body, = html.children
    img_1, div = body.children
    assert img_1.position_y == 0
    assert img_1.height == 25
    assert div.position_y == 25
    assert div.height == 100

    html, = page_2.children
    body, = html.children
    img_2, = body.children
    assert img_2.position_y == 0
    assert img_2.height == 25


@assert_no_logs
def test_page_breaks_complex_3():
    # Adding a few page-break-*: avoid, the only legal break is
    # before the <div>
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 140px; margin: 0 }
        img { height: 25px; vertical-align: top }
      </style>
      <img src=pattern.png><!-- page break here -->
      <div>
        <p style="page-break-inside: avoid">
          <img src=pattern.png><br/><img src=pattern.png></p>
        <p style="page-break-before: avoid; page-break-after: avoid; widows: 2"
          ><img src=pattern.png><br/><img src=pattern.png></p>
      </div>
      <img src=pattern.png>
    ''')
    html, = page_1.children
    body, = html.children
    img_1, = body.children
    assert img_1.position_y == 0
    assert img_1.height == 25

    html, = page_2.children
    body, = html.children
    div, img_2 = body.children
    assert div.position_y == 0
    assert div.height == 100
    assert img_2.position_y == 100
    assert img_2.height == 25


@assert_no_logs
def test_page_breaks_complex_4():
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 140px; margin: 0 }
        img { height: 25px; vertical-align: top }
      </style>
      <img src=pattern.png><!-- page break here -->
      <div>
        <div>
          <p style="page-break-inside: avoid">
            <img src=pattern.png><br/><img src=pattern.png></p>
          <p style="page-break-before:avoid; page-break-after:avoid; widows:2"
            ><img src=pattern.png><br/><img src=pattern.png></p>
        </div>
        <img src=pattern.png>
      </div>
    ''')
    html, = page_1.children
    body, = html.children
    img_1, = body.children
    assert img_1.position_y == 0
    assert img_1.height == 25

    html, = page_2.children
    body, = html.children
    outer_div, = body.children
    inner_div, img_2 = outer_div.children
    assert inner_div.position_y == 0
    assert inner_div.height == 100
    assert img_2.position_y == 100
    assert img_2.height == 25


@assert_no_logs
def test_page_breaks_complex_5():
    # Reference for the next test
    page_1, page_2, page_3 = render_pages('''
      <style>
        @page { size: 100px; margin: 0 }
        img { height: 30px; display: block; }
      </style>
      <div>
        <img src=pattern.png style="page-break-after: always">
        <section>
          <img src=pattern.png>
          <img src=pattern.png>
        </section>
      </div>
      <img src=pattern.png><!-- page break here -->
      <img src=pattern.png>
    ''')
    html, = page_1.children
    body, = html.children
    div, = body.children
    assert div.height == 100
    html, = page_2.children
    body, = html.children
    div, img_4 = body.children
    assert div.height == 60
    assert img_4.height == 30
    html, = page_3.children
    body, = html.children
    img_5, = body.children
    assert img_5.height == 30


@assert_no_logs
def test_page_breaks_complex_6():
    page_1, page_2, page_3 = render_pages('''
      <style>
        @page { size: 100px; margin: 0 }
        img { height: 30px; display: block; }
      </style>
      <div>
        <img src=pattern.png style="page-break-after: always">
        <section>
          <img src=pattern.png><!-- page break here -->
          <img src=pattern.png style="page-break-after: avoid">
        </section>
      </div>
      <img src=pattern.png style="page-break-after: avoid">
      <img src=pattern.png>
    ''')
    html, = page_1.children
    body, = html.children
    div, = body.children
    assert div.height == 100
    html, = page_2.children
    body, = html.children
    div, = body.children
    section, = div.children
    img_2, = section.children
    assert img_2.height == 30
    # TODO: currently this is 60: we do not increase the used height of blocks
    # to make them fill the blank space at the end of the age when we remove
    # children from them for some break-*: avoid.
    # See TODOs in blocks.block_container_layout
    # assert div.height == 100
    html, = page_3.children
    body, = html.children
    div, img_4, img_5, = body.children
    assert div.height == 30
    assert img_4.height == 30
    assert img_5.height == 30


@assert_no_logs
def test_page_breaks_complex_7():
    page_1, page_2, page_3 = render_pages('''
      <style>
        @page { @bottom-center { content: counter(page) } }
        @page:blank { @bottom-center { content: none } }
      </style>
      <p style="page-break-after: right">foo</p>
      <p>bar</p>
    ''')
    assert len(page_1.children) == 2  # content and @bottom-center
    assert len(page_2.children) == 1  # content only
    assert len(page_3.children) == 2  # content and @bottom-center


@assert_no_logs
def test_page_breaks_complex_8():
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 75px; margin: 0 }
        div { height: 20px }
      </style>
      <div></div>
      <section>
        <div></div>
        <div style="page-break-after: avoid">
          <div style="position: absolute"></div>
          <div style="position: fixed"></div>
        </div>
      </section>
      <div></div>
    ''')
    html, = page_1.children
    body, _div = html.children
    div_1, section = body.children
    div_2, = section.children
    assert div_1.position_y == 0
    assert div_2.position_y == 20
    assert div_1.height == 20
    assert div_2.height == 20
    html, = page_2.children
    body, = html.children
    section, div_4 = body.children
    div_3, = section.children
    absolute, fixed = div_3.children
    assert div_3.position_y == 0
    assert div_4.position_y == 20
    assert div_3.height == 20
    assert div_4.height == 20


@assert_no_logs
def test_page_breaks_complex_9():
    # Regression test for #1979.
    page_1, page_2, page_3, page_4, page_5 = render_pages('''
      <style>
        @page { size: 75px; margin: 0 }
        div { height: 20px; margin: 10px }
      </style>
      <div style="height: 40px"></div>
      <div></div>
      <div style="break-before: left"></div>
      <div style="break-before: right"></div>
    ''')
    html, = page_1.children
    body, = html.children
    div_1, = body.children
    assert div_1.content_box_x() == 10
    assert div_1.content_box_y() == 10
    html, = page_2.children
    body, = html.children
    div_2, = body.children
    assert div_2.content_box_x() == 10
    assert div_2.content_box_y() == 0  # Unforced page break
    html, = page_3.children
    assert not html.children  # Empty page
    html, = page_4.children
    body, = html.children
    div_3, = body.children
    assert div_3.content_box_x() == 10
    assert div_3.content_box_y() == 10  # Forced page break
    html, = page_5.children
    body, = html.children
    div_4, = body.children
    assert div_4.content_box_x() == 10
    assert div_4.content_box_y() == 10  # Forced page break


@assert_no_logs
@pytest.mark.parametrize(('break_after', 'margin_break', 'margin_top'), [
    ('page', 'auto', 5),
    ('auto', 'auto', 0),
    ('page', 'keep', 5),
    ('auto', 'keep', 5),
    ('page', 'discard', 0),
    ('auto', 'discard', 0),
])
def test_margin_break(break_after, margin_break, margin_top):
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 70px; margin: 0 }
        div { height: 63px; margin: 5px 0 8px;
              break-after: %s; margin-break: %s }
      </style>
      <section>
        <div></div>
      </section>
      <section>
        <div></div>
      </section>
    ''' % (break_after, margin_break))
    html, = page_1.children
    body, = html.children
    section, = body.children
    div, = section.children
    assert div.margin_top == 5

    html, = page_2.children
    body, = html.children
    section, = body.children
    div, = section.children
    assert div.margin_top == margin_top


@pytest.mark.xfail
@assert_no_logs
def test_margin_break_clearance():
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 70px; margin: 0 }
        div { height: 63px; margin: 5px 0 8px; break-after: page }
      </style>
      <section>
        <div></div>
      </section>
      <section>
        <div style="border-top: 1px solid black">
          <div></div>
        </div>
      </section>
    ''')
    html, = page_1.children
    body, = html.children
    section, = body.children
    div, = section.children
    assert div.margin_top == 5

    html, = page_2.children
    body, = html.children
    section, = body.children
    div_1, = section.children
    assert div_1.margin_top == 0
    div_2, = div_1.children
    assert div_2.margin_top == 5
    assert div_2.content_box_y() == 5


@assert_no_logs
@pytest.mark.parametrize(('direction', 'page_break', 'pages_number'), [
    ('ltr', 'recto', 3),
    ('ltr', 'verso', 2),
    ('rtl', 'recto', 3),
    ('rtl', 'verso', 2),
    ('ltr', 'right', 3),
    ('ltr', 'left', 2),
    ('rtl', 'right', 2),
    ('rtl', 'left', 3),
])
def test_recto_verso_break(direction, page_break, pages_number):
    pages = render_pages('''
      <style>
        html { direction: %s }
        p { break-before: %s }
      </style>
      abc
      <p>def</p>
    ''' % (direction, page_break))
    assert len(pages) == pages_number


@assert_no_logs
@pytest.mark.parametrize(('direction', 'page_break', 'first_page'), [
    ('ltr', 'recto', 'right'),
    ('ltr', 'verso', 'left'),
    ('rtl', 'recto', 'left'),
    ('rtl', 'verso', 'right'),
    ('ltr', 'right', 'right'),
    ('ltr', 'left', 'left'),
    ('rtl', 'right', 'right'),
    ('rtl', 'left', 'left'),
])
def test_recto_verso_break_root(direction, page_break, first_page):
    page, = render_pages('''
      <style>
        @page:left { size: 4px /* len('left') */ }
        @page:right { size: 5px /* len('right') */ }
        html { direction: %s; break-before: %s }
      </style>
      abc
    ''' % (direction, page_break))
    assert page.width == len(first_page)


@assert_no_logs
def test_page_names_1():
    pages = render_pages('''
      <style>
        @page { size: 100px 100px }
        section { page: small }
      </style>
      <div>
        <section>large</section>
      </div>
    ''')
    page1, = pages
    assert (page1.width, page1.height) == (100, 100)


@assert_no_logs
def test_page_names_2():
    pages = render_pages('''
      <style>
        @page { size: 100px 100px }
        @page narrow { margin: 1px }
        section { page: small }
      </style>
      <div>
        <section>large</section>
      </div>
    ''')
    page1, = pages
    assert (page1.width, page1.height) == (100, 100)


@assert_no_logs
def test_page_names_3():
    pages = render_pages('''
      <style>
        @page { margin: 0 }
        @page narrow { size: 100px 200px }
        @page large { size: 200px 100px }
        div { page: narrow }
        section { page: large }
      </style>
      <div>
        <section>large</section>
        <section>large</section>
        <p>narrow</p>
      </div>
    ''')
    page1, page2 = pages

    assert (page1.width, page1.height) == (200, 100)
    html, = page1.children
    body, = html.children
    div, = body.children
    section1, section2 = div.children
    assert section1.element_tag == section2.element_tag == 'section'

    assert (page2.width, page2.height) == (100, 200)
    html, = page2.children
    body, = html.children
    div, = body.children
    p, = div.children
    assert p.element_tag == 'p'


@assert_no_logs
def test_page_names_4():
    pages = render_pages('''
      <style>
        @page { size: 200px 200px; margin: 0 }
        @page small { size: 100px 100px }
        p { page: small }
      </style>
      <section>normal</section>
      <section>normal</section>
      <p>small</p>
      <section>small</section>
    ''')
    page1, page2 = pages

    assert (page1.width, page1.height) == (200, 200)
    html, = page1.children
    body, = html.children
    section1, section2 = body.children
    assert section1.element_tag == section2.element_tag == 'section'

    assert (page2.width, page2.height) == (100, 100)
    html, = page2.children
    body, = html.children
    p, section = body.children
    assert p.element_tag == 'p'
    assert section.element_tag == 'section'


@assert_no_logs
def test_page_names_5():
    pages = render_pages('''
      <style>
        @page { size: 200px 200px; margin: 0 }
        @page small { size: 100px 100px }
        div { page: small }
      </style>
      <section><p>a</p>b</section>
      <section>c<div>d</div></section>
    ''')
    page1, page2 = pages

    assert (page1.width, page1.height) == (200, 200)
    html, = page1.children
    body, = html.children
    section1, section2 = body.children
    assert section1.element_tag == section2.element_tag == 'section'
    p, line = section1.children
    line, = section2.children

    assert (page2.width, page2.height) == (100, 100)
    html, = page2.children
    body, = html.children
    section2, = body.children
    div, = section2.children


@assert_no_logs
def test_page_names_6():
    pages = render_pages('''
      <style>
        @page { margin: 0 }
        @page large { size: 200px 200px }
        @page small { size: 100px 100px }
        section { page: large }
        div { page: small }
      </style>
      <section>a<p>b</p>c</section>
      <section>d<div>e</div>f</section>
    ''')
    page1, page2, page3 = pages

    assert (page1.width, page1.height) == (200, 200)
    html, = page1.children
    body, = html.children
    section1, section2 = body.children
    assert section1.element_tag == section2.element_tag == 'section'
    line1, p, line2 = section1.children
    line, = section2.children

    assert (page2.width, page2.height) == (100, 100)
    html, = page2.children
    body, = html.children
    section2, = body.children
    div, = section2.children

    assert (page3.width, page3.height) == (200, 200)
    html, = page3.children
    body, = html.children
    section2, = body.children
    line, = section2.children


@assert_no_logs
def test_page_names_7():
    pages = render_pages('''
      <style>
        @page { size: 200px 200px; margin: 0 }
        @page small { size: 100px 100px }
        p { page: small; break-before: right }
      </style>
      <section>normal</section>
      <section>normal</section>
      <p>small</p>
      <section>small</section>
    ''')
    page1, page2, page3 = pages

    assert (page1.width, page1.height) == (200, 200)
    html, = page1.children
    body, = html.children
    section1, section2 = body.children
    assert section1.element_tag == section2.element_tag == 'section'

    assert (page2.width, page2.height) == (200, 200)
    html, = page2.children
    assert not html.children

    assert (page3.width, page3.height) == (100, 100)
    html, = page3.children
    body, = html.children
    p, section = body.children
    assert p.element_tag == 'p'
    assert section.element_tag == 'section'


@assert_no_logs
def test_page_names_8():
    pages = render_pages('''
      <style>
        @page small { size: 100px 100px }
        section { page: small }
        p { line-height: 80px }
      </style>
      <section>
        <p>small</p>
        <p>small</p>
      </section>
    ''')
    page1, page2 = pages

    assert (page1.width, page1.height) == (100, 100)
    html, = page1.children
    body, = html.children
    section, = body.children
    p, = section.children
    assert section.element_tag == 'section'
    assert p.element_tag == 'p'

    assert (page2.width, page2.height) == (100, 100)
    html, = page2.children
    body, = html.children
    section, = body.children
    p, = section.children
    assert section.element_tag == 'section'
    assert p.element_tag == 'p'


@assert_no_logs
def test_page_names_9():
    pages = render_pages('''
      <style>
        @page { size: 200px 200px }
        @page small { size: 100px 100px }
        section { break-after: page; page: small }
        article { page: small }
      </style>
      <section>
        <div>big</div>
        <div>big</div>
      </section>
      <article>
        <div>small</div>
        <div>small</div>
      </article>
    ''')
    page1, page2, = pages

    assert (page1.width, page1.height) == (100, 100)
    html, = page1.children
    body, = html.children
    section, = body.children
    assert section.element_tag == 'section'

    assert (page2.width, page2.height) == (100, 100)
    html, = page2.children
    body, = html.children
    article, = body.children
    assert article.element_tag == 'article'


@assert_no_logs
def test_page_names_10():
    pages = render_pages('''
      <style>
        #running { position: running(running); }
        #fixed { position: fixed; }
        @page { size: 200px 200px; @top-center { content: element(header); }}
        section { page: small; }
        @page small { size: 100px 100px; }
        .pagebreak { break-after: page; }
      </style>
      <div id="running">running</div>
      <div id="fixed">fixed</div>
      <section>
        <h1>text</h1>
        <div class="pagebreak"></div>
        <article>text</article>
      </section>
    ''')
    page1, page2 = pages

    assert (page1.width, page1.height) == (100, 100)
    html, running = page1.children
    body, = html.children
    fixed, section, = body.children
    h1, pagebreak = section.children
    assert h1.element_tag == 'h1'

    assert (page2.width, page2.height) == (100, 100)
    html, running = page2.children
    fixed, body = html.children
    section, = body.children
    article, = section.children
    assert article.element_tag == 'article'


@assert_no_logs
def test_page_groups():
    pages = render_pages('''
      <style>
        @page { size: 200px 200px }
        @page small { size: 100px 100px }
        @page :nth(1 of small) { size: 50px 50px }
        section { page: small }
        div, div section { break-after: page }
      </style>
      <div></div>
      <article></article>
      <section>
        <div></div>
        <div></div>
      </section>
      <section>
      </section>
      <div></div>
      <div></div>
      <section>
        <div></div>
      </section>
      <div>
        <section></section>
        <section></section>
      </div>
    ''')
    page1, page2, page3, page4, page5, page6, page7, page8, page9 = pages

    assert (page1.width, page1.height) == (200, 200)
    div, = page1.children[0].children[0].children
    assert div.element_tag == 'div'

    assert (page2.width, page2.height) == (200, 200)
    article, = page2.children[0].children[0].children
    assert article.element_tag == 'article'

    assert (page3.width, page3.height) == (50, 50)
    section, = page3.children[0].children[0].children
    assert section.element_tag == 'section'
    div, = section.children
    assert div.element_tag == 'div'

    assert (page4.width, page4.height) == (100, 100)
    section, = page4.children[0].children[0].children
    assert section.element_tag == 'section'
    div, = section.children
    assert div.element_tag == 'div'

    assert (page5.width, page5.height) == (50, 50)
    section, div = page5.children[0].children[0].children
    assert section.element_tag == 'section'
    assert div.element_tag == 'div'

    assert (page6.width, page6.height) == (200, 200)
    div, = page6.children[0].children[0].children
    assert div.element_tag == 'div'

    assert (page7.width, page7.height) == (50, 50)
    section, = page7.children[0].children[0].children
    assert section.element_tag == 'section'
    div, = section.children
    assert div.element_tag == 'div'

    assert (page8.width, page8.height) == (50, 50)
    div, = page8.children[0].children[0].children
    assert div.element_tag == 'div'
    section, = div.children
    assert section.element_tag == 'section'

    assert (page9.width, page9.height) == (50, 50)
    div, = page9.children[0].children[0].children
    assert div.element_tag == 'div'
    section, = div.children
    assert section.element_tag == 'section'


@assert_no_logs
def test_page_groups_blank_inside():
    # Regression test for #1076.
    pages = render_pages('''
      <style>
        @page { size: 100px }
        @page div { size: 50px }
        div { page: div }
        p { break-before: right }
      </style>
      <div>
        <p>1</p>
        <p>2</p>
      </div>
    ''')
    assert len(pages) == 3
    for page in pages:
        assert (page.width, page.height) == (50, 50)


@assert_no_logs
def test_page_groups_blank_outside():
    pages = render_pages('''
      <style>
        @page { size: 100px }
        @page p { size: 50px }
        p { page: p; break-before: right }
      </style>
      <div>
        <p>1</p>
        <p>2</p>
      </div>
    ''')
    page1, page2, page3 = pages
    for page in (page1, page3):
        assert (page.width, page.height) == (50, 50)
    assert (page2.width, page2.height) == (100, 100)


@assert_no_logs
def test_page_groups_first_nth():
    # Regression test for #2429.
    pages = render_pages('''
      <style>
        @page { size: 100px }
        @page div { size: 50px }
        @page :nth(2n+1 of div) { size: 30px }
        div { page: div; break-before: right }
        p { break-before: page }
      </style>
      <div>
        <p>1</p>
        <p>2</p>
        <p>3</p>
      </div>
      <div>
        <p>4</p>
        <p>5</p>
      </div>
    ''')
    page1, page2, page3, page4, page5, page6 = pages
    for page in (page1, page3, page5):
        assert (page.width, page.height) == (30, 30)
    for page in (page2, page6):
        assert (page.width, page.height) == (50, 50)
    assert (page4.width, page4.height) == (100, 100)

@assert_no_logs
def test_page_groups_counters():
    # Regression test for #2485.
    pages = render_pages('''
      <style>
        html { counter-reset: h1-counter }
        h1 { page-break-before: always; counter-increment: h1-counter; }
        div.main-content { page: main-content-page-group; break-before: page; }
        @page { size: 1000px }
        @page :nth(1 of main-content-page-group) { counter-reset: page 1; size: 500px; }
        a::after {
          content: target-counter(attr(href), h1-counter) '.'
          target-counter(attr(href), page);
        }
      </style>
      <html>
      <body>
        INTRO PAGE
        <div class="main-content">
        <h1 id="t2">First title</h1>
        <h1>Title3</h1>
        <a href="#t2">Second title</a>
        </div>
      </body>
      </html>
    ''')
    page1, page2, page3  = pages
    assert (page1.width, page1.height) == (1000, 1000)
    assert (page2.width, page2.height) == (500, 500)
    assert (page3.width, page3.height) == (1000, 1000)

    pages = render_pages('''
      <!DOCTYPE html>
      <html>
        <head>
          <style>
            @page { size: 1000px }
            div { page: group }
            h1 { break-before: page }
            p.counter::after { content: counter(pages) }
            @page :nth(1 of group) { background-color: blue; size: 500px; }
          </style>
        </head>
        <body>
          INTRO PAGE
          <div>
            <h1>Title</h1>
            <p>content</p>
            <h1>Title</h1>
            <p class="counter">content</p>
          </div>
          <div>
            <h1>Title</h1>
            <p>content</p>
            <h1>Title</h1>
            <p class="counter">content</p>
          </div>
        </body>
      </html>
    ''')
    page1, page2, page3, page4, page5  = pages
    assert (page1.width, page1.height) == (1000, 1000)
    assert (page2.width, page2.height) == (500, 500)
    assert (page3.width, page3.height) == (1000, 1000)
    assert (page4.width, page4.height) == (500, 500)
    assert (page5.width, page5.height) == (1000, 1000)

@assert_no_logs
@pytest.mark.parametrize(('style', 'line_counts'), [
    ('orphans: 2; widows: 2', [4, 3]),
    ('orphans: 5; widows: 2', [0, 7]),
    ('orphans: 2; widows: 4', [3, 4]),
    ('orphans: 4; widows: 4', [0, 7]),
    ('orphans: 2; widows: 2; page-break-inside: avoid', [0, 7]),
])
def test_orphans_widows_avoid(style, line_counts):
    pages = render_pages('''
      <style>
        @page { size: 200px }
        h1 { height: 120px }
        p { line-height: 20px;
            width: 1px; /* line break at each word */
            %s }
      </style>
      <h1>Tasty test</h1>
      <!-- There is room for 4 lines after h1 on the fist page -->
      <p>one two three four five six seven</p>
    ''' % style)
    for i, page in enumerate(pages):
        html, = page.children
        body, = html.children
        body_children = body.children if i else body.children[1:]  # skip h1
        count = len(body_children[0].children) if body_children else 0
        assert line_counts.pop(0) == count
    assert not line_counts


@assert_no_logs
def test_page_and_linebox_breaking():
    # Empty <span/> tests a corner case in skip_first_whitespace()
    pages = render_pages('''
      <style>
        @page { size: 100px; margin: 2px; border: 1px solid }
        body { margin: 0 }
        div { font-family: weasyprint; font-size: 20px }
      </style>
      <div><span/>1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15</div>
    ''')
    texts = []
    for page in pages:
        html, = page.children
        body, = html.children
        div, = body.children
        lines = div.children
        for line in lines:
            line_texts = []
            for child in line.descendants():
                if isinstance(child, boxes.TextBox):
                    line_texts.append(child.text)
            texts.append(''.join(line_texts))
    assert len(pages) == 4
    assert ''.join(texts) == '1,2,3,4,5,6,7,8,9,10,11,12,13,14,15'


@assert_no_logs
def test_margin_boxes_fixed_dimension_1():
    # Corner boxes
    page, = render_pages('''
      <style>
        @page {
          @top-left-corner {
            content: 'top_left';
            padding: 10px;
          }
          @top-right-corner {
            content: 'top_right';
            padding: 10px;
          }
          @bottom-left-corner {
            content: 'bottom_left';
            padding: 10px;
          }
          @bottom-right-corner {
            content: 'bottom_right';
            padding: 10px;
          }
          size: 1000px;
          margin-top: 10%;
          margin-bottom: 40%;
          margin-left: 20%;
          margin-right: 30%;
        }
      </style>
    ''')
    html, top_left, top_right, bottom_left, bottom_right = page.children
    for margin_box, text in zip(
            [top_left, top_right, bottom_left, bottom_right],
            ['top_left', 'top_right', 'bottom_left', 'bottom_right']):

        line, = margin_box.children
        text, = line.children
        assert text == text

    # Check positioning and Rule 1 for fixed dimensions
    assert top_left.position_x == 0
    assert top_left.position_y == 0
    assert top_left.margin_width() == 200  # margin-left
    assert top_left.margin_height() == 100  # margin-top

    assert top_right.position_x == 700  # size-x - margin-right
    assert top_right.position_y == 0
    assert top_right.margin_width() == 300  # margin-right
    assert top_right.margin_height() == 100  # margin-top

    assert bottom_left.position_x == 0
    assert bottom_left.position_y == 600  # size-y - margin-bottom
    assert bottom_left.margin_width() == 200  # margin-left
    assert bottom_left.margin_height() == 400  # margin-bottom

    assert bottom_right.position_x == 700  # size-x - margin-right
    assert bottom_right.position_y == 600  # size-y - margin-bottom
    assert bottom_right.margin_width() == 300  # margin-right
    assert bottom_right.margin_height() == 400  # margin-bottom


@assert_no_logs
def test_margin_boxes_fixed_dimension_2():
    # Test rules 2 and 3
    page, = render_pages('''
      <style>
        @page {
          margin: 100px 200px;
          @bottom-left-corner { content: ""; margin: 60px }
        }
      </style>
    ''')
    html, margin_box = page.children
    assert margin_box.margin_width() == 200
    assert margin_box.margin_left == 60
    assert margin_box.margin_right == 60
    assert margin_box.width == 80  # 200 - 60 - 60

    assert margin_box.margin_height() == 100
    # total was too big, the outside margin was ignored:
    assert margin_box.margin_top == 60
    assert margin_box.margin_bottom == 40  # Not 60
    assert margin_box.height == 0  # But not negative


@assert_no_logs
def test_margin_boxes_fixed_dimension_3():
    # Test rule 3 with a non-auto inner dimension
    page, = render_pages('''
      <style>
        @page {
          margin: 100px;
          @left-middle { content: ""; margin: 10px; width: 130px }
        }
      </style>
    ''')
    html, margin_box = page.children
    assert margin_box.margin_width() == 100
    assert margin_box.margin_left == -40  # Not 10px
    assert margin_box.margin_right == 10
    assert margin_box.width == 130  # As specified


@assert_no_logs
def test_margin_boxes_fixed_dimension_4():
    # Test rule 4
    page, = render_pages('''
      <style>
        @page {
          margin: 100px;
          @left-bottom {
            content: "";
            margin-left: 10px;
            margin-right: auto;
            width: 70px;
          }
        }
      </style>
    ''')
    html, margin_box = page.children
    assert margin_box.margin_width() == 100
    assert margin_box.margin_left == 10  # 10px this time, no over-constrain
    assert margin_box.margin_right == 20
    assert margin_box.width == 70  # As specified


@assert_no_logs
def test_margin_boxes_fixed_dimension_5():
    # Test rules 2, 3 and 4
    page, = render_pages('''
      <style>
        @page {
          margin: 100px;
          @right-top {
            content: "";
            margin-right: 10px;
            margin-left: auto;
            width: 130px;
          }
        }
      </style>
    ''')
    html, margin_box = page.children
    assert margin_box.margin_width() == 100
    assert margin_box.margin_left == 0  # rule 2
    assert margin_box.margin_right == -30  # rule 3, after rule 2
    assert margin_box.width == 130  # As specified


@assert_no_logs
def test_margin_boxes_fixed_dimension_6():
    # Test rule 5
    page, = render_pages('''
      <style>
        @page {
          margin: 100px;
          @top-left { content: ""; margin-top: 10px; margin-bottom: auto }
        }
      </style>
    ''')
    html, margin_box = page.children
    assert margin_box.margin_height() == 100
    assert margin_box.margin_top == 10
    assert margin_box.margin_bottom == 0
    assert margin_box.height == 90


@assert_no_logs
def test_margin_boxes_fixed_dimension_7():
    # Test rule 5
    page, = render_pages('''
      <style>
        @page {
          margin: 100px;
          @top-center { content: ""; margin: auto 0 }
        }
      </style>
    ''')
    html, margin_box = page.children
    assert margin_box.margin_height() == 100
    assert margin_box.margin_top == 0
    assert margin_box.margin_bottom == 0
    assert margin_box.height == 100


@assert_no_logs
def test_margin_boxes_fixed_dimension_8():
    # Test rule 6
    page, = render_pages('''
      <style>
        @page {
          margin: 100px;
          @bottom-right { content: ""; margin: auto; height: 70px }
        }
      </style>
    ''')
    html, margin_box = page.children
    assert margin_box.margin_height() == 100
    assert margin_box.margin_top == 15
    assert margin_box.margin_bottom == 15
    assert margin_box.height == 70


@assert_no_logs
def test_margin_boxes_fixed_dimension_9():
    # Rule 2 inhibits rule 6
    page, = render_pages('''
      <style>
        @page {
          margin: 100px;
          @bottom-center { content: ""; margin: auto 0; height: 150px }
        }
      </style>
    ''')
    html, margin_box = page.children
    assert margin_box.margin_height() == 100
    assert margin_box.margin_top == 0
    assert margin_box.margin_bottom == -50  # outside
    assert margin_box.height == 150


def images(*widths):
    return ' '.join(
        f'url(\'data:image/svg+xml,<svg width="{width}" height="10"></svg>\')'
        for width in widths)


@assert_no_logs
@pytest.mark.parametrize(('css', 'widths'), [
    ('''@top-left { content: %s }
        @top-center { content: %s }
        @top-right { content: %s }
     ''' % (images(50, 50), images(50, 50), images(50, 50)),
     [100, 100, 100]),  # Use preferred widths if they fit
    ('''@top-left { content: %s; margin: auto }
        @top-center { content: %s }
        @top-right { content: %s }
     ''' % (images(50, 50), images(50, 50), images(50, 50)),
     [100, 100, 100]),  # 'auto' margins are set to 0
    ('''@top-left { content: %s }
        @top-center { content: %s }
        @top-right { content: 'foo'; width: 200px }
     ''' % (images(100, 50), images(300, 150)),
     [150, 300, 200]),  # Use at least minimum widths, even if boxes overlap
    ('''@top-left { content: %s }
        @top-center { content: %s }
        @top-right { content: %s }
     ''' % (images(150, 150), images(150, 150), images(150, 150)),
     [200, 200, 200]),  # Distribute remaining space proportionally
    ('''@top-left { content: %s }
        @top-center { content: %s }
        @top-right { content: %s }
     ''' % (images(100, 100, 100), images(100, 100), images(10)),
     [220, 160, 10]),
    ('''@top-left { content: %s; width: 205px }
        @top-center { content: %s }
        @top-right { content: %s }
     ''' % (images(100, 100, 100), images(100, 100), images(10)),
     [205, 190, 10]),
    ('''@top-left { width: 1000px; margin: 1000px; padding: 1000px;
                    border: 1000px solid }
        @top-center { content: %s }
        @top-right { content: %s }
     ''' % (images(100, 100), images(10)),
     [200, 10]),  # 'width' and other have no effect without 'content'
    ('''@top-left { content: ''; width: 200px }
        @top-center { content: ''; width: 300px }
        @top-right { content: %s }
     ''' % images(50, 50),  # This leaves 150px for @top-right’s shrink-to-fit
     [200, 300, 100]),
    ('''@top-left { content: ''; width: 200px }
        @top-center { content: ''; width: 300px }
        @top-right { content: %s }
     ''' % images(100, 100, 100),
     [200, 300, 150]),
    ('''@top-left { content: ''; width: 200px }
        @top-center { content: ''; width: 300px }
        @top-right { content: %s }
     ''' % images(170, 175),
     [200, 300, 175]),
    ('''@top-left { content: ''; width: 200px }
        @top-right { content: ''; width: 500px }
     ''',
     [200, 500]),
    ('''@top-left { content: ''; width: 200px }
        @top-right { content: %s }
     ''' % images(150, 50, 150),
     [200, 350]),
    ('''@top-left { content: ''; width: 200px }
        @top-right { content: %s }
     ''' % images(150, 50, 150, 200),
     [200, 400]),
    ('''@top-left { content: %s }
        @top-right { content: ''; width: 200px }
     ''' % images(150, 50, 450),
     [450, 200]),
    ('''@top-left { content: %s }
        @top-right { content: %s }
     ''' % (images(150, 100), images(10, 120)),
     [250, 130]),
    ('''@top-left { content: %s }
        @top-right { content: %s }
     ''' % (images(550, 100), images(10, 120)),
     [550, 120]),
    ('''@top-left { content: %s }
        @top-right { content: %s }
     ''' % (images(250, 60), images(250, 180)),
     [275, 325]),  # 250 + (100 * 1 / 4), 250 + (100 * 3 / 4)
])
def test_page_style(css, widths):
    expected_at_keywords = [
        at_keyword for at_keyword in [
            '@top-left', '@top-center', '@top-right']
        if at_keyword + ' { content: ' in css]
    page, = render_pages('''
      <style>
        @page {
          size: 800px;
          margin: 100px;
          padding: 42px;
          border: 7px solid;
          %s
        }
      </style>
    ''' % css)
    assert page.children[0].element_tag == 'html'
    margin_boxes = page.children[1:]
    assert [box.at_keyword for box in margin_boxes] == expected_at_keywords
    offsets = {'@top-left': 0, '@top-center': 0.5, '@top-right': 1}
    for box in margin_boxes:
        assert box.position_x == 100 + offsets[box.at_keyword] * (
            600 - box.margin_width())
    assert [box.margin_width() for box in margin_boxes] == widths


@assert_no_logs
def test_margin_boxes_vertical_align():
    # 3 px ->    +-----+
    #            |  1  |
    #            +-----+
    #
    #        43 px ->   +-----+
    #        53 px ->   |  2  |
    #                   +-----+
    #
    #               83 px ->   +-----+
    #                          |  3  |
    #               103px ->   +-----+
    page, = render_pages('''
      <style>
        @page {
          size: 800px;
          margin: 106px;  /* margin boxes’ content height is 100px */

          @top-left {
            content: "foo"; line-height: 20px; border: 3px solid;
            vertical-align: top;
          }
          @top-center {
            content: "foo"; line-height: 20px; border: 3px solid;
            vertical-align: middle;
          }
          @top-right {
            content: "foo"; line-height: 20px; border: 3px solid;
            vertical-align: bottom;
          }
        }
      </style>
    ''')
    html, top_left, top_center, top_right = page.children
    line_1, = top_left.children
    line_2, = top_center.children
    line_3, = top_right.children
    assert line_1.position_y == 3
    assert line_2.position_y == 43
    assert line_3.position_y == 83


@assert_no_logs
def test_margin_boxes_element():
    pages = render_pages('''
      <style>
        @page {
          counter-increment: count;
          counter-reset: page pages;
          margin: 50px;
          size: 200px;
          @bottom-center {
            content: counter(page) ' of ' counter(pages)
                     ' (' counter(count) ')';
          }
        }
        h1 {
          height: 40px;
        }
      </style>
      <h1>test1</h1>
      <h1>test2</h1>
      <h1>test3</h1>
      <h1>test4</h1>
      <h1>test5</h1>
      <h1>test6</h1>
    ''')
    footer1_text = ''.join(
        getattr(node, 'text', '')
        for node in pages[0].children[1].descendants())
    assert footer1_text == '0 of 3 (1)'

    footer2_text = ''.join(
        getattr(node, 'text', '')
        for node in pages[1].children[1].descendants())
    assert footer2_text == '0 of 3 (2)'

    footer3_text = ''.join(
        getattr(node, 'text', '')
        for node in pages[2].children[1].descendants())
    assert footer3_text == '0 of 3 (3)'


@assert_no_logs
def test_margin_boxes_running_element():
    pages = render_pages('''
      <style>
        footer {
          position: running(footer);
        }
        @page {
          margin: 50px;
          size: 200px;
          @bottom-center {
            content: element(footer);
          }
        }
        body {
          font-size: 1px
        }
        h1 {
          height: 40px;
        }
        .pages:before {
          content: counter(page);
        }
        .pages:after {
          content: counter(pages);
        }
      </style>
      <footer class="pages"> of </footer>
      <h1>test1</h1>
      <h1>test2</h1>
      <h1>test3</h1>
      <h1>test4</h1>
      <h1>test5</h1>
      <h1>test6</h1>
      <footer>Static</footer>
    ''')
    footer1_text = ''.join(
        getattr(node, 'text', '')
        for node in pages[0].children[1].descendants())
    assert footer1_text == '1 of 3'

    footer2_text = ''.join(
        getattr(node, 'text', '')
        for node in pages[1].children[1].descendants())
    assert footer2_text == '2 of 3'

    footer3_text = ''.join(
        getattr(node, 'text', '')
        for node in pages[2].children[1].descendants())
    assert footer3_text == 'Static'


@assert_no_logs
@pytest.mark.parametrize(('argument', 'texts'), [
    # TODO: start doesn’t work because running elements are removed from the
    # original tree, and the current implentation in
    # layout.get_running_element_for uses the tree to know if it’s at the
    # beginning of the page

    # ('start', ('', '2-first', '2-last', '3-last', '5')),

    ('first', ('', '2-first', '3-first', '3-last', '5')),
    ('last', ('', '2-last', '3-last', '3-last', '5')),
    ('first-except', ('', '', '', '3-last', '')),
])
def test_running_elements(argument, texts):
    pages = render_pages('''
      <style>
        @page {
          margin: 50px;
          size: 200px;
          @bottom-center { content: element(title, %s) }
        }
        article { break-after: page }
        h1 { position: running(title) }
      </style>
      <article>
        <div>1</div>
      </article>
      <article>
        <h1>2-first</h1>
        <h1>2-last</h1>
      </article>
      <article>
        <p>3</p>
        <h1>3-first</h1>
        <h1>3-last</h1>
      </article>
      <article>
      </article>
      <article>
        <h1>5</h1>
      </article>
    ''' % argument)
    assert len(pages) == 5
    for page, text in zip(pages, texts):
        html, margin = page.children
        if margin.children:
            h1, = margin.children
            line, = h1.children
            textbox, = line.children
            assert textbox.text == text
        else:
            assert not text


@assert_no_logs
def test_running_elements_display():
    page, = render_pages('''
      <style>
        @page {
          margin: 50px;
          size: 200px;
          @bottom-left { content: element(inline) }
          @bottom-center { content: element(block) }
          @bottom-right { content: element(table) }
        }
        table { position: running(table) }
        div { position: running(block) }
        span { position: running(inline) }
      </style>
      text
      <table><tr><td>table</td></tr></table>
      <div>block</div>
      <span>inline</span>
    ''')
    html, left, center, right = page.children
    assert ''.join(
        getattr(node, 'text', '') for node in left.descendants()) == 'inline'
    assert ''.join(
        getattr(node, 'text', '') for node in center.descendants()) == 'block'
    assert ''.join(
        getattr(node, 'text', '') for node in right.descendants()) == 'table'


@assert_no_logs
def test_running_img():
    # Regression test.
    render_pages('''
      <style>
        img {
          position: running(img);
        }
        @page {
          @bottom-center {
            content: element(img);
          }
        }
      </style>
      <img src="pattern.png" />
    ''')


@assert_no_logs
def test_running_absolute():
    # Regression test for #1540.
    render_pages('''
      <style>
        footer {
          position: running(footer);
        }
        p {
          position: absolute;
        }
        @page {
          @bottom-center {
            content: element(footer);
          }
        }
      </style>
      <footer>Hello!<p>Bonjour!</p></footer>
    ''')


@assert_no_logs
def test_running_flex():
    # Regression test.
    render_pages('''
      <style>
        footer {
          display: flex;
          position: running(footer);
        }
        @page {
          @bottom-center {
            content: element(footer);
          }
        }
      </style>
      <footer>
        Hello!
      </footer>
    ''')


@assert_no_logs
def test_running_float():
    # Regression test.
    render_pages('''
      <style>
        footer {
          float: left;
          position: running(footer);
        }
        @page {
          @bottom-center {
            content: element(footer);
          }
        }
      </style>
      <footer>
        Hello!
      </footer>
    ''')


================================================
FILE: tests/layout/test_position.py
================================================
"""Tests for position property."""

import pytest

from ..testing_utils import assert_no_logs, render_pages


@assert_no_logs
def test_relative_positioning_1():
    page, = render_pages('''
      <style>
        p { height: 20px }
      </style>
      <p>1</p>
      <div style="position: relative; top: 10px">
        <p>2</p>
        <p style="position: relative; top: -5px; left: 5px">3</p>
        <p>4</p>
        <p style="position: relative; bottom: 5px; right: 5px">5</p>
        <p style="position: relative">6</p>
        <p>7</p>
      </div>
      <p>8</p>
    ''')
    html, = page.children
    body, = html.children
    p1, div, p8 = body.children
    p2, p3, p4, p5, p6, p7 = div.children
    assert (p1.position_x, p1.position_y) == (0, 0)
    assert (div.position_x, div.position_y) == (0, 30)
    assert (p2.position_x, p2.position_y) == (0, 30)
    assert (p3.position_x, p3.position_y) == (5, 45)  # (0 + 5, 50 - 5)
    assert (p4.position_x, p4.position_y) == (0, 70)
    assert (p5.position_x, p5.position_y) == (-5, 85)  # (0 - 5, 90 - 5)
    assert (p6.position_x, p6.position_y) == (0, 110)
    assert (p7.position_x, p7.position_y) == (0, 130)
    assert (p8.position_x, p8.position_y) == (0, 140)
    assert div.height == 120


@assert_no_logs
def test_relative_positioning_2():
    page, = render_pages('''
      <style>
        img { width: 20px }
        body { font-size: 0 } /* Remove spaces */
      </style>
      <body>
      <span><img src=pattern.png></span>
      <span style="position: relative; left: 10px">
        <img src=pattern.png>
        <img src=pattern.png
             style="position: relative; left: -5px; top: 5px">
        <img src=pattern.png>
        <img src=pattern.png
             style="position: relative; right: 5px; bottom: 5px">
        <img src=pattern.png style="position: relative">
        <img src=pattern.png>
      </span>
      <span><img src=pattern.png></span>
    ''')
    html, = page.children
    body, = html.children
    line, = body.children
    span1, span2, span3 = line.children
    img1, = span1.children
    img2, img3, img4, img5, img6, img7 = span2.children
    img8, = span3.children
    assert (img1.position_x, img1.position_y) == (0, 0)
    # Don't test the span2.position_y because it depends on fonts
    assert span2.position_x == 30
    assert (img2.position_x, img2.position_y) == (30, 0)
    assert (img3.position_x, img3.position_y) == (45, 5)  # (50 - 5, y + 5)
    assert (img4.position_x, img4.position_y) == (70, 0)
    assert (img5.position_x, img5.position_y) == (85, -5)  # (90 - 5, y - 5)
    assert (img6.position_x, img6.position_y) == (110, 0)
    assert (img7.position_x, img7.position_y) == (130, 0)
    assert (img8.position_x, img8.position_y) == (140, 0)
    assert span2.width == 120


@assert_no_logs
def test_relative_positioning_3():
    page, = render_pages('''
      <style>
        img { width: 20px }
        body { font-size: 0 } /* Remove spaces */
      </style>
      <body>
      <span><img src=pattern.png></span>
      <span style="position: relative; left: 10px; right: 5px
        "><img src=pattern.png></span>
      <span><img src=pattern.png></span>
    ''')
    html, = page.children
    body, = html.children
    line, = body.children
    span1, span2, span3 = line.children
    assert span2.position_x == 20 + 10


@assert_no_logs
def test_relative_positioning_4():
    page, = render_pages('''
      <style>
        img { width: 20px }
        body { direction: rtl; width: 100px;
               font-size: 0 } /* Remove spaces */
      </style>
      <body>
      <span><img src=pattern.png></span>
      <span style="position: relative; left: 10px; right: 5px
        "><img src=pattern.png></span>
      <span><img src=pattern.png></span>
    ''')
    html, = page.children
    body, = html.children
    line, = body.children
    span1, span2, span3 = line.children
    assert span2.position_x == 100 - 20 - 5 - 20


@assert_no_logs
def test_absolute_positioning_1():
    page, = render_pages('''
      <div style="margin: 3px">
        <div style="height: 20px; width: 20px; position: absolute"></div>
        <div style="height: 20px; width: 20px; position: absolute;
                    left: 0"></div>
        <div style="height: 20px; width: 20px; position: absolute;
                    top: 0"></div>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div1, = body.children
    div2, div3, div4 = div1.children
    assert div1.height == 0
    assert (div1.position_x, div1.position_y) == (0, 0)
    assert (div2.width, div2.height) == (20, 20)
    assert (div2.position_x, div2.position_y) == (3, 3)
    assert (div3.width, div3.height) == (20, 20)
    assert (div3.position_x, div3.position_y) == (0, 3)
    assert (div4.width, div4.height) == (20, 20)
    assert (div4.position_x, div4.position_y) == (3, 0)


@assert_no_logs
def test_absolute_positioning_2():
    page, = render_pages('''
      <div style="position: relative; width: 20px">
        <div style="height: 20px; width: 20px; position: absolute"></div>
        <div style="height: 20px; width: 20px"></div>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div1, = body.children
    div2, div3 = div1.children
    for div in (div1, div2, div3):
        assert (div.position_x, div.position_y) == (0, 0)
        assert (div.width, div.height) == (20, 20)


@assert_no_logs
def test_absolute_positioning_3():
    page, = render_pages('''
      <body style="font-size: 0">
        <img src=pattern.png>
        <span style="position: relative">
          <span style="position: absolute">2</span>
          <span style="position: absolute">3</span>
          <span>4</span>
        </span>
    ''')
    html, = page.children
    body, = html.children
    line, = body.children
    img, span1 = line.children
    span2, span3, span4 = span1.children
    assert span1.position_x == 4
    assert (span2.position_x, span2.position_y) == (4, 0)
    assert (span3.position_x, span3.position_y) == (4, 0)
    assert span4.position_x == 4


@assert_no_logs
def test_absolute_positioning_4():
    page, = render_pages('''
      <style> img { width: 5px; height: 20px} </style>
      <body style="font-size: 0">
        <img src=pattern.png>
        <span style="position: absolute">2</span>
        <img src=pattern.png>
    ''')
    html, = page.children
    body, = html.children
    line, = body.children
    img1, span, img2 = line.children
    assert (img1.position_x, img1.position_y) == (0, 0)
    assert (span.position_x, span.position_y) == (5, 0)
    assert (img2.position_x, img2.position_y) == (5, 0)


@assert_no_logs
def test_absolute_positioning_5():
    page, = render_pages('''
      <style> img { width: 5px; height: 20px} </style>
      <body style="font-size: 0">
        <img src=pattern.png>
        <span style="position: absolute; display: block">2</span>
        <img src=pattern.png>
    ''')
    html, = page.children
    body, = html.children
    line, = body.children
    img1, span, img2 = line.children
    assert (img1.position_x, img1.position_y) == (0, 0)
    assert (span.position_x, span.position_y) == (0, 20)
    assert (img2.position_x, img2.position_y) == (5, 0)


@assert_no_logs
def test_absolute_positioning_6():
    page, = render_pages('''
      <div style="position: relative; width: 20px; height: 60px;
                  border: 10px solid; padding-top: 6px; top: 5px; left: 1px">
        <div style="height: 20px; width: 20px; position: absolute;
                    bottom: 50%"></div>
        <div style="height: 20px; width: 20px; position: absolute;
                    top: 13px"></div>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div1, = body.children
    div2, div3 = div1.children
    assert (div1.position_x, div1.position_y) == (1, 5)
    assert (div1.width, div1.height) == (20, 60)
    assert (div1.border_width(), div1.border_height()) == (40, 86)
    assert (div2.position_x, div2.position_y) == (11, 28)
    assert (div2.width, div2.height) == (20, 20)
    assert (div3.position_x, div3.position_y) == (11, 28)
    assert (div3.width, div3.height) == (20, 20)


@assert_no_logs
def test_absolute_positioning_7():
    page, = render_pages('''
      <style>
        @page { size: 1000px 2000px }
        html { font-size: 0 }
        p { height: 20px }
      </style>
      <p>1</p>
      <div style="width: 100px">
        <p>2</p>
        <p style="position: absolute; top: -5px; left: 5px">3</p>
        <p style="margin: 3px">4</p>
        <p style="position: absolute; bottom: 5px; right: 15px;
                  width: 50px; height: 10%;
                  padding: 3px; margin: 7px">5
          <span>
            <img src="pattern.png">
            <span style="position: absolute"></span>
            <span style="position: absolute; top: -10px; right: 5px;
                         width: 20px; height: 15px"></span>
          </span>
        </p>
        <p style="margin-top: 8px">6</p>
      </div>
      <p>7</p>
    ''')
    html, = page.children
    body, = html.children
    p1, div, p7 = body.children
    p2, p3, p4, p5, p6 = div.children
    line, = p5.children
    span1, = line.children
    img, span2, span3 = span1.children
    assert (p1.position_x, p1.position_y) == (0, 0)
    assert (div.position_x, div.position_y) == (0, 20)
    assert (p2.position_x, p2.position_y) == (0, 20)
    assert (p3.position_x, p3.position_y) == (5, -5)
    assert (p4.position_x, p4.position_y) == (0, 40)
    # p5 x = page width - right - margin/padding/border - width
    #      = 1000       - 15    - 2 * 10                - 50
    #      = 915
    # p5 y = page height - bottom - margin/padding/border - height
    #      = 2000        - 5      - 2 * 10                - 200
    #      = 1775
    assert (p5.position_x, p5.position_y) == (915, 1775)
    assert (img.position_x, img.position_y) == (925, 1785)
    assert (span2.position_x, span2.position_y) == (929, 1785)
    # span3 x = p5 right - p5 margin - span width - span right
    #         = 985      - 7         - 20         - 5
    #         = 953
    # span3 y = p5 y + p5 margin top + span top
    #         = 1775 + 7             + -10
    #         = 1772
    assert (span3.position_x, span3.position_y) == (953, 1772)
    # p6 y = p4 y + p4 margin height - margin collapsing
    #      = 40   + 26               - 3
    #      = 63
    assert (p6.position_x, p6.position_y) == (0, 63)
    assert div.height == 71  # 20*3 + 2*3 + 8 - 3
    assert (p7.position_x, p7.position_y) == (0, 91)


@assert_no_logs
def test_absolute_positioning_8():
    # Regression test for #1264.
    page, = render_pages('''
      <style>@page{ width: 50px; height: 50px }</style>
      <body style="font-size: 0">
        <div style="position: absolute; margin: auto;
                    left: 0; right: 10px;
                    top: 0; bottom: 10px;
                    width: 10px; height: 20px">
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert (div.content_box_x(), div.content_box_y()) == (15, 10)
    assert (div.width, div.height) == (10, 20)


@assert_no_logs
def test_absolute_images():
    page, = render_pages('''
      <style>
        @page { size: 50px; }
        img { display: block; position: absolute }
      </style>
      <div style="margin: 10px">
        <img src=pattern.png />
        <img src=pattern.png style="left: 15px" />
        <img src=pattern.png style="top: 15px" />
        <img src=pattern.png style="bottom: 25px" />
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    img1, img2, img3, img4 = div.children
    assert div.height == 0
    assert (div.position_x, div.position_y) == (0, 0)
    assert (img1.position_x, img1.position_y) == (10, 10)
    assert (img1.width, img1.height) == (4, 4)
    assert (img2.position_x, img2.position_y) == (15, 10)
    assert (img2.width, img2.height) == (4, 4)
    assert (img3.position_x, img3.position_y) == (10, 15)
    assert (img3.width, img3.height) == (4, 4)
    assert (img4.position_x, img4.position_y) == (10, 21)  # (50 - 4) - 25
    assert (img4.width, img4.height) == (4, 4)

    # TODO: test the various cases in absolute_replaced()


@assert_no_logs
def test_fixed_positioning():
    # TODO:test page-break-before: left/right
    page_1, page_2, page_3 = render_pages('''
      a
      <div style="page-break-before: always; page-break-after: always">
        <p style="position: fixed">b</p>
      </div>
      c
    ''')
    html, = page_1.children
    assert [c.element_tag for c in html.children] == ['body', 'p']
    html, = page_2.children
    body, = html.children
    div, = body.children
    assert [c.element_tag for c in div.children] == ['p']
    html, = page_3.children
    assert [c.element_tag for c in html.children] == ['p', 'body']


@assert_no_logs
def test_fixed_positioning_regression_1():
    # Regression test for #641.
    page_1, page_2 = render_pages('''
      <style>
        @page:first { size: 100px 200px }
        @page { size: 200px 100px; margin: 0 }
        article { break-after: page }
        .fixed { position: fixed; top: 10px; width: 20px }
      </style>
      <ul class="fixed" style="right: 0"><li>a</li></ul>
      <img class="fixed" style="right: 20px" src="pattern.png" />
      <div class="fixed" style="right: 40px">b</div>
      <article>page1</article>
      <article>page2</article>
    ''')

    html, = page_1.children
    body, = html.children
    ul, img, div, article = body.children
    marker = ul.children[0]
    assert (ul.position_x, ul.position_y) == (80, 10)
    assert (img.position_x, img.position_y) == (60, 10)
    assert (div.position_x, div.position_y) == (40, 10)
    assert (article.position_x, article.position_y) == (0, 0)
    assert marker.position_x == ul.position_x

    html, = page_2.children
    ul, img, div, body = html.children
    marker = ul.children[0]
    assert (ul.position_x, ul.position_y) == (180, 10)
    assert (img.position_x, img.position_y) == (160, 10)
    assert (div.position_x, div.position_y) == (140, 10)
    assert (article.position_x, article.position_y) == (0, 0)
    assert marker.position_x == ul.position_x


@assert_no_logs
def test_fixed_positioning_regression_2():
    # Regression test for #728.
    page_1, page_2 = render_pages('''
      <style>
        @page { size: 100px 100px }
        section { break-after: page }
        .fixed { position: fixed; top: 10px; left: 15px; width: 20px }
      </style>
      <div class="fixed">
        <article class="fixed" style="top: 20px">
          <header class="fixed" style="left: 5px"></header>
        </article>
      </div>
      <section></section>
      <pre></pre>
    ''')
    html, = page_1.children
    body, = html.children
    div, section = body.children
    assert (div.position_x, div.position_y) == (15, 10)
    article, = div.children
    assert (article.position_x, article.position_y) == (15, 20)
    header, = article.children
    assert (header.position_x, header.position_y) == (5, 10)

    html, = page_2.children
    div, body, = html.children
    assert (div.position_x, div.position_y) == (15, 10)
    article, = div.children
    assert (article.position_x, article.position_y) == (15, 20)
    header, = article.children
    assert (header.position_x, header.position_y) == (5, 10)


@assert_no_logs
def test_flex_relative_positioning():
    page, = render_pages('''
      <style>
        @page { size: 100px 100px }
        article { display: flex }
        .box { width: 20px; height: 20px }
        .relative { position: relative; top: 10px; left: 10px }
      </style>
      <article>
        <div class="box"></div>
        <div class="box relative"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2 = article.children

    assert (div2.position_x, div2.position_y) == (30, 10)


@assert_no_logs
def test_grid_relative_positioning():
    page, = render_pages('''
      <style>
        @page { size: 100px 100px }
        article { display: grid; grid-template-columns: 20px 20px }
        .box { width: 20px; height: 20px }
        .relative { position: relative; top: 10px; left: 10px }
      </style>
      <article>
        <div class="box"></div>
        <div class="box relative"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2 = article.children

    assert (div2.position_x, div2.position_y) == (30, 10)


@assert_no_logs
@pytest.mark.xfail
def test_flex_absolute_positioning():
    """TODO: Order is not kept when out-of-flow and in-flow children are mixed."""
    page, = render_pages('''
      <style>
        @page { size: 100px 100px }
        article { display: flex; position: relative }
        .box { width: 20px; height: 20px }
        .absolute { position: absolute; top: 10px; left: 10px }
      </style>
      <article>
        <div class="box"></div>
        <div class="box absolute"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    # That’s currently div2, div1
    div1, div2 = article.children

    assert (div2.position_x, div2.position_y) == (10, 10)


@assert_no_logs
@pytest.mark.xfail
def test_grid_absolute_positioning():
    """TODO: Absolutely positioned grid items are not replaced by placeholders ."""
    page, = render_pages('''
      <style>
        @page { size: 100px 100px }
        article { display: grid; grid-template-columns: 20px 20px; position: relative }
        .box { width: 20px; height: 20px }
        .absolute { position: absolute; top: 10px; left: 10px }
      </style>
      <article>
        <div class="box"></div>
        <div class="box absolute"></div>
      </article>
    ''')
    html, = page.children
    body, = html.children
    article, = body.children
    div1, div2 = article.children

    assert (div1.position_x, div1.position_y) == (10, 10)


================================================
FILE: tests/layout/test_preferred.py
================================================
"""Tests for shrink-to-fit algorithm."""

import pytest

from ..testing_utils import assert_no_logs, render_pages


@assert_no_logs
@pytest.mark.parametrize('margin_left', range(1, 10))
@pytest.mark.parametrize('font_size', range(1, 10))
def test_shrink_to_fit_floating_point_error_1(margin_left, font_size):
    # See bugs #325 and #288, see commit fac5ee9.
    page, = render_pages('''
      <style>
        @page { size: 100000px 100px }
        p { float: left; margin-left: 0.%din; font-size: 0.%dem;
            font-family: weasyprint }
      </style>
      <p>this parrot is dead</p>
    ''' % (margin_left, font_size))
    html, = page.children
    body, = html.children
    p, = body.children
    assert len(p.children) == 1


@assert_no_logs
@pytest.mark.parametrize('font_size', [1, 5, 10, 50, 100, 1000, 10000])
def test_shrink_to_fit_floating_point_error_2(font_size):
    letters = 1
    while True:
        page, = render_pages('''
          <style>
            @page { size: %d0pt %d0px }
            p { font-size: %dpt; font-family: weasyprint }
          </style>
          <p>mmm <b>%s a</b></p>
        ''' % (font_size, font_size, font_size, 'i' * letters))
        html, = page.children
        body, = html.children
        p, = body.children
        assert len(p.children) in (1, 2)
        assert len(p.children[0].children) == 2
        text = p.children[0].children[1].children[0].text
        assert text
        if text.endswith('i'):
            letters = 1
            break
        else:
            letters += 1


@assert_no_logs
def test_preferred_inline_zero_width_inline_block():
    page, = render_pages('''
      <style>
        div { font: 2px weasyprint; float: left }
      </style>
      <div><span style="display: inline-block"></span> a</div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.width == 4
    assert div.height == 2


@assert_no_logs
def test_preferred_inline_nested_trailing_spaces():
    page, = render_pages('''
      <style>
        div { font: 2px weasyprint; float: left }
      </style>
      <div><span>a </span> </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.width == 2
    assert div.height == 2


@assert_no_logs
def test_preferred_inline_trailing_space_in_nested():
    page, = render_pages('''
      <style>
        div { font: 2px weasyprint; float: left }
      </style>
      <div><span style="display: inline-block"></span><span><span>a</span> </span></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert div.width == 2
    assert div.height == 2


================================================
FILE: tests/layout/test_table.py
================================================
"""Tests for layout of tables."""

import pytest

from weasyprint.formatting_structure import boxes
from weasyprint.layout.table import collapse_table_borders

from ..testing_utils import assert_no_logs, capture_logs, parse_all, render_pages


def _get_grid(html, grid_width, grid_height):
    html = parse_all(html)
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    border_lists = collapse_table_borders(table, grid_width, grid_height)
    return tuple(
        [[(style, width, color) if width else None
          for _score, (style, width, color) in border]
         for border in border_list]
        for border_list in border_lists)


@assert_no_logs
def test_inline_table():
    page, = render_pages('''
      <table style="display: inline-table; border-spacing: 10px; margin: 5px">
        <tr>
          <td><img src=pattern.png style="width: 20px"></td>
          <td><img src=pattern.png style="width: 30px"></td>
        </tr>
      </table>
      foo
    ''')
    html, = page.children
    body, = html.children
    line, = body.children
    table_wrapper, text = line.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 5  # 0 + margin-left
    assert td_1.position_x == 15  # 0 + border-spacing
    assert td_1.width == 20
    assert td_2.position_x == 45  # 15 + 20 + border-spacing
    assert td_2.width == 30
    assert table.width == 80  # 20 + 30 + 3 * border-spacing
    assert table_wrapper.margin_width() == 90  # 80 + 2 * margin
    assert text.position_x == 90


@assert_no_logs
def test_inline_table_width():
    page, = render_pages('''
      <div style="font: 2px weasyprint; width: 20px">
        <table style="display: inline-table; width: 20%"><tr><td>A</tr></td></table>
        <table style="display: inline-table; width: 20%"><tr><td>B</tr></td></table>
      </div>''')
    html, = page.children
    body, = html.children
    div, = body.children
    line, = div.children
    table_wrapper1, space, table_wrapper2, tail = line.children
    assert table_wrapper1.width == table_wrapper2.width == 4
    assert table_wrapper1.position_x == 0
    assert table_wrapper2.position_x == 6


@assert_no_logs
def test_implicit_width_table_col_percent():
    # Regression test for #169.
    page, = render_pages('''
      <table>
        <col style="width:25%"></col>
        <col></col>
        <tr>
          <td></td>
          <td></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children


@assert_no_logs
def test_implicit_width_table_td_percent():
    page, = render_pages('''
      <table>
        <tr>
          <td style="width:25%"></td>
          <td></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children


@assert_no_logs
def test_layout_table_fixed_1():
    page, = render_pages('''
      <table style="table-layout: fixed; border-spacing: 10px; margin: 5px">
        <colgroup>
          <col style="width: 20px" />
        </colgroup>
        <tr>
          <td></td>
          <td style="width: 40px">a</td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 5  # 0 + margin-left
    assert td_1.position_x == 15  # 5 + border-spacing
    assert td_1.width == 20
    assert td_2.position_x == 45  # 15 + 20 + border-spacing
    assert td_2.width == 40
    assert table.width == 90  # 20 + 40 + 3 * border-spacing


@assert_no_logs
def test_layout_table_fixed_2():
    page, = render_pages('''
      <table style="table-layout: fixed; border-spacing: 10px; width: 200px;
                    margin: 5px">
        <tr>
          <td style="width: 20px">a</td>
          <td style="width: 40px"></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 5  # 0 + margin-left
    assert td_1.position_x == 15  # 5 + border-spacing
    assert td_1.width == 75  # 20 + ((200 - 20 - 40 - 3 * border-spacing) / 2)
    assert td_2.position_x == 100  # 15 + 75 + border-spacing
    assert td_2.width == 95  # 40 + ((200 - 20 - 40 - 3 * border-spacing) / 2)
    assert table.width == 200


@assert_no_logs
def test_layout_table_fixed_3():
    page, = render_pages('''
      <table style="table-layout: fixed; border-spacing: 10px;
                    width: 110px; margin: 5px">
        <tr>
          <td style="width: 40px">a</td>
          <td>b</td>
        </tr>
        <tr>
          <td style="width: 50px">a</td>
          <td style="width: 30px">b</td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row_1, row_2 = row_group.children
    td_1, td_2 = row_1.children
    td_3, td_4 = row_2.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 5  # 0 + margin-left
    assert td_1.position_x == 15  # 0 + border-spacing
    assert td_3.position_x == 15
    assert td_1.width == 40
    assert td_2.width == 40
    assert td_2.position_x == 65  # 15 + 40 + border-spacing
    assert td_4.position_x == 65
    assert td_3.width == 40
    assert td_4.width == 40
    assert table.width == 110  # 20 + 40 + 3 * border-spacing


@assert_no_logs
def test_layout_table_fixed_4():
    page, = render_pages('''
      <table style="table-layout: fixed; border-spacing: 0;
                    width: 100px; margin: 10px">
        <colgroup>
          <col />
          <col style="width: 20px" />
        </colgroup>
        <tr>
          <td></td>
          <td style="width: 40px">a</td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 10  # 0 + margin-left
    assert td_1.position_x == 10
    assert td_1.width == 80  # 100 - 20
    assert td_2.position_x == 90  # 10 + 80
    assert td_2.width == 20
    assert table.width == 100


@assert_no_logs
def test_layout_table_fixed_5():
    # With border-collapse
    page, = render_pages('''
      <style>
        /* Do not apply: */
        colgroup, col, tbody, tr, td { margin: 1000px }
      </style>
      <table style="table-layout: fixed;
                    border-collapse: collapse; border: 10px solid;
                    /* ignored with collapsed borders: */
                    border-spacing: 10000px; padding: 1000px">
        <colgroup>
          <col style="width: 30px" />
        </colgroup>
        <tbody>
          <tr>
            <td style="padding: 2px"></td>
            <td style="width: 34px; padding: 10px; border: 2px solid"></td>
          </tr>
        </tbody>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 0
    assert table.border_left_width == 5  # half of the collapsed 10px border
    assert td_1.position_x == 5  # border-spacing is ignored
    assert td_1.margin_width() == 30  # as <col>
    assert td_1.width == 20  # 30 - 5 (border-left) - 1 (border-right) - 2*2
    assert td_2.position_x == 35
    assert td_2.width == 34
    assert td_2.margin_width() == 60  # 34 + 2*10 + 5 + 1
    assert table.width == 90  # 30 + 60
    assert table.margin_width() == 100  # 90 + 2*5 (border)


@assert_no_logs
def test_layout_table_auto_1():
    page, = render_pages('''
      <body style="width: 100px">
      <table style="border-spacing: 10px; margin: auto">
        <tr>
          <td><img src=pattern.png></td>
          <td><img src=pattern.png></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert table_wrapper.position_x == 0
    assert table_wrapper.width == 38  # Same as table, see below
    assert table_wrapper.margin_left == 31  # 0 + margin-left = (100 - 38) / 2
    assert table_wrapper.margin_right == 31
    assert table.position_x == 31
    assert td_1.position_x == 41  # 31 + spacing
    assert td_1.width == 4
    assert td_2.position_x == 55  # 31 + 4 + spacing
    assert td_2.width == 4
    assert table.width == 38  # 3 * spacing + 2 * 4


@assert_no_logs
def test_layout_table_auto_2():
    page, = render_pages('''
      <body style="width: 50px">
      <table style="border-spacing: 1px; margin: 10%">
        <tr>
          <td style="border: 3px solid black"><img src=pattern.png></td>
          <td style="border: 3px solid black">
            <img src=pattern.png><img src=pattern.png>
          </td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 5  # 0 + margin-left
    assert td_1.position_x == 6  # 5 + border-spacing
    assert td_1.width == 4
    assert td_2.position_x == 17  # 6 + 4 + spacing + 2 * border
    assert td_2.width == 8
    assert table.width == 27  # 3 * spacing + 4 + 8 + 4 * border


@assert_no_logs
def test_layout_table_auto_3():
    page, = render_pages('''
      <table style="border-spacing: 1px; margin: 5px; font-size: 0">
        <tr>
          <td></td>
          <td><img src=pattern.png><img src=pattern.png></td>
        </tr>
        <tr>
          <td>
            <img src=pattern.png>
            <img src=pattern.png>
            <img src=pattern.png>
          </td>
          <td><img src=pattern.png></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row1, row2 = row_group.children
    td_11, td_12 = row1.children
    td_21, td_22 = row2.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 5  # 0 + margin-left
    assert td_11.position_x == td_21.position_x == 6  # 5 + spacing
    assert td_11.width == td_21.width == 12
    assert td_12.position_x == td_22.position_x == 19  # 6 + 12 + spacing
    assert td_12.width == td_22.width == 8
    assert table.width == 23  # 3 * spacing + 12 + 8


@assert_no_logs
def test_layout_table_auto_4():
    page, = render_pages('''
      <table style="border-spacing: 1px; margin: 5px">
        <tr>
          <td style="border: 1px solid black"><img src=pattern.png></td>
          <td style="border: 2px solid black; padding: 1px">
            <img src=pattern.png>
          </td>
        </tr>
        <tr>
          <td style="border: 5px solid black"><img src=pattern.png></td>
          <td><img src=pattern.png></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row1, row2 = row_group.children
    td_11, td_12 = row1.children
    td_21, td_22 = row2.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 5  # 0 + margin-left
    assert td_11.position_x == td_21.position_x == 6  # 5 + spacing
    assert td_11.width == 12  # 4 + 2 * 5 - 2 * 1
    assert td_21.width == 4
    assert td_12.position_x == td_22.position_x == 21  # 6 + 4 + 2 * b1 + sp
    assert td_12.width == 4
    assert td_22.width == 10  # 4 + 2 * 3
    assert table.width == 27  # 3 * spacing + 4 + 4 + 2 * b1 + 2 * b2


@assert_no_logs
def test_layout_table_auto_5():
    page, = render_pages('''
      <table style="width: 1000px; font-family: weasyprint">
        <tr>
          <td style="width: 40px">aa aa aa aa</td>
          <td style="width: 40px">aaaaaaaaaaa</td>
          <td>This will take the rest of the width</td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2, td_3 = row.children

    assert table.width == 1000
    assert td_1.width == 40
    assert td_2.width == 11 * 16
    assert td_3.width == 1000 - 40 - 11 * 16


@assert_no_logs
def test_layout_table_auto_6():
    page, = render_pages('''
      <style>
        @page { size: 100px 1000px; }
      </style>
      <table style="border-spacing: 1px; margin-right: 79px; font-size: 0">
        <tr>
          <td><img src=pattern.png></td>
          <td>
            <img src=pattern.png> <img src=pattern.png>
            <img src=pattern.png> <img src=pattern.png>
            <img src=pattern.png> <img src=pattern.png>
            <img src=pattern.png> <img src=pattern.png>
            <img src=pattern.png>
          </td>
        </tr>
        <tr>
          <td></td>
        </tr>
      </table>
    ''')
    # Preferred minimum width is 2 * 4 + 3 * 1 = 11
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row1, row2 = row_group.children
    td_11, td_12 = row1.children
    td_21, = row2.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 0
    assert td_11.position_x == td_21.position_x == 1  # spacing
    assert td_11.width == td_21.width == 4  # minimum width
    assert td_12.position_x == 6  # 1 + 5 + sp
    assert td_12.width == 14  # available width
    assert table.width == 21


@assert_no_logs
def test_layout_table_auto_7():
    page, = render_pages('''
      <table style="border-spacing: 10px; margin: 5px">
        <colgroup>
          <col style="width: 20px" />
        </colgroup>
        <tr>
          <td></td>
          <td style="width: 40px">a</td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 5  # 0 + margin-left
    assert td_1.position_x == 15  # 0 + border-spacing
    assert td_1.width == 20
    assert td_2.position_x == 45  # 15 + 20 + border-spacing
    assert td_2.width == 40
    assert table.width == 90  # 20 + 40 + 3 * border-spacing


@assert_no_logs
def test_layout_table_auto_8():
    page, = render_pages('''
      <table style="border-spacing: 10px; width: 120px; margin: 5px;
                    font-size: 0">
        <tr>
          <td style="width: 20px"><img src=pattern.png></td>
          <td><img src=pattern.png style="width: 40px"></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 5  # 0 + margin-left
    assert td_1.position_x == 15  # 5 + border-spacing
    assert td_1.width == 20  # fixed
    assert td_2.position_x == 45  # 15 + 20 + border-spacing
    assert td_2.width == 70  # 120 - 3 * border-spacing - 20
    assert table.width == 120


@assert_no_logs
def test_layout_table_auto_9():
    page, = render_pages('''
      <table style="border-spacing: 10px; width: 120px; margin: 5px">
        <tr>
          <td style="width: 60px"></td>
          <td></td>
        </tr>
        <tr>
          <td style="width: 50px"></td>
          <td style="width: 30px"></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row_1, row_2 = row_group.children
    td_1, td_2 = row_1.children
    td_3, td_4 = row_2.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 5  # 0 + margin-left
    assert td_1.position_x == 15  # 0 + border-spacing
    assert td_3.position_x == 15
    assert td_1.width == 60
    assert td_2.width == 30
    assert td_2.position_x == 85  # 15 + 60 + border-spacing
    assert td_4.position_x == 85
    assert td_3.width == 60
    assert td_4.width == 30
    assert table.width == 120  # 60 + 30 + 3 * border-spacing


@assert_no_logs
def test_layout_table_auto_10():
    page, = render_pages('''
      <table style="border-spacing: 0; width: 14px; margin: 10px">
        <colgroup>
          <col />
          <col style="width: 6px" />
        </colgroup>
        <tr>
          <td><img src=pattern.png><img src=pattern.png></td>
          <td style="width: 8px"></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 10  # 0 + margin-left
    assert td_1.position_x == 10
    assert td_1.width == 6  # 14 - 8
    assert td_2.position_x == 16  # 10 + 6
    assert td_2.width == 8  # maximum of the minimum widths for the column
    assert table.width == 14


@assert_no_logs
def test_layout_table_auto_11():
    page, = render_pages('''
      <table style="border-spacing: 0">
        <tr>
          <td style="width: 10px"></td>
          <td colspan="3"></td>
        </tr>
        <tr>
          <td colspan="2" style="width: 22px"></td>
          <td style="width: 8px"></td>
          <td style="width: 8px"></td>
        </tr>
        <tr>
          <td></td>
          <td></td>
          <td colspan="2"></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row1, row2, row3 = row_group.children
    td_11, td_12 = row1.children
    td_21, td_22, td_23 = row2.children
    td_31, td_32, td_33 = row3.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 0
    assert td_11.width == 10  # fixed
    assert td_12.width == 28  # 38 - 10
    assert td_21.width == 22  # fixed
    assert td_22.width == 8  # fixed
    assert td_23.width == 8  # fixed
    assert td_31.width == 10  # same as first line
    assert td_32.width == 12  # 22 - 10
    assert td_33.width == 16  # 8 + 8 from second line
    assert table.width == 38


@assert_no_logs
def test_layout_table_auto_12():
    page, = render_pages('''
      <table style="border-spacing: 10px">
        <tr>
          <td style="width: 10px"></td>
          <td colspan="3"></td>
        </tr>
        <tr>
          <td colspan="2" style="width: 32px"></td>
          <td style="width: 8px"></td>
          <td style="width: 8px"></td>
        </tr>
        <tr>
          <td></td>
          <td></td>
          <td colspan="2"></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row1, row2, row3 = row_group.children
    td_11, td_12 = row1.children
    td_21, td_22, td_23 = row2.children
    td_31, td_32, td_33 = row3.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 0
    assert td_11.width == 10  # fixed
    assert td_12.width == 48  # 32 - 10 - sp + 2 * 8 + 2 * sp
    assert td_21.width == 32  # fixed
    assert td_22.width == 8  # fixed
    assert td_23.width == 8  # fixed
    assert td_31.width == 10  # same as first line
    assert td_32.width == 12  # 32 - 10 - sp
    assert td_33.width == 26  # 2 * 8 + sp
    assert table.width == 88


@assert_no_logs
def test_layout_table_auto_13():
    # Regression test.
    page, = render_pages('''
      <table style="width: 30px">
        <tr>
          <td colspan=2></td>
          <td></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert td_1.width == 20  # 2 / 3 * 30
    assert td_2.width == 10  # 1 / 3 * 30
    assert table.width == 30


@assert_no_logs
def test_layout_table_auto_14():
    page, = render_pages('''
      <table style="width: 20px">
        <col />
        <col />
        <tr>
          <td></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, = row.children
    assert td_1.width == 20
    assert table.width == 20


@assert_no_logs
def test_layout_table_auto_15():
    page, = render_pages('''
      <table style="width: 20px">
        <col />
        <col />
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    column_group, = table.column_groups
    column_1, column_2 = column_group.children
    assert column_1.width == 0
    assert column_2.width == 0


@assert_no_logs
def test_layout_table_auto_16():
    # Absolute table
    page, = render_pages('''
      <table style="width: 30px; position: absolute">
        <tr>
          <td colspan=2></td>
          <td></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert td_1.width == 20  # 2 / 3 * 30
    assert td_2.width == 10  # 1 / 3 * 30
    assert table.width == 30


@assert_no_logs
def test_layout_table_auto_17():
    # With border-collapse
    page, = render_pages('''
      <style>
        /* Do not apply: */
        colgroup, col, tbody, tr, td { margin: 1000px }
      </style>
      <table style="border-collapse: collapse; border: 10px solid;
                    /* ignored with collapsed borders: */
                    border-spacing: 10000px; padding: 1000px">
        <colgroup>
          <col style="width: 30px" />
        </colgroup>
        <tbody>
          <tr>
            <td style="padding: 2px"></td>
            <td style="width: 34px; padding: 10px; border: 2px solid"></td>
          </tr>
        </tbody>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert table_wrapper.position_x == 0
    assert table.position_x == 0
    assert table.border_left_width == 5  # half of the collapsed 10px border
    assert td_1.position_x == 5  # border-spacing is ignored
    assert td_1.margin_width() == 30  # as <col>
    assert td_1.width == 20  # 30 - 5 (border-left) - 1 (border-right) - 2*2
    assert td_2.position_x == 35
    assert td_2.width == 34
    assert td_2.margin_width() == 60  # 34 + 2*10 + 5 + 1
    assert table.width == 90  # 30 + 60
    assert table.margin_width() == 100  # 90 + 2*5 (border)


@assert_no_logs
def test_layout_table_auto_18():
    # Column widths as percentage
    page, = render_pages('''
      <table style="width: 200px">
        <colgroup>
          <col style="width: 70%" />
          <col style="width: 30%" />
        </colgroup>
        <tbody>
          <tr>
            <td>a</td>
            <td>abc</td>
          </tr>
        </tbody>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert td_1.width == 140
    assert td_2.width == 60
    assert table.width == 200


@assert_no_logs
def test_layout_table_auto_19():
    # Column group width
    page, = render_pages('''
      <table style="width: 200px">
        <colgroup style="width: 100px">
          <col />
          <col />
        </colgroup>
        <col style="width: 100px" />
        <tbody>
          <tr>
            <td>a</td>
            <td>a</td>
            <td>abc</td>
          </tr>
        </tbody>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2, td_3 = row.children
    assert td_1.width == 100
    assert td_2.width == 100
    assert td_3.width == 100
    assert table.width == 300


@assert_no_logs
def test_layout_table_auto_20():
    # Multiple column width
    page, = render_pages('''
      <table style="width: 200px">
        <colgroup>
          <col style="width: 50px" />
          <col style="width: 30px" />
          <col />
        </colgroup>
        <tbody>
          <tr>
            <td>a</td>
            <td>a</td>
            <td>abc</td>
          </tr>
        </tbody>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2, td_3 = row.children
    assert td_1.width == 50
    assert td_2.width == 30
    assert td_3.width == 120
    assert table.width == 200


@assert_no_logs
def test_layout_table_auto_21():
    # Fixed-width table with column group with widths as percentages and pixels
    page, = render_pages('''
      <table style="width: 500px">
        <colgroup style="width: 100px">
          <col />
          <col />
        </colgroup>
        <colgroup style="width: 30%">
          <col />
          <col />
        </colgroup>
        <tbody>
          <tr>
            <td>a</td>
            <td>a</td>
            <td>abc</td>
            <td>abc</td>
          </tr>
        </tbody>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2, td_3, td_4 = row.children
    assert td_1.width == 100
    assert td_2.width == 100
    assert td_3.width == 150
    assert td_4.width == 150
    assert table.width == 500


@assert_no_logs
def test_layout_table_auto_22():
    # Auto-width table with column group with widths as percentages and pixels
    page, = render_pages('''
      <table>
        <colgroup style="width: 10%">
          <col />
          <col />
        </colgroup>
        <colgroup style="width: 200px">
          <col />
          <col />
        </colgroup>
        <tbody>
          <tr>
            <td>a a</td>
            <td>a b</td>
            <td>a c</td>
            <td>a d</td>
          </tr>
        </tbody>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2, td_3, td_4 = row.children
    assert td_1.width == 50
    assert td_2.width == 50
    assert td_3.width == 200
    assert td_4.width == 200
    assert table.width == 500


@assert_no_logs
def test_layout_table_auto_23():
    # Wrong column group width
    page, = render_pages('''
      <table style="width: 200px">
        <colgroup style="width: 20%">
          <col />
          <col />
        </colgroup>
        <tbody>
          <tr>
            <td>a</td>
            <td>a</td>
          </tr>
        </tbody>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert td_1.width == 100
    assert td_2.width == 100
    assert table.width == 200


@assert_no_logs
def test_layout_table_auto_24():
    # Column width as percentage and cell width in pixels
    page, = render_pages('''
      <table style="width: 200px">
        <colgroup>
          <col style="width: 70%" />
          <col />
        </colgroup>
        <tbody>
          <tr>
            <td>a</td>
            <td style="width: 60px">abc</td>
          </tr>
        </tbody>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert td_1.width == 140
    assert td_2.width == 60
    assert table.width == 200


@assert_no_logs
def test_layout_table_auto_25():
    # Column width and cell width as percentage
    page, = render_pages('''
      <div style="width: 400px">
        <table style="width: 50%">
          <colgroup>
            <col style="width: 70%" />
            <col />
          </colgroup>
          <tbody>
            <tr>
              <td>a</td>
              <td style="width: 30%">abc</td>
            </tr>
          </tbody>
        </table>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    table_wrapper, = div.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert td_1.width == 140
    assert td_2.width == 60
    assert table.width == 200


@assert_no_logs
def test_layout_table_auto_26():
    # Regression test for #307.
    # Table with a cell larger than the table's max-width.
    page, = render_pages('''
      <table style="max-width: 300px">
        <td style="width: 400px"></td>
      </table>
    ''')


@assert_no_logs
def test_layout_table_auto_27():
    # Table with a cell larger than the table's width.
    page, = render_pages('''
      <table style="width: 300px">
        <td style="width: 400px"></td>
      </table>
    ''')


@assert_no_logs
def test_layout_table_auto_28():
    # Table with a cell larger than the table's width and max-width.
    page, = render_pages('''
      <table style="width: 300px; max-width: 350px">
        <td style="width: 400px"></td>
      </table>
    ''')


@assert_no_logs
def test_layout_table_auto_29():
    # Table with a cell larger than the table's width and max-width.
    page, = render_pages('''
      <table style="width: 300px; max-width: 350px">
        <td style="padding: 50px">
          <div style="width: 300px"></div>
        </td>
      </table>
    ''')


@assert_no_logs
def test_layout_table_auto_30():
    # Table with a cell larger than the table's max-width.
    page, = render_pages('''
      <table style="max-width: 300px; margin: 100px">
        <td style="width: 400px"></td>
      </table>
    ''')


@assert_no_logs
def test_layout_table_auto_31():
    # Test a table with column widths < table width < column width + spacing.
    page, = render_pages('''
      <table style="width: 300px; border-spacing: 2px">
        <td style="width: 299px"></td>
      </table>
    ''')


@assert_no_logs
def test_layout_table_auto_32():
    # Table with a cell larger than the table's width.
    page, = render_pages('''
      <table style="width: 400px; margin: 100px">
        <td style="width: 500px"></td>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    assert table_wrapper.margin_width() == 600  # 400 + 2 * 100


@assert_no_logs
def test_layout_table_auto_33():
    # Div with auto width containing a table with a min-width.
    page, = render_pages('''
      <div style="float: left">
        <table style="min-width: 400px; margin: 100px">
          <td></td>
        </table>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    table_wrapper, = div.children
    assert div.margin_width() == 600  # 400 + 2 * 100
    assert table_wrapper.margin_width() == 600  # 400 + 2 * 100


@assert_no_logs
def test_layout_table_auto_34():
    # Div with auto width containing an empty table with a min-width.
    page, = render_pages('''
      <div style="float: left">
        <table style="min-width: 400px; margin: 100px"></table>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    table_wrapper, = div.children
    assert div.margin_width() == 600  # 400 + 2 * 100
    assert table_wrapper.margin_width() == 600  # 400 + 2 * 100


@assert_no_logs
def test_layout_table_auto_35():
    # Div with auto width containing a table with a cell larger than the
    # table's max-width.
    page, = render_pages('''
      <div style="float: left">
        <table style="max-width: 300px; margin: 100px">
          <td style="width: 400px"></td>
        </table>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    table_wrapper, = div.children
    assert div.margin_width() == 600  # 400 + 2 * 100
    assert table_wrapper.margin_width() == 600  # 400 + 2 * 100


@assert_no_logs
def test_layout_table_auto_36():
    # Regression test for #152.
    page, = render_pages('''
      <table>
        <td style="width: 50%">
      </table>
    ''')


@assert_no_logs
def test_layout_table_auto_37():
    # Regression test for #305.
    page, = render_pages('''
      <table>
        <tr>
          <td>
            <table>
              <tr>
                <th>Test</th>
              </tr>
              <tr>
                <td style="min-width: 100%;"></td>
                <td style="width: 48px;"></td>
              </tr>
            </table>
          </td>
        </tr>
      </table>
    ''')


@assert_no_logs
def test_layout_table_auto_38():
    page, = render_pages('''
      <table>
        <tr>
          <td>
            <table>
              <tr>
                <td style="width: 100%;"></td>
                <td style="width: 48px;">
                  <img src="icon.png">
                </td>
              </tr>
            </table>
          </td>
        </tr>
      </table>
    ''')


@assert_no_logs
def test_layout_table_auto_39():
    page, = render_pages('''
      <table>
        <tr>
          <td>
            <table style="display: inline-table">
              <tr>
                <td style="width: 100%;"></td>
                <td></td>
              </tr>
            </table>
          </td>
        </tr>
      </table>
    ''')


@assert_no_logs
def test_layout_table_auto_40():
    # Regression test for #368.
    # Check that white-space is used for the shrink-to-fit algorithm.
    page, = render_pages('''
      <table style="width: 0">
        <td style="font-family: weasyprint; white-space: nowrap">a a</td>
      </table>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    table_wrapper, = div.children
    table, = table_wrapper.children
    assert table.width == 16 * 3


@assert_no_logs
def test_layout_table_auto_41():
    # Cell width as percentage in auto-width table.
    page, = render_pages('''
      <div style="width: 100px">
        <table>
          <tbody>
            <tr>
              <td>a a a a a a a a</td>
              <td style="width: 30%">a a a a a a a a</td>
            </tr>
          </tbody>
        </table>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    table_wrapper, = div.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert td_1.width == 70
    assert td_2.width == 30
    assert table.width == 100


@assert_no_logs
def test_layout_table_auto_42():
    # Cell width as percentage in auto-width table.
    page, = render_pages('''
      <table style="font-family: weasyprint">
        <tbody>
            <tr>
              <td style="width: 70px">aaa</td>
              <td style="width: 25%">aaa</td>
            </tr>
        </tbody>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert td_2.width == 16 * 3  # Percentage column is set to max-width
    assert td_1.width == (16 * 3) * 3  # Pixel column constraint is ignored
    assert table.width == (16 * 3) * 4


@assert_no_logs
def test_layout_table_auto_43():
    # Cell width as percentage on colspan cell in auto-width table.
    page, = render_pages('''
      <div style="width: 100px">
        <table>
          <tbody>
            <tr>
              <td>a a a a a a a a</td>
              <td style="width: 30%" colspan=2>a a a a a a a a</td>
              <td>a a a a a a a a</td>
            </tr>
          </tbody>
        </table>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    table_wrapper, = div.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2, td_3 = row.children
    assert td_1.width == 35
    assert td_2.width == 30
    assert td_3.width == 35
    assert table.width == 100


@assert_no_logs
def test_layout_table_auto_44():
    # Cells widths as percentages on normal and colspan cells.
    page, = render_pages('''
      <div style="width: 100px">
        <table>
          <tbody>
            <tr>
              <td>a a a a a a a a</td>
              <td style="width: 30%" colspan=2>a a a a a a a a</td>
              <td>a a a a a a a a</td>
              <td style="width: 40%">a a a a a a a a</td>
              <td>a a a a a a a a</td>
            </tr>
          </tbody>
        </table>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    table_wrapper, = div.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2, td_3, td_4, td_5 = row.children
    assert td_1.width == 10
    assert td_2.width == 30
    assert td_3.width == 10
    assert td_4.width == 40
    assert td_5.width == 10
    assert table.width == 100


@assert_no_logs
def test_layout_table_auto_45():
    # Cells widths as percentage on multiple lines.
    page, = render_pages('''
      <div style="width: 1000px">
        <table>
          <tbody>
            <tr>
              <td>a a a a a a a a</td>
              <td style="width: 30%">a a a a a a a a</td>
              <td>a a a a a a a a</td>
              <td style="width: 40%">a a a a a a a a</td>
              <td>a a a a a a a a</td>
            </tr>
            <tr>
              <td style="width: 31%" colspan=2>a a a a a a a a</td>
              <td>a a a a a a a a</td>
              <td style="width: 42%" colspan=2>a a a a a a a a</td>
            </tr>
          </tbody>
        </table>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    table_wrapper, = div.children
    table, = table_wrapper.children
    row_group, = table.children
    row_1, row_2 = row_group.children
    td_11, td_12, td_13, td_14, td_15 = row_1.children
    td_21, td_22, td_23 = row_2.children
    assert td_11.width == 10  # 31% - 30%
    assert td_12.width == 300  # 30%
    assert td_13.width == 270  # 1000 - 31% - 42%
    assert td_14.width == 400  # 40%
    assert td_15.width == 20  # 42% - 2%
    assert td_21.width == 310  # 31%
    assert td_22.width == 270  # 1000 - 31% - 42%
    assert td_23.width == 420  # 42%
    assert table.width == 1000


@assert_no_logs
def test_layout_table_auto_46():
    page, = render_pages('''
      <div style="position: absolute">
        <table style="margin: 50px; border: 20px solid black">
          <tr>
            <td style="width: 200px; height: 200px"></td>
          </tr>
        </table>
      </div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    table_wrapper, = div.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td, = row.children
    assert td.width == 200
    assert table.width == 200
    assert div.width == 340  # 200 + 2 * 50 + 2 * 20


@assert_no_logs
def test_layout_table_auto_47():
    # Regression test for #666.
    page, = render_pages('''
      <table style="font-family: weasyprint">
        <tr>
          <td colspan=5>aaa</td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td, = row.children
    assert td.width == 48  # 3 * font-size


@assert_no_logs
def test_layout_table_auto_48():
    # Regression test for #685.
    page, = render_pages('''
      <table style="font-family: weasyprint; border-spacing: 100px;
                    border-collapse: collapse">
        <tr>
          <td colspan=5>aaa</td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td, = row.children
    assert td.width == 48  # 3 * font-size


@pytest.mark.xfail
@assert_no_logs
def test_layout_table_auto_49():
    # Regression test for #685.
    # See TODO in table_layout.group_layout.
    page, = render_pages('''
      <table style="font-family: weasyprint; border-spacing: 100px">
        <tr>
          <td colspan=5>aaa</td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td, = row.children
    assert td.width == 48  # 3 * font-size


@assert_no_logs
def test_layout_table_auto_50():
    # Regression test for #685.
    page, = render_pages('''
      <table style="font-family: weasyprint; border-spacing: 5px">
       <tr><td>a</td><td>a</td><td>a</td><td>a</td><td>a</td></tr>
       <tr>
         <td colspan='5'>aaa aaa aaa aaa</td>
       </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row_1, row_2 = row_group.children
    for td in row_1.children:
        assert td.width == 44  # (15 * font_size - 4 * sp) / 5
    td_21, = row_2.children
    assert td_21.width == 240  # 15 * font_size


@assert_no_logs
def test_layout_table_auto_51():
    # Regression test for #2174.
    page, = render_pages('''
      <table style="font-family: weasyprint; width: 100px">
        <tr>
          <td style="width: 29.9999%">a</td>
          <td style="width: 70%">a</td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row_1, = row_group.children
    td_1, td_2 = row_1.children
    assert abs(td_1.width - 30) < 0.1
    assert abs(td_2.width - 70) < 0.1


@assert_no_logs
def test_layout_table_auto_52():
    # Regression test for #2325.
    page, = render_pages('''
      <style>
        @page { size: 20px }
      </style>
      <table style="font-family: weasyprint; border-spacing: 1px;
                    font-size: 2px; line-height: 1">
        <tr>
          <td><img src=pattern.png></td>
          <td>
            <span>foo</span>,
            <span>foo</span>,
            <span>foo</span>
          </td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert table.width == 20
    assert table_wrapper.position_x == 0
    assert table.position_x == 0
    assert td_1.position_x == 1  # spacing
    assert td_1.width == 4  # image width
    assert td_2.position_x == td_1.width + 2 * 1  # 2 * spacing
    assert td_2.width == table.width - td_1.width - 3 * 1  # 3 * spacing
    assert td_2.height == 3 * 2  # 3 lines * line height


@assert_no_logs
@pytest.mark.parametrize(
    ('body_width', 'table_width', 'check_width', 'positions', 'widths'), [
        ('500px', '230px', 220, [170, 5], [45, 155]),
        ('530px', '100%', 520, [395, 5], [120, 380]),
    ]
)
def test_explicit_width_table_percent_rtl(body_width, table_width, check_width,
                                          positions, widths):
    page, = render_pages('''
      <style>
        body { width: %s }
        table { width: %s; table-layout: fixed; direction: rtl;
                border-collapse: collapse; font-size: 1px }
        td, th { border: 10px solid }
      </style>
      <table style="">
        <col style="width: 25%%"></col>
        <col></col>
        <tr>
          <th>الاسم</th>
          <th>العائلة</th>
        </tr>
        <tr>
          <td>محمد يوسف</td>
          <td>29</td>
        </tr>
      </table>
    ''' % (body_width, table_width))
    html, = page.children
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    row_group, = table.children
    row_1, row_2 = row_group.children

    assert table.position_x == 0
    assert table.width == check_width
    assert [child.position_x for child in row_1.children] == positions
    assert [child.position_x for child in row_2.children] == positions
    assert [child.width for child in row_1.children] == widths
    assert [child.width for child in row_2.children] == widths


@assert_no_logs
def test_table_column_width_1():
    source = '''
      <style>
        body { width: 20000px; margin: 0 }
        table {
          width: 10000px; margin: 0 auto; border-spacing: 100px 0;
          table-layout: fixed
        }
        td { border: 10px solid; padding: 1px }
      </style>
      <table>
        <col style="width: 10%">
        <tr>
          <td style="width: 30%" colspan=3>
          <td>
        </tr>
        <tr>
          <td>
          <td>
          <td>
          <td>
        </tr>
        <tr>
          <td>
          <td colspan=12>This cell will be truncated to grid width
          <td>This cell will be removed as it is beyond the grid width
        </tr>
      </table>
    '''
    with capture_logs() as logs:
        page, = render_pages(source)
    assert len(logs) == 1
    assert logs[0].startswith('WARNING: This table row has more columns than '
                              'the table, ignored 1 cell')
    html, = page.children
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    row_group, = table.children
    first_row, second_row, third_row = row_group.children
    cells = [first_row.children, second_row.children, third_row.children]
    assert len(first_row.children) == 2
    assert len(second_row.children) == 4
    # Third cell here is completly removed.
    assert len(third_row.children) == 2

    assert body.position_x == 0
    assert wrapper.position_x == 0
    assert wrapper.margin_left == 5000
    assert wrapper.content_box_x() == 5000  # auto margin-left
    assert wrapper.width == 10000
    assert table.position_x == 5000
    assert table.width == 10000
    assert row_group.position_x == 5100  # 5000 + border_spacing
    assert row_group.width == 9800  # 10000 - 2*border-spacing
    assert first_row.position_x == row_group.position_x
    assert first_row.width == row_group.width

    # This cell has colspan=3.
    assert cells[0][0].position_x == 5100  # 5000 + border-spacing
    # `width` on a cell sets the content width.
    assert cells[0][0].width == 3000  # 30% of 10000px
    assert cells[0][0].border_width() == 3022  # 3000 + borders + padding

    # Second cell of the first line, but on the fourth and last column.
    assert cells[0][1].position_x == 8222  # 5100 + 3022 + border-spacing
    assert cells[0][1].border_width() == 6678  # 10000 - 3022 - 3*100
    assert cells[0][1].width == 6656  # 6678 - borders - padding

    assert cells[1][0].position_x == 5100  # 5000 + border-spacing
    # `width` on a column sets the border width of cells.
    assert cells[1][0].border_width() == 1000  # 10% of 10000px
    assert cells[1][0].width == 978  # 1000 - borders - padding

    assert cells[1][1].position_x == 6200  # 5100 + 1000 + border-spacing
    assert cells[1][1].border_width() == 911  # (3022 - 1000 - 2*100) / 2
    assert cells[1][1].width == 889  # 911 - borders - padding

    assert cells[1][2].position_x == 7211  # 6200 + 911 + border-spacing
    assert cells[1][2].border_width() == 911  # (3022 - 1000 - 2*100) / 2
    assert cells[1][2].width == 889  # 911 - borders - padding

    # Same as cells[0][1].
    assert cells[1][3].position_x == 8222  # Also 7211 + 911 + border-spacing
    assert cells[1][3].border_width() == 6678
    assert cells[1][3].width == 6656

    # Same as cells[1][0].
    assert cells[2][0].position_x == 5100
    assert cells[2][0].border_width() == 1000
    assert cells[2][0].width == 978

    assert cells[2][1].position_x == 6200  # Same as cells[1][1]
    assert cells[2][1].border_width() == 8700  # 1000 - 1000 - 3*border-spacing
    assert cells[2][1].width == 8678  # 8700 - borders - padding
    assert cells[2][1].colspan == 3  # truncated to grid width


@assert_no_logs
def test_table_column_width_2():
    page, = render_pages('''
      <style>
        table { width: 1000px; border-spacing: 100px; table-layout: fixed }
      </style>
      <table>
        <tr>
          <td style="width: 50%">
          <td style="width: 60%">
          <td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    row_group, = table.children
    row, = row_group.children
    assert row.children[0].width == 500
    assert row.children[1].width == 600
    assert row.children[2].width == 0
    assert table.width == 1500  # 500 + 600 + 4 * border-spacing


@assert_no_logs
def test_table_column_width_3():
    # Sum of columns width larger that the table width: increase the table width.
    page, = render_pages('''
      <style>
        table { width: 1000px; border-spacing: 100px; table-layout: fixed }
        td { width: 60% }
      </style>
      <table>
        <tr>
          <td>
          <td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    row_group, = table.children
    row, = row_group.children
    cell_1, cell_2 = row.children
    assert cell_1.width == 600  # 60% of 1000px
    assert cell_2.width == 600
    assert table.width == 1500  # 600 + 600 + 3*border-spacing
    assert wrapper.width == table.width


@assert_no_logs
def test_table_row_height_1():
    page, = render_pages('''
      <table style="width: 1000px; border-spacing: 0 100px;
                    font: 20px/1em serif; margin: 3px; table-layout: fixed">
        <tr>
          <td rowspan=0 style="height: 420px; vertical-align: top"></td>
          <td>X<br>X<br>X</td>
          <td><table style="margin-top: 20px; border-spacing: 0">
            <tr><td>X</td></tr></table></td>
          <td style="vertical-align: top">X</td>
          <td style="vertical-align: middle">X</td>
          <td style="vertical-align: bottom">X</td>
        </tr>
        <tr>
          <!-- cells with no text (no line boxes) is a corner case
               in cell baselines -->
          <td style="padding: 15px"></td>
          <td><div style="height: 10px"></div></td>
        </tr>
        <tr></tr>
        <tr>
            <td style="vertical-align: bottom"></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    row_group, = table.children

    assert wrapper.position_y == 0
    assert table.position_y == 3  # 0 + margin-top
    assert table.height == 620  # sum of row heigths + 5*border-spacing
    assert wrapper.height == table.height
    assert row_group.position_y == 103  # 3 + border-spacing
    assert row_group.height == 420  # 620 - 2*border-spacing
    assert [row.height for row in row_group.children] == [
        80, 30, 0, 10]
    assert [row.position_y for row in row_group.children] == [
        # cumulative sum of previous row heights and border-spacings
        103, 283, 413, 513]
    assert [[cell.height for cell in row.children]
            for row in row_group.children] == [
        [420, 60, 40, 20, 20, 20],
        [0, 10],
        [],
        [0]
    ]
    assert [[cell.border_height() for cell in row.children]
            for row in row_group.children] == [
        [420, 80, 80, 80, 80, 80],
        [30, 30],
        [],
        [10]
    ]
    # The baseline of the first row is at 40px because of the third column.
    # The second column thus gets a top padding of 20px pushes the bottom
    # to 80px.The middle is at 40px.
    assert [[cell.padding_top for cell in row.children]
            for row in row_group.children] == [
        [0, 20, 0, 0, 30, 60],
        [15, 5],
        [],
        [10]
    ]
    assert [[cell.padding_bottom for cell in row.children]
            for row in row_group.children] == [
        [0, 0, 40, 60, 30, 0],
        [15, 15],
        [],
        [0]
    ]
    assert [[cell.position_y for cell in row.children]
            for row in row_group.children] == [
        [103, 103, 103, 103, 103, 103],
        [283, 283],
        [],
        [513]
    ]


@assert_no_logs
def test_table_row_height_2():
    # A cell box cannot extend beyond the last row box of a table.
    page, = render_pages('''
      <table style="border-spacing: 0">
        <tr style="height: 10px">
          <td rowspan=5></td>
          <td></td>
        </tr>
        <tr style="height: 10px">
          <td></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    row_group, = table.children


@assert_no_logs
def test_table_row_height_3():
    # Regression test for #937.
    page, = render_pages('''
      <table style="border-spacing: 0; font-family: weasyprint;
                    line-height: 20px">
        <tr><td>Table</td><td rowspan="2"></td></tr>
        <tr></tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    assert table.height == 20
    row_group, = table.children
    assert row_group.height == 20
    row1, row2 = row_group.children
    assert row1.height == 20
    assert row2.height == 0


@assert_no_logs
def test_table_row_height_4():
    # A row cannot be shorter than the border-height of its tallest cell.
    page, = render_pages('''
      <table style="border-spacing: 0;">
        <tr style="height: 4px;">
          <td style="border: 1px solid; padding: 5px;"></td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    row_group, = table.children
    assert row_group.height == 12


@assert_no_logs
def test_table_vertical_align(assert_pixels):
    assert_pixels('''
        rrrrrrrrrrrrrrrrrrrrrrrrrrrr
        rBBBBBBBBBBBBBBBBBBBBBBBBBBr
        rBrBB_BB_BB_BB_BBrrBBrrBB_Br
        rBrBB_BB_BBrBBrBBrrBBrrBBrBr
        rB_BBrBB_BBrBBrBBrrBBrrBBrBr
        rB_BBrBB_BB_BB_BBrrBBrrBB_Br
        rB_BB_BBrBB_BB_BB__BB__BB_Br
        rB_BB_BBrBB_BB_BB__BB__BB_Br
        rBBBBBBBBBBBBBBBBBBBBBBBBBBr
        rrrrrrrrrrrrrrrrrrrrrrrrrrrr
    ''', '''
      <style>
        @page { size: 28px 10px }
        html { font-size: 1px; color: red }
        body { margin: 0; width: 28px; height: 10px }
        td {
          width: 1em;
          padding: 0 !important;
          border: 1px solid blue;
          line-height: 1em;
          font-family: weasyprint;
        }
      </style>
      <table style="border: 1px solid red; border-spacing: 0">
        <tr>
          <!-- Test vertical-align: top, auto height -->
          <td style="vertical-align: top">o o</td>

          <!-- Test vertical-align: middle, auto height -->
          <td style="vertical-align: middle">o o</td>

          <!-- Test vertical-align: bottom, fixed useless height -->
          <td style="vertical-align: bottom; height: 2em">o o</td>

          <!-- Test default vertical-align value (baseline),
               fixed useless height -->
          <td style="height: 5em">o o</td>

          <!-- Test vertical-align: baseline with baseline set by next cell,
               auto height -->
          <td style="vertical-align: baseline">o o</td>

          <!-- Set baseline height to 2px, auto height -->
          <td style="vertical-align: baseline; font-size: 2em">o o</td>

          <!-- Test padding-bottom, fixed useless height,
               set the height of the cells to 2 lines * 2em + 2px = 6px -->
          <td style="vertical-align: baseline; height: 1em;
                     font-size: 2em; padding-bottom: 2px !important">
            o o
          </td>

          <!-- Test padding-top, auto height -->
          <td style="vertical-align: top; padding-top: 1em !important">
            o o
          </td>
        </tr>
      </table>
    ''')


@assert_no_logs
def test_table_vertical_align_float():
    # Regression test for #2216 and #2293.
    page, = render_pages('''
      <style>
        @page { size: 100px 400px }
        td { width: 50px; height: 100px; line-height: 0 }
      </style>
      <table>
        <tr>
          <td style="vertical-align: middle">
            <div style="float: left; height: 20px; width: 20px"></div>
            <div style="display: inline-block; height: 30px; width: 30px"></div>
          </td>
          <td style="vertical-align: bottom">
            <div style="display: inline-block; height: 30px; width: 30px"></div>
            <div style="float: right; height: 20px; width: 20px"></div>
          </td>
        </tr>
        <tr>
          <td style="vertical-align: middle">
            <div style="float: left; height: 20px; width: 20px"></div>
            <div style="display: inline-block; height: 10px; width: 10px"></div>
          </td>
          <td style="vertical-align: bottom">
            <div style="display: inline-block; height: 10px; width: 10px"></div>
            <div style="float: right; height: 20px; width: 20px"></div>
          </td>
        </tr>
        <tr>
          <td style="vertical-align: middle">
            <div style="display: inline-block; height: 10px; width: 10px"></div>
          </td>
          <td style="vertical-align: bottom">
            <div style="display: inline-block; height: 10px; width: 10px"></div>
          </td>
        </tr>
        <tr>
          <td style="vertical-align: middle">
            <div style="float: left; height: 20px; width: 20px"></div>
          </td>
          <td style="vertical-align: bottom">
            <div style="float: right; height: 20px; width: 20px"></div>
          </td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    table, = wrapper.children
    row_group, = table.children
    row_1, row_2, row_3, row_4, = row_group.children

    td_1, td_2 = row_1.children
    div_1, line_wrapper = td_1.children
    assert div_1.position_x == 0
    assert div_1.position_y == (100 - 30) / 2
    div_2 = line_wrapper.children[0].children[0]
    assert div_2.position_x == 20
    assert div_2.position_y == (100 - 30) / 2
    line_box, = td_2.children
    div_1, _, div_2 = line_box.children
    assert div_1.position_x == 50
    assert div_1.position_y == 100 - 30
    assert div_2.position_x == 80
    assert div_2.position_y == 100 - 30

    td_1, td_2 = row_2.children
    div_1, line_wrapper = td_1.children
    assert div_1.position_x == 0
    assert div_1.position_y == 100 + (100 - 20) / 2
    div_2 = line_wrapper.children[0].children[0]
    assert div_2.position_x == 20
    assert div_2.position_y == 100 + (100 - 20) / 2
    line_box, = td_2.children
    div_1, _, div_2 = line_box.children
    assert div_1.position_x == 50
    assert div_1.position_y == 100 + (100 - 20)
    assert div_2.position_x == 80
    assert div_2.position_y == 100 + (100 - 20)

    td_1, td_2 = row_3.children
    line_box, = td_1.children
    div, _ = line_box.children
    assert div.position_x == 0
    assert div.position_y == 200 + (100 - 10) / 2
    div, = td_2.children
    assert div.position_x == 50
    assert div.position_y == 200 + (100 - 10)

    td_1, td_2 = row_4.children
    div, = td_1.children
    assert div.position_x == 0
    assert div.position_y == 300 + (100 - 20) / 2
    div, = td_2.children
    assert div.position_x == 80
    assert div.position_y == 300 + (100 - 20)


@assert_no_logs
def test_table_wrapper():
    page, = render_pages('''
      <style>
        @page { size: 1000px }
        table { width: 600px; height: 500px; table-layout: fixed;
                  padding: 1px; border: 10px solid; margin: 100px; }
      </style>
      <table></table>
    ''')
    html, = page.children
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    assert body.width == 1000
    assert wrapper.width == 600  # not counting borders or padding
    assert wrapper.margin_left == 100
    assert table.margin_width() == 600
    assert table.width == 578  # 600 - 2*10 - 2*1, no margin
    # box-sizing in the UA stylesheet makes `height: 500px` set this.
    assert table.border_height() == 500
    assert table.height == 478  # 500 - 2*10 - 2*1
    assert table.margin_height() == 500  # no margin
    assert wrapper.height == 500
    assert wrapper.margin_height() == 700  # 500 + 2*100


@assert_no_logs
def test_table_html_tag():
    # Regression test.
    page, = render_pages('<html style="display: table">')


@assert_no_logs
@pytest.mark.parametrize(('html', 'rows', 'positions'), [
    ('''
      <style>
        @page { size: 120px }
        table { table-layout: fixed; width: 100% }
        h1 { height: 30px }
        td { height: 40px }
      </style>
      <h1>Dummy title</h1>
      <table>
        <tr><td>row 1</td></tr>
        <tr><td>row 2</td></tr>

        <tr><td>row 3</td></tr>
        <tr><td>row 4</td></tr>
        <tr><td>row 5</td></tr>

        <tr><td style="height: 300px"> <!-- overflow the page -->
          row 6</td></tr>
        <tr><td>row 7</td></tr>
        <tr><td>row 8</td></tr>
      </table>
     ''',
     [2, 3, 1, 2],
     [30, 70, 0, 40, 80, 0, 0, 40]),
    ('''
      <style>
        @page { size: 120px }
        h1 { height: 30px}
        td { height: 40px }
        table { table-layout: fixed; width: 100%;
                page-break-inside: avoid }
      </style>
      <h1>Dummy title</h1>
      <table>
        <tr><td>row 1</td></tr>
        <tr><td>row 2</td></tr>
        <tr><td>row 3</td></tr>
        <tr><td>row 4</td></tr>
     </table>
     ''',
     [0, 3, 1],
     [0, 40, 80, 0]),
    ('''
      <style>
        @page { size: 120px }
        h1 { height: 30px}
        td { height: 40px }
        table { table-layout: fixed; width: 100%;
                page-break-inside: avoid }
      </style>
      <h1>Dummy title</h1>
      <table>
        <tbody>
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>

        <tr><td>row 4</td></tr>
      </table>
     ''',
     [0, 3, 1],
     [0, 40, 80, 0]),
    ('''
      <style>
        @page { size: 120px }
        h1 { height: 30px}
        td { height: 40px }
        table { table-layout: fixed; width: 100% }
      </style>
      <h1>Dummy title</h1>
      <table>
        <tr><td>row 1</td></tr>

        <tbody style="page-break-inside: avoid">
          <tr><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>
      </table>
     ''',
     [1, 2],
     [30, 0, 40]),
    ('''
      <style>
        @page { size: 120px }
        h1 { height: 30px}
        td { line-height: 40px }
        table { table-layout: fixed; width: 100% }
      </style>
      <h1>Dummy title</h1>
      <table>
        <tr><td>r1l1</td></tr>
        <tr style="break-inside: avoid"><td>r2l1<br>r2l2</td></tr>
        <tr><td>r3l1</td></tr>
      </table>
     ''',
     [1, 2],
     [30, 0, 80]),
    ('''
      <style>
        @page { size: 120px }
        h1 { height: 30px}
        td { line-height: 40px }
        table { table-layout: fixed; width: 100% }
      </style>
      <h1>Dummy title</h1>
      <table>
        <tbody>
          <tr><td>r1l1</td></tr>
          <tr style="break-inside: avoid"><td>r2l1<br>r2l2</td></tr>
        </tbody>
        <tr><td>r3l1</td></tr>
      </table>
     ''',
     [1, 2],
     [30, 0, 80]),
    ('''
      <style>
        @page { size: 100px }
        h1 { height: 30px }
        td { line-height: 40px }
        table { table-layout: fixed; width: 100% }
        thead { display: table-row-group; break-after: avoid }
        thead tr { break-after: avoid }
      </style>
      <h1>Dummy title</h1>
      <table>
        <thead>
          <tr><td>r1l1</td></tr>
        </thead>
        <tbody>
          <tr><td>r2l1</td></tr>
        </tbody>
      </table>
     ''',
     [0, 2],
     [0, 40]),
])
def test_table_page_breaks(html, rows, positions):
    pages = render_pages(html)
    rows_per_page = []
    rows_position_y = []
    for i, page in enumerate(pages):
        html, = page.children
        body, = html.children
        if i == 0:
            body_children = body.children[1:]  # skip h1
        else:
            body_children = body.children
        if not body_children:
            rows_per_page.append(0)
            continue
        table_wrapper, = body_children
        table, = table_wrapper.children
        rows_in_this_page = 0
        for group in table.children:
            assert group.children, 'found an empty table group'
            for row in group.children:
                rows_in_this_page += 1
                rows_position_y.append(row.position_y)
                cell, = row.children
        rows_per_page.append(rows_in_this_page)

    assert rows_per_page == rows
    assert rows_position_y == positions


@assert_no_logs
def test_table_page_breaks_in_cell():
    page1, page2 = render_pages('''
      <style>
        @page { size: 120px }
        h1 { height: 30px}
        td { line-height: 40px }
        table { table-layout: fixed; width: 100% }
      </style>
      <h1>Dummy title</h1>
      <table>
        <tr><td>r1c1l1</td><td>r1c2l1</td></tr>
        <tr><td>r2c1l1</td><td style="break-inside: avoid">r2c2l1<br>r2c2l2</td></tr>
        <tr><td>r3c1l1</td><td>r3l1</td></tr>
      </table>
    ''')
    html, = page1.children
    body, = html.children
    h1, table_wrapper = body.children
    table, = table_wrapper.children
    group, = table.children
    row, = group.children
    assert len(row.children) == 2

    html, = page2.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    group, = table.children
    row1, row2 = group.children
    assert len(row1.children) == len(row2.children) == 2


@assert_no_logs
def test_table_page_breaks_complex_1():
    pages = render_pages('''
      <style>
        @page { size: 100px }
      </style>
      <h1 style="margin: 0; height: 30px">Lipsum</h1>
      <!-- Leave 70px on the first page: enough for the header or row1
           but not both.  -->
      <table style="border-spacing: 0; font-size: 5px">
        <thead>
          <tr><td style="height: 20px">Header</td></tr>
        </thead>
        <tbody>
          <tr><td style="height: 60px">Row 1</td></tr>
          <tr><td style="height: 10px">Row 2</td></tr>
          <tr><td style="height: 50px">Row 3</td></tr>
          <tr><td style="height: 61px">Row 4</td></tr>
          <tr><td style="height: 90px">Row 5</td></tr>
        </tbody>
        <tfoot>
          <tr><td style="height: 20px">Footer</td></tr>
        </tfoot>
      </table>
    ''')
    rows_per_page = []
    for i, page in enumerate(pages):
        groups = []
        html, = page.children
        body, = html.children
        table_wrapper, = body.children
        if i == 0:
            assert table_wrapper.element_tag == 'h1'
        else:
            table, = table_wrapper.children
            for group in table.children:
                assert group.children, 'found an empty table group'
                rows = []
                for row in group.children:
                    cell, = row.children
                    line, = cell.children
                    text, = line.children
                    rows.append(text.text)
                groups.append(rows)
        rows_per_page.append(groups)
    assert rows_per_page == [
        [],
        [['Header'], ['Row 1'], ['Footer']],
        [['Header'], ['Row 2', 'Row 3'], ['Footer']],
        [['Header'], ['Row 4']],
        [['Row 5']]
    ]


@assert_no_logs
def test_table_page_breaks_complex_2():
    pages = render_pages('''
      <style>
        @page { size: 250px }
        td { height: 40px }
        table { table-layout: fixed; width: 100%; break-before: avoid }
      </style>
      <table>
        <thead>
          <tr><td>head 1</td></tr>
        </thead>
        <tbody>
          <tr><td>row 1 1</td></tr>
          <tr><td>row 1 2</td></tr>
          <tr><td>row 1 3</td></tr>
        </tbody>
        <tfoot>
          <tr><td>foot 1</td></tr>
        </tfoot>
      </table>
      <table>
        <thead>
          <tr><td>head 2</td></tr>
        </thead>
        <tbody>
          <tr><td>row 2 1</td></tr>
          <tr><td>row 2 2</td></tr>
          <tr><td>row 2 3</td></tr>
        </tbody>
        <tfoot>
          <tr><td>foot 2</td></tr>
        </tfoot>
      </table>
     ''')
    rows_per_page = []
    for i, page in enumerate(pages):
        groups = []
        html, = page.children
        body, = html.children
        for table_wrapper in body.children:
            table, = table_wrapper.children
            for group in table.children:
                assert group.children, 'found an empty table group'
                rows = []
                for row in group.children:
                    cell, = row.children
                    line, = cell.children
                    text, = line.children
                    rows.append(text.text)
                groups.append(rows)
        rows_per_page.append(groups)
    assert rows_per_page == [
        [['head 1'], ['row 1 1', 'row 1 2'], ['foot 1']],
        [['head 1'], ['row 1 3'], ['foot 1'],
         ['head 2'], ['row 2 1'], ['foot 2']],
        [['head 2'], ['row 2 2', 'row 2 3'], ['foot 2']],
    ]
    # TODO: test positions, the place of footer on the first page is wrong.


@assert_no_logs
def test_table_page_break_after():
    page1, page2, page3, page4, page5, page6 = render_pages('''
      <style>
        @page { size: 1000px }
        h1 { height: 30px}
        td { height: 40px }
        table { table-layout: fixed; width: 100% }
      </style>
      <h1>Dummy title</h1>
      <table>

        <tbody>
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>
        <tbody>
          <tr style="break-after: page"><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>
        <tbody>
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
          <tr style="break-after: page"><td>row 3</td></tr>
        </tbody>
        <tbody style="break-after: right">
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>
        <tbody style="break-after: page">
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>

      </table>
      <p>bla bla</p>
     ''')
    html, = page1.children
    body, = html.children
    h1, table_wrapper = body.children
    table, = table_wrapper.children
    table_group1, table_group2 = table.children
    assert len(table_group1.children) == 3
    assert len(table_group2.children) == 1

    html, = page2.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    table_group1, table_group2 = table.children
    assert len(table_group1.children) == 2
    assert len(table_group2.children) == 3

    html, = page3.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    table_group, = table.children
    assert len(table_group.children) == 3

    html, = page4.children
    assert not html.children

    html, = page5.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    table_group, = table.children
    assert len(table_group.children) == 3

    html, = page6.children
    body, = html.children
    p, = body.children
    assert p.element_tag == 'p'


@assert_no_logs
def test_table_page_break_before():
    page1, page2, page3, page4, page5, page6 = render_pages('''
      <style>
        @page { size: 1000px }
        h1 { height: 30px}
        td { height: 40px }
        table { table-layout: fixed; width: 100% }
      </style>
      <h1>Dummy title</h1>
      <table>

        <tbody>
          <tr style="break-before: page"><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>
        <tbody>
          <tr><td>row 1</td></tr>
          <tr style="break-before: page"><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>
        <tbody>
          <tr style="break-before: page"><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>
        <tbody>
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>
        <tbody style="break-before: left">
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>

      </table>
      <p>bla bla</p>
     ''')
    html, = page1.children
    body, = html.children
    h1, = body.children
    assert h1.element_tag == 'h1'

    html, = page2.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    table_group1, table_group2 = table.children
    assert len(table_group1.children) == 3
    assert len(table_group2.children) == 1

    html, = page3.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    table_group, = table.children
    assert len(table_group.children) == 2

    html, = page4.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    table_group1, table_group2 = table.children
    assert len(table_group1.children) == 3
    assert len(table_group2.children) == 3

    html, = page5.children
    assert not html.children

    html, = page6.children
    body, = html.children
    table_wrapper, p = body.children
    table, = table_wrapper.children
    table_group, = table.children
    assert len(table_group.children) == 3
    assert p.element_tag == 'p'


@assert_no_logs
@pytest.mark.parametrize(('html', 'rows'), [
    ('''
      <style>
        @page { size: 100px }
        table { table-layout: fixed; width: 100% }
        tr { height: 26px }
      </style>
      <table>
        <tbody>
          <tr><td>row 0</td></tr>
          <tr><td>row 1</td></tr>
          <tr style="break-before: avoid"><td>row 2</td></tr>
          <tr style="break-before: avoid"><td>row 3</td></tr>
        </tbody>
      </table>
    ''',
     [1, 3]),
    ('''
      <style>
        @page { size: 100px }
        table { table-layout: fixed; width: 100% }
        tr { height: 26px }
      </style>
      <table>
        <tbody>
          <tr><td>row 0</td></tr>
          <tr style="break-after: avoid"><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
          <tr style="break-before: avoid"><td>row 3</td></tr>
        </tbody>
      </table>
     ''',
     [1, 3]),
    ('''
      <style>
        @page { size: 100px }
        table { table-layout: fixed; width: 100% }
        tr { height: 26px }
      </style>
      <table>
        <tbody>
          <tr><td>row 0</td></tr>
          <tr><td>row 1</td></tr>
          <tr style="break-after: avoid"><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>
      </table>
     ''',
     [2, 2]),
    ('''
      <style>
        @page { size: 100px }
        table { table-layout: fixed; width: 100% }
        tr { height: 26px }
      </style>
      <table>
        <tbody>
          <tr style="break-before: avoid"><td>row 0</td></tr>
          <tr style="break-before: avoid"><td>row 1</td></tr>
          <tr style="break-before: avoid"><td>row 2</td></tr>
          <tr style="break-before: avoid"><td>row 3</td></tr>
        </tbody>
      </table>
     ''',
     [3, 1]),
    ('''
      <style>
        @page { size: 100px }
        table { table-layout: fixed; width: 100% }
        tr { height: 26px }
      </style>
      <table>
        <tbody>
          <tr style="break-after: avoid"><td>row 0</td></tr>
          <tr style="break-after: avoid"><td>row 1</td></tr>
          <tr style="break-after: avoid"><td>row 2</td></tr>
          <tr style="break-after: avoid"><td>row 3</td></tr>
        </tbody>
      </table>
     ''',
     [3, 1]),
    ('''
      <style>
        @page { size: 100px }
        table { table-layout: fixed; width: 100% }
        tr { height: 26px }
        p { height: 26px }
      </style>
      <p>wow p</p>
      <table>
        <tbody>
          <tr style="break-after: avoid"><td>row 0</td></tr>
          <tr style="break-after: avoid"><td>row 1</td></tr>
          <tr style="break-after: avoid"><td>row 2</td></tr>
          <tr style="break-after: avoid"><td>row 3</td></tr>
        </tbody>
      </table>
     ''',
     [1, 3, 1]),
    ('''
      <style>
        @page { size: 100px }
        table { table-layout: fixed; width: 100% }
        tr { height: 30px }
      </style>
      <table>
        <tbody style="break-after: avoid">
          <tr><td>row 0</td></tr>
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
        </tbody>
        <tbody>
          <tr><td>row 0</td></tr>
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
        </tbody>
      </table>
     ''',
     [2, 3, 1]),
    ('''
      <style>
        @page { size: 100px }
        table { table-layout: fixed; width: 100% }
        tr { height: 30px }
      </style>
      <table>
        <tbody>
          <tr><td>row 0</td></tr>
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
        </tbody>
        <tbody style="break-before: avoid">
          <tr><td>row 0</td></tr>
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
        </tbody>
      </table>
     ''',
     [2, 3, 1]),
    ('''
      <style>
        @page { size: 100px }
        table { table-layout: fixed; width: 100% }
        tr { height: 30px }
      </style>
      <table>
        <tbody>
          <tr><td>row 0</td></tr>
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
        </tbody>
        <tbody>
          <tr style="break-before: avoid"><td>row 0</td></tr>
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
        </tbody>
      </table>
     ''',
     [2, 3, 1]),
    ('''
      <style>
        @page { size: 100px }
        table { table-layout: fixed; width: 100% }
        tr { height: 30px }
      </style>
      <table>
        <tbody>
          <tr><td>row 0</td></tr>
          <tr><td>row 1</td></tr>
          <tr style="break-after: avoid"><td>row 2</td></tr>
        </tbody>
        <tbody>
          <tr><td>row 0</td></tr>
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
        </tbody>
      </table>
     ''',
     [2, 3, 1]),
    ('''
      <style>
        @page { size: 100px }
        table { table-layout: fixed; width: 100% }
        tr { height: 30px }
      </style>
      <table>
        <tbody style="break-after: avoid">
          <tr><td>row 0</td></tr>
          <tr><td>row 1</td></tr>
          <tr style="break-after: page"><td>row 2</td></tr>
        </tbody>
        <tbody>
          <tr><td>row 0</td></tr>
          <tr><td>row 1</td></tr>
          <tr><td>row 2</td></tr>
        </tbody>
      </table>
     ''',
     [3, 3]),
])
def test_table_page_break_avoid(html, rows):
    pages = render_pages(html)
    assert len(pages) == len(rows)
    rows_per_page = []
    for page in pages:
        html, = page.children
        body, = html.children
        if body.children[0].element_tag == 'p':
            rows_per_page.append(len(body.children))
            continue
        else:
            table_wrapper, = body.children
        table, = table_wrapper.children
        rows_in_this_page = 0
        for group in table.children:
            for row in group.children:
                rows_in_this_page += 1
        rows_per_page.append(rows_in_this_page)

    assert rows_per_page == rows


@assert_no_logs
def test_table_page_break_avoid_before_table():
    page1, page2 = render_pages('''
      <style>
        @page { size: 100px }
        h1 { height: 30px }
        td, p { font: 20px / 1 weasyprint }
        tr { break-after: avoid }
        table { table-layout: fixed; width: 100%; break-before: avoid }
      </style>
      <h1>Dummy title</h1>
      <p>paragraph</p>
      <table>
        <tbody>
          <tr><td>row 1</td></tr>
        </tbody>
        <tbody>
          <tr><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>
      </table>
     ''')
    html, = page1.children
    body, = html.children
    h1, = body.children
    assert h1.element_tag == 'h1'

    html, = page2.children
    body, = html.children
    p, table_wrapper = body.children
    assert p.element_tag == 'p'
    assert table_wrapper.element_tag == 'table'


@assert_no_logs
def test_table_page_break_avoid_before_tbody():
    page1, page2 = render_pages('''
      <style>
        @page { size: 100px }
        h1 { height: 30px }
        td, p { height: 20px }
        tr { break-after: avoid }
        tbody { break-before: avoid }
      </style>
      <h1>Dummy title</h1>
      <p>paragraph</p>
      <table>
        <tbody>
          <tr><td>row 1</td></tr>
        </tbody>
        <tbody>
          <tr><td>row 2</td></tr>
          <tr><td>row 3</td></tr>
        </tbody>
      </table>
     ''')
    html, = page1.children
    body, = html.children
    h1, = body.children
    assert h1.element_tag == 'h1'

    html, = page2.children
    body, = html.children
    p, table_wrapper = body.children
    assert p.element_tag == 'p'
    assert table_wrapper.element_tag == 'table'


@assert_no_logs
@pytest.mark.parametrize(('vertical_align', 'table_position_y'), [
    ('top', 8),
    ('bottom', 8),
    ('baseline', 10),
])
def test_inline_table_baseline(vertical_align, table_position_y):
    # Check that inline table's baseline is its first row's baseline.
    #
    # Div text's baseline is at 18px from the top (10px because of the
    # line-height, 8px as it's weasyprint.otf's baseline position).
    #
    # When a row has vertical-align: baseline cells, its baseline is its cell's
    # baseline. The position of the table is thus 10px above the text's
    # baseline.
    #
    # When a row has another value for vertical-align, the baseline is the
    # bottom of the row. The first cell's text is aligned with the div's text,
    # and the top of the table is thus 8px above the baseline.
    page, = render_pages('''
      <div style="font-family: weasyprint; font-size: 10px; line-height: 30px">
        abc
        <table style="display: inline-table; border-collapse: collapse;
                      line-height: 10px">
          <tr><td style="vertical-align: %s">a</td></tr>
          <tr><td>a</td></tr>
        </table>
        abc
      </div>
    ''' % vertical_align)
    html, = page.children
    body, = html.children
    div, = body.children
    line, = div.children
    text1, table_wrapper, text2 = line.children
    table, = table_wrapper.children
    assert text1.position_y == text2.position_y == 0
    assert table.height == 10 * 2
    assert abs(table.position_y - table_position_y) < 0.1


@assert_no_logs
def test_table_caption_margin_top():
    page, = render_pages('''
      <style>
        table { margin: 20px; }
        caption, h1, h2 { margin: 20px; height: 10px }
        td { height: 10px }
      </style>
      <h1></h1>
      <table>
        <caption></caption>
        <tr>
          <td></td>
        </tr>
      </table>
      <h2></h2>
    ''')
    html, = page.children
    body, = html.children
    h1, wrapper, h2 = body.children
    caption, table = wrapper.children
    tbody, = table.children
    assert (h1.content_box_x(), h1.content_box_y()) == (20, 20)
    assert (wrapper.content_box_x(), wrapper.content_box_y()) == (20, 50)
    assert (caption.content_box_x(), caption.content_box_y()) == (40, 70)
    assert (tbody.content_box_x(), tbody.content_box_y()) == (20, 100)
    assert (h2.content_box_x(), h2.content_box_y()) == (20, 130)


@assert_no_logs
def test_table_caption_margin_bottom():
    page, = render_pages('''
      <style>
        table { margin: 20px; }
        caption, h1, h2 { margin: 20px; height: 10px; caption-side: bottom }
        td { height: 10px }
      </style>
      <h1></h1>
      <table>
        <caption></caption>
        <tr>
          <td></td>
        </tr>
      </table>
      <h2></h2>
    ''')
    html, = page.children
    body, = html.children
    h1, wrapper, h2 = body.children
    table, caption = wrapper.children
    tbody, = table.children
    assert (h1.content_box_x(), h1.content_box_y()) == (20, 20)
    assert (wrapper.content_box_x(), wrapper.content_box_y()) == (20, 50)
    assert (tbody.content_box_x(), tbody.content_box_y()) == (20, 50)
    assert (caption.content_box_x(), caption.content_box_y()) == (40, 80)
    assert (h2.content_box_x(), h2.content_box_y()) == (20, 130)


@assert_no_logs
@pytest.mark.parametrize(('rows_expected', 'thead', 'tfoot', 'content'), [
    ([[], ['Header', 'Footer']], 45, 45, '<p>content</p>'),
    ([[], ['Header', 'Footer']], 85, 5, '<p>content</p>'),
    ([['Header', 'Footer']], 30, 30, '<p>content</p>'),
    ([[], ['Header']], 30, 110, '<p>content</p>'),
    ([[], ['Header', 'Footer']], 30, 60, '<p>content</p>'),
    ([[], ['Footer']], 110, 30, '<p>content</p>'),

    # We try to render the header and footer on the same page, but it does not
    # fit. So we try to render the header or the footer on the next one, but
    # nothing fit either.
    ([[], []], 110, 110, '<p>content</p>'),

    ([['Header', 'Footer']], 30, 30, ''),
    ([['Header']], 30, 110, ''),
    ([['Header', 'Footer']], 30, 60, ''),
    ([['Footer']], 110, 30, ''),
    ([[]], 110, 110, ''),
])
def test_table_empty_body(rows_expected, thead, tfoot, content):
    html = '''
      <style>
        @page { size: 100px }
        p { height: 20px }
        thead th { height: %spx }
        tfoot th { height: %spx }
      </style>
      %s
      <table>
        <thead><tr><th>Header</th></tr></thead>
        <tfoot><tr><th>Footer</th></tr></tfoot>
      </table>
    ''' % (thead, tfoot, content)
    pages = render_pages(html)
    assert len(pages) == len(rows_expected)
    for i, page in enumerate(pages):
        rows = []
        html, = page.children
        body, = html.children
        table_wrapper = body.children[-1]
        if not table_wrapper.is_table_wrapper:
            assert rows == rows_expected[i]
            continue
        table, = table_wrapper.children
        for group in table.children:
            for row in group.children:
                cell, = row.children
                line, = cell.children
                text, = line.children
                rows.append(text.text)
        assert rows == rows_expected[i]


def test_table_group_break_inside_avoid_absolute():
    # Regression test for #2134.
    html = '''
      <style>
        @page { size: 5cm }
        tbody { break-inside: avoid; line-height: 2cm }
        div { position: absolute }
      </style>
      <table>
        <tbody><tr><td>a</td></tr></tbody>
        <tbody><tr>
          <td><div>a<br>b</div></td>
          <td>a<br>b</td>
        </tr></tbody>
      </table>
    '''
    page1, page2 = render_pages(html)

    html, = page1.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    group, = table.children  # Only first group

    html, = page2.children
    body, = html.children  # No absolute div here
    table_wrapper, = body.children
    table, = table_wrapper.children
    group, = table.children  # Only second group


def test_table_row_break_inside_avoid_absolute():
    # Regression test for #2134.
    html = '''
      <style>
        @page { size: 5cm }
        tr { break-inside: avoid; line-height: 2cm }
        div { position: absolute }
      </style>
      <table>
        <tr><td>a</td></tr>
        <tr>
          <td><div>a<br>b</div></td>
          <td>a<br>b</td>
        </tr>
      </table>
    '''
    page1, page2 = render_pages(html)

    html, = page1.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    group, = table.children
    row, = group.children  # Only first row

    html, = page2.children
    body, = html.children  # No absolute div here
    table_wrapper, = body.children
    table, = table_wrapper.children
    group, = table.children
    row, = group.children  # Only second row


def test_table_break_inside_avoid_absolute():
    # Regression test for #2134.
    html = '''
      <style>
        @page { size: 5cm }
        body { line-height: 2cm }
        table { break-inside: avoid }
        div { position: absolute }
      </style>
      <p>text</p>
      <table>
        <tr>
          <td><div>a<br>b</div></td>
          <td>a<br>b</td>
        </tr>
      </table>
    '''
    page1, page2 = render_pages(html)

    html, = page1.children
    body, = html.children
    p, = body.children
    line, = p.children
    text, = line.children
    assert text.text == 'text'

    html, = page2.children
    body, = html.children  # No absolute div here


def test_table_break_children_margin():
    # Regression test for #1254.
    html = '''
      <style>
        @page { size: 100px }
        p { height: 20px; margin-top: 50px }
      </style>
      <table>
        <tr><td><p>Page1</p></td></tr>
        <tr><td><p>Page2</p></td></tr>
        <tr><td><p>Page3</p></td></tr>
      </table>
    '''
    assert len(render_pages(html)) == 3


def test_table_td_break_inside_avoid():
    # Regression test for #1547.
    html = '''
      <style>
        @page { size: 4cm }
        td { break-inside: avoid; line-height: 3cm }
      </style>
      <table>
        <tr>
          <td>
            a<br>a
          </td>
        </tr>
      </table>
    '''
    assert len(render_pages(html)) == 2


@assert_no_logs
def test_table_bad_int_td_th_span():
    page, = render_pages('''
      <table>
        <tr>
          <td colspan="bad"></td>
          <td rowspan="23.4"></td>
        </tr>
        <tr>
          <th colspan="x" rowspan="-2"></th>
          <th></th>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row_1, row_2 = row_group.children
    td_1, td_2 = row_1.children
    assert td_1.width == td_2.width
    th_1, th_2 = row_2.children
    assert th_1.width == th_2.width


@assert_no_logs
def test_table_bad_int_col_span():
    page, = render_pages('''
      <table>
        <colgroup>
          <col span="bad" style="width:25px" />
        </colgroup>
        <tr>
          <td>a</td>
          <td>a</td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert td_1.width == 25


@assert_no_logs
def test_table_bad_int_colgroup_span():
    page, = render_pages('''
      <table>
        <colgroup span="bad" style="width:25px">
          <col />
        </colgroup>
        <tr>
          <td>a</td>
          <td>a</td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    row, = row_group.children
    td_1, td_2 = row.children
    assert td_1.width == 25


@assert_no_logs
def test_table_different_display():
    # Test display attribute set on different table elements.
    render_pages('''
      <table style="font-size: 1px">
        <colgroup style="display: block"><div>a</div></colgroup>
        <col style="display: block"><div>a</div></col>
        <tr style="display: block"><div>a</div></tr>
        <td style="display: block"><div>a</div></td>
        <th style="display: block"><div>a</div></th>
        <thead>
          <colgroup style="display: block"><div>a</div></colgroup>
          <col style="display: block"><div>a</div></col>
          <tr style="display: block"><div>a</div></tr>
          <td style="display: block"><div>a</div></td>
          <th style="display: block"><div>a</div></th>
        </thead>
        <tbody>
          <colgroup style="display: block"><div>a</div></colgroup>
          <col style="display: block"><div>a</div></col>
          <tr style="display: block"><div>a</div></tr>
          <td style="display: block"><div>a</div></td>
          <th style="display: block"><div>a</div></th>
        </tbody>
        <tr>
          <colgroup style="display: block"><div>a</div></colgroup>
          <col style="display: block"><div>a</div></col>
          <tr style="display: block"><div>a</div></tr>
          <td style="display: block"><div>a</div></td>
          <th style="display: block"><div>a</div></th>
        </tr>
        <td>
          <colgroup style="display: block"><div>a</div></colgroup>
          <col style="display: block"><div>a</div></col>
          <tr style="display: block"><div>a</div></tr>
          <td style="display: block"><div>a</div></td>
          <th style="display: block"><div>a</div></th>
        </td>
      </table>
    ''')


@assert_no_logs
def test_min_width_with_overflow():
    # Regression test for #1383.
    page, = render_pages('''
      <style>
        table td { border: 1px solid black }
        table.key-val tr td:nth-child(1) { min-width: 13em }
      </style>

      <table class="key-val">
        <tbody>
          <tr>
            <td>Normal Key 1</td>
            <td>Normal Value 1</td>
          </tr>
          <tr>
            <td>Normal Key 2</td>
            <td>Normal Value 2</td>
          </tr>
        </tbody>
      </table>

      <table class="key-val">
        <tbody>
          <tr>
            <td>Short value</td>
            <td>Works as expected</td>
          </tr>
          <tr>
            <td>Long Value</td>
            <td>Annoyingly breaks my table layout: Sed ut perspiciatis
                unde omnis iste natus error sit voluptatem
                accusantium doloremque laudantium, totam rem aperiam,
                eaque ipsa quae ab illo inventore veritatis et quasi
                architecto beatae vitae dicta sunt explicabo.
            </td>
          </tr>
        </tbody>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper_1, table_wrapper_2 = body.children

    table1, = table_wrapper_1.children
    tbody1, = table1.children
    tr1, tr2 = tbody1.children
    table1_td1, table1_td2 = tr1.children

    table2, = table_wrapper_2.children
    tbody2, = table2.children
    tr1, tr2 = tbody2.children
    table2_td1, table2_td2 = tr1.children

    assert table1_td1.min_width == table2_td1.min_width
    assert table1_td1.width == table2_td1.width


@assert_no_logs
def test_table_cell_max_width():
    page, = render_pages('''
      <style>
        td {
          text-overflow: ellipsis;
          white-space: nowrap;
          overflow: hidden;
          max-width: 45px;
        }
      </style>
      <table>
        <tr>
          <td>abcdefghijkl</td>
        </tr>
      </table>
    ''')
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    tbody, = table.children
    tr, = tbody.children
    td, = tr.children
    assert td.max_width == 45
    assert td.width == 45


black = (0, 0, 0, 1)
red = (1, 0, 0, 1)
green = (0, 1, 0, 1)  # lime in CSS
blue = (0, 0, 1, 1)
yellow = (1, 1, 0, 1)
black_3 = ('solid', 3, black)
red_1 = ('solid', 1, red)
yellow_5 = ('solid', 5, yellow)
green_5 = ('solid', 5, green)
dashed_blue_5 = ('dashed', 5, blue)


@assert_no_logs
def test_border_collapse_1():
    html = parse_all('<table></table>')
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    assert isinstance(table, boxes.TableBox)
    assert not hasattr(table, 'collapsed_border_grid')

    grid = _get_grid('<table style="border-collapse: collapse"></table>', 0, 0)
    assert grid == ([], [])


@assert_no_logs
def test_border_collapse_2():
    vertical_borders, horizontal_borders = _get_grid('''
      <style>td { border: 1px solid red }</style>
      <table style="border-collapse: collapse; border: 3px solid black">
        <tr> <td>A</td> <td>B</td> </tr>
        <tr> <td>C</td> <td>D</td> </tr>
      </table>
    ''', 2, 2)
    assert vertical_borders == [
        [black_3, red_1, black_3],
        [black_3, red_1, black_3],
    ]
    assert horizontal_borders == [
        [black_3, black_3],
        [red_1, red_1],
        [black_3, black_3],
    ]


@assert_no_logs
def test_border_collapse_3():
    # hidden vs. none
    vertical_borders, horizontal_borders = _get_grid('''
      <style>table, td { border: 3px solid }</style>
      <table style="border-collapse: collapse">
        <tr> <td>A</td> <td style="border-style: hidden">B</td> </tr>
        <tr> <td>C</td> <td style="border-style: none">D</td> </tr>
      </table>
    ''', 2, 2)
    assert vertical_borders == [
        [black_3, None, None],
        [black_3, black_3, black_3],
    ]
    assert horizontal_borders == [
        [black_3, None],
        [black_3, None],
        [black_3, black_3],
    ]


@assert_no_logs
def test_border_collapse_4():
    vertical_borders, horizontal_borders = _get_grid('''
      <style>td { border: 1px solid red }</style>
      <table style="border-collapse: collapse; border: 5px solid yellow">
        <col style="border: 3px solid black" />
        <tr> <td></td> <td></td> <td></td> </tr>
        <tr> <td></td> <td style="border: 5px dashed blue"></td>
          <td style="border: 5px solid lime"></td> </tr>
        <tr> <td></td> <td></td> <td></td> </tr>
        <tr> <td></td> <td></td> <td></td> </tr>
      </table>
    ''', 3, 4)
    assert vertical_borders == [
        [yellow_5, black_3, red_1, yellow_5],
        [yellow_5, dashed_blue_5, green_5, green_5],
        [yellow_5, black_3, red_1, yellow_5],
        [yellow_5, black_3, red_1, yellow_5],
    ]
    assert horizontal_borders == [
        [yellow_5, yellow_5, yellow_5],
        [red_1, dashed_blue_5, green_5],
        [red_1, dashed_blue_5, green_5],
        [red_1, red_1, red_1],
        [yellow_5, yellow_5, yellow_5],
    ]


@assert_no_logs
def test_border_collapse_5():
    # rowspan and colspan
    vertical_borders, horizontal_borders = _get_grid('''
        <style>col, tr { border: 3px solid }</style>
        <table style="border-collapse: collapse">
            <col /><col /><col />
            <tr> <td rowspan=2></td> <td></td> <td></td> </tr>
            <tr>                     <td colspan=2></td> </tr>
        </table>
    ''', 3, 2)
    assert vertical_borders == [
        [black_3, black_3, black_3, black_3],
        [black_3, black_3, None, black_3],
    ]
    assert horizontal_borders == [
        [black_3, black_3, black_3],
        [None, black_3, black_3],
        [black_3, black_3, black_3],
    ]


@assert_no_logs
def test_table_zero_width():
    # Regression test for #2306.
    page, = render_pages('''
      <table style="font-family: weasyprint">
        <thead>
          <tr>
            <th colspan="2">aaaaaaaaaaaaaaaaaa</th>
          </tr>
          <tr>
            <th style="width:80px"></th>
            <th style="width:80px">rrrrr</th>
          </tr>
        </thead>
      </table>
    ''')


@assert_no_logs
def test_table_inline_atomic_nowrap():
    # Regression test for #2661.
    page, = render_pages('''
      <div style="width: 0; font: 2px weasyprint; white-space: nowrap">
        <table>
          <tr>
            <td>a<img src=pattern.png></td>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    table_wrapper, = div.children
    assert div.width == 0
    assert table_wrapper.width == 6


================================================
FILE: tests/resources/acid2-reference.html
================================================
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
<html>
 <head>
  <title>The Second Acid Test (Reference Rendering)</title>
  <style type="text/css">
   html { margin: 0; padding: 0; border: 0; overflow: hidden; background: white; }
   body { margin: 0; padding: 0; border: 0; }
   h2 { margin: 0; padding: 48px 0 36px 84px; border: 0; font: 24px/24px sans-serif; color: navy; }
   p { margin: 0; padding: 0 0 0 72px; border: 0; }
   img { vertical-align: top; margin: 0; padding: 0; border: 0; }
  </style>
 </head>
 <body>
  <h2>Hello&nbsp;World!</h2>
  <p><a href="reference.png"><img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAKgAAACoCAMAAABDlVWGAAABUFBMVEUAAAABAQADAwAICAAIpQQOpwodHQAhISAmryIsLAAwsy1AQEBDQwBSUgBTwFBUVAB1dQCAgACBgQCCggCDgwCEhACFhQCGhgCJiQCJ1IeKigCLiwCMjACOjgCPjwCPj4+SkgCTkwCVlQCXlwCYmACbmwCdnQCdnZ2fnwCgoACiogCi3aClpQCmpgCpqQCrqwCsrACtrQCvrwCwsLCysgCzswC2tgC8vAC9vQC+vgDBwQDCwgDDwwDExADIyADJyQDKygDKysrLywDNzQDOzgDO7c3Q0ADS0gDT0wDU1ADW1gDX1wDa2gDb29vd3QDf3wDg4ADh4QDk5ADl5QDo6ADo9ujp6QDq6gDq6urr6wDs7ADt7QDv7wDw8ADx8QDy8gDz8wDz+vP19QD29gD39wD4+AD5+QD7+wD7+/v8/AD9/QD9/f3+/gD+/v7//wD///+VIlNwAAADWklEQVR42u3d6VPaQBgGcBBBkDNciiCIgKgRTxTPqijeiCeioohcAiH9/7+VduqMbVNIJruMGZ/96Mz77C/AZt/VDKq+yxgqiUPWXIACCiiggAIKKDXo/ybmJQ45FwAooIACCiiggJKFygHJuQBAAQUUUEABBZQeVBTuuVCTC6sVniWjJULLmeT6YUUutHK4nsyUKUJLmY0Zv2+t/Yo+xm1mk8lsiz+KxX2sqK35/DMbmRItaPVs0euw+4/rfMKq06hVKrVGZ02Ic/5RUT/22x3exbMqHWj1bH7U7po8Kb9EDH3G6G46vRs19hkiL92Zf1eUTyZd9tF5ISkBaHZlmGHCpw0+ohsI5Jqt9mjmAgO6SHfoPxWN0zDDDK9kaUArB6F29naFTxgGlt6KKdbjYVPFt6UBQ9d3X6Cist2+6tBBhQL0YXmEcS8U+EdrX+DtlrXotVq9hb19C/RZu6wowYrCgpsZWX4gD62fTzsZ7z7Hx3XGXJEd7P81BtlizqiLd4YKVnD7XsY5fV4nDq0d+e1M6JLjbZpoM2Xp/z0sqWZUY+sMFazgLkOM3X9UIw6tJscY11ye583q3Rarf59Wz7Z21ebOUOGK/JyLGUtWiUNLe0HGNdvONanSLY/2fVqtp5VWmTpDhSuqsy4muFciv5iOxx1DPz/8pKAPy0OO8WMKq/4iZnfHnsi99U8xtz12QQH6mnAwwWtyi+k6yDgSrzR2ppOpId9mg9TtqbHpG5o6obKF5rdCzokyR+aGz5UnnKGtPJ3uKbsajl1xZLZQ7ioWXs1SavNqNzvfCkIthvSmhOcL33ZuarQaZ+71riHQtElv89o/aty9chSPIg2BNlh64/wxihL0fdy/HyzuxR5FxFYQhvb+6Kwc6GfASf3jBKCAAgoooIACCqi4fGVAySbRgxKPogSlkUUDSimMOJReGlko1TiCybTzSAX3IJBIbm8S5cf2LFJmai8zv8YrqpzPqHJWvXLuo8rZmZSz1yune1JOP6qcDl85ZyblnELxCwhAAQUUUEAB/UxQMQ8W0LgYMXNJfgICUEABBRRQQAGV/RChitAQkw8ooIACCiiggJKF4hsLAAUUUEABBfTrQPFNhIACCiiggAL6daD4DwOAAgoooIACqljoDwseYUYsza58AAAAAElFTkSuQmCC" alt="Follow this link to view the reference image, which should be rendered below the text &quot;Hello World!&quot; on the test page in the same way that this paragraph is rendered below that text on this page."></a></p>
 </body>
</html>

================================================
FILE: tests/resources/acid2-test.html
================================================
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
<html>
 <head>
  <title>The Second Acid Test</title>
  <style type="text/css">
   /* section numbers refer to CSS2.1 */

   /* page setup */
   html { font: 12px sans-serif; margin: 0; padding: 0; overflow: hidden; /* hides scrollbars on viewport, see 11.1.1:3 */ background: white; color: red; }
   body { margin: 0; padding: 0; }

   /* introduction message */
   .intro { font: 2em sans-serif; margin: 3.5em 2em; padding: 0.5em; border: solid thin; background: white; color: black; position: relative; z-index: 2; /* should cover the black and red bars that are fixed-positioned */ }
   .intro * { font: inherit; margin: 0; padding: 0; }
   .intro h1 { font-size: 1em; font-weight: bolder; margin: 0; padding: 0; }
   .intro :link { color: blue; }
   .intro :visited { color: purple; }

   /* picture setup */
   #top { margin: 100em 3em 0; padding: 2em 0 0 .5em; text-align: left; font: 2em/24px sans-serif; color: navy; white-space: pre; } /* "Hello World!" text */
   .picture { position: relative; border: 1em solid transparent; margin: 0 0 100em 3em; } /* containing block for face */
   .picture { background: red; } /* overriden by preferred stylesheet below */

   /* top line of face (scalp): fixed positioning and min/max height/width */
   .picture p { position: fixed; margin: 0; padding: 0; border: 0; top: 9em; left: 11em; width: 140%; max-width: 4em; height: 8px; min-height: 1em; max-height: 2mm; /* min-height overrides max-height, see 10.7 */ background: black; border-bottom: 0.5em yellow solid; }

   /* bits that shouldn't be part of the top line (and shouldn't be visible at all): HTML parsing, "+" combinator, stacking order */
   .picture p.bad { border-bottom: red solid; /* shouldn't matter, because the "p + table + p" rule below should match it too, thus hiding it */ }
   .picture p + p { background: maroon; z-index: 1; } /* shouldn't match anything */
   .picture p + table + p { margin-top: 3em; /* should end up under the absolutely positioned table below, and thus not be visible */ }

   /* second line of face: attribute selectors, float positioning */
   [class~=one].first.one { position: absolute; top: 0; margin: 36px 0 0 60px; padding: 0; border: black 2em; border-style: none solid; /* shrink wraps around float */ }
   [class~=one][class~=first] [class=second\ two][class="second two"] { float: right; width: 48px; height: 12px; background: yellow; margin: 0; padding: 0; } /* only content of abs pos block */

   /* third line of face: width and overflow */
   .forehead { margin: 4em; width: 8em; border-left: solid black 1em; border-right: solid black 1em; background: red url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR42mP4%2F58BAAT%2FAf9jgNErAAAAAElFTkSuQmCC); /* that's a 1x1 yellow pixel PNG */ }
   .forehead * { width: 12em; line-height: 1em; }

   /* class selectors headache */
   .two.error.two { background: maroon; } /* shouldn't match */
   .forehead.error.forehead { background: red; } /* shouldn't match */
   [class=second two] { background: red; } /* this should be ignored (invalid selector -- grammar says it only accepts IDENTs or STRINGs) */

   /* fourth and fifth lines of face, with eyes: paint order test (see appendix E) and fixed backgrounds */
   /* the two images are identical: 2-by-2 squares with the top left
      and bottom right pixels set to yellow and the other two set to
      transparent. Since they are offset by one pixel from each other,
      the second one paints exactly over the transparent parts of the
      first one, thus creating a solid yellow block. */
   .eyes { position: absolute; top: 5em; left: 3em; margin: 0; padding: 0; background: red; }
   #eyes-a { height: 0; line-height: 2em; text-align: right; } /* contents should paint top-most because they're inline */
   #eyes-a object { display: inline; vertical-align: bottom; }
   #eyes-a object[type] { width: 7.5em; height: 2.5em; } /* should have no effect since that object should fallback to being inline (height/width don't apply to inlines) */
   #eyes-a object object object { border-right: solid 1em black; padding: 0 12px 0 11px; background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABnRSTlMAAAAAAABupgeRAAAABmJLR0QA%2FwD%2FAP%2BgvaeTAAAAEUlEQVR42mP4%2F58BCv7%2FZwAAHfAD%2FabwPj4AAAAASUVORK5CYII%3D) fixed 1px 0; }
   #eyes-b { float: left; width: 10em; height: 2em; background: fixed url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABnRSTlMAAAAAAABupgeRAAAABmJLR0QA%2FwD%2FAP%2BgvaeTAAAAEUlEQVR42mP4%2F58BCv7%2FZwAAHfAD%2FabwPj4AAAAASUVORK5CYII%3D); border-left: solid 1em black; border-right: solid 1em red; } /* should paint in the middle layer because it is a float */
   #eyes-c { display: block; background: red; border-left: 2em solid yellow; width: 10em; height: 2em; } /* should paint bottom most because it is a block */

   /* lines six to nine, with nose: auto margins */
   .nose { float: left; margin: -2em 2em -1em; border: solid 1em black; border-top: 0; min-height: 80%; height: 60%; max-height: 3em; /* percentages become auto (see 10.5 and 10.7) and intrinsic height is more than 3em, so 3em wins */ padding: 0; width: 12em; }
   .nose > div { padding: 1em 1em 3em; height: 0; background: yellow; }
   .nose div div { width: 2em; height: 2em; background: red; margin: auto; }
   .nose :hover div { border-color: blue; }
   .nose div:hover :before { border-bottom-color: inherit; }
   .nose div:hover :after { border-top-color: inherit; }
   .nose div div:before { display: block; border-style: none solid solid; border-color: red yellow black yellow; border-width: 1em; content: ''; height: 0; }
   .nose div    :after { display: block; border-style: solid solid none; border-color: black yellow red yellow; border-width: 1em; content: ''; height: 0; }

   /* between lines nine and ten: margin collapsing with 'float' and 'clear' */
   .empty { margin: 6.25em; height: 10%; /* computes to auto which makes it empty per 8.3.1:7 (own margins) */ }
   .empty div { margin: 0 2em -6em 4em; }
   .smile { margin: 5em 3em; clear: both; /* clearance is negative (see 8.3.1 and 9.5.1) */ }

   /* line ten and eleven: containing block for abs pos */
   .smile div { margin-top: 0.25em; background: black; width: 12em; height: 2em; position: relative; bottom: -1em; }
   .smile div div { position: absolute; top: 0; right: 1em; width: auto; height: 0; margin: 0; border: yellow solid 1em; }

   /* smile (over lines ten and eleven): backgrounds behind borders, inheritance of 'float', nested floats, negative heights */
   .smile div div span { display: inline; margin: -1em 0 0 0; border: solid 1em transparent; border-style: none solid; float: right; background: black; height: 1em; }
   .smile div div span em { float: inherit; border-top: solid yellow 1em; border-bottom: solid black 1em; } /* zero-height block; width comes from (zero-height) child. */
   .smile div div span em strong { width: 6em; display: block; margin-bottom: -1em; /* should have no effect, since parent has top&bottom borders, so this margin doesn't collapse */ }

   /* line twelve: line-height */
   .chin { margin: -4em 4em 0; width: 8em; line-height: 1em; border-left: solid 1em black; border-right: solid 1em black; background: yellow url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAIAAAFSDNYfAAAAaklEQVR42u3XQQrAIAwAQeP%2F%2F6wf8CJBJTK9lnQ7FpHGaOurt1I34nfH9pMMZAZ8BwMGEvvh%2BBsJCAgICLwIOA8EBAQEBAQEBAQEBK79H5RfIQAAAAAAAAAAAAAAAAAAAAAAAAAAAID%2FABMSqAfj%2FsLmvAAAAABJRU5ErkJggg%3D%3D) /* 64x64 red square */ no-repeat fixed /* shouldn't be visible unless the smiley is moved to the top left of the viewport */; }
   .chin div { display: inline; font: 2px/4px serif; }

   /* line thirteen: cascade and selector tests */
   .parser-container div { color: maroon; border: solid; color: orange; } /* setup */
   div.parser-container * { border-color: black; /* overrides (implied) border-color on previous line */ } /* setup */
   * div.parser { border-width: 0 2em; /* overrides (implied) declarations on earlier line */ } /* setup */

   /* line thirteen continued: parser tests */
   .parser { /* comment parsing test -- comment ends before the end of this line, the backslash should have no effect: \*/ }
   .parser { margin: 0 5em 1em; padding: 0 1em; width: 2em; height: 1em; error: \}; background: yellow; } /* setup with parsing test */
   * html .parser {  background: gray; }
   \.parser { padding: 2em; }
   .parser { m\argin: 2em; };
   .parser { height: 3em; }
   .parser { width: 200; }
   .parser { border: 5em solid red ! error; }
   .parser { background: red pink; }

   /* line fourteen (last line of face): table */
   ul { display: table; padding: 0; margin: -1em 7em 0; background: red; }
   ul li { padding: 0; margin: 0; }
   ul li.first-part { display: table-cell; height: 1em; width: 1em; background: black; }
   ul li.second-part { display: table; height: 1em; width: 1em; background: black; } /* anonymous table cell wraps around this */
   ul li.third-part { display: table-cell; height: 0.5em; /* gets stretched to fit row */ width: 1em; background: black; }
   ul li.fourth-part { list-style: none; height: 1em; width: 1em; background: black; } /* anonymous table cell wraps around this */

   /* bits that shouldn't appear: inline alignment in cells */
   .image-height-test { height: 10px; overflow: hidden; font: 20em serif; } /* only the area between the top of the line box and the top of the image should be visible */
   table { margin: 0; border-spacing: 0; }
   td { padding: 0; }

  </style>
  <link rel="appendix stylesheet" href="data:text/css,.picture%20%7B%20background%3A%20none%3B%20%7D"> <!-- this stylesheet should be applied by default -->
 </head>
 <body>

  <div class="intro">
   <h1>Standards compliant?</h1>
   <p><a href="#top">Take The Acid2 Test</a> and compare it to <a href="reference.html">the reference rendering</a>.</p>
  </div>
  <h2 id="top">Hello World!</h2>

  <div class="picture">
   <p><table><tr><td></table><p class="bad"> <!-- <table> closes <p> per the HTML4 DTD -->
   <blockquote class="first one"><address class="second two"></address></blockquote>
   <div class="forehead"><div>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</div></div>
   <div class="eyes"><div id="eyes-a"><object data="data:application/x-unknown,ERROR"><object data="./404" type="text/html"><object data="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGAAAAAYCAYAAAFy7sgCAAAGsUlEQVRo3u2ZbWwcZxHHf3s%2B7LNbO3ZjXBtowprGODRX0qpNQCjmJKuVKhMl1P2AkCwhFOIKkCBSm9IXavGFKAixIAECwkmWo5MrhRI3Ub40IEwQgp6aIDg3Cd6eEqyIHEteah%2B1E69vhw%2BZtTaX8704ZzkKjHS6271nZ56ZZ%2BY%2F%2F%2BdZKF%2FCwYshx3EkkggLsD1v4FQkEZZYLCbAKyG9%2Ba9EIsG6hnUAf8x74K3aUC3j4%2BM54HcsR2oAIomwZOezkv%2FnSHpYNh%2BNCmAE7xv94zvFdd1bHsjMZmQkPSxAJP%2B%2FfuBLwK54PC7JZFKAVJmzXLBt2w%2FMvcDLwIb8QS8CeJ4nkURYIomw7J%2FYJ8BvSiiXptGGxWds2%2Fa9%2Bnaxh%2BYAD%2Bgt04NDgABTpQY2cvvSFLzw86gWeBVwC8SzlOSv2YeBPfmDBoBHgKmR9LBEEmHZfDTqGykqfkUE0nA78BzQGfSgUeP3wNeTXwXg7MwZDhw4UHL6ra2ti79%2FOvljgG8AZ4H64Lhm4MvAocxsRppGG%2FxcXihlwLIs6R%2FfKV2HO%2F26uA94pdDYUKUZUU7W1RQYXA98Gnhaf5%2FXWX0HeAHYoQonqa4sZSOsSWMCWeC9Yko%2BCQwBe4E6oNc0Tc91XTl1%2BaTsn9gnI%2Blhyc5nZWxsrBIkKSbl2tiic3tW53YDEwOKaoFBrcOfqKee53lG9xsPMjV784r%2F4lO%2FpPvyJ9iyZcuvFSaXK5XYeAZ4CDgGvB3MS4B54LQuWYPeuy4iRFsevsXqpuYoqVQKIH2bK1CuDQNo11o4XUzh%2FcDWYIe1LEtyuZx4niee54njOGKapgfsqlL%2Bl2OjEXg8nxrc1dJ0h3hbtL%2BGCtz7KPBF4CuBe9uB15VafE8hr9qylI3HgG8C2%2FK7VyHZoJj7MrBRm30qFotJMpkU27YlHo%2F7Ha5a%2BV%2FKRkSJ4KuKRLVLKapTjB1SzAVIjY2NSXY%2BKyPpYdk%2FsU9OXT4pruv6BdZbBQfKsVGnvWlIe1VB6VQO8JxC1vZYLCbZ%2BaxsPhpdZDyRRFhG0sPiOE6ldKBg2lRg4xF1YCDIIIKN7DGgD3gH%2BBXwejKZfPrs2tPs%2FvPN2bKuYR1nd7xLKBSSJeqoXKnERjPwNWAG%2BLn2rZuM%2B4Tpml6vaWlp4eLcxVusZq5lCgVgOVKJjRqdX86ffL4D5wIoZACnTpw4wRMdT96i%2FImOJxERAs4uVyqxUacF%2FPdiCj%2BjdRBRGFtwXVdG0sPSdbhTmkYbpH98p2RmM2JZlig1vl0GWo4NQ%2Fn%2Bs5pKRXfwjweaxy7TND3HcRZbfC6X8xVPVQlGy7WxVWlO5XRXFXm6EZmrQuSXYyPE3SiVoEhE6Wyr0u2rumO6zv%2B21AFdQAswC1wCMuUCXCmyWQus103Qg8qlDO0lxwOb%2Fl4FiK3AB3VS%2FuKKLtK%2FgbeAnwG%2FvUODuRw%2FFrR0H1UC75fwu8oJ%2FhFsW5VIG%2FBUgEIN6Y65O4AHu4Ap0zQ9y7LEcZyb9lRBUHQcRyzL8unZVBW5bFWAvAp%2BhDQ2g4F47dUYtlU6obXA54DnVdFLekjUGGifh4AFy7LEdV3xj3X9I66m0QZpGm2QrsOd0j%2B%2BU0bSw5KZzYjrun6HWlAd961i4FfCj0aN1Usau%2Bc1lmuXPFwvAEumUut7tQQvAb%2FXb%2FT0bCAej9cODg7yt%2Bm%2F8q2%2F7OUHZ76PnZ1k2p0mJzlykmPancbOTnL0whHs7CQfb%2B5mx2d3sH79%2BtCRI0c6FeaOr9ICrIQfLvA%2B8BGNXxi4R6HrisJVUWrxAVW2oMFf0Aczim8o3kV6enowDIPjF9%2Fk%2BMU3S3rrjzMMg56eHr%2BxP7qKFbASfojG6kpeDGs1tiW53RxwWT%2Bin5q8w4xpQK5evQpAR30H7ZH2khNvj7TTUd8BgD4rqmu1ZKX8qNeY%2BfHz4zlXDgT5E8tpCTUq7XSBC4Euv8227TV9fX1E73%2BYtvo27BmbS9cvFVTY3bSRFza9yOcf6Gfmygy7d%2B%2Fm%2FPnzF4DvrsBLhnJlJfwIKXxv1PheAE4qK6p4H9AGbNKTuhngBPBPXYRe4IemaT5kWZbR19fHNbmGnZ1k4r3U4glDR30Hm5qjbGjsImJEOHbsGHv27JFz5869o0eFq01Jq%2BmHAXwI6FFKagMTgHM7GzFDS%2BoeLSMv7zjzC9x4Y7gxFovVDAwMEI1GaWlpWSzRVCrFwYMH%2FXfxZ4AfAa8B%2F7lDaGg1%2FQgp43lfK0yqtRMuJa3ceKe5DfgYsCYAZ2ngD8CfAkzqTpW7xY%2F%2FSznyX%2FVeUb2kVmX4AAAAAElFTkSuQmCC">ERROR</object></object></object></div><div id="eyes-b"></div><div id="eyes-c"></div></div> <!-- that's a PNG with 8bit alpha containing two eyes -->
   <div class="nose"><div><div></div></div></div>
   <div class="empty"><div></div></div>

   <div class="smile"><div><div><span><em><strong></strong></em></span></div></div></div>
   <div class="chin"><div>&nbsp;</div></div>
   <div class="parser-container"><div class="parser"><!-- ->ERROR<!- --></div></div> <!-- two dashes is what delimits a comment, so the text "->ERROR<!-" earlier on this line is actually part of a comment -->
   <ul>
    <li class="first-part"></li>
    <li class="second-part"></li>
    <li class="third-part"></li>
    <li class="fourth-part"></li>

   </ul>
   <div class="image-height-test"><table><tr><td><img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAIAAAFSDNYfAAAAaklEQVR42u3XQQrAIAwAQeP%2F%2F6wf8CJBJTK9lnQ7FpHGaOurt1I34nfH9pMMZAZ8BwMGEvvh%2BBsJCAgICLwIOA8EBAQEBAQEBAQEBK79H5RfIQAAAAAAAAAAAAAAAAAAAAAAAAAAAID%2FABMSqAfj%2FsLmvAAAAABJRU5ErkJggg%3D%3D" alt=""></td></tr></table></div>
  </div>
 </body>
</html>


================================================
FILE: tests/resources/doc1.html
================================================
<html>
<head>
    <meta http-equiv=Content-Type content=text/html;charset=utf-8>
    <!-- currentColor means 'inherit' on color itself. -->
    <link rel=stylesheet href="data:text/css;charset=ASCII,a%7Bcolor%3AcurrentColor%7D">
    <style media=print>
        @import url(sub_directory/sheet1.css);
        @import "data:text/css;charset=utf-16le;base64,\
                    bABpAHsAYwBvAGwAbwByADoAcgBlAGQAfQA=";
        @import "data:,ul {border-width: 1000px !important}" screen;
        @font-face { src: url(weasyprint.otf); font-family: weasyprint }
        a:after {
            content: " [" attr(href) "]";
            border-style: solid;
            border-top-width: inherit;
            border-bottom-width: initial;
        }
        @page :first { margin-top: 5px }
        ul {
            border-style: none solid hidden;
            border-width: thin thick 4px .25in;
        }
        body > h1:first-child {
            background-image: url(logo_small.png);
        }
        h1 ~ p ~ ul a:after {
            background: red;
        }
    </style>
    <style type=text/NOT-css>
        ul {
            border-width: 1000px !important;
        }
    </style>
    <style media=screen>
        ul {
            border-width: 1000px !important;
        }
    </style>
    <link rel=not_stylesheet href="data:,ul {border-width: 1000px !important}">
</head>
<body style="font-size: 20px">
    <h1 style="font-size: 2em">WeasyPrint test document (with Ünicōde)</h1>
    <p style="color: blue; font-size: x-large;
              -weasy-link: attr(foo-link)  /* no such attribute */">Hello</p>
    <ul style="font-family: weasyprint; font-size: 1.25ex">
        <li style="font-size: 6pt; font-weight: bold">
            <a href=home.html
                style="padding: 1px 2px 3px 4px; border: 42px solid;
                       font-size: 300%; font-weight: bolder">Home</a>
        <li>…
    </ul>
    <div style="font-size: 2em">
      <span style="display: block; width: 10rem; height: 10em">
        <span style="font-size: 2rem">WeasyPrint</span>
      </span>
    </div>
</body>


================================================
FILE: tests/resources/latin1-test.css
================================================
h1::before {
    content: "Ilv Unicode";
    background-image: url(pattern.png)
}


================================================
FILE: tests/resources/mini_ua.css
================================================
/* Minimal user-agent stylesheet */
p { margin: 1em 0px } /* 0px should be translated to 0*/
a { text-decoration: underline }
h1 { font-weight: bolder }


================================================
FILE: tests/resources/sheet2.css
================================================
li {
    margin-bottom: 3em; /* Should be masked*/
    margin: 2em 0;
    margin-left: 4em; /* Should not be masked*/
}


================================================
FILE: tests/resources/sub_directory/sheet1.css
================================================
@import url(../sheet2.css) all;
p {
    background: currentColor;
}

@media print {
    ul {
        /* 1ex == 0.8em for weasyprint.otf. */
        margin: 2em 2.5ex;
    }
}
@media screen {
    ul {
        border-width: 1000px !important;
    }
}


================================================
FILE: tests/resources/tests_ua.css
================================================
/* Simplified user-agent stylesheet for HTML5 in tests. */

@font-face { src: url(weasyprint.otf); font-family: weasyprint }
@page { background: white; bleed: 0; @footnote { margin: 0 } }

html, body, div, h1, h2, h3, h4, ol, p, ul, hr, pre, section, article { display: block }

body      { orphans: 1; widows: 1 }
li        { display: list-item }
head      { display: none }
pre       { white-space: pre }
br:before { content: '\A'; white-space: pre-line }
ol        { list-style-type: decimal }
ol, ul    { counter-reset: list-item }

table     { display: table; box-sizing: border-box }
tr        { display: table-row }
thead     { display: table-header-group }
tbody     { display: table-row-group }
tfoot     { display: table-footer-group }
col       { display: table-column }
colgroup  { display: table-column-group }
td, th    { display: table-cell }
caption   { display: table-caption }

*[lang]   { -weasy-lang: attr(lang) }
a[href]   { -weasy-link: attr(href) }
a[name]   { -weasy-anchor: attr(name) }
*[id]     { -weasy-anchor: attr(id) }
h1        { bookmark-level: 1; bookmark-label: content(text) }
h2        { bookmark-level: 2; bookmark-label: content(text) }
h3        { bookmark-level: 3; bookmark-label: content(text) }
h4        { bookmark-level: 4; bookmark-label: content(text) }
h5        { bookmark-level: 5; bookmark-label: content(text) }
h6        { bookmark-level: 6; bookmark-label: content(text) }

::marker  { font-variant-numeric: tabular-nums }

::footnote-call   { content: counter(footnote) }
::footnote-marker { content: counter(footnote) '.' }


================================================
FILE: tests/resources/user.css
================================================
html {
    /* Reversed contrast */
    color: white;
    background-color: black;
}


================================================
FILE: tests/resources/utf8-test.css
================================================
h1::before {
    content: "I løvë Unicode";
    background-image: url(pattern.png)
}


================================================
FILE: tests/test_acid2.py
================================================
"""Check the famous Acid2 test."""

import io

from PIL import Image

from weasyprint import CSS, HTML

from .testing_utils import assert_no_logs, capture_logs, resource_path


@assert_no_logs
def test_acid2(assert_pixels_equal):
    # Reduce image size and avoid Ghostscript rounding problems
    stylesheets = (CSS(string='@page { size: 500px 800px }'),)

    def render(filename):
        return HTML(resource_path(filename)).render(stylesheets=stylesheets)

    with capture_logs():
        # This is a copy of https://www.webstandards.org/files/acid2/test.html
        document = render('acid2-test.html')
        intro_page, test_page = document.pages
        # Ignore the intro page: it is not in the reference
        test_png = document.copy([test_page]).write_png()
        test_pixels = Image.open(io.BytesIO(test_png)).get_flattened_data()

    # This is a copy of https://www.webstandards.org/files/acid2/reference.html
    ref_png = render('acid2-reference.html').write_png()
    ref_image = Image.open(io.BytesIO(ref_png))
    ref_pixels = ref_image.get_flattened_data()
    width, height = ref_image.size

    assert_pixels_equal(width, height, test_pixels, ref_pixels, tolerance=2)


================================================
FILE: tests/test_api.py
================================================
"""Test the public API."""

import contextlib
import gzip
import io
import os
import re
import sys
import threading
import unicodedata
import wsgiref.simple_server
import zlib
from base64 import b64encode
from functools import partial
from pathlib import Path
from urllib.parse import urljoin, uses_relative

import pytest
from PIL import Image

from weasyprint import CSS, HTML, __main__, default_url_fetcher
from weasyprint.pdf.anchors import resolve_links

from .draw import parse_pixels
from .testing_utils import FakeHTML, assert_no_logs, capture_logs, resource_path

from weasyprint.urls import (  # isort:skip
    FatalURLFetchingError, URLFetcher, URLFetcherResponse, URLFetchingError, path2url)

try:
    # Available in Python 3.11+
    from contextlib import chdir
except ImportError:
    # Backported from Python 3.11
    from contextlib import AbstractContextManager

    class chdir(AbstractContextManager):  # noqa: N801
        def __init__(self, path):
            self.path = path
            self._old_cwd = []

        def __enter__(self):
            self._old_cwd.append(os.getcwd())
            os.chdir(self.path)

        def __exit__(self, *excinfo):
            os.chdir(self._old_cwd.pop())


def _test_resource(class_, name, check, **kwargs):
    """Common code for testing the HTML and CSS classes."""
    absolute_path = resource_path(name)
    absolute_filename = str(absolute_path)
    url = path2url(absolute_path)
    check(class_(absolute_path, **kwargs))
    check(class_(absolute_filename, **kwargs))
    check(class_(guess=absolute_path, **kwargs))
    check(class_(guess=absolute_filename, **kwargs))
    check(class_(filename=absolute_path, **kwargs))
    check(class_(filename=absolute_filename, **kwargs))
    check(class_(url, **kwargs))
    check(class_(guess=url, **kwargs))
    url = path2url(absolute_filename.encode())
    check(class_(url=url, **kwargs))
    with absolute_path.open('rb') as fd:
        check(class_(fd, **kwargs))
    with absolute_path.open('rb') as fd:
        check(class_(guess=fd, **kwargs))
    with absolute_path.open('rb') as fd:
        check(class_(file_obj=fd, **kwargs))
    content = absolute_path.read_bytes()
    with chdir(Path(__file__).parent):
        relative_path = Path('resources') / name
        relative_filename = str(relative_path)
        check(class_(relative_path, **kwargs))
        check(class_(relative_filename, **kwargs))
        kwargs.pop('base_url', None)
        check(class_(string=content, base_url=relative_filename, **kwargs))
        encoding = kwargs.pop('encoding', 'utf-8')
        with absolute_path.open('r', encoding=encoding) as fd:
            check(class_(file_obj=fd, **kwargs))
        check(class_(
            string=content.decode(encoding), base_url=relative_filename,
            **kwargs))
    with pytest.raises(TypeError):
        class_(filename='foo', url='bar')


def _check_doc1(html, has_base_url=True):
    """Check that a parsed HTML document looks like resources/doc1.html"""
    root = html.etree_element
    assert root.tag == 'html'
    assert [child.tag for child in root] == ['head', 'body']
    _head, body = root
    assert [child.tag for child in body] == ['h1', 'p', 'ul', 'div']
    h1, p, ul, div = body
    assert h1.text == 'WeasyPrint test document (with Ünicōde)'
    if has_base_url:
        url = urljoin(html.base_url, 'pattern.png')
        assert url.startswith('file:')
        assert url.endswith('tests/resources/pattern.png')
    else:
        assert html.base_url is None


def _run(args, stdin=b''):
    stdin = io.BytesIO(stdin)
    stdout = io.BytesIO()
    HTML = partial(FakeHTML, force_uncompressed_pdf=False)  # noqa: N806
    __main__.main(args.split(), stdin=stdin, stdout=stdout, HTML=HTML)
    return stdout.getvalue()


def _gzip_compress(data):
    file_obj = io.BytesIO()
    gzip_file = gzip.GzipFile(fileobj=file_obj, mode='wb')
    gzip_file.write(data)
    gzip_file.close()
    return file_obj.getvalue()


@contextlib.contextmanager
def http_server():
    handlers = {
        '/gzip': lambda env: (
            (_gzip_compress(b'<html test=ok>'), {'Content-Encoding': 'gzip'})
            if 'gzip' in env.get('HTTP_ACCEPT_ENCODING', '') else
            (b'<html test=accept-encoding-header-fail>', {})
        ),
        '/deflate': lambda env: (
            (zlib.compress(b'<html test=ok>'), {'Content-Encoding': 'deflate'})
            if 'deflate' in env.get('HTTP_ACCEPT_ENCODING', '') else
            (b'<html test=accept-encoding-header-fail>', {})
        ),
        '/raw-deflate': lambda env: (
            # Remove zlib header and checksum
            (zlib.compress(b'<html test=ok>')[2:-4], {'Content-Encoding': 'deflate'})
            if 'deflate' in env.get('HTTP_ACCEPT_ENCODING', '') else
            (b'<html test=accept-encoding-header-fail>', {})
        ),
        '/redirect': lambda env: (b'', {'Location': '/gzip'}),
        '/redirect-loop': lambda env: (b'', {'Location': '/redirect-loop-2'}),
        '/redirect-loop-2': lambda env: (b'', {'Location': '/redirect-loop'}),
    }

    def wsgi_app(environ, start_response):
        handler = handlers.get(environ['PATH_INFO'])
        if handler:
            response, headers = handler(environ)
            status = '301 Moved Permanently' if 'Location' in headers else '200 OK'
            headers = [(str(name), str(value)) for name, value in headers.items()]
        else:  # pragma: no cover
            status = '404 Not Found'
            response = b''
            headers = []
        start_response(status, headers)
        return [response]

    # Port 0: let the OS pick an available port number
    # https://stackoverflow.com/a/1365284/1162888
    server = wsgiref.simple_server.make_server('127.0.0.1', 0, wsgi_app)
    _host, port = server.socket.getsockname()
    thread = threading.Thread(target=server.serve_forever)
    thread.start()
    try:
        yield f'http://127.0.0.1:{port}'
    finally:
        server.shutdown()
        thread.join()


class FakeFile:
    def __init__(self):
        self.chunks = []

    def write(self, data):
        self.chunks.append(bytes(data[:]))

    def getvalue(self):
        return b''.join(self.chunks)


def _png_size(png_bytes):
    image = Image.open(io.BytesIO(png_bytes))
    return image.width, image.height


def _round_meta(pages):
    """Eliminate errors of floating point arithmetic for metadata."""
    for page in pages:
        anchors = page.anchors
        for anchor_name, (x1, y1, x2, y2) in anchors.items():
            anchors[anchor_name] = (
                round(x1, 6), round(y1, 6),
                round(x2, 6), round(y2, 6))
        links = page.links
        for i, link in enumerate(links):
            link_type, target, rectangle, box = link
            pos_x, pos_y, width, height = rectangle
            link = (
                link_type, target,
                (round(pos_x, 6), round(pos_y, 6),
                 round(width, 6), round(height, 6)),
                box)
            links[i] = link
        bookmarks = page.bookmarks
        for i, (level, label, (pos_x, pos_y), state) in enumerate(bookmarks):
            bookmarks[i] = (
                level, label, (round(pos_x, 6), round(pos_y, 6)), state)


@assert_no_logs
def test_html_parsing():
    """Test the constructor for the HTML class."""
    _test_resource(FakeHTML, 'doc1.html', _check_doc1)
    _test_resource(
        FakeHTML, 'doc1_UTF-16BE.html', _check_doc1, encoding='UTF-16BE')

    with chdir(Path(__file__).parent):
        path = Path('resources') / 'doc1.html'
        string = path.read_text('utf-8')
        _test_resource(FakeHTML, 'doc1.html', _check_doc1, base_url=path)
        _check_doc1(FakeHTML(string=string, base_url=path))
        _check_doc1(FakeHTML(string=string), has_base_url=False)
        string_with_base = string.replace(
            '<meta', '<base href="resources/"><meta')
        _check_doc1(FakeHTML(string=string_with_base, base_url='.'))
        string_with_no_base = string.replace('<meta', '<base><meta')
        _check_doc1(FakeHTML(string=string_with_no_base), has_base_url=False)


@assert_no_logs
def test_css_parsing():
    """Test the constructor for the CSS class."""
    def check_css(css):
        """Check that a parsed stylsheet looks like resources/utf8-test.css"""
        # Using 'encoding' adds a CSSCharsetRule
        h1_rule, = css.matcher.lower_local_name_selectors['h1']
        assert h1_rule[3] == 'before'
        assert h1_rule[4][0][0][0] == 'content'
        assert h1_rule[4][0][0][1][0][1] == 'I løvë Unicode'
        assert h1_rule[4][0][1][0] == 'background_image'
        assert h1_rule[4][0][1][1][0][0] == 'url'
        assert h1_rule[4][0][1][1][0][1].startswith('file:')
        assert h1_rule[4][0][1][1][0][1].endswith('tests/resources/pattern.png')

    _test_resource(CSS, 'utf8-test.css', check_css)
    _test_resource(CSS, 'latin1-test.css', check_css, encoding='latin1')


def check_png_pattern(assert_pixels_equal, png_bytes, x2=False, blank=False,
                      rotated=False):
    if blank:
        expected_pixels = '''
            ________
            ________
            ________
            ________
            ________
            ________
            ________
            ________
        '''
    elif x2:
        expected_pixels = '''
            ________________
            ________________
            ________________
            ________________
            ____rrBBBBBB____
            ____rrBBBBBB____
            ____BBBBBBBB____
            ____BBBBBBBB____
            ____BBBBBBBB____
            ____BBBBBBBB____
            ____BBBBBBBB____
            ____BBBBBBBB____
            ________________
            ________________
            ________________
            ________________
        '''
    elif rotated:
        expected_pixels = '''
            ________
            ________
            __BBBB__
            __BBBB__
            __BBBB__
            __rBBB__
            ________
            ________
        '''
    else:
        expected_pixels = '''
            ________
            ________
            __rBBB__
            __BBBB__
            __BBBB__
            __BBBB__
            ________
            ________
        '''
    image = Image.open(io.BytesIO(png_bytes))
    width, height, pixels = parse_pixels(expected_pixels)
    assert_pixels_equal(width, height, image.get_flattened_data(), pixels)


@assert_no_logs
def test_python_render(assert_pixels_equal, tmp_path):
    """Test rendering with the Python API."""
    base_url = str(resource_path('dummy.html'))
    html_string = '<body><img src=pattern.png>'
    css_string = '''
        @page { margin: 2px; size: 8px }
        body { margin: 0; font-size: 0 }
        img { image-rendering: pixelated }

        @media screen { img { transform: rotate(-90deg) } }
    '''
    html = FakeHTML(string=html_string, base_url=base_url)
    css = CSS(string=css_string)

    png_bytes = html.write_png(stylesheets=[css])
    pdf_bytes = html.write_pdf(stylesheets=[css])
    assert png_bytes.startswith(b'\211PNG\r\n\032\n')
    assert pdf_bytes.startswith(b'%PDF')
    check_png_pattern(assert_pixels_equal, png_bytes)

    png_file = FakeFile()
    html.write_png(png_file, stylesheets=[css])
    assert png_file.getvalue() == png_bytes
    pdf_file = FakeFile()
    html.write_pdf(pdf_file, stylesheets=[css])
    assert pdf_file.getvalue().startswith(b'%PDF')

    png_path = tmp_path / '1.png'
    pdf_path = tmp_path / '1.pdf'
    html.write_png(png_path, stylesheets=[css])
    html.write_pdf(pdf_path, stylesheets=[css])
    assert png_path.read_bytes() == png_bytes
    assert pdf_path.read_bytes().startswith(b'%PDF')

    png_path = tmp_path / '2.png'
    pdf_path = tmp_path / '2.pdf'
    with png_path.open('wb') as png_fd:
        html.write_png(png_fd, stylesheets=[css])
    with pdf_path.open('wb') as pdf_fd:
        html.write_pdf(pdf_fd, stylesheets=[css])
    assert png_path.read_bytes() == png_bytes
    assert pdf_path.read_bytes().startswith(b'%PDF')

    x2_png_bytes = html.write_png(stylesheets=[css], resolution=192)
    check_png_pattern(assert_pixels_equal, x2_png_bytes, x2=True)

    screen_css = CSS(string=css_string, media_type='screen')
    rotated_png_bytes = html.write_png(stylesheets=[screen_css])
    check_png_pattern(assert_pixels_equal, rotated_png_bytes, rotated=True)

    assert FakeHTML(
        string=html_string, base_url=base_url, media_type='screen'
    ).write_png(
        stylesheets=[io.BytesIO(css_string.encode())]
    ) == rotated_png_bytes
    assert FakeHTML(
        string=f'<style>{css_string}</style>{html_string}',
        base_url=base_url, media_type='screen'
    ).write_png() == rotated_png_bytes


@assert_no_logs
def test_unknown_options():
    with capture_logs() as logs:
        pdf_bytes = FakeHTML(string='test').write_pdf(zoom=2, unknown=True)
    assert len(logs) == 1
    assert 'unknown' in logs[0]
    assert pdf_bytes


@assert_no_logs
def test_command_line_render(tmp_path):
    css = b'''
        @page { margin: 2px; size: 8px }
        @media screen { img { transform: rotate(-90deg) } }
        body { margin: 0; font-size: 0 }
    '''
    html = b'<body><img src=pattern.png>'
    combined = b'<style>' + css + b'</style>' + html
    linked = b'<link rel=stylesheet href=style.css>' + html
    not_optimized = b'<body>a<img src="not-optimized.jpg">'

    for name in ('pattern.png', 'not-optimized.jpg'):
        pattern_bytes = resource_path(name).read_bytes()
        (tmp_path / name).write_bytes(pattern_bytes)

    with chdir(tmp_path):
        # Reference
        html_obj = FakeHTML(
            string=combined, base_url='dummy.html',
            force_uncompressed_pdf=False)
        pdf_bytes = html_obj.write_pdf()
        rotated_pdf_bytes = FakeHTML(
            string=combined, base_url='dummy.html',
            media_type='screen', force_uncompressed_pdf=False).write_pdf()

        (tmp_path / 'no_css.html').write_bytes(html)
        (tmp_path / 'combined.html').write_bytes(combined)
        (tmp_path / 'combined-UTF-16BE.html').write_bytes(
            combined.decode().encode('UTF-16BE'))
        (tmp_path / 'linked.html').write_bytes(linked)
        (tmp_path / 'not_optimized.html').write_bytes(not_optimized)
        (tmp_path / 'style.css').write_bytes(css)

        _run('combined.html out2.pdf')
        assert (tmp_path / 'out2.pdf').read_bytes() == pdf_bytes

        _run('combined-UTF-16BE.html out3.pdf --encoding UTF-16BE')
        assert (tmp_path / 'out3.pdf').read_bytes() == pdf_bytes

        _run(f'{(tmp_path / "combined.html")} out4.pdf')
        assert (tmp_path / 'out4.pdf').read_bytes() == pdf_bytes

        _run(f'{path2url(tmp_path / "combined.html")} out5.pdf')
        assert (tmp_path / 'out5.pdf').read_bytes() == pdf_bytes

        _run('linked.html --debug out6.pdf')  # test relative URLs
        assert (tmp_path / 'out6.pdf').read_bytes() == pdf_bytes

        _run('combined.html --verbose out7')
        _run('combined.html --quiet out8')
        assert (tmp_path / 'out7').read_bytes() == pdf_bytes
        assert (tmp_path / 'out8').read_bytes() == pdf_bytes

        _run('no_css.html out9.pdf')
        _run('no_css.html out10.pdf -s style.css')
        assert (tmp_path / 'out9.pdf').read_bytes() != pdf_bytes
        assert (tmp_path / 'out10.pdf').read_bytes() == pdf_bytes

        stdout = _run('combined.html -')
        assert stdout == pdf_bytes

        _run('- out11.pdf', stdin=combined)
        assert (tmp_path / 'out11.pdf').read_bytes() == pdf_bytes

        stdout = _run('- -', stdin=combined)
        assert stdout == pdf_bytes

        _run('combined.html out13.pdf --media-type screen')
        _run('combined.html out12.pdf -m screen')
        _run('linked.html out14.pdf -m screen')
        assert (tmp_path / 'out12.pdf').read_bytes() == rotated_pdf_bytes
        assert (tmp_path / 'out13.pdf').read_bytes() == rotated_pdf_bytes
        assert (tmp_path / 'out14.pdf').read_bytes() == rotated_pdf_bytes

        os.environ['SOURCE_DATE_EPOCH'] = '0'
        _run('not_optimized.html out15.pdf')
        _run('not_optimized.html out16.pdf --optimize-images')
        _run('not_optimized.html out17.pdf --optimize-images -j 10')
        _run('not_optimized.html out18.pdf --optimize-images -j 10 -D 1')
        _run('not_optimized.html out19.pdf --hinting')
        _run('not_optimized.html out20.pdf --full-fonts')
        _run('not_optimized.html out21.pdf --full-fonts --uncompressed-pdf')
        _run(f'not_optimized.html out22.pdf -c {tmp_path}')
        assert (
            len((tmp_path / 'out18.pdf').read_bytes()) <
            len((tmp_path / 'out17.pdf').read_bytes()) <
            len((tmp_path / 'out16.pdf').read_bytes()) <
            len((tmp_path / 'out15.pdf').read_bytes()) <
            len((tmp_path / 'out19.pdf').read_bytes()) <
            len((tmp_path / 'out20.pdf').read_bytes()) <
            len((tmp_path / 'out21.pdf').read_bytes()))
        assert len({
            (tmp_path / f'out{i}.pdf').read_bytes()
            for i in (15, 22)}) == 1
        os.environ.pop('SOURCE_DATE_EPOCH')

        stdout = _run('combined.html --uncompressed-pdf -')
        assert stdout.count(b'Filespec') == 0
        stdout = _run('combined.html --uncompressed-pdf -')
        assert stdout.count(b'Filespec') == 0
        stdout = _run('-a pattern.png --uncompressed-pdf combined.html -')
        assert stdout.count(b'Filespec') == 1
        stdout = _run(
            '-a style.css -a pattern.png --uncompressed-pdf combined.html -')
        assert stdout.count(b'Filespec') == 2

        _run('combined.html out23.pdf --timeout 30')
        assert (tmp_path / 'out23.pdf').read_bytes() == pdf_bytes

    subdirectory = tmp_path / 'subdirectory'
    subdirectory.mkdir()
    with chdir(subdirectory):
        with capture_logs() as logs:
            stdout = _run('- -', stdin=combined)
        assert len(logs) == 1
        assert logs[0].startswith('ERROR: Failed to load image')
        assert stdout.startswith(b'%PDF')

        with capture_logs() as logs:
            stdout = _run('--base-url= - -', stdin=combined)
        assert len(logs) == 1
        assert logs[0].startswith(
            'ERROR: Relative URI reference without a base URI')
        assert stdout.startswith(b'%PDF')

        stdout = _run('--base-url .. - -', stdin=combined)
        assert stdout == pdf_bytes

    with pytest.raises(SystemExit):
        _run('--info')

    with pytest.raises(SystemExit):
        _run('--version')


@pytest.mark.parametrize(('version', 'pdf_version'), [
    ('1a', '1.4'),
    ('2b', '1.7'),
    ('3u', '1.7'),
    ('4e', '2.0'),
])
@assert_no_logs
def test_pdfa(version, pdf_version):
    stdout = _run(
        f'--pdf-variant=pdf/a-{version} --uncompressed-pdf - -', b'<html lang=en>test')
    assert f'PDF-{pdf_version}'.encode() in stdout
    assert f'part="{version[0]}"'.encode() in stdout


@pytest.mark.parametrize(('version', 'pdf_version'), [
    ('1a', '1.4'),
    ('2b', '1.7'),
    ('3u', '1.7'),
    ('4e', '2.0'),
])
@assert_no_logs
def test_pdfa_compressed(version, pdf_version):
    stdout = _run(f'--pdf-variant=pdf/a-{version} - -', b'<html lang=en>test')
    assert f'PDF-{pdf_version}'.encode() in stdout


def test_pdfa1b_cidset():
    stdout = _run('--pdf-variant=pdf/a-1b --uncompressed-pdf - -', b'test')
    assert b'PDF-1.4' in stdout
    assert b'CIDSet' in stdout


@pytest.mark.parametrize(('version', 'pdf_version'), [
    (1, '1.7'),
    (2, '2.0'),
])
@assert_no_logs
def test_pdfua(version, pdf_version):
    stdout = _run(
        f'--pdf-variant=pdf/ua-{version} --uncompressed-pdf - -', b'<html lang=en>test')
    assert f'PDF-{pdf_version}'.encode() in stdout
    assert f'part="{version}"'.encode() in stdout


@pytest.mark.parametrize(('version', 'pdf_version'), [
    (1, '1.7'),
    (2, '2.0'),
])
@assert_no_logs
def test_pdfua_compressed(version, pdf_version):
    stdout = _run(f'--pdf-variant=pdf/ua-{version} - -', b'<html lang=en>test')
    assert f'PDF-{pdf_version}'.encode() in stdout


@assert_no_logs
def test_pdf_tags():
    stdout = _run('--pdf-tags --uncompressed-pdf - -', b'<html lang=en><article>test')
    assert b'/StructTreeRoot' in stdout
    assert b'/Art' in stdout


@assert_no_logs
def test_pdf_identifier():
    stdout = _run('--pdf-identifier=abc --uncompressed-pdf - -', b'test')
    assert b'abc' in stdout


@assert_no_logs
def test_pdf_version():
    stdout = _run('--pdf-version=1.4 --uncompressed-pdf - -', b'test')
    assert b'PDF-1.4' in stdout


@assert_no_logs
def test_pdf_custom_metadata():
    stdout = _run(
        '--custom-metadata --uncompressed-pdf - -',
        b'<meta name=key content=value />')
    assert b'/key' in stdout
    assert b'value' in stdout


@assert_no_logs
def test_bad_pdf_custom_metadata():
    stdout = _run(
        '--custom-metadata --uncompressed-pdf - -',
        '<meta name=é content=value />'.encode('latin1'))
    assert b'value' not in stdout


@assert_no_logs
def test_partial_pdf_custom_metadata():
    stdout = _run(
        '--custom-metadata --uncompressed-pdf - -',
        '<meta name=a.b/céd0 content=value />'.encode('latin1'))
    assert b'/abcd0' in stdout
    assert b'value' in stdout


@assert_no_logs
def test_pdf_srgb():
    stdout = _run('--srgb --uncompressed-pdf - -', b'test')
    assert b'sRGB' in stdout


@assert_no_logs
def test_pdf_no_srgb():
    stdout = _run('--uncompressed-pdf - -', b'test')
    assert b'sRGB' not in stdout


@assert_no_logs
def test_pdf_font_name():
    # Regression test for #2396.
    stdout = _run('--uncompressed-pdf - -', b'<div style="font-family:weasyprint">test')
    assert b'+weasyprint/' in stdout


@assert_no_logs
def test_to_unicode():
    # Regression test for #2388.
    stdout = _run('--uncompressed-pdf --full-fonts - -', b'test')
    matches = re.findall(b'(\\d+) beginbfchar', stdout)
    assert matches
    for match in matches:
        assert int(match) <= 100


@assert_no_logs
def test_to_unicode_rtl():
    # Regression test for #378.
    stdout = _run(
        '--uncompressed-pdf -e utf-8 - -',
        '<div style="font-family: weasyprint">اب'.encode())
    assert b'<00cf> <0627>' in stdout
    assert b'<00d0> <0628>' in stdout


@assert_no_logs
def test_no_redirect():
    with http_server() as root_url:
        _run(f'--no-http-redirect {root_url}/gzip -')
        with pytest.raises(URLFetchingError):
            _run(f'--no-http-redirect {root_url}/bad -')
        with pytest.raises(URLFetchingError):
            _run(f'--no-http-redirect {root_url}/redirect -')
        with capture_logs() as logs:
            _run(
                '--no-http-redirect - -',
                f'<link rel=stylesheet href="{root_url}/redirect">'.encode())
        assert len(logs) == 1
        assert 'Failed to load stylesheet' in logs[0]


@assert_no_logs
def test_fail_on_error():
    with http_server() as root_url:
        _run(f'--fail-on-http-error {root_url}/gzip -')
        _run(f'--fail-on-http-error {root_url}/redirect -')
        with pytest.raises(FatalURLFetchingError):
            _run(f'--fail-on-http-error {root_url}/bad -')
        with pytest.raises(FatalURLFetchingError):
            _run(
                '--fail-on-http-error - -',
                f'<link rel=stylesheet href="{root_url}/bad">'.encode())


@assert_no_logs
def test_no_redirect_fail_on_error():
    with http_server() as root_url:
        _run(f'--no-http-redirect --fail-on-http-error {root_url}/gzip -')
        with pytest.raises(FatalURLFetchingError):
            _run(f'--no-http-redirect --fail-on-http-error {root_url}/redirect -')
        with pytest.raises(FatalURLFetchingError):
            _run(f'--no-http-redirect --fail-on-http-error {root_url}/bad -')
        with pytest.raises(FatalURLFetchingError):
            _run(
                '--no-http-redirect --fail-on-http-error - -',
                f'<link rel=stylesheet href="{root_url}/bad">'.encode())


@assert_no_logs
@pytest.mark.parametrize('command', [
    '- -',
    '--allowed-protocols file - -',
    '--allowed-protocols file,http - -',
    '--allowed-protocols file,file - -',
    '--allowed-protocols Http,File - -',
])
def test_allowed_protocols(command):
    _run(command, f'<img src="{path2url(resource_path("pattern.png"))}">'.encode())


@assert_no_logs
@pytest.mark.parametrize('command', [
    '- -',
    '--allowed-protocols data - -',
    '--allowed-protocols File,Data - -',
])
def test_allowed_protocols_data(command):
    data = b64encode(resource_path('pattern.png').read_bytes()).decode()
    _run(command, f'<img src="data:image/png;base64,{data}">'.encode())


@pytest.mark.parametrize('command', [
    '--allowed-protocols http - -',
    '--allowed-protocols http,https - -',
    '--allowed-protocols filetest - -',
    '--allowed-protocols "" - -',
])
def test_disallowed_protocols(command):
    with capture_logs() as logs:
        _run(command, f'<img src="{path2url(resource_path("pattern.png"))}">'.encode())
    assert len(logs) == 1
    assert 'URI uses disallowed protocol' in logs[0]


@assert_no_logs
def test_redirect_loop():
    with http_server() as root_url:
        with pytest.raises(URLFetchingError, match='infinite loop'):
            _run(f'{root_url}/redirect-loop -')


@pytest.mark.parametrize(('html', 'fields'), [
    ('<input>', ['/Tx', '/V ()']),
    ('<input value="">', ['/Tx', '/V ()']),
    ('<input type="checkbox">', ['/Btn']),
    ('<input type="radio">',
     ['/Btn', '/V /Off', '/AS /Off', '/Ff 49152']),
    ('<input checked type="radio" name="foo" value="value">',
     ['/Btn', '/T (foo)', '/V /0', '/AS /0']),
    ('<form><input type="radio" name="foo" value="v0"></form>'
     '<form><input checked type="radio" name="foo" value="v1"></form>',
     ['/Btn', '/AS /0', '/V /0', '/AS /Off', '/V /Off']),
    ('<textarea></textarea>', ['/Tx', '/V ()']),
    ('<select><option value="a">A</option></select>', ['/Ch', '/Opt']),
    ('<select>'
     '<option value="a">A</option>'
     '<option value="b" selected>B</option>'
     '</select>', ['/Ch', '/Opt', '/V (b)']),
    ('<select multiple>'
     '<option value="a">A</option>'
     '<option value="b" selected>B</option>'
     '<option value="c" selected>C</option>'
     '</select>', ['/Ch', '/Opt', '[(b) (c)]']),
])
def test_pdf_inputs(html, fields):
    stdout = _run('--pdf-forms --uncompressed-pdf - -', html.encode())
    assert b'AcroForm' in stdout
    for field in fields:
        assert field.encode() in stdout
    stdout = _run('--uncompressed-pdf - -', html.encode())
    assert b'AcroForm' not in stdout


@pytest.mark.parametrize(('css', 'with_forms', 'without_forms'), [
    ('appearance: auto', True, True),
    ('appearance: none', False, False),
    ('', True, False),
])
def test_appearance(css, with_forms, without_forms):
    html = f'<input style="{css}">'.encode()
    assert with_forms is (
        b'AcroForm' in _run('--pdf-forms --uncompressed-pdf - -', html))
    assert without_forms is (
        b'AcroForm' in _run(' --uncompressed-pdf - -', html))


def test_appearance_non_input():
    html = b'<div style="appearance: auto">'
    assert b'AcroForm' not in _run('--pdf-forms --uncompressed-pdf - -', html)


def test_reproducible():
    os.environ['SOURCE_DATE_EPOCH'] = '0'
    stdout1 = _run('- -', b'<body>a<img src=pattern.png>')
    stdout2 = _run('- -', b'<body>a<img src=pattern.png>')
    os.environ.pop('SOURCE_DATE_EPOCH')
    assert stdout1 == stdout2


@assert_no_logs
def test_unicode_filenames(assert_pixels_equal, tmp_path):
    """Test non-ASCII filenames both in Unicode or bytes form."""
    # Replicate pattern.png in CSS so that base_url does not matter.
    html = b'''
        <style>
            @page { margin: 2px; size: 8px }
            html { background: #00f; }
            body { background: #f00; width: 1px; height: 1px }
        </style>
        <body>
    '''
    png_bytes = FakeHTML(string=html).write_png()
    check_png_pattern(assert_pixels_equal, png_bytes)
    unicode_filename = 'Unicödé'
    if sys.platform.startswith('darwin'):  # pragma: no cover
        unicode_filename = unicodedata.normalize('NFD', unicode_filename)

    with chdir(tmp_path):
        (tmp_path / unicode_filename).write_bytes(html)
        bytes_file, = tuple(tmp_path.iterdir())
        assert bytes_file.name == unicode_filename

        assert FakeHTML(unicode_filename).write_png() == png_bytes
        assert FakeHTML(bytes_file).write_png() == png_bytes

        os.remove(unicode_filename)
        assert not tuple(tmp_path.iterdir())

        FakeHTML(string=html).write_png(unicode_filename)
        assert bytes_file.read_bytes() == png_bytes


@assert_no_logs
def test_low_level_api(assert_pixels_equal):
    html = FakeHTML(string='<body>')
    css = CSS(string='''
        @page { margin: 2px; size: 8px }
        html { background: #00f; }
        body { background: #f00; width: 1px; height: 1px }
    ''')
    pdf_bytes = html.write_pdf(stylesheets=[css])
    assert pdf_bytes.startswith(b'%PDF')

    png_bytes = html.write_png(stylesheets=[css])
    document = html.render(stylesheets=[css])
    page, = document.pages
    assert page.width == 8
    assert page.height == 8
    assert document.write_png() == png_bytes
    assert document.copy([page]).write_png() == png_bytes

    document = html.render(stylesheets=[css])
    page, = document.pages
    assert (page.width, page.height) == (8, 8)
    png_bytes = document.write_png(resolution=192)
    check_png_pattern(assert_pixels_equal, png_bytes, x2=True)

    document = html.render(stylesheets=[css])
    page, = document.pages
    assert (page.width, page.height) == (8, 8)
    # A resolution that is not multiple of 96:
    assert _png_size(document.write_png(resolution=145.2)) == (12, 12)

    document = FakeHTML(string='''
        <style>
            @page:first { size: 5px 10px } @page { size: 6px 4px }
            p { page-break-before: always }
        </style>
        <p></p>
        <p></p>
    ''').render()
    page_1, page_2 = document.pages
    assert (page_1.width, page_1.height) == (5, 10)
    assert (page_2.width, page_2.height) == (6, 4)

    result = document.write_png()
    # (Max of both widths, Sum of both heights)
    assert _png_size(result) == (6, 14)
    assert document.copy([page_1, page_2]).write_png() == result
    assert _png_size(document.copy([page_1]).write_png()) == (5, 10)
    assert _png_size(document.copy([page_2]).write_png()) == (6, 4)


@pytest.mark.parametrize(('html', 'expected_by_page', 'expected_tree', 'round'), [
    ('''
        <style>h1, h2, h3, h4 { height: 10px }</style>
        <h1>a</h1>
        <h4 style="page-break-after: always">b</h4>
        <h3 style="position: relative; top: 2px; left: 3px">c</h3>
        <h2>d</h2>
        <h1>e</h1>
    ''', [
        [(1, 'a', (0, 0), 'open'), (4, 'b', (0, 10), 'open')],
        [(3, 'c', (3, 2), 'open'), (2, 'd', (0, 10), 'open'),
         (1, 'e', (0, 20), 'open')],
    ], [
        ('a', (0, 0, 0), [
            ('b', (0, 0, 10), [], 'open'),
            ('c', (1, 3, 2), [], 'open'),
            ('d', (1, 0, 10), [], 'open')], 'open'),
        ('e', (1, 0, 20), [], 'open'),
    ], False),
    ('''
        <style>
            h1, h2, h3, span { height: 90px; margin: 0 0 10px 0 }
        </style>
        <h1>Title 1</h1>
        <h1>Title 2</h1>
        <h2 style="position: relative; left: 20px">Title 3</h2>
        <h2>Title 4</h2>
        <h3>Title 5</h3>
        <span style="display: block; page-break-before: always"></span>
        <h2>Title 6</h2>
        <h1>Title 7</h1>
        <h2>Title 8</h2>
        <h3>Title 9</h3>
        <h1>Title 10</h1>
        <h2>Title 11</h2>
    ''', [
        [
            (1, 'Title 1', (0, 0), 'open'),
            (1, 'Title 2', (0, 100), 'open'),
            (2, 'Title 3', (20, 200), 'open'),
            (2, 'Title 4', (0, 300), 'open'),
            (3, 'Title 5', (0, 400), 'open')
        ], [
            (2, 'Title 6', (0, 100), 'open'),
            (1, 'Title 7', (0, 200), 'open'),
            (2, 'Title 8', (0, 300), 'open'),
            (3, 'Title 9', (0, 400), 'open'),
            (1, 'Title 10', (0, 500), 'open'),
            (2, 'Title 11', (0, 600), 'open')
        ],
    ], [
        ('Title 1', (0, 0, 0), [], 'open'),
        ('Title 2', (0, 0, 100), [
            ('Title 3', (0, 20, 200), [], 'open'),
            ('Title 4', (0, 0, 300), [
                ('Title 5', (0, 0, 400), [], 'open')], 'open'),
            ('Title 6', (1, 0, 100), [], 'open')], 'open'),
        ('Title 7', (1, 0, 200), [
            ('Title 8', (1, 0, 300), [
                ('Title 9', (1, 0, 400), [], 'open')], 'open')], 'open'),
        ('Title 10', (1, 0, 500), [
            ('Title 11', (1, 0, 600), [], 'open')], 'open'),
    ], False),
    ('''
        <style>* { height: 10px }</style>
        <h2>A</h2> <p>depth 1</p>
        <h4>B</h4> <p>depth 2</p>
        <h2>C</h2> <p>depth 1</p>
        <h3>D</h3> <p>depth 2</p>
        <h4>E</h4> <p>depth 3</p>
    ''', [[
        (2, 'A', (0, 0), 'open'),
        (4, 'B', (0, 20), 'open'),
        (2, 'C', (0, 40), 'open'),
        (3, 'D', (0, 60), 'open'),
        (4, 'E', (0, 80), 'open'),
    ]], [
        ('A', (0, 0, 0), [
            ('B', (0, 0, 20), [], 'open')], 'open'),
        ('C', (0, 0, 40), [
            ('D', (0, 0, 60), [
                ('E', (0, 0, 80), [], 'open')], 'open')], 'open'),
    ], False),
    ('''
        <style>* { height: 10px; font-size: 0 }</style>
        <h2>A</h2> <p>h2 depth 1</p>
        <h4>B</h4> <p>h4 depth 2</p>
        <h3>C</h3> <p>h3 depth 2</p>
        <h5>D</h5> <p>h5 depth 3</p>
        <h1>E</h1> <p>h1 depth 1</p>
        <h2>F</h2> <p>h2 depth 2</p>
        <h2>G</h2> <p>h2 depth 2</p>
        <h4>H</h4> <p>h4 depth 3</p>
        <h1>I</h1> <p>h1 depth 1</p>
    ''', [[
        (2, 'A', (0, 0), 'open'),
        (4, 'B', (0, 20), 'open'),
        (3, 'C', (0, 40), 'open'),
        (5, 'D', (0, 60), 'open'),
        (1, 'E', (0, 70), 'open'),
        (2, 'F', (0, 90), 'open'),
        (2, 'G', (0, 110), 'open'),
        (4, 'H', (0, 130), 'open'),
        (1, 'I', (0, 150), 'open'),
    ]], [
        ('A', (0, 0, 0), [
            ('B', (0, 0, 20), [], 'open'),
            ('C', (0, 0, 40), [
                ('D', (0, 0, 60), [], 'open')], 'open')], 'open'),
        ('E', (0, 0, 70), [
            ('F', (0, 0, 90), [], 'open'),
            ('G', (0, 0, 110), [
                ('H', (0, 0, 130), [], 'open')], 'open')], 'open'),
        ('I', (0, 0, 150), [], 'open'),
    ], False),
    ('<h1>é', [
        [(1, 'é', (0, 0), 'open')]
    ], [
        ('é', (0, 0, 0), [], 'open')
    ], False),
    ('''
        <h1 style="transform: translateX(50px)">!
    ''', [
        [(1, '!', (50, 0), 'open')]
    ], [
        ('!', (0, 50, 0), [], 'open')
    ], False),
    ('''
        <style>
          img { display: block; bookmark-label: attr(alt); bookmark-level: 1 }
        </style>
        <img src="%s" alt="Chocolate" />
    ''' % path2url(resource_path('pattern.png')),
     [[(1, 'Chocolate', (0, 0), 'open')]],
     [('Chocolate', (0, 0, 0), [], 'open')], False),
    ('''
        <h1 style="transform-origin: 0 0;
                   transform: rotate(90deg) translateX(50px)">!
    ''', [[(1, '!', (0, 50), 'open')]], [('!', (0, 0, 50), [], 'open')], True),
    ('''
        <body style="transform-origin: 0 0; transform: rotate(90deg)">
        <h1 style="transform: translateX(50px)">!
    ''', [[(1, '!', (0, 50), 'open')]], [('!', (0, 0, 50), [], 'open')], True),
    ('''
        <body>
        <h1 style="width: 10px; line-height: 10px;
                   transform: skew(45deg, 45deg)">!
    ''', [[(1, '!', (-5, -5), 'open')]], [('!', (0, -5, -5), [], 'open')],
     True),
])
@assert_no_logs
def test_assert_bookmarks(html, expected_by_page, expected_tree, round):
    document = FakeHTML(string=html).render()
    if round:
        _round_meta(document.pages)
    assert [page.bookmarks for page in document.pages] == expected_by_page
    assert document.make_bookmark_tree() == expected_tree


def simplify_links(links):
    return [
        (link_type, link_target, rectangle)
        for link_type, link_target, rectangle, box in links]


def assert_links(html, links, anchors, resolved_links,
                 base_url=resource_path('<inline HTML>'), warnings=(),
                 round=False):
    with capture_logs() as logs:
        document = FakeHTML(string=html, base_url=base_url).render()
        if round:
            _round_meta(document.pages)
        document_resolved_links = [
            (simplify_links(page_links), page_anchors)
            for page_links, page_anchors in resolve_links(document.pages)]
    assert len(logs) == len(warnings)
    for message, expected in zip(logs, warnings):
        assert expected in message
    document_links = [simplify_links(page.links) for page in document.pages]
    document_anchors = [page.anchors for page in document.pages]
    assert document_links == links
    assert document_anchors == anchors
    assert document_resolved_links == resolved_links


@assert_no_logs
def test_links_1():
    assert_links('''
        <style>
            body { font-size: 10px; line-height: 2; width: 200px }
            p { height: 90px; margin: 0 0 10px 0 }
            img { width: 30px; vertical-align: top }
        </style>
        <p><a href="https://weasyprint.org"><img src=pattern.png></a></p>
        <p style="padding: 0 10px"><a
            href="#lipsum"><img style="border: solid 1px"
                                src=pattern.png></a></p>
        <p id=hello>Hello, World</p>
        <p id=lipsum>
            <a style="display: block; page-break-before: always; height: 30px"
               href="#hel%6Co"></a>
        </p>
    ''', [
        [
            ('external', 'https://weasyprint.org', (0, 0, 30, 20)),
            ('external', 'https://weasyprint.org', (0, 0, 30, 30)),
            ('internal', 'lipsum', (10, 100, 42, 120)),
            ('internal', 'lipsum', (10, 100, 42, 132))
        ],
        [('internal', 'hello', (0, 0, 200, 30))],
    ], [
        {'hello': (0, 200, 200, 290)},
        {'lipsum': (0, 0, 200, 90)}
    ], [
        (
            [
                ('external', 'https://weasyprint.org', (0, 0, 30, 20)),
                ('external', 'https://weasyprint.org', (0, 0, 30, 30)),
                ('internal', 'lipsum', (10, 100, 42, 120)),
                ('internal', 'lipsum', (10, 100, 42, 132))
            ],
            [('hello', 0, 200)],
        ),
        (
            [('internal', 'hello', (0, 0, 200, 30))],
            [('lipsum', 0, 0)]),
    ])


@assert_no_logs
def test_links_2():
    assert_links(
        '''
            <body style="width: 200px">
            <a href="../lipsum/é_%E9" style="display: block; margin: 10px 5px">
        ''', [[('external', 'https://weasyprint.org/foo/lipsum/%C3%A9_%E9',
                (5, 10, 195, 10))]],
        [{}], [([('external', 'https://weasyprint.org/foo/lipsum/%C3%A9_%E9',
                  (5, 10, 195, 10))], [])],
        base_url='https://weasyprint.org/foo/bar/')


@assert_no_logs
def test_links_3():
    assert_links(
        '''
            <body style="width: 200px">
            <div style="display: block; margin: 10px 5px;
                        -weasy-link: url(../lipsum/é_%E9)">
        ''', [[('external', 'https://weasyprint.org/foo/lipsum/%C3%A9_%E9',
                (5, 10, 195, 10))]],
        [{}], [([('external', 'https://weasyprint.org/foo/lipsum/%C3%A9_%E9',
                  (5, 10, 195, 10))], [])],
        base_url='https://weasyprint.org/foo/bar/')


@assert_no_logs
def test_links_4():
    # Relative URI reference without a base URI: allowed for links
    assert_links(
        '''
            <body style="width: 200px">
            <a href="../lipsum" style="display: block; margin: 10px 5px">
        ''', [[('external', '../lipsum', (5, 10, 195, 10))]], [{}],
        [([('external', '../lipsum', (5, 10, 195, 10))], [])],
        base_url=None)


@assert_no_logs
def test_links_5():
    # Relative URI reference without a base URI: not supported for -weasy-link
    assert_links(
        '''
            <body style="width: 200px">
            <div style="-weasy-link: url(../lipsum);
                        display: block; margin: 10px 5px">
        ''', [[]], [{}], [([], [])], base_url=None, warnings=[
            'WARNING: Ignored `-weasy-link: url(../lipsum)` at 1:1, '
            'Relative URI reference without a base URI'])


@assert_no_logs
def test_links_6():
    # Internal or absolute URI reference without a base URI: OK
    assert_links(
        '''
            <body style="width: 200px">
            <a href="#lipsum" id="lipsum"
                style="display: block; margin: 10px 5px"></a>
            <a href="https://weasyprint.org/" style="display: block"></a>
        ''', [[
            ('internal', 'lipsum', (5, 10, 195, 10)),
            ('external', 'https://weasyprint.org/', (0, 10, 200, 10))]],
        [{'lipsum': (5, 10, 195, 10)}],
        [([('internal', 'lipsum', (5, 10, 195, 10)),
           ('external', 'https://weasyprint.org/', (0, 10, 200, 10))],
          [('lipsum', 5, 10)])],
        base_url=None)


@assert_no_logs
def test_links_7():
    assert_links(
        '''
            <body style="width: 200px">
            <div style="-weasy-link: url(#lipsum);
                        margin: 10px 5px" id="lipsum">
        ''',
        [[('internal', 'lipsum', (5, 10, 195, 10))]],
        [{'lipsum': (5, 10, 195, 10)}],
        [([('internal', 'lipsum', (5, 10, 195, 10))], [('lipsum', 5, 10)])],
        base_url=None)


@assert_no_logs
def test_links_8():
    assert_links(
        '''
            <style> a { display: block; height: 15px } </style>
            <body style="width: 200px">
                <a href="#lipsum"></a>
                <a href="#missing" id="lipsum"></a>
        ''',
        [[('internal', 'lipsum', (0, 0, 200, 15)),
          ('internal', 'missing', (0, 15, 200, 30))]],
        [{'lipsum': (0, 15, 200, 30)}],
        [([('internal', 'lipsum', (0, 0, 200, 15))], [('lipsum', 0, 15)])],
        base_url=None,
        warnings=[
            'ERROR: No anchor #missing for internal URI reference'])


@assert_no_logs
def test_links_9():
    assert_links(
        '''
            <body style="width: 100px; transform: translateY(100px)">
            <a href="#lipsum" id="lipsum" style="display: block; height: 20px;
                transform: rotate(90deg) scale(2)">
        ''',
        [[('internal', 'lipsum', (30, 10, 70, 210))]],
        [{'lipsum': (70, 10, 30, 210)}],
        [([('internal', 'lipsum', (30, 10, 70, 210))], [('lipsum', 70, 10)])],
        round=True)


@assert_no_logs
def test_links_10():
    # Download for attachment
    assert_links(
        '''
            <body style="width: 200px">
            <a rel=attachment href="pattern.png" download="wow.png"
                style="display: block; margin: 10px 5px">
        ''', [[('attachment', 'pattern.png', (5, 10, 195, 10))]],
        [{}], [([('attachment', 'pattern.png', (5, 10, 195, 10))], [])],
        base_url=None)


@assert_no_logs
def test_links_11():
    # Attachment with missing href
    assert_links(
        '''
            <body style="width: 200px">
            <a rel=attachment download="wow.png"
                style="display: block; margin: 10px 5px">
        ''', [[]], [{}], [([], [])], base_url=None)


@assert_no_logs
def test_links_12():
    # Absolute URI with no fragment and the same base URI: keep external URI
    # Regression test for #1767.
    assert_links(
        '''
            <body style="width: 200px">
            <a href="https://weasyprint.org"
               style="display: block; margin: 10px 5px">
        ''',
        [[('external', 'https://weasyprint.org', (5, 10, 195, 10))]], [{}],
        [([('external', 'https://weasyprint.org', (5, 10, 195, 10))], [])],
        base_url='https://weasyprint.org')


# Make relative URL references work with our custom URL scheme.
uses_relative.append('weasyprint-custom')


@pytest.mark.filterwarnings('ignore')
@assert_no_logs
def test_deprecated_url_fetcher(assert_pixels_equal):
    path = resource_path('pattern.png')
    pattern_png = path.read_bytes()

    def fetcher(url):
        if url == 'weasyprint-custom:foo/%C3%A9_%e9_pattern':
            return {'string': pattern_png, 'mime_type': 'image/png'}
        elif url == 'weasyprint-custom:foo/bar.css':
            return {
                'string': 'body { background: url(é_%e9_pattern)',
                'mime_type': 'text/css'}
        elif url == 'weasyprint-custom:foo/bar.no':
            return {
                'string': 'body { background: red }',
                'mime_type': 'text/no'}
        else:
            return default_url_fetcher(url)

    base_url = str(resource_path('dummy.html'))
    css = CSS(string='''
        @page { size: 8px; margin: 2px }
        body { margin: 0; font-size: 0 }
    ''', base_url=base_url)

    def test(html, blank=False):
        html = FakeHTML(string=html, url_fetcher=fetcher, base_url=base_url)
        check_png_pattern(
            assert_pixels_equal, html.write_png(stylesheets=[css]),
            blank=blank)

    test('<body><img src="pattern.png">')  # Test a "normal" URL
    test(f'<body><img src="{path.as_uri()}">')
    test(f'<body><img src="{path.as_uri()}?ignored">')
    test('<body><img src="weasyprint-custom:foo/é_%e9_pattern">')
    test('<body style="background: url(weasyprint-custom:foo/é_%e9_pattern)">')
    test('<body><li style="list-style: inside '
         'url(weasyprint-custom:foo/é_%e9_pattern)">')
    test('<link rel=stylesheet href="weasyprint-custom:foo/bar.css"><body>')
    test('<style>@import "weasyprint-custom:foo/bar.css";</style><body>')
    test('<style>@import url(weasyprint-custom:foo/bar.css);</style><body>')
    test('<style>@import url("weasyprint-custom:foo/bar.css");</style><body>')

    with capture_logs() as logs:
        test('<body><img src="custom:foo/bar">', blank=True)
    assert len(logs) == 1
    assert logs[0].startswith(
        "ERROR: Failed to load image at 'custom:foo/bar'")

    with capture_logs() as logs:
        test(
            '<link rel=stylesheet href="weasyprint-custom:foo/bar.css">'
            '<link rel=stylesheet href="weasyprint-custom:foo/bar.no"><body>')
    assert len(logs) == 1
    assert logs[0].startswith('ERROR: Unsupported stylesheet type text/no')

    def fetcher_2(url):
        assert url == 'weasyprint-custom:%C3%A9_%e9.css'
        return {'string': '', 'mime_type': 'text/css'}
    FakeHTML(
        string='<link rel=stylesheet href="weasyprint-custom:é_%e9.css"><body',
        url_fetcher=fetcher_2).render()


class Fetcher(URLFetcher):
    def fetch(self, url, headers=None):
        if url.startswith('fatal:'):
            raise FatalURLFetchingError('Fatal error')
        elif 'forbidden' in url:
            raise FatalURLFetchingError('Forbidden URL')
        elif url.startswith('bad:'):
            raise ValueError('Bad protocol')
        elif url == 'redirect:':
            return self.fetch('weasyprint-custom:foo/bar.css')
        elif url == 'weasyprint-custom:foo/%C3%A9_%e9_pattern':
            pattern_png = resource_path('pattern.png').read_bytes()
            return URLFetcherResponse(url, pattern_png, {'Content-Type': 'image/png'})
        elif url == 'weasyprint-custom:foo/bar.css':
            return URLFetcherResponse(
                url, 'body { background: url(é_%e9_pattern)'.encode('iso-8859-15'),
                {'Content-Type': 'text/css;charset=iso-8859-15'})
        elif url == 'weasyprint-custom:foo/bar.no':
            return URLFetcherResponse(
                url, 'body { background: red }', {'Content-Type': 'text/no'})
        else:
            return super().fetch(url, headers)


@pytest.mark.parametrize('html', [
    '<body><img src="pattern.png">',
    f'<body><img src="{resource_path("pattern.png").as_uri()}">',
    f'<body><img src="{resource_path("pattern.png").as_uri()}?ignored">',
    '<body><img src="weasyprint-custom:foo/é_%e9_pattern">',
    '<body style="background: url(weasyprint-custom:foo/é_%e9_pattern)">',
    '<body><li style="list-style: inside url(weasyprint-custom:foo/é_%e9_pattern)">',
    '<link rel=stylesheet href="weasyprint-custom:foo/bar.css"><body>',
    '<link rel=stylesheet href="redirect:"><body>',
    '<style>@import "weasyprint-custom:foo/bar.css";</style><body>',
    '<style>@import url(weasyprint-custom:foo/bar.css);</style><body>',
    '<style>@import url("weasyprint-custom:foo/bar.css");</style><body>',
])
@assert_no_logs
def test_url_fetcher(html, assert_pixels_equal):
    base_url = str(resource_path('dummy.html'))
    css = CSS(string='@page{size:8px;margin:2px} body{font-size:0}', base_url=base_url)
    html = FakeHTML(string=html, url_fetcher=Fetcher(), base_url=base_url)
    check_png_pattern(assert_pixels_equal, html.write_png(stylesheets=[css]))


@assert_no_logs
def test_url_fetcher_default(assert_pixels_equal):
    html = '<body><img src="pattern.png">'
    base_url = str(resource_path('dummy.html'))
    css = CSS(string='@page{size:8px;margin:2px} body{font-size:0}', base_url=base_url)
    html = FakeHTML(string=html, url_fetcher=URLFetcher(), base_url=base_url)
    check_png_pattern(assert_pixels_equal, html.write_png(stylesheets=[css]))


@assert_no_logs
def test_url_fetcher_bad_image(assert_pixels_equal):
    string = '<body><img src="custom:foo/bar">'
    css = CSS(string='@page { size: 8px; margin: 2px } body { font-size: 0 }')
    with capture_logs() as logs:
        html = FakeHTML(string=string, url_fetcher=Fetcher())
        png = html.write_png(stylesheets=[css])
    assert len(logs) == 1
    assert logs[0].startswith("ERROR: Failed to load image at 'custom:foo/bar'")
    check_png_pattern(assert_pixels_equal, png, blank=True)


@assert_no_logs
def test_url_fetcher_bad_stylesheet(assert_pixels_equal):
    string = (
        '<link rel=stylesheet href="weasyprint-custom:foo/bar.css">'
        '<link rel=stylesheet href="weasyprint-custom:foo/bar.no"><body>')
    with capture_logs() as logs:
        FakeHTML(string=string, url_fetcher=Fetcher()).write_png()
    assert len(logs) == 1
    assert logs[0].startswith('ERROR: Unsupported stylesheet type text/no')


@assert_no_logs
def test_url_fetcher_non_fatal_error(assert_pixels_equal):
    string = '<link rel=stylesheet href="bad:foo/bar.no"><body>'
    with capture_logs() as logs:
        FakeHTML(string=string, url_fetcher=Fetcher()).write_png()
    assert len(logs) == 1
    assert 'Bad protocol' in logs[0]


@assert_no_logs
def test_url_fetcher_fatal_error(assert_pixels_equal):
    string = '<link rel=stylesheet href="fatal:foo/bar.no"><body>'
    with pytest.raises(FatalURLFetchingError, match='Fatal error'):
        FakeHTML(string=string, url_fetcher=Fetcher()).write_png()


@assert_no_logs
def test_url_fetcher_default_fail_on_errors(assert_pixels_equal):
    html = '<body><img src="unknown.png">'
    base_url = str(resource_path('dummy.html'))
    url_fetcher = URLFetcher(fail_on_errors=True)
    with pytest.raises(FatalURLFetchingError, match='Error fetching'):
        FakeHTML(string=html, url_fetcher=url_fetcher, base_url=base_url).write_png()


def assert_meta(html, **meta):
    meta.setdefault('title', None)
    meta.setdefault('authors', [])
    meta.setdefault('keywords', [])
    meta.setdefault('generator', None)
    meta.setdefault('description', None)
    meta.setdefault('created', None)
    meta.setdefault('modified', None)
    meta.setdefault('attachments', [])
    meta.setdefault('lang', None)
    meta.setdefault('custom', {})
    meta.setdefault('xmp_metadata', [])
    assert vars(FakeHTML(string=html).render().metadata) == meta


@assert_no_logs
def test_html_meta_1():
    assert_meta('<body>')


@assert_no_logs
def test_html_meta_2():
    assert_meta(
        '''
            <html lang="en"><head>
            <meta name=author content="I Me &amp; Myself">
            <meta name=author content="Smith, John">
            <title>Test document</title>
            <h1>Another title</h1>
            <meta name=generator content="Human after all">
            <meta name=generator content="Human">
            <meta name=dummy content=ignored>
            <meta name=dummy>
            <meta content=ignored>
            <meta>
            <meta name=keywords content="html ,\tcss,
                                         pdf,css">
            <meta name=dcterms.created content=2011-04>
            <meta name=dcterms.created content=2011-05>
            <meta name=dcterms.modified content=2013>
            <meta name=keywords content="Python; pydyf">
            <meta name=description content="Blah… ">
            <meta name=description content="*Oh-no/">
            <meta name=dcterms.modified content=2012>
            </head></html>
        ''',
        authors=['I Me & Myself', 'Smith, John'],
        title='Test document',
        generator='Human after all',
        keywords=['html', 'css', 'pdf', 'Python; pydyf'],
        description='Blah… ',
        created='2011-04',
        modified='2013',
        lang='en',
        custom={'dummy': 'ignored'})


@assert_no_logs
def test_html_meta_3():
    assert_meta(
        '''
            <title>One</title>
            <meta name=Author>
            <title>Two</title>
            <title>Three</title>
            <meta name=author content=Me>
        ''',
        title='One',
        authors=['', 'Me'])


@assert_no_logs
def test_html_meta_4():
    with capture_logs() as logs:
        assert_meta(
            '''
                <meta name=dcterms.created content=wrong>
                <meta name=author content=Me>
                <title>Title</title>
            ''',
            title='Title',
            authors=['Me'])
    assert len(logs) == 1
    assert 'Invalid date' in logs[0]


@assert_no_logs
def test_http():
    with http_server() as root_url:
        assert HTML(f'{root_url}/gzip').etree_element.get('test') == 'ok'
        assert HTML(f'{root_url}/deflate').etree_element.get('test') == 'ok'
        assert HTML(f'{root_url}/raw-deflate').etree_element.get('test') == 'ok'
        assert HTML(f'{root_url}/redirect').etree_element.get('test') == 'ok'

        url_fetcher = URLFetcher()
        HTML(f'{root_url}/redirect', url_fetcher=url_fetcher).render()
        with capture_logs() as logs:
            HTML(
                string=f'<link rel=stylesheet href="{root_url}/redirect">',
                url_fetcher=url_fetcher).render()
        assert len(logs) == 1
        assert 'Unsupported stylesheet' in logs[0]

        url_fetcher = URLFetcher(allow_redirects=False)
        with pytest.raises(URLFetchingError, match='301'):
            HTML(f'{root_url}/redirect', url_fetcher=url_fetcher).render()
        with capture_logs() as logs:
            HTML(
                string=f'<link rel=stylesheet href="{root_url}/redirect">',
                url_fetcher=url_fetcher).render()
        assert len(logs) == 1
        assert '301' in logs[0]

        url_fetcher = URLFetcher(fail_on_errors=True)
        HTML(f'{root_url}/redirect', url_fetcher=url_fetcher).render()
        with pytest.raises(FatalURLFetchingError, match='Error fetching'):
            HTML(
                string=f'<img src="{root_url}/bad">',
                url_fetcher=url_fetcher).render()

        url_fetcher = URLFetcher(allow_redirects=False, fail_on_errors=True)
        with pytest.raises(FatalURLFetchingError, match='Error fetching'):
            HTML(f'{root_url}/redirect', url_fetcher=url_fetcher).render()
        with pytest.raises(FatalURLFetchingError, match='Error fetching'):
            HTML(
                string=f'<link rel=stylesheet href="{root_url}/redirect">',
                url_fetcher=url_fetcher).render()


@assert_no_logs
def test_page_copy_relative():
    # Regression test for #1473.
    document = FakeHTML(string='<div style="position: relative">a').render()
    duplicated_pages = document.copy([*document.pages, *document.pages])
    pngs = duplicated_pages.write_png(split_images=True)
    assert pngs[0] == pngs[1]


================================================
FILE: tests/test_boxes.py
================================================
"""Test that the "before layout" box tree is correctly constructed."""

import pytest

from weasyprint.css import get_all_computed_styles
from weasyprint.formatting_structure import boxes, build
from weasyprint.layout.page import PageType, set_page_type_computed_styles

from .testing_utils import (  # isort:skip
    FakeHTML, assert_no_logs, assert_tree, capture_logs, parse, parse_all,
    render_pages)


@assert_no_logs
def test_box_tree():
    assert_tree(parse('<p>'), [('p', 'Block', [])])
    assert_tree(parse('''
      <style>
        span { display: inline-block }
      </style>
      <p>Hello <em>World <img src="pattern.png"><span>L</span></em>!</p>'''), [
          ('p', 'Block', [
            ('p', 'Text', 'Hello '),
            ('em', 'Inline', [
                ('em', 'Text', 'World '),
                ('img', 'InlineReplaced', '<replaced>'),
                ('span', 'InlineBlock', [
                    ('span', 'Text', 'L')])]),
            ('p', 'Text', '!')])])


@assert_no_logs
def test_html_entities():
    for quote in ['"', '&quot;', '&#x22;', '&#34;']:
        assert_tree(parse(f'<p>{quote}abc{quote}'), [
            ('p', 'Block', [
                ('p', 'Text', '"abc"')])])


@assert_no_logs
def test_inline_in_block_1():
    source = '<div>Hello, <em>World</em>!\n<p>Lipsum.</p></div>'
    expected = [
        ('div', 'Block', [
            ('div', 'Block', [
                ('div', 'Line', [
                    ('div', 'Text', 'Hello, '),
                    ('em', 'Inline', [
                        ('em', 'Text', 'World')]),
                    ('div', 'Text', '!\n')])]),
            ('p', 'Block', [
                ('p', 'Line', [
                    ('p', 'Text', 'Lipsum.')])])])]
    box = parse(source)
    box = build.inline_in_block(box)
    assert_tree(box, expected)


@assert_no_logs
def test_inline_in_block_2():
    source = '<div><p>Lipsum.</p>Hello, <em>World</em>!\n</div>'
    expected = [
        ('div', 'Block', [
            ('p', 'Block', [
                ('p', 'Line', [
                    ('p', 'Text', 'Lipsum.')])]),
            ('div', 'Block', [
                ('div', 'Line', [
                    ('div', 'Text', 'Hello, '),
                    ('em', 'Inline', [
                        ('em', 'Text', 'World')]),
                    ('div', 'Text', '!\n')])])])]
    box = parse(source)
    box = build.inline_in_block(box)
    assert_tree(box, expected)


@assert_no_logs
def test_inline_in_block_3():
    # Absolutes are left in the lines to get their static position later.
    source = '''<p>Hello <em style="position:absolute;
                                    display: block">World</em>!</p>'''
    expected = [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p', 'Text', 'Hello '),
                ('em', 'Block', [
                    ('em', 'Line', [
                        ('em', 'Text', 'World')])]),
                ('p', 'Text', '!')])])]
    box = parse(source)
    box = build.inline_in_block(box)
    assert_tree(box, expected)
    box = build.block_in_inline(box)
    assert_tree(box, expected)


@assert_no_logs
def test_inline_in_block_4():
    # Floats are pull to the top of their containing blocks
    source = '<p>Hello <em style="float: left">World</em>!</p>'
    box = parse(source)
    box = build.inline_in_block(box)
    box = build.block_in_inline(box)
    assert_tree(box, [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p', 'Text', 'Hello '),
                ('em', 'Block', [
                    ('em', 'Line', [
                        ('em', 'Text', 'World')])]),
                ('p', 'Text', '!')])])])


@assert_no_logs
def test_block_in_inline():
    box = parse('''
      <style>
        p { display: inline-block; }
        span, i { display: block; }
      </style>
      <p>Lorem <em>ipsum <strong>dolor <span>sit</span>
      <span>amet,</span></strong><span><em>conse<i>''')
    box = build.inline_in_block(box)
    assert_tree(box, [
        ('body', 'Line', [
            ('p', 'InlineBlock', [
                ('p', 'Line', [
                    ('p', 'Text', 'Lorem '),
                    ('em', 'Inline', [
                        ('em', 'Text', 'ipsum '),
                        ('strong', 'Inline', [
                            ('strong', 'Text', 'dolor '),
                            ('span', 'Block', [  # This block is "pulled up"
                                ('span', 'Line', [
                                    ('span', 'Text', 'sit')])]),
                            ('strong', 'Text', '\n      '),
                            ('span', 'Block', [  # This block is "pulled up"
                                ('span', 'Line', [
                                    ('span', 'Text', 'amet,')])])]),
                        ('span', 'Block', [  # This block is "pulled up"
                            ('span', 'Line', [
                                ('em', 'Inline', [
                                    ('em', 'Text', 'conse'),
                                    ('i', 'Block', [])])])])])])])])])

    box = build.block_in_inline(box)
    assert_tree(box, [
        ('body', 'Line', [
            ('p', 'InlineBlock', [
                ('p', 'Block', [
                    ('p', 'Line', [
                        ('p', 'Text', 'Lorem '),
                        ('em', 'Inline', [
                            ('em', 'Text', 'ipsum '),
                            ('strong', 'Inline', [
                                ('strong', 'Text', 'dolor ')])])])]),
                ('span', 'Block', [
                    ('span', 'Line', [
                        ('span', 'Text', 'sit')])]),
                ('p', 'Block', [
                    ('p', 'Line', [
                        ('em', 'Inline', [
                            ('strong', 'Inline', [
                                ('strong', 'Text', '\n      ')])])])]),
                ('span', 'Block', [
                    ('span', 'Line', [
                        ('span', 'Text', 'amet,')])]),

                ('p', 'Block', [
                    ('p', 'Line', [
                        ('em', 'Inline', [
                            ('strong', 'Inline', [])])])]),
                ('span', 'Block', [
                    ('span', 'Block', [
                        ('span', 'Line', [
                            ('em', 'Inline', [
                                ('em', 'Text', 'conse')])])]),
                    ('i', 'Block', []),
                    ('span', 'Block', [
                        ('span', 'Line', [
                            ('em', 'Inline', [])])])]),
                ('p', 'Block', [
                    ('p', 'Line', [
                        ('em', 'Inline', [])])])])])])


@assert_no_logs
def test_styles():
    box = parse('''
      <style>
        span { display: block; }
        * { margin: 42px }
        html { color: blue }
      </style>
      <p>Lorem <em>ipsum <strong>dolor <span>sit</span>
        <span>amet,</span></strong><span>consectetur</span></em></p>''')
    box = build.inline_in_block(box)
    box = build.block_in_inline(box)

    descendants = list(box.descendants())
    assert len(descendants) == 31
    assert descendants[0] == box

    for child in descendants:
        # All boxes inherit the color
        assert child.style['color'] == (0, 0, 1, 1)  # blue
        # Only non-anonymous boxes have margins
        assert child.style['margin_top'] in ((0, 'px'), (42, 'px'))


@assert_no_logs
def test_whitespace():
    assert_tree(parse_all('''
      <p>Lorem \t\r\n  ipsum\t<strong>  dolor
        <img src=pattern.png> sit
        <span style="position: absolute"></span> <em> amet </em>
        consectetur</strong>.</p>
      <pre>\t  foo\n</pre>
      <pre style="white-space: pre-wrap">\t  foo\n</pre>
      <pre style="white-space: pre-line">\t  foo\n</pre>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p', 'Text', 'Lorem ipsum '),
                ('strong', 'Inline', [
                    ('strong', 'Text', 'dolor '),
                    ('img', 'InlineReplaced', '<replaced>'),
                    ('strong', 'Text', ' sit '),
                    ('span', 'Block', []),
                    ('em', 'Inline', [
                        ('em', 'Text', 'amet ')]),
                    ('strong', 'Text', 'consectetur')]),
                ('p', 'Text', '.')])]),
        ('pre', 'Block', [
            ('pre', 'Line', [
                # pre
                ('pre', 'Text', '\t  foo\n')])]),
        ('pre', 'Block', [
            ('pre', 'Line', [
                # pre-wrap
                ('pre', 'Text', '\t  foo\n')])]),
        ('pre', 'Block', [
            ('pre', 'Line', [
                # pre-line
                ('pre', 'Text', 'foo\n')])])])


@assert_no_logs
@pytest.mark.parametrize(('page_type', 'top', 'right', 'bottom', 'left'), [
    (PageType('left', False, '', 0, ()), 20, 3, 3, 10),
    (PageType('right', False, '', 0, ()), 20, 10, 3, 3),
    (PageType('left', False, '', 1, ()), 10, 3, 3, 10),
    (PageType('right', False, '', 1, ()), 10, 10, 3, 3),
    (PageType('right', False, 'name', 1, (('name', 0),)), 5, 10, 3, 15),
    (PageType('right', False, 'name', 1, (('name', 1),)), 5, 10, 4, 15),
    (PageType('right', False, 'name', 2, (('name', 0),)), 5, 10, 1, 15),
    (PageType('right', False, 'name', 8, (('name', 8),)), 5, 10, 2, 15),
])
def test_page_style(page_type, top, right, bottom, left):
    document = FakeHTML(string='''
      <style>
        @page { margin: 3px }
        @page name { margin-left: 15px; margin-top: 5px }
        @page :nth(3) { margin-bottom: 1px }
        @page :nth(5n+4) { margin-bottom: 2px }
        @page :nth(2 of name) { margin-bottom: 4px }
        @page :first { margin-top: 20px }
        @page :right { margin-right: 10px; margin-top: 10px }
        @page :left { margin-left: 10px; margin-top: 10px }
      </style>
    ''')
    style_for = get_all_computed_styles(document)

    # Force the generation of the style for this page type as it's generally
    # only done during the rendering.
    set_page_type_computed_styles(page_type, document, style_for)

    style = style_for(page_type)
    assert style['margin_top'] == (top, 'px')
    assert style['margin_right'] == (right, 'px')
    assert style['margin_bottom'] == (bottom, 'px')
    assert style['margin_left'] == (left, 'px')


@assert_no_logs
def test_images_1():
    with capture_logs() as logs:
        result = parse_all('''
          <p><img src=pattern.png
            /><img alt="No src"
            /><img src=inexistent.jpg alt="Inexistent src" /></p>
        ''')
    assert len(logs) == 1
    assert 'ERROR: Failed to load image' in logs[0]
    assert 'inexistent.jpg' in logs[0]
    assert_tree(result, [
        ('p', 'Block', [
            ('p', 'Line', [
                ('img', 'InlineReplaced', '<replaced>'),
                ('img', 'Inline', [
                    ('img', 'Text', 'No src')]),
                ('img', 'Inline', [
                    ('img', 'Text', 'Inexistent src')])])])])


@assert_no_logs
def test_images_2():
    with capture_logs() as logs:
        result = parse_all('<p><img src=pattern.png alt="No base_url">',
                           base_url=None)
    assert len(logs) == 1
    assert 'ERROR: Relative URI reference without a base URI' in logs[0]
    assert_tree(result, [
        ('p', 'Block', [
            ('p', 'Line', [
                ('img', 'Inline', [
                    ('img', 'Text', 'No base_url')])])])])


@assert_no_logs
def test_tables_1():
    # Rules in https://www.w3.org/TR/CSS21/tables.html#anonymous-boxes

    # Rule 1.3
    # Also table model: https://www.w3.org/TR/CSS21/tables.html#model
    assert_tree(parse_all('''
      <style>
        x-table { display: table }
        x-tr { display: table-row }
        x-td, x-th { display: table-cell }
        x-thead { display: table-header-group }
        x-tfoot { display: table-footer-group }
        x-col { display: table-column }
        x-caption { display: table-caption }
      </style>
      <x-table>
        <x-tr>
          <x-th>foo</x-th>
          <x-th>bar</x-th>
        </x-tr>
        <x-tfoot></x-tfoot>
        <x-thead><x-th></x-th></x-thead>
        <x-caption style="caption-side: bottom"></x-caption>
        <x-thead></x-thead>
        <x-col></x-col>
        <x-caption>top caption</x-caption>
        <x-tr>
          <x-td>baz</x-td>
        </x-tr>
      </x-table>
    '''), [
        ('x-table', 'Block', [
            ('x-caption', 'TableCaption', [
                ('x-caption', 'Line', [
                    ('x-caption', 'Text', 'top caption')])]),
            ('x-table', 'Table', [
                ('x-table', 'TableColumnGroup', [
                    ('x-col', 'TableColumn', [])]),
                ('x-thead', 'TableRowGroup', [
                    ('x-thead', 'TableRow', [
                        ('x-th', 'TableCell', [])])]),
                ('x-table', 'TableRowGroup', [
                    ('x-tr', 'TableRow', [
                        ('x-th', 'TableCell', [
                            ('x-th', 'Line', [
                                ('x-th', 'Text', 'foo')])]),
                        ('x-th', 'TableCell', [
                            ('x-th', 'Line', [
                                ('x-th', 'Text', 'bar')])])])]),
                ('x-thead', 'TableRowGroup', []),
                ('x-table', 'TableRowGroup', [
                    ('x-tr', 'TableRow', [
                        ('x-td', 'TableCell', [
                            ('x-td', 'Line', [
                                ('x-td', 'Text', 'baz')])])])]),
                ('x-tfoot', 'TableRowGroup', [])]),
            ('x-caption', 'TableCaption', [])])])


@assert_no_logs
def test_tables_2():
    # Rules 1.4 and 3.1
    assert_tree(parse_all('''
      <span style="display: table-cell">foo</span>
      <span style="display: table-cell">bar</span>
    '''), [
        ('body', 'Block', [
            ('body', 'Table', [
                ('body', 'TableRowGroup', [
                    ('body', 'TableRow', [
                        ('span', 'TableCell', [
                            ('span', 'Line', [
                                ('span', 'Text', 'foo')])]),
                        ('span', 'TableCell', [
                            ('span', 'Line', [
                                ('span', 'Text', 'bar')])])])])])])])


@assert_no_logs
def test_tables_3():
    # https://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
    # Rules 1.1 and 1.2
    # Rule XXX (not in the spec): column groups have at least one column child
    assert_tree(parse_all('''
      <span style="display: table-column-group">
        1
        <em style="display: table-column">
          2
          <strong>3</strong>
        </em>
        <strong>4</strong>
      </span>
      <ins style="display: table-column-group"></ins>
    '''), [
        ('body', 'Block', [
            ('body', 'Table', [
                ('span', 'TableColumnGroup', [
                    ('em', 'TableColumn', [])]),
                ('ins', 'TableColumnGroup', [
                    ('ins', 'TableColumn', [])])])])])


@assert_no_logs
def test_tables_4():
    # Rules 2.1 then 2.3
    assert_tree(parse_all('<x-table style="display:table">foo <div></div></x-table>'), [
        ('x-table', 'Block', [
            ('x-table', 'Table', [
                ('x-table', 'TableRowGroup', [
                    ('x-table', 'TableRow', [
                        ('x-table', 'TableCell', [
                            ('x-table', 'Block', [
                                ('x-table', 'Line', [
                                    ('x-table', 'Text', 'foo ')])]),
                            ('div', 'Block', [])])])])])])])


@assert_no_logs
def test_tables_5():
    # Rule 2.2
    assert_tree(parse_all('<x-thead style="display: table-header-group"><div></div>'
                          '<x-td style="display: table-cell"></x-td></x-thead>'), [
        ('body', 'Block', [
            ('body', 'Table', [
                ('x-thead', 'TableRowGroup', [
                    ('x-thead', 'TableRow', [
                        ('x-thead', 'TableCell', [
                            ('div', 'Block', [])]),
                        ('x-td', 'TableCell', [])])])])])])


@assert_no_logs
def test_tables_6():
    # Rule 3.2
    assert_tree(parse_all('<span><x-tr style="display: table-row"></x-tr></span>'), [
        ('body', 'Line', [
            ('span', 'Inline', [
                ('span', 'InlineBlock', [
                    ('span', 'InlineTable', [
                        ('span', 'TableRowGroup', [
                            ('x-tr', 'TableRow', [])])])])])])])


@assert_no_logs
def test_tables_7():
    # Rule 3.1
    # Also, rule 1.3 does not apply: whitespace before and after is preserved
    assert_tree(parse_all('''
      <span>
        <em style="display: table-cell"></em>
        <em style="display: table-cell"></em>
      </span>
    '''), [
        ('body', 'Line', [
            ('span', 'Inline', [
                # Whitespace is preserved in table handling, then collapsed
                # into a single space.
                ('span', 'Text', ' '),
                ('span', 'InlineBlock', [
                    ('span', 'InlineTable', [
                        ('span', 'TableRowGroup', [
                            ('span', 'TableRow', [
                                ('em', 'TableCell', []),
                                ('em', 'TableCell', [])])])])]),
                ('span', 'Text', ' ')])])])


@assert_no_logs
def test_tables_8():
    # Rule 3.2
    assert_tree(parse_all(
        '<x-tr style="display: table-row"></x-tr>\t'
        '<x-tr style="display: table-row"></x-tr>'
    ), [
        ('body', 'Block', [
            ('body', 'Table', [
                ('body', 'TableRowGroup', [
                    ('x-tr', 'TableRow', []),
                    ('x-tr', 'TableRow', [])])])])])


@assert_no_logs
def test_tables_9():
    assert_tree(parse_all(
        '<x-col style="display: table-column"></x-col>\n'
        '<x-colgroup style="display: table-column-group"></x-colgroup>'
    ), [
        ('body', 'Block', [
            ('body', 'Table', [
                ('body', 'TableColumnGroup', [
                    ('x-col', 'TableColumn', [])]),
                ('x-colgroup', 'TableColumnGroup', [
                    ('x-colgroup', 'TableColumn', [])])])])])


@assert_no_logs
def test_table_style():
    html = parse_all('<table style="margin: 1px; padding: 2px"></table>')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    assert isinstance(wrapper, boxes.BlockBox)
    assert isinstance(table, boxes.TableBox)
    assert wrapper.style['margin_top'] == (1, 'px')
    assert wrapper.style['padding_top'] == (0, 'px')
    assert table.style['margin_top'] == (0, 'px')
    assert table.style['padding_top'] == (2, 'px')


@assert_no_logs
def test_column_style():
    html = parse_all('''
      <table>
        <col span=3 style="width: 10px"></col>
        <col span=2></col>
      </table>
    ''')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    colgroup, = table.column_groups
    widths = [col.style['width'] for col in colgroup.children]
    assert widths == [(10, 'px'), (10, 'px'), (10, 'px'), 'auto', 'auto']
    assert [col.grid_x for col in colgroup.children] == [0, 1, 2, 3, 4]
    # copies, not the same box object
    assert colgroup.children[0] is not colgroup.children[1]


@assert_no_logs
def test_nested_grid_x():
    html = parse_all('''
      <table>
        <col span=2></col>
        <colgroup span=2></colgroup>
        <colgroup>
          <col></col>
          <col span=2></col>
        </colgroup>
        <col></col>
      </table>
    ''')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    grid = [(colgroup.grid_x, [col.grid_x for col in colgroup.children])
            for colgroup in table.column_groups]
    assert grid == [(0, [0, 1]), (2, [2, 3]), (4, [4, 5, 6]), (7, [7])]


@assert_no_logs
def test_colspan_rowspan_1():
    # +---+---+---+
    # | A | B | C | X
    # +---+---+---+
    # | D |     E | X
    # +---+---+   +---+
    # |  F ...|   |   |   <-- overlap
    # +---+---+---+   +
    # | H | X   X | G |
    # +---+---+   +   +
    # | I | J | X |   |
    # +---+---+   +---+

    # X: empty cells
    html = parse_all('''
      <table>
        <tr>
          <td>A <td>B <td>C
        </tr>
        <tr>
          <td>D <td colspan=2 rowspan=2>E
        </tr>
        <tr>
          <td colspan=2>F <td rowspan=0>G
        </tr>
        <tr>
          <td>H
        </tr>
        <tr>
          <td>I <td>J
        </tr>
      </table>
    ''')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    group, = table.children
    assert [[c.grid_x for c in row.children] for row in group.children] == [
        [0, 1, 2],
        [0, 1],
        [0, 3],
        [0],
        [0, 1],
    ]
    assert [[c.colspan for c in row.children] for row in group.children] == [
        [1, 1, 1],
        [1, 2],
        [2, 1],
        [1],
        [1, 1],
    ]
    assert [[c.rowspan for c in row.children] for row in group.children] == [
        [1, 1, 1],
        [1, 2],
        [1, 3],
        [1],
        [1, 1],
    ]


@assert_no_logs
def test_colspan_rowspan_2():
    # A cell box cannot extend beyond the last row box of a table.
    html = parse_all('''
        <table>
            <tr>
                <td rowspan=5></td>
                <td></td>
            </tr>
            <tr>
                <td></td>
            </tr>
        </table>
    ''')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    group, = table.children
    assert [[c.grid_x for c in row.children] for row in group.children] == [
        [0, 1],
        [1],
    ]
    assert [[c.colspan for c in row.children] for row in group.children] == [
        [1, 1],
        [1],
    ]
    assert [[c.rowspan for c in row.children] for row in group.children] == [
        [2, 1],  # Not 5
        [1],
    ]


@assert_no_logs
def test_before_after_1():
    assert_tree(parse_all('''
      <style>
        p:before { content: normal }
        div:before { content: none }
        section::before { color: black }
      </style>
      <p></p>
      <div></div>
      <section></section>
    '''), [
        # No content in pseudo-element, no box generated
        ('p', 'Block', []),
        ('div', 'Block', []),
        ('section', 'Block', [])])


@assert_no_logs
def test_before_after_2():
    assert_tree(parse_all('''
      <style>
        p:before { content: 'a' 'b' }
        p::after { content: 'd' 'e' }
      </style>
      <p> c </p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p::before', 'Inline', [
                    ('p::before', 'Text', 'ab')]),
                ('p', 'Text', ' c '),
                ('p::after', 'Inline', [
                    ('p::after', 'Text', 'de')])])])])


@assert_no_logs
def test_before_after_3():
    assert_tree(parse_all('''
      <style>
        a[href]:before { content: '[' attr(href) '] ' }
      </style>
      <p><a href="some url">some text</a></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('a', 'Inline', [
                    ('a::before', 'Inline', [
                        ('a::before', 'Text', '[some url] ')]),
                    ('a', 'Text', 'some text')])])])])


@assert_no_logs
def test_before_after_4():
    assert_tree(parse_all('''
      <style>
        body { quotes: '«' '»' '“' '”' }
        q:before { content: open-quote ' '}
        q:after { content: ' ' close-quote }
      </style>
      <p><q>Lorem ipsum <q>dolor</q> sit amet</q></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('q', 'Inline', [
                    ('q::before', 'Inline', [
                        ('q::before', 'Text', '« ')]),
                    ('q', 'Text', 'Lorem ipsum '),
                    ('q', 'Inline', [
                        ('q::before', 'Inline', [
                            ('q::before', 'Text', '“ ')]),
                        ('q', 'Text', 'dolor'),
                        ('q::after', 'Inline', [
                            ('q::after', 'Text', ' ”')])]),
                    ('q', 'Text', ' sit amet'),
                    ('q::after', 'Inline', [
                        ('q::after', 'Text', ' »')])])])])])


@assert_no_logs
def test_before_after_5():
    # Regression test.
    with capture_logs() as logs:
        assert_tree(parse_all('''
          <style>
            p:before {
              content: 'a' url(pattern.png) 'b';
              /* Invalid, ignored in favor of the one above. */
              content: some-function(nested-function(something));
            }
          </style>
          <p>c</p>
        '''), [
            ('p', 'Block', [
                ('p', 'Line', [
                    ('p::before', 'Inline', [
                        ('p::before', 'Text', 'a'),
                        ('p::before', 'InlineReplaced', '<replaced>'),
                        ('p::before', 'Text', 'b')]),
                    ('p', 'Text', 'c')])])])
    assert len(logs) == 1
    assert 'nested-function(' in logs[0]
    assert 'invalid value' in logs[0]


@assert_no_logs
def test_quotes_auto():
    assert_tree(parse_all('''
      <style>
        body { quotes: auto }
        q:before { content: open-quote ' '}
        q:after { content: ' ' close-quote }
      </style>
      <p><q>Lorem ipsum <q>dolor</q> sit amet</q></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('q', 'Inline', [
                    ('q::before', 'Inline', [
                        ('q::before', 'Text', '“ ')]),
                    ('q', 'Text', 'Lorem ipsum '),
                    ('q', 'Inline', [
                        ('q::before', 'Inline', [
                            ('q::before', 'Text', '‘ ')]),
                        ('q', 'Text', 'dolor'),
                        ('q::after', 'Inline', [
                            ('q::after', 'Text', ' ’')])]),
                    ('q', 'Text', ' sit amet'),
                    ('q::after', 'Inline', [
                        ('q::after', 'Text', ' ”')])])])])])


@assert_no_logs
def test_quotes_none():
    assert_tree(parse_all('''
      <style>
        body { quotes: none }
        q:before { content: open-quote ' '}
        q:after { content: ' ' close-quote }
      </style>
      <p><q>Lorem ipsum <q>dolor</q> sit amet</q></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('q', 'Inline', [
                    ('q::before', 'Inline', [
                        ('q::before', 'Text', ' ')]),
                    ('q', 'Text', 'Lorem ipsum '),
                    ('q', 'Inline', [
                        ('q::before', 'Inline', [
                            ('q::before', 'Text', ' ')]),
                        ('q', 'Text', 'dolor'),
                        ('q::after', 'Inline', [
                            ('q::after', 'Text', ' ')])]),
                    ('q', 'Text', ' sit amet'),
                    ('q::after', 'Inline', [
                        ('q::after', 'Text', ' ')])])])])])


@assert_no_logs
def test_quotes_lang():
    assert_tree(parse_all('''
      <style>
        q:before { content: open-quote ' '}
        q:after { content: ' ' close-quote }
      </style>
      <p lang="fr"><q>Lorem ipsum <q>dolor</q> sit amet</q></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('q', 'Inline', [
                    ('q::before', 'Inline', [
                        ('q::before', 'Text', '« ')]),
                    ('q', 'Text', 'Lorem ipsum '),
                    ('q', 'Inline', [
                        ('q::before', 'Inline', [
                            ('q::before', 'Text', '« ')]),
                        ('q', 'Text', 'dolor'),
                        ('q::after', 'Inline', [
                            ('q::after', 'Text', ' »')])]),
                    ('q', 'Text', ' sit amet'),
                    ('q::after', 'Inline', [
                        ('q::after', 'Text', ' »')])])])])])


@assert_no_logs
def test_quotes_lang_alternate():
    assert_tree(parse_all('''
      <style>
        q:before { content: open-quote ' '}
        q:after { content: ' ' close-quote }
      </style>
      <p lang="fr_CH"><q>Lorem ipsum <q>dolor</q> sit amet</q></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('q', 'Inline', [
                    ('q::before', 'Inline', [
                        ('q::before', 'Text', '« ')]),
                    ('q', 'Text', 'Lorem ipsum '),
                    ('q', 'Inline', [
                        ('q::before', 'Inline', [
                            ('q::before', 'Text', '‹ ')]),
                        ('q', 'Text', 'dolor'),
                        ('q::after', 'Inline', [
                            ('q::after', 'Text', ' ›')])]),
                    ('q', 'Text', ' sit amet'),
                    ('q::after', 'Inline', [
                        ('q::after', 'Text', ' »')])])])])])


@assert_no_logs
def test_quotes_lang_parent():
    assert_tree(parse_all('''
      <style>
        q:before { content: open-quote ' '}
        q:after { content: ' ' close-quote }
      </style>
      <p lang="fr_CH_alt"><q>Lorem ipsum <q>dolor</q> sit amet</q></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('q', 'Inline', [
                    ('q::before', 'Inline', [
                        ('q::before', 'Text', '« ')]),
                    ('q', 'Text', 'Lorem ipsum '),
                    ('q', 'Inline', [
                        ('q::before', 'Inline', [
                            ('q::before', 'Text', '‹ ')]),
                        ('q', 'Text', 'dolor'),
                        ('q::after', 'Inline', [
                            ('q::after', 'Text', ' ›')])]),
                    ('q', 'Text', ' sit amet'),
                    ('q::after', 'Inline', [
                        ('q::after', 'Text', ' »')])])])])])


@assert_no_logs
def test_margin_boxes():
    page_1, page_2 = render_pages('''
      <style>
        @page {
          /* Make the page content area only 10px high and wide,
             so every word in <p> end up on a page of its own. */
          size: 30px;
          margin: 10px;
          @top-center { content: "Title" }
        }
        @page :first {
          @bottom-left { content: "foo" }
          @bottom-left-corner { content: "baz" }
        }
      </style>
      <p>lorem ipsum
    ''')
    assert page_1.children[0].element_tag == 'html'
    assert page_2.children[0].element_tag == 'html'

    margin_boxes_1 = [box.at_keyword for box in page_1.children[1:]]
    margin_boxes_2 = [box.at_keyword for box in page_2.children[1:]]
    assert margin_boxes_1 == ['@top-center', '@bottom-left',
                              '@bottom-left-corner']
    assert margin_boxes_2 == ['@top-center']

    html, top_center = page_2.children
    line_box, = top_center.children
    text_box, = line_box.children
    assert text_box.text == 'Title'


@assert_no_logs
def test_margin_box_string_set_1():
    # Test that both pages get string in the `bottom-center` margin box
    page_1, page_2 = render_pages('''
      <style>
        @page {
          @bottom-center { content: string(text_header) }
        }
        p {
          string-set: text_header content();
        }
        .page {
          page-break-before: always;
        }
      </style>
      <p>first assignment</p>
      <div class="page"></div>
    ''')

    html, bottom_center = page_2.children
    line_box, = bottom_center.children
    text_box, = line_box.children
    assert text_box.text == 'first assignment'

    html, bottom_center = page_1.children
    line_box, = bottom_center.children
    text_box, = line_box.children
    assert text_box.text == 'first assignment'


@assert_no_logs
def test_margin_box_string_set_2():
    def simple_string_set_test(content_val, extra_style=''):
        page_1, = render_pages('''
          <style>
            @page {
              @top-center { content: string(text_header) }
            }
            p {
              string-set: text_header content(%s);
            }
            %s
          </style>
          <p>first assignment</p>
        ''' % (content_val, extra_style))

        html, top_center = page_1.children
        line_box, = top_center.children
        text_box, = line_box.children
        if content_val in ('before', 'after'):
            assert text_box.text == 'pseudo'
        else:
            assert text_box.text == 'first assignment'

    # Test each accepted value of `content()` as an arguemnt to `string-set`
    for value in ('', 'text', 'before', 'after'):
        if value in ('before', 'after'):
            extra_style = 'p:%s{content: "pseudo"}' % value
            simple_string_set_test(value, extra_style)
        else:
            simple_string_set_test(value)


@assert_no_logs
def test_margin_box_string_set_3():
    # Test `first` (default value) ie. use the first assignment on the page
    page_1, = render_pages('''
      <style>
        @page {
          @top-center { content: string(text_header, first) }
        }
        p {
          string-set: text_header content();
        }
      </style>
      <p>first assignment</p>
      <p>Second assignment</p>
    ''')

    html, top_center = page_1.children
    line_box, = top_center.children
    text_box, = line_box.children
    assert text_box.text == 'first assignment'


@assert_no_logs
def test_margin_box_string_set_4():
    # test `first-except` ie. exclude from page on which value is assigned
    page_1, page_2 = render_pages('''
      <style>
        @page {
          @top-center { content: string(header_nofirst, first-except) }
        }
        p{
          string-set: header_nofirst content();
        }
        .page{
          page-break-before: always;
        }
      </style>
      <p>first_excepted</p>
      <div class="page"></div>
    ''')
    html, top_center = page_1.children
    assert len(top_center.children) == 0

    html, top_center = page_2.children
    line_box, = top_center.children
    text_box, = line_box.children
    assert text_box.text == 'first_excepted'


@assert_no_logs
def test_margin_box_string_set_5():
    # Test `last` ie. use the most-recent assignment
    page_1, = render_pages('''
      <style>
        @page {
          @top-center { content: string(header_last, last) }
        }
        p {
          string-set: header_last content();
        }
      </style>
      <p>String set</p>
      <p>Second assignment</p>
    ''')

    html, top_center = page_1.children[:2]
    line_box, = top_center.children

    text_box, = line_box.children
    assert text_box.text == 'Second assignment'


@assert_no_logs
def test_margin_box_string_set_6():
    # Test multiple complex string-set values
    page_1, = render_pages('''
      <style>
        @page {
          @top-center { content: string(text_header, first) }
          @bottom-center { content: string(text_footer, last) }
        }
        html { counter-reset: a }
        body { counter-increment: a }
        ul { counter-reset: b }
        li {
          counter-increment: b;
          string-set:
            text_header content(before) "-" content() "-" content(after)
                        counter(a, upper-roman) '.' counters(b, '|'),
            text_footer content(before) '-' attr(class)
                        counters(b, '|') "/" counter(a, upper-roman);
        }
        li:before { content: 'before!' }
        li:after { content: 'after!' }
        li:last-child:before { content: 'before!last' }
        li:last-child:after { content: 'after!last' }
      </style>
      <ul>
        <li class="firstclass">first
        <li>
          <ul>
            <li class="secondclass">second
    ''')

    html, top_center, bottom_center = page_1.children
    top_line_box, = top_center.children
    top_text_box, = top_line_box.children
    assert top_text_box.text == 'before!-first-after!I.1'
    bottom_line_box, = bottom_center.children
    bottom_text_box, = bottom_line_box.children
    assert bottom_text_box.text == 'before!last-secondclass2|1/I'


def test_margin_box_string_set_7():
    # Regression test for #722.
    page_1, = render_pages('''
      <style>
        img { string-set: left attr(alt) }
        img + img { string-set: right attr(alt) }
        @page { @top-left  { content: '[' string(left)  ']' }
                @top-right { content: '{' string(right) '}' } }
      </style>
      <img src=pattern.png alt="Chocolate">
      <img src=no_such_file.png alt="Cake">
    ''')

    html, top_left, top_right = page_1.children
    left_line_box, = top_left.children
    left_text_box, = left_line_box.children
    assert left_text_box.text == '[Chocolate]'
    right_line_box, = top_right.children
    right_text_box, = right_line_box.children
    assert right_text_box.text == '{Cake}'


@assert_no_logs
def test_margin_box_string_set_8():
    # Regression test for #726.
    page_1, page_2, page_3 = render_pages('''
      <style>
        @page { @top-left  { content: '[' string(left) ']' } }
        p { page-break-before: always }
        .initial { string-set: left 'initial' }
        .empty   { string-set: left ''        }
        .space   { string-set: left ' '       }
      </style>

      <p class="initial">Initial</p>
      <p class="empty">Empty</p>
      <p class="space">Space</p>
    ''')
    html, top_left = page_1.children
    left_line_box, = top_left.children
    left_text_box, = left_line_box.children
    assert left_text_box.text == '[initial]'

    html, top_left = page_2.children
    left_line_box, = top_left.children
    left_text_box, = left_line_box.children
    assert left_text_box.text == '[]'

    html, top_left = page_3.children
    left_line_box, = top_left.children
    left_text_box, = left_line_box.children
    assert left_text_box.text == '[ ]'


@assert_no_logs
def test_margin_box_string_set_9():
    # Regression test for #827.
    # Test that named strings are case-sensitive.
    page_1, = render_pages('''
      <style>
        @page {
          @top-center {
            content: string(text_header, first)
                     ' ' string(TEXT_header, first)
          }
        }
        p { string-set: text_header content() }
        div { string-set: TEXT_header content() }
      </style>
      <p>first assignment</p>
      <div>second assignment</div>
    ''')

    html, top_center = page_1.children
    line_box, = top_center.children
    text_box, = line_box.children
    assert text_box.text == 'first assignment second assignment'


@assert_no_logs
def test_margin_box_string_set_10():
    page_1, page_2, page_3, page_4 = render_pages('''
      <style>
        @page { @top-left  { content: '[' string(p, start) ']' } }
        p { string-set: p content(); page-break-after: always }
      </style>
      <article></article>
      <p>1</p>
      <article></article>
      <p>2</p>
      <p>3</p>
      <article></article>
    ''')
    html, top_left = page_1.children
    left_line_box, = top_left.children
    left_text_box, = left_line_box.children
    assert left_text_box.text == '[]'

    html, top_left = page_2.children
    left_line_box, = top_left.children
    left_text_box, = left_line_box.children
    assert left_text_box.text == '[1]'

    html, top_left = page_3.children
    left_line_box, = top_left.children
    left_text_box, = left_line_box.children
    assert left_text_box.text == '[3]'

    html, top_left = page_4.children
    left_line_box, = top_left.children
    left_text_box, = left_line_box.children
    assert left_text_box.text == '[3]'


@assert_no_logs
def test_page_counters():
    """Test page-based counters."""
    pages = render_pages('''
      <style>
        @page {
          /* Make the page content area only 10px high and wide,
             so every word in <p> end up on a page of its own. */
          size: 30px;
          margin: 10px;
          @bottom-center {
            content: "Page " counter(page) " of " counter(pages) ".";
          }
        }
      </style>
      <p>lorem ipsum dolor
    ''')
    for page_number, page in enumerate(pages, 1):
        html, bottom_center = page.children
        line_box, = bottom_center.children
        text_box, = line_box.children
        assert text_box.text == f'Page {page_number} of 3.'


@assert_no_logs
@pytest.mark.parametrize('html', [
    '<html style="display: none">',
    '<html style="display: none">abc',
    '<html style="display: none"><p>abc',
    '<body style="display: none"><p>abc',
])
def test_display_none_root(html):
    box = parse_all(html)
    assert box.style['display'] == ('block', 'flow')
    assert not box.children


================================================
FILE: tests/test_fonts.py
================================================
"""Test the fonts features."""

from .testing_utils import assert_no_logs, render_pages


@assert_no_logs
def test_font_face():
    page, = render_pages('''
      <style>
        body { font-family: weasyprint }
      </style>
      <span>abc</span>''')
    html, = page.children
    body, = html.children
    line, = body.children
    assert line.width == 3 * 16


@assert_no_logs
def test_kerning_default():
    # Kerning and ligatures are on by default
    page, = render_pages('''
      <style>
        body { font-family: weasyprint }
      </style>
      <span>kk</span><span>liga</span>''')
    html, = page.children
    body, = html.children
    line, = body.children
    span1, span2 = line.children
    assert span1.width == 1.5 * 16
    assert span2.width == 1.5 * 16


@assert_no_logs
def test_ligatures_word_space():
    # Regression test for #1469.
    # Kerning and ligatures are on for text with increased word spacing.
    page, = render_pages('''
      <style>
        body { font-family: weasyprint; word-spacing: 1em; width: 10em }
      </style>
      aa liga aa''')
    html, = page.children
    body, = html.children
    assert len(body.children) == 1


@assert_no_logs
def test_kerning_deactivate():
    # Deactivate kerning
    page, = render_pages('''
      <style>
        @font-face {
          src: url(weasyprint.otf);
          font-family: no-kern;
          font-feature-settings: 'kern' 0;
        }
        @font-face {
          src: url(weasyprint.otf);
          font-family: kern;
        }
        span:nth-child(1) { font-family: kern }
        span:nth-child(2) { font-family: no-kern }
      </style>
      <span>kk</span><span>kk</span>''')
    html, = page.children
    body, = html.children
    line, = body.children
    span1, span2 = line.children
    assert span1.width == 1.5 * 16
    assert span2.width == 2 * 16


@assert_no_logs
def test_kerning_ligature_deactivate():
    # Deactivate kerning and ligatures
    page, = render_pages('''
      <style>
        @font-face {
          src: url(weasyprint.otf);
          font-family: no-kern-liga;
          font-feature-settings: 'kern' off;
          font-variant: no-common-ligatures;
        }
        @font-face {
          src: url(weasyprint.otf);
          font-family: kern-liga;
        }
        span:nth-child(1) { font-family: kern-liga }
        span:nth-child(2) { font-family: no-kern-liga }
      </style>
      <span>kk liga</span><span>kk liga</span>''')
    html, = page.children
    body, = html.children
    line, = body.children
    span1, span2 = line.children
    assert span1.width == (1.5 + 1 + 1.5) * 16
    assert span2.width == (2 + 1 + 4) * 16


@assert_no_logs
def test_font_face_descriptors():
    page, = render_pages(
        '''
        <style>
          @font-face {
            src: url(weasyprint.otf);
            font-family: weasyprint-variant;
            font-variant: sub
                          discretionary-ligatures
                          oldstyle-nums
                          slashed-zero;
          }
          span { font-family: weasyprint-variant }
        </style>'''
        '<span>kk</span>'
        '<span>subs</span>'
        '<span>dlig</span>'
        '<span>onum</span>'
        '<span>zero</span>')
    html, = page.children
    body, = html.children
    line, = body.children
    kern, subs, dlig, onum, zero = line.children
    assert kern.width == 1.5 * 16
    assert subs.width == 1.5 * 16
    assert dlig.width == 1.5 * 16
    assert onum.width == 1.5 * 16
    assert zero.width == 1.5 * 16


@assert_no_logs
def test_woff_simple():
    page, = render_pages(
      '''
      <style>
        @font-face {
          src: url(weasyprint.otf);
          font-family: weasyprint-otf;
        }
        @font-face {
          src: url(weasyprint.woff);
          font-family: weasyprint-woff;
        }
        @font-face {
          src: url(weasyprint.woff);
          font-family: weasyprint-woff-cached;
        }
        span:nth-child(1) { font-family: weasyprint-otf }
        span:nth-child(2) { font-family: weasyprint-woff }
        span:nth-child(3) { font-family: weasyprint-woff-cached }
        span:nth-child(4) { font-family: sans }
      </style>'''
      '<span>woff font</span>'
      '<span>woff font</span>'
      '<span>woff font</span>'
      '<span>woff font</span>')
    html, = page.children
    body, = html.children
    line, = body.children
    span1, span2, span3, span4 = line.children
    # otf font matches woff font
    assert span1.width == span2.width
    # otf font matches woff font loaded from cache
    assert span1.width == span3.width
    # the default font does not match the loaded fonts
    assert span1.width != span4.width


================================================
FILE: tests/test_pdf.py
================================================
"""Test PDF-related code, including metadata, bookmarks and hyperlinks."""

import hashlib
import io
import re
from codecs import BOM_UTF16_BE

import pytest

from weasyprint import Attachment
from weasyprint.document import Document, DocumentMetadata
from weasyprint.text.fonts import FontConfiguration
from weasyprint.urls import path2url

from .testing_utils import FakeHTML, assert_no_logs, capture_logs, resource_path

# Top and right positions in points, rounded to the default float precision of
# 6 digits, a rendered by pydyf
TOP = round(297 * 72 / 25.4, 6)
RIGHT = round(210 * 72 / 25.4, 6)


@assert_no_logs
@pytest.mark.parametrize('zoom', [1, 1.5, 0.5])
def test_page_size_zoom(zoom):
    pdf = FakeHTML(string='<style>@page{size:3in 4in').write_pdf(zoom=zoom)
    width, height = int(216 * zoom), int(288 * zoom)
    assert f'/MediaBox [0 0 {width} {height}]'.encode() in pdf


@assert_no_logs
def test_bookmarks_1():
    pdf = FakeHTML(string='''
      <h1>a</h1>  #
      <h4>b</h4>  ####
      <h3>c</h3>  ###
      <h2>d</h2>  ##
      <h1>e</h1>  #
    ''').write_pdf()
    # a
    # |_ b
    # |_ c
    # L_ d
    # e
    assert re.findall(b'/Count ([0-9-]*)', pdf)[-1] == b'5'
    assert re.findall(b'/Title \\((.*)\\)', pdf) == [
        b'a', b'b', b'c', b'd', b'e']


@assert_no_logs
def test_bookmarks_2():
    pdf = FakeHTML(string='<body>').write_pdf()
    assert b'Outlines' not in pdf


@assert_no_logs
def test_bookmarks_3():
    pdf = FakeHTML(string='<h1>a nbsp…</h1>').write_pdf()
    assert re.findall(b'/Title <(\\w*)>', pdf) == [
        b'feff006100a0006e0062007300702026']


@assert_no_logs
def test_bookmarks_4():
    pdf = FakeHTML(string='''
      <style>
        h1, h2, h3, span { height: 90pt; margin: 0 0 10pt 0 }
      </style>
      <h1>1</h1>
      <h1>2</h1>
      <h2 style="position: relative; left: 20pt">3</h2>
      <h2>4</h2>
      <h3>5</h3>
      <span style="display: block; page-break-before: always"></span>
      <h2>6</h2>
      <h1>7</h1>
      <h2>8</h2>
      <h3>9</h3>
      <h1>10</h1>
      <h2>11</h2>
    ''').write_pdf()
    # 1
    # 2
    # |_ 3
    # |_ 4
    # |  L_ 5
    # L_ 6
    # 7
    # L_ 8
    #    L_ 9
    # 10
    # L_ 11
    assert re.findall(b'/Title \\((.*)\\)', pdf) == [
        str(i).encode() for i in range(1, 12)]
    counts = re.findall(b'/Count ([0-9-]*)', pdf)
    counts.pop(0)  # Page count
    outlines = counts.pop()
    assert outlines == b'11'
    assert counts == [
        b'0', b'4', b'0', b'1', b'0', b'0', b'2', b'1', b'0', b'1', b'0']


@assert_no_logs
def test_bookmarks_5():
    pdf = FakeHTML(string='''
      <h2>1</h2> level 1
      <h4>2</h4> level 2
      <h2>3</h2> level 1
      <h3>4</h3> level 2
      <h4>5</h4> level 3
    ''').write_pdf()
    # 1
    # L_ 2
    # 3
    # L_ 4
    #    L_ 5
    assert re.findall(b'/Title \\((.*)\\)', pdf) == [
        str(i).encode() for i in range(1, 6)]
    counts = re.findall(b'/Count ([0-9-]*)', pdf)
    counts.pop(0)  # Page count
    outlines = counts.pop()
    assert outlines == b'5'
    assert counts == [b'1', b'0', b'2', b'1', b'0']


@assert_no_logs
def test_bookmarks_6():
    pdf = FakeHTML(string='''
      <h2>1</h2> h2 level 1
      <h4>2</h4> h4 level 2
      <h3>3</h3> h3 level 2
      <h5>4</h5> h5 level 3
      <h1>5</h1> h1 level 1
      <h2>6</h2> h2 level 2
      <h2>7</h2> h2 level 2
      <h4>8</h4> h4 level 3
      <h1>9</h1> h1 level 1
    ''').write_pdf()
    # 1
    # |_ 2
    # L_ 3
    #    L_ 4
    # 5
    # |_ 6
    # L_ 7
    #    L_ 8
    # 9
    assert re.findall(b'/Title \\((.*)\\)', pdf) == [
        str(i).encode() for i in range(1, 10)]
    counts = re.findall(b'/Count ([0-9-]*)', pdf)
    counts.pop(0)  # Page count
    outlines = counts.pop()
    assert outlines == b'9'
    assert counts == [b'3', b'0', b'1', b'0', b'3', b'0', b'1', b'0', b'0']


@assert_no_logs
def test_bookmarks_7():
    # Reference for the next test. zoom=1
    pdf = FakeHTML(string='<h2>a</h2>').write_pdf()

    assert re.findall(b'/Title \\((.*)\\)', pdf) == [b'a']
    dest, = re.findall(b'/Dest \\[(.*)\\]', pdf)
    y = round(float(dest.strip().split()[-2]))

    pdf = FakeHTML(string='<h2>a</h2>').write_pdf(zoom=1.5)
    assert re.findall(b'/Title \\((.*)\\)', pdf) == [b'a']
    dest, = re.findall(b'/Dest \\[(.*)\\]', pdf)
    assert round(float(dest.strip().split()[-2])) == 1.5 * y


@assert_no_logs
def test_bookmarks_8():
    pdf = FakeHTML(string='''
      <h1>a</h1>
      <h2>b</h2>
      <h3>c</h3>
      <h2 style="bookmark-state: closed">d</h2>
      <h3>e</h3>
      <h4>f</h4>
      <h1>g</h1>
    ''').write_pdf()
    # a
    # |_ b
    # |  |_ c
    # |_ d (closed)
    # |  |_ e
    # |     |_ f
    # g
    assert re.findall(b'/Title \\((.*)\\)', pdf) == [
        b'a', b'b', b'c', b'd', b'e', b'f', b'g']
    counts = re.findall(b'/Count ([0-9-]*)', pdf)
    counts.pop(0)  # Page count
    outlines = counts.pop()
    assert outlines == b'5'
    assert counts == [b'3', b'1', b'0', b'-2', b'1', b'0', b'0']


@assert_no_logs
def test_bookmarks_9():
    pdf = FakeHTML(string='''
      <h1 style="bookmark-label: 'h1 on page ' counter(page)">a</h1>
    ''').write_pdf()
    counts = re.findall(b'/Count ([0-9-]*)', pdf)
    outlines = counts.pop()
    assert outlines == b'1'
    assert re.findall(b'/Title \\((.*)\\)', pdf) == [b'h1 on page 1']


@assert_no_logs
def test_bookmarks_10():
    pdf = FakeHTML(string='''
      <style>
      div:before, div:after {
         content: '';
         bookmark-level: 1;
         bookmark-label: 'x';
      }
      </style>
      <div>a</div>
    ''').write_pdf()
    # x
    # x
    counts = re.findall(b'/Count ([0-9-]*)', pdf)
    outlines = counts.pop()
    assert outlines == b'2'
    assert re.findall(b'/Title \\((.*)\\)', pdf) == [b'x', b'x']


@assert_no_logs
def test_bookmarks_11():
    pdf = FakeHTML(string='''
      <div style="display:inline; white-space:pre;
       bookmark-level:1; bookmark-label:'a'">
      a
      a
      a
      </div>
      <div style="bookmark-level:1; bookmark-label:'b'">
        <div>b</div>
        <div style="break-before:always">c</div>
      </div>
    ''').write_pdf()
    # a
    # b
    counts = re.findall(b'/Count ([0-9-]*)', pdf)
    outlines = counts.pop()
    assert outlines == b'2'
    assert re.findall(b'/Title \\((.*)\\)', pdf) == [b'a', b'b']


@assert_no_logs
def test_bookmarks_12():
    pdf = FakeHTML(string='''
      <div style="bookmark-level:1; bookmark-label:contents">a</div>
    ''').write_pdf()
    # a
    counts = re.findall(b'/Count ([0-9-]*)', pdf)
    outlines = counts.pop()
    assert outlines == b'1'
    assert re.findall(b'/Title \\((.*)\\)', pdf) == [b'a']


@assert_no_logs
def test_bookmarks_13():
    pdf = FakeHTML(string='''
      <div style="bookmark-level:1; bookmark-label:contents;
                  text-transform:uppercase">a</div>
    ''').write_pdf()
    # a
    counts = re.findall(b'/Count ([0-9-]*)', pdf)
    outlines = counts.pop()
    assert outlines == b'1'
    assert re.findall(b'/Title \\((.*)\\)', pdf) == [b'a']


@assert_no_logs
def test_bookmarks_14():
    pdf = FakeHTML(string='''
      <h1>a</h1>
      <h1> b c d </h1>
      <h1> e
             f </h1>
      <h1> g <span> h </span> i </h1>
    ''').write_pdf()
    assert re.findall(b'/Count ([0-9-]*)', pdf)[-1] == b'4'
    assert re.findall(b'/Title \\((.*)\\)', pdf) == [
        b'a', b'b c d', b'e f', b'g h i']


@assert_no_logs
def test_bookmarks_15():
    # Regression test for #1815.
    pdf = FakeHTML(string='''
      <style>@page { size: 10pt 10pt }</style>
      <h1>a</h1>
    ''').write_pdf()
    assert re.findall(b'/Count ([0-9-]*)', pdf)[-1] == b'1'
    assert re.findall(b'/Title \\((.*)\\)', pdf) == [b'a']
    assert b'/XYZ 0 10 0' in pdf


@assert_no_logs
def test_links_none():
    pdf = FakeHTML(string='<body>').write_pdf()
    assert b'Annots' not in pdf


@assert_no_logs
def test_links():
    pdf = FakeHTML(string='''
      <style>
        body { margin: 0; font-size: 10pt; line-height: 2 }
        p { display: block; height: 90pt; margin: 0 0 10pt 0 }
        img { width: 30pt; vertical-align: top }
      </style>
      <p><a href="https://weasyprint.org"><img src=pattern.png></a></p>
      <p style="padding: 0 10pt"><a
         href="#lipsum"><img style="border: solid 1pt"
                             src=pattern.png></a></p>
      <p id=hello>Hello, World</p>
      <p id=lipsum>
        <a style="display: block; page-break-before: always; height: 30pt"
           href="#hel%6Co"></a>a
      </p>
    ''', base_url=resource_path('<inline HTML>')).write_pdf()

    uris = re.findall(b'/URI \\((.*)\\)', pdf)
    types = re.findall(b'/S (/\\w*)', pdf)
    subtypes = re.findall(b'/Subtype (/\\w*)', pdf)
    rects = [
        [float(number) for number in match.split()] for match in re.findall(
            b'/Rect \\[([\\d\\.]+ [\\d\\.]+ [\\d\\.]+ [\\d\\.]+)\\]', pdf)]

    # 30pt wide (like the image), 20pt high (like line-height)
    assert uris.pop(0) == b'https://weasyprint.org'
    assert subtypes.pop(0) == b'/Link'
    assert types.pop(0) == b'/URI'
    assert rects.pop(0) == [0, TOP, 30, TOP - 20]

    # The image itself: 30*30pt
    assert uris.pop(0) == b'https://weasyprint.org'
    assert subtypes.pop(0) == b'/Link'
    assert types.pop(0) == b'/URI'
    assert rects.pop(0) == [0, TOP, 30, TOP - 30]

    # 32pt wide (image + 2 * 1pt of border), 20pt high
    assert subtypes.pop(0) == b'/Link'
    assert b'/Dest (lipsum)' in pdf
    link = re.search(
        b'\\(lipsum\\) \\[\\d+ 0 R /XYZ ([\\d\\.]+ [\\d\\.]+ [\\d\\.]+)]',
        pdf).group(1)
    assert [float(number) for number in link.split()] == [0, TOP, 0]
    assert rects.pop(0) == [10, TOP - 100, 10 + 32, TOP - 100 - 20]

    # The image itself: 32*32pt
    assert subtypes.pop(0) == b'/Link'
    assert rects.pop(0) == [10, TOP - 100, 10 + 32, TOP - 100 - 32]

    # 100% wide (block), 30pt high
    assert subtypes.pop(0) == b'/Link'
    assert b'/Dest (hello)' in pdf
    link = re.search(
        b'\\(hello\\) \\[\\d+ 0 R /XYZ ([\\d\\.]+ [\\d\\.]+ [\\d\\.]+)]',
        pdf).group(1)
    assert [float(number) for number in link.split()] == [0, TOP - 200, 0]
    assert rects.pop(0) == [0, TOP, RIGHT, TOP - 30]


@assert_no_logs
def test_sorted_links():
    # Regression test for #1352.
    pdf = FakeHTML(string='''
      <p id="zzz">zzz</p>
      <p id="aaa">aaa</p>
      <a href="#zzz">z</a>
      <a href="#aaa">a</a>
    ''', base_url=resource_path('<inline HTML>')).write_pdf()
    assert b'(zzz) [' in pdf.split(b'(aaa) [')[-1]


@assert_no_logs
def test_relative_links_no_height():
    # 100% wide (block), 0pt high
    pdf = FakeHTML(
        string='<a href="../lipsum" style="display: block"></a>a',
        base_url='https://weasyprint.org/foo/bar/').write_pdf()
    assert b'/S /URI\n/URI (https://weasyprint.org/foo/lipsum)'
    assert f'/Rect [0 {TOP} {RIGHT} {TOP}]'.encode() in pdf


@assert_no_logs
def test_relative_links_missing_base():
    # Relative URI reference without a base URI
    pdf = FakeHTML(
        string='<a href="../lipsum" style="display: block"></a>a',
        base_url=None).write_pdf()
    assert b'/S /URI\n/URI (../lipsum)'
    assert f'/Rect [0 {TOP} {RIGHT} {TOP}]'.encode() in pdf


@assert_no_logs
def test_relative_links_missing_base_link():
    # Relative URI reference without a base URI: not supported for -weasy-link
    with capture_logs() as logs:
        pdf = FakeHTML(
            string='<div style="-weasy-link: url(../lipsum)">',
            base_url=None).write_pdf()
    assert b'/Annots' not in pdf
    assert len(logs) == 1
    assert 'WARNING: Ignored `-weasy-link: url(../lipsum)`' in logs[0]
    assert 'Relative URI reference without a base URI' in logs[0]


@assert_no_logs
def test_relative_links_internal():
    # Internal URI reference without a base URI: OK
    pdf = FakeHTML(
        string='<a href="#lipsum" id="lipsum" style="display: block"></a>a',
        base_url=None).write_pdf()
    assert b'/Dest (lipsum)' in pdf
    link = re.search(
        b'\\(lipsum\\) \\[\\d+ 0 R /XYZ ([\\d\\.]+ [\\d\\.]+ [\\d\\.]+)]',
        pdf).group(1)
    assert [float(number) for number in link.split()] == [0, TOP, 0]
    rect = re.search(
        b'/Rect \\[([\\d\\.]+ [\\d\\.]+ [\\d\\.]+ [\\d\\.]+)\\]',
        pdf).group(1)
    assert [float(number) for number in rect.split()] == [0, TOP, RIGHT, TOP]


@assert_no_logs
def test_relative_links_anchors():
    pdf = FakeHTML(
        string='<div style="-weasy-link: url(#lipsum)" id="lipsum"></div>a',
        base_url=None).write_pdf()
    assert b'/Dest (lipsum)' in pdf
    link = re.search(
        b'\\(lipsum\\) \\[\\d+ 0 R /XYZ ([\\d\\.]+ [\\d\\.]+ [\\d\\.]+)]',
        pdf).group(1)
    assert [float(number) for number in link.split()] == [0, TOP, 0]
    rect = re.search(
        b'/Rect \\[([\\d\\.]+ [\\d\\.]+ [\\d\\.]+ [\\d\\.]+)\\]',
        pdf).group(1)
    assert [float(number) for number in rect.split()] == [0, TOP, RIGHT, TOP]


@assert_no_logs
def test_relative_links_different_base():
    pdf = FakeHTML(
        string='<a href="/test/lipsum"></a>a',
        base_url='https://weasyprint.org/foo/bar/').write_pdf()
    assert b'https://weasyprint.org/test/lipsum' in pdf


@assert_no_logs
def test_relative_links_same_base():
    pdf = FakeHTML(
        string='<a id="test" href="/foo/bar/#test"></a>a',
        base_url='https://weasyprint.org/foo/bar/').write_pdf()
    assert b'/Dest (test)' in pdf


@assert_no_logs
def test_missing_links():
    with capture_logs() as logs:
        pdf = FakeHTML(string='''
          <style> a { display: block; height: 15pt } </style>
          <a href="#lipsum"></a>
          <a href="#missing" id="lipsum"></a>
          <a href=""></a>a
        ''', base_url=None).write_pdf()
    assert b'/Dest (lipsum)' in pdf
    assert len(logs) == 1
    link = re.search(
        b'\\(lipsum\\) \\[\\d+ 0 R /XYZ ([\\d\\.]+ [\\d\\.]+ [\\d\\.]+)]',
        pdf).group(1)
    assert [float(number) for number in link.split()] == [0, TOP - 15, 0]
    rect = re.search(
        b'/Rect \\[([\\d\\.]+ [\\d\\.]+ [\\d\\.]+ [\\d\\.]+)\\]',
        pdf).group(1)
    assert [float(number) for number in rect.split()] == [
        0, TOP, RIGHT, TOP - 15]
    assert 'ERROR: No anchor #missing for internal URI reference' in logs[0]


@assert_no_logs
def test_anchor_multiple_pages():
    pdf = FakeHTML(string='''
      <style> a { display: block; break-after: page } </style>
      <div id="lipsum">
        <a href="#lipsum"></a>
        <a href="#lipsum"></a>
        <a href="#lipsum"></a>
      </div>
    ''', base_url=None).write_pdf()
    first_page, = re.findall(b'/Kids \\[(\\d+) 0 R', pdf)
    assert b'/Names [(lipsum) [' + first_page in pdf


@assert_no_logs
def test_embed_gif():
    assert b'/Filter /DCTDecode' not in FakeHTML(
        base_url=resource_path('dummy.html'),
        string='<img src="pattern.gif">').write_pdf()


@assert_no_logs
def test_embed_jpeg():
    # JPEG-encoded image, embedded in PDF:
    assert b'/Filter /DCTDecode' in FakeHTML(
        base_url=resource_path('dummy.html'),
        string='<img src="blue.jpg">').write_pdf()


@assert_no_logs
def test_embed_image_once():
    # Image repeated multiple times, embedded once
    assert FakeHTML(
        base_url=resource_path('dummy.html'),
        string='''
          <img src="blue.jpg">
          <div style="background: url(blue.jpg)"></div>
          <img src="blue.jpg">
          <div style="background: url(blue.jpg) no-repeat"></div>
        ''').write_pdf().count(b'/Filter /DCTDecode') == 1


@assert_no_logs
def test_embed_images_from_pages():
    page1, = FakeHTML(
        base_url=resource_path('dummy.html'),
        string='<img src="blue.jpg">').render().pages
    page2, = FakeHTML(
        base_url=resource_path('dummy.html'),
        string='<img src="not-optimized.jpg">').render().pages
    document = Document(
        (page1, page2), metadata=DocumentMetadata(),
        font_config=FontConfiguration(), color_profiles={},
        url_fetcher=None).write_pdf()
    assert document.count(b'/Filter /DCTDecode') == 2


@assert_no_logs
def test_document_info():
    pdf = FakeHTML(string='''
      <meta name=author content="I Me &amp; Myself">
      <title>Test document</title>
      <h1>Another title</h1>
      <meta name=generator content="Human after all">
      <meta name=keywords content="html ,\tcss,
                                   pdf,css">
      <meta name=description content="Blah… ">
      <meta name=dcterms.created content=2011-04-21T23:00:00Z>
      <meta name=dcterms.modified content=2013-07-21T23:46+01:00>
    ''').write_pdf()
    assert b'/Author (I Me & Myself)' in pdf
    assert b'/Title (Test document)' in pdf
    assert (
        b'/Creator <feff00480075006d0061006e00a00061'
        b'006600740065007200a00061006c006c>') in pdf
    assert b'/Keywords (html, css, pdf)' in pdf
    assert b'/Subject <feff0042006c0061006820260020>' in pdf
    assert b'/CreationDate (D:20110421230000Z)' in pdf
    assert b"/ModDate (D:20130721234600+01'00)" in pdf


@assert_no_logs
def test_embedded_files_attachments(tmp_path):
    absolute_tmp_path = tmp_path / 'some_file.txt'
    absolute_data = b'12345678'
    absolute_tmp_path.write_bytes(absolute_data)
    absolute_url = path2url(absolute_tmp_path)
    assert absolute_url.startswith('file://')

    relative_tmp_path = tmp_path / 'äöü.txt'
    relative_data = b'abcdefgh'
    relative_tmp_path.write_bytes(relative_data)

    pdf = FakeHTML(
        string=f'''
          <title>Test document</title>
          <meta charset="utf-8">
          <link
            rel="attachment"
            title="some file attachment äöü"
            href="data:,hi%20there">
          <link rel="attachment" href="{absolute_url}">
          <link rel="attachment" href="{relative_tmp_path.name}">
          <h1>Heading 1</h1>
          <h2>Heading 2</h2>
        ''',
        base_url=tmp_path,
    ).write_pdf(
        attachments=[
            Attachment('data:,oob attachment', description='Hello'),
            'data:,raw URL',
            io.BytesIO(b'file like obj')
        ]
    )
    assert f'<{hashlib.md5(b"hi there").hexdigest()}>'.encode() in pdf
    assert b'/F (attachment.bin)' in pdf
    assert b'/UF (attachment.bin)' in pdf
    name = BOM_UTF16_BE + 'some file attachment äöü'.encode('utf-16-be')
    assert b'/Desc <' + name.hex().encode() + b'>' in pdf

    assert hashlib.md5(absolute_data).hexdigest().encode() in pdf
    assert absolute_tmp_path.name.encode() in pdf

    assert hashlib.md5(relative_data).hexdigest().encode() in pdf
    name = BOM_UTF16_BE + 'some file attachment äöü'.encode('utf-16-be')
    assert b'/Desc <' + name.hex().encode() + b'>' in pdf

    assert hashlib.md5(b'oob attachment').hexdigest().encode() in pdf
    assert b'/Desc (Hello)' in pdf
    assert hashlib.md5(b'raw URL').hexdigest().encode() in pdf
    assert hashlib.md5(b'file like obj').hexdigest().encode() in pdf

    assert b'/EmbeddedFiles' in pdf
    assert b'/Outlines' in pdf


@assert_no_logs
def test_attachments_data():
    pdf = FakeHTML(string='''
      <title>Test document 2</title>
      <meta charset="utf-8">
      <link rel="attachment" href="data:,some data">
    ''').write_pdf()
    md5 = f'<{hashlib.md5(b"some data").hexdigest()}>'.encode()
    assert md5 in pdf
    assert b'EmbeddedFiles' in pdf


@assert_no_logs
def test_attachments_data_with_anchor():
    pdf = FakeHTML(string='''
      <title>Test document 2</title>
      <meta charset="utf-8">
      <link rel="attachment" href="data:,some data">
      <h1 id="title">Title</h1>
      <a href="#title">example</a>
    ''').write_pdf()
    md5 = f'<{hashlib.md5(b"some data").hexdigest()}>'.encode()
    assert md5 in pdf
    assert b'EmbeddedFiles' in pdf


@assert_no_logs
def test_attachments_no_href():
    with capture_logs() as logs:
        pdf = FakeHTML(string='''
          <title>Test document 2</title>
          <meta charset="utf-8">
          <link rel="attachment">
        ''').write_pdf()
    assert b'Names' not in pdf
    assert b'Outlines' not in pdf
    assert len(logs) == 1
    assert 'Missing href' in logs[0]


@assert_no_logs
def test_attachments_none():
    pdf = FakeHTML(string='''
      <title>Test document 3</title>
      <meta charset="utf-8">
      <h1>Heading</h1>
    ''').write_pdf()
    assert b'Names' not in pdf
    assert b'Outlines' in pdf


@assert_no_logs
def test_attachments_none_empty():
    pdf = FakeHTML(string='''
      <title>Test document 3</title>
      <meta charset="utf-8">
    ''').write_pdf()
    assert b'Names' not in pdf
    assert b'Outlines' not in pdf


@assert_no_logs
def test_annotations():
    pdf = FakeHTML(string='''
      <title>Test document</title>
      <meta charset="utf-8">
      <a
        rel="attachment"
        href="data:,some data"
        download>A link that lets you download an attachment</a>
    ''').write_pdf()

    assert hashlib.md5(b'some data').hexdigest().encode() in pdf
    assert b'/FileAttachment' in pdf
    assert b'/EmbeddedFiles' not in pdf


@pytest.mark.parametrize(('style', 'media', 'bleed', 'trim'), [
    ('bleed: 30pt; size: 10pt',
     [-30, -30, 40, 40],
     [-10, -10, 20, 20],
     [0, 0, 10, 10]),
    ('bleed: 15pt 3pt 6pt 18pt; size: 12pt 15pt',
     [-18, -15, 15, 21],
     [-10, -10, 15, 21],
     [0, 0, 12, 15]),
])
@assert_no_logs
def test_bleed(style, media, bleed, trim):
    pdf = FakeHTML(string='''
      <title>Test document</title>
      <style>@page { %s }</style>
      <body>test
    ''' % style).write_pdf()
    assert f'/MediaBox {str(media).replace(",", "")}'.encode() in pdf
    assert f'/BleedBox {str(bleed).replace(",", "")}'.encode() in pdf
    assert f'/TrimBox {str(trim).replace(",", "")}'.encode() in pdf


@assert_no_logs
def test_default_rdf_metadata():
    pdf_document = FakeHTML(string='<body>test</body>').render()

    pdf_document.metadata.title = None

    pdf_bytes = pdf_document.write_pdf(
        pdf_variant='pdf/a-3b', pdf_identifier=b'example-bytes', uncompressed_pdf=True)
    assert b'<rdf:RDF xmlns:pdf="http://ns.adobe.com/pdf/1.3/"' in pdf_bytes


@assert_no_logs
def test_custom_rdf_metadata():
    def generate_rdf_metadata(*args, **kwargs):
        return b'TEST_METADATA'

    pdf_document = FakeHTML(string='<body>test</body>').render()

    pdf_document.metadata.title = None
    pdf_document.metadata.generate_rdf_metadata = generate_rdf_metadata

    pdf_bytes = pdf_document.write_pdf(
        pdf_variant='pdf/a-3b', pdf_identifier=b'example-bytes', uncompressed_pdf=True)
    assert b'TEST_METADATA' in pdf_bytes


@assert_no_logs
def test_font_descent_ascent():
    pdf = FakeHTML(string='''
      <html style="font-family: weasyprint">abc
    ''').write_pdf()
    assert b'/Descent -200' in pdf
    assert b'/Ascent 800' in pdf


@assert_no_logs
def test_pdf_tags_inline_table():
    # Regression test for #2601.
    FakeHTML(string='''
      <html lang="en"><table style="display: inline"><td>abc
    ''').write_pdf(pdf_tags=True)


================================================
FILE: tests/test_presentational_hints.py
================================================
"""Test the HTML presentational hints."""

from weasyprint import CSS, HTML

from .testing_utils import BASE_URL, assert_no_logs

PH_TESTING_CSS = CSS(string='''
@page {margin: 0; size: 1000px 1000px}
body {margin: 0}
''')


@assert_no_logs
def test_no_ph():
    # Test both CSS and non-CSS rules
    document = HTML(string='''
      <hr size=100 />
      <table align=right width=100><td>0</td></table>
    ''').render(stylesheets=[PH_TESTING_CSS])
    page, = document.pages
    html, = page._page_box.children
    body, = html.children
    hr, table = body.children
    assert hr.border_height() != 100
    assert table.position_x == 0


@assert_no_logs
def test_ph_page():
    document = HTML(string='''
      <body marginheight=2 topmargin=3 leftmargin=5
            bgcolor=red text=blue />
    ''').render(stylesheets=[PH_TESTING_CSS], presentational_hints=True)
    page, = document.pages
    html, = page._page_box.children
    body, = html.children
    assert body.margin_top == 2
    assert body.margin_bottom == 2
    assert body.margin_left == 5
    assert body.margin_right == 0
    assert body.style['background_color'] == (1, 0, 0, 1)
    assert body.style['color'] == (0, 0, 1, 1)


@assert_no_logs
def test_ph_flow():
    document = HTML(string='''
      <pre wrap></pre>
      <center></center>
      <div align=center></div>
      <div align=middle></div>
      <div align=left></div>
      <div align=right></div>
      <div align=justify></div>
    ''').render(stylesheets=[PH_TESTING_CSS], presentational_hints=True)
    page, = document.pages
    html, = page._page_box.children
    body, = html.children
    pre, center, div1, div2, div3, div4, div5 = body.children
    assert pre.style['white_space'] == 'pre-wrap'
    assert center.style['text_align_all'] == 'center'
    assert div1.style['text_align_all'] == 'center'
    assert div2.style['text_align_all'] == 'center'
    assert div3.style['text_align_all'] == 'left'
    assert div4.style['text_align_all'] == 'right'
    assert div5.style['text_align_all'] == 'justify'


@assert_no_logs
def test_ph_phrasing():
    document = HTML(string='''
      <br clear=left>
      <br clear=right />
      <br clear=both />
      <br clear=all />
      <font color=red face=weasyprint size=7></font>
      <Font size=4></Font>
      <font size=+5 ></font>
      <font size=-5 ></font>
    ''', base_url=BASE_URL).render(
        stylesheets=[PH_TESTING_CSS], presentational_hints=True)
    page, = document.pages
    html, = page._page_box.children
    body, = html.children
    line1, line2, line3, line4, line5 = body.children
    br1, = line1.children
    br2, = line2.children
    br3, = line3.children
    br4, = line4.children
    font1, font2, font3, font4 = line5.children
    assert br1.style['clear'] == 'left'
    assert br2.style['clear'] == 'right'
    assert br3.style['clear'] == 'both'
    assert br4.style['clear'] == 'both'
    assert font1.style['color'] == (1, 0, 0, 1)
    assert font1.style['font_family'] == ('weasyprint',)
    assert font1.style['font_size'] == 1.5 * 2 * 16
    assert font2.style['font_size'] == 6 / 5 * 16
    assert font3.style['font_size'] == 1.5 * 2 * 16
    assert font4.style['font_size'] == 8 / 9 * 16


@assert_no_logs
def test_ph_lists():
    document = HTML(string='''
      <ol>
        <li type=A></li>
        <li type=1></li>
        <li type=a></li>
        <li type=i></li>
        <li type=I></li>
      </ol>
      <ul>
        <li type=circle></li>
        <li type=disc></li>
        <li type=square></li>
      </ul>
    ''').render(stylesheets=[PH_TESTING_CSS], presentational_hints=True)
    page, = document.pages
    html, = page._page_box.children
    body, = html.children
    ol, ul = body.children
    oli1, oli2, oli3, oli4, oli5 = ol.children
    uli1, uli2, uli3 = ul.children
    assert oli1.style['list_style_type'] == 'upper-alpha'
    assert oli2.style['list_style_type'] == 'decimal'
    assert oli3.style['list_style_type'] == 'lower-alpha'
    assert oli4.style['list_style_type'] == 'lower-roman'
    assert oli5.style['list_style_type'] == 'upper-roman'
    assert uli1.style['list_style_type'] == 'circle'
    assert uli2.style['list_style_type'] == 'disc'
    assert uli3.style['list_style_type'] == 'square'


@assert_no_logs
def test_ph_lists_types():
    document = HTML(string='''
      <ol type=A></ol>
      <ol type=1></ol>
      <ol type=a></ol>
      <ol type=i></ol>
      <ol type=I></ol>
      <ul type=circle></ul>
      <ul type=disc></ul>
      <ul type=square></ul>
    ''').render(stylesheets=[PH_TESTING_CSS], presentational_hints=True)
    page, = document.pages
    html, = page._page_box.children
    body, = html.children
    ol1, ol2, ol3, ol4, ol5, ul1, ul2, ul3 = body.children
    assert ol1.style['list_style_type'] == 'upper-alpha'
    assert ol2.style['list_style_type'] == 'decimal'
    assert ol3.style['list_style_type'] == 'lower-alpha'
    assert ol4.style['list_style_type'] == 'lower-roman'
    assert ol5.style['list_style_type'] == 'upper-roman'
    assert ul1.style['list_style_type'] == 'circle'
    assert ul2.style['list_style_type'] == 'disc'
    assert ul3.style['list_style_type'] == 'square'


@assert_no_logs
def test_ph_tables():
    document = HTML(string='''
      <table align=left rules=none></table>
      <table align=right rules=groups></table>
      <table align=center rules=rows></table>
      <table border=10 cellspacing=3 bordercolor=green>
        <thead>
          <tr>
            <th valign=top></th>
          </tr>
        </thead>
        <tr>
          <td nowrap><h1 align=right></h1><p align=center></p></td>
        </tr>
        <tr>
        </tr>
        <tfoot align=justify>
          <tr>
            <td></td>
          </tr>
        </tfoot>
      </table>
    ''').render(stylesheets=[PH_TESTING_CSS], presentational_hints=True)
    page, = document.pages
    html, = page._page_box.children
    body, = html.children
    wrapper1, wrapper2, wrapper3, wrapper4, = body.children
    assert wrapper1.style['float'] == 'left'
    assert wrapper2.style['float'] == 'right'
    assert wrapper3.style['margin_left'] == 'auto'
    assert wrapper3.style['margin_right'] == 'auto'
    assert wrapper1.children[0].style['border_left_style'] == 'hidden'
    assert wrapper1.style['border_collapse'] == 'collapse'
    assert wrapper2.children[0].style['border_left_style'] == 'hidden'
    assert wrapper2.style['border_collapse'] == 'collapse'
    assert wrapper3.children[0].style['border_left_style'] == 'hidden'
    assert wrapper3.style['border_collapse'] == 'collapse'

    table4, = wrapper4.children
    assert table4.style['border_top_style'] == 'outset'
    assert table4.style['border_top_width'] == 10
    assert table4.style['border_spacing'] == (3, 3)
    r, g, b, a = table4.style['border_left_color']
    assert g > r
    assert g > b
    head_group, rows_group, foot_group = table4.children
    head, = head_group.children
    th, = head.children
    assert th.style['vertical_align'] == 'top'
    line1, line2 = rows_group.children
    td, = line1.children
    assert td.style['white_space'] == 'nowrap'
    assert td.style['border_top_width'] == 1
    assert td.style['border_top_style'] == 'inset'
    h1, p = td.children
    assert h1.style['text_align_all'] == 'right'
    assert p.style['text_align_all'] == 'center'
    foot, = foot_group.children
    tr, = foot.children
    assert tr.style['text_align_all'] == 'justify'


@assert_no_logs
def test_ph_hr():
    document = HTML(string='''
      <hr align=left>
      <hr align=right />
      <hr align=both color=red />
      <hr align=center noshade size=10 />
      <hr align=all size=8 width=100 />
    ''').render(stylesheets=[PH_TESTING_CSS], presentational_hints=True)
    page, = document.pages
    html, = page._page_box.children
    body, = html.children
    hr1, hr2, hr3, hr4, hr5 = body.children
    assert hr1.margin_left == 0
    assert hr1.style['margin_right'] == 'auto'
    assert hr2.style['margin_left'] == 'auto'
    assert hr2.margin_right == 0
    assert hr3.style['margin_left'] == 'auto'
    assert hr3.style['margin_right'] == 'auto'
    assert hr3.style['color'] == (1, 0, 0, 1)
    assert hr4.style['margin_left'] == 'auto'
    assert hr4.style['margin_right'] == 'auto'
    assert hr4.border_height() == 10
    assert hr4.style['border_top_width'] == 5
    assert hr5.border_height() == 8
    assert hr5.height == 6
    assert hr5.width == 100
    assert hr5.style['border_top_width'] == 1


@assert_no_logs
def test_ph_embedded():
    document = HTML(string='''
      <object data="data:image/svg+xml,<svg></svg>"
              align=top hspace=10 vspace=20></object>
      <img src="data:image/svg+xml,<svg></svg>" alt=text
              align=right width=10 height=20 />
      <embed src="data:image/svg+xml,<svg></svg>" align=texttop />
    ''').render(stylesheets=[PH_TESTING_CSS], presentational_hints=True)
    page, = document.pages
    html, = page._page_box.children
    body, = html.children
    line, = body.children
    object_, text1, img, embed, text2 = line.children
    assert embed.style['vertical_align'] == 'text-top'
    assert object_.style['vertical_align'] == 'top'
    assert object_.margin_top == 20
    assert object_.margin_left == 10
    assert img.style['float'] == 'right'
    assert img.width == 10
    assert img.height == 20


================================================
FILE: tests/test_stacking.py
================================================
"""Test CSS stacking contexts."""

import pytest

from weasyprint.stacking import StackingContext

from .testing_utils import assert_no_logs, render_pages, serialize

z_index_source = '''
  <style>
    @page { size: 10px }
    div, div * { width: 10px; height: 10px; position: absolute }
    article { background: red; z-index: %s }
    section { background: blue; z-index: %s }
    nav { background: lime; z-index: %s }
  </style>
  <div>
    <article></article>
    <section></section>
    <nav></nav>
  </div>'''


def flatten_blocks_and_cells(blocks_and_cells):
    for block, blocks_and_cells in blocks_and_cells.items():
        yield block.element_tag
        yield from flatten_blocks_and_cells(blocks_and_cells)


def serialize_stacking(context):
    return (
        context.box.element_tag,
        list(flatten_blocks_and_cells(context.blocks_and_cells)),
        [serialize_stacking(context) for context in context.zero_z_contexts])


@assert_no_logs
@pytest.mark.parametrize(('source', 'contexts'), [
    ('''
      <p id=lorem></p>
      <div style="position: relative">
        <p id=lipsum></p>
      </div>''',
     ('html', ['body', 'p'], [('div', ['p'], [])])),
    ('''
      <div style="position: relative">
        <p style="position: relative"></p>
      </div>''',
     ('html', ['body'], [('div', [], []), ('p', [], [])])),
])
def test_nested(source, contexts):
    page, = render_pages(source)
    html, = page.children
    assert serialize_stacking(StackingContext.from_box(html, page)) == contexts


@assert_no_logs
def test_image_contexts():
    page, = render_pages('''
      <body>Some text: <img style="position: relative" src=pattern.png>''')
    html, = page.children
    context = StackingContext.from_box(html, page)
    # The image is *not* in this context:
    assert serialize([context.box]) == [
        ('html', 'Block', [
            ('body', 'Block', [
                ('body', 'Line', [
                    ('body', 'Text', 'Some text: ')])])])]
    # ... but in a sub-context:
    assert serialize(c.box for c in context.zero_z_contexts) == [
        ('img', 'InlineReplaced', '<replaced>')]


@assert_no_logs
@pytest.mark.parametrize(('z_indexes', 'color'), [
    ((3, 2, 1), 'R'),
    ((1, 2, 3), 'G'),
    ((1, 2, -3), 'B'),
    ((1, 2, 'auto'), 'B'),
    ((-1, 'auto', -2), 'B'),
])
def test_z_index(assert_pixels, z_indexes, color):
    assert_pixels('\n'.join([color * 10] * 10), z_index_source % z_indexes)


================================================
FILE: tests/test_text.py
================================================
"""Test the text layout."""

import pytest

from weasyprint.css import InitialStyle
from weasyprint.formatting_structure.build import capitalize
from weasyprint.text.fonts import FontConfiguration
from weasyprint.text.line_break import split_first_line

from .testing_utils import MONO_FONTS, SANS_FONTS, assert_no_logs, render_pages


def make_text(text, width=None, **style):
    """Wrapper for split_first_line() creating a style dict."""
    new_style = InitialStyle(FontConfiguration())
    new_style['font_family'] = MONO_FONTS.split(',')
    new_style.update(style)
    return split_first_line(
        text, new_style, context=None, max_width=width,
        justification_spacing=0)


@assert_no_logs
def test_line_content():
    for width, remaining in [(100, 'text for test'),
                             (45, 'is a text for test')]:
        text = 'This is a text for test'
        _, length, resume_index, _, _, _ = make_text(
            text, width, font_family=SANS_FONTS.split(','), font_size=19)
        assert text[resume_index:] == remaining
        assert length + 1 == resume_index  # +1 for the removed trailing space


@assert_no_logs
def test_line_with_any_width():
    _, _, _, width_1, _, _ = make_text('some text')
    _, _, _, width_2, _, _ = make_text('some text some text')
    assert width_1 < width_2


@assert_no_logs
def test_line_breaking():
    string = 'Thïs is a text for test'

    # These two tests do not really rely on installed fonts
    _, _, resume_index, _, _, _ = make_text(string, 90, font_size=1)
    assert resume_index is None

    _, _, resume_index, _, _, _ = make_text(string, 90, font_size=100)
    assert string.encode()[resume_index:].decode() == 'is a text for test'

    _, _, resume_index, _, _, _ = make_text(
        string, 100, font_family=SANS_FONTS.split(','), font_size=19)
    assert string.encode()[resume_index:].decode() == 'text for test'


@assert_no_logs
def test_line_breaking_rtl():
    string = 'لوريم ايبسوم دولا'

    # These two tests do not really rely on installed fonts
    _, _, resume_index, _, _, _ = make_text(string, 90, font_size=1)
    assert resume_index is None

    _, _, resume_index, _, _, _ = make_text(string, 90, font_size=100)
    assert string.encode()[resume_index:].decode() == 'ايبسوم دولا'


@assert_no_logs
def test_line_breaking_nbsp():
    # Regression test for #1561.
    page, = render_pages('''
      <style>
        body { font-family: weasyprint; width: 7.5em }
      </style>
      <body>a <span>b</span> c d&nbsp;<span>ef
    ''')
    html, = page.children
    body, = html.children
    line_1, line_2 = body.children
    assert line_1.children[0].text == 'a '
    assert line_1.children[1].children[0].text == 'b'
    assert line_1.children[2].text == ' c'
    assert line_2.children[0].text == 'd\xa0'
    assert line_2.children[1].children[0].text == 'ef'


@assert_no_logs
def test_text_dimension():
    string = 'This is a text for test. This is a test for text.py'
    _, _, _, width_1, height_1, _ = make_text(string, 200, font_size=12)

    _, _, _, width_2, height_2, _ = make_text(string, 200, font_size=20)
    assert width_1 * height_1 < width_2 * height_2


@assert_no_logs
def test_text_font_size_zero():
    page, = render_pages('''
      <style>
        p { font-size: 0; }
      </style>
      <p>test font size zero</p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line, = paragraph.children
    # zero-sized text boxes are removed
    assert not line.children
    assert line.height == 0
    assert paragraph.height == 0


@assert_no_logs
def test_text_font_size_very_small():
    # Regression test for #1499.
    page, = render_pages('''
      <style>
        p { font-size: 0.00000001px }
      </style>
      <p>test font size zero</p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line, = paragraph.children
    assert line.height < 0.001
    assert paragraph.height < 0.001


@assert_no_logs
def test_text_spaced_inlines():
    page, = render_pages('''
      <p>start <i><b>bi1</b> <b>bi2</b></i> <b>b1</b> end</p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line, = paragraph.children
    start, i, space, b, end = line.children
    assert start.text == 'start '
    assert space.text == ' '
    assert space.width > 0
    assert end.text == ' end'

    bi1, space, bi2 = i.children
    bi1, = bi1.children
    bi2, = bi2.children
    assert bi1.text == 'bi1'
    assert space.text == ' '
    assert space.width > 0
    assert bi2.text == 'bi2'

    b1, = b.children
    assert b1.text == 'b1'


@assert_no_logs
def test_text_align_left():
    # <-------------------->  page, body
    #     +-----+
    # +---+     |
    # |   |     |
    # +---+-----+

    # ^   ^     ^          ^
    # x=0 x=40  x=100      x=200
    page, = render_pages('''
      <style>
        @page { size: 200px }
      </style>
      <body>
        <img src="pattern.png" style="width: 40px"
        ><img src="pattern.png" style="width: 60px">''')
    html, = page.children
    body, = html.children
    line, = body.children
    img_1, img_2 = line.children
    # initial value for text-align: left (in ltr text)
    assert img_1.position_x == 0
    assert img_2.position_x == 40


@assert_no_logs
def test_text_align_right():
    # <-------------------->  page, body
    #                +-----+
    #            +---+     |
    #            |   |     |
    #            +---+-----+

    # ^          ^   ^     ^
    # x=0        x=100     x=200
    #                x=140
    page, = render_pages('''
      <style>
        @page { size: 200px }
        body { text-align: right }
      </style>
      <body>
        <img src="pattern.png" style="width: 40px"
        ><img src="pattern.png" style="width: 60px">''')
    html, = page.children
    body, = html.children
    line, = body.children
    img_1, img_2 = line.children
    assert img_1.position_x == 100  # 200 - 60 - 40
    assert img_2.position_x == 140  # 200 - 60


@assert_no_logs
def test_text_align_center():
    # <-------------------->  page, body
    #           +-----+
    #       +---+     |
    #       |   |     |
    #       +---+-----+

    # ^     ^   ^     ^
    # x=    x=50     x=150
    #           x=90
    page, = render_pages('''
      <style>
        @page { size: 200px }
        body { text-align: center }
      </style>
      <body>
        <img src="pattern.png" style="width: 40px"
        ><img src="pattern.png" style="width: 60px">''')
    html, = page.children
    body, = html.children
    line, = body.children
    img_1, img_2 = line.children
    assert img_1.position_x == 50
    assert img_2.position_x == 90


@assert_no_logs
def test_text_align_justify():
    page, = render_pages('''
      <style>
        @page { size: 300px 1000px }
        body { text-align: justify }
      </style>
      <p><img src="pattern.png" style="width: 40px">
        <strong>
          <img src="pattern.png" style="width: 60px">
          <img src="pattern.png" style="width: 10px">
          <img src="pattern.png" style="width: 100px"
        ></strong><img src="pattern.png" style="width: 290px"
        ><!-- Last image will be on its own line. -->''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line_1, line_2 = paragraph.children
    image_1, space_1, strong = line_1.children
    image_2, space_2, image_3, space_3, image_4 = strong.children
    image_5, = line_2.children
    assert space_1.text == ' '
    assert space_2.text == ' '
    assert space_3.text == ' '

    assert image_1.position_x == 0
    assert space_1.position_x == 40
    assert strong.position_x == 70
    assert image_2.position_x == 70
    assert space_2.position_x == 130
    assert image_3.position_x == 160
    assert space_3.position_x == 170
    assert image_4.position_x == 200
    assert strong.width == 230

    assert image_5.position_x == 0


@assert_no_logs
def test_text_align_justify_all():
    page, = render_pages('''
      <style>
        @page { size: 300px 1000px }
        body { text-align: justify-all }
      </style>
      <p><img src="pattern.png" style="width: 40px">
        <strong>
          <img src="pattern.png" style="width: 60px">
          <img src="pattern.png" style="width: 10px">
          <img src="pattern.png" style="width: 100px"
        ></strong><img src="pattern.png" style="width: 200px">
        <img src="pattern.png" style="width: 10px">''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line_1, line_2 = paragraph.children
    image_1, space_1, strong = line_1.children
    image_2, space_2, image_3, space_3, image_4 = strong.children
    image_5, space_4, image_6 = line_2.children
    assert space_1.text == ' '
    assert space_2.text == ' '
    assert space_3.text == ' '
    assert space_4.text == ' '

    assert image_1.position_x == 0
    assert space_1.position_x == 40
    assert strong.position_x == 70
    assert image_2.position_x == 70
    assert space_2.position_x == 130
    assert image_3.position_x == 160
    assert space_3.position_x == 170
    assert image_4.position_x == 200
    assert strong.width == 230

    assert image_5.position_x == 0
    assert space_4.position_x == 200
    assert image_6.position_x == 290


@assert_no_logs
def test_text_align_all_last():
    page, = render_pages('''
      <style>
        @page { size: 300px 1000px }
        body { text-align-all: justify; text-align-last: right }
      </style>
      <p><img src="pattern.png" style="width: 40px">
        <strong>
          <img src="pattern.png" style="width: 60px">
          <img src="pattern.png" style="width: 10px">
          <img src="pattern.png" style="width: 100px"
        ></strong><img src="pattern.png" style="width: 200px"
        ><img src="pattern.png" style="width: 10px">''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line_1, line_2 = paragraph.children
    image_1, space_1, strong = line_1.children
    image_2, space_2, image_3, space_3, image_4 = strong.children
    image_5, image_6 = line_2.children
    assert space_1.text == ' '
    assert space_2.text == ' '
    assert space_3.text == ' '

    assert image_1.position_x == 0
    assert space_1.position_x == 40
    assert strong.position_x == 70
    assert image_2.position_x == 70
    assert space_2.position_x == 130
    assert image_3.position_x == 160
    assert space_3.position_x == 170
    assert image_4.position_x == 200
    assert strong.width == 230

    assert image_5.position_x == 90
    assert image_6.position_x == 290


@assert_no_logs
def test_text_align_not_enough_space():
    page, = render_pages('''
      <style>
        p { text-align: center; width: 0 }
        span { display: inline-block }
      </style>
      <p><span>aaaaaaaaaaaaaaaaaaaaaaaaaa</span></p>''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    span, = paragraph.children
    assert span.position_x == 0


@assert_no_logs
def test_text_align_justify_no_space():
    # single-word line (zero spaces)
    page, = render_pages('''
      <style>
        body { text-align: justify; width: 50px }
      </style>
      <p>Supercalifragilisticexpialidocious bar</p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line_1, line_2 = paragraph.children
    text, = line_1.children
    assert text.position_x == 0


@assert_no_logs
def test_text_align_justify_text_indent():
    # text-indent
    page, = render_pages('''
      <style>
        @page { size: 300px 1000px }
        body { text-align: justify }
        p { text-indent: 3px }
      </style>
      <p><img src="pattern.png" style="width: 40px">
        <strong>
          <img src="pattern.png" style="width: 60px">
          <img src="pattern.png" style="width: 10px">
          <img src="pattern.png" style="width: 100px"
        ></strong><img src="pattern.png" style="width: 290px"
        ><!-- Last image will be on its own line. -->''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line_1, line_2 = paragraph.children
    image_1, space_1, strong = line_1.children
    image_2, space_2, image_3, space_3, image_4 = strong.children
    image_5, = line_2.children
    assert space_1.text == ' '
    assert space_2.text == ' '
    assert space_3.text == ' '

    assert image_1.position_x == 3
    assert space_1.position_x == 43
    assert strong.position_x == 72
    assert image_2.position_x == 72
    assert space_2.position_x == 132
    assert image_3.position_x == 161
    assert space_3.position_x == 171
    assert image_4.position_x == 200
    assert strong.width == 228

    assert image_5.position_x == 0


@assert_no_logs
def test_text_align_justify_no_break_between_children():
    # Test justification when line break happens between two inline children
    # that must stay together.
    # Regression test for #637.
    page, = render_pages('''
      <style>
        p { text-align: justify; font-family: weasyprint; width: 7em }
      </style>
      <p>
        <span>a</span>
        <span>b</span>
        <span>bla</span><span>,</span>
        <span>b</span>
      </p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line_1, line_2 = paragraph.children

    span_1, space_1, span_2, space_2 = line_1.children
    assert span_1.position_x == 0
    assert span_2.position_x == 6 * 16  # 1 character + 5 spaces
    assert line_1.width == 7 * 16  # 7em

    span_1, span_2, space_1, span_3, space_2 = line_2.children
    assert span_1.position_x == 0
    assert span_2.position_x == 3 * 16  # 3 characters
    assert span_3.position_x == 5 * 16  # (3 + 1) characters + 1 space


@pytest.mark.parametrize('text', [
    'Lorem ipsum dolor<em>sit amet</em>',
    'Lorem ipsum <em>dolorsit</em> amet',
    'Lorem ipsum <em></em>dolorsit amet',
    'Lorem ipsum<em> </em>dolorsit amet',
    'Lorem ipsum<em> dolorsit</em> amet',
    'Lorem ipsum <em>dolorsit </em>amet',
])
@assert_no_logs
def test_word_spacing(text):
    # Regression test.
    page, = render_pages('''
      <style></style> <!-- element.text is None -->
      <body><strong>Lorem ipsum dolor<em>sit amet</em></strong>''')
    html, = page.children
    body, = html.children
    line, = body.children
    strong_1, = line.children

    page, = render_pages('''
      <style>strong { word-spacing: 11px }</style>
      <body><strong>%s</strong>''' % text)
    html, = page.children
    body, = html.children
    line, = body.children
    strong_2, = line.children

    assert strong_2.width - strong_1.width == 33


@assert_no_logs
def test_letter_spacing_1():
    page, = render_pages('''
        <body><strong>Supercalifragilisticexpialidocious</strong>''')
    html, = page.children
    body, = html.children
    line, = body.children
    strong_1, = line.children

    page, = render_pages('''
        <style>strong { letter-spacing: 11px }</style>
        <body><strong>Supercalifragilisticexpialidocious</strong>''')
    html, = page.children
    body, = html.children
    line, = body.children
    strong_2, = line.children
    assert strong_2.width - strong_1.width == 34 * 11

    # an embedded tag should not affect the single-line letter spacing
    page, = render_pages(
        '<style>strong { letter-spacing: 11px }</style>'
        '<body><strong>Supercali<span>fragilistic</span>expialidocious'
        '</strong>')
    html, = page.children
    body, = html.children
    line, = body.children
    strong_3, = line.children
    assert strong_3.width == strong_2.width

    # duplicate wrapped lines should also have same overall width
    # Note work-around for word-wrap bug (issue #163) by marking word
    # as an inline-block
    page, = render_pages(
        '<style>'
        '  strong {'
        '    letter-spacing: 11px;'
        f'    max-width: {strong_3.width * 1.5}px'
        '}'
        '  span { display: inline-block }'
        '</style>'
        '<body><strong>'
        '  <span>Supercali<i>fragilistic</i>expialidocious</span> '
        '  <span>Supercali<i>fragilistic</i>expialidocious</span>'
        '</strong>')
    html, = page.children
    body, = html.children
    line1, line2 = body.children
    assert line1.children[0].width == line2.children[0].width
    assert line1.children[0].width == strong_2.width


@pytest.mark.parametrize('spacing', ['word-spacing', 'letter-spacing'])
@assert_no_logs
def test_spacing_ex(spacing):
    # Regression test.
    render_pages(f'<div style="{spacing}: 2ex">abc def')


@pytest.mark.parametrize('indent', ['12px', '6%'])
@assert_no_logs
def test_text_indent(indent):
    page, = render_pages('''
        <style>
            @page { size: 220px }
            body { margin: 10px; text-indent: %(indent)s }
        </style>
        <p>Some text that is long enough that it take at least three line,
           but maybe more.
    ''' % {'indent': indent})
    html, = page.children
    body, = html.children
    paragraph, = body.children
    lines = paragraph.children
    text_1, = lines[0].children
    text_2, = lines[1].children
    text_3, = lines[2].children
    assert text_1.position_x == 22  # 10px margin-left + 12px indent
    assert text_2.position_x == 10  # No indent
    assert text_3.position_x == 10  # No indent


@assert_no_logs
def test_text_indent_inline():
    # Regression test for #1000.
    page, = render_pages('''
        <style>
            p { display: inline-block; text-indent: 1em; font-family: weasyprint }
        </style>
        <p><span>text
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line, = paragraph.children
    assert line.width == (4 + 1) * 16


@pytest.mark.parametrize('indent', ['12px', '6%'])
@assert_no_logs
def test_text_indent_multipage(indent):
    # Regression test for #706.
    pages = render_pages('''
        <style>
            @page { size: 220px 1.5em; margin: 0 }
            body { margin: 10px; text-indent: %(indent)s }
        </style>
        <p>Some text that is long enough that it take at least three line,
           but maybe more.
    ''' % {'indent': indent})
    page = pages.pop(0)
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line, = paragraph.children
    text, = line.children
    assert text.position_x == 22  # 10px margin-left + 12px indent

    page = pages.pop(0)
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line, = paragraph.children
    text, = line.children
    assert text.position_x == 10  # No indent


@assert_no_logs
def test_hyphenate_character_1():
    page, = render_pages(
        '<html style="width: 5em; font-family: weasyprint">'
        '<body style="hyphens: auto;'
        'hyphenate-character: \'!\'" lang=fr>'
        'hyphénation')
    html, = page.children
    body, = html.children
    lines = body.children
    assert len(lines) > 1
    assert lines[0].children[0].text.endswith('!')
    full_text = ''.join(line.children[0].text for line in lines)
    assert full_text.replace('!', '') == 'hyphénation'


@assert_no_logs
def test_hyphenate_character_2():
    page, = render_pages(
        '<html style="width: 5em; font-family: weasyprint">'
        '<body style="hyphens: auto;'
        'hyphenate-character: \'à\'" lang=fr>'
        'hyphénation')
    html, = page.children
    body, = html.children
    lines = body.children
    assert len(lines) > 1
    assert lines[0].children[0].text.endswith('à')
    full_text = ''.join(line.children[0].text for line in lines)
    assert full_text.replace('à', '') == 'hyphénation'


@assert_no_logs
def test_hyphenate_character_3():
    page, = render_pages(
        '<html style="width: 5em; font-family: weasyprint">'
        '<body style="hyphens: auto;'
        'hyphenate-character: \'ù ù\'" lang=fr>'
        'hyphénation')
    html, = page.children
    body, = html.children
    lines = body.children
    assert len(lines) > 1
    assert lines[0].children[0].text.endswith('ù ù')
    full_text = ''.join(line.children[0].text for line in lines)
    assert full_text.replace(' ', '').replace('ù', '') == 'hyphénation'


@assert_no_logs
def test_hyphenate_character_4():
    page, = render_pages(
        '<html style="width: 5em; font-family: weasyprint">'
        '<body style="hyphens: auto;'
        'hyphenate-character: \'\'" lang=fr>'
        'hyphénation')
    html, = page.children
    body, = html.children
    lines = body.children
    assert len(lines) > 1
    full_text = ''.join(line.children[0].text for line in lines)
    assert full_text == 'hyphénation'


@assert_no_logs
def test_hyphenate_character_5():
    page, = render_pages(
        '<html style="width: 5em; font-family: weasyprint">'
        '<body style="hyphens: auto;'
        'hyphenate-character: \'———\'" lang=fr>'
        'hyphénation')
    html, = page.children
    body, = html.children
    lines = body.children
    assert len(lines) > 1
    assert lines[0].children[0].text.endswith('———')
    full_text = ''.join(line.children[0].text for line in lines)
    assert full_text.replace('—', '') == 'hyphénation'


@assert_no_logs
@pytest.mark.parametrize('i', (range(1, len('hyphénation'))))
def test_hyphenate_manual_1(i):
    for hyphenate_character in ('!', 'ù ù'):
        word = f'{"hyphénation"[:i]}\xad{"hyphénation"[i:]}'
        page, = render_pages(
            '<html style="width: 5em; font-family: weasyprint">'
            '<body style="hyphens: manual;'
            f'  hyphenate-character: \'{hyphenate_character}\'"'
            f'  lang=fr>{word}')
        html, = page.children
        body, = html.children
        lines = body.children
        assert len(lines) == 2
        assert lines[0].children[0].text.endswith(hyphenate_character)
        full_text = ''.join(
            child.text for line in lines for child in line.children)
        assert full_text.replace(hyphenate_character, '') == word


@assert_no_logs
@pytest.mark.parametrize('i', (range(1, len('hy phénation'))))
def test_hyphenate_manual_2(i):
    for hyphenate_character in ('!', 'ù ù'):
        word = f'{"hy phénation"[:i]}\xad{"hy phénation"[i:]}'
        page, = render_pages(
            '<html style="width: 5em; font-family: weasyprint">'
            '<body style="hyphens: manual;'
            f'  hyphenate-character: \'{hyphenate_character}\'"'
            f'  lang=fr>{word}')
        html, = page.children
        body, = html.children
        lines = body.children
        assert len(lines) in (2, 3)
        full_text = ''.join(
            child.text for line in lines for child in line.children)
        full_text = full_text.replace(hyphenate_character, '')
        if lines[0].children[0].text.endswith(hyphenate_character):
            assert full_text == word
        else:
            assert lines[0].children[0].text.rstrip('\xad').endswith('y')
            if len(lines) == 3:
                assert lines[1].children[0].text.rstrip('\xad').endswith(
                    hyphenate_character)


@assert_no_logs
def test_hyphenate_manual_3():
    # Automatic hyphenation opportunities within a word must be ignored if the
    # word contains a conditional hyphen, in favor of the conditional
    # hyphen(s).
    page, = render_pages(
        '<html style="width: 0.1em" lang="en">'
        '<body style="hyphens: auto">in&shy;lighten&shy;lighten&shy;in')
    html, = page.children
    body, = html.children
    line_1, line_2, line_3, line_4 = body.children
    assert line_1.children[0].text == 'in\xad‐'
    assert line_2.children[0].text == 'lighten\xad‐'
    assert line_3.children[0].text == 'lighten\xad‐'
    assert line_4.children[0].text == 'in'


@assert_no_logs
def test_hyphenate_manual_4():
    # Regression test for #1878.
    page, = render_pages(
        '<html style="width: 0.1em" lang="en">'
        '<body style="hyphens: auto">test&shy;')
    html, = page.children
    body, = html.children
    line_1, = body.children
    # TODO: should not end with an hyphen
    # assert line_1.children[0].text == 'test\xad'


@assert_no_logs
def test_hyphenate_limit_zone_1():
    page, = render_pages(
        '<html style="width: 12em; font-family: weasyprint">'
        '<body style="hyphens: auto;'
        'hyphenate-limit-zone: 0" lang=fr>'
        'mmmmm hyphénation')
    html, = page.children
    body, = html.children
    lines = body.children
    assert len(lines) == 2
    assert lines[0].children[0].text.endswith('‐')
    full_text = ''.join(line.children[0].text for line in lines)
    assert full_text.replace('‐', '') == 'mmmmm hyphénation'


@assert_no_logs
def test_hyphenate_limit_zone_2():
    page, = render_pages(
        '<html style="width: 12em; font-family: weasyprint">'
        '<body style="hyphens: auto;'
        'hyphenate-limit-zone: 9em" lang=fr>'
        'mmmmm hyphénation')
    html, = page.children
    body, = html.children
    lines = body.children
    assert len(lines) > 1
    assert lines[0].children[0].text.endswith('mm')
    full_text = ''.join(line.children[0].text for line in lines)
    assert full_text == 'mmmmmhyphénation'


@assert_no_logs
def test_hyphenate_limit_zone_3():
    page, = render_pages(
        '<html style="width: 12em; font-family: weasyprint">'
        '<body style="hyphens: auto;'
        'hyphenate-limit-zone: 5%" lang=fr>'
        'mmmmm hyphénation')
    html, = page.children
    body, = html.children
    lines = body.children
    assert len(lines) == 2
    assert lines[0].children[0].text.endswith('‐')
    full_text = ''.join(line.children[0].text for line in lines)
    assert full_text.replace('‐', '') == 'mmmmm hyphénation'


@assert_no_logs
def test_hyphenate_limit_zone_4():
    page, = render_pages(
        '<html style="width: 12em; font-family: weasyprint">'
        '<body style="hyphens: auto;'
        'hyphenate-limit-zone: 95%" lang=fr>'
        'mmmmm hyphénation')
    html, = page.children
    body, = html.children
    lines = body.children
    assert len(lines) > 1
    assert lines[0].children[0].text.endswith('mm')
    full_text = ''.join(line.children[0].text for line in lines)
    assert full_text == 'mmmmmhyphénation'


def test_hyphen_nbsp():
    # Regression test for #1817.
    page, = render_pages('''
      <style>
        body {width: 20px; font: 2px weasyprint}
      </style>
      <body style="hyphens: auto;" lang="en">
        <span>this&nbsp;hyphenation
    ''')
    html, = page.children
    body, = html.children
    line1, line2 = body.children
    assert line1.children[0].children[0].text == 'this hy‐'
    assert line2.children[0].children[0].text == 'phenation'


@assert_no_logs
@pytest.mark.parametrize(('css', 'result'), [
    ('auto', 2),
    ('auto auto 0', 2),
    ('0 0 0', 2),
    ('4 4 auto', 1),
    ('6 2 4', 2),
    ('auto 1 auto', 2),
    ('7 auto auto', 1),
    ('6 auto auto', 2),
    ('5 2', 2),
    ('3', 2),
    ('2 4 6', 1),
    ('auto 4', 1),
    ('auto 2', 2),
])
def test_hyphenate_limit_chars(css, result):
    page, = render_pages(
        '<html style="width: 1em; font-family: weasyprint">'
        '<body style="hyphens: auto;'
        f'hyphenate-limit-chars: {css}" lang=en>'
        'hyphen')
    html, = page.children
    body, = html.children
    lines = body.children
    assert len(lines) == result


@assert_no_logs
@pytest.mark.parametrize('css', [
    # light·en
    '3 3 3',  # 'en' is shorter than 3
    '3 6 2',  # 'light' is shorter than 6
    '8',  # 'lighten' is shorter than 8
])
def test_hyphenate_limit_chars_punctuation(css):
    # Regression test for #109.
    page, = render_pages(
        '<html style="width: 1em; font-family: weasyprint">'
        '<body style="hyphens: auto;'
        f'hyphenate-limit-chars: {css}" lang=en>'
        '..lighten..')
    html, = page.children
    body, = html.children
    lines = body.children
    assert len(lines) == 1


@assert_no_logs
@pytest.mark.parametrize(('wrap', 'text', 'test', 'full_text'), [
    ('anywhere', 'aaaaaaaa', lambda a: a > 1, 'aaaaaaaa'),
    ('break-word', 'aaaaaaaa', lambda a: a > 1, 'aaaaaaaa'),
    ('normal', 'aaaaaaaa', lambda a: a == 1, 'aaaaaaaa'),
    ('break-word', 'hyphenations', lambda a: a > 3,
     'hy\u2010phen\u2010ations'),
    ('break-word', 'A splitted word.  An hyphenated word.',
     lambda a: a > 8, 'Asplittedword.Anhy\u2010phen\u2010atedword.'),
])
def test_overflow_wrap(wrap, text, test, full_text):
    page, = render_pages('''
      <style>
        body {width: 80px; overflow: hidden; font-family: weasyprint}
        span {overflow-wrap: %s}
      </style>
      <body style="hyphens: auto;" lang="en">
        <span>%s
    ''' % (wrap, text))
    html, = page.children
    body, = html.children
    lines = []
    for line in body.children:
        box, = line.children
        text_box, = box.children
        lines.append(text_box.text)
    lines_full_text = ''.join(line for line in lines)
    assert test(len(lines))
    assert full_text == lines_full_text


@assert_no_logs
@pytest.mark.parametrize(('span_css', 'expected_lines'), [
    # overflow-wrap: anywhere and break-word are only allowed to break a word
    # "if there are no otherwise-acceptable break points in the line", which
    # means they should not split a word if it fits cleanly into the next line.
    # This can be done accidentally if it is in its own inline element.
    ('overflow-wrap: anywhere', ['aaa', 'bbb']),
    ('overflow-wrap: break-word', ['aaa', 'bbb']),

    # On the other hand, word-break: break-all mandates a break anywhere at the
    # end of a line, even if the word could fit cleanly onto the next line.
    ('word-break: break-all', ['aaa b', 'bb']),
])
def test_wrap_overflow_word_break(span_css, expected_lines):
    page, = render_pages('''
      <style>
        body {width: 80px; overflow: hidden; font-family: weasyprint}
        span {%s}
      </style>
      <body>
        <span>aaa </span><span>bbb
    ''' % span_css)
    html, = page.children
    body, = html.children
    lines = body.children
    lines = []
    for line in body.children:
        line_text = ''
        for span_box in line.children:
            line_text += span_box.children[0].text
        lines.append(line_text)
    assert lines == expected_lines


@assert_no_logs
@pytest.mark.parametrize(('wrap', 'text', 'body_width', 'expected_width'), [
    ('anywhere', 'aaaaaa', 10, 20),
    ('anywhere', 'aaaaaa', 40, 40),
    ('break-word', 'aaaaaa', 40, 120),
    ('normal', 'aaaaaa', 40, 120),
])
def test_overflow_wrap_2(wrap, text, body_width, expected_width):
    page, = render_pages('''
      <style>
        body {width: %dpx; font-family: weasyprint; font-size: 20px}
        table {overflow-wrap: %s}
      </style>
      <table><tr><td>%s''' % (body_width, wrap, text))
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    tr, = row_group.children
    td, = tr.children
    assert td.width == expected_width


@assert_no_logs
@pytest.mark.parametrize(('wrap', 'text', 'body_width', 'expected_width'), [
    ('anywhere', 'aaaaaa', 10, 20),
    ('anywhere', 'aaaaaa', 40, 40),
    ('break-word', 'aaaaaa', 40, 120),
    ('normal', 'abcdef', 40, 120),
])
def test_overflow_wrap_trailing_space(wrap, text, body_width, expected_width):
    page, = render_pages('''
      <style>
        body {width: %dpx; font-family: weasyprint; font-size: 20px}
        table {overflow-wrap: %s}
      </style>
      <table><tr><td>%s ''' % (body_width, wrap, text))
    html, = page.children
    body, = html.children
    table_wrapper, = body.children
    table, = table_wrapper.children
    row_group, = table.children
    tr, = row_group.children
    td, = tr.children
    assert td.width == expected_width


def test_overflow_wrap_no_break_on_space():
    # Regression test for #1817.
    page, = render_pages('''
      <style>
        body {width: 11px; font-family: weasyprint; font-size: 2px;
              overflow-wrap: anywhere}
      </style>.jpg, .png''')
    html, = page.children
    body, = html.children
    line1, line2 = body.children
    text1, = line1.children
    assert text1.text == '.jpg,'
    text2, = line2.children
    assert text2.text == '.png'


def test_line_break_before_trailing_space():
    # Regression test for #1852.
    page, = render_pages('''
        <p style="display: inline-block">test\u2028 </p>a
        <p style="display: inline-block">test\u2028</p>a
    ''')
    html, = page.children
    body, = html.children
    line, = body.children
    p1, space1, p2, space2 = line.children
    assert p1.width == p2.width


def test_line_break_before_nested_trailing_space():
    # Regression test for #2448.
    page, = render_pages('''
    <div style="font: 2px weasyprint; width: 6px">
      AA <span><b><i>BBB</i></b> </span></div>
    ''')
    html, = page.children
    body, = html.children
    div, = body.children
    assert len(div.children) == 2


def white_space_lines(width, space):
    page, = render_pages('''
      <style>
        body { font-size: 100px; width: %dpx }
        span { white-space: %s }
      </style>
      <body><span>This +    \n    is text''' % (width, space))
    html, = page.children
    body, = html.children
    return body.children


@assert_no_logs
def test_white_space_1():
    line1, line2, line3, line4 = white_space_lines(1, 'normal')
    box1, = line1.children
    text1, = box1.children
    assert text1.text == 'This'
    box2, = line2.children
    text2, = box2.children
    assert text2.text == '+'
    box3, = line3.children
    text3, = box3.children
    assert text3.text == 'is'
    box4, = line4.children
    text4, = box4.children
    assert text4.text == 'text'


@assert_no_logs
def test_white_space_2():
    line1, line2 = white_space_lines(1, 'pre')
    box1, = line1.children
    text1, = box1.children
    assert text1.text == 'This +    '
    box2, = line2.children
    text2, = box2.children
    assert text2.text == '    is text'


@assert_no_logs
def test_white_space_3():
    line1, = white_space_lines(1, 'nowrap')
    box1, = line1.children
    text1, = box1.children
    assert text1.text == 'This + is text'


@assert_no_logs
def test_white_space_4():
    line1, line2, line3, line4, line5 = white_space_lines(1, 'pre-wrap')
    box1, = line1.children
    text1, = box1.children
    assert text1.text == 'This '
    box2, = line2.children
    text2, = box2.children
    assert text2.text == '+    '
    box3, = line3.children
    text3, = box3.children
    assert text3.text == '    '
    box4, = line4.children
    text4, = box4.children
    assert text4.text == 'is '
    box5, = line5.children
    text5, = box5.children
    assert text5.text == 'text'


@assert_no_logs
def test_white_space_5():
    line1, line2, line3, line4 = white_space_lines(1, 'pre-line')
    box1, = line1.children
    text1, = box1.children
    assert text1.text == 'This'
    box2, = line2.children
    text2, = box2.children
    assert text2.text == '+'
    box3, = line3.children
    text3, = box3.children
    assert text3.text == 'is'
    box4, = line4.children
    text4, = box4.children
    assert text4.text == 'text'


@assert_no_logs
def test_white_space_6():
    line1, = white_space_lines(1000000, 'normal')
    box1, = line1.children
    text1, = box1.children
    assert text1.text == 'This + is text'


@assert_no_logs
def test_white_space_7():
    line1, line2 = white_space_lines(1000000, 'pre')
    box1, = line1.children
    text1, = box1.children
    assert text1.text == 'This +    '
    box2, = line2.children
    text2, = box2.children
    assert text2.text == '    is text'


@assert_no_logs
def test_white_space_8():
    line1, = white_space_lines(1000000, 'nowrap')
    box1, = line1.children
    text1, = box1.children
    assert text1.text == 'This + is text'


@assert_no_logs
def test_white_space_9():
    line1, line2 = white_space_lines(1000000, 'pre-wrap')
    box1, = line1.children
    text1, = box1.children
    assert text1.text == 'This +    '
    box2, = line2.children
    text2, = box2.children
    assert text2.text == '    is text'


@assert_no_logs
def test_white_space_10():
    line1, line2 = white_space_lines(1000000, 'pre-line')
    box1, = line1.children
    text1, = box1.children
    assert text1.text == 'This +'
    box2, = line2.children
    text2, = box2.children
    assert text2.text == 'is text'


@assert_no_logs
def test_white_space_11():
    # Regression test for #813.
    page, = render_pages('''
      <style>
        pre { width: 0 }
      </style>
      <body><pre>This<br/>is text''')
    html, = page.children
    body, = html.children
    pre, = body.children
    line1, line2 = pre.children
    text1, box = line1.children
    assert text1.text == 'This'
    assert box.element_tag == 'br'
    text2, = line2.children
    assert text2.text == 'is text'


@assert_no_logs
def test_white_space_12():
    # Regression test for #813.
    page, = render_pages('''
      <style>
        pre { width: 0 }
      </style>
      <body><pre>This is <span>lol</span> text''')
    html, = page.children
    body, = html.children
    pre, = body.children
    line1, = pre.children
    text1, span, text2 = line1.children
    assert text1.text == 'This is '
    assert span.element_tag == 'span'
    assert text2.text == ' text'


@assert_no_logs
@pytest.mark.parametrize(('value', 'width'), [
    (8, 144),  # (2 + (8 - 1)) * 16
    (4, 80),  # (2 + (4 - 1)) * 16
    ('3em', 64),  # (2 + (3 - 1)) * 16
    ('25px', 41),  # 2 * 16 + 25 - 1 * 16
    # (0, 32),  # See Layout.set_tabs
])
def test_tab_size(value, width):
    page, = render_pages('''
      <style>
        pre { tab-size: %s; font-family: weasyprint }
      </style>
      <pre>a&#9;a</pre>
    ''' % value)
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line, = paragraph.children
    assert line.width == width


@assert_no_logs
def test_text_transform():
    page, = render_pages('''
      <style>
        p { text-transform: capitalize }
        p+p { text-transform: uppercase }
        p+p+p { text-transform: lowercase }
        p+p+p+p { text-transform: full-width }
        p+p+p+p+p { text-transform: none }
      </style>
<p>hé lO1</p><p>hé lO1</p><p>hé lO1</p><p>hé lO1</p><p>hé lO1</p>
    ''')
    html, = page.children
    body, = html.children
    p1, p2, p3, p4, p5 = body.children
    line1, = p1.children
    text1, = line1.children
    assert text1.text == 'Hé LO1'
    line2, = p2.children
    text2, = line2.children
    assert text2.text == 'HÉ LO1'
    line3, = p3.children
    text3, = line3.children
    assert text3.text == 'hé lo1'
    line4, = p4.children
    text4, = line4.children
    assert text4.text == '\uff48é\u3000\uff4c\uff2f\uff11'
    line5, = p5.children
    text5, = line5.children
    assert text5.text == 'hé lO1'


@assert_no_logs
@pytest.mark.parametrize(
    ('lang', 'lowercase', 'uppercase'), [
        ('az', 'ı i', 'I İ'),
        ('tr', 'ı i', 'I İ'),
        ('el', 'καλημέρα αύριο θεϊκό ευφυΐα Νεράιδα',
         'ΚΑΛΗΜΕΡΑ ΑΥΡΙΟ ΘΕΪΚΟ ΕΥΦΥΪΑ ΝΕΡΑΪΔΑ'),
])
def test_text_transform_lang_uppercase(lang, lowercase, uppercase):
    page, = render_pages(f'''
      <html lang="{lang}">
        <p style="text-transform: uppercase">{lowercase}
    ''')
    html, = page.children
    body, = html.children
    p, = body.children
    line, = p.children
    text, = line.children
    assert text.text == uppercase


@assert_no_logs
@pytest.mark.parametrize(
    ('lang', 'uppercase', 'lowercase'), [
        ('az', 'İ I', 'i ı'),
        ('tr', 'İ I', 'i ı'),
        ('lt', 'Ì Í Ĩ', 'i̇̀ i̇́ i̇̃'),
])
def test_text_transform_lang_lowercase(lang, uppercase, lowercase):
    page, = render_pages(f'''
      <html lang="{lang}">
        <p style="text-transform: lowercase">{uppercase}
    ''')
    html, = page.children
    body, = html.children
    p, = body.children
    line, = p.children
    text, = line.children
    assert text.text == lowercase


@assert_no_logs
@pytest.mark.parametrize(
    ('original', 'transformed', 'lang_code'), [
        ('abc def ghi', 'Abc Def Ghi', None),
        ('AbC def ghi', 'AbC Def Ghi', None),
        ('I’m SO cool', 'I’m SO Cool', None),
        ('Wow.wow!wow', 'Wow.wow!wow', None),
        ('!now not tomorrow', '!Now Not Tomorrow', None),
        ('SUPER cool', 'SUPER Cool', None),
        ('i 😻 non‑breaking characters', 'I 😻 Non‑breaking Characters', None),
        ('3lite 3lite', '3lite 3lite', None),
        ('one/two/three', 'One/two/three', None),
        ('supernatural,super', 'Supernatural,super', None),
        ('éternel αιώνια', 'Éternel Αιώνια', None),
        ('great ijland', 'Great Ijland', 'fr'),
        ('great ijland', 'Great IJland', 'nl'),
        ('great ijland', 'Great İjland', 'az'),
    ]
)
def test_text_transform_capitalize(original, transformed, lang_code):
    # Results are different for different browsers, we almost get the same
    # results as Firefox, that’s good enough!
    assert capitalize(original, lang_code) == transformed


@assert_no_logs
def test_text_floating_pre_line():
    # Regression test for #610.
    page, = render_pages('''
      <div style="float: left; white-space: pre-line">This is
      oh this end </div>
    ''')


@assert_no_logs
@pytest.mark.parametrize(
    ('leader', 'content'), [
        ('dotted', '.'),
        ('solid', '_'),
        ('space', ' '),
        ('" .-"', ' .-'),
    ]
)
def test_leader_content(leader, content):
    page, = render_pages('''
      <style>div::after { content: leader(%s) }</style>
      <div></div>
    ''' % leader)
    html, = page.children
    body, = html.children
    div, = body.children
    line, = div.children
    after, = line.children
    inline, = after.children
    assert inline.children[0].text == content


@pytest.mark.xfail
@assert_no_logs
def test_max_lines():
    page, = render_pages('''
      <style>
        @page {size: 10px 10px;}
        p {
          font-family: weasyprint;
          font-size: 2px;
          max-lines: 2;
        }
      </style>
      <p>
        abcd efgh ijkl
      </p>
    ''')
    html, = page.children
    body, = html.children
    p1, p2 = body.children
    line1, line2 = p1.children
    line3, = p2.children
    text1, = line1.children
    text2, = line2.children
    text3, = line3.children
    assert text1.text == 'abcd'
    assert text2.text == 'efgh'
    assert text3.text == 'ijkl'


@assert_no_logs
def test_continue():
    page, = render_pages('''
      <style>
        @page {size: 10px 4px;}
        div {
          continue: discard;
          font-family: weasyprint;
          font-size: 2px;
        }
      </style>
      <div>
        abcd efgh ijkl
      </div>
    ''')
    html, = page.children
    body, = html.children
    p, = body.children
    line1, line2 = p.children
    text1, = line1.children
    text2, = line2.children
    assert text1.text == 'abcd'
    assert text2.text == 'efgh'


@assert_no_logs
def test_first_letter_line_height():
    page, = render_pages('''
      <style>
        p { font-family: weasyprint }
        p:first-letter { line-height: 1; font-size: 20px }
      </style>
      <p>abc
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line, = paragraph.children
    first_letter, _ = line.children
    first_letter_text, = first_letter.children
    assert first_letter_text.text == 'a'
    assert first_letter_text.height == 20


@assert_no_logs
def test_first_letter_text_transform():
    # Regression test for #1906.
    page, = render_pages('''
      <style>
        p::first-letter { text-transform: uppercase }
      </style>
      <p>abc
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line, = paragraph.children
    first_letter, next_text = line.children
    first_letter_text, = first_letter.children
    assert first_letter_text.text == 'A'
    assert next_text.text == 'bc'


@assert_no_logs
def test_first_letter_nested():
    page, = render_pages('''
      <style>
        body::first-letter { font-style: italic }
        p::first-letter { font-weight: 700 }
      </style>
      <p>abc</p>
      <p>abc</p>
    ''')
    html, = page.children
    body, = html.children
    p1, p2 = body.children
    line, = p1.children
    first_letter, next_text = line.children
    first_letter_text, = first_letter.children
    assert first_letter_text.style['font_style'] == 'italic'
    assert first_letter_text.style['font_weight'] == 700
    assert next_text.style['font_style'] == 'normal'
    assert next_text.style['font_weight'] == 400
    line, = p2.children
    first_letter, next_text = line.children
    first_letter_text, = first_letter.children
    assert first_letter_text.style['font_style'] == 'normal'
    assert first_letter_text.style['font_weight'] == 700
    assert next_text.style['font_style'] == 'normal'
    assert next_text.style['font_weight'] == 400


@assert_no_logs
def test_first_line_line_height():
    page, = render_pages('''
      <style>
        p { font-family: weasyprint }
        p:first-line { line-height: 1; font-size: 20px }
      </style>
      <p>abc<br>def
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line1, line2 = paragraph.children
    first_line_box, = line1.children
    first_line_text, br = first_line_box.children
    assert first_line_text.text == 'abc'
    assert first_line_text.height == 20


@assert_no_logs
def test_first_line_text_transform():
    page, = render_pages('''
      <style>
        p::first-line { text-transform: uppercase }
      </style>
      <p>abc<br>def
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line1, line2 = paragraph.children
    first_line_box, = line1.children
    first_line_text, br = first_line_box.children
    assert first_line_text.text == 'ABC'
    next_line_text, = line2.children
    assert next_line_text.text == 'def'


@assert_no_logs
def test_first_line_nested():
    page, = render_pages('''
      <style>
        body::first-line { font-style: italic }
        p::first-line { font-weight: 700 }
      </style>
      <p>abc<br>def</p>
      <p>abc<br>def</p>
    ''')
    html, = page.children
    body, = html.children
    p1, p2 = body.children
    line1, line2 = p1.children
    first_line_box, = line1.children
    first_line_text, br = first_line_box.children
    assert first_line_text.style['font_style'] == 'italic'
    assert first_line_text.style['font_weight'] == 700
    next_line_text, = line2.children
    assert next_line_text.style['font_style'] == 'normal'
    assert next_line_text.style['font_weight'] == 400
    line1, line2 = p2.children
    first_line_box, = line1.children
    first_line_text, br = first_line_box.children
    assert first_line_text.style['font_style'] == 'normal'
    assert first_line_text.style['font_weight'] == 700
    next_line_text, = line2.children
    assert next_line_text.style['font_style'] == 'normal'
    assert next_line_text.style['font_weight'] == 400


@assert_no_logs
def test_first_line_first_letter():
    page, = render_pages('''
      <style>
        p::first-letter { font-style: italic }
        p::first-line { font-weight: 700 }
      </style>
      <p>abc<br>def</p>
    ''')
    html, = page.children
    body, = html.children
    paragraph, = body.children
    line1, line2 = paragraph.children
    first_line_box, = line1.children
    first_letter_box, first_line_text, br = first_line_box.children
    first_letter_text, = first_letter_box.children
    assert first_letter_text.style['font_style'] == 'italic'
    assert first_letter_text.style['font_weight'] == 700
    assert first_line_text.style['font_style'] == 'normal'
    assert first_line_text.style['font_weight'] == 700
    next_line_text, = line2.children
    assert next_line_text.style['font_style'] == 'normal'
    assert next_line_text.style['font_weight'] == 400


================================================
FILE: tests/test_unicode.py
================================================
"""Test various unicode texts and filenames."""

from weasyprint.urls import ensure_url

from .draw import document_to_pixels, html_to_pixels
from .testing_utils import FakeHTML, assert_no_logs, resource_path


@assert_no_logs
def test_unicode(assert_pixels_equal, tmp_path):
    text = 'I løvë Unicode'
    style = '''
      @page { size: 200px 50px }
      p { color: blue }
    '''
    expected_width, expected_height, expected_lines = html_to_pixels(f'''
      <style>{style}</style>
      <p><img src="pattern.png"> {text}</p>
    ''')

    stylesheet = tmp_path / 'style.css'
    image = tmp_path / 'pattern.png'
    html = tmp_path / 'doc.html'
    stylesheet.write_text(style, 'utf-8')
    image.write_bytes(resource_path('pattern.png').read_bytes())
    html_content = f'''
      <link rel=stylesheet href="{ensure_url(str(stylesheet))}">
      <p><img src="{ensure_url(str(image))}"> {text}</p>
    '''
    html.write_text(html_content, 'utf-8')

    document = FakeHTML(html, encoding='utf-8')
    width, height, lines = document_to_pixels(document)
    assert (expected_width, expected_height) == (width, height)
    assert_pixels_equal(width, height, lines, expected_lines)


================================================
FILE: tests/test_url.py
================================================
"""Test URLs."""

import re

import pytest

from .testing_utils import FakeHTML, capture_logs, resource_path


@pytest.mark.parametrize(('url', 'base_url'), [
    ('https://weasyprint.org]', resource_path('<inline HTML>')),
    ('https://weasyprint.org]', 'https://weasyprint.org]'),
    ('https://weasyprint.org/', 'https://weasyprint.org]'),
])
def test_malformed_url_link(url, base_url):
    """Test malformed URLs."""
    with capture_logs() as logs:
        pdf = FakeHTML(
            string=f'<p><a href="{url}">My Link</a></p>',
            base_url=base_url).write_pdf()

    assert len(logs) == 1
    assert 'Malformed' in logs[0]
    assert ']' in logs[0]

    uris = re.findall(b'/URI \\((.*)\\)', pdf)
    types = re.findall(b'/S (/\\w*)', pdf)
    subtypes = re.findall(b'/Subtype (/\\w*)', pdf)

    assert uris.pop(0) == url.encode()
    assert subtypes.pop(0) == b'/Link'
    assert types.pop(0) == b'/URI'


================================================
FILE: tests/testing_utils.py
================================================
"""Helpers for tests."""

import functools
import sys
from pathlib import Path

from weasyprint import CSS, DEFAULT_OPTIONS, HTML, images
from weasyprint.css import get_all_computed_styles
from weasyprint.css.counters import CounterStyle
from weasyprint.css.targets import TargetCollector
from weasyprint.formatting_structure import boxes, build
from weasyprint.html import HTML5_UA_STYLESHEET
from weasyprint.logger import capture_logs
from weasyprint.text.fonts import FontConfiguration
from weasyprint.urls import path2url

# Lists of fonts with many variants (including condensed)
if sys.platform.startswith('win'):  # pragma: no cover
    SANS_FONTS = 'DejaVu Sans, Arial Nova, Arial, sans'
    MONO_FONTS = 'Courier New, Courier, monospace'
else:  # pragma: no cover
    SANS_FONTS = 'DejaVu Sans, sans'
    MONO_FONTS = 'DejaVu Sans Mono, monospace'

PROPER_CHILDREN = {
    # Children can be of *any* type in *one* of the lists.
    boxes.BlockContainerBox: ((boxes.BlockLevelBox,), (boxes.LineBox,)),
    boxes.LineBox: ((boxes.InlineLevelBox,),),
    boxes.InlineBox: ((boxes.InlineLevelBox,),),
    boxes.TableBox: ((
        boxes.TableCaptionBox, boxes.TableColumnGroupBox, boxes.TableColumnBox,
        boxes.TableRowGroupBox, boxes.TableRowBox),),
    boxes.InlineTableBox: ((
        boxes.TableCaptionBox, boxes.TableColumnGroupBox, boxes.TableColumnBox,
        boxes.TableRowGroupBox, boxes.TableRowBox),),
    boxes.TableColumnGroupBox: ((boxes.TableColumnBox,),),
    boxes.TableRowGroupBox: ((boxes.TableRowBox,),),
    boxes.TableRowBox: ((boxes.TableCellBox,),),
}


class FakeHTML(HTML):
    """Like weasyprint.HTML, but with a lighter UA stylesheet."""
    def __init__(self, *args, force_uncompressed_pdf=True, **kwargs):
        super().__init__(*args, **kwargs)
        self._force_uncompressed_pdf = force_uncompressed_pdf

    def _ua_stylesheets(self, forms=False):
        return [
            TEST_UA_STYLESHEET if stylesheet == HTML5_UA_STYLESHEET
            else stylesheet for stylesheet in super()._ua_stylesheets(forms)]

    def render(self, font_config=None, *args, **kwargs):
        return super().render(TEST_UA_FONT_CONFIG, *args, **kwargs)

    def write_pdf(self, target=None, zoom=1, finisher=None, **options):
        # Override function to force the generation of uncompressed PDFs
        if self._force_uncompressed_pdf:
            options['uncompressed_pdf'] = True
        return super().write_pdf(target, zoom, finisher, **options)


def resource_path(name):
    """Return the absolute path of the resource called ``name``."""
    return Path(__file__).parent / 'resources' / name


# Dummy filename, but in the right directory.
BASE_URL = path2url(resource_path('<test>'))
# Default stylesheet for tests.
TEST_UA_FONT_CONFIG = FontConfiguration()
TEST_UA_STYLESHEET = CSS(resource_path('tests_ua.css'), font_config=TEST_UA_FONT_CONFIG)


def assert_no_logs(function):
    """Decorator that asserts that nothing is logged in a function."""
    @functools.wraps(function)
    def wrapper(*args, **kwargs):
        with capture_logs() as logs:
            try:
                function(*args, **kwargs)
            except Exception:  # pragma: no cover
                if logs:
                    print(f'{len(logs)} errors logged:', file=sys.stderr)  # noqa: T201
                    for message in logs:
                        print(message, file=sys.stderr)  # noqa: T201
                raise
            else:
                if logs:  # pragma: no cover
                    for message in logs:
                        print(message, file=sys.stderr)  # noqa: T201
                    raise AssertionError(f'{len(logs)} errors logged')
    return wrapper


def serialize(box_list):
    """Transform a box list into a structure easier to compare for testing."""
    return [(
        box.element_tag,
        type(box).__name__[:-3],
        # All concrete boxes are either text, replaced, column or parent.
        (box.text if isinstance(box, boxes.TextBox)
            else '<replaced>' if isinstance(box, boxes.ReplacedBox)
            else serialize(
                getattr(box, 'column_groups', ()) + tuple(box.children))))
            for box in box_list]


def tree_position(box_list, matcher):
    """Return a list identifying the first matching box's tree position.

    Given a list of Boxes, this function returns a list containing the first
    (depth-first) Box that the matcher function identifies. This list can then
    be compared to another similarly-obtained list to assert that one Box is in
    the document tree before or after another.

    box_list: a list of Box objects, possibly PageBoxes
    matcher: a function that takes a Box and returns truthy when it matches

    """
    for i, box in enumerate(box_list):
        if matcher(box):
            return [i]
        elif hasattr(box, 'children'):
            position = tree_position(box.children, matcher)
            if position:
                return [i, *position]


def _parse_base(html_content, base_url=BASE_URL):
    document = FakeHTML(string=html_content, base_url=base_url)
    counter_style = CounterStyle()
    style_for = get_all_computed_styles(document, counter_style=counter_style)
    get_image_from_uri = functools.partial(
        images.get_image_from_uri, cache={}, url_fetcher=document.url_fetcher,
        options=DEFAULT_OPTIONS)
    target_collector = TargetCollector()
    footnotes = []
    return (
        document.etree_element, style_for, get_image_from_uri, base_url,
        target_collector, counter_style, footnotes)


def parse(html_content):
    """Parse some HTML, apply stylesheets and transform to boxes."""
    box, = build.element_to_box(*_parse_base(html_content))
    return box


def parse_all(html_content, base_url=BASE_URL):
    """Like parse() but also run all corrections on boxes."""
    box = build.build_formatting_structure(*_parse_base(
        html_content, base_url))
    _sanity_checks(box)
    return box


def render_pages(html_content):
    """Lay out a document and return a list of PageBox objects."""
    return [
        page._page_box for page in
        FakeHTML(string=html_content, base_url=BASE_URL).render().pages]


def assert_tree(box, expected):
    """Check the box tree equality.

    The obtained result is prettified in the message in case of failure.

    box: a Box object, starting with <html> and <body> blocks.
    expected: a list of serialized <body> children as returned by to_lists().

    """
    assert box.element_tag == 'html'
    assert isinstance(box, boxes.BlockBox)
    assert len(box.children) == 1

    box = box.children[0]
    assert isinstance(box, boxes.BlockBox)
    assert box.element_tag == 'body'

    assert serialize(box.children) == expected


def _sanity_checks(box):
    """Check that the rules regarding boxes are met.

    This is not required and only helps debugging.

    - A block container can contain either only block-level boxes or
      only line boxes;
    - Line boxes and inline boxes can only contain inline-level boxes.

    """
    if not isinstance(box, boxes.ParentBox):
        return

    acceptable_types_lists = None  # raises when iterated
    for class_ in type(box).mro():  # pragma: no cover
        if class_ in PROPER_CHILDREN:
            acceptable_types_lists = PROPER_CHILDREN[class_]
            break

    assert any(
        all(isinstance(child, acceptable_types) or
            not child.is_in_normal_flow()
            for child in box.children)
        for acceptable_types in acceptable_types_lists
    ), (box, box.children)

    for child in box.children:
        _sanity_checks(child)


================================================
FILE: weasyprint/__init__.py
================================================
"""The Awesome Document Factory.

The public API is what is accessible from this "root" packages without
importing sub-modules.

"""

from datetime import datetime
from os.path import getctime, getmtime
from pathlib import Path
from urllib.parse import urljoin

import cssselect2
import tinycss2
import tinyhtml5

VERSION = __version__ = '68.1'

#: Default values for command-line and Python API rendering options. See
#: :func:`__main__.main` to learn more about specific options for
#: command-line.
#:
#: :param list stylesheets:
#:     An optional list of user stylesheets. The list can include
#:     are :class:`CSS` objects, filenames, URLs, or file-like
#:     objects. (See :ref:`Stylesheet Origins`.)
#: :param str media_type:
#:     Media type to use for @media.
#: :param list attachments:
#:     A list of additional file attachments for the generated PDF
#:     document or :obj:`None`. The list's elements are
#:     :class:`Attachment` objects, filenames, URLs or file-like objects.
#: :param bytes pdf_identifier:
#:     A bytestring used as PDF file identifier.
#: :param str pdf_variant:
#:     A PDF variant name.
#: :param str pdf_version:
#:     A PDF version number.
#: :param bool pdf_forms:
#:     Whether PDF forms have to be included.
#: :param bool pdf_tags:
#:     Whether PDF should be tagged for accessibility.
#: :param bool uncompressed_pdf:
#:     Whether PDF content should be compressed.
#: :param bool custom_metadata:
#:     Whether custom HTML metadata should be stored in the generated PDF.
#: :param bool presentational_hints:
#:     Whether HTML presentational hints are followed.
#: :param bool srgb:
#:     Whether sRGB color profile should be included and set as default for
#:     device-dependant RGB colors.
#: :param bool optimize_images:
#:     Whether size of embedded images should be optimized, with no quality
#:     loss.
#: :param int jpeg_quality:
#:     JPEG quality between 0 (worst) to 95 (best).
#: :param int dpi:
#:     Maximum resolution of images embedded in the PDF.
#: :param bool full_fonts:
#:     Whether unmodified font files should be embedded when possible.
#: :param bool hinting:
#:     Whether hinting information should be kept in embedded fonts.
#: :type cache: :obj:`dict`, :class:`pathlib.Path` or :obj:`str`
#: :param cache:
#:     A dictionary used to cache images in memory, or a folder path where
#:     images are temporarily stored.
DEFAULT_OPTIONS = {
    'stylesheets': None,
    'attachments': None,
    'attachment_relationships': None,
    'pdf_identifier': None,
    'pdf_variant': None,
    'pdf_version': None,
    'pdf_forms': None,
    'pdf_tags': False,
    'uncompressed_pdf': False,
    'xmp_metadata': None,
    'custom_metadata': False,
    'presentational_hints': False,
    'srgb': False,
    'optimize_images': False,
    'jpeg_quality': None,
    'dpi': None,
    'full_fonts': False,
    'hinting': False,
    'cache': None,
}

__all__ = [
    'CSS', 'DEFAULT_OPTIONS', 'HTML', 'VERSION', 'Attachment', 'Document', 'Page',
    '__version__', 'default_url_fetcher']


# Import after setting the version, as the version is used in other modules
from .urls import URLFetcher, default_url_fetcher, select_source  # noqa: I001, E402
from .logger import LOGGER, PROGRESS_LOGGER  # noqa: E402
# Some imports are at the end of the file (after the CSS class)
# to work around circular imports.


def _find_base_url(html_document, fallback_base_url):
    """Return the base URL for the document.

    See https://www.w3.org/TR/html5/urls.html#document-base-url

    """
    first_base_element = next(iter(html_document.iter('base')), None)
    if first_base_element is not None:
        href = first_base_element.get('href', '').strip()
        if href:
            return urljoin(fallback_base_url, href)
    return fallback_base_url


class HTML:
    """HTML document parsed by tinyhtml5.

    You can just create an instance with a positional argument:
    ``doc = HTML(something)``
    The class will try to guess if the input is a filename, an absolute URL,
    or a :term:`file object`.

    Alternatively, use **one** named argument so that no guessing is involved:

    :type filename: str or pathlib.Path
    :param filename:
        A filename, relative to the current directory, or absolute.
    :param str url:
        An absolute, fully qualified URL.
    :type file_obj: :term:`file object`
    :param file_obj:
        Any object with a ``read`` method.
    :param str string:
        A string of HTML source.

    Specifying multiple inputs is an error:
    ``HTML(filename="foo.html", url="localhost://bar.html")``
    will raise a :obj:`TypeError`.

    You can also pass optional named arguments:

    :param str encoding:
        Force the source character encoding.
    :type base_url: str or pathlib.Path
    :param base_url:
        The base used to resolve relative URLs (e.g. in
        ``<img src="../foo.png">``). If not provided, try to use the input
        filename, URL, or ``name`` attribute of
        :term:`file objects <file object>`.
    :type url_fetcher: :term:`callable`
    :param url_fetcher:
        An instance of :class:`urls.URLFetcher`. (See :ref:`URL Fetchers`.)
    :param str media_type:
        The media type to use for ``@media``. Defaults to ``'print'``.
        **Note:** In some cases like ``HTML(string=foo)`` relative URLs will be
        invalid if ``base_url`` is not provided.

    """
    def __init__(self, guess=None, filename=None, url=None, file_obj=None,
                 string=None, encoding=None, base_url=None,
                 url_fetcher=None, media_type='print'):
        PROGRESS_LOGGER.info(
            'Step 1 - Fetching and parsing HTML - %s',
            guess or filename or url or
            getattr(file_obj, 'name', 'HTML string'))
        if isinstance(base_url, Path):
            base_url = str(base_url)
        if url_fetcher is None:
            url_fetcher = URLFetcher()
        result = select_source(
            guess, filename, url, file_obj, string, base_url, url_fetcher)
        with result as (file_obj, base_url, protocol_encoding, _):
            kwargs = {'namespace_html_elements': False}
            if protocol_encoding is not None:
                kwargs['transport_encoding'] = protocol_encoding
            if encoding is not None:
                kwargs['override_encoding'] = encoding
            result = tinyhtml5.parse(file_obj, **kwargs)
        self.base_url = _find_base_url(result, base_url)
        self.url_fetcher = url_fetcher
        self.media_type = media_type
        self.wrapper_element = cssselect2.ElementWrapper.from_html_root(
            result, content_language=None)
        self.etree_element = self.wrapper_element.etree_element

    def _ua_stylesheets(self, forms=False):
        if forms:
            return [HTML5_UA_STYLESHEET, HTML5_UA_FORM_STYLESHEET]
        return [HTML5_UA_STYLESHEET]

    def _ua_counter_style(self):
        return [HTML5_UA_COUNTER_STYLE.copy()]

    def _ph_stylesheets(self):
        return [HTML5_PH_STYLESHEET]

    def render(self, font_config=None, counter_style=None, color_profiles=None,
               **options):
        """Lay out and paginate the document, but do not (yet) export it.

        This returns a :class:`document.Document` object which provides
        access to individual pages and various meta-data.
        See :meth:`write_pdf` to get a PDF directly.

        :type font_config: :class:`text.fonts.FontConfiguration`
        :param font_config:
            A font configuration handling ``@font-face`` rules.
        :type counter_style: :class:`css.counters.CounterStyle`
        :param counter_style:
            A dictionary storing ``@counter-style`` rules.
        :param options:
            The ``options`` parameter includes by default the
            :data:`DEFAULT_OPTIONS` values.
        :returns: A :class:`document.Document` object.

        """
        for unknown in set(options) - set(DEFAULT_OPTIONS):
            LOGGER.warning('Unknown rendering option: %s.', unknown)
        new_options = DEFAULT_OPTIONS.copy()
        new_options.update(options)
        options = new_options
        return Document._render(
            self, font_config, counter_style, color_profiles, options)

    def write_pdf(self, target=None, zoom=1, finisher=None,
                  font_config=None, counter_style=None, color_profiles=None, **options):
        """Render the document to a PDF file.

        This is a shortcut for calling :meth:`render`, then
        :meth:`Document.write_pdf() <document.Document.write_pdf>`.

        :type target:
            :class:`str`, :class:`pathlib.Path` or :term:`file object`
        :param target:
            A filename where the PDF file is generated, a file object, or
            :obj:`None`.
        :param float zoom:
            The zoom factor in PDF units per CSS units.  **Warning**:
            All CSS units are affected, including physical units like
            ``cm`` and named sizes like ``A4``.  For values other than
            1, the physical CSS units will thus be "wrong".
        :type finisher: :term:`callable`
        :param finisher:
            A finisher function or callable that accepts the document and a
            :class:`pydyf.PDF` object as parameters. Can be passed to perform
            post-processing on the PDF right before the trailer is written.
        :type font_config: :class:`text.fonts.FontConfiguration`
        :param font_config:
            A font configuration handling ``@font-face`` rules.
        :type counter_style: :class:`css.counters.CounterStyle`
        :param counter_style:
            A dictionary storing ``@counter-style`` rules.
        :param options:
            The ``options`` parameter includes by default the
            :data:`DEFAULT_OPTIONS` values.
        :returns:
            The PDF as :obj:`bytes` if ``target`` is not provided or
            :obj:`None`, otherwise :obj:`None` (the PDF is written to
            ``target``).

        """
        new_options = DEFAULT_OPTIONS.copy()
        new_options.update(options)
        options = new_options
        return (
            self.render(font_config, counter_style, color_profiles, **options)
            .write_pdf(target, zoom, finisher, **options))


class CSS:
    """CSS stylesheet parsed by tinycss2.

    An instance is created in the same way as :class:`HTML`, with the same
    arguments.

    An additional argument called ``font_config`` must be provided to handle
    ``@font-face`` rules. The same ``text.fonts.FontConfiguration`` object
    must be used for different ``CSS`` objects applied to the same document.

    ``CSS`` objects have no public attributes or methods. They are only meant
    to be used in the :meth:`HTML.write_pdf` and :meth:`HTML.render` methods
    of :class:`HTML` objects.

    """
    def __init__(self, guess=None, filename=None, url=None, file_obj=None, string=None,
                 encoding=None, base_url=None, url_fetcher=None, _check_mime_type=False,
                 media_type='print', font_config=None, counter_style=None,
                 color_profiles=None, matcher=None, page_rules=None, layers=None,
                 layer=None):
        PROGRESS_LOGGER.info(
            'Step 2 - Fetching and parsing CSS - %s',
            filename or url or getattr(file_obj, 'name', 'CSS string'))
        if url_fetcher is None:
            url_fetcher = URLFetcher()
        result = select_source(
            guess, filename, url, file_obj, string, base_url=base_url,
            url_fetcher=url_fetcher, check_css_mime_type=_check_mime_type)
        with result as (file_obj, base_url, protocol_encoding, mime_type):
            css = file_obj.read()
            if isinstance(css, str):
                stylesheet = tinycss2.parse_stylesheet(css)
            else:
                stylesheet, _ = tinycss2.parse_stylesheet_bytes(
                    css, environment_encoding=encoding,
                    protocol_encoding=protocol_encoding)
        self.base_url = base_url
        self.matcher = matcher or cssselect2.Matcher()
        self.page_rules = [] if page_rules is None else page_rules
        self.layers = [] if layers is None else layers
        counter_style = {} if counter_style is None else counter_style
        color_profiles = {} if color_profiles is None else color_profiles
        preprocess_stylesheet(
            media_type, base_url, stylesheet, url_fetcher, self.matcher,
            self.page_rules, self.layers, font_config, counter_style, color_profiles,
            layer=layer)


class Attachment:
    """File attachment for a PDF document.

    An instance is created in the same way as :class:`HTML`, except that the
    HTML specific arguments (``encoding`` and ``media_type``) are not
    supported.

    :param str name:
        The name of the attachment to be included in the PDF document.
        May be :obj:`None`.
    :param str description:
        A description of the attachment to be included in the PDF document.
        May be :obj:`None`.
    :type created: :obj:`datetime.datetime`
    :param created:
        Creation date and time. Default is current date and time.
    :type modified: :obj:`datetime.datetime`
    :param modified:
        Modification date and time. Default is current date and time.
    :param str relationship:
        A string that represents the relationship between the attachment and
        the PDF it is embedded in. Default is 'Unspecified', other common
        values are defined in ISO-32000-2:2020, 7.11.3.

    """
    def __init__(self, guess=None, filename=None, url=None, file_obj=None,
                 string=None, base_url=None, url_fetcher=None, name=None,
                 description=None, created=None, modified=None,
                 relationship='Unspecified'):
        if url_fetcher is None:
            url_fetcher = URLFetcher()
        self.source = select_source(
            guess, filename, url, file_obj, string, base_url=base_url,
            url_fetcher=url_fetcher)
        self.name = name
        self.description = description
        self.relationship = relationship
        self.md5 = None

        if created is None:
            if filename:
                created = datetime.fromtimestamp(getctime(filename))
            else:
                created = datetime.now()
        if modified is None:
            if filename:
                modified = datetime.fromtimestamp(getmtime(filename))
            else:
                modified = datetime.now()
        self.created = created
        self.modified = modified


# Work around circular imports.
from .css import preprocess_stylesheet  # noqa: I001, E402
from .html import (  # noqa: E402
    HTML5_UA_COUNTER_STYLE, HTML5_UA_STYLESHEET, HTML5_UA_FORM_STYLESHEET,
    HTML5_PH_STYLESHEET)
from .document import Document, Page  # noqa: E402


================================================
FILE: weasyprint/__main__.py
================================================
"""Command-line interface to WeasyPrint."""

import argparse
import logging
import platform
import sys

import pydyf

from . import DEFAULT_OPTIONS, HTML, LOGGER, __version__
from .pdf import VARIANTS
from .text.ffi import pango
from .urls import URLFetcher


class PrintInfo(argparse.Action):
    def __call__(*_, **__):
        # TODO: ignore check at block-level when available.
        # https://github.com/astral-sh/ruff/issues/3711
        uname = platform.uname()
        print('System:', uname.system)  # noqa: T201
        print('Machine:', uname.machine)  # noqa: T201
        print('Version:', uname.version)  # noqa: T201
        print('Release:', uname.release)  # noqa: T201
        print()  # noqa: T201
        print('WeasyPrint version:', __version__)  # noqa: T201
        print('Python version:', sys.version.split()[0])  # noqa: T201
        print('Pydyf version:', pydyf.__version__)  # noqa: T201
        print('Pango version:', pango.pango_version())  # noqa: T201
        sys.exit()


class Parser(argparse.ArgumentParser):
    def __init__(self, *args, **kwargs):
        self._groups = {None: {}}
        super().__init__(*args, **kwargs)

    def add_argument(self, *args, _group_name=None, **kwargs):
        if _group_name is None:
            super().add_argument(*args, **kwargs)
        key = args[-1].lstrip('-')
        kwargs['flags'] = args
        kwargs['positional'] = args[-1][0] != '-'
        self._groups[_group_name][key] = kwargs

    def add_argument_group(self, name, *args, **kwargs):
        group = super().add_argument_group(name, *args, **kwargs)
        self._groups[name] = {}
        def add_argument(*args, **kwargs):
            group._add_argument(*args, **kwargs)
            self.add_argument(*args, _group_name=name, **kwargs)
        group._add_argument = group.add_argument
        group.add_argument = add_argument
        return group

    @property
    def docstring(self):
        self._groups[None].pop('help')
        data = []
        for group, arguments in self._groups.items():
            if not arguments:
                continue
            if group:
                data.append(f'{group[0].title()}{group[1:]}\n')
                data.append(f'{"~" * len(group)}\n\n')
            for key, args in arguments.items():
                data.append('.. option:: ')
                action = args.get('action', 'store')
                for flag in args['flags']:
                    data.append(flag)
                    if not args['positional'] and action in ('store', 'append'):
                        data.append(f' <{key}>')
                    data.append(', ')
                data[-1] = '\n\n'
                data.append(f'  {args["help"][0].upper()}{args["help"][1:]}.\n\n')
                if 'choices' in args:
                    choices = ', '.join(args['choices'])
                    data.append(f'  Possible choices: {choices}.\n\n')
                if action == 'append':
                    data.append('  This option can be passed multiple times.\n\n')
        return ''.join(data)


PARSER = Parser(prog='weasyprint', description='Render web pages to PDF.')
PARSER.add_argument('input', help='URL or filename of the HTML input, or - for stdin')
PARSER.add_argument('output', help='filename where output is written, or - for stdout')
PARSER.add_argument(
    '-i', '--info', action=PrintInfo, nargs=0, help='print system information and exit')
PARSER.add_argument(
    '--version', action='version', version=f'WeasyPrint version {__version__}',
    help='print WeasyPrint’s version number and exit')

group = PARSER.add_argument_group('rendering options')
group.add_argument(
    '-s', '--stylesheet', action='append', dest='stylesheets',
    help='URL or filename for a user CSS stylesheet')
group.add_argument(
    '-a', '--attachment', action='append', dest='attachments',
    help='URL or filename of a file to attach to the PDF document')
group.add_argument(
    '--attachment-relationship', action='append', dest='attachment_relationships',
    help='Relationship of the attachment file to attach to the PDF')
group.add_argument('--pdf-identifier', help='PDF file identifier')
group.add_argument('--pdf-variant', choices=VARIANTS, help='PDF variant to generate')
group.add_argument('--pdf-version', help='PDF version number')
group.add_argument('--pdf-forms', action='store_true', help='include PDF forms')
group.add_argument('--pdf-tags', action='store_true', help='tag PDF for accessibility')
group.add_argument(
    '--uncompressed-pdf', action='store_true',
    help='do not compress PDF content, mainly for debugging purpose')
group.add_argument(
    '--xmp-metadata', action='append',
    help='URL or filename of a file to include into the XMP metadata')
group.add_argument(
    '--custom-metadata', action='store_true',
    help='include custom HTML meta tags in PDF metadata')
group.add_argument(
    '-p', '--presentational-hints', action='store_true',
    help='follow HTML presentational hints')
group.add_argument('--srgb', action='store_true', help='include sRGB color profile')
group.add_argument(
    '--optimize-images', action='store_true',
    help='optimize size of embedded images with no quality loss')
group.add_argument(
    '-j', '--jpeg-quality', type=int,
    help='JPEG quality between 0 (worst) to 95 (best)')
group.add_argument(
    '-D', '--dpi', type=int,
    help='set maximum resolution of images embedded in the PDF')
group.add_argument(
    '--full-fonts', action='store_true',
    help='embed unmodified font files when possible')
group.add_argument(
    '--hinting', action='store_true', help='keep hinting information in embedded fonts')
group.add_argument(
    '-c', '--cache-folder', dest='cache',
    help='store cache on disk instead of memory, folder is '
    'created if needed and cleaned after the PDF is generated')

group = PARSER.add_argument_group('HTML options')
group.add_argument('-e', '--encoding', help='force the input character encoding')
group.add_argument(
    '-m', '--media-type', help='media type to use for @media, defaults to print',
    default='print')
group.add_argument(
    '-u', '--base-url',
    help='base for relative URLs in the HTML input, defaults to the '
    'input’s own filename or URL or the current directory for stdin')

group = PARSER.add_argument_group('URL fetcher options')
group.add_argument(
    '-t', '--timeout', type=int, help='set timeout in seconds for HTTP requests')
group.add_argument(
    '--allowed-protocols', dest='allowed_protocols',
    help='only authorize comma-separated list of protocols for fetching URLs')
group.add_argument(
    '--no-http-redirects', action='store_true', help='do not follow HTTP redirects')
group.add_argument(
    '--fail-on-http-errors', action='store_true',
    help='abort document rendering on any HTTP error')

group = PARSER.add_argument_group('command-line logging options')
group.add_argument(
    '-v', '--verbose', action='store_true',
    help='show warnings and information messages')
group.add_argument(
    '-d', '--debug', action='store_true', help='show debugging messages')
group.add_argument('-q', '--quiet', action='store_true', help='hide logging messages')

PARSER.set_defaults(**DEFAULT_OPTIONS)


def main(argv=None, stdout=None, stdin=None, HTML=HTML):  # noqa: N803
    """The ``weasyprint`` program takes at least two arguments:

    .. code-block:: sh

        weasyprint [options] <input> <output>

    """
    args = PARSER.parse_args(argv)

    if args.input == '-':
        source = stdin or sys.stdin.buffer
        if args.base_url is None:
            args.base_url = '.'  # current directory
        elif args.base_url == '':
            args.base_url = None  # no base URL
    else:
        source = args.input

    if args.output == '-':
        output = stdout or sys.stdout.buffer
    else:
        output = args.output

    fetcher_args = {}
    if args.timeout is not None:
        fetcher_args['timeout'] = args.timeout
    if args.allowed_protocols is not None:
        fetcher_args['allowed_protocols'] = {
            protocol.strip().lower() for protocol in args.allowed_protocols.split(',')}
    if args.no_http_redirects:
        fetcher_args['allow_redirects'] = False
    if args.fail_on_http_errors:
        fetcher_args['fail_on_errors'] = True
    url_fetcher = URLFetcher(**fetcher_args)

    options = {
        key: value for key, value in vars(args).items() if key in DEFAULT_OPTIONS}

    # Default to logging to stderr.
    if args.debug:
        LOGGER.setLevel(logging.DEBUG)
    elif args.verbose:
        LOGGER.setLevel(logging.INFO)
    if not args.quiet:
        handler = logging.StreamHandler()
        if args.debug:
            # Add extra information when debug logging
            handler.setFormatter(
                logging.Formatter(
                    '%(levelname)s: %(filename)s:%(lineno)d '
                    '(%(funcName)s): %(message)s'))
        else:
            handler.setFormatter(logging.Formatter('%(levelname)s: %(message)s'))
        LOGGER.addHandler(handler)

    html = HTML(
        source, base_url=args.base_url, encoding=args.encoding,
        media_type=args.media_type, url_fetcher=url_fetcher)
    html.write_pdf(output, **options)


main.__doc__ += '\n\n' + PARSER.docstring


if __name__ == '__main__':  # pragma: no cover
    main()


================================================
FILE: weasyprint/anchors.py
================================================
"""Find anchors, links, bookmarks and inputs in documents."""

import math

from .formatting_structure import boxes
from .layout.percent import percentage
from .matrix import Matrix


def rectangle_aabb(matrix, pos_x, pos_y, width, height):
    """Apply a transformation matrix to an axis-aligned rectangle.

    Return its axis-aligned bounding box as ``(x1, y1, x2, y2)``.

    """
    if not matrix:
        return pos_x, pos_y, pos_x + width, pos_y + height
    transform_point = matrix.transform_point
    x1, y1 = transform_point(pos_x, pos_y)
    x2, y2 = transform_point(pos_x + width, pos_y)
    x3, y3 = transform_point(pos_x, pos_y + height)
    x4, y4 = transform_point(pos_x + width, pos_y + height)
    box_x1 = min(x1, x2, x3, x4)
    box_y1 = min(y1, y2, y3, y4)
    box_x2 = max(x1, x2, x3, x4)
    box_y2 = max(y1, y2, y3, y4)
    return box_x1, box_y1, box_x2, box_y2


def gather_anchors(box, anchors, links, bookmarks, forms, parent_matrix=None,
                   parent_form=None):
    """Gather anchors and other data related to specific positions in PDF.

    Currently finds anchors, links, bookmarks and forms.

    """
    # Get box transformation matrix.
    # "Transforms apply to block-level and atomic inline-level elements,
    #  but do not apply to elements which may be split into
    #  multiple inline-level boxes."
    # https://www.w3.org/TR/css-transforms-1/#introduction
    if box.style['transform'] and not isinstance(box, boxes.InlineBox):
        border_width = box.border_width()
        border_height = box.border_height()
        origin_x, origin_y = box.style['transform_origin']
        offset_x = percentage(origin_x, box.style, border_width)
        offset_y = percentage(origin_y, box.style, border_height)
        origin_x = box.border_box_x() + offset_x
        origin_y = box.border_box_y() + offset_y

        matrix = Matrix(e=origin_x, f=origin_y)
        for name, args in box.style['transform']:
            a, b, c, d, e, f = 1, 0, 0, 1, 0, 0
            if name == 'scale':
                a, d = args
            elif name == 'rotate':
                a = d = math.cos(args)
                b = math.sin(args)
                c = -b
            elif name == 'translate':
                e = percentage(args[0], box.style, border_width)
                f = percentage(args[1], box.style, border_height)
            elif name == 'skew':
                b, c = math.tan(args[1]), math.tan(args[0])
            else:
                assert name == 'matrix'
                a, b, c, d, e, f = args
            matrix = Matrix(a, b, c, d, e, f) @ matrix
        box.transformation_matrix = (
            Matrix(e=-origin_x, f=-origin_y) @ matrix)
        if parent_matrix:
            matrix = box.transformation_matrix @ parent_matrix
        else:
            matrix = box.transformation_matrix
    else:
        matrix = parent_matrix

    bookmark_label = box.bookmark_label
    if box.style['bookmark_level'] == 'none':
        bookmark_level = None
    else:
        bookmark_level = box.style['bookmark_level']
    state = box.style['bookmark_state']
    link = box.style['link']
    anchor_name = box.style['anchor']
    has_bookmark = bookmark_label and bookmark_level
    # 'link' is inherited but redundant on text boxes
    has_link = link and not isinstance(box, (boxes.TextBox, boxes.LineBox))
    # In case of duplicate IDs, only the first is an anchor.
    has_anchor = anchor_name and anchor_name not in anchors
    is_input = box.is_input()

    if box.is_form():
        parent_form = box.element
        if parent_form not in forms:
            forms[parent_form] = []

    if has_bookmark or has_link or has_anchor or is_input:
        if is_input:
            pos_x, pos_y = box.content_box_x(), box.content_box_y()
            width, height = box.width, box.height
        else:
            pos_x, pos_y, width, height = box.hit_area()
        if has_link or is_input:
            rectangle = rectangle_aabb(matrix, pos_x, pos_y, width, height)
        if has_link:
            token_type, link = link
            assert token_type == 'url'
            link_type, target = link
            assert isinstance(target, str)
            if link_type == 'external' and box.is_attachment():
                link_type = 'attachment'
            links.append((link_type, target, rectangle, box))
        if is_input:
            forms[parent_form].append((box.element, box.style, rectangle))
        if has_bookmark:
            if matrix:
                pos_x, pos_y = matrix.transform_point(pos_x, pos_y)
            bookmark = (bookmark_level, bookmark_label, (pos_x, pos_y), state)
            bookmarks.append(bookmark)
        if has_anchor:
            pos_x1, pos_y1, pos_x2, pos_y2 = pos_x, pos_y, pos_x + width, pos_y + height
            if matrix:
                pos_x1, pos_y1 = matrix.transform_point(pos_x1, pos_y1)
                pos_x2, pos_y2 = matrix.transform_point(pos_x2, pos_y2)
            anchors[anchor_name] = (pos_x1, pos_y1, pos_x2, pos_y2)

    for child in box.all_children():
        gather_anchors(child, anchors, links, bookmarks, forms, matrix, parent_form)


def make_page_bookmark_tree(page, skipped_levels, last_by_depth,
                            previous_level, page_number, matrix):
    """Make a tree of all bookmarks in a given page."""
    for level, label, (point_x, point_y), state in page.bookmarks:
        if level > previous_level:
            # Example: if the previous bookmark is a <h2>, the next
            # depth "should" be for <h3>. If now we get a <h6> we’re
            # skipping two levels: append 6 - 3 - 1 = 2
            skipped_levels.append(level - previous_level - 1)
        else:
            temp = level
            while temp < previous_level:
                temp += 1 + skipped_levels.pop()
            if temp > previous_level:
                # We remove too many "skips", add some back:
                skipped_levels.append(temp - previous_level - 1)

        previous_level = level
        depth = level - sum(skipped_levels)
        assert depth == len(skipped_levels)
        assert depth >= 1

        children = []
        point_x, point_y = matrix.transform_point(point_x, point_y)
        subtree = (label, (page_number, point_x, point_y), children, state)
        last_by_depth[depth - 1].append(subtree)
        del last_by_depth[depth:]
        last_by_depth.append(children)
    return previous_level


================================================
FILE: weasyprint/css/__init__.py
================================================
"""Find and apply CSS.

This module takes care of steps 3 and 4 of “CSS 2.1 processing model”: Retrieve
stylesheets associated with a document and annotate every element with a value
for every CSS property.

https://www.w3.org/TR/CSS21/intro.html#processing-model

This module does this in more than two steps. The
:func:`get_all_computed_styles` function does everything, but it is itsef based
on other functions in this module.

"""

import math
from collections import namedtuple
from itertools import groupby
from logging import DEBUG, WARNING
from math import inf

import cssselect2
import tinycss2
import tinycss2.ast
import tinycss2.nth
from PIL.ImageCms import ImageCmsProfile

from .. import CSS
from ..logger import LOGGER, PROGRESS_LOGGER
from ..text.fonts import FontConfiguration
from ..urls import URLFetchingError, fetch, get_url_attribute, url_join
from . import counters, media_queries
from .computed_values import COMPUTER_FUNCTIONS, PHYSICAL_FUNCTIONS
from .functions import Function, check_math, check_var
from .properties import INHERITED, INITIAL_NOT_COMPUTED, INITIAL_VALUES, ZERO_PIXELS
from .units import ANGLE_UNITS, LENGTH_UNITS, RELATIVE_UNITS, to_pixels, to_radians
from .validation import preprocess_declarations
from .validation.descriptors import preprocess_descriptors
from .validation.properties import validate_non_shorthand

from .tokens import (  # isort:skip
    E, MINUS_INFINITY, NAN, PI, PLUS_INFINITY, InvalidValues, Pending, PercentageInMath,
    RelativeLengthInMath, get_angle, get_url, remove_whitespace, split_on_comma,
    tokenize)

# Reject anything not in here:
PSEUDO_ELEMENTS = (
    None, 'before', 'after', 'marker', 'first-line', 'first-letter',
    'footnote-call', 'footnote-marker')

PageSelectorType = namedtuple(
    'PageSelectorType', ['side', 'blank', 'first', 'index', 'name'])


class StyleFor:
    """Convenience function to get the computed styles for an element."""
    def __init__(self, html, sheets, presentational_hints, font_config,
                 target_collector):
        # keys: (element, pseudo_element_type)
        #    element: an ElementTree Element or the '@page' string
        #    pseudo_element_type: a string such as 'first' (for @page) or
        #        'after', or None for normal elements
        # values: dicts of
        #     keys: property name as a string
        #     values: (values, weight)
        #         values: a PropertyValue-like object
        #         weight: values with a greater weight take precedence, see
        #             https://www.w3.org/TR/CSS21/cascade.html#cascading-order
        self._cascaded_styles = cascaded_styles = {}

        # keys: (element, pseudo_element_type), like cascaded_styles
        # values: style dict objects:
        #     keys: property name as a string
        #     values: a PropertyValue-like object
        self._computed_styles = {}

        # Set when the first page is created, used for viewport-based units.
        self.initial_page_sizes = {'box': None, 'area': None}

        self._sheets = sheets
        self.font_config = font_config

        PROGRESS_LOGGER.info('Step 3 - Applying CSS')
        layer_order = inf
        for specificity, attributes in find_style_attributes(
                html.etree_element, presentational_hints, html.base_url):
            element, declarations, base_url = attributes
            style = cascaded_styles.setdefault((element, None), {})
            for name, values, importance in preprocess_declarations(
                    base_url, declarations):
                precedence = declaration_precedence('author', importance)
                weight = (precedence, layer_order, specificity)
                old_weight = style.get(name, (None, None))[1]
                if old_weight is None or old_weight <= weight:
                    style[name] = values, weight

        # First, add declarations and set computed styles for "real" elements
        # *in tree order*. Tree order is important so that parents have
        # computed styles before their children, for inheritance.

        # Iterate on all elements, even if there is no cascaded style for them.
        for element in html.wrapper_element.iter_subtree():
            for sheet, origin, sheet_specificity in sheets:
                # Add declarations for matched elements
                for selector in sheet.matcher.match(element):
                    specificity, order, pseudo_type, (declarations, layer) = selector
                    layer_order = inf if layer is None else sheet.layers.index(layer)
                    specificity = sheet_specificity or specificity
                    style = cascaded_styles.setdefault(
                        (element.etree_element, pseudo_type), {})
                    for name, values, importance in declarations:
                        precedence = declaration_precedence(origin, importance)
                        weight = (precedence, layer_order, specificity)
                        old_weight = style.get(name, (None, None))[1]
                        if old_weight is None or old_weight <= weight:
                            style[name] = values, weight
            parent = element.parent.etree_element if element.parent else None
            self.set_computed_styles(
                element.etree_element, root=html.etree_element, parent=parent,
                base_url=html.base_url, target_collector=target_collector)

        # Then computed styles for pseudo elements, in any order.
        # Pseudo-elements inherit from their associated element so they come
        # last. Do them in a second pass as there is no easy way to iterate
        # on the pseudo-elements for a given element with the current structure
        # of cascaded_styles. (Keys are (element, pseudo_type) tuples.)

        # Only iterate on pseudo-elements that have cascaded styles. (Others
        # might as well not exist.)
        for element, pseudo_type in cascaded_styles:
            if pseudo_type:
                self.set_computed_styles(
                    element, pseudo_type=pseudo_type,
                    # The pseudo-element inherits from the element.
                    root=html.etree_element, parent=element,
                    base_url=html.base_url, target_collector=target_collector)

        # Clear the cascaded styles, we don't need them anymore. Keep the
        # dictionary, it is used later for page margins.
        self._cascaded_styles.clear()

    def __call__(self, element, pseudo_type=None):
        if style := self._computed_styles.get((element, pseudo_type)):
            if 'table' in style['display'] and style['border_collapse'] == 'collapse':
                # Padding does not apply.
                for side in ('top', 'bottom', 'left', 'right'):
                    style[f'padding_{side}'] = ZERO_PIXELS
            if len(style['display']) == 1:
                display, = style['display']
                if display.startswith('table-') and display != 'table-caption':
                    # Margins do not apply.
                    for side in ('top', 'bottom', 'left', 'right'):
                        style[f'margin_{side}'] = ZERO_PIXELS
        return style

    def set_computed_styles(self, element, parent, root=None, pseudo_type=None,
                            base_url=None, target_collector=None):
        """Set the computed values of styles to ``element``.

        Take the properties left by ``apply_style_rule`` on an element or
        pseudo-element and assign computed values with respect to the cascade,
        declaration priority (ie. ``!important``) and selector specificity.

        """
        cascaded_styles = self.get_cascaded_styles()
        computed_styles = self.get_computed_styles()
        if element == root and pseudo_type is None:
            assert parent is None
            parent_style = None
            root_style = InitialStyle(self.font_config)
        else:
            assert parent is not None
            parent_style = computed_styles[parent, None]
            root_style = computed_styles[root, None]

        cascaded = cascaded_styles.get((element, pseudo_type), {})
        computed = computed_styles[element, pseudo_type] = ComputedStyle(
            parent_style, cascaded, element, pseudo_type, root_style, base_url,
            self.font_config, self.initial_page_sizes)
        if target_collector and computed['anchor']:
            target_collector.collect_anchor(computed['anchor'])

    def add_page_declarations(self, page_type):
        # TODO: use real layer order.
        layer_order = None
        for sheet, origin, sheet_specificity in self._sheets:
            for _rule, selector_list, declarations in sheet.page_rules:
                for selector in selector_list:
                    specificity, pseudo_type, page_selector_type = selector
                    if self._page_type_match(page_selector_type, page_type):
                        specificity = sheet_specificity or specificity
                        style = self._cascaded_styles.setdefault(
                            (page_type, pseudo_type), {})
                        for name, values, importance in declarations:
                            precedence = declaration_precedence(origin, importance)
                            weight = (precedence, layer_order, specificity)
                            old_weight = style.get(name, (None, None))[1]
                            if old_weight is None or old_weight <= weight:
                                style[name] = values, weight

    def get_cascaded_styles(self):
        return self._cascaded_styles

    def get_computed_styles(self):
        return self._computed_styles

    @staticmethod
    def _page_type_match(page_selector_type, page_type):
        if page_selector_type.side not in (None, page_type.side):
            return False
        if page_selector_type.blank not in (None, page_type.blank):
            return False
        if page_selector_type.first not in (None, page_type.index == 0):
            return False
        if page_selector_type.name not in (None, page_type.name):
            return False
        if page_selector_type.index is not None:
            a, b, name = page_selector_type.index
            if name is None:
                index = page_type.index
                offset = index + 1 - b
                return offset == 0 if a == 0 else (offset / a >= 0 and not offset % a)
            if name != page_type.name:
                return False
            for group_name, index in page_type.groups:
                if name != group_name:
                    continue
                offset = index + 1 - b
                if (offset == 0 if a == 0 else (offset / a >= 0 and not offset % a)):
                    return True
            return False
        return True


def get_child_text(element):
    """Return the text directly in the element, not descendants."""
    content = [element.text] if element.text else []
    for child in element:
        if child.tail:
            content.append(child.tail)
    return ''.join(content)


def text_decoration(key, value, parent_value, cascaded):
    # The text-decoration-* properties are not inherited but propagated
    # using specific rules.
    # See https://drafts.csswg.org/css-text-decor-3/#line-decoration
    # TODO: these rules don’t follow the specification.
    text_properties = (
        'text_decoration_color', 'text_decoration_style', 'text_decoration_thickness')
    if key in text_properties:
        if not cascaded:
            value = parent_value
    elif key == 'text_decoration_line':
        if parent_value != 'none':
            if value == 'none':
                value = parent_value
            else:
                value = value | parent_value
    return value


def find_stylesheets(wrapper_element, device_media_type, url_fetcher, base_url,
                     font_config, counter_style, color_profiles, page_rules, layers):
    """Yield the stylesheets in ``element_tree``.

    The output order is the same as the source order.

    """
    from ..html import element_has_link_type

    for wrapper in wrapper_element.query_all('style', 'link'):
        element = wrapper.etree_element
        mime_type = element.get('type', 'text/css').split(';', 1)[0].strip()
        # Only keep 'type/subtype' from 'type/subtype ; param1; param2'.
        if mime_type != 'text/css':
            continue
        media_attr = element.get('media', '').strip() or 'all'
        media = [media_type.strip() for media_type in media_attr.split(',')]
        if not media_queries.evaluate_media_query(media, device_media_type):
            continue
        if element.tag == 'style':
            # Content is text that is directly in the <style> element, not its
            # descendants
            content = get_child_text(element)
            # ElementTree should give us either unicode or ASCII-only
            # bytestrings, so we don't need `encoding` here.
            css = CSS(
                string=content, base_url=base_url,
                url_fetcher=url_fetcher, media_type=device_media_type,
                font_config=font_config, counter_style=counter_style,
                page_rules=page_rules, color_profiles=color_profiles, layers=layers)
            yield css
        elif element.tag == 'link' and element.get('href'):
            if not element_has_link_type(element, 'stylesheet') or \
                    element_has_link_type(element, 'alternate'):
                continue
            href = get_url_attribute(element, 'href', base_url)
            if href is not None:
                try:
                    yield CSS(
                        url=href, url_fetcher=url_fetcher, media_type=device_media_type,
                        font_config=font_config, counter_style=counter_style,
                        color_profiles=color_profiles, page_rules=page_rules,
                        layers=layers, _check_mime_type=True)
                except URLFetchingError as exception:
                    LOGGER.error('Failed to load stylesheet at %s: %s', href, exception)
                    LOGGER.debug('Error while loading stylesheet:', exc_info=exception)


def find_style_attributes(tree, presentational_hints=False, base_url=None):
    """Yield ``specificity, (element, declaration, base_url)`` rules.

    Rules from "style" attribute are returned with specificity
    ``(1, 0, 0)``.

    If ``presentational_hints`` is ``True``, rules from presentational hints
    are returned with specificity ``(0, 0, 0)``.

    """
    def check_style_attribute(element, style_attribute):
        declarations = tinycss2.parse_blocks_contents(style_attribute)
        return element, declarations, base_url

    for element in tree.iter():
        specificity = (1, 0, 0)
        style_attribute = element.get('style')
        if style_attribute:
            yield specificity, check_style_attribute(element, style_attribute)
        if not presentational_hints:
            continue
        specificity = (0, 0, 0)
        if element.tag == 'body':
            # TODO: we should check the container frame element
            for part, position in (
                    ('height', 'top'), ('height', 'bottom'),
                    ('width', 'left'), ('width', 'right')):
                style_attribute = None
                for prop in (f'margin{part}', f'{position}margin'):
                    if element.get(prop):
                        style_attribute = f'margin-{position}:{element.get(prop)}px'
                        break
                if style_attribute:
                    yield specificity, check_style_attribute(element, style_attribute)
            if element.get('background'):
                style_attribute = f'background-image:url({element.get("background")})'
                yield specificity, check_style_attribute(element, style_attribute)
            if element.get('bgcolor'):
                style_attribute = f'background-color:{element.get("bgcolor")}'
                yield specificity, check_style_attribute(element, style_attribute)
            if element.get('text'):
                style_attribute = f'color:{element.get("text")}'
                yield specificity, check_style_attribute(element, style_attribute)
            # TODO: we should support link, vlink, alink
        elif element.tag == 'center':
            yield specificity, check_style_attribute(element, 'text-align:center')
        elif element.tag == 'div':
            align = element.get('align', '').lower()
            if align == 'middle':
                yield specificity, check_style_attribute(element, 'text-align:center')
            elif align in ('center', 'left', 'right', 'justify'):
                yield specificity, check_style_attribute(element, f'text-align:{align}')
        elif element.tag == 'font':
            if element.get('color'):
                yield specificity, check_style_attribute(
                    element, f'color:{element.get("color")}')
            if element.get('face'):
                yield specificity, check_style_attribute(
                    element, f'font-family:{element.get("face")}')
            if element.get('size'):
                size = element.get('size').strip()
                relative_plus = size.startswith('+')
                relative_minus = size.startswith('-')
                if relative_plus or relative_minus:
                    size = size[1:].strip()
                try:
                    size = int(size)
                except ValueError:
                    LOGGER.warning('Invalid value for size: %s', size)
                else:
                    font_sizes = {
                        1: 'x-small',
                        2: 'small',
                        3: 'medium',
                        4: 'large',
                        5: 'x-large',
                        6: 'xx-large',
                        7: '48px',  # 1.5 * xx-large
                    }
                    if relative_plus:
                        size += 3
                    elif relative_minus:
                        size -= 3
                    size = max(1, min(7, size))
                    yield specificity, check_style_attribute(
                        element, f'font-size:{font_sizes[size]}')
        elif element.tag == 'table':
            if element.get('cellspacing'):
                yield specificity, check_style_attribute(
                    element, f'border-spacing:{element.get("cellspacing")}px')
            if element.get('cellpadding'):
                cellpadding = element.get('cellpadding')
                if cellpadding.isdigit():
                    cellpadding += 'px'
                # TODO: don't match subtables cells
                for subelement in element.iter():
                    if subelement.tag in ('td', 'th'):
                        yield specificity, check_style_attribute(
                            subelement,
                            f'padding-left:{cellpadding};'
                            f'padding-right:{cellpadding};'
                            f'padding-top:{cellpadding};'
                            f'padding-bottom:{cellpadding};')
            if element.get('hspace'):
                hspace = element.get('hspace')
                if hspace.isdigit():
                    hspace += 'px'
                yield specificity, check_style_attribute(
                    element, f'margin-left:{hspace};margin-right:{hspace}')
            if element.get('vspace'):
                vspace = element.get('vspace')
                if vspace.isdigit():
                    vspace += 'px'
                yield specificity, check_style_attribute(
                    element, f'margin-top:{vspace};margin-bottom:{vspace}')
            if element.get('width'):
                style_attribute = f'width:{element.get("width")}'
                if element.get('width').isdigit():
                    style_attribute += 'px'
                yield specificity, check_style_attribute(element, style_attribute)
            if element.get('height'):
                style_attribute = f'height:{element.get("height")}'
                if element.get('height').isdigit():
                    style_attribute += 'px'
                yield specificity, check_style_attribute(element, style_attribute)
            if element.get('background'):
                style_attribute = (
                    f'background-image:url({element.get("background")})')
                yield specificity, check_style_attribute(element, style_attribute)
            if element.get('bgcolor'):
                style_attribute = f'background-color:{element.get("bgcolor")}'
                yield specificity, check_style_attribute(element, style_attribute)
            if element.get('bordercolor'):
                style_attribute = f'border-color:{element.get("bordercolor")}'
                yield specificity, check_style_attribute(element, style_attribute)
            if element.get('border'):
                style_attribute = f'border-width:{element.get("border")}px'
                yield specificity, check_style_attribute(element, style_attribute)
        elif element.tag in ('tr', 'td', 'th', 'thead', 'tbody', 'tfoot'):
            align = element.get('align', '').lower()
            # TODO: we should align descendants too
            if align == 'middle':
                yield specificity, check_style_attribute(
                    element, 'text-align:center')
            elif align in ('center', 'left', 'right', 'justify'):
                yield specificity, check_style_attribute(element, f'text-align:{align}')
            if element.get('background'):
                style_attribute = f'background-image:url({element.get("background")})'
                yield specificity, check_style_attribute(element, style_attribute)
            if element.get('bgcolor'):
                style_attribute = f'background-color:{element.get("bgcolor")}'
                yield specificity, check_style_attribute(element, style_attribute)
            if element.tag in ('tr', 'td', 'th'):
                if element.get('height'):
                    style_attribute = f'height:{element.get("height")}'
                    if element.get('height').isdigit():
                        style_attribute += 'px'
                    yield specificity, check_style_attribute(element, style_attribute)
                if element.tag in ('td', 'th'):
                    if element.get('width'):
                        style_attribute = f'width:{element.get("width")}'
                        if element.get('width').isdigit():
                            style_attribute += 'px'
                        yield specificity, check_style_attribute(
                            element, style_attribute)
        elif element.tag == 'caption':
            align = element.get('align', '').lower()
            # TODO: we should align descendants too
            if align == 'middle':
                yield specificity, check_style_attribute(element, 'text-align:center')
            elif align in ('center', 'left', 'right', 'justify'):
                yield specificity, check_style_attribute(element, f'text-align:{align}')
        elif element.tag == 'col':
            if element.get('width'):
                style_attribute = f'width:{element.get("width")}'
                if element.get('width').isdigit():
                    style_attribute += 'px'
                yield specificity, check_style_attribute(element, style_attribute)
        elif element.tag == 'hr':
            size = 0
            if element.get('size'):
                try:
                    size = int(element.get('size'))
                except ValueError:
                    LOGGER.warning('Invalid value for size: %s', size)
            if (element.get('color'), element.get('noshade')) != (None, None):
                if size >= 1:
                    yield specificity, check_style_attribute(
                        element, f'border-width:{size / 2}px')
            elif size == 1:
                yield specificity, check_style_attribute(
                    element, 'border-bottom-width:0')
            elif size > 1:
                yield specificity, check_style_attribute(
                    element, f'height:{size - 2}px')
            if element.get('width'):
                style_attribute = f'width:{element.get("width")}'
                if element.get('width').isdigit():
                    style_attribute += 'px'
                yield specificity, check_style_attribute(element, style_attribute)
            if element.get('color'):
                yield specificity, check_style_attribute(
                    element, f'color:{element.get("color")}')
        elif element.tag in (
                'iframe', 'applet', 'embed', 'img', 'input', 'object',
                '{http://www.w3.org/2000/svg}svg'):
            if (element.tag != 'input' or
                    element.get('type', '').lower() == 'image'):
                align = element.get('align', '').lower()
                if align in ('middle', 'center'):
                    # TODO: middle and center values are wrong
                    yield specificity, check_style_attribute(
                        element, 'vertical-align:middle')
                if element.get('hspace'):
                    hspace = element.get('hspace')
                    if hspace.isdigit():
                        hspace += 'px'
                    yield specificity, check_style_attribute(
                        element, f'margin-left:{hspace};margin-right:{hspace}')
                if element.get('vspace'):
                    vspace = element.get('vspace')
                    if vspace.isdigit():
                        vspace += 'px'
                    yield specificity, check_style_attribute(
                        element, f'margin-top:{vspace};margin-bottom:{vspace}')
                # TODO: img seems to be excluded for width and height, but a
                # lot of W3C tests rely on this attribute being applied to img
                if element.get('width'):
                    style_attribute = f'width:{element.get("width")}'
                    if element.get('width').isdigit():
                        style_attribute += 'px'
                    yield specificity, check_style_attribute(element, style_attribute)
                if element.get('height'):
                    style_attribute = f'height:{element.get("height")}'
                    if element.get('height').isdigit():
                        style_attribute += 'px'
                    yield specificity, check_style_attribute(element, style_attribute)
                if element.tag in ('img', 'object', 'input'):
                    if element.get('border'):
                        yield specificity, check_style_attribute(
                            element,
                            f'border-width:{element.get("border")}px;'
                            f'border-style:solid')
        elif element.tag == 'ol':
            # From https://www.w3.org/TR/css-lists-3/#ua-stylesheet
            if element.get('start'):
                yield specificity, check_style_attribute(
                    element,
                    f'counter-reset:list-item {element.get("start")};'
                    'counter-increment:list-item -1')
        elif element.tag == 'li':
            # From https://www.w3.org/TR/css-lists-3/#ua-stylesheet
            if element.get('value'):
                yield specificity, check_style_attribute(
                    element,
                    f'counter-reset:list-item {element.get("value")};'
                    'counter-increment:none')


def declaration_precedence(origin, importance):
    """Return the precedence for a declaration.

    Precedence values have no meaning unless compared to each other.

    Acceptable values for ``origin`` are the strings ``'author'``, ``'user'``
    and ``'user agent'``.

    """
    # See https://www.w3.org/TR/CSS21/cascade.html#cascading-order
    if origin == 'user agent':
        return 1
    elif origin == 'user' and not importance:
        return 2
    elif origin == 'author' and not importance:
        return 3
    elif origin == 'author':  # and importance
        return 4
    else:
        assert origin == 'user'  # and importance
        return 5


def resolve_var(computed, token, parent_style, known_variables=None):
    """Return token with resolved CSS variables."""
    if not check_var(token):
        return

    if known_variables is None:
        known_variables = set()

    if token.type == '() block' or token.lower_name != 'var':
        items = []
        token_items = token.arguments if token.type == 'function' else token.content
        for i, argument in enumerate(token_items):
            if argument.type in ('function', '() block'):
                resolved = resolve_var(
                    computed, argument, parent_style, known_variables.copy())
                items.extend((argument,) if resolved is None else resolved)
            else:
                items.append(argument)
        if token.type == '() block':
            token = tinycss2.ast.ParenthesesBlock(
                token.source_line, token.source_column, items)
        else:
            token = tinycss2.ast.FunctionBlock(
                token.source_line, token.source_column, token.name, items)
        return resolve_var(computed, token, parent_style, known_variables) or (token,)

    function = Function(token)
    arguments = function.split_comma(single_tokens=False, trailing=True)
    if not arguments or len(arguments[0]) != 1:
        return []
    variable_name = arguments[0][0].value.replace('-', '_')  # first arg is name
    if variable_name in known_variables:
        return []  # endless recursion
    else:
        known_variables.add(variable_name)
    default = arguments[1] if len(arguments) > 1 else []
    computed_value = []
    for value in (computed[variable_name] or default):
        resolved = resolve_var(computed, value, parent_style, known_variables.copy())
        computed_value.extend((value,) if resolved is None else resolved)
    return computed_value


def _resolve_calc_sum(computed, tokens, property_name, refer_to):
    groups = [[]]
    for token in tokens:
        if token.type == 'literal' and token.value in '+-':
            groups.append(token.value)
            groups.append([])
        elif token.type == '() block':
            content = remove_whitespace(token.content)
            result = _resolve_calc_sum(computed, content, property_name, refer_to)
            if result is None:
                return
            groups[-1].append(result)
        else:
            groups[-1].append(token)

    value, sign, unit = 0, '+', None
    exception = None
    while groups:
        if sign is None:
            sign = groups.pop(0)
            assert sign in '+-'
        else:
            group = groups.pop(0)
            assert group
            assert isinstance(group, list)
            try:
                product = _resolve_calc_product(
                    computed, group, property_name, refer_to)
            except RelativeLengthInMath as relative_exception:
                # RelativeLengthInMath raised, assume that we got pixels and continue to
                # find if we have to raise PercentageInMath first.
                if unit == '%':
                    raise PercentageInMath
                exception = relative_exception
                unit = 'px'
                sign = None
                continue
            else:
                if product is None:
                    return
            if product.type == 'dimension':
                if unit is None:
                    unit = product.unit.lower()
                elif unit == '%':
                    raise PercentageInMath
                elif unit != product.unit.lower():
                    return
            elif product.type == 'percentage':
                if refer_to is not None:
                    product.value = product.value / 100 * refer_to
                    unit = 'px'
                else:
                    if unit is None or unit == '%':
                        unit = '%'
                    else:
                        raise PercentageInMath
            if sign == '+':
                value += product.value
            else:
                value -= product.value
            sign = None

    # Raise RelativeLengthInMath, only if we didn’t raise PercentageInMath before.
    if exception:
        raise exception

    return tokenize(value, unit=unit)


def _resolve_calc_product(computed, tokens, property_name, refer_to):
    groups = [[]]
    for token in tokens:
        if token.type == 'literal' and token.value in '*/':
            groups.append(token.value)
            groups.append([])
        elif token.type == 'number':
            groups[-1].append(token)
        elif token.type == 'dimension' and token.unit.lower() in LENGTH_UNITS:
            if computed is None and token.unit.lower() in RELATIVE_UNITS:
                raise RelativeLengthInMath
            pixels = to_pixels(token, computed, property_name)
            groups[-1].append(tokenize(pixels, unit='px'))
        elif token.type == 'dimension' and token.unit.lower() in ANGLE_UNITS:
            groups[-1].append(tokenize(to_radians(token), unit='rad'))
        elif token.type == 'percentage':
            groups[-1].append(tokenize(token.value, unit='%'))
        elif token.type == 'ident':
            groups[-1].append(token)
        else:
            return

    value, sign, unit = 1, '*', None
    while groups:
        if sign is None:
            sign = groups.pop(0)
            assert sign in '*/'
        else:
            group = groups.pop(0)
            assert isinstance(group, list)
            calc = _resolve_calc_value(computed, group)
            if calc is None:
                return
            if calc.type == 'dimension':
                if unit is None or unit == '%':
                    unit = calc.unit.lower()
                else:
                    return
            elif calc.type == 'percentage':
                if unit is None:
                    unit = '%'
            if sign == '*':
                value *= calc.value
            else:
                value /= calc.value
            sign = None

    return tokenize(value, unit=unit)


def _resolve_calc_value(computed, tokens):
    if len(tokens) == 1:
        token, = tokens
        if token.type in ('number', 'dimension', 'percentage'):
            return token
        elif token.type == 'ident':
            if token.lower_value == 'e':
                return E
            elif token.lower_value == 'pi':
                return PI
            elif token.lower_value == 'infinity':
                return PLUS_INFINITY
            elif token.lower_value == '-infinity':
                return MINUS_INFINITY
            elif token.lower_value == 'nan':
                return NAN


def resolve_math(token, computed=None, property_name=None, refer_to=None):
    """Return token with resolved math functions.

    Raise, in order of priority, ``PercentageInMath`` if percentages are mixed with
    other values with no ``refer_to`` size, or ``RelativeLengthInMath`` if no
    ``computed`` style is available to get font / viewport size.

    ``PercentageInMath`` has to be raised before ``RelativeLengthInMath`` so that it can
    be used to discard validation of properties that don’t accept percentages.

    """
    if not check_math(token):
        return

    args = []
    function = Function(token)
    if function.name is None:
        return
    for part in function.split_comma(single_tokens=False):
        args.append([])
        for arg in part:
            if check_math(arg):
                arg = resolve_math(arg, computed, property_name, refer_to)
                if arg is None:
                    return
            args[-1].append(arg)

    if function.name == 'calc':
        result = _resolve_calc_sum(computed, args[0], property_name, refer_to)
        if result is None:
            return
        else:
            return tokenize(result)

    elif function.name in ('min', 'max'):
        target_value = target_token = unit = None
        for tokens in args:
            token = _resolve_calc_sum(computed, tokens, property_name, refer_to)
            if token is None:
                return
            if token.type == 'percentage':
                if refer_to is None:
                    if unit in ('px', ''):
                        raise PercentageInMath
                    unit = '%'
                    value = token
                else:
                    unit = 'px'
                    token = value = tokenize(token.value / 100 * refer_to, unit='px')
            elif token.type == 'number':
                if unit == '%':
                    raise PercentageInMath
                elif unit == 'px':
                    return
                unit = ''
                value = tokenize(token.value, unit='px')
            else:
                if unit == '%':
                    raise PercentageInMath
                elif unit == '':
                    return
                unit = 'px'
                value = tokenize(to_pixels(token, computed, property_name), unit='px')
            update_condition = (
                target_value is None or
                (function.name == 'min' and value.value < target_value.value) or
                (function.name == 'max' and value.value > target_value.value))
            if update_condition:
                target_value, target_token = value, token
        return tokenize(target_token)

    elif function.name == 'round':
        strategy, multiple = 'nearest', 1
        if len(args) == 1:
            number_token = _resolve_calc_sum(computed, args[0], property_name, refer_to)
        elif len(args) == 2:
            strategies = ('nearest', 'up', 'down', 'to-zero')
            if len(args[0]) == 1 and args[0][0].value in strategies:
                strategy = args[0][0].value
                number_token = _resolve_calc_sum(
                    computed, args[1], property_name, refer_to)
                if number_token is None:
                    return
            else:
                number_token = _resolve_calc_sum(
                    computed, args[0], property_name, refer_to)
                multiple_token = _resolve_calc_sum(
                    computed, args[1], property_name, refer_to)
                if None in (number_token, multiple_token):
                    return
                if number_token.type != multiple_token.type:
                    return
                multiple = multiple_token.value
        elif len(args) == 3:
            strategy = args[0][0].value
            number_token = _resolve_calc_sum(computed, args[1], property_name, refer_to)
            multiple_token = _resolve_calc_sum(
                computed, args[2], property_name, refer_to)
            if None in (number_token, multiple_token):
                return
            if number_token.type != multiple_token.type:
                return
            multiple = multiple_token.value
        if strategy == 'nearest':
            # TODO: always round x.5 to +inf, see
            # https://drafts.csswg.org/css-values-4/#combine-integers.
            function = round
        elif strategy == 'up':
            function = math.ceil
        elif strategy == 'down':
            function = math.floor
        elif strategy == 'to-zero':
            function = math.floor if number_token.value > 0 else math.ceil
        else:
            return
        return tokenize(number_token, lambda x: function(x / multiple) * multiple)

    elif function.name in ('mod', 'rem'):
        number_token = _resolve_calc_sum(computed, args[0], property_name, refer_to)
        parameter_token = _resolve_calc_sum(computed, args[1], property_name, refer_to)
        if None in (number_token, parameter_token):
            return
        if number_token.type != parameter_token.type:
            return
        number = number_token.value
        parameter = parameter_token.value
        value = number % parameter
        if function.name == 'rem' and number * parameter < 0:
            value += abs(parameter)
        return tokenize(number_token, lambda x: value)

    elif function.name in ('sin', 'cos', 'tan'):
        number_token = _resolve_calc_sum(computed, args[0], property_name, refer_to)
        if number_token is None:
            return
        if number_token.type == 'number':
            angle = number_token.value
        elif (angle := get_angle(number_token)) is None:
            return
        value = getattr(math, function.name)(angle)
        return tokenize(value)

    elif function.name in ('asin', 'acos', 'atan'):
        number_token = _resolve_calc_sum(computed, args[0], property_name, refer_to)
        if number_token is None or number_token.type != 'number':
            return
        try:
            value = getattr(math, function.name)(number_token.value)
        except ValueError:
            return
        return tokenize(value, unit='rad')

    elif function.name == 'atan2':
        y_token, x_token = [
            _resolve_calc_sum(computed, arg, property_name, refer_to) for arg in args]
        if None in (y_token, x_token):
            return
        if {y_token.type, x_token.type} != {'number'}:
            return
        y, x = y_token.value, x_token.value
        return tokenize(math.atan2(y, x), unit='rad')

    elif function.name == 'clamp':
        pixels_list = []
        unit = None
        for tokens in args:
            token = _resolve_calc_sum(computed, tokens, property_name, refer_to)
            if token is None:
                return
            if token.type == 'percentage':
                if refer_to is None:
                    if unit == 'px':
                        raise PercentageInMath
                    unit = '%'
                    value = token
                else:
                    unit = 'px'
                    token = tokenize(token.value / 100 * refer_to, unit='px')
            else:
                if unit == '%':
                    raise PercentageInMath
                unit = 'px'
                pixels = to_pixels(token, computed, property_name)
                value = tokenize(pixels, unit='px')
            pixels_list.append(value)
        min_token, token, max_token = pixels_list
        if token.value < min_token.value:
            token = min_token
        if token.value > max_token.value:
            token = max_token
        return tokenize(token)

    elif function.name == 'pow':
        number_token, power_token = [
            _resolve_calc_sum(computed, arg, property_name, refer_to) for arg in args]
        if None in (number_token, power_token):
            return
        if {number_token.type, power_token.type} != {'number'}:
            return
        return tokenize(number_token, lambda x: x ** power_token.value)

    elif function.name == 'sqrt':
        number_token = _resolve_calc_sum(computed, args[0], property_name, refer_to)
        if number_token is None or number_token.type != 'number':
            return
        return tokenize(number_token, lambda x: x ** 0.5)

    elif function.name == 'hypot':
        resolved = [
            _resolve_calc_sum(computed, tokens, property_name, refer_to)
            for tokens in args]
        if None in resolved:
            return
        value = math.hypot(*[token.value for token in resolved])
        return tokenize(resolved[0], lambda x: value)

    elif function.name == 'log':
        number_token = _resolve_calc_sum(computed, args[0], property_name, refer_to)
        if number_token is None or number_token.type != 'number':
            return
        if len(args) == 2:
            base_token = _resolve_calc_sum(computed, args[1], property_name, refer_to)
            if base_token is None or base_token.type != 'number':
                return
            base = base_token.value
        else:
            base = math.e
        return tokenize(number_token, lambda x: math.log(x, base))

    elif function.name == 'exp':
        number_token = _resolve_calc_sum(computed, args[0], property_name, refer_to)
        if number_token is None or number_token.type != 'number':
            return
        return tokenize(number_token, math.exp)

    elif function.name == 'abs':
        number_token = _resolve_calc_sum(computed, args[0], property_name, refer_to)
        if number_token is None:
            return
        return tokenize(number_token, abs)

    elif function.name == 'sign':
        number_token = _resolve_calc_sum(computed, args[0], property_name, refer_to)
        if number_token is None:
            return
        return tokenize(
            number_token.value, lambda x: 0 if x == 0 else 1 if x > 0 else -1)

    arguments = []
    for i, argument in enumerate(token.arguments):
        if argument.type == 'function':
            result = resolve_math(argument, computed, property_name, refer_to)
            if result is None:
                return
            arguments.append(result)
        else:
            arguments.append(argument)
    token = tinycss2.ast.FunctionBlock(
        token.source_line, token.source_column, token.name, arguments)
    return resolve_math(token, computed, property_name, refer_to) or token


class InitialStyle(dict):
    """Dummy computed style used to store initial values."""
    def __init__(self, font_config):
        self.parent_style = None
        self.specified = self
        self.cache = {}
        self.font_config = font_config

    def __missing__(self, key):
        value = self[key] = INITIAL_VALUES[key]
        return value


class AnonymousStyle(dict):
    """Computed style used for anonymous boxes."""
    def __init__(self, parent_style):
        # border-*-style is none, so border-width computes to zero.
        # Other than that, properties that would need computing are
        # border-*-color, but they do not apply.
        self.update({
            'border_top_width': 0,
            'border_bottom_width': 0,
            'border_left_width': 0,
            'border_right_width': 0,
            'outline_width': 0,
        })
        self.parent_style = parent_style
        self.is_root_element = False
        self.specified = self
        self.cache = parent_style.cache
        self.font_config = parent_style.font_config

    def copy(self):
        copy = AnonymousStyle(self.parent_style)
        copy.update(self)
        return copy

    def __missing__(self, key):
        if key in INHERITED or key[:2] == '__':
            value = self[key] = self.parent_style[key]
        elif key == 'page':
            # page is not inherited but taken from the ancestor if 'auto'
            value = self[key] = self.parent_style[key]
        elif key[:16] == 'text_decoration_':
            value = self[key] = text_decoration(
                key, INITIAL_VALUES[key], self.parent_style[key], cascaded=False)
        else:
            value = INITIAL_VALUES[key]
            if key in INITIAL_NOT_COMPUTED:
                # Value not computed yet: compute.
                value = self[key] = COMPUTER_FUNCTIONS[key](self, key, value)
            else:
                # The value is the same as when computed.
                self[key] = value
        return value


class ComputedStyle(dict):
    """Computed style used for non-anonymous boxes."""
    def __init__(self, parent_style, cascaded, element, pseudo_type,
                 root_style, base_url, font_config, initial_page_sizes):
        self.specified = {}
        self.parent_style = parent_style
        self.cascaded = cascaded
        self.is_root_element = parent_style is None
        self.element = element
        self.pseudo_type = pseudo_type
        self.root_style = root_style
        self.base_url = base_url
        self.font_config = font_config
        self.initial_page_sizes = initial_page_sizes
        self.cache = parent_style.cache if parent_style else {}

    def copy(self):
        copy = ComputedStyle(
            self.parent_style, self.cascaded, self.element, self.pseudo_type,
            self.root_style, self.base_url, self.font_config, self.initial_page_sizes)
        copy.update(self)
        copy.specified = self.specified.copy()
        return copy

    def __missing__(self, key):
        if key == 'float':
            # Set specified value for position, needed for computed value.
            self['position']
        elif key == 'display':
            # Set specified value for float, needed for computed value.
            self['float']

        parent_style = self.parent_style

        if key in self.cascaded:
            # Property defined in cascaded properties.
            value, weight = self.cascaded[key]
            pending = isinstance(value, Pending)
        else:
            # Property not defined in cascaded properties, define as inherited
            # or initial value.
            if key in INHERITED or key[:2] == '__':
                value = 'inherit'
            else:
                value = 'initial'
            weight = (0, 0, (0, 0, 0))
            pending = False

        if logical_function := PHYSICAL_FUNCTIONS.get(key):
            # TODO: use writing-mode and text-orientation.
            logical_key = logical_function(block='ttb', inline=self['direction'])
            if logical_key in self.cascaded:
                logical_value, logical_weight = self.cascaded[logical_key]
                if logical_weight >= weight:
                    value = logical_value
                    pending = isinstance(value, Pending)

        if value == 'inherit' and parent_style is None:
            # On the root element, 'inherit' from initial values
            value = 'initial'

        if pending:
            # Property with pending values, validate them.
            solved_tokens = []
            for token in value.tokens:
                tokens = resolve_var(self, token, parent_style)
                if tokens is None:
                    solved_tokens.append(token)
                else:
                    solved_tokens.extend(tokens)
            original_key = key.replace('_', '-')
            try:
                value = value.solve(solved_tokens, original_key)
            except InvalidValues:
                if key in INHERITED and parent_style is not None:
                    # Values in parent_style are already computed.
                    self[key] = value = parent_style[key]
                else:
                    value = INITIAL_VALUES[key]
                    if key not in INITIAL_NOT_COMPUTED:
                        # The value is the same as when computed.
                        self[key] = value

        if value == 'initial':
            value = [] if key[:2] == '__' else INITIAL_VALUES[key]
            if key not in INITIAL_NOT_COMPUTED:
                # The value is the same as when computed.
                self[key] = value
        elif value == 'inherit':
            # Values in parent_style are already computed.
            self[key] = value = parent_style[key]

        if key[:16] == 'text_decoration_' and parent_style is not None:
            # Text decorations are not inherited but propagated. See
            # https://www.w3.org/TR/css-text-decor-3/#line-decoration.
            if key in COMPUTER_FUNCTIONS:
                value = COMPUTER_FUNCTIONS[key](self, key, value)
            self[key] = text_decoration(
                key, value, parent_style[key], key in self.cascaded)
        elif key == 'page' and value == 'auto':
            # The page property does not inherit. However, if the page value on
            # an element is auto, then its used value is the value specified on
            # its nearest ancestor with a non-auto value. When specified on the
            # root element, the used value for auto is the empty string. See
            # https://www.w3.org/TR/css-page-3/#using-named-pages.
            value = '' if parent_style is None else parent_style['page']
            if key in self:
                del self[key]
        elif key in ('position', 'float', 'display'):
            # Save specified values to define computed values for these
            # specific properties. See
            # https://www.w3.org/TR/CSS21/visuren.html#dis-pos-flo.
            self.specified[key] = value

        if check_math(value):
            function = value
            solved_tokens = []
            try:
                try:
                    token = resolve_math(function, self, key)
                except PercentageInMath:
                    solved_tokens.append(function)
                else:
                    if token is None:
                        raise Exception
                    solved_tokens.append(token)
                original_key = key.replace('_', '-')
                value = validate_non_shorthand(solved_tokens, original_key)[0][1]
            except Exception:
                LOGGER.warning(
                    'Invalid math function at %d:%d: %s',
                    function.source_line, function.source_column, function.serialize())
                if key in INHERITED and parent_style is not None:
                    # Values in parent_style are already computed.
                    self[key] = value = parent_style[key]
                else:
                    value = INITIAL_VALUES[key]
                    if key not in INITIAL_NOT_COMPUTED:
                        # The value is the same as when computed.
                        self[key] = value

        if key in self:
            # Value already computed and saved: return.
            return self[key]

        if key in COMPUTER_FUNCTIONS:
            # Value not computed yet: compute.
            value = COMPUTER_FUNCTIONS[key](self, key, value)

        self[key] = value
        return value


class ColorProfile:
    def __init__(self, file_object, descriptors):
        self.src = descriptors['src'][1]
        self.renderingintent = descriptors['rendering-intent']
        self.components = descriptors['components']
        self._profile = ImageCmsProfile(file_object)

    @property
    def name(self):
        return (
            self._profile.profile.model or
            self._profile.profile.profile_description)

    @property
    def content(self):
        return self._profile.tobytes()


def _add_layer(layer, layers):
    """Add layer to list of layers, handling order."""
    index = None
    parts = layer.split('.')
    full_layer = ''
    for part in parts:
        if full_layer:
            full_layer += '.'
        full_layer += part
        if full_layer in layers:
            index = layers.index(full_layer)
            continue
        if index is None:
            layers.append(full_layer)
            index = len(layers) - 1
        else:
            layers.insert(index, full_layer)
            index -= 1


def computed_from_cascaded(element, cascaded, parent_style, pseudo_type=None,
                           root_style=None, base_url=None,
                           target_collector=None):
    """Get a dict of computed style mixed from parent and cascaded styles."""
    if not cascaded and parent_style is not None:
        return AnonymousStyle(parent_style)


def _parse_layer(tokens):
    """Parse tokens representing a layer name."""
    if not tokens:
        return
    new_layer = ''
    last_dot = True
    for token in tokens:
        if token.type == 'ident' and last_dot:
            new_layer += token.value
            last_dot = False
        elif token.type == 'literal' and token.value == '.' and not last_dot:
            new_layer += '.'
            last_dot = True
        else:
            return
    if not last_dot:
        return new_layer


def parse_color_profile_name(prelude):
    tokens = list(remove_whitespace(prelude))

    if len(tokens) != 1:
        return

    token = tokens[0]
    if token.type != 'ident':
        return

    if token.value.startswith('--') or token.value == 'device-cmyk':
        return token.value


def parse_page_selectors(rule):
    """Parse a page selector rule.

    Return a list of page data if the rule is correctly parsed. Page data are a
    dict containing:

    - 'side' ('left', 'right' or None),
    - 'blank' (True or None),
    - 'first' (True or None),
    - 'index' (page number or None),
    - 'name' (page name string or None), and
    - 'specificity' (list of numbers).

    Return ``None` if something went wrong while parsing the rule.

    """
    # See https://drafts.csswg.org/css-page-3/#syntax-page-selector

    tokens = list(remove_whitespace(rule.prelude))
    page_data = []

    # TODO: Specificity is probably wrong, should clean and test that.
    if not tokens:
        page_data.append({
            'side': None, 'blank': None, 'first': None, 'index': None,
            'name': None, 'specificity': [0, 0, 0]})
        return page_data

    while tokens:
        types = {
            'side': None, 'blank': None, 'first': None, 'index': None,
            'name': None, 'specificity': [0, 0, 0]}

        if tokens[0].type == 'ident':
            token = tokens.pop(0)
            types['name'] = token.value
            types['specificity'][0] = 1

        if len(tokens) == 1:
            return None
        elif not tokens:
            page_data.append(types)
            return page_data

        while tokens:
            literal = tokens.pop(0)
            if literal.type != 'literal':
                return None

            if literal.value == ':':
                if not tokens:
                    return None

                if tokens[0].type == 'ident':
                    ident = tokens.pop(0)
                    pseudo_class = ident.lower_value

                    if pseudo_class in ('left', 'right'):
                        if types['side'] and types['side'] != pseudo_class:
                            return None
                        types['side'] = pseudo_class
                        types['specificity'][2] += 1
                        continue

                    elif pseudo_class in ('blank', 'first'):
                        types[pseudo_class] = True
                        types['specificity'][1] += 1
                        continue

                elif tokens[0].type == 'function':
                    function = tokens.pop(0)
                    if function.name != 'nth':
                        return None
                    for i, argument in enumerate(function.arguments):
                        if argument.type == 'ident' and argument.value == 'of':
                            nth = function.arguments[:i - 1]
                            group = function.arguments[i + 1:]
                            break
                    else:
                        nth = function.arguments
                        group = None

                    nth_values = tinycss2.nth.parse_nth(nth)
                    if nth_values is None:
                        return None

                    if group is not None:
                        group = [
                            token for token in group
                            if token.type not in ('comment', 'whitespace')]
                        if len(group) != 1:
                            return None
                        group, = group
                        if group.type != 'ident':
                            return None
                        group = group.value

                    types['index'] = (*nth_values, group)
                    # TODO: specificity is not specified yet
                    # https://github.com/w3c/csswg-drafts/issues/3524
                    types['specificity'][1] += 1
                    if group:
                        types['specificity'][0] += 1
                    continue

                return None
            elif literal.value == ',':
                if tokens and any(types['specificity']):
                    break
                else:
                    return None

        page_data.append(types)

    return page_data


def preprocess_stylesheet(device_media_type, base_url, stylesheet_rules, url_fetcher,
                          matcher, page_rules, layers, font_config, counter_style,
                          color_profiles, ignore_imports=False, layer=None):
    """Do what can be done early on stylesheet, before being in a document."""
    for rule in stylesheet_rules:
        if getattr(rule, 'content', None) is None:
            if rule.type == 'error':
                LOGGER.warning(
                    'Parse error at %d:%d: %s',
                    rule.source_line, rule.source_column, rule.message)
            if rule.type != 'at-rule':
                continue
            if rule.lower_at_keyword not in ('import', 'layer'):
                LOGGER.warning(
                    'Unknown empty rule %s at %d:%d',
                    rule, rule.source_line, rule.source_column)
                continue

        if rule.type == 'qualified-rule':
            try:
                logger_level = WARNING
                contents = tinycss2.parse_blocks_contents(rule.content)
                selectors_declarations = list(
                    preprocess_declarations(base_url, contents, rule.prelude))

                if selectors_declarations:
                    selectors_declarations = groupby(
                        selectors_declarations, key=lambda x: x[0])
                    for selectors, declarations in selectors_declarations:
                        declarations = [
                            declaration[1] for declaration in declarations]
                        for selector in selectors:
                            matcher.add_selector(selector, (declarations, layer))
                            if selector.pseudo_element not in PSEUDO_ELEMENTS:
                                prelude = tinycss2.serialize(rule.prelude)
                                if selector.pseudo_element.startswith('-'):
                                    logger_level = DEBUG
                                    raise cssselect2.SelectorError(
                                        f"'{prelude}', "
                                        'ignored prefixed pseudo-element: '
                                        f'{selector.pseudo_element}')
                                else:
                                    raise cssselect2.SelectorError(
                                        f"'{prelude}', "
                                        'unknown pseudo-element: '
                                        f'{selector.pseudo_element}')
                        ignore_imports = True
                else:
                    ignore_imports = True
            except cssselect2.SelectorError as exc:
                LOGGER.log(logger_level, 'Invalid or unsupported selector, %s', exc)
                continue

        elif rule.type == 'at-rule' and rule.lower_at_keyword == 'import':
            if ignore_imports:
                LOGGER.warning(
                    '@import rule %r not at the beginning of the '
                    'the whole rule was ignored at %d:%d.',
                    tinycss2.serialize(rule.prelude),
                    rule.source_line, rule.source_column)
                continue

            tokens = remove_whitespace(rule.prelude)
            url = None
            if tokens:
                if tokens[0].type == 'string':
                    url = url_join(
                        base_url, tokens[0].value, allow_relative=False,
                        context='@import at %s:%s',
                        context_args=(rule.source_line, rule.source_column))
                else:
                    url_tuple = get_url(tokens[0], base_url)
                    if url_tuple and url_tuple[1][0] == 'external':
                        url = url_tuple[1][1]
            if url is None:
                continue

            new_layer = None
            next_tokens = list(tokens[1:])
            if next_tokens:
                if next_tokens[0].type == 'function' and next_tokens[0].name == 'layer':
                    function = next_tokens.pop(0)
                    if not (new_layer := _parse_layer(function.arguments)):
                        LOGGER.warning(
                            'Invalid layer name %r '
                            'the whole @import rule was ignored at %d:%d.',
                            tinycss2.serialize(function),
                            rule.source_line, rule.source_column)
                        continue
                elif next_tokens[0].type == 'ident' and next_tokens[0].value == 'layer':
                    next_tokens.pop(0)
                    new_layer = f'@anonymous{len(layers)}'
                if new_layer:
                    if layer is not None:
                        new_layer = f'{layer}.{new_layer}'
                    _add_layer(new_layer, layers)

            media = media_queries.parse_media_query(next_tokens)
            if media is None:
                LOGGER.warning(
                    'Invalid media type %r '
                    'the whole @import rule was ignored at %d:%d.',
                    tinycss2.serialize(rule.prelude),
                    rule.source_line, rule.source_column)
                continue
            if not media_queries.evaluate_media_query(media, device_media_type):
                continue
            if url is not None:
                try:
                    CSS(
                        url=url, url_fetcher=url_fetcher, media_type=device_media_type,
                        font_config=font_config, counter_style=counter_style,
                        color_profiles=color_profiles, matcher=matcher,
                        page_rules=page_rules, layers=layers, layer=new_layer)
                except URLFetchingError as exception:
                    LOGGER.error('Failed to load stylesheet at %s : %s', url, exception)
                    LOGGER.debug('Error while loading stylesheet:', exc_info=exception)

        elif rule.type == 'at-rule' and rule.lower_at_keyword == 'media':
            media = media_queries.parse_media_query(rule.prelude)
            if media is None:
                LOGGER.warning(
                    'Invalid media type %r '
                    'the whole @media rule was ignored at %d:%d.',
                    tinycss2.serialize(rule.prelude),
                    rule.source_line, rule.source_column)
                continue
            if not media_queries.evaluate_media_query(media, device_media_type):
                continue
            content_rules = tinycss2.parse_rule_list(rule.content)
            preprocess_stylesheet(
                device_media_type, base_url, content_rules, url_fetcher, matcher,
                page_rules, layers, font_config, counter_style, color_profiles,
                ignore_imports=True)

        elif rule.type == 'at-rule' and rule.lower_at_keyword == 'page':
            data = parse_page_selectors(rule)

            if data is None:
                LOGGER.warning(
                    'Unsupported @page selector %r, '
                    'the whole @page rule was ignored at %d:%d.',
                    tinycss2.serialize(rule.prelude),
                    rule.source_line, rule.source_column)
                continue

            ignore_imports = True
            for page_data in data:
                specificity = page_data.pop('specificity')
                page_selector_type = PageSelectorType(**page_data)
                content = tinycss2.parse_blocks_contents(rule.content)
                declarations = list(preprocess_declarations(base_url, content))

                if declarations:
                    selector_list = [(specificity, None, page_selector_type)]
                    page_rules.append((rule, selector_list, declarations))

                for margin_rule in content:
                    if margin_rule.type != 'at-rule' or margin_rule.content is None:
                        continue
                    declarations = list(preprocess_declarations(
                        base_url,
                        tinycss2.parse_blocks_contents(margin_rule.content)))
                    if declarations:
                        selector_list = [(
                            specificity, f'@{margin_rule.lower_at_keyword}',
                            page_selector_type)]
                        page_rules.append((margin_rule, selector_list, declarations))

        elif rule.type == 'at-rule' and rule.lower_at_keyword == 'font-face':
            ignore_imports = True
            content = tinycss2.parse_blocks_contents(rule.content)
            rule_descriptors = dict(
                preprocess_descriptors('font-face', base_url, content))
            for key in ('src', 'font_family'):
                if key not in rule_descriptors:
                    LOGGER.warning(
                        "Missing %s descriptor in '@font-face' rule at %d:%d",
                        key.replace('_', '-'), rule.source_line, rule.source_column)
                    break
            else:
                if font_config is not None:
                    font_config.add_font_face(rule_descriptors, url_fetcher)

        elif rule.type == 'at-rule' and rule.lower_at_keyword == 'color-profile':
            ignore_imports = True

            if (name := parse_color_profile_name(rule.prelude)) is None:
                LOGGER.warning(
                    'Invalid color profile name %r, the whole '
                    '@color-profile rule was ignored at %d:%d.',
                    tinycss2.serialize(rule.prelude), rule.source_line,
                    rule.source_column)
                continue

            content = tinycss2.parse_blocks_contents(rule.content)
            rule_descriptors = preprocess_descriptors(
                'color-profile', base_url, content)

            descriptors = {
                'src': None,
                'rendering-intent': 'relative-colorimetric',
                'components': None,
            }
            for descriptor_name, descriptor_value in rule_descriptors:
                if descriptor_name in descriptors:
                    descriptors[descriptor_name] = descriptor_value
                else:
                    LOGGER.warning(
                        'Unknown descriptor %r for profile named %r at %d:%d.',
                        descriptor_name, tinycss2.serialize(rule.prelude),
                        rule.source_line, rule.source_column)

            if descriptors['src'] is None:
                LOGGER.warning(
                    'No source for profile named %r, the whole '
                    '@color-profile rule was ignored at %d:%d.',
                    tinycss2.serialize(rule.prelude), rule.source_line,
                    rule.source_column)
                continue

            with fetch(url_fetcher, descriptors['src'][1]) as response:
                try:
                    color_profile = ColorProfile(response, descriptors)
                except BaseException:
                    LOGGER.warning(
                        'Invalid profile file for profile named %r, the whole '
                        '@color-profile rule was ignored at %d:%d.',
                        tinycss2.serialize(rule.prelude), rule.source_line,
                        rule.source_column)
                    continue
                else:
                    color_profiles[name] = color_profile

        elif rule.type == 'at-rule' and rule.lower_at_keyword == 'counter-style':
            name = counters.parse_counter_style_name(rule.prelude, counter_style)
            if name is None:
                LOGGER.warning(
                    'Invalid counter style name %r, the whole '
                    '@counter-style rule was ignored at %d:%d.',
                    tinycss2.serialize(rule.prelude), rule.source_line,
                    rule.source_column)
                continue

            ignore_imports = True
            content = tinycss2.parse_blocks_contents(rule.content)
            counter = {
                'system': None,
                'negative': None,
                'prefix': None,
                'suffix': None,
                'range': None,
                'pad': None,
                'fallback': None,
                'symbols': None,
                'additive_symbols': None,
            }
            rule_descriptors = preprocess_descriptors(
                'counter-style', base_url, content)

            for descriptor_name, descriptor_value in rule_descriptors:
                counter[descriptor_name] = descriptor_value

            if counter['system'] is None:
                system = (None, 'symbolic', None)
            else:
                system = counter['system']

            if system[0] is None:
                if system[1] in ('cyclic', 'fixed', 'symbolic'):
                    if len(counter['symbols'] or []) < 1:
                        LOGGER.warning(
                            'In counter style %r at %d:%d, '
                            'counter style %r needs at least one symbol',
                            name, rule.source_line, rule.source_column, system[1])
                        continue
                elif system[1] in ('alphabetic', 'numeric'):
                    if len(counter['symbols'] or []) < 2:
                        LOGGER.warning(
                            'In counter style %r at %d:%d, '
                            'counter style %r needs at least two symbols',
                            name, rule.source_line, rule.source_column, system[1])
                        continue
                elif system[1] == 'additive':
                    if len(counter['additive_symbols'] or []) < 2:
                        LOGGER.warning(
                            'In counter style %r at %d:%d, '
                            'counter style "additive" '
                            'needs at least two additive symbols',
                            name, rule.source_line, rule.source_column)
                        continue

            counter_style[name] = counter

        elif rule.type == 'at-rule' and rule.lower_at_keyword == 'layer':
            new_layers = []
            prelude = remove_whitespace(rule.prelude)
            comma_separated_tokens = split_on_comma(prelude) if prelude else ()
            for tokens in comma_separated_tokens:
                if new_layer := _parse_layer(tokens):
                    if layer is not None:
                        new_layer = f'{layer}.{new_layer}'
                    new_layers.append(new_layer)
                else:
                    new_layers = None
                    break
            if new_layers is None:
                LOGGER.warning(
                    'Unsupported @layer selector %r, '
                    'the whole @layer rule was ignored at %d:%d.',
                    tinycss2.serialize(rule.prelude),
                    rule.source_line, rule.source_column)
                continue
            elif len(new_layers) > 1:
                if rule.content:
                    LOGGER.warning(
                        '@layer rule with multiple layer names, '
                        'the whole @layer rule was ignored at %d:%d.',
                        rule.source_line, rule.source_column)
                    continue
                for new_layer in new_layers:
                    _add_layer(new_layer, layers)
                continue

            if new_layers:
                new_layer, = new_layers
            else:
                new_layer = f'@anonymous{len(layers)}'
                if layer is not None:
                    new_layer = f'{layer}.{new_layer}'
            _add_layer(new_layer, layers)

            if rule.content is None:
                continue
            content_rules = tinycss2.parse_rule_list(rule.content)
            preprocess_stylesheet(
                device_media_type, base_url, content_rules, url_fetcher, matcher,
                page_rules, layers, font_config, counter_style, color_profiles,
                ignore_imports=True, layer=new_layer)

        else:
            LOGGER.warning(
                'Unknown rule %s at %d:%d',
                rule, rule.source_line, rule.source_column)


def get_all_computed_styles(html, user_stylesheets=None, presentational_hints=False,
                            font_config=None, counter_style=None, color_profiles=None,
                            page_rules=None, layers=None, target_collector=None,
                            forms=False):
    """Compute all the computed styles of all elements in ``html`` document.

    Do everything from finding author stylesheets to parsing and applying them.

    Return a ``style_for`` function that takes an element and an optional
    pseudo-element type, and return a style dict object.

    """
    # List stylesheets. Order here is not important ('origin' is).
    sheets = []
    if counter_style is None:
        counter_style = counters.CounterStyle()
    if font_config is None:
        font_config = FontConfiguration()
    for style in html._ua_counter_style():
        for key, value in style.items():
            counter_style[key] = value
    for sheet in (html._ua_stylesheets(forms) or []):
        sheets.append((sheet, 'user agent', None))
    if presentational_hints:
        for sheet in (html._ph_stylesheets() or []):
            sheets.append((sheet, 'author', (0, 0, 0)))
    for sheet in find_stylesheets(
            html.wrapper_element, html.media_type, html.url_fetcher,
            html.base_url, font_config, counter_style, color_profiles, page_rules,
            layers):
        sheets.append((sheet, 'author', None))
    for sheet in (user_stylesheets or []):
        sheets.append((sheet, 'user', None))

    return StyleFor(html, sheets, presentational_hints, font_config, target_collector)


================================================
FILE: weasyprint/css/computed_values.py
================================================
"""Convert specified property values into computed values."""

from functools import partial
from math import pi

from tinycss2.color5 import parse_color

from ..logger import LOGGER
from ..text.line_break import strut
from ..urls import get_link_attribute, get_url_tuple
from .functions import check_math
from .properties import INITIAL_VALUES, ZERO_PIXELS, Dimension
from .units import ANGLE_TO_RADIANS, LENGTH_UNITS, to_pixels
from .validation import validate_non_shorthand

# Value in pixels of font-size for <absolute-size> keywords: 12pt (16px) for
# medium, and scaling factors given in CSS3 for others:
# https://www.w3.org/TR/css-fonts-3/#font-size-prop
FONT_SIZE_KEYWORDS = {
    # medium is 16px, others are a ratio of medium
    name: INITIAL_VALUES['font_size'] * factor
    for name, factor in (
        ('xx-small', 3 / 5),
        ('x-small', 3 / 4),
        ('small', 8 / 9),
        ('medium', 1),
        ('large', 6 / 5),
        ('x-large', 3 / 2),
        ('xx-large', 2),
    )
}

# These are unspecified, other than 'thin' <= 'medium' <= 'thick'.
# Values are in pixels.
BORDER_WIDTH_KEYWORDS = {
    'thin': 1,
    'medium': 3,
    'thick': 5,
}
assert INITIAL_VALUES['border_top_width'] == BORDER_WIDTH_KEYWORDS['medium']

# https://www.w3.org/TR/CSS21/fonts.html#propdef-font-weight
FONT_WEIGHT_RELATIVE = {
    'bolder': {
        100: 400,
        200: 400,
        300: 400,
        400: 700,
        500: 700,
        600: 900,
        700: 900,
        800: 900,
        900: 900,
    },
    'lighter': {
        100: 100,
        200: 100,
        300: 100,
        400: 100,
        500: 100,
        600: 400,
        700: 400,
        800: 700,
        900: 700,
    },
}

# https://www.w3.org/TR/css-page-3/#size
PAGE_SIZES = {
    page_size: (Dimension(width, unit), Dimension(height, unit))
    for page_size, width, height, unit in (
        ('a10', 26, 37, 'mm'),
        ('a9', 37, 52, 'mm'),
        ('a8', 52, 74, 'mm'),
        ('a7', 74, 105, 'mm'),
        ('a6', 105, 148, 'mm'),
        ('a5', 148, 210, 'mm'),
        ('a4', 210, 297, 'mm'),
        ('a3', 297, 420, 'mm'),
        ('a2', 420, 594, 'mm'),
        ('a1', 594, 841, 'mm'),
        ('a0', 841, 1189, 'mm'),
        ('b10', 31, 44, 'mm'),
        ('b9', 44, 62, 'mm'),
        ('b8', 62, 88, 'mm'),
        ('b7', 88, 125, 'mm'),
        ('b6', 125, 176, 'mm'),
        ('b5', 176, 250, 'mm'),
        ('b4', 250, 353, 'mm'),
        ('b3', 353, 500, 'mm'),
        ('b2', 500, 707, 'mm'),
        ('b1', 707, 1000, 'mm'),
        ('b0', 1000, 1414, 'mm'),
        ('c10', 28, 40, 'mm'),
        ('c9', 40, 57, 'mm'),
        ('c8', 57, 81, 'mm'),
        ('c7', 81, 114, 'mm'),
        ('c6', 114, 162, 'mm'),
        ('c5', 162, 229, 'mm'),
        ('c4', 229, 324, 'mm'),
        ('c3', 324, 458, 'mm'),
        ('c2', 458, 648, 'mm'),
        ('c1', 648, 917, 'mm'),
        ('c0', 917, 1297, 'mm'),
        ('jis-b10', 32, 45, 'mm'),
        ('jis-b9', 45, 64, 'mm'),
        ('jis-b8', 64, 91, 'mm'),
        ('jis-b7', 91, 128, 'mm'),
        ('jis-b6', 128, 182, 'mm'),
        ('jis-b5', 182, 257, 'mm'),
        ('jis-b4', 257, 364, 'mm'),
        ('jis-b3', 364, 515, 'mm'),
        ('jis-b2', 515, 728, 'mm'),
        ('jis-b1', 728, 1030, 'mm'),
        ('jis-b0', 1030, 1456, 'mm'),
        ('letter', 8.5, 11, 'in'),
        ('legal', 8.5, 14, 'in'),
        ('ledger', 11, 17, 'in'),
    )
}
# In "portrait" orientation.
assert all(width.value < height.value for width, height in PAGE_SIZES.values())

INITIAL_PAGE_SIZE = PAGE_SIZES['a4']
INITIAL_VALUES['size'] = tuple(
    to_pixels(size, None, 'size') for size in INITIAL_PAGE_SIZE)


# Maps physical to functions getting block and inline directions.
PHYSICAL_FUNCTIONS = {}


def register_logical(names, prefixes=('',), suffixes=('',)):
    """Decorator registering logical properties matching physical ``names``."""

    def decorator(function):
        """Register the properties ``names`` for ``function``."""
        for name in names:
            name = name.replace('-', '_')
            for prefix in prefixes:
                for suffix in suffixes:
                    property_name = name
                    if prefix:
                        property_name = f'{prefix}_{property_name}'
                    if suffix:
                        property_name = f'{property_name}_{suffix}'
                    PHYSICAL_FUNCTIONS[property_name] = partial(
                        function, name=name, prefix=prefix, suffix=suffix)
        return function
    return decorator


@register_logical(('width', 'height'), prefixes=('', 'max', 'min'))
def physical_size(name, prefix, suffix, block, inline):
    vertical_main_direction = block in ('ttb', 'btt')
    vertical_property = 'height' in name
    logical = 'block' if (vertical_property == vertical_main_direction) else 'inline'
    return f'{prefix}_{logical}_size' if prefix else f'{logical}_size'


@register_logical(
    ('top', 'left', 'bottom', 'right'),
    prefixes=('', 'padding', 'margin'))
@register_logical(
    ('top', 'left', 'bottom', 'right'),
    prefixes=('border',), suffixes=('width', 'style', 'color'))
def physical_inset(name, prefix, suffix, block, inline):
    if name == 'top':
        logical = 'block' if block in ('ttb', 'btt') else 'inline'
        side = 'start' if 'ttb' in (block, inline) else 'end'
    elif name == 'bottom':
        logical = 'block' if block in ('ttb', 'btt') else 'inline'
        side = 'start' if 'btt' in (block, inline) else 'end'
    elif name == 'left':
        logical = 'block' if block in ('ltr', 'rtl') else 'inline'
        side = 'start' if 'ltr' in (block, inline) else 'end'
    elif name == 'right':
        logical = 'block' if block in ('ltr', 'rtl') else 'inline'
        side = 'start' if 'rtl' in (block, inline) else 'end'
    prefix = f'{prefix or "inset"}_'
    if suffix:
        suffix = f'_{suffix}'
    return f'{prefix}{logical}_{side}{suffix}'


@register_logical(
    ('top_left', 'top_right', 'bottom_left', 'bottom_right'),
    prefixes=('border',), suffixes=('radius',))
def physical_radius(name, prefix, suffix, block, inline):
    vertical, horizontal = name.split('_')
    if block == 'ttb':
        block = 'start' if vertical == 'top' else 'end'
    elif block == 'btt':
        block = 'start' if vertical == 'bottom' else 'end'
    elif block == 'ltr':
        block = 'start' if horizontal == 'left' else 'end'
    elif block == 'rtl':
        block = 'start' if horizontal == 'right' else 'end'
    if inline == 'ttb':
        inline = 'start' if vertical == 'top' else 'end'
    elif inline == 'btt':
        inline = 'start' if vertical == 'bottom' else 'end'
    elif inline == 'ltr':
        inline = 'start' if horizontal == 'left' else 'end'
    elif inline == 'rtl':
        inline = 'start' if horizontal == 'right' else 'end'
    return f'{prefix}_{block}_{inline}_{suffix}'


# Maps property names to functions returning the computed values
COMPUTER_FUNCTIONS = {}


def register_computer(name):
    """Decorator registering a property ``name`` for a function."""
    name = name.replace('-', '_')

    def decorator(function):
        """Register the property ``name`` for ``function``."""
        COMPUTER_FUNCTIONS[name] = function
        return function
    return decorator


def compute_attr(style, values):
    # TODO: use real token parsing instead of casting with Python types, and follow new
    # syntax. See https://drafts.csswg.org/css-values-5/#attr-notation.
    func_name, value = values
    assert func_name == 'attr()'
    attr_name, type_or_unit, fallback = value
    try:
        attr_value = style.element.get(attr_name, fallback)
        if type_or_unit == 'string':
            pass  # Keep the string
        elif type_or_unit == 'url':
            attr_value = get_url_tuple(attr_value, style.base_url)
        elif type_or_unit == 'color':
            attr_value = parse_color(attr_value.strip(), style['color_scheme'])
        elif type_or_unit == 'integer':
            attr_value = int(attr_value.strip())
        elif type_or_unit == 'number':
            attr_value = float(attr_value.strip())
        elif type_or_unit == '%':
            attr_value = Dimension(float(attr_value.strip()), '%')
            type_or_unit = 'length'
        elif type_or_unit in LENGTH_UNITS:
            attr_value = Dimension(float(attr_value.strip()), type_or_unit)
            type_or_unit = 'length'
        elif type_or_unit in ANGLE_TO_RADIANS:
            attr_value = Dimension(float(attr_value.strip()), type_or_unit)
            type_or_unit = 'angle'
        else:
            return
    except Exception:
        return
    return (type_or_unit, attr_value)


@register_computer('background-image')
def background_image(style, name, values):
    """Compute lenghts in gradient background-image."""
    return tuple(image(style, name, value) for value in values)


@register_computer('border-image-source')
def image(style, name, image):
    """Compute lenghts in gradient border-image-source."""
    type_, value = image
    if type_ in ('linear-gradient', 'radial-gradient'):
        value.stop_positions = tuple(
            length(style, name, pos) if pos is not None else None
            for pos in value.stop_positions)
        value.color_hints = tuple(
            length(style, name, hint) if hint is not None else None
            for hint in value.color_hints)
    if type_ == 'radial-gradient':
        value.center, = compute_position(style, name, (value.center,))
        if value.size_type == 'explicit':
            value.size = length_or_percentage_tuple(style, name, value.size)
    return image


@register_computer('color')
@register_computer('background-color')
@register_computer('border-top-color')
@register_computer('border-right-color')
@register_computer('border-bottom-color')
@register_computer('border-left-color')
@register_computer('column-rule-color')
@register_computer('outline-color')
@register_computer('text-decoration-color')
def color(style, name, values):
    return parse_color(values, style['color_scheme'])


@register_computer('background-position')
@register_computer('object-position')
def compute_position(style, name, values):
    """Compute lengths in background-position."""
    return tuple(
        (origin_x, length(style, name, pos_x),
         origin_y, length(style, name, pos_y))
        for origin_x, pos_x, origin_y, pos_y in values)


@register_computer('transform-origin')
def length_or_percentage_tuple(style, name, values):
    """Compute the lists of lengths that can be percentages."""
    return tuple(length(style, name, value) for value in values)


@register_computer('border-spacing')
@register_computer('size')
@register_computer('clip')
def length_tuple(style, name, values):
    """Compute the properties with a list of lengths."""
    return tuple(length(style, name, value, pixels_only=True) for value in values)


@register_computer('break-after')
@register_computer('break-before')
def break_before_after(style, name, value):
    """Compute the ``break-before`` and ``break-after`` properties."""
    return 'page' if value == 'always' else value


@register_computer('top')
@register_computer('right')
@register_computer('left')
@register_computer('bottom')
@register_computer('margin-top')
@register_computer('margin-right')
@register_computer('margin-bottom')
@register_computer('margin-left')
@register_computer('height')
@register_computer('width')
@register_computer('block-size')
@register_computer('inline-size')
@register_computer('min-width')
@register_computer('min-height')
@register_computer('min-block-size')
@register_computer('min-inline-size')
@register_computer('max-width')
@register_computer('max-height')
@register_computer('max-block-size')
@register_computer('max-inline-size')
@register_computer('padding-top')
@register_computer('padding-right')
@register_computer('padding-bottom')
@register_computer('padding-left')
@register_computer('text-indent')
@register_computer('hyphenate-limit-zone')
@register_computer('flex-basis')
@register_computer('text-underline-offset')
@register_computer('text-decoration-thickness')
def length(style, name, value, font_size=None, pixels_only=False):
    """Compute a length ``value``."""
    if value in ('auto', 'content', 'from-font') or check_math(value):
        return value
    elif value.value == 0:
        return 0 if pixels_only else ZERO_PIXELS
    elif value.unit not in LENGTH_UNITS:
        # A percentage or 'auto': no conversion needed.
        return value

    pixels = to_pixels(value, style, name, font_size)
    return pixels if pixels_only else Dimension(pixels, 'px')


@register_computer('bleed-left')
@register_computer('bleed-right')
@register_computer('bleed-top')
@register_computer('bleed-bottom')
def bleed(style, name, value):
    if value == 'auto':
        return Dimension(8 if 'crop' in style['marks'] else 0, 'px')
    return length(style, name, value)


@register_computer('letter-spacing')
def pixel_length(style, name, value):
    if value == 'normal':
        return value
    return length(style, name, value, pixels_only=True)


@register_computer('background-size')
def background_size(style, name, values):
    """Compute the ``background-size`` properties."""
    return tuple(
        value if value in ('contain', 'cover') else
        length_or_percentage_tuple(style, name, value)
        for value in values)


@register_computer('image-orientation')
def image_orientation(style, name, values):
    """Compute the ``image-orientation`` properties."""
    if values in ('none', 'from-image'):
        return values
    angle, flip = values
    return (round(angle / pi * 2) % 4 * 90, flip)


@register_computer('border-top-width')
@register_computer('border-right-width')
@register_computer('border-left-width')
@register_computer('border-bottom-width')
@register_computer('column-rule-width')
@register_computer('outline-width')
def border_width(style, name, value):
    """Compute the ``border-*-width`` properties."""
    border_style = style[name.replace('width', 'style')]
    if border_style in ('none', 'hidden'):
        return 0

    if value in BORDER_WIDTH_KEYWORDS:
        return BORDER_WIDTH_KEYWORDS[value]

    if isinstance(value, int):
        # The initial value can get here, but length() would fail as
        # it does not have a 'unit' attribute.
        return value

    return length(style, name, value, pixels_only=True)


@register_computer('border-image-slice')
@register_computer('mask-border-slice')
def border_image_slice(style, name, values):
    """Compute the ``border-image-slice`` property."""
    computed_values = []
    fill = None
    for value in values:
        if value == 'fill':
            fill = value
        else:
            number, unit = value
            if unit is None:
                computed_values.append(number)
            else:
                computed_values.append(Dimension(number, '%'))
    if len(computed_values) == 1:
        computed_values *= 4
    elif len(computed_values) == 2:
        computed_values *= 2
    elif len(computed_values) == 3:
        computed_values.append(computed_values[1])
    return (*computed_values, fill)


@register_computer('border-image-width')
@register_computer('mask-border-width')
def border_image_width(style, name, values):
    """Compute the ``border-image-width`` property."""
    computed_values = []
    for value in values:
        if value == 'auto':
            computed_values.append(value)
        else:
            number, unit = value
            computed_values.append(number if unit is None else value)
    if len(computed_values) == 1:
        computed_values *= 4
    elif len(computed_values) == 2:
        computed_values *= 2
    elif len(computed_values) == 3:
        computed_values.append(computed_values[1])
    return tuple(computed_values)


@register_computer('border-image-outset')
@register_computer('mask-border-outset')
def border_image_outset(style, name, values):
    """Compute the ``border-image-outset`` property."""
    computed_values = [
        value if isinstance(value, (int, float)) else length(style, name, value)
        for value in values]
    if len(computed_values) == 1:
        computed_values *= 4
    elif len(computed_values) == 2:
        computed_values *= 2
    elif len(computed_values) == 3:
        computed_values.append(computed_values[1])
    return tuple(computed_values)


@register_computer('border-image-repeat')
@register_computer('mask-border-repeat')
def border_image_repeat(style, name, values):
    """Compute the ``border-image-repeat`` property."""
    return (values * 2) if len(values) == 1 else values


@register_computer('column-width')
@register_computer('outline-offset')
def length_pixels_only(style, name, value):
    """Compute a pixel length property."""
    return length(style, name, value, pixels_only=True)


@register_computer('border-top-left-radius')
@register_computer('border-top-right-radius')
@register_computer('border-bottom-left-radius')
@register_computer('border-bottom-right-radius')
def border_radius(style, name, values):
    """Compute the ``border-*-radius`` properties."""
    return tuple(length(style, name, value) for value in values)


@register_computer('column-gap')
@register_computer('row-gap')
def gap(style, name, value):
    """Compute the ``*-gap`` properties."""
    return value if value == 'normal' else length(style, name, value)


def _content_list(style, values):
    computed_values = []
    for value in values:
        if value[0] in ('string', 'content', 'url', 'quote', 'leader()'):
            computed_value = value
        elif value[0] == 'attr()':
            assert value[1][1] == 'string'
            computed_value = compute_attr(style, value)
        elif value[0] in (
                'counter()', 'counters()', 'content()', 'element()',
                'string()'):
            # Other values need layout context, their computed value cannot be
            # better than their specified value yet.
            # See build.compute_content_list.
            computed_value = value
        elif value[0] in (
                'target-counter()', 'target-counters()', 'target-text()'):
            anchor_token = value[1][0]
            if anchor_token[0] == 'attr()':
                attr = compute_attr(style, anchor_token)
                if attr is None:
                    computed_value = None
                else:
                    computed_value = (value[0], (attr, *value[1][1:]))
            else:
                computed_value = value
        if computed_value is None:
            LOGGER.warning('Unable to compute %r value for content: %r' % (
                style.element, ', '.join(str(item) for item in value)))
        else:
            computed_values.append(computed_value)

    return tuple(computed_values)


@register_computer('bookmark-label')
def bookmark_label(style, name, values):
    """Compute the ``bookmark-label`` property."""
    return _content_list(style, values)


@register_computer('string-set')
def string_set(style, name, values):
    """Compute the ``string-set`` property."""
    # Spec asks for strings after custom keywords, but we allow content-lists
    return tuple(
        (string_set[0], _content_list(style, string_set[1]))
        for string_set in values)


@register_computer('content')
def content(style, name, values):
    """Compute the ``content`` property."""
    if len(values) == 1:
        value, = values
        if value == 'normal':
            return 'inhibit' if style.pseudo_type else 'contents'
        elif value == 'none':
            return 'inhibit'
    return _content_list(style, values)


@register_computer('display')
def display(style, name, value):
    """Compute the ``display`` property."""
    # See https://www.w3.org/TR/CSS21/visuren.html#dis-pos-flo.
    float_ = style.specified['float']
    position = style.specified['position']
    if position in ('absolute', 'fixed') or float_ != 'none' or style.is_root_element:
        if value == ('inline-table',):
            return ('block', 'table')
        elif len(value) == 1 and value[0].startswith('table-'):
            return ('block', 'flow')
        elif value[0] == 'inline':
            if 'list-item' in value:
                return ('block', 'flow', 'list-item')
            else:
                return ('block', 'flow')
    return value


@register_computer('float')
def compute_float(style, name, value):
    """Compute the ``float`` property."""
    # See https://www.w3.org/TR/CSS21/visuren.html#dis-pos-flo.
    position = style.specified['position']
    if position in ('absolute', 'fixed') or position[0] == 'running()':
        return 'none'
    else:
        return value


@register_computer('font-size')
def font_size(style, name, value):
    """Compute the ``font-size`` property."""
    if value in FONT_SIZE_KEYWORDS:
        return FONT_SIZE_KEYWORDS[value]

    keyword_values = list(FONT_SIZE_KEYWORDS.values())
    if style.parent_style is None:
        parent_font_size = INITIAL_VALUES['font_size']
    else:
        parent_font_size = style.parent_style['font_size']

    if value == 'larger':
        for i, keyword_value in enumerate(keyword_values):
            if keyword_value > parent_font_size:
                return keyword_values[i]
        else:
            return parent_font_size * 1.2
    elif value == 'smaller':
        for i, keyword_value in enumerate(keyword_values[::-1]):
            if keyword_value < parent_font_size:
                return keyword_values[-i - 1]
        else:
            return parent_font_size * 0.8
    elif isinstance(value, Dimension) and value.unit == '%':
        return value.value * parent_font_size / 100
    else:
        return length(
            style, name, value, pixels_only=True,
            font_size=parent_font_size)


@register_computer('font-weight')
def font_weight(style, name, value):
    """Compute the ``font-weight`` property."""
    if value == 'normal':
        return 400
    elif value == 'bold':
        return 700
    elif value in ('bolder', 'lighter'):
        if style.parent_style is None:
            parent_value = INITIAL_VALUES['font_weight']
        else:
            parent_value = style.parent_style['font_weight']
        return FONT_WEIGHT_RELATIVE[value][parent_value]
    else:
        return value


def _compute_track_breadth(style, name, value):
    """Compute track breadth."""
    if value in ('auto', 'min-content', 'max-content'):
        return value
    elif isinstance(value, Dimension):
        if value.unit and value.unit.lower() == 'fr':
            return value
        else:
            return length(style, name, value)


def _track_size(style, name, values):
    """Compute track size."""
    return_values = []
    for i, value in enumerate(values):
        if i % 2 == 0:
            # line name
            return_values.append(value)
        else:
            # track section
            track_breadth = _compute_track_breadth(style, name, value)
            if track_breadth:
                return_values.append(track_breadth)
            elif value[0] == 'minmax()':
                return_values.append((
                    'minmax()',
                    _compute_track_breadth(style, name, value[1]),
                    _compute_track_breadth(style, name, value[2])))
            elif value[0] == 'fit-content()':
                return_values.append((
                    'fit-content()', length(style, name, value[1])))
            elif value[0] == 'repeat()':
                return_values.append((
                    'repeat()', value[1], _track_size(style, name, value[2])))
    return tuple(return_values)


@register_computer('grid-template-columns')
@register_computer('grid-template-rows')
def grid_template(style, name, values):
    """Compute the ``grid-template-*`` properties."""
    if values == 'none' or values[0] == 'subgrid':
        return values
    else:
        return _track_size(style, name, values)


@register_computer('grid-auto-columns')
@register_computer('grid-auto-rows')
def grid_auto(style, name, values):
    """Compute the ``grid-auto-*`` properties."""
    return_values = []
    for value in values:
        track_breadth = _compute_track_breadth(style, name, value)
        if track_breadth:
            return_values.append(track_breadth)
        elif value[0] == 'minmax()':
            return_values.append((
                'minmax()', grid_auto(style, name, [value[1]])[0],
                grid_auto(style, name, [value[2]])[0]))
        elif value[0] == 'fit-content()':
            return_values.append((
                'fit-content()', grid_auto(style, name, [value[1]])[0]))
    return tuple(return_values)


@register_computer('line-height')
def line_height(style, name, value):
    """Compute the ``line-height`` property."""
    if value == 'normal':
        return value
    elif not value.unit:
        return ('NUMBER', value.value)
    elif value.unit == '%':
        factor = value.value / 100
        font_size_value = style['font_size']
        pixels = factor * font_size_value
    else:
        pixels = length(style, name, value, pixels_only=True)
    return ('PIXELS', pixels)


@register_computer('anchor')
def anchor(style, name, values):
    """Compute the ``anchor`` property."""
    if values != 'none':
        _, key = values
        anchor_name = style.element.get(key) or None
        return anchor_name


@register_computer('link')
def link(style, name, values):
    """Compute the ``link`` property."""
    if values == 'none':
        return
    type_, value = values
    if type_ == 'attr()':
        return get_link_attribute(style.element, value, style.base_url)
    return values


@register_computer('lang')
def lang(style, name, values):
    """Compute the ``lang`` property."""
    if values == 'none':
        return
    name, key = values
    if name == 'attr()':
        return style.element.get(key) or None
    elif name == 'string':
        return key


@register_computer('tab-size')
def tab_size(style, name, value):
    """Compute the ``tab-size`` property."""
    return value if isinstance(value, int) else length(style, name, value)


@register_computer('transform')
def transform(style, name, value):
    """Compute the ``transform`` property."""
    result = []
    for function, args in value:
        if function == 'translate':
            args = length_or_percentage_tuple(style, name, args)
        result.append((function, args))
    return tuple(result)


@register_computer('vertical-align')
def vertical_align(style, name, value):
    """Compute the ``vertical-align`` property."""
    from ..css import resolve_math

    # Use +/- half an em for super and sub, same as Pango.
    # (See the SUPERSUB_RISE constant in pango-markup.c)
    if check_math(value):
        height, _ = strut(style)
        result = resolve_math(value, style, 'vertical_align', height)
        value = validate_non_shorthand((result,), 'vertical-align')[0][1]
        if value is None:
            value = 'baseline'
    if value in ('baseline', 'middle', 'text-top', 'text-bottom', 'top', 'bottom'):
        return value
    elif value == 'super':
        return style['font_size'] * 0.5
    elif value == 'sub':
        return style['font_size'] * -0.5
    elif value.unit == '%':
        height, _ = strut(style)
        return height * value.value / 100
    else:
        return length(style, name, value, pixels_only=True)


@register_computer('word-spacing')
def word_spacing(style, name, value):
    """Compute the ``word-spacing`` property."""
    return 0 if value == 'normal' else length(style, name, value, pixels_only=True)


================================================
FILE: weasyprint/css/counters.py
================================================
"""Implement counter styles.

These are defined in CSS Counter Styles Level 3:
https://www.w3.org/TR/css-counter-styles-3/#counter-style-system

"""

from math import inf

from .tokens import remove_whitespace


def symbol(string_or_url):
    """Create a string from a symbol."""
    # TODO: this function should handle images too, and return something else
    # than strings.
    type_, value = string_or_url
    if type_ == 'string':
        return value
    return ''


def parse_counter_style_name(tokens, counter_style):
    tokens = remove_whitespace(tokens)
    if len(tokens) == 1:
        token, = tokens
        if token.type == 'ident':
            if token.lower_value in ('decimal', 'disc'):
                if token.lower_value not in counter_style:
                    return token.value
            elif token.lower_value != 'none':
                return token.value


class CounterStyle(dict):
    """Counter styles dictionary.

    Keep a list of counter styles defined by ``@counter-style`` rules, indexed
    by their names.

    See https://www.w3.org/TR/css-counter-styles-3/.

    """
    def resolve_counter(self, counter_name, previous_types=None):
        if counter_name[0] in ('symbols()', 'string'):
            counter_type, arguments = counter_name
            if counter_type == 'string':
                system = (None, 'cyclic', None)
                symbols = (('string', arguments),)
                suffix = ('string', '')
            elif counter_type == 'symbols()':
                system = (
                    None, arguments[0], 1 if arguments[0] == 'fixed' else None)
                symbols = tuple(
                    ('string', argument) for argument in arguments[1:])
                suffix = ('string', ' ')
            return {
                'system': system,
                'negative': (('string', '-'), ('string', '')),
                'prefix': ('string', ''),
                'suffix': suffix,
                'range': 'auto',
                'pad': (0, ''),
                'fallback': 'decimal',
                'symbols': symbols,
                'additive_symbols': (),
            }
        elif counter_name in self:
            # Avoid circular fallbacks
            if previous_types is None:
                previous_types = []
            elif counter_name in previous_types:
                return
            previous_types.append(counter_name)

            counter = self[counter_name].copy()
            if counter['system']:
                extends, system, _ = counter['system']
            else:
                extends, system = None, 'symbolic'

            # Handle extends
            while extends:
                if system in self:
                    extended_counter = self[system]
                    counter['system'] = extended_counter['system']
                    previous_types.append(system)
                    if counter['system']:
                        extends, system, _ = counter['system']
                    else:
                        extends, system = None, 'symbolic'
                    if extends and system in previous_types:
                        extends, system = 'extends', 'decimal'
                        continue
                    for name, value in extended_counter.items():
                        if counter[name] is None and value is not None:
                            counter[name] = value
                else:
                    return counter

            return counter

    def render_value(self, counter_value, counter_name=None, counter=None,
                     previous_types=None):
        """Generate the counter representation.

        See https://www.w3.org/TR/css-counter-styles-3/#generate-a-counter

        """
        assert counter or counter_name
        counter = counter or self.resolve_counter(counter_name, previous_types)
        if counter is None:
            if 'decimal' in self:
                return self.render_value(counter_value, 'decimal')
            else:
                # Could happen if the UA stylesheet is not used
                return ''

        if counter['system']:
            extends, system, fixed_number = counter['system']
        else:
            extends, system, fixed_number = None, 'symbolic', None

        # Avoid circular fallbacks
        if previous_types is None:
            previous_types = []
        elif system in previous_types:
            return self.render_value(counter_value, 'decimal')
        previous_types.append(counter_name)

        # Handle extends
        while extends:
            if system in self:
                extended_counter = self[system]
                counter['system'] = extended_counter['system']
                if counter['system']:
                    extends, system, fixed_number = counter['system']
                else:
                    extends, system, fixed_number = None, 'symbolic', None
                if system in previous_types:
                    return self.render_value(counter_value, 'decimal')
                previous_types.append(system)
                for name, value in extended_counter.items():
                    if counter[name] is None and value is not None:
                        counter[name] = value
            else:
                return self.render_value(counter_value, 'decimal')

        # Step 2
        if counter['range'] in ('auto', None):
            min_range, max_range = -inf, inf
            if system in ('alphabetic', 'symbolic'):
                min_range = 1
            elif system == 'additive':
                min_range = 0
            counter_ranges = ((min_range, max_range),)
        else:
            counter_ranges = counter['range']
        for min_range, max_range in counter_ranges:
            if min_range <= counter_value <= max_range:
                break
        else:
            return self.render_value(
                counter_value, counter['fallback'] or 'decimal',
                previous_types=previous_types)

        # Step 3
        initial = None
        is_negative = counter_value < 0
        if is_negative:
            negative_prefix, negative_suffix = (
                symbol(character) for character
                in counter['negative'] or (('string', '-'), ('string', '')))
            use_negative = (
                system in
                ('symbolic', 'alphabetic', 'numeric', 'additive'))
            if use_negative:
                counter_value = abs(counter_value)

        # TODO: instead of using the decimal fallback when we have the wrong
        # number of symbols, we should discard the whole counter. The problem
        # only happens when extending from another style, it is easily refused
        # during validation otherwise.

        if system == 'cyclic':
            length = len(counter['symbols'])
            if length < 1:
                return self.render_value(counter_value, 'decimal')
            index = (counter_value - 1) % length
            initial = symbol(counter['symbols'][index])

        elif system == 'fixed':
            length = len(counter['symbols'])
            if length < 1:
                return self.render_value(counter_value, 'decimal')
            index = counter_value - fixed_number
            if 0 <= index < length:
                initial = symbol(counter['symbols'][index])
            else:
                return self.render_value(
                    counter_value, counter['fallback'] or 'decimal',
                    previous_types=previous_types)

        elif system == 'symbolic':
            length = len(counter['symbols'])
            if length < 1:
                return self.render_value(counter_value, 'decimal')
            index = (counter_value - 1) % length
            repeat = (counter_value - 1) // length + 1
            initial = symbol(counter['symbols'][index]) * repeat

        elif system == 'alphabetic':
            length = len(counter['symbols'])
            if length < 2:
                return self.render_value(counter_value, 'decimal')
            reversed_parts = []
            while counter_value != 0:
                counter_value -= 1
                reversed_parts.append(symbol(
                    counter['symbols'][counter_value % length]))
                counter_value //= length
            initial = ''.join(reversed(reversed_parts))

        elif system == 'numeric':
            if counter_value == 0:
                initial = symbol(counter['symbols'][0])
            else:
                reversed_parts = []
                length = len(counter['symbols'])
                if length < 2:
                    return self.render_value(counter_value, 'decimal')
                counter_value = abs(counter_value)
                while counter_value != 0:
                    reversed_parts.append(symbol(
                        counter['symbols'][counter_value % length]))
                    counter_value //= length
                initial = ''.join(reversed(reversed_parts))

        elif system == 'additive':
            if counter_value == 0:
                for weight, symbol_string in counter['additive_symbols']:
                    if weight == 0:
                        initial = symbol(symbol_string)
            else:
                parts = []
                if len(counter['additive_symbols']) < 1:
                    return self.render_value(counter_value, 'decimal')
                for weight, symbol_string in counter['additive_symbols']:
                    repetitions = counter_value // weight
                    parts.extend([symbol(symbol_string)] * repetitions)
                    counter_value -= weight * repetitions
                    if counter_value == 0:
                        initial = ''.join(parts)
                        break
            if initial is None:
                return self.render_value(
                    counter_value, counter['fallback'] or 'decimal',
                    previous_types=previous_types)

        assert initial is not None

        # Step 4
        pad = counter['pad'] or (0, '')
        pad_difference = pad[0] - len(initial)
        if is_negative and use_negative:
            pad_difference -= len(negative_prefix) + len(negative_suffix)
        if pad_difference > 0:
            initial = pad_difference * symbol(pad[1]) + initial

        # Step 5
        if is_negative and use_negative:
            initial = negative_prefix + initial + negative_suffix

        # Step 6
        return initial

    def render_marker(self, counter_name, counter_value):
        """Generate the content of a ::marker pseudo-element."""
        counter = self.resolve_counter(counter_name)
        if counter is None:
            if 'decimal' in self:
                return self.render_marker('decimal', counter_value)
            else:
                # Could happen if the UA stylesheet is not used
                return ''

        prefix = symbol(counter['prefix'] or ('string', ''))
        suffix = symbol(counter['suffix'] or ('string', '. '))

        value = self.render_value(counter_value, counter_name=counter_name)
        assert value is not None
        return prefix + value + suffix

    def copy(self):
        # Values are dicts but they are never modified, no need to deepcopy
        return CounterStyle(super().copy())


================================================
FILE: weasyprint/css/functions.py
================================================
"""CSS functions parsers."""


class Function:
    """CSS function."""
    # See https://drafts.csswg.org/css-values-4/#functional-notation.

    def __init__(self, token):
        """Create Function from function token."""
        if getattr(token, 'type', None) == 'function':
            self.name = token.lower_name
            self.arguments = token.arguments
        else:
            self.name = self.arguments = None

    def split_space(self):
        """Split arguments on spaces."""
        if self.arguments is not None:
            return [
                argument for argument in self.arguments
                if argument.type not in ('whitespace', 'comment')]

    def split_comma(self, single_tokens=True, trailing=False):
        """Split arguments on commas.

        Spaces in parentheses and after commas are removed.

        If ``single_tokens`` is ``True``, check that only a single token is between
        commas and flatten returned list.

        If ``trailing`` is ``True``, allow a bare comma at the end.

        """
        if self.arguments is None:
            return

        parts = [[]]
        for token in self.arguments:
            if token.type == 'literal' and token.value == ',':
                parts.append([])
                continue
            if token.type not in ('comment', 'whitespace'):
                parts[-1].append(token)

        if trailing:
            if single_tokens:
                if all(len(part) == 1 for part in parts[:-1]):
                    if len(parts[-1]) in (0, 1):
                        return [part[0] if part else None for part in parts[:-1]]
            elif all(parts[:-1]):
                return parts
        else:
            if single_tokens:
                if all(len(part) == 1 for part in parts):
                    return [part[0] for part in parts]
            elif all(parts):
                return parts
        return []


def check_attr(token, allowed_type=None):
    function = Function(token)
    if function.name != 'attr':
        return

    parts = function.split_comma(single_tokens=False, trailing=True)
    if len(parts) == 1:
        name_and_type, fallback = parts[0], ''
    elif len(parts) == 2:
        name_and_type, fallback = parts
        # TODO: support fallbacks with multiple tokens and follow type.
        if len(fallback) >= 1 and fallback[0].type == 'string':
            fallback = fallback[0].value
        else:
            fallback = ''
    else:
        return

    if any(token.type != 'ident' for token in name_and_type):
        return
    # TODO: follow new syntax, see https://drafts.csswg.org/css-values-5/#attr-notation.

    name = name_and_type[0].value
    type_or_unit = name_and_type[1].value if len(name_and_type) == 2 else 'string'
    if allowed_type in (None, type_or_unit):
        return ('attr()', (name, type_or_unit, fallback))


def check_counter(token, allowed_type=None):
    from .validation.properties import list_style_type

    function = Function(token)
    arguments = function.split_comma()
    if function.name == 'counter':
        if len(arguments) not in (1, 2):
            return
    elif function.name == 'counters':
        if len(arguments) not in (2, 3):
            return
    else:
        return

    result = []
    ident = arguments.pop(0)
    if ident.type != 'ident':
        return
    result.append(ident.value)

    if function.name == 'counters':
        string = arguments.pop(0)
        if string.type != 'string':
            return
        result.append(string.value)

    if arguments:
        counter_style = list_style_type((arguments.pop(0),))
        if counter_style is None:
            return
        result.append(counter_style)
    else:
        result.append('decimal')

    return (f'{function.name}()', tuple(result))


def check_content(token):
    function = Function(token)
    if function.name == 'content':
        arguments = function.split_comma()
        if len(arguments) == 0:
            return ('content()', 'text')
        elif len(arguments) == 1:
            ident = arguments.pop(0)
            values = ('text', 'before', 'after', 'first-letter', 'marker')
            if ident.type == 'ident' and ident.lower_value in values:
                return ('content()', ident.lower_value)


def check_string_or_element(string_or_element, token):
    function = Function(token)
    arguments = function.split_comma()
    if function.name == string_or_element and len(arguments) in (1, 2):
        custom_ident = arguments.pop(0)
        if custom_ident.type != 'ident':
            return
        custom_ident = custom_ident.value

        if arguments:
            ident = arguments.pop(0)
            if ident.type != 'ident':
                return
            if ident.lower_value not in ('first', 'start', 'last', 'first-except'):
                return
            ident = ident.lower_value
        else:
            ident = 'first'

        return (f'{string_or_element}()', (custom_ident, ident))


def check_var(token):
    if token.type == '() block':
        return any(check_var(item) for item in token.content)
    function = Function(token)
    if function.name is None:
        return
    arguments = function.split_space()
    if function.name == 'var':
        ident = arguments[0]
        # TODO: we should check authorized tokens
        # https://drafts.csswg.org/css-syntax-3/#typedef-declaration-value
        return ident.type == 'ident' and ident.value.startswith('--')
    return any(check_var(argument) for argument in arguments)


def check_math(token):
    # TODO: validate for real.
    function = Function(token)
    if (name := function.name) is None:
        return
    arguments = function.split_comma(single_tokens=False)
    if name == 'calc':
        return len(arguments) == 1
    elif name in ('min', 'max'):
        return len(arguments) >= 1
    elif name == 'clamp':
        return len(arguments) == 3
    elif name == 'round':
        return 1 <= len(arguments) <= 3
    elif name in ('mod', 'rem'):
        return len(arguments) == 2
    elif name in ('sin', 'cos', 'tan'):
        return len(arguments) == 1
    elif name in ('asin', 'acos', 'atan'):
        return len(arguments) == 1
    elif name == 'atan2':
        return len(arguments) == 2
    elif name == 'pow':
        return len(arguments) == 2
    elif name == 'sqrt':
        return len(arguments) == 1
    elif name == 'hypot':
        return len(arguments) >= 1
    elif name == 'log':
        return 1 <= len(arguments) <= 2
    elif name == 'exp':
        return len(arguments) == 1
    elif name in ('abs', 'sign'):
        return len(arguments) == 1
    arguments = function.split_space()
    return any(check_math(argument) for argument in arguments)


================================================
FILE: weasyprint/css/html5_ph.css
================================================
/*

Presentational hints stylsheet for HTML.

This stylesheet contains all the presentational hints rules that can be
expressed as CSS.

See https://www.w3.org/TR/html5/rendering.html#rendering

TODO: Attribute values are not case-insensitive, but they should be. We can add
a "i" flag when CSS Selectors Level 4 is supported.

*/

pre[wrap] { white-space: pre-wrap }

br[clear=left i] { clear: left }
br[clear=right i] { clear: right }
br[clear=all i], br[clear=both i] { clear: both }

:is(ol, li)[type="1"] { list-style-type: decimal }
:is(ol, li)[type=a] { list-style-type: lower-alpha }
:is(ol, li)[type=A] { list-style-type: upper-alpha }
:is(ol, li)[type=i] { list-style-type: lower-roman }
:is(ol, li)[type=I] { list-style-type: upper-roman }
:is(ul, li)[type=disc i] { list-style-type: disc }
:is(ul, li)[type=circle i] { list-style-type: circle }
:is(ul, li)[type=square i] { list-style-type: square }

table[align=left i] { float: left }
table[align=right i] { float: right }
table[align=center i] { margin-left: auto; margin-right: auto }
:is(thead, tbody, tfoot, tr, td, th)[align=absmiddle i] { text-align: center }

caption[align=bottom i] { caption-side: bottom }
:is(p, h1, h2, h3, h4, h5, h6)[align=left i] { text-align: left }
:is(p, h1, h2, h3, h4, h5, h6)[align=right i] { text-align: right }
:is(p, h1, h2, h3, h4, h5, h6)[align=center i] { text-align: center }
:is(p, h1, h2, h3, h4, h5, h6)[align=justify i] { text-align: justify }
:is(thead, tbody, tfoot, tr, td, th)[valign=top i] { vertical-align: top }
:is(thead, tbody, tfoot, tr, td, th)[valign=middle i] { vertical-align: middle }
:is(thead, tbody, tfoot, tr, td, th)[valign=bottom i] { vertical-align: bottom }
:is(thead, tbody, tfoot, tr, td, th)[valign=baseline i] { vertical-align: baseline }

:is(td, th)[nowrap] { white-space: nowrap }

table:is([rules=none i], [rules=groups i], [rules=rows i], [rules=cols i]) { border-style: hidden; border-collapse: collapse }
table[border]:not([border="0 i"]) { border-style: outset }
table[frame=void i] { border-style: hidden }
table[frame=above i] { border-style: outset hidden hidden hidden }
table[frame=below i] { border-style: hidden hidden outset hidden }
table[frame=hsides i] { border-style: outset hidden outset hidden }
table[frame=lhs i] { border-style: hidden hidden hidden outset }
table[frame=rhs i] { border-style: hidden outset hidden hidden }
table[frame=vsides i] { border-style: hidden outset }
table[frame=box i], table[frame=border i] { border-style: outset }

table[border]:not([border="0"]) > tr > :is(td, th), table[border]:not([border="0"]) > :is(thead, tbody, tfoot) > tr > :is(td, th) { border-width: 1px; border-style: inset }
table:is([rules=none i], [rules=groups i], [rules=rows i]) > tr > :is(td, th), table:is([rules=none i], [rules=groups i], [rules=rows i]) > :is(thead, tbody, tfoot) > tr > :is(td, th) { border-width: 1px; border-style: none }
table[rules=cols i] > tr > :is(td, th), table[rules=cols i] > :is(thead, tbody, tfoot) > tr > :is(td, th) { border-width: 1px; border-style: none solid }
table[rules=all i] > tr > :is(td, th), table[rules=all i] > :is(thead, tbody, tfoot) > tr > :is(td, th) { border-width: 1px; border-style: solid }
table[rules=groups i] > colgroup { border-left-width: 1px; border-left-style: solid; border-right-width: 1px; border-right-style: solid }
table[rules=groups i] > :is(thead, tbody, tfoot) { border-top-width: 1px; border-top-style: solid; border-bottom-width: 1px; border-bottom-style: solid }
table[rules=rows i] > tr, table[rules=rows i] > :is(thead, tbody, tfoot) > tr { border-top-width: 1px; border-top-style: solid; border-bottom-width: 1px; border-bottom-style: solid }

hr[align=left i] { margin-left: 0; margin-right: auto }
hr[align=right i] { margin-left: auto; margin-right: 0 }
hr[align=center i] { margin-left: auto; margin-right: auto }
hr[color], hr[noshade] { border-style: solid }

iframe[frameborder="0"], iframe[frameborder=no i] { border: none }

:is(applet, embed, iframe, img, input, object)[align=left i] { float: left }
:is(applet, embed, iframe, img, input, object)[align=right i] { float: right }
:is(applet, embed, iframe, img, input, object)[align=top i] { vertical-align: top }
:is(applet, embed, iframe, img, input, object)[align=baseline i] { vertical-align: baseline }
:is(applet, embed, iframe, img, input, object)[align=texttop i] { vertical-align: text-top }
:is(applet, embed, iframe, img, input, object):is([align=middle i], [align=absmiddle i], [align=absmiddle i]) { vertical-align: middle }
:is(applet, embed, iframe, img, input, object)[align=bottom i] { vertical-align: bottom }


================================================
FILE: weasyprint/css/html5_ua.css
================================================
/*

User agent stylsheet for HTML.

Contributed by Peter Moulder.
Based on suggested styles in the HTML5 specification, CSS 2.1, and
what various web browsers use.

https://dev.w3.org/html5/spec-LC/rendering.html#the-css-user-agent-style-sheet-and-presentational-hints

*/

/* WeasyPrint-only features */

[id] { -weasy-anchor: attr(id) }
a[name] { -weasy-anchor: attr(name) }
[lang] { -weasy-lang: attr(lang) }
a[href] { -weasy-link: attr(href) }

/* Display and visibility */

[hidden], area, base, basefont, command, datalist, head, input[type=hidden i], link, menu[type=context i], meta, noembed, noframes, param, rp, script, source, style, template, title, track { display: none }
address, article, aside, blockquote, body, center, dd, details, dir, div, dl, dt, frame, frameset, fieldset, figure, figcaption, footer, form, h1, h2, h3, h4, h5, h6, header, hgroup, hr, html, legend, listing, main, menu, nav, ol, p, plaintext, pre, section, summary, ul, xmp { display: block }
button, input, keygen, select, textarea { display: inline-block }
li { display: list-item }
table { display: table }
caption { display: table-caption }
colgroup, colgroup[hidden] { display: table-column-group }
col, col[hidden] { display: table-column }
thead, thead[hidden] { display: table-header-group }
tbody, tbody[hidden] { display: table-row-group }
tfoot, tfoot[hidden] { display: table-footer-group }
tr, tr[hidden] { display: table-row }
td, th, td[hidden], th[hidden] { display: table-cell }
:is(colgroup, col, thead, tbody, tfoot, tr, td, th)[hidden] { visibility: collapse }

/* Margins and padding */

blockquote, dir, dl, figure, listing, menu, ol, p, plaintext, pre, ul, xmp { margin-top: 1em; margin-bottom: 1em }
:is(dir, dl, menu, ol, ul) :is(dir, dl, menu, ol, ul) { margin-top: 0; margin-bottom: 0 }

body { margin: 8px }

h1 { margin-top: .67em; margin-bottom: .67em }
h2 { margin-top: .83em; margin-bottom: .83em }
h3 { margin-top: 1em; margin-bottom: 1em }
h4 { margin-top: 1.33em; margin-bottom: 1.33em }
h5 { margin-top: 1.67em; margin-bottom: 1.67em }
h6 { margin-top: 2.33em; margin-bottom: 2.33em }

blockquote, figure { margin-left: 40px; margin-right: 40px }

dd { margin-left: 40px }
[dir=ltr i] dd { margin-left: 0; margin-right: 40px }
[dir=rtl i] dd { margin-left: 40px; margin-right: 0 }
[dir] [dir=ltr i] dd { margin-left: 0; margin-right: 40px }
[dir] [dir=rtl i] dd { margin-left: 40px; margin-right: 0 }
[dir] [dir] [dir=ltr i] dd { margin-left: 0; margin-right: 40px }
[dir] [dir] [dir=rtl i] dd { margin-left: 40px; margin-right: 0 }
dd[dir=ltr i][dir][dir] { margin-left: 0; margin-right: 40px }
dd[dir=rtl i][dir][dir] { margin-left: 40px; margin-right: 0 }

dir, menu, ol, ul { padding-left: 40px }
[dir=ltr i] :is(dir, menu, ol, ul) { padding-left: 40px; padding-right: 0 }
[dir=rtl i] :is(dir, menu, ol, ul) { padding-left: 0; padding-right: 40px }
[dir] [dir=ltr i] :is(dir, menu, ol, ul) { padding-left: 40px; padding-right: 0 }
[dir] [dir=rtl i] :is(dir, menu, ol, ul) { padding-left: 0; padding-right: 40px }
[dir] [dir] [dir=ltr i] :is(dir, menu, ol, ul) { padding-left: 40px; padding-right: 0 }
[dir] [dir] [dir=rtl i] :is(dir, menu, ol, ul) { padding-left: 0; padding-right: 40px }
:is(dir, menu, ol, ul)[dir=ltr i][dir][dir] { padding-left: 40px; padding-right: 0 }
:is(dir, menu, ol, ul)[dir=rtl i][dir][dir] { padding-left: 0; padding-right: 40px }

table { border-spacing: 2px; border-collapse: separate }
td, th { padding: 1px }

/* Alignment */

thead, tbody, tfoot, table > tr { vertical-align: middle }
tr, td, th { vertical-align: inherit }
sub { vertical-align: sub }
sup { vertical-align: super }

/* Fonts and colors */

html { color-scheme: light }
address, cite, dfn, em, i, var { font-style: italic }
b, strong, th { font-weight: bold }
code, kbd, listing, plaintext, pre, samp, tt, xmp { font-family: monospace }
h1 { font-size: 2em; font-weight: bold }
h2 { font-size: 1.5em; font-weight: bold }
h3 { font-size: 1.17em; font-weight: bold }
h4 { font-size: 1em; font-weight: bold }
h5 { font-size: .83em; font-weight: bold }
h6 { font-size: .67em; font-weight: bold }
big { font-size: larger }
small, sub, sup { font-size: smaller }
sub, sup { line-height: normal }

:link { color: blue }
mark { background: yellow; color: black }

table, td, th { border-color: gray }
thead, tbody, tfoot, tr { border-color: inherit }
table:is([rules], [frame]):is([frame=above i], [frame=below i], [frame=border i], [frame=box i], [frame=hsides i], [frame=lhs i], [frame=rhs i], [frame=void i], [frame=vsides i], [rules=all i], [rules=cols i], [rules=groups i], [rules=none i], [rules=rows i]), table[rules]:is([rules=all i], [rules=cols i], [rules=groups i], [rules=none i], [rules=rows i]) > tr > :is(td, th), table[rules]:is([rules=all i], [rules=cols i], [rules=groups i], [rules=none i], [rules=rows i]) > :is(thead, tbody, tfoot) > tr > :is(td, th) { border-color: black }

/* Punctuation and decorations */

:link, :visited, ins, u { text-decoration: underline }
abbr[title], acronym[title] { text-decoration: dotted underline }
del, s, strike { text-decoration: line-through }
q::before { content: open-quote }
q::after { content: close-quote }

br::before { content: "\A"; white-space: pre-line }
wbr::before { content: "\200B" }
nobr { white-space: nowrap }

hr { border-style: inset; border-width: 1px; color: gray; margin: .5em auto }

listing, plaintext, pre, xmp { white-space: pre }
textarea { white-space: pre-wrap }
ol { list-style-type: decimal }
dir, menu, ul { list-style-type: disc }
:is(dir, menu, ol, ul) ul { list-style-type: circle }
:is(dir, menu, ol, ul) :is(dir, menu, ol, ul) ul { list-style-type: square }

::marker { font-variant-numeric: tabular-nums; white-space: pre; text-transform: none }

[dir=ltr i] { direction: ltr }
[dir=rtl i] { direction: rtl }

/* Text indent */

table, input, select, option, optgroup, button, textarea, keygen { text-indent: initial }

/* Specific tags */

center { text-align: center }
iframe:not([seamless]) { border: 2px inset }
img, svg { overflow: hidden }
video { object-fit: contain }
table { box-sizing: border-box }

/* Footnotes */

::footnote-call { content: counter(footnote); vertical-align: super; font-size: smaller; line-height: inherit }
::footnote-marker { content: counter(footnote) ". " }

/* Counters and bookmarks */

ol, ul { counter-reset: list-item }
h1 { bookmark-level: 1 }
h2 { bookmark-level: 2 }
h3 { bookmark-level: 3 }
h4 { bookmark-level: 4 }
h5 { bookmark-level: 5 }
h6 { bookmark-level: 6 }
h1, h2, h3, h4, h5, h6 { bookmark-label: content(text) }

/* Page breaks and hyphens */

h1, h2, h3, h4, h5, h6 { hyphens: manual; break-after: avoid; break-inside: avoid }
ol, ul { break-before: avoid }

/* Form fields */

button, input, select, textarea { border: 1px solid black; font-size: .85em; height: 1.2em; padding: .2em; white-space: pre; width: 20em }
input:is([type=button i], [type=reset i], [type=submit i]), button { background: lightgrey; border-radius: .25em; text-align: center }
input:is([type=button i], [type=reset i], [type=submit i])[value], button[value] { max-width: 100%; width: auto }
input[type=submit i]:not([value])::before { content: "Submit" }
input[type=reset i]:not([value])::before { content: "Reset" }
input:is([type=checkbox i], [type=radio i]) { height: .7em; vertical-align: -.2em; width: .7em }
input:is([type=checkbox i], [type=radio i])[checked]::before { background: black; content: ""; display: block; height: 100% }
input[type=radio i], input[type=radio][checked]:before { border-radius: 50% }
input[value]:not([type=checkbox i], [type=radio i])::before { content: attr(value); display: block; overflow: hidden }
:is(input, input[value=""], input[type=checkbox i], input[type=radio i]) { content: ""; display: block }
select { background: lightgrey; border-radius: .25em .25em; position: relative; white-space: normal }
select[multiple] { height: 3.6em }
select:not([multiple])::before { content: "˅"; position: absolute; right: 0; text-align: center; width: 1.5em }
select option { padding-right: 1.5em; white-space: nowrap }
select:not([multiple]) option { display: none }
select[multiple] option, select:not(:has(option[selected])) option:first-of-type, select option[selected]:not(option[selected] ~ option[selected]) { display: block; overflow: hidden }
textarea { height: 3em; margin: .1em 0; overflow: hidden; overflow-wrap: break-word; padding: .2em; white-space: pre-wrap }
textarea:empty { height: 3em }
fieldset { border: groove 2px; margin-left: 2px; margin-right: 2px; padding: .35em .625em .75em }

/* Pages */

@page {
  margin: 75px;
  @footnote { margin-top: 1em }
  @top-left-corner     { text-align: right;  vertical-align:  middle }
  @top-left            { text-align: left;   vertical-align:  middle }
  @top-center          { text-align: center; vertical-align:  middle }
  @top-right           { text-align: right;  vertical-align:  middle }
  @top-right-corner    { text-align: left;   vertical-align:  middle }
  @left-top            { text-align: center; vertical-align:  top    }
  @left-middle         { text-align: center; vertical-align:  middle }
  @left-bottom         { text-align: center; vertical-align:  bottom }
  @right-top           { text-align: center; vertical-align:  top    }
  @right-middle        { text-align: center; vertical-align:  middle }
  @right-bottom        { text-align: center; vertical-align:  bottom }
  @bottom-left-corner  { text-align: right;  vertical-align:  middle }
  @bottom-left         { text-align: left;   vertical-align:  middle }
  @bottom-center       { text-align: center; vertical-align:  middle }
  @bottom-right        { text-align: right;  vertical-align:  middle }
  @bottom-right-corner { text-align: left;   vertical-align:  middle }
}

/* Counters */

@counter-style disc { system: cyclic; symbols: •; suffix: " " }
@counter-style circle { system: cyclic; symbols: ◦; suffix: " " }
@counter-style square { system: cyclic; symbols: ▪; suffix: " " }
@counter-style disclosure-open { system: cyclic; symbols: ▾; suffix: " " }
@counter-style disclosure-closed { system: cyclic; symbols: ▸; suffix: " " }
@counter-style decimal { system: numeric; symbols: "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" }
@counter-style decimal-leading-zero { system: extends decimal; pad: 2 "0" }
@counter-style arabic-indic { system: numeric; symbols: ٠ ١ ٢ ٣ ٤ ٥ ٦ ٧ ٨ ٩ }
@counter-style armenian { system: additive; range: 1 9999; additive-symbols: 9000 Ք, 8000 Փ, 7000 Ւ, 6000 Ց, 5000 Ր, 4000 Տ, 3000 Վ, 2000 Ս, 1000 Ռ, 900 Ջ, 800 Պ, 700 Չ, 600 Ո, 500 Շ, 400 Ն, 300 Յ, 200 Մ, 100 Ճ, 90 Ղ, 80 Ձ, 70 Հ, 60 Կ, 50 Ծ, 40 Խ, 30 Լ, 20 Ի, 10 Ժ, 9 Թ, 8 Ը, 7 Է, 6 Զ, 5 Ե, 4 Դ, 3 Գ, 2 Բ, 1 Ա }
@counter-style upper-armenian {system: extends armenian }
@counter-style lower-armenian { system: additive; range: 1 9999; additive-symbols: 9000 ք, 8000 փ, 7000 ւ, 6000 ց, 5000 ր, 4000 տ, 3000 վ, 2000 ս, 1000 ռ, 900 ջ, 800 պ, 700 չ, 600 ո, 500 շ, 400 ն, 300 յ, 200 մ, 100 ճ, 90 ղ, 80 ձ, 70 հ, 60 կ, 50 ծ, 40 խ, 30 լ, 20 ի, 10 ժ, 9 թ, 8 ը, 7 է, 6 զ, 5 ե, 4 դ, 3 գ, 2 բ, 1 ա }
@counter-style bengali { system: numeric; symbols: ০ ১ ২ ৩ ৪ ৫ ৬ ৭ ৮ ৯ }
@counter-style cambodian { system: numeric; symbols: ០ ១ ២ ៣ ៤ ៥ ៦ ៧ ៨ ៩ }
@counter-style khmer { system: extends cambodian }
@counter-style cjk-decimal { system: numeric; range: 0 infinite; symbols: 〇 一 二 三 四 五 六 七 八 九; suffix: "、" }
@counter-style devanagari { system: numeric; symbols: ० १ २ ३ ४ ५ ६ ७ ८ ९ }
@counter-style georgian { system: additive; range: 1 19999; additive-symbols: 10000 ჵ, 9000 ჰ, 8000 ჯ, 7000 ჴ, 6000 ხ, 5000 ჭ, 4000 წ, 3000 ძ, 2000 ც, 1000 ჩ, 900 შ, 800 ყ, 700 ღ, 600 ქ, 500 ფ, 400 ჳ, 300 ტ, 200 ს, 100 რ, 90 ჟ, 80 პ, 70 ო, 60 ჲ, 50 ნ, 40 მ, 30 ლ, 20 კ, 10 ი, 9 თ, 8 ჱ, 7 ზ, 6 ვ, 5 ე, 4 დ, 3 გ, 2 ბ, 1 ა }
@counter-style gujarati { system: numeric; symbols: ૦ ૧ ૨ ૩ ૪ ૫ ૬ ૭ ૮ ૯ }
@counter-style gurmukhi { system: numeric; symbols: ੦ ੧ ੨ ੩ ੪ ੫ ੬ ੭ ੮ ੯ }
@counter-style hebrew { system: additive; range: 1 10999; additive-symbols: 10000 י׳, 9000 ט׳, 8000 ח׳, 7000 ז׳, 6000 ו׳, 5000 ה׳, 4000 ד׳, 3000 ג׳, 2000 ב׳, 1000 א׳, 400 ת, 300 ש, 200 ר, 100 ק, 90 צ, 80 פ, 70 ע, 60 ס, 50 נ, 40 מ, 30 ל, 20 כ, 19 יט, 18 יח, 17 יז, 16 טז, 15 טו, 10 י, 9 ט, 8 ח, 7 ז, 6 ו, 5 ה, 4 ד, 3 ג, 2 ב, 1 א }
@counter-style kannada { system: numeric; symbols: ೦ ೧ ೨ ೩ ೪ ೫ ೬ ೭ ೮ ೯ }
@counter-style lao { system: numeric; symbols: ໐ ໑ ໒ ໓ ໔ ໕ ໖ ໗ ໘ ໙ }
@counter-style malayalam { system: numeric; symbols: ൦ ൧ ൨ ൩ ൪ ൫ ൬ ൭ ൮ ൯ }
@counter-style mongolian { system: numeric; symbols: ᠐ ᠑ ᠒ ᠓ ᠔ ᠕ ᠖ ᠗ ᠘ ᠙ }
@counter-style myanmar { system: numeric; symbols: ၀ ၁ ၂ ၃ ၄ ၅ ၆ ၇ ၈ ၉ }
@counter-style oriya { system: numeric; symbols: ୦ ୧ ୨ ୩ ୪ ୫ ୬ ୭ ୮ ୯ }
@counter-style persian { system: numeric; symbols: ۰ ۱ ۲ ۳ ۴ ۵ ۶ ۷ ۸ ۹ }
@counter-style lower-roman { system: additive; range: 1 3999; additive-symbols: 1000 m, 900 cm, 500 d, 400 cd, 100 c, 90 xc, 50 l, 40 xl, 10 x, 9 ix, 5 v, 4 iv, 1 i }
@counter-style upper-roman { system: additive; range: 1 3999; additive-symbols: 1000 M, 900 CM, 500 D, 400 CD, 100 C, 90 XC, 50 L, 40 XL, 10 X, 9 IX, 5 V, 4 IV, 1 I }
@counter-style tamil { system: numeric; symbols: ௦ ௧ ௨ ௩ ௪ ௫ ௬ ௭ ௮ ௯ }
@counter-style telugu { system: numeric; symbols: ౦ ౧ ౨ ౩ ౪ ౫ ౬ ౭ ౮ ౯ }
@counter-style thai { system: numeric; symbols: ๐ ๑ ๒ ๓ ๔ ๕ ๖ ๗ ๘ ๙ }
@counter-style tibetan { system: numeric; symbols: ༠ ༡ ༢ ༣ ༤ ༥ ༦ ༧ ༨ ༩ } @counter-style lower-alpha { system: alphabetic; symbols: a b c d e f g h i j k l m n o p q r s t u v w x y z }
@counter-style lower-latin { system: extends lower-alpha }
@counter-style upper-alpha { system: alphabetic; symbols: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z }
@counter-style upper-latin { system: extends upper-alpha }
@counter-style cjk-earthly-branch { system: alphabetic; symbols: 子 丑 寅 卯 辰 巳 午 未 申 酉 戌 亥; suffix: "、" }
@counter-style cjk-heavenly-stem { system: alphabetic; symbols: 甲 乙 丙 丁 戊 己 庚 辛 壬 癸; suffix: "、" }
@counter-style lower-greek { system: alphabetic; symbols: α β γ δ ε ζ η θ ι κ λ μ ν ξ ο π ρ σ τ υ φ χ ψ ω }
@counter-style hiragana { system: alphabetic; symbols: あ い う え お か き く け こ さ し す せ そ た ち つ て と な に ぬ ね の は ひ ふ へ ほ ま み む め も や ゆ よ ら り る れ ろ わ ゐ ゑ を ん; suffix: "、" }
@counter-style hiragana-iroha { system: alphabetic; symbols: い ろ は に ほ へ と ち り ぬ る を わ か よ た れ そ つ ね な ら む う ゐ の お く や ま け ふ こ え て あ さ き ゆ め み し ゑ ひ も せ す; suffix: "、" }
@counter-style katakana { system: alphabetic; symbols: ア イ ウ エ オ カ キ ク ケ コ サ シ ス セ ソ タ チ ツ テ ト ナ ニ ヌ ネ ノ ハ ヒ フ ヘ ホ マ ミ ム メ モ ヤ ユ ヨ ラ リ ル レ ロ ワ ヰ ヱ ヲ ン; suffix: "、" }
@counter-style katakana-iroha { system: alphabetic; symbols: イ ロ ハ ニ ホ ヘ ト チ リ ヌ ル ヲ ワ カ ヨ タ レ ソ ツ ネ ナ ラ ム ウ ヰ ノ オ ク ヤ マ ケ フ コ エ テ ア サ キ ユ メ ミ シ ヱ ヒ モ セ ス; suffix: "、" }
@counter-style japanese-informal { system: additive; range: -9999 9999; additive-symbols: 9000 九千, 8000 八千, 7000 七千, 6000 六千, 5000 五千, 4000 四千, 3000 三千, 2000 二千, 1000 千, 900 九百, 800 八百, 700 七百, 600 六百, 500 五百, 400 四百, 300 三百, 200 二百, 100 百, 90 九十, 80 八十, 70 七十, 60 六十, 50 五十, 40 四十, 30 三十, 20 二十, 10 十, 9 九, 8 八, 7 七, 6 六, 5 五, 4 四, 3 三, 2 二, 1 一, 0 〇; suffix: 、; negative: マイナス; fallback: cjk-decimal }
@counter-style japanese-formal { system: additive; range: -9999 9999; additive-symbols: 9000 九阡, 8000 八阡, 7000 七阡, 6000 六阡, 5000 伍阡, 4000 四阡, 3000 参阡, 2000 弐阡, 1000 壱阡, 900 九百, 800 八百, 700 七百, 600 六百, 500 伍百, 400 四百, 300 参百, 200 弐百, 100 壱百, 90 九拾, 80 八拾, 70 七拾, 60 六拾, 50 伍拾, 40 四拾, 30 参拾, 20 弐拾, 10 壱拾, 9 九, 8 八, 7 七, 6 六, 5 伍, 4 四, 3 参, 2 弐, 1 壱, 0 零; suffix: 、; negative: マイナス; fallback: cjk-decimal }
@counter-style korean-hangul-formal { system: additive; range: -9999 9999; additive-symbols: 9000 구천, 8000 팔천, 7000 칠천, 6000 육천, 5000 오천, 4000 사천, 3000 삼천, 2000 이천, 1000 일천, 900 구백, 800 팔백, 700 칠백, 600 육백, 500 오백, 400 사백, 300 삼백, 200 이백, 100 일백, 90 구십, 80 팔십, 70 칠십, 60 육십, 50 오십, 40 사십, 30 삼십, 20 이십, 10 일십, 9 구, 8 팔, 7 칠, 6 육, 5 오, 4 사, 3 삼, 2 이, 1 일, 0 영; suffix: ", "; negative: "마이너스  " }
@counter-style korean-hanja-informal { system: additive; range: -9999 9999; additive-symbols: 9000 九千, 8000 八千, 7000 七千, 6000 六千, 5000 五千, 4000 四千, 3000 三千, 2000 二千, 1000 千, 900 九百, 800 八百, 700 七百, 600 六百, 500 五百, 400 四百, 300 三百, 200 二百, 100 百, 90 九十, 80 八十, 70 七十, 60 六十, 50 五十, 40 四十, 30 三十, 20 二十, 10 十, 9 九, 8 八, 7 七, 6 六, 5 五, 4 四, 3 三, 2 二, 1 一, 0 零; suffix: ", "; negative: "마이너스  " }
@counter-style korean-hanja-formal { system: additive; range: -9999 9999; additive-symbols: 9000 九仟, 8000 八仟, 7000 七仟, 6000 六仟, 5000 五仟, 4000 四仟, 3000 參仟, 2000 貳仟, 1000 壹仟, 900 九百, 800 八百, 700 七百, 600 六百, 500 五百, 400 四百, 300 參百, 200 貳百, 100 壹百, 90 九拾, 80 八拾, 70 七拾, 60 六拾, 50 五拾, 40 四拾, 30 參拾, 20 貳拾, 10 壹拾, 9 九, 8 八, 7 七, 6 六, 5 五, 4 四, 3 參, 2 貳, 1 壹, 0 零; suffix: ", "; negative: "마이너스  " }


================================================
FILE: weasyprint/css/html5_ua_form.css
================================================
/* Default stylesheet for PDF forms */

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


================================================
FILE: weasyprint/css/media_queries.py
================================================
"""Handle media queries.

https://www.w3.org/TR/mediaqueries-4/

"""

import tinycss2

from ..logger import LOGGER
from .tokens import remove_whitespace, split_on_comma


def evaluate_media_query(query_list, device_media_type):
    """Return the boolean evaluation of `query_list` for the given
    `device_media_type`.

    :attr query_list: a cssutilts.stlysheets.MediaList
    :attr device_media_type: a media type string (for now)

    """
    # TODO: actual support for media queries, not just media types
    return 'all' in query_list or device_media_type in query_list


def parse_media_query(tokens):
    tokens = remove_whitespace(tokens)
    if not tokens:
        return ['all']
    else:
        media = []
        if tokens[0].type == 'ident' and tokens[0].lower_value == 'only':
            tokens = tokens[1:]
        for part in split_on_comma(tokens):
            types = [token.type for token in part]
            if types == ['ident']:
                media.append(part[0].lower_value)
            else:
                LOGGER.warning(
                    'Expected a media type, got %r', tinycss2.serialize(part))
                return
        return media


================================================
FILE: weasyprint/css/properties.py
================================================
"""Various data about known CSS properties."""

import collections
from math import inf

from tinycss2.color5 import parse_color

Dimension = collections.namedtuple('Dimension', ['value', 'unit'])

ZERO_PIXELS = Dimension(0, 'px')

INITIAL_VALUES = {
    # CSS 2.1: https://www.w3.org/TR/CSS21/propidx.html
    'bottom': 'auto',
    'caption_side': 'top',
    'clear': 'none',
    'clip': (),  # computed value for 'auto'
    'color': parse_color('black'),  # chosen by the user agent
    'direction': 'ltr',
    'display': ('inline', 'flow'),
    'empty_cells': 'show',
    'float': 'none',
    'left': 'auto',
    'line_height': 'normal',
    'margin_top': ZERO_PIXELS,
    'margin_right': ZERO_PIXELS,
    'margin_bottom': ZERO_PIXELS,
    'margin_left': ZERO_PIXELS,
    'padding_top': ZERO_PIXELS,
    'padding_right': ZERO_PIXELS,
    'padding_bottom': ZERO_PIXELS,
    'padding_left': ZERO_PIXELS,
    'position': 'static',
    'right': 'auto',
    'table_layout': 'auto',
    'top': 'auto',
    'unicode_bidi': 'normal',
    'vertical_align': 'baseline',
    'visibility': 'visible',
    'z_index': 'auto',

    # Backgrounds and Borders 3 (CR): https://www.w3.org/TR/css-backgrounds-3/
    'background_attachment': ('scroll',),
    'background_clip': ('border-box',),
    'background_color': 'transparent',
    'background_image': (('none', None),),
    'background_origin': ('padding-box',),
    'background_position': (('left', Dimension(0, '%'),
                             'top', Dimension(0, '%')),),
    'background_repeat': (('repeat', 'repeat'),),
    'background_size': (('auto', 'auto'),),
    'border_bottom_color': 'currentcolor',
    'border_bottom_left_radius': (ZERO_PIXELS, ZERO_PIXELS),
    'border_bottom_right_radius': (ZERO_PIXELS, ZERO_PIXELS),
    'border_bottom_style': 'none',
    'border_bottom_width': 3,
    'border_collapse': 'separate',
    'border_left_color': 'currentcolor',
    'border_left_style': 'none',
    'border_left_width': 3,
    'border_right_color': 'currentcolor',
    'border_right_style': 'none',
    'border_right_width': 3,
    'border_spacing': (0, 0),
    'border_top_color': 'currentcolor',
    'border_top_left_radius': (ZERO_PIXELS, ZERO_PIXELS),
    'border_top_right_radius': (ZERO_PIXELS, ZERO_PIXELS),
    'border_top_style': 'none',
    'border_top_width': 3,  # computed value for 'medium'
    'border_image_source': ('none', None),
    'border_image_slice': (
        Dimension(100, '%'), Dimension(100, '%'),
        Dimension(100, '%'), Dimension(100, '%'),
        None),
    'border_image_width': (1, 1, 1, 1),
    'border_image_outset': (
        Dimension(0, None), Dimension(0, None),
        Dimension(0, None), Dimension(0, None)),
    'border_image_repeat': ('stretch', 'stretch'),
    'mask_border_source': ('none', None),
    'mask_border_slice': (
        Dimension(100, '%'), Dimension(100, '%'),
        Dimension(100, '%'), Dimension(100, '%'),
        None),
    'mask_border_width': ('auto', 'auto', 'auto', 'auto'),
    'mask_border_outset': (
        Dimension(0, None), Dimension(0, None),
        Dimension(0, None), Dimension(0, None)),
    'mask_border_repeat': ('stretch', 'stretch'),
    'mask_border_mode': 'alpha',

    # Color Adjustment 1 (CRD): https://www.w3.org/TR/css-color-adjust-1
    'color_scheme': 'normal',

    # Color 3 (REC): https://www.w3.org/TR/css-color-3/
    'opacity': 1,

    # Multi-column Layout (WD): https://www.w3.org/TR/css-multicol-1/
    'column_width': 'auto',
    'column_count': 'auto',
    'column_rule_color': 'currentcolor',
    'column_rule_style': 'none',
    'column_rule_width': 'medium',
    'column_fill': 'balance',
    'column_span': 'none',

    # Fonts 3 (REC): https://www.w3.org/TR/css-fonts-3/
    'font_family': ('serif',),  # depends on user agent
    'font_feature_settings': 'normal',
    'font_kerning': 'auto',
    'font_language_override': 'normal',
    'font_size': 16,  # actually medium, but we define medium from this
    'font_stretch': 'normal',
    'font_style': 'normal',
    'font_variant': 'normal',
    'font_variant_alternates': 'normal',
    'font_variant_caps': 'normal',
    'font_variant_east_asian': 'normal',
    'font_variant_ligatures': 'normal',
    'font_variant_numeric': 'normal',
    'font_variant_position': 'normal',
    'font_weight': 400,

    # Fonts 4 (WD): https://www.w3.org/TR/css-fonts-4/
    'font_variation_settings': 'normal',

    # Fragmentation 3/4 (CR/WD): https://www.w3.org/TR/css-break-4/
    'box_decoration_break': 'slice',
    'break_after': 'auto',
    'break_before': 'auto',
    'break_inside': 'auto',
    'margin_break': 'auto',
    'orphans': 2,
    'widows': 2,

    # Generated Content 3 (WD): https://www.w3.org/TR/css-content-3/
    'bookmark_label': (('content', 'text'),),
    'bookmark_level': 'none',
    'bookmark_state': 'open',
    'content': 'normal',
    'footnote_display': 'block',
    'footnote_policy': 'auto',
    'quotes': 'auto',
    'string_set': 'none',

    # Images 3/4 (CR/WD): https://www.w3.org/TR/css-images-4/
    'image_resolution': 1,  # dppx
    'image_rendering': 'auto',
    'image_orientation': 'from-image',
    'object_fit': 'fill',
    'object_position': (('left', Dimension(50, '%'),
                         'top', Dimension(50, '%')),),

    # Paged Media 3 (WD): https://www.w3.org/TR/css-page-3/
    'size': None,  # set to A4 in computed_values
    'page': 'auto',
    'bleed_left': 'auto',
    'bleed_right': 'auto',
    'bleed_top': 'auto',
    'bleed_bottom': 'auto',
    'marks': (),  # computed value for 'none'

    # Text 3/4 (WD/WD): https://www.w3.org/TR/css-text-4/
    'hyphenate_character': '‐',  # computed value chosen by the user agent
    'hyphenate_limit_chars': (5, 2, 2),
    'hyphenate_limit_zone': ZERO_PIXELS,
    'hyphens': 'manual',
    'letter_spacing': 'normal',
    'tab_size': 8,
    'text_align_all': 'start',
    'text_align_last': 'auto',
    'text_indent': ZERO_PIXELS,
    'text_transform': 'none',
    'white_space': 'normal',
    'word_break': 'normal',
    'word_spacing': 0,  # computed value for 'normal'

    # Transforms 1 (CR): https://www.w3.org/TR/css-transforms-1/
    'transform_origin': (Dimension(50, '%'), Dimension(50, '%')),
    'transform': (),  # computed value for 'none'

    # User Interface 3/4 (REC/WD): https://www.w3.org/TR/css-ui-4/
    'appearance': 'none',
    'outline_color': 'currentcolor',  # invert is not supported
    'outline_style': 'none',
    'outline_width': 3,  # computed value for 'medium'
    'outline_offset': 0,

    # Sizing 3 (WD): https://www.w3.org/TR/css-sizing-3/
    'box_sizing': 'content-box',
    'height': 'auto',
    'max_height': Dimension(inf, 'px'),  # parsed value for 'none'
    'max_width': Dimension(inf, 'px'),
    'min_height': 'auto',
    'min_width': 'auto',
    'width': 'auto',

    # Logical Properties and Values 1 (WD): https://www.w3.org/TR/css-logical-1/
    'block_size': 'auto',
    'inline_size': 'auto',
    'max_block_size': Dimension(inf, 'px'),  # parsed value for 'none',
    'max_inline_size': Dimension(inf, 'px'),
    'min_block_size': 'auto',
    'min_inline_size': 'auto',
    'margin_block_start': 0,
    'margin_inline_start': 0,
    'margin_block_end': 0,
    'margin_inline_end': 0,
    'padding_block_start': 0,
    'padding_inline_start': 0,
    'padding_block_end': 0,
    'padding_inline_end': 0,
    'inset_block_start': 'auto',
    'inset_inline_start': 'auto',
    'inset_block_end': 'auto',
    'inset_inline_end': 'auto',
    'border_block_start_width': 3,
    'border_inline_start_width': 3,
    'border_block_end_width': 3,
    'border_inline_end_width': 3,
    'border_block_start_style': 'none',
    'border_inline_start_style': 'none',
    'border_block_end_style': 'none',
    'border_inline_end_style': 'none',
    'border_block_start_color': 'currentcolor',
    'border_inline_start_color': 'currentcolor',
    'border_block_end_color': 'currentcolor',
    'border_inline_end_color': 'currentcolor',
    'border_start_start_radius': 0,
    'border_start_end_radius': 0,
    'border_end_start_radius': 0,
    'border_end_end_radius': 0,

    # Flexible Box Layout Module 1 (CR): https://www.w3.org/TR/css-flexbox-1/
    'flex_basis': 'auto',
    'flex_direction': 'row',
    'flex_grow': 0,
    'flex_shrink': 1,
    'flex_wrap': 'nowrap',

    # Grid Layout Module Level 2 (CR): https://www.w3.org/TR/css-grid-2/
    'grid_auto_columns': ('auto',),
    'grid_auto_flow': ('row',),
    'grid_auto_rows': ('auto',),
    'grid_template_areas': 'none',
    'grid_template_columns': 'none',
    'grid_template_rows': 'none',
    'grid_row_start': 'auto',
    'grid_column_start': 'auto',
    'grid_row_end': 'auto',
    'grid_column_end': 'auto',

    # CSS Box Alignment Module Level 3 (WD): https://www.w3.org/TR/css-align-3/
    'align_content': ('normal',),
    'align_items': ('normal',),
    'align_self': ('auto',),
    'justify_content': ('normal',),
    'justify_items': ('normal',),
    'justify_self': ('auto',),
    'order': 0,
    'column_gap': 'normal',
    'row_gap': 'normal',

    # Text Decoration Module 3/4 (CR/WD): https://www.w3.org/TR/css-text-decor-4/
    'text_decoration_line': 'none',
    'text_decoration_color': 'currentcolor',
    'text_decoration_style': 'solid',
    'text_decoration_thickness': 'auto',
    'text_underline_offset': 'auto',

    # Overflow Module 3/4 (WD): https://www.w3.org/TR/css-overflow-4/
    'block_ellipsis': 'none',
    'continue': 'auto',
    'max_lines': 'none',
    'overflow': 'visible',
    'overflow_wrap': 'normal',
    'text_overflow': 'clip',

    # Lists Module 3 (WD): https://drafts.csswg.org/css-lists-3/
    # Means 'none', but allow `display: list-item` to increment the
    # list-item counter. If we ever have a way for authors to query
    # computed values (JavaScript?), this value should serialize to 'none'.
    'counter_increment': 'auto',
    'counter_reset': (),  # parsed value for 'none'
    'counter_set': (),  # parsed value for 'none'
    'list_style_image': ('none', None),
    'list_style_position': 'outside',
    'list_style_type': 'disc',

    # Proprietary
    'anchor': None,  # computed value of 'none'
    'link': None,  # computed value of 'none'
    'lang': None,  # computed value of 'none'
}


KNOWN_PROPERTIES = set(name.replace('_', '-') for name in INITIAL_VALUES)

# Do not list shorthand properties here as we handle them before inheritance.
#
# Values inherited but not applicable to print are not included.
#
# text_decoration is not a really inherited, see
# https://www.w3.org/TR/CSS2/text.html#propdef-text-decoration
#
# link: click events normally bubble up to link ancestors
#   See https://lists.w3.org/Archives/Public/www-style/2012Jun/0315.html
INHERITED = {
    'block_ellipsis',
    'border_collapse',
    'border_spacing',
    'caption_side',
    'color',
    'color_scheme',
    'direction',
    'empty_cells',
    'font_family',
    'font_feature_settings',
    'font_kerning',
    'font_language_override',
    'font_size',
    'font_style',
    'font_stretch',
    'font_variant',
    'font_variant_alternates',
    'font_variant_caps',
    'font_variant_east_asian',
    'font_variant_ligatures',
    'font_variant_numeric',
    'font_variant_position',
    'font_variation_settings',
    'font_weight',
    'hyphens',
    'hyphenate_character',
    'hyphenate_limit_chars',
    'hyphenate_limit_zone',
    'image_rendering',
    'image_resolution',
    'lang',
    'letter_spacing',
    'line_height',
    'link',
    'list_style_image',
    'list_style_position',
    'list_style_type',
    'orphans',
    'overflow_wrap',
    'quotes',
    'tab_size',
    'text_align_all',
    'text_align_last',
    'text_indent',
    'text_transform',
    'text_underline_offset',
    'visibility',
    'white_space',
    'widows',
    'word_break',
    'word_spacing',
}


# https://www.w3.org/TR/CSS21/tables.html#model
# See also https://lists.w3.org/Archives/Public/www-style/2012Jun/0066.html
# Only non-inherited properties need to be included here.
TABLE_WRAPPER_BOX_PROPERTIES = {
    'bottom',
    'break_after',
    'break_before',
    'clear',
    'counter_increment',
    'counter_reset',
    'counter_set',
    'float',
    'left',
    'margin_top',
    'margin_bottom',
    'margin_left',
    'margin_right',
    'margin_block_start',
    'margin_block_end',
    'margin_inline_start',
    'margin_inline_end',
    'opacity',
    'overflow',
    'position',
    'right',
    'top',
    'transform',
    'transform_origin',
    'vertical_align',
    'z_index',
}


# Properties that have an initial value that is not always the same when
# computed.
INITIAL_NOT_COMPUTED = {
    'display',
    'column_gap',
    'bleed_top',
    'bleed_left',
    'bleed_bottom',
    'bleed_right',
    'outline_width',
    'outline_color',
    'column_rule_width',
    'column_rule_color',
    'border_top_width',
    'border_left_width',
    'border_bottom_width',
    'border_right_width',
    'border_top_color',
    'border_left_color',
    'border_bottom_color',
    'border_right_color',
    'border_block_start_width',
    'border_inline_start_width',
    'border_block_end_width',
    'border_inline_end_width',
    'border_block_start_color',
    'border_inline_start_color',
    'border_block_end_color',
    'border_inline_end_color',
    'background_color',
}


================================================
FILE: weasyprint/css/targets.py
================================================
"""Handle target-counter, target-counters and target-text.

The TargetCollector is a structure providing required targets' counter_values
and stuff needed to build pending targets later, when the layout of all
targeted anchors has been done.

"""

import copy

from ..logger import LOGGER


class TargetLookupItem:
    """Item controlling pending targets and page based target counters.

    Collected in the TargetCollector's ``target_lookup_items``.

    """
    def __init__(self, state='pending'):
        self.state = state

        # Required by target-counter and target-counters to access the
        # target's .cached_counter_values.
        # Needed for target-text via extract_text().
        self.target_box = None

        # Functions that have to been called to check pending targets.
        # Keys are (source_box, css_token).
        self.parse_again_functions = {}

        # Anchor position during pagination (page_number - 1)
        self.page_maker_index = None

        # target_box's page_counters during pagination
        self.cached_page_counter_values = {}


class CounterLookupItem:
    """Item controlling page based counters.

    Collected in the TargetCollector's ``counter_lookup_items``.

    """
    def __init__(self, parse_again, missing_counters, missing_target_counters):
        # Function that have to been called to check pending counter.
        self.parse_again = parse_again

        # Missing counters and target counters
        self.missing_counters = missing_counters
        self.missing_target_counters = missing_target_counters

        # Box position during pagination (page_number - 1)
        self.page_maker_index = None

        # Marker for remake_page
        self.pending = False

        # Targeting box's page_counters during pagination
        self.cached_page_counter_values = {}


def anchor_name_from_token(anchor_token):
    """Get anchor name from string or uri token."""
    if anchor_token[0] == 'string' and anchor_token[1].startswith('#'):
        return anchor_token[1][1:]
    elif anchor_token[0] == 'url' and anchor_token[1][0] == 'internal':
        return anchor_token[1][1]


class TargetCollector:
    """Collector of HTML targets used by CSS content with ``target-*``."""

    def __init__(self):
        # Lookup items for targets and page counters
        self.target_lookup_items = {}
        self.counter_lookup_items = {}

        # When collecting is True, compute_content_list() collects missing
        # page counters in CounterLookupItems. Otherwise, it mixes in the
        # TargetLookupItem's cached_page_counter_values.
        # Is switched to False in check_pending_targets().
        self.collecting = True

        # had_pending_targets is set to True when a target is needed but has
        # not been seen yet. check_pending_targets then uses this information
        # to call the needed parse_again functions.
        self.had_pending_targets = False

    def collect_anchor(self, anchor_name):
        """Create a TargetLookupItem for the given `anchor_name``."""
        if isinstance(anchor_name, str):
            if self.target_lookup_items.get(anchor_name) is not None:
                LOGGER.warning('Anchor defined twice: %r', anchor_name)
            else:
                self.target_lookup_items.setdefault(
                    anchor_name, TargetLookupItem())

    def lookup_target(self, anchor_token, source_box, css_token, parse_again):
        """Get a TargetLookupItem corresponding to ``anchor_token``.

        If it is already filled by a previous anchor-element, the status is
        'up-to-date'. Otherwise, it is 'pending', we must parse the whole
        tree again.

        """
        anchor_name = anchor_name_from_token(anchor_token)
        item = self.target_lookup_items.get(
            anchor_name, TargetLookupItem('undefined'))

        if item.state == 'pending':
            self.had_pending_targets = True
            item.parse_again_functions.setdefault(
                (source_box, css_token), parse_again)

        if item.state == 'undefined':
            LOGGER.error(
                'Content discarded: target points to undefined anchor %r',
                anchor_token)

        return item

    def store_target(self, anchor_name, target_counter_values, target_box):
        """Store a target called ``anchor_name``.

        If there is a pending TargetLookupItem, it is updated. Only previously
        collected anchors are stored.

        """
        item = self.target_lookup_items.get(anchor_name)
        if item and item.state == 'pending':
            item.state = 'up-to-date'
            item.target_box = target_box
            # Store the counter_values in the target_box like
            # compute_content_list does.
            if target_box.cached_counter_values is None:
                target_box.cached_counter_values = {
                    key: value.copy() for key, value
                    in target_counter_values.items()}

    def collect_missing_counters(self, parent_box, css_token,
                                 parse_again_function, missing_counters,
                                 missing_target_counters):
        """Collect missing (probably page-based) counters during formatting.

        The ``missing_counters`` are re-used during pagination.

        The ``missing_link`` attribute added to the parent_box is required to
        connect the paginated boxes to their originating ``parent_box``.

        """
        # No counter collection during pagination
        if not self.collecting:
            return

        # No need to add empty miss-lists
        if missing_counters or missing_target_counters:
            if parent_box.missing_link is None:
                parent_box.missing_link = parent_box
            counter_lookup_item = CounterLookupItem(
                parse_again_function, missing_counters,
                missing_target_counters)
            self.counter_lookup_items.setdefault(
                (parent_box, css_token), counter_lookup_item)

    def check_pending_targets(self):
        """Check pending targets if needed."""
        if self.had_pending_targets:
            for item in self.target_lookup_items.values():
                for function in item.parse_again_functions.values():
                    function()
            self.had_pending_targets = False
        # Ready for pagination
        self.collecting = False

    def cache_target_page_counters(self, anchor_name, page_counter_values,
                                   page_maker_index, page_maker):
        """Store target's current ``page_maker_index`` and page counter values.

        Eventually update associated targeting boxes.

        """
        # Only store page counters when paginating
        if self.collecting:
            return

        item = self.target_lookup_items.get(anchor_name)
        if item and item.state == 'up-to-date':
            item.page_maker_index = page_maker_index
            if item.cached_page_counter_values != page_counter_values:
                item.cached_page_counter_values = copy.deepcopy(
                    page_counter_values)

                # Spread the news: update boxes affected by a change in the
                # anchor's page counter values.
                for (_, css_token), item in self.counter_lookup_items.items():
                    # Only update items that need counters in their content
                    if css_token != 'content':
                        continue

                    # Don't update if item has no missing target counter
                    missing_counters = item.missing_target_counters.get(
                        anchor_name)
                    if missing_counters is None:
                        continue

                    # Pending marker for remake_page
                    if (item.page_maker_index is None or
                            item.page_maker_index >= len(page_maker)):
                        item.pending = True
                        continue

                    # TODO: Is the item at all interested in the new
                    # page_counter_values? It probably is and this check is a
                    # brake.
                    for counter_name in missing_counters:
                        counter_value = page_counter_values.get(counter_name)
                        if counter_value is not None:
                            remake_state = (
                                page_maker[item.page_maker_index][-1])
                            remake_state['content_changed'] = True
                            item.parse_again(item.cached_page_counter_values)
                            break
                    # Hint: the box's own cached page counters trigger a
                    # separate 'content_changed'.


================================================
FILE: weasyprint/css/tokens.py
================================================
"""CSS tokens parsers."""

import functools
from abc import ABC, abstractmethod
from math import e, inf, nan, pi

from tinycss2.ast import DimensionToken, IdentToken, NumberToken, PercentageToken
from tinycss2.color5 import parse_color

from ..logger import LOGGER
from ..urls import get_url_tuple
from . import functions
from .functions import check_math
from .properties import Dimension
from .units import ANGLE_TO_RADIANS, LENGTH_UNITS, RESOLUTION_TO_DPPX

ZERO_PERCENT = Dimension(0, '%')
FIFTY_PERCENT = Dimension(50, '%')
HUNDRED_PERCENT = Dimension(100, '%')
BACKGROUND_POSITION_PERCENTAGES = {
    'top': ZERO_PERCENT,
    'left': ZERO_PERCENT,
    'center': FIFTY_PERCENT,
    'bottom': HUNDRED_PERCENT,
    'right': HUNDRED_PERCENT,
}

DIRECTION_KEYWORDS = {
    # ('angle', radians), 0 upwards, then clockwise.
    ('to', 'top'): ('angle', 0),
    ('to', 'right'): ('angle', pi / 2),
    ('to', 'bottom'): ('angle', pi),
    ('to', 'left'): ('angle', pi * 3 / 2),
    # ('corner', keyword).
    ('to', 'top', 'left'): ('corner', 'top_left'),
    ('to', 'left', 'top'): ('corner', 'top_left'),
    ('to', 'top', 'right'): ('corner', 'top_right'),
    ('to', 'right', 'top'): ('corner', 'top_right'),
    ('to', 'bottom', 'left'): ('corner', 'bottom_left'),
    ('to', 'left', 'bottom'): ('corner', 'bottom_left'),
    ('to', 'bottom', 'right'): ('corner', 'bottom_right'),
    ('to', 'right', 'bottom'): ('corner', 'bottom_right'),
}

E = NumberToken(0, 0, e, None, 'e')
PI = NumberToken(0, 0, pi, None, 'π')
PLUS_INFINITY = NumberToken(0, 0, inf, None, '∞')
MINUS_INFINITY = NumberToken(0, 0, -inf, None, '-∞')
NAN = NumberToken(0, 0, nan, None, 'NaN')


class InvalidValues(ValueError):  # noqa: N818
    """Invalid or unsupported values for a known CSS property."""


class PercentageInMath(ValueError):  # noqa: N818
    """Percentage in math function without reference length."""


class RelativeLengthInMath(ValueError):  # noqa: N818
    """Relative length unit in math function without reference style."""


class Pending(ABC):
    """Abstract class representing property value with pending validation."""
    # See https://drafts.csswg.org/css-variables-2/#variables-in-shorthands.
    def __init__(self, tokens, name):
        self.tokens = tokens
        self.name = name
        self._reported_error = False

    @abstractmethod
    def validate(self, tokens, wanted_key):
        """Get validated value for wanted key."""
        raise NotImplementedError

    def solve(self, tokens, wanted_key):
        """Get validated value or raise error."""
        try:
            if not tokens:
                # Having no tokens is allowed by grammar but refused by all
                # properties and expanders.
                raise InvalidValues('no value')
            return self.validate(tokens, wanted_key)
        except InvalidValues as exception:
            if self._reported_error:
                raise exception
            source_line = self.tokens[0].source_line
            source_column = self.tokens[0].source_column
            value = ' '.join(token.serialize() for token in tokens)
            message = exception.args[0] if exception.args else 'invalid value'
            LOGGER.warning(
                'Ignored `%s: %s` at %d:%d, %s.',
                self.name, value, source_line, source_column, message)
            self._reported_error = True
            raise exception


def parse_color_hint(tokens):
    if len(tokens) == 1:
        return get_length(tokens[0], percentage=True)


def parse_color_stop(tokens):
    if len(tokens) == 1:
        color = parse_color(tokens[0])
        if color == 'currentcolor':
            # TODO: return the current color instead
            return parse_color('black'), None
        if color is not None:
            return color, None
    elif len(tokens) == 2:
        color = parse_color(tokens[0])
        position = get_length(tokens[1], negative=True, percentage=True)
        if color is not None and position is not None:
            return color, position
    raise InvalidValues


def parse_color_stops_and_hints(color_stops_hints):
    if not color_stops_hints:
        raise InvalidValues

    color_stops = [parse_color_stop(color_stops_hints[0])]
    color_hints = []
    previous_was_color_stop = True

    for tokens in color_stops_hints[1:]:
        if hint := parse_color_hint(tokens):
            color_hints.append(hint)
            previous_was_color_stop = False
        elif previous_was_color_stop:
            color_hints.append(FIFTY_PERCENT)
            color_stops.append(parse_color_stop(tokens))
            previous_was_color_stop = True
        else:
            color_stops.append(parse_color_stop(tokens))
            previous_was_color_stop = True

    if not previous_was_color_stop:
        raise InvalidValues

    return color_stops, color_hints


def parse_linear_gradient_parameters(arguments):
    first_arg = arguments[0]
    if len(first_arg) == 1:
        angle = get_angle(first_arg[0])
        if angle is not None:
            return ('angle', angle), arguments[1:]
    else:
        result = DIRECTION_KEYWORDS.get(tuple(map(get_keyword, first_arg)))
        if result is not None:
            return result, arguments[1:]
    return ('angle', pi), arguments  # Default direction is 'to bottom'


def parse_2d_position(tokens):
    """Common syntax of background-position and transform-origin."""
    if len(tokens) == 1:
        tokens = [tokens[0], IdentToken(0, 0, 'center')]
    elif len(tokens) != 2:
        return None

    token_1, token_2 = tokens
    length_1 = get_length(token_1, percentage=True)
    length_2 = get_length(token_2, percentage=True)
    if length_1 and length_2:
        return length_1, length_2
    keyword_1, keyword_2 = map(get_keyword, tokens)
    if length_1 and keyword_2 in ('top', 'center', 'bottom'):
        return length_1, BACKGROUND_POSITION_PERCENTAGES[keyword_2]
    elif length_2 and keyword_1 in ('left', 'center', 'right'):
        return BACKGROUND_POSITION_PERCENTAGES[keyword_1], length_2
    elif (keyword_1 in ('left', 'center', 'right') and
          keyword_2 in ('top', 'center', 'bottom')):
        return (BACKGROUND_POSITION_PERCENTAGES[keyword_1],
                BACKGROUND_POSITION_PERCENTAGES[keyword_2])
    elif (keyword_1 in ('top', 'center', 'bottom') and
          keyword_2 in ('left', 'center', 'right')):
        # Swap tokens. They need to be in (horizontal, vertical) order.
        return (BACKGROUND_POSITION_PERCENTAGES[keyword_2],
                BACKGROUND_POSITION_PERCENTAGES[keyword_1])


def parse_position(tokens):
    """Parse background-position and object-position.

    See https://drafts.csswg.org/css-backgrounds-3/#the-background-position
    https://drafts.csswg.org/css-images-3/#propdef-object-position

    """
    result = parse_2d_position(tokens)
    if result is not None:
        pos_x, pos_y = result
        return 'left', pos_x, 'top', pos_y

    if len(tokens) == 4:
        keyword_1 = get_keyword(tokens[0])
        keyword_2 = get_keyword(tokens[2])
        length_1 = get_length(tokens[1], percentage=True)
        length_2 = get_length(tokens[3], percentage=True)
        if length_1 and length_2:
            if (keyword_1 in ('left', 'right') and
                    keyword_2 in ('top', 'bottom')):
                return keyword_1, length_1, keyword_2, length_2
            if (keyword_2 in ('left', 'right') and
                    keyword_1 in ('top', 'bottom')):
                return keyword_2, length_2, keyword_1, length_1

    if len(tokens) == 3:
        length = get_length(tokens[2], percentage=True)
        if length is not None:
            keyword = get_keyword(tokens[1])
            other_keyword = get_keyword(tokens[0])
        else:
            length = get_length(tokens[1], percentage=True)
            other_keyword = get_keyword(tokens[2])
            keyword = get_keyword(tokens[0])

        if length is not None:
            if other_keyword == 'center':
                if keyword in ('top', 'bottom'):
                    return 'left', FIFTY_PERCENT, keyword, length
                if keyword in ('left', 'right'):
                    return keyword, length, 'top', FIFTY_PERCENT
            elif (keyword in ('left', 'right') and
                    other_keyword in ('top', 'bottom')):
                return keyword, length, other_keyword, ZERO_PERCENT
            elif (keyword in ('top', 'bottom') and
                    other_keyword in ('left', 'right')):
                return other_keyword, ZERO_PERCENT, keyword, length


def parse_radial_gradient_parameters(arguments):
    shape = None
    position = None
    size = None
    size_shape = None
    stack = arguments[0][::-1]
    while stack:
        token = stack.pop()
        keyword = get_keyword(token)
        if keyword == 'at':
            position = parse_position(stack[::-1])
            if position is None:
                return
            break
        elif keyword in ('circle', 'ellipse') and shape is None:
            shape = keyword
        elif keyword in ('closest-corner', 'farthest-corner',
                         'closest-side', 'farthest-side') and size is None:
            size = 'keyword', keyword
        else:
            if stack and size is None:
                length_1 = get_length(token, percentage=True)
                length_2 = get_length(stack[-1], percentage=True)
                if None not in (length_1, length_2):
                    size = 'explicit', (length_1, length_2)
                    size_shape = 'ellipse'
                    stack.pop()
            if size is None:
                length_1 = get_length(token)
                if length_1 is not None:
                    size = 'explicit', (length_1, length_1)
                    size_shape = 'circle'
            if size is None:
                return
    if (shape, size_shape) in (('circle', 'ellipse'), ('circle', 'ellipse')):
        return
    return (
        shape or size_shape or 'ellipse',
        size or ('keyword', 'farthest-corner'),
        position or ('left', FIFTY_PERCENT, 'top', FIFTY_PERCENT),
        arguments[1:])


def split_on_comma(tokens):
    """Split a list of tokens on commas, ie ``LiteralToken(',')``.

    Only "top-level" comma tokens are splitting points, not commas inside a
    function or blocks.

    """
    parts = []
    this_part = []
    for token in tokens:
        if token.type == 'literal' and token.value == ',':
            parts.append(this_part)
            this_part = []
        else:
            this_part.append(token)
    parts.append(this_part)
    return tuple(parts)


def remove_whitespace(tokens):
    """Remove any top-level whitespace and comments in a token list."""
    return tuple(
        token for token in tokens
        if token.type not in ('whitespace', 'comment'))


def get_keyword(token):
    """If ``token`` is a keyword, return its lowercase name.

    Otherwise return ``None``.

    """
    if token.type == 'ident':
        return token.lower_value


def get_custom_ident(token):
    """If ``token`` is a keyword, return its name.

    Otherwise return ``None``.

    """
    if token.type == 'ident':
        return token.value


def get_single_keyword(tokens):
    """If ``values`` is a 1-element list of keywords, return its name.

    Otherwise return ``None``.

    """
    if len(tokens) == 1:
        token = tokens[0]
        if token.type == 'ident':
            return token.lower_value


def get_number(token, negative=True, integer=False):
    """Parse a <number> token."""
    from . import resolve_math

    if check_math(token):
        try:
            resolved = resolve_math(token)
        except (PercentageInMath, RelativeLengthInMath):
            return
        else:
            if resolved is None:
                return
            if resolved.type != 'number':
                return
            value = resolved.value
            if not negative and value < 0:
                value = 0
            if integer:
                # TODO: always round x.5 to +inf, see
                # https://drafts.csswg.org/css-values-4/#combine-integers.
                value = round(value)
            return Dimension(value, None)
    elif token.type == 'number':
        if integer:
            if token.int_value is not None:
                if negative or token.int_value >= 0:
                    return Dimension(token.int_value, None)
        elif negative or token.value >= 0:
            return Dimension(token.value, None)


def get_string(token):
    """Parse a <string> token."""
    if token.type == 'string':
        return ('string', token.value)
    if token.type == 'function':
        if token.name == 'attr':
            return functions.check_attr(token, 'string')
        elif token.name in ('counter', 'counters'):
            return functions.check_counter(token)
        elif token.name == 'content':
            return functions.check_content(token)
        elif token.name == 'string':
            return functions.check_string_or_element('string', token)


def get_percentage(token, negative=True):
    """Parse a <percentage> token."""
    from . import resolve_math

    if check_math(token):
        try:
            token = resolve_math(token) or token
        except (PercentageInMath, RelativeLengthInMath):
            return
        else:
            # Range clamp.
            if not negative:
                token.value = max(0, token.value)
    if token.type == 'percentage' and (negative or token.value >= 0):
        return Dimension(token.value, '%')


def get_length(token, negative=True, percentage=False):
    """Parse a <length> token."""
    from . import resolve_math

    if check_math(token):
        try:
            token = resolve_math(token) or token
        except PercentageInMath:
            # PercentageInMath is raised in priority to help discarding percentages for
            # properties that don’t allow them.
            return token if percentage else None
        except RelativeLengthInMath:
            return token
        else:
            # Range clamp.
            if not negative and token.type not in ('function', 'number'):
                token.value = max(0, token.value)
    if percentage and token.type == 'percentage':
        if negative or token.value >= 0:
            return Dimension(token.value, '%')
    if token.type == 'dimension' and token.unit.lower() in LENGTH_UNITS:
        if negative or token.value >= 0:
            return Dimension(token.value, token.unit.lower())
    if token.type == 'number' and token.value == 0:
        return Dimension(0, None)


def get_angle(token):
    """Parse an <angle> token in radians."""
    from . import resolve_math

    try:
        token = resolve_math(token) or token
    except (PercentageInMath, RelativeLengthInMath):
        return
    if token.type == 'number' and token.value == 0:
        # Legacy syntax: https://drafts.csswg.org/css-values-4/#angles.
        return 0
    elif token.type == 'dimension':
        factor = ANGLE_TO_RADIANS.get(token.unit.lower())
        if factor is not None:
            return token.value * factor


def get_resolution(token):
    """Parse a <resolution> token in dppx."""
    from . import resolve_math

    try:
        token = resolve_math(token) or token
    except (PercentageInMath, RelativeLengthInMath):
        return
    if token.type == 'dimension':
        factor = RESOLUTION_TO_DPPX.get(token.unit.lower())
        if factor is not None:
            return token.value * factor


def get_image(token, base_url):
    """Parse an <image> token."""
    from ..images import LinearGradient, RadialGradient

    if parsed_url := get_url(token, base_url):
        assert parsed_url[0] == 'url'
        if parsed_url[1][0] == 'external':
            return 'url', parsed_url[1][1]
    function = functions.Function(token)
    arguments = function.split_comma(single_tokens=False)
    if not arguments:
        return
    repeating = function.name.startswith('repeating-')
    if function.name in ('linear-gradient', 'repeating-linear-gradient'):
        direction, color_stops = parse_linear_gradient_parameters(arguments)
        color_stops, color_hints = parse_color_stops_and_hints(color_stops)
        return 'linear-gradient', LinearGradient(
            color_stops, direction, repeating, color_hints)
    elif function.name in ('radial-gradient', 'repeating-radial-gradient'):
        result = parse_radial_gradient_parameters(arguments)
        if result is not None:
            shape, size, position, color_stops = result
        else:
            shape = 'ellipse'
            size = 'keyword', 'farthest-corner'
            position = 'left', FIFTY_PERCENT, 'top', FIFTY_PERCENT
            color_stops = arguments
        color_stops, color_hints = parse_color_stops_and_hints(color_stops)
        return 'radial-gradient', RadialGradient(
            color_stops, shape, size, position, repeating, color_hints)


def get_url(token, base_url):
    """Parse an <url> token."""
    if token.type == 'url':
        url = get_url_tuple(token.value, base_url)
    elif token.type == 'function':
        if token.name == 'attr':
            return functions.check_attr(token, 'url')
        elif token.name == 'url' and len(token.arguments) in (1, 2):
            # Ignore url modifiers
            # See https://drafts.csswg.org/css-values-3/#urls
            url = get_url_tuple(token.arguments[0].value, base_url)
        else:
            return
    else:
        return

    if url is None:
        raise InvalidValues(f'Relative URI reference without a base URI: {url!r}')

    return ('url', url)


def get_quote(token):
    """Parse a <quote> token."""
    keyword = get_keyword(token)
    if keyword in (
            'open-quote', 'close-quote',
            'no-open-quote', 'no-close-quote'):
        return keyword


def get_target(token, base_url):
    """Parse a <target> token."""
    function = functions.Function(token)
    arguments = function.split_comma()
    if function.name == 'target-counter':
        if len(arguments) not in (2, 3):
            return
    elif function.name == 'target-counters':
        if len(arguments) not in (3, 4):
            return
    elif function.name == 'target-text':
        if len(arguments) not in (1, 2):
            return
    else:
        return

    values = []

    link = arguments.pop(0)
    string_link = get_string(link)
    if string_link is None:
        url = get_url(link, base_url)
        if url is None:
            return
        values.append(url)
    else:
        values.append(string_link)

    if function.name.startswith('target-counter'):
        ident = arguments.pop(0)
        if ident.type != 'ident':
            return
        values.append(ident.value)

        if function.name == 'target-counters':
            string = get_string(arguments.pop(0))
            if string is None:
                return
            values.append(string)

        if arguments:
            counter_style = get_keyword(arguments.pop(0))
        else:
            counter_style = 'decimal'
        values.append(counter_style)
    else:
        if arguments:
            content = get_keyword(arguments.pop(0))
            if content not in ('content', 'before', 'after', 'first-letter'):
                return
        else:
            content = 'content'
        values.append(content)

    return (f'{function.name}()', tuple(values))


def get_content_list(tokens, base_url):
    """Parse <content-list> tokens."""
    # See https://www.w3.org/TR/css-content-3/#typedef-content-list
    parsed_tokens = [get_content_list_token(token, base_url) for token in tokens]
    if None not in parsed_tokens:
        return parsed_tokens


def get_content_list_token(token, base_url):
    """Parse one of the <content-list> tokens."""
    # See https://drafts.csswg.org/css-content-3/#content-values.

    # <string>
    if (string := get_string(token)) is not None:
        return string

    # contents
    if get_keyword(token) == 'contents':
        return ('content()', 'text')

    # <uri>
    if (url := get_url(token, base_url)) is not None:
        return url

    # <quote>
    if (quote := get_quote(token)) is not None:
        return ('quote', quote)

    # <target>
    if (target := get_target(token, base_url)) is not None:
        return target

    function = functions.Function(token)
    arguments = function.split_comma()

    # <leader()>
    if function.name == 'leader':
        if len(arguments) != 1:
            return
        arg, = arguments
        if arg.type == 'ident':
            if arg.value == 'dotted':
                string = '.'
            elif arg.value == 'solid':
                string = '_'
            elif arg.value == 'space':
                string = ' '
            else:
                return
        elif arg.type == 'string':
            string = arg.value
        return ('leader()', ('string', string))

    # <element()>
    elif function.name == 'element':
        return functions.check_string_or_element('element', token)


def single_keyword(function):
    """Decorator for validators that only accept a single keyword."""
    @functools.wraps(function)
    def keyword_validator(tokens):
        """Wrap a validator to call get_single_keyword on tokens."""
        keyword = get_single_keyword(tokens)
        if function(keyword):
            return keyword
    return keyword_validator


def single_token(function):
    """Decorator for validators that only accept a single token."""
    @functools.wraps(function)
    def single_token_validator(tokens, *args):
        """Validate a property whose token is single."""
        if len(tokens) == 1:
            return function(tokens[0], *args)
    single_token_validator.__func__ = function
    return single_token_validator


def comma_separated_list(function):
    """Decorator for validators that accept a comma separated list."""
    @functools.wraps(function)
    def wrapper(tokens, *args):
        results = []
        for part in split_on_comma(tokens):
            result = function(remove_whitespace(part), *args)
            if result is None:
                return None
            results.append(result)
        return tuple(results)
    wrapper.single_value = function
    return wrapper


def tokenize(item, function=None, unit=None):
    """Transform a computed value result into a token."""
    if isinstance(item, (DimensionToken, Dimension)):
        value = function(item.value) if function else item.value
        return DimensionToken(0, 0, value, None, str(value), item.unit.lower())
    elif isinstance(item, PercentageToken):
        value = function(item.value) if function else item.value
        return PercentageToken(0, 0, value, None, str(value))
    elif isinstance(item, (NumberToken, int, float)):
        if isinstance(item, NumberToken):
            value = item.value
        else:
            value = item
        value = function(value) if function else value
        int_value = round(value) if float(value).is_integer() else None
        representation = str(int_value if float(value).is_integer() else value)
        if unit is None:
            return NumberToken(0, 0, value, int_value, representation)
        elif unit == '%':
            return PercentageToken(0, 0, value, int_value, representation)
        else:
            return DimensionToken(0, 0, value, int_value, representation, unit)


================================================
FILE: weasyprint/css/units.py
================================================
"""Constants and helpers for units."""

import math

from ..logger import LOGGER
from ..text.line_break import character_ratio, strut

# How many radians is one <unit>?
# https://drafts.csswg.org/css-values-4/#angles
ANGLE_TO_RADIANS = {
    'rad': 1,
    'turn': 2 * math.pi,
    'deg': math.pi / 180,
    'grad': math.pi / 200,
}

# How many CSS pixels is one <unit>?
# https://www.w3.org/TR/CSS21/syndata.html#length-units
LENGTHS_TO_PIXELS = {
    'px': 1,
    'pt': 1 / 0.75,
    'pc': 16,
    'in': 96,
    'cm': 96 / 2.54,
    'mm': 96 / 25.4,
    'q': 96 / 25.4 / 4,
}

# How many dppx is one <unit>?
# https://drafts.csswg.org/css-values/#resolution
RESOLUTION_TO_DPPX = {
    'dppx': 1,
    'x': 1,
    'dpi': 1 / LENGTHS_TO_PIXELS['in'],
    'dpcm': 1 / LENGTHS_TO_PIXELS['cm'],
}

# Sets of units.
# https://drafts.csswg.org/css-values-4/#lengths
ABSOLUTE_UNITS = set(LENGTHS_TO_PIXELS)
FONT_UNITS = {
     'em',  'ex',  'cap',  'ch',  'ic',  'lh',
    'rem', 'rex', 'rcap', 'rch', 'ric', 'rlh',
}
VIEWPORT_UNITS = {
     'vw',  'vh',  'vi',  'vb',  'vmin',  'vmax',
    'lvw', 'lvh', 'lvi', 'lvb', 'lvmin', 'lvmax',
    'svw', 'svh', 'svi', 'svb', 'svmin', 'svmax',
    'dvw', 'dvh', 'dvi', 'dvb', 'dvmin', 'dvmax',
    'pvw', 'pvh', 'pvi', 'pvb', 'pvmin', 'pvmax',
}
RELATIVE_UNITS = FONT_UNITS | VIEWPORT_UNITS
LENGTH_UNITS = ABSOLUTE_UNITS | RELATIVE_UNITS
# https://drafts.csswg.org/css-values-4/#angles
ANGLE_UNITS = set(ANGLE_TO_RADIANS)


def to_pixels(value, style, property_name, font_size=None):
    """Get number of pixels corresponding to a length."""
    if value.value == 0:
        return 0
    elif (unit := value.unit.lower()) == 'px':
        return value.value
    elif unit in LENGTHS_TO_PIXELS:
        # Convert absolute lengths to pixels.
        return value.value * LENGTHS_TO_PIXELS[unit]
    elif unit in FONT_UNITS:
        assert (style, font_size) != (None, None)
        if font_size is None:
            font_size = style['font_size']
        if unit == 'lh':
            if property_name in ('font_size', 'line_height'):
                if style.parent_style is None:
                    parent_style = style.root_style
                else:
                    parent_style = style.parent_style
                line_height, _ = strut(parent_style)
            else:
                line_height, _ = strut(style)
            return value.value * line_height
        elif unit == 'rlh':
            parent_style = style.root_style
            line_height, _ = strut(parent_style)
            return value.value * line_height
        elif unit == 'em':
            return value.value * font_size
        elif unit == 'rem':
            return value.value * style.root_style['font_size']
        elif unit.startswith('r'):
            ratio = character_ratio(style.root_style, unit[1:])
            return value.value * style.root_style['font_size'] * ratio
        else:
            ratio = character_ratio(style, unit)
            return value.value * font_size * ratio
    elif unit in VIEWPORT_UNITS:
        page_size = style.initial_page_sizes['box' if unit[0] == 'p' else 'area']
        if page_size is None:
            LOGGER.warn(f'{unit} unit resolved before first page layout')
            from .computed_values import INITIAL_PAGE_SIZE
            page_width = to_pixels(INITIAL_PAGE_SIZE[0], None, None)
            page_height = to_pixels(INITIAL_PAGE_SIZE[1], None, None)
        else:
            page_width, page_height = page_size
        # TODO: use writing-mode for vi and vb.
        if unit.endswith(('vw', 'vi')):
            return value.value / 100 * page_width
        elif unit.endswith(('vh', 'vb')):
            return value.value / 100 * page_height
        elif unit.endswith('vmin'):
            return value.value / 100 * min(page_width, page_height)
        elif unit.endswith('vmax'):
            return value.value / 100 * max(page_width, page_height)


def to_radians(value):
    """Get number of radians corresponding to an angle."""
    if (unit := value.unit.lower()) == 'rad':
        return value.value
    elif unit in ANGLE_TO_RADIANS:
        return value.value * ANGLE_TO_RADIANS[unit]


================================================
FILE: weasyprint/css/validation/__init__.py
================================================
"""Validate properties, expanders and descriptors."""

from cssselect2 import SelectorError, compile_selector_list
from tinycss2 import parse_blocks_contents, serialize
from tinycss2.ast import FunctionBlock, IdentToken, LiteralToken, WhitespaceToken

from ... import LOGGER
from ..tokens import InvalidValues, remove_whitespace
from .expanders import EXPANDERS
from .properties import PREFIX, PROPRIETARY, UNSTABLE, validate_non_shorthand

# Not applicable to the print media
NOT_PRINT_MEDIA = {
    # Aural media
    'azimuth',
    'cue',
    'cue-after',
    'cue-before',
    'elevation',
    'pause',
    'pause-after',
    'pause-before',
    'pitch-range',
    'pitch',
    'play-during',
    'richness',
    'speak-header',
    'speak-numeral',
    'speak-punctuation',
    'speak',
    'speech-rate',
    'stress',
    'voice-family',
    'volume',
    # Animations, transitions, timelines
    'animation',
    'animation-composition',
    'animation-delay',
    'animation-direction',
    'animation-duration',
    'animation-fill-mode',
    'animation-iteration-count',
    'animation-name',
    'animation-play-state',
    'animation-range',
    'animation-range-end',
    'animation-range-start',
    'animation-timeline',
    'animation-timing-function',
    'timeline-scope',
    'transition',
    'transition-delay',
    'transition-duration',
    'transition-property',
    'transition-timing-function',
    'view-timeline',
    'view-timeline-axis',
    'view-timeline-inset',
    'view-timeline-name',
    'view-transition-name',
    'will-change',
    # Dynamic and interactive
    'caret',
    'caret-color',
    'caret-shape',
    'cursor',
    'field-sizing',
    'pointer-events',
    'resize',
    'touch-action',
    # Browser viewport scrolling
    'overscroll-behavior',
    'overscroll-behavior-block',
    'overscroll-behavior-inline',
    'overscroll-behavior-x',
    'overscroll-behavior-y',
    'scroll-behavior',
    'scroll-margin',
    'scroll-margin-block',
    'scroll-margin-block-end',
    'scroll-margin-block-start',
    'scroll-margin-bottom',
    'scroll-margin-inline',
    'scroll-margin-inline-end',
    'scroll-margin-inline-start',
    'scroll-margin-left',
    'scroll-margin-right',
    'scroll-margin-top',
    'scroll-padding',
    'scroll-padding-block',
    'scroll-padding-block-end',
    'scroll-padding-block-start',
    'scroll-padding-bottom',
    'scroll-padding-inline',
    'scroll-padding-inline-end',
    'scroll-padding-inline-start',
    'scroll-padding-left',
    'scroll-padding-right',
    'scroll-padding-top',
    'scroll-snap-align',
    'scroll-snap-stop',
    'scroll-snap-type',
    'scroll-timeline',
    'scroll-timeline-axis',
    'scroll-timeline-name',
    'scrollbar-color',
    'scrollbar-gutter',
    'scrollbar-width',
}
NESTING_SELECTOR = LiteralToken(1, 1, '&')
ROOT_TOKEN = LiteralToken(1, 1, ':'), IdentToken(1, 1, 'root')


def preprocess_declarations(base_url, declarations, prelude=None):
    """Expand shorthand properties, filter unsupported properties and values.

    Log a warning for every ignored declaration.

    Return a iterable of ``(name, value, important)`` tuples.

    """
    # Compile list of selectors.
    if prelude is not None:
        try:
            if NESTING_SELECTOR in prelude:
                # Handle & selector in non-nested rule. MDN explains that & is
                # then equivalent to :scope, and :scope is equivalent to :root
                # as we don’t support :scope yet.
                original_prelude, prelude = prelude, []
                for token in original_prelude:
                    if token == NESTING_SELECTOR:
                        prelude.extend(ROOT_TOKEN)
                    else:
                        prelude.append(token)
            selectors = compile_selector_list(prelude)
        except SelectorError:
            raise SelectorError(f"'{serialize(prelude)}'")

    # Yield declarations.
    is_token = LiteralToken(1, 1, ':'), FunctionBlock(1, 1, 'is', prelude)
    for declaration in declarations:
        if declaration.type == 'error':
            LOGGER.warning(
                'Error: %s at %d:%d.',
                declaration.message,
                declaration.source_line, declaration.source_column)

        if declaration.type == 'qualified-rule':
            # Nested rule.
            if prelude is None:
                continue
            declaration_prelude = []
            token_groups = [[]]
            for token in declaration.prelude:
                if token == ',':
                    token_groups.append([])
                else:
                    token_groups[-1].append(token)
            for token_group in token_groups:
                if NESTING_SELECTOR in token_group:
                    # Replace & selector by parent.
                    for token in declaration.prelude:
                        if token == NESTING_SELECTOR:
                            declaration_prelude.extend(is_token)
                        else:
                            declaration_prelude.append(token)
                else:
                    # No & selector, prepend parent.
                    is_token = (
                        LiteralToken(1, 1, ':'),
                        FunctionBlock(1, 1, 'is', prelude))
                    declaration_prelude.extend([
                        *is_token, WhitespaceToken(1, 1, ' '),
                        *token_group])
                declaration_prelude.append(LiteralToken(1, 1, ','))
            yield from preprocess_declarations(
                base_url, parse_blocks_contents(declaration.content),
                declaration_prelude[:-1])

        if declaration.type != 'declaration':
            continue

        name = declaration.name
        if not name.startswith('--'):
            name = declaration.lower_name

        def validation_error(level, reason):
            getattr(LOGGER, level)(
                'Ignored `%s:%s` at %d:%d, %s.',
                declaration.name, serialize(declaration.value),
                declaration.source_line, declaration.source_column, reason)

        if name in NOT_PRINT_MEDIA:
            validation_error(
                'debug', 'the property does not apply for the print media')
            continue

        if name.startswith(PREFIX):
            unprefixed_name = name[len(PREFIX):]
            if unprefixed_name in PROPRIETARY:
                name = unprefixed_name
            elif unprefixed_name in UNSTABLE:
                LOGGER.warning(
                    'Deprecated `%s:%s` at %d:%d, '
                    'prefixes on unstable attributes are deprecated, '
                    'use %r instead.',
                    declaration.name, serialize(declaration.value),
                    declaration.source_line, declaration.source_column,
                    unprefixed_name)
                name = unprefixed_name
            else:
                LOGGER.warning(
                    'Ignored `%s:%s` at %d:%d, '
                    'prefix on this attribute is not supported, '
                    'use %r instead.',
                    declaration.name, serialize(declaration.value),
                    declaration.source_line, declaration.source_column,
                    unprefixed_name)
                continue

        if name.startswith('-') and not name.startswith('--'):
            validation_error('debug', 'prefixed selectors are ignored')
            continue

        validator = EXPANDERS.get(name, validate_non_shorthand)
        tokens = remove_whitespace(declaration.value)
        try:
            # Having no tokens is allowed by grammar but refused by all
            # properties and expanders.
            if not tokens:
                raise InvalidValues('no value')
            # Use list() to consume generators now and catch any error.
            result = list(validator(tokens, name, base_url))
        except InvalidValues as exc:
            validation_error(
                'warning',
                exc.args[0] if exc.args and exc.args[0] else 'invalid value')
            continue

        important = declaration.important
        for long_name, value in result:
            if prelude is not None:
                declaration = (long_name.replace('-', '_'), value, important)
                yield selectors, declaration
            else:
                yield long_name.replace('-', '_'), value, important


================================================
FILE: weasyprint/css/validation/descriptors.py
================================================
"""Validate descriptors used for some at-rules."""

from math import inf

import tinycss2

from ...logger import LOGGER
from . import properties

from ..tokens import (  # isort:skip
    InvalidValues, comma_separated_list, get_custom_ident, get_keyword, get_number,
    get_single_keyword, get_url, remove_whitespace, single_keyword, single_token,
    split_on_comma)

DESCRIPTORS = {
    'font-face': {},
    'counter-style': {},
    'color-profile': {},
}
NOT_PRINT_MEDIA = (
    'font-display',
)


class NoneFakeToken:
    type = 'ident'
    lower_value = 'none'


class NormalFakeToken:
    type = 'ident'
    lower_value = 'normal'


def preprocess_descriptors(rule, base_url, descriptors):
    """Filter unsupported names and values for descriptors.

    Log a warning for every ignored descriptor.

    Return a iterable of ``(name, value)`` tuples.

    """
    for descriptor in descriptors:
        if descriptor.type != 'declaration' or descriptor.important:
            continue
        tokens = remove_whitespace(descriptor.value)
        try:
            if descriptor.name in NOT_PRINT_MEDIA:
                continue
            elif descriptor.name not in DESCRIPTORS[rule]:
                raise InvalidValues('descriptor not supported')

            function = DESCRIPTORS[rule][descriptor.name]
            if function.wants_base_url:
                value = function(tokens, base_url)
            else:
                value = function(tokens)
            if value is None:
                raise InvalidValues
            result = ((descriptor.name, value),)
        except InvalidValues as exc:
            LOGGER.warning(
                'Ignored `%s:%s` at %d:%d, %s.',
                descriptor.name, tinycss2.serialize(descriptor.value),
                descriptor.source_line, descriptor.source_column,
                exc.args[0] if exc.args and exc.args[0] else 'invalid value')
            continue

        for long_name, value in result:
            yield long_name.replace('-', '_'), value


def descriptor(rule, descriptor_name=None, wants_base_url=False):
    """Decorator adding a function to the ``DESCRIPTORS``.

    The name of the descriptor covered by the decorated function is set to
    ``descriptor_name`` if given, or is inferred from the function name
    (replacing underscores by hyphens).

    :param wants_base_url:
        The function takes the stylesheet’s base URL as an additional
        parameter.

    """
    def decorator(function):
        """Add ``function`` to the ``DESCRIPTORS``."""
        if descriptor_name is None:
            name = function.__name__.replace('_', '-')
        else:
            name = descriptor_name
        assert name not in DESCRIPTORS[rule], name

        function.wants_base_url = wants_base_url
        DESCRIPTORS[rule][name] = function
        return function
    return decorator


def expand_font_variant(tokens):
    keyword = get_single_keyword(tokens)
    if keyword in ('normal', 'none'):
        for suffix in (
                '-alternates', '-caps', '-east-asian', '-numeric',
                '-position'):
            yield suffix, [NormalFakeToken]
        token = NormalFakeToken if keyword == 'normal' else NoneFakeToken
        yield '-ligatures', [token]
    else:
        features = {
            'alternates': [],
            'caps': [],
            'east-asian': [],
            'ligatures': [],
            'numeric': [],
            'position': []}
        for token in tokens:
            keyword = get_keyword(token)
            if keyword == 'normal':
                # We don't allow 'normal', only the specific values
                raise InvalidValues
            for feature in features:
                function_name = f'font_variant_{feature.replace("-", "_")}'
                if getattr(properties, function_name)([token]):
                    features[feature].append(token)
                    break
            else:
                raise InvalidValues
        for feature, tokens in features.items():
            if tokens:
                yield (f'-{feature}', tokens)


@descriptor('font-face')
def font_family(tokens, allow_spaces=False):
    """``font-family`` descriptor validation."""
    allowed_types = ['ident']
    if allow_spaces:
        allowed_types.append('whitespace')
    if len(tokens) == 1 and tokens[0].type == 'string':
        return tokens[0].value
    if tokens and all(token.type in allowed_types for token in tokens):
        return ' '.join(
            token.value for token in tokens if token.type == 'ident')


@descriptor('font-face', wants_base_url=True)
@comma_separated_list
def src(tokens, base_url):
    """``src`` descriptor validation."""
    if len(tokens) in (1, 2):
        tokens, token = tokens[:-1], tokens[-1]
        if token.type == 'function' and token.lower_name == 'format':
            tokens, token = tokens[:-1], tokens[-1]
        if token.type == 'function' and token.lower_name == 'local':
            return 'local', font_family(token.arguments, allow_spaces=True)
        url = get_url(token, base_url)
        if url is not None and url[0] == 'url':
            return url[1]


@descriptor('font-face')
@single_keyword
def font_style(keyword):
    """``font-style`` descriptor validation."""
    return keyword in ('normal', 'italic', 'oblique')


@descriptor('font-face')
@single_token
def font_weight(token):
    """``font-weight`` descriptor validation."""
    keyword = get_keyword(token)
    if keyword in ('normal', 'bold'):
        return keyword
    if number := get_number(token, integer=True):
        if number.value in (100, 200, 300, 400, 500, 600, 700, 800, 900):
            return number.value


@descriptor('font-face')
@single_keyword
def font_stretch(keyword):
    """``font-stretch`` descriptor validation."""
    return keyword in (
        'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed',
        'normal',
        'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded')


@descriptor('font-face')
def font_feature_settings(tokens):
    """``font-feature-settings`` descriptor validation."""
    return properties.font_feature_settings(tokens)


@descriptor('font-face')
def font_variant(tokens):
    """``font-variant`` descriptor validation."""
    if len(tokens) == 1:
        keyword = get_keyword(tokens[0])
        if keyword in ('normal', 'none', 'inherit'):
            return []
    values = []
    for name, sub_tokens in expand_font_variant(tokens):
        try:
            values.append(properties.validate_non_shorthand(
                sub_tokens, f'font-variant{name}', required=True))
        except InvalidValues:
            return None
    return values


@descriptor('font-face')
@comma_separated_list
@single_token
def unicode_range(token):
    """``unicode_range`` descriptor validation."""
    if token.type == 'unicode-range':
        return token


@descriptor('counter-style')
def system(tokens):
    """``system`` descriptor validation."""
    if len(tokens) > 2:
        return

    keyword = get_keyword(tokens[0])
    if keyword == 'extends':
        if len(tokens) == 2:
            if second_keyword := get_keyword(tokens[1]):
                return (keyword, second_keyword, None)
    elif keyword == 'fixed':
        if len(tokens) == 1:
            return (None, 'fixed', 1)
        elif number := get_number(tokens[1], integer=True):
            return (None, 'fixed', number.value)
    elif len(tokens) == 1 and keyword in (
            'cyclic', 'numeric', 'alphabetic', 'symbolic', 'additive'):
        return (None, keyword, None)


@descriptor('counter-style', wants_base_url=True)
def negative(tokens, base_url):
    """``negative`` descriptor validation."""
    if len(tokens) > 2:
        return

    values = []
    tokens = list(tokens)
    while tokens:
        token = tokens.pop(0)
        if token.type in ('string', 'ident'):
            values.append(('string', token.value))
            continue
        url = get_url(token, base_url)
        if url is not None and url[0] == 'url':
            values.append(('url', url[1]))

    if len(values) == 1:
        values.append(('string', ''))

    if len(values) == 2:
        return values


@descriptor('counter-style', 'prefix', wants_base_url=True)
@descriptor('counter-style', 'suffix', wants_base_url=True)
def prefix_suffix(tokens, base_url):
    """``prefix`` and ``suffix`` descriptors validation."""
    if len(tokens) != 1:
        return

    token, = tokens
    if token.type in ('string', 'ident'):
        return ('string', token.value)
    url = get_url(token, base_url)
    if url is not None and url[0] == 'url':
        return ('url', url[1])


@descriptor('counter-style')
@comma_separated_list
def range(tokens):
    """``range`` descriptor validation."""
    if len(tokens) == 1:
        keyword = get_single_keyword(tokens)
        if keyword == 'auto':
            return 'auto'
    elif len(tokens) == 2:
        values = []
        for i, token in enumerate(tokens):
            if token.type == 'ident' and token.value == 'infinite':
                values.append(inf if i else -inf)
            elif number := get_number(token, integer=True):
                values.append(number.value)
        if len(values) == 2 and values[0] <= values[1]:
            return tuple(values)


@descriptor('counter-style', wants_base_url=True)
def pad(tokens, base_url):
    """``pad`` descriptor validation."""
    if len(tokens) == 2:
        values = [None, None]
        for token in tokens:
            if number := get_number(token, integer=True, negative=False):
                if values[0] is None:
                    values[0] = number.value
            elif token.type in ('string', 'ident'):
                values[1] = ('string', token.value)
            url = get_url(token, base_url)
            if url is not None and url[0] == 'url':
                values[1] = ('url', url[1])

        if None not in values:
            return tuple(values)


@descriptor('counter-style')
@single_token
def fallback(token):
    """``fallback`` descriptor validation."""
    ident = get_custom_ident(token)
    if ident != 'none':
        return ident


@descriptor('counter-style', wants_base_url=True)
def symbols(tokens, base_url):
    """``symbols`` descriptor validation."""
    values = []
    for token in tokens:
        if token.type in ('string', 'ident'):
            values.append(('string', token.value))
            continue
        url = get_url(token, base_url)
        if url is not None and url[0] == 'url':
            values.append(('url', url[1]))
            continue
        return
    return tuple(values)


@descriptor('counter-style', wants_base_url=True)
def additive_symbols(tokens, base_url):
    """``additive-symbols`` descriptor validation."""
    results = []
    for part in split_on_comma(tokens):
        if not (result := pad(remove_whitespace(part), base_url)):
            return
        if results and results[-1][0] <= result[0]:
            return
        results.append(result)
    return tuple(results)


@descriptor('color-profile', descriptor_name='src', wants_base_url=True)
@single_token
def color_profile_src(token, base_url):
    url = get_url(token, base_url)
    if url is not None and url[0] == 'url':
        return url[1]


@descriptor('color-profile')
@single_keyword
def rendering_intent(keyword):
    possible_values = (
        'relative-colorimetric', 'absolute-colorimetric', 'perceptual', 'saturation')
    if keyword in possible_values:
        return keyword


@descriptor('color-profile')
@comma_separated_list
def components(tokens):
    components = []
    for token in tokens:
        if token.type == 'ident':
            components.append(token.value)
        else:
            return
    return components


================================================
FILE: weasyprint/css/validation/expanders.py
================================================
"""Validate properties expanders."""

import functools

from tinycss2.ast import DimensionToken, IdentToken, NumberToken
from tinycss2.color5 import parse_color

from ..functions import check_var
from ..properties import INITIAL_VALUES
from .descriptors import expand_font_variant

from ..tokens import (  # isort:skip
    InvalidValues, Pending, get_keyword, get_single_keyword, split_on_comma)
from .properties import (  # isort:skip
    background_attachment, background_image, background_position, background_repeat,
    background_size, block_ellipsis, border_image_source, border_image_slice,
    border_image_width, border_image_outset, border_image_repeat, border_style,
    border_width, box, column_count, column_width, flex_basis, flex_direction,
    flex_grow_shrink, flex_wrap, font_family, font_size, font_stretch, font_style,
    font_variant_caps, font_weight, gap, grid_line, grid_template, line_height,
    list_style_image, list_style_position, list_style_type, mask_border_mode,
    other_colors, overflow_wrap, text_decoration_thickness, validate_non_shorthand)

EXPANDERS = {}


class PendingExpander(Pending):
    """Expander with validation done when defining calculated values."""
    def __init__(self, tokens, validator):
        super().__init__(tokens, validator.keywords['name'])
        self.validator = validator

    def validate(self, tokens, wanted_key):
        for key, value in self.validator(tokens):
            if key.startswith('-'):
                key = f'{self.validator.keywords["name"]}{key}'
            if key == wanted_key:
                return value
        raise KeyError


def _find_var(tokens, expander, expanded_names):
    """Return pending expanders when var is found in tokens."""
    for token in tokens:
        if check_var(token):
            # Found CSS variable, keep pending-substitution values.
            pending = PendingExpander(tokens, expander)
            return {name: pending for name in expanded_names}


def expander(property_name):
    """Decorator adding a function to the ``EXPANDERS``."""
    def expander_decorator(function):
        """Add ``function`` to the ``EXPANDERS``."""
        assert property_name not in EXPANDERS, property_name
        EXPANDERS[property_name] = function
        return function
    return expander_decorator


def generic_expander(*expanded_names, **kwargs):
    """Decorator helping expanders to handle ``inherit`` and ``initial``.

    Wrap an expander so that it does not have to handle the 'inherit' and
    'initial' cases, and can just yield name suffixes. Missing suffixes
    get the initial value.

    """
    wants_base_url = kwargs.pop('wants_base_url', False)
    assert not kwargs

    def generic_expander_decorator(wrapped):
        """Decorate the ``wrapped`` expander."""
        @functools.wraps(wrapped)
        def generic_expander_wrapper(tokens, name, base_url):
            """Wrap the expander."""
            expander = functools.partial(
                generic_expander_wrapper, name=name, base_url=base_url)

            skip_validation = False
            keyword = get_single_keyword(tokens)
            if keyword in ('inherit', 'initial'):
                results = {name: keyword for name in expanded_names}
                skip_validation = True
            else:
                results = _find_var(tokens, expander, expanded_names)
                if results:
                    skip_validation = True

            if not skip_validation:
                results = {}
                if wants_base_url:
                    result = wrapped(tokens, name, base_url)
                else:
                    result = wrapped(tokens, name)
                for new_name, new_token in result:
                    assert new_name in expanded_names, new_name
                    if new_name in results:
                        raise InvalidValues(
                            f'got multiple {new_name.strip("-")} values '
                            f'in a {name} shorthand')
                    results[new_name] = new_token

            for new_name in expanded_names:
                if new_name.startswith('-'):
                    # new_name is a suffix
                    actual_new_name = f'{name}{new_name}'
                else:
                    actual_new_name = new_name

                if new_name in results:
                    value = results[new_name]
                    if not skip_validation:
                        # validate_non_shorthand returns ((name, value),)
                        (actual_new_name, value), = validate_non_shorthand(
                            value, actual_new_name, base_url, required=True)
                else:
                    value = 'initial'

                yield actual_new_name, value
        return generic_expander_wrapper
    return generic_expander_decorator


@expander('margin-block')
@expander('margin-inline')
@expander('padding-block')
@expander('padding-inline')
@expander('border-block-color')
@expander('border-block-style')
@expander('border-block-width')
@expander('border-inline-color')
@expander('border-inline-style')
@expander('border-inline-width')
@expander('inset-block')
@expander('inset-inline')
def expand_two_logical_sides(tokens, name, base_url):
    """Expand properties setting a token for two logical sides of a box."""
    yield from _expand_sides(tokens, name, base_url, ('start', 'end'))


@expander('border-color')
@expander('border-style')
@expander('border-width')
@expander('margin')
@expander('padding')
@expander('bleed')
@expander('inset')
def expand_four_sides(tokens, name, base_url):
    """Expand properties setting a token for four sides of a box, possibly logical."""
    sides = ('top', 'right', 'bottom', 'left')
    if tokens and get_keyword(tokens[0]) == 'logical':
        sides = ('block-start', 'inline-start', 'block-end', 'inline-end')
        tokens = tokens[1:]
    yield from _expand_sides(tokens, name, base_url, sides)


def _expand_sides(tokens, name, base_url, sides):
    """Expand properties setting a token for two or four sides of a box."""
    # Define expanded names.
    expanded_names = []
    for side in sides:
        if name.endswith(('-color', '-style', '-width')):
            # For example, border-color becomes border-*-color, not border-color-*.
            expanded_names.append(f'{name[:-6]}-{side}-{name[-5:]}')
        else:
            if name == 'inset' and '-' not in side:
                # Physical "inset" does not yield "inset-top", just "top".
                expanded_names.append(side)
            else:
                expanded_names.append(f'{name}-{side}')

    # Return pending expanders if var is found.
    expander = functools.partial(expand_four_sides, name=name, base_url=base_url)
    if result := _find_var(tokens, expander, expanded_names):
        yield from result.items()
        return

    # Make sure we have the right number of tokens.
    if len(tokens) == 1:
        tokens *= len(sides)
    elif len(sides) == 4 and len(tokens) == 2:
        tokens *= 2  # (bottom, left) defaults to (top, right)
    elif len(sides) == 4 and len(tokens) == 3:
        tokens += (tokens[1],)  # left defaults to right
    elif len(tokens) != len(sides):
        raise InvalidValues(f'Expected 1 to {len(sides)} tokens, got {len(tokens)}')
    for expanded_name, token in zip(expanded_names, tokens):
        # validate_non_shorthand returns ((name, value),), we yield (name, value).
        yield validate_non_shorthand([token], expanded_name, base_url, required=True)[0]


@expander('border-radius')
@generic_expander(
    'border-top-left-radius', 'border-top-right-radius',
    'border-bottom-right-radius', 'border-bottom-left-radius',
    wants_base_url=True)
def border_radius(tokens, name, base_url):
    """Validator for the ``border-radius`` property."""
    current = horizontal = []
    vertical = []
    for token in tokens:
        if token.type == 'literal' and token.value == '/':
            if current is horizontal:
                if token == tokens[-1]:
                    raise InvalidValues('Expected value after "/" separator')
                else:
                    current = vertical
            else:
                raise InvalidValues('Expected only one "/" separator')
        else:
            current.append(token)

    if not vertical:
        vertical = horizontal[:]

    for values in horizontal, vertical:
        # Make sure we have 4 tokens
        if len(values) == 1:
            values *= 4
        elif len(values) == 2:
            values *= 2  # (br, bl) defaults to (tl, tr)
        elif len(values) == 3:
            values.append(values[1])  # bl defaults to tr
        elif len(values) != 4:
            raise InvalidValues(
                f'Expected 1 to 4 token components got {len(values)}')
    corners = ('top-left', 'top-right', 'bottom-right', 'bottom-left')
    for corner, tokens in zip(corners, zip(horizontal, vertical)):
        name = f'border-{corner}-radius'
        validate_non_shorthand(tokens, name, base_url, required=True)
        yield name, tokens


@expander('list-style')
@generic_expander('-type', '-position', '-image', wants_base_url=True)
def expand_list_style(tokens, name, base_url):
    """Expand the ``list-style`` shorthand property.

    See https://www.w3.org/TR/CSS21/generate.html#propdef-list-style

    """
    type_specified = image_specified = False
    none_count = 0
    for token in tokens:
        if get_keyword(token) == 'none':
            # Can be either -style or -image, see at the end which is not
            # otherwise specified.
            none_count += 1
            none_token = token
            continue

        if list_style_image([token], base_url) is not None:
            suffix = '-image'
            image_specified = True
        elif list_style_position([token]) is not None:
            suffix = '-position'
        elif list_style_type([token]) is not None:
            suffix = '-type'
            type_specified = True
        else:
            raise InvalidValues
        yield suffix, [token]

    if not type_specified and none_count:
        yield '-type', [none_token]
        none_count -= 1

    if not image_specified and none_count:
        yield '-image', [none_token]
        none_count -= 1

    if none_count:
        # Too many none tokens.
        raise InvalidValues


@expander('border')
def expand_border(tokens, name, base_url):
    """Expand the ``border`` shorthand property.

    See https://www.w3.org/TR/CSS21/box.html#propdef-border

    """
    for suffix in ('top', 'right', 'bottom', 'left'):
        yield from expand_border_side(tokens, f'{name}-{suffix}', base_url)


@expander('border-block')
@expander('border-inline')
def expand_logical_border(tokens, name, base_url):
    """Expand the logical ``border-*`` shorthands property."""
    for suffix in ('start', 'end'):
        yield from expand_border_side(tokens, f'{name}-{suffix}', base_url)


@expander('border-top')
@expander('border-right')
@expander('border-bottom')
@expander('border-left')
@expander('border-block-start')
@expander('border-block-end')
@expander('border-inline-start')
@expander('border-inline-end')
@expander('column-rule')
@expander('outline')
@generic_expander('-width', '-color', '-style')
def expand_border_side(tokens, name):
    """Expand the ``border-*`` shorthand properties.

    See https://www.w3.org/TR/CSS21/box.html#propdef-border-top

    """
    for token in tokens:
        if parse_color(token) is not None:
            suffix = '-color'
        elif border_width([token]) is not None:
            suffix = '-width'
        elif border_style([token]) is not None:
            suffix = '-style'
        else:
            raise InvalidValues
        yield suffix, [token]


@expander('border-image')
@generic_expander('-outset', '-repeat', '-slice', '-source', '-width',
                  wants_base_url=True)
def expand_border_image(tokens, name, base_url):
    """Expand the ``border-image-*`` shorthand properties.

    See https://drafts.csswg.org/css-backgrounds/#the-border-image

    """
    tokens = list(tokens)
    while tokens:
        if border_image_source(tokens[:1], base_url):
            yield '-source', [tokens.pop(0)]
        elif border_image_repeat(tokens[:1]):
            repeats = [tokens.pop(0)]
            while tokens and border_image_repeat(tokens[:1]):
                repeats.append(tokens.pop(0))
            yield '-repeat', repeats
        elif border_image_slice(tokens[:1]) or get_keyword(tokens[0]) == 'fill':
            slices = [tokens.pop(0)]
            while tokens and border_image_slice(slices + tokens[:1]):
                slices.append(tokens.pop(0))
            yield '-slice', slices
            if tokens and tokens[0].type == 'literal' and tokens[0].value == '/':
                # slices / *
                tokens.pop(0)
            else:
                # slices other
                continue
            if not tokens:
                # slices /
                raise InvalidValues
            if border_image_width(tokens[:1]):
                widths = [tokens.pop(0)]
                while tokens and border_image_width(widths + tokens[:1]):
                    widths.append(tokens.pop(0))
                yield '-width', widths
                if tokens and tokens[0].type == 'literal' and tokens[0].value == '/':
                    # slices / widths / slash *
                    tokens.pop(0)
                else:
                    # slices / widths other
                    continue
            elif tokens and tokens[0].type == 'literal' and tokens[0].value == '/':
                # slices / / *
                tokens.pop(0)
            else:
                # slices / other
                raise InvalidValues
            if not tokens:
                # slices / * /
                raise InvalidValues
            if border_image_outset(tokens[:1]):
                outsets = [tokens.pop(0)]
                while tokens and border_image_outset(outsets + tokens[:1]):
                    outsets.append(tokens.pop(0))
                yield '-outset', outsets
            else:
                # slash / * / other
                raise InvalidValues
        else:
            raise InvalidValues


@expander('mask-border')
@generic_expander('-outset', '-repeat', '-slice', '-source', '-width', '-mode',
                  wants_base_url=True)
def expand_mask_border(tokens, name, base_url):
    """Expand the ``mask-border-*`` shorthand properties.

    See https://drafts.fxtf.org/css-masking/#the-mask-border

    """
    tokens = list(tokens)
    while tokens:
        if border_image_source(tokens[:1], base_url):
            yield '-source', [tokens.pop(0)]
        elif mask_border_mode(tokens[:1]):
            yield '-mode', [tokens.pop(0)]
        elif border_image_repeat(tokens[:1]):
            repeats = [tokens.pop(0)]
            while tokens and border_image_repeat(tokens[:1]):
                repeats.append(tokens.pop(0))
            yield '-repeat', repeats
        elif border_image_slice(tokens[:1]) or get_keyword(tokens[0]) == 'fill':
            slices = [tokens.pop(0)]
            while tokens and border_image_slice(slices + tokens[:1]):
                slices.append(tokens.pop(0))
            yield '-slice', slices
            if tokens and tokens[0].type == 'literal' and tokens[0].value == '/':
                # slices / *
                tokens.pop(0)
            else:
                # slices other
                continue
            if not tokens:
                # slices /
                raise InvalidValues
            if border_image_width(tokens[:1]):
                widths = [tokens.pop(0)]
                while tokens and border_image_width(widths + tokens[:1]):
                    widths.append(tokens.pop(0))
                yield '-width', widths
                if tokens and tokens[0].type == 'literal' and tokens[0].value == '/':
                    # slices / widths / slash *
                    tokens.pop(0)
                else:
                    # slices / widths other
                    continue
            elif tokens and tokens[0].type == 'literal' and tokens[0].value == '/':
                # slices / / *
                tokens.pop(0)
            else:
                # slices / other
                raise InvalidValues
            if not tokens:
                # slices / * /
                raise InvalidValues
            if border_image_outset(tokens[:1]):
                outsets = [tokens.pop(0)]
                while tokens and border_image_outset(outsets + tokens[:1]):
                    outsets.append(tokens.pop(0))
                yield '-outset', outsets
            else:
                # slash / * / other
                raise InvalidValues
        else:
            raise InvalidValues


@expander('background')
def expand_background(tokens, name, base_url):
    """Expand the ``background`` shorthand property.

    See https://drafts.csswg.org/css-backgrounds-3/#the-background

    """
    expanded_names = (
        'background-color', 'background-image', 'background-repeat',
        'background-attachment', 'background-position', 'background-size',
        'background-clip', 'background-origin')
    keyword = get_single_keyword(tokens)
    if keyword in ('initial', 'inherit'):
        for name in expanded_names:
            yield name, keyword
        return

    expander = functools.partial(
        expand_background, name=name, base_url=base_url)
    if result := _find_var(tokens, expander, expanded_names):
        yield from result.items()
        return

    def parse_layer(tokens, final_layer=False):
        results = {}

        def add(name, value):
            if value is None:
                return False
            name = f'background-{name}'
            if name in results:
                raise InvalidValues
            results[name] = value
            return True

        # Make `tokens` a stack
        tokens = tokens[::-1]
        while tokens:
            if add('repeat',
                   background_repeat.single_value(tokens[-2:][::-1])):
                del tokens[-2:]
                continue
            token = tokens[-1:]
            if final_layer and add('color', other_colors(token)):
                tokens.pop()
                continue
            if add('image', background_image.single_value(token, base_url)):
                tokens.pop()
                continue
            if add('repeat', background_repeat.single_value(token)):
                tokens.pop()
                continue
            if add('attachment', background_attachment.single_value(token)):
                tokens.pop()
                continue
            for n in (4, 3, 2, 1)[-len(tokens):]:
                n_tokens = tokens[-n:][::-1]
                position = background_position.single_value(n_tokens)
                if position is not None:
                    assert add('position', position)
                    del tokens[-n:]
                    if (tokens and tokens[-1].type == 'literal' and
                            tokens[-1].value == '/'):
                        for n in (3, 2)[-len(tokens):]:
                            # n includes the '/' delimiter.
                            n_tokens = tokens[-n:-1][::-1]
                            size = background_size.single_value(n_tokens)
                            if size is not None:
                                assert add('size', size)
                                del tokens[-n:]
                    break
            if position is not None:
                continue
            if add('origin', box.single_value(token)):
                tokens.pop()
                next_token = tokens[-1:]
                if add('clip', box.single_value(next_token)):
                    tokens.pop()
                else:
                    # The same keyword sets both
                    add('clip', box.single_value(token))
                continue
            raise InvalidValues

        color = results.pop(
            'background-color', INITIAL_VALUES['background_color'])
        for name in expanded_names:
            if name not in results and name != 'background-color':
                results[name] = INITIAL_VALUES[name.replace('-', '_')][0]
        return color, results

    layers = reversed(split_on_comma(tokens))
    color, last_layer = parse_layer(next(layers), final_layer=True)
    results = {key: [value] for key, value in last_layer.items()}
    for tokens in layers:
        _, layer = parse_layer(tokens)
        for name, value in layer.items():
            results[name].append(value)
    for name, values in results.items():
        yield name, values[::-1]  # "Un-reverse"
    yield 'background-color', color


@expander('text-decoration')
@generic_expander('-line', '-color', '-style', '-thickness')
def expand_text_decoration(tokens, name):
    """Expand the ``text-decoration`` shorthand property."""
    line = []
    color = []
    style = []
    thickness = []
    none_in_line = False

    for token in tokens:
        keyword = get_keyword(token)
        if keyword in ('none', 'underline', 'overline', 'line-through', 'blink'):
            line.append(token)
            if none_in_line:
                raise InvalidValues
            elif keyword == 'none':
                none_in_line = True
        elif keyword in ('solid', 'double', 'dotted', 'dashed', 'wavy'):
            if style:
                raise InvalidValues
            style.append(token)
        elif parse_color(token):
            if color:
                raise InvalidValues
            color.append(token)
        elif text_decoration_thickness([token]):
            if thickness:
                raise InvalidValues
            thickness.append(token)
        else:
            raise InvalidValues

    if line:
        yield '-line', line
    if color:
        yield '-color', color
    if style:
        yield '-style', style
    if thickness:
        yield '-thickness', thickness


def expand_page_break_before_after(tokens, name):
    """Expand legacy ``page-break-before`` and ``page-break-after`` properties.

    See https://www.w3.org/TR/css-break-3/#page-break-properties

    """
    keyword = get_single_keyword(tokens)
    new_name = name.split('-', 1)[1]
    if keyword in ('auto', 'left', 'right', 'avoid'):
        yield new_name, tokens
    elif keyword == 'always':
        token = IdentToken(
            tokens[0].source_line, tokens[0].source_column, 'page')
        yield new_name, [token]
    else:
        raise InvalidValues


@expander('page-break-after')
@generic_expander('break-after')
def expand_page_break_after(tokens, name):
    """Expand legacy ``page-break-after`` property.

    See https://www.w3.org/TR/css-break-3/#page-break-properties

    """
    return expand_page_break_before_after(tokens, name)


@expander('page-break-before')
@generic_expander('break-before')
def expand_page_break_before(tokens, name):
    """Expand legacy ``page-break-before`` property.

    See https://www.w3.org/TR/css-break-3/#page-break-properties

    """
    return expand_page_break_before_after(tokens, name)


@expander('page-break-inside')
@generic_expander('break-inside')
def expand_page_break_inside(tokens, name):
    """Expand the legacy ``page-break-inside`` property.

    See https://www.w3.org/TR/css-break-3/#page-break-properties

    """
    keyword = get_single_keyword(tokens)
    if keyword in ('auto', 'avoid'):
        yield 'break-inside', tokens
    else:
        raise InvalidValues


@expander('columns')
@generic_expander('column-width', 'column-count')
def expand_columns(tokens, name):
    """Expand the ``columns`` shorthand property."""
    name = None
    if len(tokens) == 2 and get_keyword(tokens[0]) == 'auto':
        tokens = tokens[::-1]
    for token in tokens:
        if column_width([token]) is not None and name != 'column-width':
            name = 'column-width'
        elif column_count([token]) is not None:
            name = 'column-count'
        else:
            raise InvalidValues
        yield name, [token]
    if len(tokens) == 1:
        name = 'column-width' if name == 'column-count' else 'column-count'
        token = IdentToken(
            tokens[0].source_line, tokens[0].source_column, 'auto')
        yield name, [token]


@expander('font-variant')
@generic_expander('-alternates', '-caps', '-east-asian', '-ligatures',
                  '-numeric', '-position')
def font_variant(tokens, name):
    """Expand the ``font-variant`` shorthand property.

    https://www.w3.org/TR/css-fonts-3/#font-variant-prop

    """
    return expand_font_variant(tokens)


@expander('font')
@generic_expander('-style', '-variant-caps', '-weight', '-stretch', '-size',
                  'line-height', '-family')  # line-height is not a suffix
def expand_font(tokens, name):
    """Expand the ``font`` shorthand property.

    https://www.w3.org/TR/css-fonts-3/#font-prop

    """
    expand_font_keyword = get_single_keyword(tokens)
    if expand_font_keyword in ('caption', 'icon', 'menu', 'message-box',
                               'small-caption', 'status-bar'):
        raise InvalidValues('System fonts are not supported')

    # Make `tokens` a stack
    tokens = list(reversed(tokens))
    # Values for font-style, font-variant-caps, font-weight and font-stretch
    # can come in any order and are all optional.
    for _ in range(4):
        token = tokens.pop()
        if get_keyword(token) == 'normal':
            # Just ignore 'normal' keywords. Unspecified properties will get
            # their initial token, which is 'normal' for all four here.
            continue

        if font_style([token]) is not None:
            suffix = '-style'
        elif font_variant_caps([token]) is not None:
            suffix = '-variant-caps'
        elif font_weight([token]) is not None:
            suffix = '-weight'
        elif font_stretch([token]) is not None:
            suffix = '-stretch'
        else:
            # We’re done with these four, continue with font-size
            break
        yield suffix, [token]

        if not tokens:
            raise InvalidValues
    else:
        if not tokens:
            raise InvalidValues
        token = tokens.pop()

    # Then font-size is mandatory
    # Latest `token` from the loop.
    if font_size([token]) is None:
        raise InvalidValues
    yield '-size', [token]

    # Then line-height is optional, but font-family is not so the list
    # must not be empty yet
    if not tokens:
        raise InvalidValues

    token = tokens.pop()
    if token.type == 'literal' and token.value == '/':
        token = tokens.pop()
        if line_height([token]) is None:
            raise InvalidValues
        yield 'line-height', [token]
    else:
        # We pop()ed a font-family, add it back
        tokens.append(token)

    # Reverse the stack to get normal list
    tokens.reverse()
    if font_family(tokens) is None:
        raise InvalidValues
    yield '-family', tokens


@expander('word-wrap')
@generic_expander('overflow-wrap')
def expand_word_wrap(tokens, name):
    """Expand the ``word-wrap`` legacy property.

    See https://www.w3.org/TR/css-text-3/#overflow-wrap

    """
    keyword = overflow_wrap(tokens)
    if keyword is None:
        raise InvalidValues
    yield 'overflow-wrap', tokens


@expander('flex')
@generic_expander('-grow', '-shrink', '-basis')
def expand_flex(tokens, name):
    """Expand the ``flex`` property."""
    keyword = get_single_keyword(tokens)
    if keyword == 'none':
        line, column = tokens[0].source_line, tokens[0].source_column
        zero_token = NumberToken(line, column, 0, 0, '0')
        auto_token = IdentToken(line, column, 'auto')
        yield '-grow', [zero_token]
        yield '-shrink', [zero_token]
        yield '-basis', [auto_token]
    else:
        grow, shrink, basis = 1, 1, None
        grow_found, shrink_found, basis_found = False, False, False
        for token in tokens:
            # "A unitless zero that is not already preceded by two flex factors
            # must be interpreted as a flex factor."
            forced_flex_factor = (
                token.type == 'number' and token.int_value == 0 and
                not all((grow_found, shrink_found)))
            if not basis_found and not forced_flex_factor:
                new_basis = flex_basis([token])
                if new_basis is not None:
                    basis = token
                    basis_found = True
                    continue
            if not grow_found:
                new_grow = flex_grow_shrink([token])
                if new_grow is None:
                    raise InvalidValues
                else:
                    grow = new_grow
                    grow_found = True
                    continue
            elif not shrink_found:
                new_shrink = flex_grow_shrink([token])
                if new_shrink is None:
                    raise InvalidValues
                else:
                    shrink = new_shrink
                    shrink_found = True
                    continue
            else:
                raise InvalidValues
        line, column = tokens[0].source_line, tokens[0].source_column
        int_grow = int(grow) if float(grow).is_integer() else None
        int_shrink = int(shrink) if float(shrink).is_integer() else None
        grow_token = NumberToken(line, column, grow, int_grow, str(grow))
        shrink_token = NumberToken(
            line, column, shrink, int_shrink, str(shrink))
        if not basis_found:
            basis = DimensionToken(line, column, 0, 0, '0', 'px')
        yield '-grow', [grow_token]
        yield '-shrink', [shrink_token]
        yield '-basis', [basis]


@expander('flex-flow')
@generic_expander('flex-direction', 'flex-wrap')
def expand_flex_flow(tokens, name):
    """Expand the ``flex-flow`` property."""
    if len(tokens) == 2:
        for sorted_tokens in tokens, tokens[::-1]:
            direction = flex_direction([sorted_tokens[0]])
            wrap = flex_wrap([sorted_tokens[1]])
            if direction and wrap:
                yield 'flex-direction', [sorted_tokens[0]]
                yield 'flex-wrap', [sorted_tokens[1]]
                break
        else:
            raise InvalidValues
    elif len(tokens) == 1:
        direction = flex_direction([tokens[0]])
        if direction:
            yield 'flex-direction', [tokens[0]]
        else:
            wrap = flex_wrap([tokens[0]])
            if wrap:
                yield 'flex-wrap', [tokens[0]]
            else:
                raise InvalidValues
    else:
        raise InvalidValues


def _expand_grid_template(tokens, name):
    line, column = tokens[0].source_line, tokens[0].source_column
    none = IdentToken(line, column, 'none')
    if len(tokens) == 1 and get_keyword(tokens[0]) == 'none':
        yield '-columns', [none]
        yield '-rows', [none]
        yield '-areas', [none]
        return
    slash_separated = [[]]
    for token in tokens:
        if token.type == 'literal' and token.value == '/':
            slash_separated.append([])
        else:
            slash_separated[-1].append(token)
    if len(slash_separated) == 2:
        rows = grid_template(slash_separated[0])
        columns = grid_template(slash_separated[1])
        if columns:
            if rows:
                yield '-columns', slash_separated[1]
                yield '-rows', slash_separated[0]
                yield '-areas', [none]
                return
            columns = slash_separated[1]
        else:
            raise InvalidValues
    elif len(slash_separated) == 1:
        columns = [none]
    else:
        raise InvalidValues
    # TODO: Handle last syntax.
    raise InvalidValues


@expander('grid-template')
@generic_expander('-columns', '-rows', '-areas')
def expand_grid_template(tokens, name):
    """Expand the ``grid-template`` property."""
    yield from _expand_grid_template(tokens, name)


@expander('grid')
@generic_expander('-template-columns', '-template-rows', '-template-areas',
                  '-auto-columns', '-auto-rows', '-auto-flow')
def expand_grid(tokens, name):
    """Expand the ``grid`` property."""
    line, column = tokens[0].source_line, tokens[0].source_column
    auto = IdentToken(line, column, 'auto')
    none = IdentToken(line, column, 'none')
    row = IdentToken(line, column, 'row')
    column = IdentToken(line, column, 'column')
    try:
        template = tuple(_expand_grid_template(tokens, 'grid-template'))
    except InvalidValues:
        pass
    else:
        for key, value in template:
            yield f'-template-{key.split("-")[-1]}', value
        yield '-auto-columns', [auto]
        yield '-auto-rows', [auto]
        yield '-auto-flow', [row]
        return
    split_tokens = [[]]
    for token in tokens:
        if token.type == 'literal' and token.value == '/':
            split_tokens.append([])
            continue
        split_tokens[-1].append(token)
    if len(split_tokens) != 2:
        raise InvalidValues
    auto_track = None
    dense = None
    templates = {'row': [], 'column': []}
    iterable = zip(split_tokens, templates.items())
    for tokens, (track, track_templates) in iterable:
        auto_flow_token = False
        for token in tokens:
            if get_keyword(token) == 'dense':
                if dense or (auto_track and auto_track != track):
                    raise InvalidValues
                dense = token
                auto_track = track
            elif get_keyword(token) == 'auto-flow':
                if auto_flow_token or (auto_track and auto_track != track):
                    raise InvalidValues
                auto_flow_token = True
                auto_track = track
            elif token == tokens[-1]:
                track_templates.append(token)
            else:
                raise InvalidValues
    if not auto_track:
        raise InvalidValues
    non_auto_track = 'row' if auto_track == 'column' else 'column'
    auto_track_token = column if auto_track == 'column' else row
    yield '-auto-flow', (
        (auto_track_token, dense) if dense else (auto_track_token,))
    yield f'-auto-{auto_track}s', tuple(templates[auto_track])
    yield f'-auto-{non_auto_track}s', [auto]
    yield f'-template-{auto_track}s', [none]
    yield f'-template-{non_auto_track}s', tuple(templates[non_auto_track])
    yield '-template-areas', [none]


def _expand_grid_column_row_area(tokens, max_number):
    grid_lines = [[]]
    for token in tokens:
        if token.type == 'literal' and token.value == '/':
            grid_lines.append([])
            continue
        grid_lines[-1].append(token)
    if not 1 <= len(grid_lines) <= max_number:
        raise InvalidValues
    validations = []
    for tokens in grid_lines:
        if not (validation := grid_line(tokens)):
            raise InvalidValues
        validations.append(validation)
        yield tuple(tokens)
    auto = IdentToken(token.source_line, token.source_column, 'auto')
    if (lines := len(grid_lines)) <= 1:
        custom_ident = set(validations[0][:2]) == {None}
        value = tuple(grid_lines[0]) if custom_ident else (auto,)
        grid_lines.append(tokens)
        validations.append(validations[0])
        yield value
    if lines <= 2 < max_number:
        custom_ident = set(validations[0][:2]) == {None}
        yield tuple(grid_lines[0]) if custom_ident else (auto,)
    if lines <= 3 < max_number:
        custom_ident = set(validations[1][:2]) == {None}
        yield tuple(grid_lines[1]) if custom_ident else (auto,)


@expander('grid-column')
@expander('grid-row')
@generic_expander('-start', '-end')
def expand_grid_column_row(tokens, name):
    """Expand the ``grid-[column|row]`` properties."""
    tokens_list = _expand_grid_column_row_area(tokens, 2)
    for tokens, side in zip(tokens_list, ('start', 'end')):
        yield f'-{side}', tokens


@expander('grid-area')
@generic_expander('grid-row-start', 'grid-row-end',
                  'grid-column-start', 'grid-column-end')
def expand_grid_area(tokens, name):
    """Expand the ``grid-area`` property."""
    tokens_list = _expand_grid_column_row_area(tokens, 4)
    sides = ('row-start', 'column-start', 'row-end', 'column-end')
    for tokens, side in zip(tokens_list, sides):
        yield f'grid-{side}', tokens


@expander('grid-gap')
@expander('gap')
@generic_expander('column-gap', 'row-gap')
def expand_gap(tokens, name):
    """Expand the ``gap`` property."""
    if len(tokens) == 1:
        if gap(tokens) is None:
            raise InvalidValues
        yield 'row-gap', tokens
        yield 'column-gap', tokens
    elif len(tokens) == 2:
        column_gap, row_gap = gap(tokens[0:1]), gap(tokens[1:2])
        if None in (column_gap, row_gap):
            raise InvalidValues
        yield 'row-gap', tokens[0:1]
        yield 'column-gap', tokens[1:2]
    else:
        raise InvalidValues


@expander('grid-column-gap')
@generic_expander('column-gap')
def expand_legacy_column_gap(tokens, name):
    """Expand legacy ``grid-column-gap`` property."""
    keyword = gap(tokens)
    if keyword is None:
        raise InvalidValues
    yield 'column-gap', tokens


@expander('grid-row-gap')
@generic_expander('row-gap')
def expand_legacy_row_gap(tokens, name):
    """Expand legacy ``grid-row-gap`` property."""
    keyword = gap(tokens)
    if keyword is None:
        raise InvalidValues
    yield 'row-gap', tokens


@expander('place-content')
@generic_expander('align-content', 'justify-content')
def expand_place_content(tokens, name):
    """Expand the ``place-content`` property."""
    # TODO
    raise InvalidValues


@expander('place-items')
@generic_expander('align-items', 'justify-items')
def expand_place_items(tokens, name):
    """Expand the ``place-items`` property."""
    # TODO
    raise InvalidValues


@expander('place-self')
@generic_expander('align-self', 'justify-self')
def expand_place_self(tokens, name):
    """Expand the ``place-self`` property."""
    # TODO
    raise InvalidValues


@expander('line-clamp')
@generic_expander('max-lines', 'continue', 'block-ellipsis')
def expand_line_clamp(tokens, name):
    """Expand the ``line-clamp`` property."""
    if len(tokens) == 1:
        keyword = get_single_keyword(tokens)
        if keyword == 'none':
            line, column = tokens[0].source_line, tokens[0].source_column
            none_token = IdentToken(line, column, 'none')
            auto_token = IdentToken(line, column, 'auto')
            yield 'max-lines', [none_token]
            yield 'continue', [auto_token]
            yield 'block-ellipsis', [none_token]
        elif tokens[0].type == 'number' and tokens[0].int_value is not None:
            line, column = tokens[0].source_line, tokens[0].source_column
            auto_token = IdentToken(line, column, 'auto')
            discard_token = IdentToken(line, column, 'discard')
            yield 'max-lines', [tokens[0]]
            yield 'continue', [discard_token]
            yield 'block-ellipsis', [auto_token]
        else:
            raise InvalidValues
    elif len(tokens) == 2:
        if tokens[0].type == 'number':
            max_lines = tokens[0].int_value
            ellipsis = block_ellipsis([tokens[1]])
            if max_lines and ellipsis is not None:
                line, column = tokens[0].source_line, tokens[0].source_column
                discard_token = IdentToken(line, column, 'discard')
                yield 'max-lines', [tokens[0]]
                yield 'continue', [discard_token]
                yield 'block-ellipsis', [tokens[1]]
            else:
                raise InvalidValues
        else:
            raise InvalidValues
    else:
        raise InvalidValues


@expander('text-align')
@generic_expander('-all', '-last')
def expand_text_align(tokens, name):
    """Expand the ``text-align`` property."""
    if len(tokens) == 1:
        keyword = get_single_keyword(tokens)
        if keyword is None:
            raise InvalidValues
        if keyword == 'justify-all':
            line, column = tokens[0].source_line, tokens[0].source_column
            align_all = IdentToken(line, column, 'justify')
        else:
            align_all = tokens[0]
        yield '-all', [align_all]
        if keyword == 'justify':
            line, column = tokens[0].source_line, tokens[0].source_column
            align_last = IdentToken(line, column, 'start')
        else:
            align_last = align_all
        yield '-last', [align_last]
    else:
        raise InvalidValues


================================================
FILE: weasyprint/css/validation/properties.py
================================================
"""Validate properties.

See https://www.w3.org/TR/CSS21/propidx.html and various CSS3 modules.

"""

from math import inf

from tinycss2 import parse_component_value_list
from tinycss2.color5 import parse_color

from .. import computed_values
from ..functions import Function, check_var
from ..properties import KNOWN_PROPERTIES, ZERO_PIXELS, Dimension

from ..tokens import (  # isort:skip
    InvalidValues, Pending, comma_separated_list, get_angle, get_content_list,
    get_content_list_token, get_custom_ident, get_image, get_keyword, get_length,
    get_number, get_percentage, get_resolution, get_single_keyword, get_url,
    parse_2d_position, parse_position, remove_whitespace, single_keyword, single_token)

PREFIX = '-weasy-'
PROPRIETARY = set()
UNSTABLE = set()

# Yes/no validators for non-shorthand properties
# Maps property names to functions taking a property name and a value list,
# returning a value or None for invalid.
# For properties that take a single value, that value is returned by itself
# instead of a list.
PROPERTIES = {}


class PendingProperty(Pending):
    """Property with validation done when defining calculated values."""
    def validate(self, tokens, wanted_key):
        return validate_non_shorthand(tokens, self.name)[0][1]


# Validators

def property(property_name=None, proprietary=False, unstable=False,
             wants_base_url=False):
    """Decorator adding a function to the ``PROPERTIES``.

    The name of the property covered by the decorated function is set to
    ``property_name`` if given, or is inferred from the function name
    (replacing underscores by hyphens).

    :param proprietary:
        Proprietary (vendor-specific, non-standard) are prefixed: anchors can
        for example be set using ``-weasy-anchor: attr(id)``.
        See https://www.w3.org/TR/CSS/#proprietary
    :param unstable:
        Mark properties that are defined in specifications that didn't reach
        the Candidate Recommandation stage. They can be used both
        vendor-prefixed or unprefixed.
        See https://www.w3.org/TR/CSS/#unstable-syntax
    :param wants_base_url:
        The function takes the stylesheet’s base URL as an additional
        parameter.

    """
    def decorator(function):
        """Add ``function`` to the ``PROPERTIES``."""
        if property_name is None:
            name = function.__name__.replace('_', '-')
        else:
            name = property_name
        assert name in KNOWN_PROPERTIES, name
        assert name not in PROPERTIES, name

        function.wants_base_url = wants_base_url
        PROPERTIES[name] = function
        if proprietary:
            PROPRIETARY.add(name)
        if unstable:
            UNSTABLE.add(name)
        return function
    return decorator


def validate_non_shorthand(tokens, name, base_url=None, required=False):
    """Validator for non-shorthand properties."""
    if name.startswith('--'):
        # TODO: validate content
        return ((name, tokens),)

    if not required and name not in KNOWN_PROPERTIES:
        raise InvalidValues('unknown property')

    if not required and name not in PROPERTIES:
        raise InvalidValues('property not supported yet')

    function = PROPERTIES[name]
    for token in tokens:
        if check_var(token):
            # Found CSS variable, return pending-substitution values.
            return ((name, PendingProperty(tokens, name)),)

    keyword = get_single_keyword(tokens)
    if keyword in ('initial', 'inherit'):
        value = keyword
    else:
        if function.wants_base_url:
            value = function(tokens, base_url)
        else:
            value = function(tokens)
        if value is None:
            raise InvalidValues
    return ((name, value),)


@property()
@comma_separated_list
@single_keyword
def background_attachment(keyword):
    """``background-attachment`` property validation."""
    return keyword in ('scroll', 'fixed', 'local')


@property('background-color')
@property('border-top-color')
@property('border-right-color')
@property('border-bottom-color')
@property('border-left-color')
@property('border-block-start-color')
@property('border-block-end-color')
@property('border-inline-start-color')
@property('border-inline-end-color')
@property('column-rule-color', unstable=True)
@property('text-decoration-color')
@single_token
def other_colors(token):
    if parse_color(token):
        return token


@property()
@single_token
def outline_color(token):
    if get_keyword(token) == 'invert':
        return 'currentcolor'
    elif parse_color(token):
        return token


@property()
@single_keyword
def border_collapse(keyword):
    return keyword in ('separate', 'collapse')


@property()
@single_keyword
def empty_cells(keyword):
    """``empty-cells`` property validation."""
    return keyword in ('show', 'hide')


@property('color')
@single_token
def color(token):
    """``*-color`` and ``color`` properties validation."""
    result = parse_color(token)
    if result == 'currentcolor':
        return 'inherit'
    elif result:
        return token


@property('background-image', wants_base_url=True)
@comma_separated_list
@single_token
def background_image(token, base_url):
    if get_keyword(token) == 'none':
        return 'none', None
    return get_image(token, base_url)


@property('list-style-image', wants_base_url=True)
@single_token
def list_style_image(token, base_url):
    """``list-style-image`` property validation."""
    if get_keyword(token) == 'none':
        return 'none', None
    parsed_url = get_url(token, base_url)
    if parsed_url:
        if parsed_url[0] == 'url' and parsed_url[1][0] == 'external':
            return 'url', parsed_url[1][1]


@property()
def transform_origin(tokens):
    """``transform-origin`` property validation."""
    if len(tokens) == 3:
        # Ignore third parameter as 3D transforms are ignored.
        tokens = tokens[:2]
    return parse_2d_position(tokens)


@property()
@comma_separated_list
def background_position(tokens):
    """``background-position`` property validation."""
    return parse_position(tokens)


@property()
@comma_separated_list
def object_position(tokens):
    """``object-position`` property validation."""
    return parse_position(tokens)


@property()
@comma_separated_list
def background_repeat(tokens):
    """``background-repeat`` property validation."""
    keywords = tuple(map(get_keyword, tokens))
    if keywords == ('repeat-x',):
        return ('repeat', 'no-repeat')
    if keywords == ('repeat-y',):
        return ('no-repeat', 'repeat')
    if keywords in (('no-repeat',), ('repeat',), ('space',), ('round',)):
        return keywords * 2
    if len(keywords) == 2 and all(
            k in ('no-repeat', 'repeat', 'space', 'round')
            for k in keywords):
        return keywords


@property()
@comma_separated_list
def background_size(tokens):
    """Validation for ``background-size``."""
    if len(tokens) == 1:
        token = tokens[0]
        keyword = get_keyword(token)
        if keyword in ('contain', 'cover'):
            return keyword
        if keyword == 'auto':
            return ('auto', 'auto')
        length = get_length(token, negative=False, percentage=True)
        if length:
            return (length, 'auto')
    elif len(tokens) == 2:
        values = []
        for token in tokens:
            length = get_length(token, negative=False, percentage=True)
            if length:
                values.append(length)
            elif get_keyword(token) == 'auto':
                values.append('auto')
        if len(values) == 2:
            return tuple(values)


@property('background-clip')
@property('background-origin')
@comma_separated_list
@single_keyword
def box(keyword):
    """Validation for the ``<box>`` type used in ``background-clip``
    and ``background-origin``."""
    return keyword in ('border-box', 'padding-box', 'content-box')


@property()
def border_spacing(tokens):
    """Validator for the `border-spacing` property."""
    lengths = [get_length(token, negative=False) for token in tokens]
    if all(lengths):
        if len(lengths) == 1:
            return (lengths[0], lengths[0])
        elif len(lengths) == 2:
            return tuple(lengths)


@property('border-top-right-radius')
@property('border-bottom-right-radius')
@property('border-bottom-left-radius')
@property('border-top-left-radius')
@property('border-start-start-radius')
@property('border-start-end-radius')
@property('border-end-start-radius')
@property('border-end-end-radius')
def border_corner_radius(tokens):
    """Validator for the `border-*-radius` properties."""
    lengths = [get_length(token, negative=False, percentage=True) for token in tokens]
    if all(lengths):
        if len(lengths) == 1:
            return (lengths[0], lengths[0])
        elif len(lengths) == 2:
            return tuple(lengths)


@property('border-top-style')
@property('border-right-style')
@property('border-left-style')
@property('border-bottom-style')
@property('border-block-start-style')
@property('border-block-end-style')
@property('border-inline-start-style')
@property('border-inline-end-style')
@property('column-rule-style', unstable=True)
@single_keyword
def border_style(keyword):
    """``border-*-style`` properties validation."""
    return keyword in ('none', 'hidden', 'dotted', 'dashed', 'double',
                       'inset', 'outset', 'groove', 'ridge', 'solid')


@property('break-before')
@property('break-after')
@single_keyword
def break_before_after(keyword):
    """``break-before`` and ``break-after`` properties validation."""
    return keyword in ('auto', 'avoid', 'avoid-page', 'page', 'left', 'right',
                       'recto', 'verso', 'avoid-column', 'column', 'always')


@property()
@single_keyword
def break_inside(keyword):
    """``break-inside`` property validation."""
    return keyword in ('auto', 'avoid', 'avoid-page', 'avoid-column')


@property()
@single_keyword
def box_decoration_break(keyword):
    """``box-decoration-break`` property validation."""
    return keyword in ('slice', 'clone')


@property()
@single_token
def block_ellipsis(token):
    """``box-ellipsis`` property validation."""
    if token.type == 'string':
        return ('string', token.value)
    else:
        keyword = get_keyword(token)
        if keyword in ('none', 'auto'):
            return keyword


@property('continue', unstable=True)
@single_keyword
def continue_(keyword):
    """``continue`` property validation."""
    return keyword in ('auto', 'discard')


@property(unstable=True)
@single_token
def max_lines(token):
    if number := get_number(token, negative=False, integer=True):
        return number.value
    elif get_keyword(token) == 'none':
        return 'none'


@property(unstable=True)
@single_keyword
def margin_break(keyword):
    """``margin-break`` property validation."""
    return keyword in ('auto', 'keep', 'discard')


@property(unstable=True)
@single_token
def page(token):
    """``page`` property validation."""
    if token.type == 'ident':
        return 'auto' if token.lower_value == 'auto' else token.value


@property('bleed-left', unstable=True)
@property('bleed-right', unstable=True)
@property('bleed-top', unstable=True)
@property('bleed-bottom', unstable=True)
@single_token
def bleed(token):
    """``bleed`` property validation."""
    if get_keyword(token) == 'auto':
        return 'auto'
    else:
        return get_length(token)


@property(unstable=True)
def marks(tokens):
    """``marks`` property validation."""
    if len(tokens) == 2:
        keywords = tuple(get_keyword(token) for token in tokens)
        if 'crop' in keywords and 'cross' in keywords:
            return keywords
    elif len(tokens) == 1:
        if (keyword := get_keyword(tokens[0])) in ('crop', 'cross'):
            return (keyword,)
        elif keyword == 'none':
            return ()


@property('outline-style')
@single_keyword
def outline_style(keyword):
    """``outline-style`` properties validation."""
    return keyword in ('none', 'dotted', 'dashed', 'double', 'inset',
                       'outset', 'groove', 'ridge', 'solid')


@property('border-top-width')
@property('border-right-width')
@property('border-left-width')
@property('border-bottom-width')
@property('border-block-start-width')
@property('border-block-end-width')
@property('border-inline-start-width')
@property('border-inline-end-width')
@property('column-rule-width', unstable=True)
@property('outline-width')
@single_token
def border_width(token):
    """Border, column rule and outline widths properties validation."""
    if length := get_length(token, negative=False):
        return length
    if (keyword := get_keyword(token)) in ('thin', 'medium', 'thick'):
        return keyword


@property('border-image-source', wants_base_url=True)
@property('mask-border-source', wants_base_url=True)
@single_token
def border_image_source(token, base_url):
    if get_keyword(token) == 'none':
        return 'none', None
    return get_image(token, base_url)


@property('border-image-slice')
@property('mask-border-slice')
def border_image_slice(tokens):
    values = []
    fill = False
    for i, token in enumerate(tokens):
        # Don't use get_length() because a dimension with a unit is disallowed.
        if percentage := get_percentage(token, negative=False):
            values.append(percentage)
        elif get_keyword(token) == 'fill' and not fill and i in (0, len(tokens) - 1):
            fill = True
            values.append('fill')
        elif number := get_number(token, negative=False):
            values.append(number)
        else:
            return

    if 1 <= len(values) - int(fill) <= 4:
        return tuple(values)


@property('border-image-width')
@property('mask-border-width')
def border_image_width(tokens):
    values = []
    for token in tokens:
        if get_keyword(token) == 'auto':
            values.append('auto')
        elif number := get_number(token, negative=False):
            values.append(number)
        elif length := get_length(token, negative=False, percentage=True):
            values.append(length)
        else:
            return

    if 1 <= len(values) <= 4:
        return tuple(values)


@property('border-image-outset')
@property('mask-border-outset')
def border_image_outset(tokens):
    values = []
    for token in tokens:
        if number := get_number(token, negative=False):
            values.append(number)
        elif length := get_length(token, negative=False):
            values.append(length)
        else:
            return

    if 1 <= len(values) <= 4:
        return tuple(values)


@property('border-image-repeat')
@property('mask-border-repeat')
def border_image_repeat(tokens):
    if 1 <= len(tokens) <= 2:
        keywords = tuple(get_keyword(token) for token in tokens)
        if set(keywords) <= {'stretch', 'repeat', 'round', 'space'}:
            return keywords


@property()
@single_keyword
def mask_border_mode(keyword):
    return keyword in ('luminance', 'alpha')


@property(unstable=True)
@single_token
def column_width(token):
    """``column-width`` property validation."""
    if length := get_length(token, negative=False):
        return length
    keyword = get_keyword(token)
    if keyword == 'auto':
        return keyword


@property(unstable=True)
@single_keyword
def column_span(keyword):
    """``column-span`` property validation."""
    return keyword in ('all', 'none')


@property()
@single_keyword
def box_sizing(keyword):
    """Validation for the ``box-sizing`` property from css3-ui"""
    return keyword in ('padding-box', 'border-box', 'content-box')


@property()
@single_keyword
def caption_side(keyword):
    """``caption-side`` properties validation."""
    return keyword in ('top', 'bottom')


@property()
@single_keyword
def clear(keyword):
    """``clear`` property validation."""
    return keyword in ('left', 'right', 'inline-start', 'inline-end', 'both', 'none')


@property()
@single_token
def clip(token):
    """Validation for the ``clip`` property."""
    function = Function(token)
    arguments = function.split_comma()
    if function.name == 'rect' and len(arguments) == 4:
        values = []
        for argument in arguments:
            if get_keyword(argument) == 'auto':
                values.append('auto')
            elif length := get_length(argument):
                values.append(length)
            else:
                return
        return tuple(values)
    elif get_keyword(token) == 'auto':
        return ()


@property(wants_base_url=True)
def content(tokens, base_url):
    """``content`` property validation."""
    # See https://www.w3.org/TR/css-content-3/#content-property
    tokens = list(tokens)
    parsed_tokens = []
    while tokens:
        if len(tokens) >= 2 and tokens[1].type == 'literal' and tokens[1].value == ',':
            token, tokens = tokens[0], tokens[2:]
            if parsed_token := get_image(token, base_url) or get_url(token, base_url):
                parsed_tokens.append(parsed_token)
            else:
                return
        else:
            break
    if len(tokens) == 0:
        return
    if len(tokens) >= 3 and tokens[-1].type == 'string' and (
            tokens[-2].type == 'literal' and tokens[-2].value == '/'):
        # Ignore text for speech
        tokens = tokens[:-2]
    keyword = get_single_keyword(tokens)
    if keyword in ('normal', 'none'):
        return (keyword,)
    return get_content_list(tokens, base_url)


@property()
def counter_increment(tokens):
    """``counter-increment`` property validation."""
    return counter(tokens, default_integer=1)


@property()
def counter_reset(tokens):
    """``counter-reset`` property validation."""
    return counter(tokens, default_integer=0)


@property()
def counter_set(tokens):
    """``counter-set`` property validation."""
    return counter(tokens, default_integer=0)


def counter(tokens, default_integer):
    """``counter-increment`` and ``counter-reset`` properties validation."""
    if get_single_keyword(tokens) == 'none':
        return ()
    tokens = iter(tokens)
    token = next(tokens, None)
    assert token, 'got an empty token list'
    results = []
    while token is not None:
        if token.type != 'ident':
            return  # expected a keyword here
        counter_name = token.value
        if counter_name in ('none', 'initial', 'inherit'):
            raise InvalidValues(f'Invalid counter name: {counter_name}')
        token = next(tokens, None)
        if token and (number := get_number(token, integer=True)):
            # Found an integer. Use it and get the next token.
            integer = number.value
            token = next(tokens, None)
        else:
            # Not an integer. Might be the next counter name. Keep `token` for the next
            # loop iteration.
            integer = default_integer
        results.append((counter_name, integer))
    return tuple(results)


@property('top')
@property('right')
@property('left')
@property('bottom')
@property('inset-block-start')
@property('inset-block-end')
@property('inset-inline-start')
@property('inset-inline-end')
@property('margin-top')
@property('margin-right')
@property('margin-bottom')
@property('margin-left')
@property('margin-block-start')
@property('margin-block-end')
@property('margin-inline-start')
@property('margin-inline-end')
@property('text-underline-offset')
@single_token
def lenght_precentage_or_auto(token):
    """``margin-*`` and various other properties validation."""
    if length := get_length(token, percentage=True):
        return length
    if get_keyword(token) == 'auto':
        return 'auto'


@property('height')
@property('width')
@property('block-size')
@property('inline-size')
@single_token
def width_height(token):
    """Validation for the ``width`` and ``height`` properties."""
    if length := get_length(token, negative=False, percentage=True):
        return length
    if get_keyword(token) == 'auto':
        return 'auto'


@property('column-gap', unstable=True)
@property('row-gap', unstable=True)
@single_token
def gap(token):
    """Validation for the ``column-gap`` and ``row-gap`` properties."""
    if length := get_length(token, percentage=True, negative=False):
        return length
    keyword = get_keyword(token)
    if keyword == 'normal':
        return keyword


@property(unstable=True)
@single_keyword
def column_fill(keyword):
    """``column-fill`` property validation."""
    return keyword in ('auto', 'balance')


@property()
@single_keyword
def direction(keyword):
    """``direction`` property validation."""
    return keyword in ('ltr', 'rtl')


@property()
def display(tokens):
    """``display`` property validation."""
    for token in tokens:
        if token.type != 'ident':
            return

    if len(tokens) == 1:
        value = tokens[0].value
        if value in (
                'none', 'table-caption', 'table-row-group', 'table-cell',
                'table-header-group', 'table-footer-group', 'table-row',
                'table-column-group', 'table-column'):
            return (value,)
        elif value in ('inline-table', 'inline-flex', 'inline-grid'):
            return tuple(value.split('-'))
        elif value == 'inline-block':
            return ('inline', 'flow-root')

    outside = inside = list_item = None
    for token in tokens:
        value = token.value
        if value in ('block', 'inline'):
            if outside:
                return
            outside = value
        elif value in ('flow', 'flow-root', 'table', 'flex', 'grid'):
            if inside:
                return
            inside = value
        elif value == 'list-item':
            if list_item:
                return
            list_item = value
        else:
            return

    outside = outside or 'block'
    inside = inside or 'flow'
    if list_item:
        if inside in ('flow', 'flow-root'):
            return (outside, inside, list_item)
    else:
        return (outside, inside)


@property('float')
@single_keyword
def float_(keyword):  # XXX do not hide the "float" builtin
    """``float`` property validation."""
    return keyword in (
        'left', 'right', 'inline-start', 'inline-end', 'footnote', 'none')


@property()
@comma_separated_list
def font_family(tokens):
    """``font-family`` property validation."""
    if len(tokens) == 1 and tokens[0].type == 'string':
        return tokens[0].value
    elif tokens and all(token.type == 'ident' for token in tokens):
        return ' '.join(token.value for token in tokens)


@property()
@single_keyword
def font_kerning(keyword):
    return keyword in ('auto', 'normal', 'none')


@property()
@single_token
def font_language_override(token):
    keyword = get_keyword(token)
    if keyword == 'normal':
        return keyword
    elif token.type == 'string':
        return token.value


@property()
def font_variant_ligatures(tokens):
    if len(tokens) == 1:
        keyword = get_keyword(tokens[0])
        if keyword in ('normal', 'none'):
            return keyword
    values = []
    couples = (
        ('common-ligatures', 'no-common-ligatures'),
        ('historical-ligatures', 'no-historical-ligatures'),
        ('discretionary-ligatures', 'no-discretionary-ligatures'),
        ('contextual', 'no-contextual'))
    all_values = []
    for couple in couples:
        all_values.extend(couple)
    for token in tokens:
        if token.type != 'ident':
            return None
        if token.value in all_values:
            concurrent_values = next(
                couple for couple in couples if token.value in couple)
            if any(value in values for value in concurrent_values):
                return None
            else:
                values.append(token.value)
        else:
            return None
    if values:
        return tuple(values)


@property()
@single_keyword
def font_variant_position(keyword):
    return keyword in ('normal', 'sub', 'super')


@property()
@single_keyword
def font_variant_caps(keyword):
    return keyword in (
        'normal', 'small-caps', 'all-small-caps', 'petite-caps',
        'all-petite-caps', 'unicase', 'titling-caps')


@property()
def font_variant_numeric(tokens):
    if len(tokens) == 1:
        keyword = get_keyword(tokens[0])
        if keyword == 'normal':
            return keyword
    values = []
    couples = (
        ('lining-nums', 'oldstyle-nums'),
        ('proportional-nums', 'tabular-nums'),
        ('diagonal-fractions', 'stacked-fractions'),
        ('ordinal',), ('slashed-zero',))
    all_values = []
    for couple in couples:
        all_values.extend(couple)
    for token in tokens:
        if token.type != 'ident':
            return None
        if token.value in all_values:
            concurrent_values = next(
                couple for couple in couples if token.value in couple)
            if any(value in values for value in concurrent_values):
                return None
            else:
                values.append(token.value)
        else:
            return None
    if values:
        return tuple(values)


@property()
def font_feature_settings(tokens):
    """``font-feature-settings`` property validation."""
    if len(tokens) == 1 and get_keyword(tokens[0]) == 'normal':
        return 'normal'

    @comma_separated_list
    def font_feature_settings_list(tokens):
        feature, value = None, None

        if len(tokens) == 2:
            tokens, token = tokens[:-1], tokens[-1]
            if token.type == 'ident':
                value = {'on': 1, 'off': 0}.get(token.value)
            elif number := get_number(token, negative=False, integer=True):
                value = number.value
        elif len(tokens) == 1:
            value = 1

        if len(tokens) == 1:
            token, = tokens
            if token.type == 'string' and len(token.value) == 4:
                if all(0x20 <= ord(letter) <= 0x7f for letter in token.value):
                    feature = token.value

        if feature is not None and value is not None:
            return feature, value

    return font_feature_settings_list(tokens)


@property()
@single_keyword
def font_variant_alternates(keyword):
    # TODO: support other values
    # See https://drafts.csswg.org/css-fonts/#font-variant-alternates-prop
    return keyword in ('normal', 'historical-forms')


@property()
def font_variant_east_asian(tokens):
    if len(tokens) == 1:
        keyword = get_keyword(tokens[0])
        if keyword == 'normal':
            return keyword
    values = []
    couples = (
        ('jis78', 'jis83', 'jis90', 'jis04', 'simplified', 'traditional'),
        ('full-width', 'proportional-width'),
        ('ruby',))
    all_values = []
    for couple in couples:
        all_values.extend(couple)
    for token in tokens:
        if token.type != 'ident':
            return None
        if token.value in all_values:
            concurrent_values = next(
                couple for couple in couples if token.value in couple)
            if any(value in values for value in concurrent_values):
                return None
            else:
                values.append(token.value)
        else:
            return None
    if values:
        return tuple(values)


@property()
def font_variation_settings(tokens):
    """``font-variation-settings`` property validation."""
    if len(tokens) == 1 and get_keyword(tokens[0]) == 'normal':
        return 'normal'

    @comma_separated_list
    def font_variation_settings_list(tokens):
        if len(tokens) == 2:
            key, value = tokens
            if key.type == 'string' and value.type == 'number':
                return key.value, value.value

    return font_variation_settings_list(tokens)


@property()
@single_token
def font_size(token):
    """``font-size`` property validation."""
    if length := get_length(token, negative=False, percentage=True):
        return length
    font_size_keyword = get_keyword(token)
    if font_size_keyword in ('smaller', 'larger'):
        return font_size_keyword
    if font_size_keyword in computed_values.FONT_SIZE_KEYWORDS:
        return font_size_keyword


@property()
@single_keyword
def font_style(keyword):
    """``font-style`` property validation."""
    return keyword in ('normal', 'italic', 'oblique')


@property()
@single_keyword
def font_stretch(keyword):
    """Validation for the ``font-stretch`` property."""
    return keyword in (
        'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed',
        'normal',
        'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded')


@property()
@single_token
def font_weight(token):
    """``font-weight`` property validation."""
    keyword = get_keyword(token)
    if keyword in ('normal', 'bold', 'bolder', 'lighter'):
        return keyword
    if token.type == 'number' and token.int_value is not None:
        if token.int_value in (100, 200, 300, 400, 500, 600, 700, 800, 900):
            return token.int_value


@property()
@single_keyword
def object_fit(keyword):
    # TODO: Figure out what the spec means by "'scale-down' flag".
    #   As of this writing, neither Firefox nor chrome support
    #   anything other than a single keyword as is done here.
    return keyword in ('fill', 'contain', 'cover', 'none', 'scale-down')


@property(unstable=True)
@single_token
def image_resolution(token):
    # TODO: support 'snap' and 'from-image'
    return get_resolution(token)


@property('letter-spacing')
@property('word-spacing')
@single_token
def spacing(token):
    """Validation for ``letter-spacing`` and ``word-spacing``."""
    if get_keyword(token) == 'normal':
        return 'normal'
    if length := get_length(token):
        return length


@property()
@single_token
def outline_offset(token):
    """Validation for ``outline-offset``."""
    if length := get_length(token):
        return length


@property()
@single_token
def line_height(token):
    """``line-height`` property validation."""
    if get_keyword(token) == 'normal':
        return 'normal'
    elif number := get_number(token, negative=False):
        return number
    elif length := get_length(token, negative=False, percentage=True):
        return length


@property()
@single_keyword
def list_style_position(keyword):
    """``list-style-position`` property validation."""
    return keyword in ('inside', 'outside')


@property()
@single_token
def list_style_type(token):
    """``list-style-type`` property validation."""
    if token.type == 'ident':
        return token.value
    elif token.type == 'string':
        return ('string', token.value)
    elif token.type == 'function' and token.name == 'symbols':
        allowed_types = ('cyclic', 'numeric', 'alphabetic', 'symbolic', 'fixed')
        if not (function_arguments := remove_whitespace(token.arguments)):
            return
        arguments = []
        if function_arguments[0].type == 'ident':
            if function_arguments[0].value in allowed_types:
                index = 1
                arguments.append(function_arguments[0].value)
            else:
                return
        else:
            arguments.append('symbolic')
            index = 0
        if len(function_arguments) < index + 1:
            return
        for i in range(index, len(function_arguments)):
            if function_arguments[i].type != 'string':
                return
            arguments.append(function_arguments[i].value)
        if arguments[0] in ('alphabetic', 'numeric'):
            if len(arguments) < 3:
                return
        return ('symbols()', tuple(arguments))


@property('min-width')
@property('min-height')
@property('min-block-size')
@property('min-inline-size')
@single_token
def min_width_height(token):
    """``min-width`` and ``min-height`` properties validation."""
    # See https://www.w3.org/TR/css-flexbox-1/#min-size-auto
    if get_keyword(token) == 'auto':
        return 'auto'
    else:
        return length_or_precentage([token])


@property('padding-top')
@property('padding-right')
@property('padding-bottom')
@property('padding-left')
@property('padding-block-start')
@property('padding-block-end')
@property('padding-inline-start')
@property('padding-inline-end')
@single_token
def length_or_precentage(token):
    """``padding-*`` properties validation."""
    if length := get_length(token, negative=False, percentage=True):
        return length


@property('max-width')
@property('max-height')
@property('max-block-size')
@property('max-inline-size')
@single_token
def max_width_height(token):
    """Validation for max-width and max-height"""
    if length := get_length(token, negative=False, percentage=True):
        return length
    if get_keyword(token) == 'none':
        return Dimension(inf, 'px')


@property()
@single_token
def opacity(token):
    """Validation for the ``opacity`` property."""
    if number := get_number(token):
        return min(1, max(0, number.value))
    elif percentage := get_percentage(token):
        return min(1, max(0, percentage.value / 100))


@property()
@single_token
def z_index(token):
    """Validation for the ``z-index`` property."""
    if get_keyword(token) == 'auto':
        return 'auto'
    elif number := get_number(token, integer=True):
        return number.value


@property('orphans')
@property('widows')
@single_token
def orphans_widows(token):
    """Validation for the ``orphans`` and ``widows`` properties."""
    if number := get_number(token, negative=False, integer=True):
        if number.value >= 1:
            return number.value


@property(unstable=True)
@single_token
def column_count(token):
    """Validation for the ``column-count`` property."""
    if number := get_number(token, negative=False, integer=True):
        if number.value >= 1:
            return number.value
    elif get_keyword(token) == 'auto':
        return 'auto'


@property()
@single_keyword
def overflow(keyword):
    """Validation for the ``overflow`` property."""
    return keyword in ('auto', 'visible', 'hidden', 'scroll')


@property()
@single_keyword
def text_overflow(keyword):
    """Validation for the ``text-overflow`` property."""
    return keyword in ('clip', 'ellipsis')


@property()
@single_token
def position(token):
    """``position`` property validation."""
    if token.type == 'function' and token.name == 'running':
        if len(token.arguments) == 1 and token.arguments[0].type == 'ident':
            return ('running()', token.arguments[0].value)
    keyword = get_single_keyword([token])
    if keyword in ('static', 'relative', 'absolute', 'fixed'):
        return keyword


@property()
def quotes(tokens):
    """``quotes`` property validation."""
    if len(tokens) == 1:
        if (keyword := get_keyword(tokens[0])) in ('auto', 'none'):
            return keyword
    if (tokens and len(tokens) % 2 == 0 and
            all(token.type == 'string' for token in tokens)):
        strings = tuple(token.value for token in tokens)
        # Separate open and close quotes.
        # eg.  ('«', '»', '“', '”')  -> (('«', '“'), ('»', '”'))
        return strings[::2], strings[1::2]


@property()
@single_keyword
def table_layout(keyword):
    """Validation for the ``table-layout`` property"""
    if keyword in ('fixed', 'auto'):
        return keyword


@property()
@single_keyword
def text_align_all(keyword):
    """``text-align-all`` property validation."""
    return keyword in ('left', 'right', 'center', 'justify', 'start', 'end')


@property()
@single_keyword
def text_align_last(keyword):
    """``text-align-last`` property validation."""
    return keyword in ('auto', 'left', 'right', 'center', 'justify', 'start', 'end')


@property()
def text_decoration_line(tokens):
    """``text-decoration-line`` property validation."""
    if (keywords := {get_keyword(token) for token in tokens}) == {'none'}:
        return 'none'
    allowed_values = {'underline', 'overline', 'line-through', 'blink'}
    if len(tokens) == len(keywords) and keywords.issubset(allowed_values):
        return keywords


@property()
@single_keyword
def text_decoration_style(keyword):
    """``text-decoration-style`` property validation."""
    if keyword in ('solid', 'double', 'dotted', 'dashed', 'wavy'):
        return keyword


@property()
@single_token
def text_decoration_thickness(token):
    """``text-decoration-thickness`` property validation."""
    if length := get_length(token, percentage=True):
        return length
    elif (keyword := get_keyword(token)) in ('auto', 'from-font'):
        return keyword


@property()
@single_token
def text_indent(token):
    """``text-indent`` property validation."""
    if length := get_length(token, percentage=True):
        return length


@property()
@single_keyword
def text_transform(keyword):
    """``text-align`` property validation."""
    return keyword in ('none', 'uppercase', 'lowercase', 'capitalize', 'full-width')


@property()
@single_token
def vertical_align(token):
    """Validation for the ``vertical-align`` property"""
    if length := get_length(token, percentage=True):
        return length
    keyword = get_keyword(token)
    if keyword in ('baseline', 'middle', 'sub', 'super',
                   'text-top', 'text-bottom', 'top', 'bottom'):
        return keyword


@property()
@single_keyword
def visibility(keyword):
    """``white-space`` property validation."""
    return keyword in ('visible', 'hidden', 'collapse')


@property()
@single_keyword
def white_space(keyword):
    """``white-space`` property validation."""
    return keyword in ('normal', 'pre', 'nowrap', 'pre-wrap', 'pre-line')


@property()
@single_keyword
def overflow_wrap(keyword):
    """``overflow-wrap`` property validation."""
    return keyword in ('anywhere', 'normal', 'break-word')


@property()
@single_keyword
def word_break(keyword):
    """``word-break`` property validation."""
    return keyword in ('normal', 'break-all')


@property()
@single_token
def flex_basis(token):
    """``flex-basis`` property validation."""
    if (basis := width_height([token])) is not None:
        return basis
    elif get_keyword(token) == 'content':
        return 'content'


@property()
@single_keyword
def flex_direction(keyword):
    """``flex-direction`` property validation."""
    return keyword in ('row', 'row-reverse', 'column', 'column-reverse')


@property('flex-grow')
@property('flex-shrink')
@single_token
def flex_grow_shrink(token):
    if number := get_number(token):
        return number.value


def _inflexible_breadth(token):
    """Parse ``inflexible-breadth``."""
    if (keyword := get_keyword(token)) in ('auto', 'min-content', 'max-content'):
        return keyword
    elif keyword:
        return
    elif length := get_length(token, negative=False, percentage=True):
        return length


def _track_breadth(token):
    """Parse ``track-breadth``."""
    if token.type == 'dimension' and token.value >= 0 and token.unit.lower() == 'fr':
        return Dimension(token.value, token.unit.lower())
    return _inflexible_breadth(token)


def _track_size(token):
    """Parse ``track-size``."""
    if track_breadth := _track_breadth(token):
        return track_breadth
    function = Function(token)
    arguments = function.split_comma()
    if function.name == 'minmax':
        if len(arguments) == 2:
            inflexible_breadth = _inflexible_breadth(arguments[0])
            track_breadth = _track_breadth(arguments[1])
            if inflexible_breadth and track_breadth:
                return ('minmax()', inflexible_breadth, track_breadth)
    elif function.name == 'fit-content':
        if len(arguments) == 1:
            if length := get_length(arguments[0], negative=False, percentage=True):
                return ('fit-content()', length)


def _fixed_size(token):
    """Parse ``fixed-size``."""
    if length := get_length(token, negative=False, percentage=True):
        return length
    function = Function(token)
    arguments = function.split_comma()
    if function.name == 'minmax' and len(arguments) == 2:
        if length := get_length(arguments[0], negative=False, percentage=True):
            track_breadth = _track_breadth(arguments[1])
            if track_breadth:
                return ('minmax()', length, track_breadth)
        keyword = get_keyword(arguments[0])
        if keyword in ('min-content', 'max-content', 'auto') or length:
            fixed_breadth = get_length(arguments[1], negative=False, percentage=True)
            if fixed_breadth:
                return ('minmax()', length or keyword, fixed_breadth)


def _line_names(token):
    """Parse ``line-names``."""
    return_line_names = []
    if token.type == '[] block':
        for token in token.content:
            if token.type == 'ident':
                return_line_names.append(token.value)
            elif token.type != 'whitespace':
                return
        return tuple(return_line_names)


@property('grid-auto-columns')
@property('grid-auto-rows')
def grid_auto(tokens):
    """``grid-auto-columns`` and ``grid-auto-rows`` properties validation."""
    return_tokens = []
    for token in tokens:
        if track_size := _track_size(token):
            return_tokens.append(track_size)
            continue
        return
    return tuple(return_tokens)


@property()
def grid_auto_flow(tokens):
    """``grid-auto-flow`` property validation."""
    if len(tokens) == 1:
        keyword = get_keyword(tokens[0])
        if keyword in ('row', 'column'):
            return (keyword,)
        elif keyword == 'dense':
            return (keyword, 'row')
    elif len(tokens) == 2:
        keywords = [get_keyword(token) for token in tokens]
        if 'dense' in keywords and ('row' in keywords or 'column' in keywords):
            return tuple(keywords)


@property('grid-template-columns')
@property('grid-template-rows')
def grid_template(tokens):
    """``grid-template-columns`` and ``grid-template-rows`` validation."""
    return_tokens = []
    if len(tokens) == 1 and get_keyword(tokens[0]) == 'none':
        return 'none'
    if get_keyword(tokens[0]) == 'subgrid':
        return_tokens.append('subgrid')
        subgrid_tokens = []
        for token in tokens[1:]:
            line_names = _line_names(token)
            if line_names is not None:
                subgrid_tokens.append(line_names)
                continue
            function = Function(token)
            arguments = function.split_comma(single_tokens=False)
            if arguments is None or len(arguments) != 2:
                return
            repeat, tracks = arguments
            if len(repeat) != 1 or not tracks:
                return
            repeat, = repeat
            if function.name == 'repeat' and len(arguments) >= 2:
                if (repeat.type == 'number' and float(repeat.value).is_integer() and
                        repeat.value >= 1):
                    number = repeat.int_value
                elif get_keyword(repeat) == 'auto-fill':
                    number = 'auto-fill'
                else:
                    return
                line_names_list = []
                for argument in tracks:
                    line_names = _line_names(argument)
                    if line_names is not None:
                        line_names_list.append(line_names)
                subgrid_tokens.append(('repeat()', number, tuple(line_names_list)))
                continue
            return
        return_tokens.append(tuple(subgrid_tokens))
    else:
        includes_auto_repeat = False
        includes_track = False
        last_is_line_name = False
        for token in tokens:
            line_names = _line_names(token)
            if line_names is not None:
                if last_is_line_name:
                    return
                last_is_line_name = True
                return_tokens.append(line_names)
                continue
            fixed_size = _fixed_size(token)
            if fixed_size:
                if not last_is_line_name:
                    return_tokens.append(())
                last_is_line_name = False
                return_tokens.append(fixed_size)
                continue
            track_size = _track_size(token)
            if track_size:
                if not last_is_line_name:
                    return_tokens.append(())
                last_is_line_name = False
                return_tokens.append(track_size)
                includes_track = True
                continue
            function = Function(token)
            arguments = function.split_comma(single_tokens=False)
            if arguments is None or len(arguments) != 2:
                return
            repeat, tracks = arguments
            if len(repeat) != 1 or not tracks:
                return
            repeat, = repeat
            if function.name == 'repeat' and len(arguments) >= 2:
                if number := get_number(repeat, negative=False, integer=True):
                    if number.value >= 1:
                        number = number.value
                elif get_keyword(repeat) in ('auto-fill', 'auto-fit'):
                    # auto-repeat
                    if includes_auto_repeat:
                        return
                    number = repeat.value
                    includes_auto_repeat = True
                else:
                    return
                names_and_sizes = []
                repeat_last_is_line_name = False
                for arg in tracks:
                    line_names = _line_names(arg)
                    if line_names is not None:
                        if repeat_last_is_line_name:
                            return
                        names_and_sizes.append(line_names)
                        repeat_last_is_line_name = True
                        continue
                    # fixed-repeat
                    fixed_size = _fixed_size(arg)
                    if fixed_size:
                        if not repeat_last_is_line_name:
                            names_and_sizes.append(())
                        repeat_last_is_line_name = False
                        names_and_sizes.append(fixed_size)
                        continue
                    # track-repeat
                    track_size = _track_size(arg)
                    if track_size:
                        includes_track = True
                        if not repeat_last_is_line_name:
                            names_and_sizes.append(())
                        repeat_last_is_line_name = False
                        names_and_sizes.append(track_size)
                        continue
                    return
                if not last_is_line_name:
                    return_tokens.append(())
                last_is_line_name = False
                if not repeat_last_is_line_name:
                    names_and_sizes.append(())
                return_tokens.append(('repeat()', number, tuple(names_and_sizes)))
                continue
            return
        if includes_auto_repeat and includes_track:
            return
        if not last_is_line_name:
            return_tokens.append(())
    return tuple(return_tokens)


@property()
def grid_template_areas(tokens):
    """``grid-template-areas`` property validation."""
    if len(tokens) == 1 and get_keyword(tokens[0]) == 'none':
        return 'none'
    grid_areas = []
    for token in tokens:
        if token.type != 'string':
            return
        component_values = parse_component_value_list(token.value)
        row = []
        last_is_dot = False
        for value in component_values:
            if value.type == 'ident':
                row.append(value.value)
                last_is_dot = False
            elif value.type == 'literal' and value.value == '.':
                if last_is_dot:
                    continue
                row.append(None)
                last_is_dot = True
            elif value.type == 'whitespace':
                last_is_dot = False
            else:
                return
        if not row:
            return
        grid_areas.append(tuple(row))
    # check row / column have the same sizes
    if len(set(len(row) for row in grid_areas)) == 1:
        # check areas are continuous rectangles
        coordinates = set()
        areas = set()
        for y, row in enumerate(grid_areas):
            for x, area in enumerate(row):
                if (x, y) in coordinates or area is None:
                    continue
                if area in areas:
                    return
                areas.add(area)
                coordinates.add((x, y))
                nx = x
                for nx, narea in enumerate(row[x+1:], start=x+1):
                    if narea != area:
                        break
                    coordinates.add((nx, y))
                else:
                    nx += 1
                for ny, nrow in enumerate(grid_areas[y+1:], start=y+1):
                    if set(nrow[x:nx]) == {area}:
                        for nnx in range(x, nx):
                            coordinates.add((nnx, ny))
                    else:
                        break
        return tuple(grid_areas)


@property('grid-row-start')
@property('grid-row-end')
@property('grid-column-start')
@property('grid-column-end')
def grid_line(tokens):
    """``grid-[row|column]-[start—end]`` properties validation."""
    if len(tokens) == 1:
        token = tokens[0]
        if keyword := get_keyword(token):
            if keyword == 'auto':
                return keyword
            elif keyword != 'span':
                return (None, None, token.value)
        elif number := get_number(token, integer=True):
            if number.value != 0:
                return (None, number.value, None)
        return
    number = ident = span = None
    for token in tokens:
        if keyword := get_keyword(token):
            if keyword == 'auto':
                return
            if keyword == 'span':
                if span is None:
                    span = 'span'
                    continue
            elif keyword and ident is None:
                ident = token.value
                continue
        elif item := get_number(token, integer=True):
            if item.value != 0 and number is None:
                number = item.value
                continue
        return
    if span:
        if isinstance(number, int) and number < 0:
            return
        elif ident or number:
            return (span, number, ident)
    elif number:
        return (span, number, ident)


@property()
@single_keyword
def flex_wrap(keyword):
    """``flex-wrap`` property validation."""
    return keyword in ('nowrap', 'wrap', 'wrap-reverse')


@property()
def justify_content(tokens):
    """``justify-content`` property validation."""
    if len(tokens) == 1:
        keyword = get_keyword(tokens[0])
        if keyword in (
                'center', 'space-between', 'space-around', 'space-evenly',
                'stretch', 'normal', 'flex-start', 'flex-end',
                'start', 'end', 'left', 'right'):
            return (keyword,)
    elif len(tokens) == 2:
        keywords = tuple(get_keyword(token) for token in tokens)
        if keywords[0] in ('safe', 'unsafe'):
            if keywords[1] in (
                    'center', 'start', 'end', 'flex-start', 'flex-end', 'left',
                    'right'):
                return keywords


@property()
def justify_items(tokens):
    """``justify-items`` property validation."""
    if len(tokens) == 1:
        keyword = get_keyword(tokens[0])
        if keyword in (
                'normal', 'stretch', 'center', 'start', 'end', 'self-start',
                'self-end', 'flex-start', 'flex-end', 'left', 'right',
                'legacy'):
            return (keyword,)
        elif keyword == 'baseline':
            return ('first', keyword)
    elif len(tokens) == 2:
        keywords = tuple(get_keyword(token) for token in tokens)
        if keywords[0] in ('safe', 'unsafe'):
            if keywords[1] in (
                    'center', 'start', 'end', 'self-start', 'self-end',
                    'flex-start', 'flex-end', 'left', 'right'):
                return keywords
        elif 'baseline' in keywords:
            if 'first' in keywords or 'last' in keywords:
                return keywords
        elif 'legacy' in keywords:
            if set(keywords) & {'left', 'right', 'center'}:
                return keywords


@property()
def justify_self(tokens):
    """``justify-self`` property validation."""
    if len(tokens) == 1:
        keyword = get_keyword(tokens[0])
        if keyword in (
                'auto', 'normal', 'stretch', 'center', 'start', 'end',
                'self-start', 'self-end', 'flex-start', 'flex-end', 'left',
                'right'):
            return (keyword,)
        elif keyword == 'baseline':
            return ('first', keyword)
    elif len(tokens) == 2:
        keywords = tuple(get_keyword(token) for token in tokens)
        if keywords[0] in ('safe', 'unsafe'):
            if keywords[1] in (
                    'center', 'start', 'end', 'self-start', 'self-end',
                    'flex-start', 'flex-end', 'left', 'right'):
                return keywords
        elif 'baseline' in keywords:
            if 'first' in keywords or 'last' in keywords:
                return keywords


@property()
def align_items(tokens):
    """``align-items`` property validation."""
    if len(tokens) == 1:
        keyword = get_keyword(tokens[0])
        if keyword in (
                'normal', 'stretch', 'center', 'start', 'end', 'self-start',
                'self-end', 'flex-start', 'flex-end'):
            return (keyword,)
        elif keyword == 'baseline':
            return ('first', keyword)
    elif len(tokens) == 2:
        keywords = tuple(get_keyword(token) for token in tokens)
        if keywords[0] in ('safe', 'unsafe'):
            if keywords[1] in (
                    'center', 'start', 'end', 'self-start', 'self-end',
                    'flex-start', 'flex-end'):
                return keywords
        elif 'baseline' in keywords:
            if 'first' in keywords or 'last' in keywords:
                return keywords


@property()
def align_self(tokens):
    """``align-self`` property validation."""
    if len(tokens) == 1:
        keyword = get_keyword(tokens[0])
        if keyword in (
                'auto', 'normal', 'stretch', 'center', 'start', 'end',
                'self-start', 'self-end', 'flex-start', 'flex-end'):
            return (keyword,)
        elif keyword == 'baseline':
            return ('first', keyword)
    elif len(tokens) == 2:
        keywords = tuple(get_keyword(token) for token in tokens)
        if keywords[0] in ('safe', 'unsafe'):
            if keywords[1] in (
                    'center', 'start', 'end', 'self-start', 'self-end',
                    'flex-start', 'flex-end'):
                return keywords
        elif 'baseline' in keywords:
            if 'first' in keywords or 'last' in keywords:
                return keywords


@property()
def align_content(tokens):
    """``align-content`` property validation."""
    if len(tokens) == 1:
        keyword = get_keyword(tokens[0])
        if keyword in (
                'center', 'space-between', 'space-around', 'space-evenly',
                'stretch', 'normal', 'flex-start', 'flex-end',
                'start', 'end'):
            return (keyword,)
        elif keyword == 'baseline':
            return ('first', keyword)
    elif len(tokens) == 2:
        keywords = tuple(get_keyword(token) for token in tokens)
        if keywords[0] in ('safe', 'unsafe'):
            if keywords[1] in (
                    'center', 'start', 'end', 'flex-start', 'flex-end'):
                return keywords
        elif 'baseline' in keywords:
            if 'first' in keywords or 'last' in keywords:
                return keywords


@property()
@single_token
def order(token):
    if number := get_number(token, integer=True):
        return number.value


@property(unstable=True)
@single_keyword
def image_rendering(keyword):
    """Validation for ``image-rendering``."""
    return keyword in ('auto', 'crisp-edges', 'pixelated')


@property(unstable=True)
def image_orientation(tokens):
    """Validation for ``image-orientation``."""
    keyword = get_single_keyword(tokens)
    if keyword in ('none', 'from-image'):
        return keyword
    angle, flip = None, None
    for token in tokens:
        keyword = get_keyword(token)
        if keyword == 'flip':
            if flip is not None:
                return
            flip = True
            continue
        if angle is None:
            angle = get_angle(token)
            if angle is not None:
                continue
        return
    angle = 0 if angle is None else angle
    flip = False if flip is None else flip
    return (angle, flip)


@property(unstable=True)
def size(tokens):
    """``size`` property validation.

    See https://www.w3.org/TR/css-page-3/#page-size-prop

    """
    lengths = [get_length(token, negative=False) for token in tokens]
    if all(lengths):
        if len(lengths) == 1:
            return (lengths[0], lengths[0])
        elif len(lengths) == 2:
            return tuple(lengths)

    keywords = [get_keyword(token) for token in tokens]
    if len(keywords) == 1:
        keyword = keywords[0]
        if keyword in computed_values.PAGE_SIZES:
            return computed_values.PAGE_SIZES[keyword]
        elif keyword in ('auto', 'portrait'):
            return computed_values.INITIAL_PAGE_SIZE
        elif keyword == 'landscape':
            return computed_values.INITIAL_PAGE_SIZE[::-1]

    if len(keywords) == 2:
        if keywords[0] in ('portrait', 'landscape'):
            orientation, page_size = keywords
        elif keywords[1] in ('portrait', 'landscape'):
            page_size, orientation = keywords
        else:
            page_size = None
        if page_size in computed_values.PAGE_SIZES:
            width_height = computed_values.PAGE_SIZES[page_size]
            if orientation == 'portrait':
                return width_height
            else:
                height, width = width_height
                return width, height


@property(proprietary=True)
@single_token
def anchor(token):
    """Validation for ``anchor``."""
    if get_keyword(token) == 'none':
        return 'none'
    function = Function(token)
    if arguments := function.split_space():
        prototype = (function.name, [argument.type for argument in arguments])
        if prototype == ('attr', ['ident']):
            return ('attr()', arguments[0].value)


@property(proprietary=True, wants_base_url=True)
@single_token
def link(token, base_url):
    """Validation for ``link``."""
    if get_keyword(token) == 'none':
        return 'none'
    parsed_url = get_url(token, base_url)
    if parsed_url:
        return parsed_url
    function = Function(token)
    if arguments := function.split_space():
        prototype = (function.name, [argument.type for argument in arguments])
        if prototype == ('attr', ['ident']):
            return ('attr()', arguments[0].value)


@property()
@single_token
def tab_size(token):
    """Validation for ``tab-size``.

    See https://www.w3.org/TR/css-text-3/#tab-size

    """
    if token.type == 'number' and token.int_value is not None:
        if value := token.int_value:
            return value
    return get_length(token, negative=False)


@property(unstable=True)
@single_token
def hyphens(token):
    """Validation for ``hyphens``."""
    if (keyword := get_keyword(token)) in ('none', 'manual', 'auto'):
        return keyword


@property(unstable=True)
@single_token
def hyphenate_character(token):
    """Validation for ``hyphenate-character``."""
    if get_keyword(token) == 'auto':
        return '‐'
    elif token.type == 'string':
        return token.value


@property(unstable=True)
@single_token
def hyphenate_limit_zone(token):
    """Validation for ``hyphenate-limit-zone``."""
    return get_length(token, negative=False, percentage=True)


@property(unstable=True)
def hyphenate_limit_chars(tokens):
    """Validation for ``hyphenate-limit-chars``."""
    if len(tokens) == 1:
        token, = tokens
        keyword = get_keyword(token)
        if keyword == 'auto':
            return (5, 2, 2)
        elif number := get_number(token, integer=True):
            return (number.value, 2, 2)
    elif len(tokens) == 2:
        total, left = tokens
        total_keyword = get_keyword(total)
        left_keyword = get_keyword(left)
        if total_number := get_number(total, integer=True):
            if left_number := get_number(left, integer=True):
                return (total_number.value, left_number.value, left_number.value)
            elif left_keyword == 'auto':
                return (total_number.value, 2, 2)
        elif total_keyword == 'auto':
            if left_number := get_number(left, integer=True):
                return (5, left_number.value, left_number.value)
            elif left_keyword == 'auto':
                return (5, 2, 2)
    elif len(tokens) == 3:
        total, left, right = tokens
        result = []
        for token in total, left, right:
            if get_keyword(token) == 'auto':
                result.append(5 if token is total else 2)
            elif number := get_number(token, integer=True):
                result.append(number.value)
            else:
                return
        return tuple(result)


@property(proprietary=True)
@single_token
def lang(token):
    """Validation for ``lang``."""
    if get_keyword(token) == 'none':
        return 'none'
    function = Function(token)
    if arguments := function.split_space():
        prototype = (function.name, [argument.type for argument in arguments])
        if prototype == ('attr', ['ident']):
            return ('attr()', arguments[0].value)
    elif token.type == 'string':
        return ('string', token.value)


@property(unstable=True, wants_base_url=True)
def bookmark_label(tokens, base_url):
    """Validation for ``bookmark-label``."""
    parsed_tokens = tuple(get_content_list_token(token, base_url) for token in tokens)
    if None not in parsed_tokens:
        return parsed_tokens


@property(unstable=True)
@single_token
def bookmark_level(token):
    """Validation for ``bookmark-level``."""
    if number := get_number(token, negative=False, integer=True):
        if number.value >= 1:
            return number.value
    elif get_keyword(token) == 'none':
        return 'none'


@property(unstable=True)
@single_keyword
def bookmark_state(keyword):
    """Validation for ``bookmark-state``."""
    return keyword in ('open', 'closed')


@property(unstable=True)
@single_keyword
def footnote_display(keyword):
    """Validation for ``footnote-display``."""
    return keyword in ('block', 'inline', 'compact')


@property(unstable=True)
@single_keyword
def footnote_policy(keyword):
    """Validation for ``footnote-policy``."""
    return keyword in ('auto', 'line', 'block')


@property(unstable=True, wants_base_url=True)
@comma_separated_list
def string_set(tokens, base_url):
    """Validation for ``string-set``."""
    # Spec asks for strings after custom keywords, but we allow content-lists
    if len(tokens) >= 2:
        var_name = get_custom_ident(tokens[0])
        if var_name is None:
            return
        parsed_tokens = tuple(
            get_content_list_token(token, base_url) for token in tokens[1:])
        if None not in parsed_tokens:
            return (var_name, parsed_tokens)
    elif tokens and get_keyword(tokens[0]) == 'none':
        return 'none', ()


@property()
def transform(tokens):
    """Validation for ``transform``."""
    if get_single_keyword(tokens) == 'none':
        return ()
    else:
        transforms = []
        for token in tokens:
            function = Function(token)
            arguments = function.split_comma()
            if arguments is None:
                return

            all_numbers = {argument.type for argument in arguments} == {'number'}
            if len(arguments) == 1:
                angle = get_angle(arguments[0])
                length = get_length(arguments[0], percentage=True)
                if function.name == 'rotate' and angle is not None:
                    transforms.append((function.name, angle))
                elif function.name in ('skewx', 'skew') and angle is not None:
                    transforms.append(('skew', (angle, 0)))
                elif function.name == 'skewy' and angle is not None:
                    transforms.append(('skew', (0, angle)))
                elif function.name in ('translatex', 'translate') and length:
                    transforms.append(('translate', (length, ZERO_PIXELS)))
                elif function.name == 'translatey' and length:
                    transforms.append(('translate', (ZERO_PIXELS, length)))
                elif function.name == 'scalex' and all_numbers:
                    transforms.append(('scale', (arguments[0].value, 1)))
                elif function.name == 'scaley' and all_numbers:
                    transforms.append(('scale', (1, arguments[0].value)))
                elif function.name == 'scale' and all_numbers:
                    transforms.append(('scale', (arguments[0].value,) * 2))
                else:
                    return
            elif len(arguments) == 2:
                if function.name == 'scale' and all_numbers:
                    values = tuple(argument.value for argument in arguments)
                    transforms.append((function.name, values))
                elif function.name == 'translate':
                    lengths = tuple(
                        get_length(token, percentage=True) for token in arguments)
                    if all(lengths):
                        transforms.append((function.name, lengths))
                    else:
                        return
                elif function.name == 'skew':
                    angles = tuple(get_angle(token) for token in arguments)
                    if all(angle is not None for angle in angles):
                        transforms.append((function.name, angles))
                    else:
                        return
                else:
                    return
            elif len(arguments) == 6 and function.name == 'matrix' and all_numbers:
                transforms.append(
                    (function.name, tuple(argument.value for argument in arguments)))
            else:
                return
        return tuple(transforms)


@property()
@single_token
def appearance(token):
    """``appearance`` property validation."""
    if (keyword := get_keyword(token)) in ('none', 'auto'):
        return keyword


@property()
def color_scheme(tokens):
    """``color-scheme`` property validation."""
    if len(tokens) == 1:
        keyword = get_single_keyword(tokens)
        if keyword == 'normal':
            return keyword
        elif keyword != 'only':
            return (keyword,)
        else:
            return
    else:
        keywords = []
        only = False
        for i, token in enumerate(tokens):
            keyword = get_keyword(token)
            if keyword == 'only':
                if only or i not in (0, len(tokens) - 1):
                    return
                else:
                    only = True
            elif keyword == 'normal':
                return
            elif keyword:
                keywords.append(keyword)
            else:
                return
        if only:
            keywords.append('only')
        return tuple(keywords)


================================================
FILE: weasyprint/document.py
================================================
"""Document generation management."""

import functools
import io
from hashlib import md5
from pathlib import Path

from . import CSS, DEFAULT_OPTIONS
from .anchors import gather_anchors, make_page_bookmark_tree
from .css import get_all_computed_styles
from .css.counters import CounterStyle
from .css.targets import TargetCollector
from .draw import draw_page
from .formatting_structure.build import build_formatting_structure
from .html import get_html_metadata
from .images import get_image_from_uri as original_get_image_from_uri
from .layout import LayoutContext, layout_document
from .logger import PROGRESS_LOGGER
from .matrix import Matrix
from .pdf import VARIANTS, generate_pdf
from .pdf.metadata import DocumentMetadata
from .text.fonts import FontConfiguration


class Page:
    """Represents a single rendered page.

    Should be obtained from :attr:`Document.pages` but not
    instantiated directly.

    """

    def __init__(self, page_box):
        #: The page width, including margins, in CSS pixels.
        self.width = page_box.margin_width()

        #: The page height, including margins, in CSS pixels.
        self.height = page_box.margin_height()

        #: The page bleed widths as a :obj:`dict` with ``'top'``, ``'right'``,
        #: ``'bottom'`` and ``'left'`` as keys, and values in CSS pixels.
        self.bleed = {
            side: page_box.style[f'bleed_{side}'].value
            for side in ('top', 'right', 'bottom', 'left')}

        #: The :obj:`list` of ``(level, label, target, state)``
        #: :obj:`tuples <tuple>`. ``level`` and ``label`` are respectively an
        #: :obj:`int` and a :obj:`string <str>`, based on the CSS properties
        #: of the same names. ``target`` is an ``(x, y)`` point in CSS pixels
        #: from the top-left of the page.
        self.bookmarks = []

        #: The :obj:`list` of ``(link_type, target, rectangle, box)``
        #: :obj:`tuples <tuple>`. A ``rectangle`` is ``(x, y, width, height)``,
        #: in CSS pixels from the top-left of the page. ``link_type`` is one of
        #: three strings:
        #:
        #: * ``'external'``: ``target`` is an absolute URL
        #: * ``'internal'``: ``target`` is an anchor name (see
        #:   :attr:`Page.anchors`).
        #:   The anchor might be defined in another page,
        #:   in multiple pages (in which case the first occurence is used),
        #:   or not at all.
        #: * ``'attachment'``: ``target`` is an absolute URL and points
        #:   to a resource to attach to the document.
        self.links = []

        #: The :obj:`dict` mapping each anchor name to its target, an
        #: ``(x, y)`` point in CSS pixels from the top-left of the page.
        self.anchors = {}

        #: The :obj:`dict` mapping form elements to a list
        #: of ``(element, attributes, rectangle)`` :obj:`tuples <tuple>`.
        #: A ``rectangle`` is ``(x, y, width, height)``, in CSS
        #: pixels from the top-left of the page. ``atributes`` is a
        #: :obj:`dict` of HTML tag attributes and values.
        #: The key ``None`` will contain inputs that are not part of a form.
        self.forms = {None: []}

        gather_anchors(page_box, self.anchors, self.links, self.bookmarks, self.forms)
        self._page_box = page_box

    def paint(self, stream, scale=1):
        """Paint the page into the PDF file."""
        with stream.stacked():
            stream.transform(a=scale, d=scale)
            draw_page(self._page_box, stream)


class DiskCache:
    """Dict-like storing images content on disk.

    Bytestring values are stored on disk. Other lightweight Python objects
    (i.e. RasterImage instances) are still stored in memory.

    """

    def __init__(self, folder):
        self._path = Path(folder)
        self._path.mkdir(parents=True, exist_ok=True)
        self._memory_cache = {}
        self._disk_paths = set()

    def _path_from_key(self, key):
        digest = md5(key.encode(), usedforsecurity=False).hexdigest()
        return self._path / digest

    def __getitem__(self, key):
        if key in self._memory_cache:
            return self._memory_cache[key]
        else:
            return self._path_from_key(key).read_bytes()

    def __setitem__(self, key, value):
        if isinstance(value, bytes):
            path = self._path_from_key(key)
            self._disk_paths.add(path)
            path.write_bytes(value)
        else:
            self._memory_cache[key] = value

    def __contains__(self, key):
        return (
            key in self._memory_cache or
            self._path_from_key(key).exists())

    def __del__(self):
        try:
            for path in self._disk_paths:
                path.unlink(missing_ok=True)
            self._path.rmdir()
        except Exception:
            # Silently ignore errors while clearing cache
            pass


class Document:
    """A rendered document ready to be painted in a pydyf stream.

    Typically obtained from :meth:`HTML.render() <weasyprint.HTML.render>`, but
    can also be instantiated directly with a list of :class:`pages <Page>`, a
    set of :class:`metadata <DocumentMetadata>`, a :class:`url_fetcher
    <weasyprint.urls.URLFetcher>`, and a :class:`font_config
    <weasyprint.text.fonts.FontConfiguration>`.

    """

    @classmethod
    def _build_layout_context(cls, html, font_config, counter_style, color_profiles,
                              options):
        target_collector = TargetCollector()
        page_rules = []
        layers = []
        user_stylesheets = []
        cache = options['cache']
        if cache is None:
            cache = {}
        elif not isinstance(cache, (dict, DiskCache)):
            cache = DiskCache(cache)
        for css in options['stylesheets'] or []:
            if not hasattr(css, 'matcher'):
                css = CSS(
                    guess=css, media_type=html.media_type,
                    font_config=font_config, counter_style=counter_style,
                    color_profiles=color_profiles)
            user_stylesheets.append(css)
        style_for = get_all_computed_styles(
            html, user_stylesheets, options['presentational_hints'], font_config,
            counter_style, color_profiles, page_rules, layers, target_collector,
            options['pdf_forms'])
        get_image_from_uri = functools.partial(
            original_get_image_from_uri, cache=cache,
            url_fetcher=html.url_fetcher, options=options)
        PROGRESS_LOGGER.info('Step 4 - Creating formatting structure')
        context = LayoutContext(
            style_for, get_image_from_uri, font_config, counter_style,
            target_collector)
        return context

    @classmethod
    def _render(cls, html, font_config, counter_style, color_profiles, options):
        if font_config is None:
            font_config = FontConfiguration()

        if counter_style is None:
            counter_style = CounterStyle()

        if color_profiles is None:
            color_profiles = {}

        context = cls._build_layout_context(
            html, font_config, counter_style, color_profiles, options)

        root_box = build_formatting_structure(
            html.etree_element, context.style_for, context.get_image_from_uri,
            html.base_url, context.target_collector, counter_style,
            context.footnotes)

        page_boxes = layout_document(html, root_box, context)
        rendering = cls(
            [Page(page_box) for page_box in page_boxes],
            DocumentMetadata(**get_html_metadata(html)),
            html.url_fetcher, font_config, color_profiles)
        rendering._html = html
        return rendering

    def __init__(self, pages, metadata, url_fetcher, font_config, color_profiles):
        #: A list of :class:`Page` objects.
        self.pages = pages
        #: A :class:`DocumentMetadata` object.
        #: Contains information that does not belong to a specific page
        #: but to the whole document.
        self.metadata = metadata
        #: A :class:`weasyprint.urls.URLFetcher` object (see :ref:`URL Fetchers`.)
        self.url_fetcher = url_fetcher
        #: A :obj:`dict` of fonts used by the document. Keys are hashes used to
        #: identify fonts, values are ``Font`` objects.
        self.fonts = {}

        # Keep a reference to font_config to avoid its garbage collection until
        # rendering is destroyed. This is needed as font_config.__del__ removes
        # fonts that may be used when rendering
        self.font_config = font_config

        self.color_profiles = color_profiles

    def copy(self, pages='all'):
        """Take a subset of the pages.

        :type pages: :term:`iterable`
        :param pages:
            An iterable of :class:`Page` objects from :attr:`pages`.
        :return:
            A new :class:`Document` object.

        Examples:

        Write two PDF files for odd-numbered and even-numbered pages::

            # Python lists count from 0 but pages are numbered from 1.
            # [::2] is a slice of even list indexes but odd-numbered pages.
            document.copy(document.pages[::2]).write_pdf('odd_pages.pdf')
            document.copy(document.pages[1::2]).write_pdf('even_pages.pdf')

        Combine multiple documents into one PDF file,
        using metadata from the first::

            all_pages = [p for doc in documents for p in doc.pages]
            documents[0].copy(all_pages).write_pdf('combined.pdf')

        """
        if pages == 'all':
            pages = self.pages
        elif not isinstance(pages, list):
            pages = list(pages)
        return type(self)(
            pages, self.metadata, self.url_fetcher, self.font_config,
            self.color_profiles)

    def make_bookmark_tree(self, scale=1, transform_pages=False):
        """Make a tree of all bookmarks in the document.

        :param float scale:
            Zoom scale.
        :param bool transform_pages:
            A boolean defining whether the default PDF page transformation
            matrix has to be applied to bookmark coordinates, setting the
            bottom-left corner as the origin.
        :return: A list of bookmark subtrees.
            A subtree is ``(label, target, children, state)``. ``label`` is
            a string, ``target`` is ``(page_number, x, y)``  and ``children``
            is a list of child subtrees.

        """
        root = []
        # At one point in the document, for each "output" depth, how much
        # to add to get the source level (CSS values of bookmark-level).
        # E.g. with <h1> then <h3>, level_shifts == [0, 1]
        # 1 means that <h3> has depth 3 - 1 = 2 in the output.
        skipped_levels = []
        last_by_depth = [root]
        previous_level = 0
        for page_number, page in enumerate(self.pages):
            if transform_pages:
                matrix = Matrix(a=scale, d=-scale, f=page.height * scale)
            else:
                matrix = Matrix(a=scale, d=scale)
            previous_level = make_page_bookmark_tree(
                page, skipped_levels, last_by_depth, previous_level,
                page_number, matrix)
        return root

    def write_pdf(self, target=None, zoom=1, finisher=None, **options):
        """Paint the pages in a PDF file, with metadata.

        :type target:
            :class:`str`, :class:`pathlib.Path` or :term:`file object`
        :param target:
            A filename where the PDF file is generated, a file object, or
            :obj:`None`.
        :param float zoom:
            The zoom factor in PDF units per CSS units.  **Warning**:
            All CSS units are affected, including physical units like
            ``cm`` and named sizes like ``A4``.  For values other than
            1, the physical CSS units will thus be "wrong".
        :type finisher: :term:`callable`
        :param finisher:
            A finisher function or callable that accepts the document and a
            :class:`pydyf.PDF` object as parameters. Can be passed to perform
            post-processing on the PDF right before the trailer is written.
        :param options:
            The ``options`` parameter includes by default the
            :data:`weasyprint.DEFAULT_OPTIONS` values.
        :returns:
            The PDF as :obj:`bytes` if ``target`` is not provided or
            :obj:`None`, otherwise :obj:`None` (the PDF is written to
            ``target``).

        """
        new_options = DEFAULT_OPTIONS.copy()
        new_options.update(options)
        options = new_options

        # Set default PDF version for PDF variants.
        if variant := options['pdf_variant']:
            _, properties = VARIANTS[variant]
            if 'version' in properties and not options['pdf_version']:
                options['pdf_version'] = properties['version']
            if 'identifier' in properties and not options['pdf_identifier']:
                options['pdf_identifier'] = properties['identifier']

        pdf = generate_pdf(self, target, zoom, **options)

        if finisher:
            finisher(self, pdf)

        identifier = options['pdf_identifier']
        compress = not options['uncompressed_pdf']
        version = options['pdf_version']

        if target is None:
            output = io.BytesIO()
            pdf.write(output, version, identifier, compress)
            return output.getvalue()

        if hasattr(target, 'write'):
            pdf.write(target, version, identifier, compress)
        else:
            with open(target, 'wb') as fd:
                pdf.write(fd, version, identifier, compress)


================================================
FILE: weasyprint/draw/__init__.py
================================================
"""Take an "after layout" box tree and draw it onto a pydyf stream."""

import operator
from math import floor
from xml.etree import ElementTree

from ..formatting_structure import boxes
from ..images import SVGImage
from ..layout import replaced
from ..layout.background import BackgroundLayer
from ..matrix import Matrix
from ..stacking import StackingContext
from .border import draw_border, draw_line, draw_outline, rounded_box, set_mask_border
from .color import styled_color
from .text import draw_text


def draw_page(page, stream):
    """Draw the given PageBox."""
    marks = page.style['marks']
    stacking_context = StackingContext.from_page(page)
    draw_background(
        stream, stacking_context.box.background, clip_box=False, bleed=page.bleed,
        marks=marks)
    set_mask_border(stream, page)
    draw_background(stream, page.canvas_background, clip_box=False)
    draw_border(stream, page)
    draw_stacking_context(stream, stacking_context)


def draw_stacking_context(stream, stacking_context):
    """Draw a ``stacking_context`` on ``stream``."""
    # See https://www.w3.org/TR/CSS2/zindex.html.
    with stream.stacked():
        box = stacking_context.box

        # Apply the viewport_overflow to the html box, see #35.
        if box.is_for_root_element and (
                stacking_context.page.style['overflow'] != 'visible'):
            rounded_box(stream, stacking_context.page.rounded_padding_box())
            stream.clip()
            stream.end()

        if box.is_absolutely_positioned() and box.style['clip']:
            top, right, bottom, left = box.style['clip']
            if top == 'auto':
                top = 0
            if right == 'auto':
                right = 0
            if bottom == 'auto':
                bottom = box.border_height()
            if left == 'auto':
                left = box.border_width()
            stream.rectangle(
                box.border_box_x() + right, box.border_box_y() + top,
                left - right, bottom - top)
            stream.clip()
            stream.end()

        if box.style['opacity'] < 1:
            original_stream = stream
            stream = stream.add_group(*stream.page_rectangle)

        if box.transformation_matrix:
            if box.transformation_matrix.determinant:
                stream.transform(*box.transformation_matrix.values)
            else:
                return

        # Point 1 is done in draw_page.

        # Point 2.
        if isinstance(box, (boxes.BlockBox, boxes.MarginBox, boxes.InlineBlockBox,
                            boxes.TableCellBox, boxes.FlexContainerBox,
                            boxes.GridContainerBox, boxes.ReplacedBox)):
            set_mask_border(stream, box)
            # The canvas background was removed by layout_backgrounds.
            draw_background(stream, box.background)
            draw_border(stream, box)

        with stream.stacked():
            # Dont clip the page box, see #35.
            clip = (
                box.style['overflow'] != 'visible' and
                not isinstance(box, boxes.PageBox))
            if clip:
                # Only clip the content and the children:
                # - the background is already clipped,
                # - the border must *not* be clipped.
                rounded_box(stream, box.rounded_padding_box())
                stream.clip()
                stream.end()

            # Point 3.
            for child_context in stacking_context.negative_z_contexts:
                draw_stacking_context(stream, child_context)

            # Point 4.
            for block in stacking_context.block_level_boxes:
                set_mask_border(stream, block)

                if isinstance(block, boxes.TableBox):
                    draw_table(stream, block)
                else:
                    draw_background(stream, block.background)
                    draw_border(stream, block)

            # Point 5.
            for child_context in stacking_context.float_contexts:
                draw_stacking_context(stream, child_context)

            # Point 6.
            if isinstance(box, boxes.InlineBox):
                draw_inline_level(stream, stacking_context.page, box)

            # Point 7.
            draw_block_level(
                stacking_context.page, stream, {box: stacking_context.blocks_and_cells})

            # Point 8.
            for child_context in stacking_context.zero_z_contexts:
                draw_stacking_context(stream, child_context)

            # Point 9.
            for child_context in stacking_context.positive_z_contexts:
                draw_stacking_context(stream, child_context)

        # Point 10.
        draw_outline(stream, box)

        if box.style['opacity'] < 1:
            group_id = stream.id
            stream = original_stream
            with stream.stacked():
                stream.set_alpha(box.style['opacity'], stroke=True, fill=True)
                stream.draw_x_object(group_id)


def draw_background(stream, bg, clip_box=True, bleed=None, marks=()):
    """Draw the background color and image to a ``pdf.stream.Stream``.

    If ``clip_box`` is set to ``False``, the background is not clipped to the
    border box of the background, but only to the painting area.

    """
    if bg is None:
        return

    with stream.stacked():
        if clip_box:
            for box in bg.layers[-1].clipped_boxes:
                rounded_box(stream, box)
            stream.clip()
            stream.end()

        # Draw background color.
        if bg.color.alpha > 0:
            with stream.artifact(), stream.stacked():
                stream.set_color(bg.color)
                painting_area = bg.layers[-1].painting_area
                stream.rectangle(*painting_area)
                stream.clip()
                stream.end()
                stream.rectangle(*painting_area)
                stream.fill()

        # Draw crop marks and crosses.
        if bleed and marks:
            x, y, width, height = bg.layers[-1].painting_area
            half_bleed = {key: value * 0.5 for key, value in bleed.items()}
            svg = f'''
              <svg height="{height}" width="{width}"
                   fill="transparent" stroke="black" stroke-width="1"
                   xmlns="http://www.w3.org/2000/svg">
            '''
            if 'crop' in marks:
                svg += f'''
                  <path d="M0,{bleed['top']} h{half_bleed['left']}" />
                  <path d="M0,{bleed['top']} h{half_bleed['right']}"
                        transform="translate({width},0) scale(-1,1)" />
                  <path d="M0,{bleed['bottom']} h{half_bleed['right']}"
                        transform="translate({width},{height}) scale(-1,-1)" />
                  <path d="M0,{bleed['bottom']} h{half_bleed['left']}"
                        transform="translate(0,{height}) scale(1,-1)" />
                  <path d="M{bleed['left']},0 v{half_bleed['top']}" />
                  <path d="M{bleed['right']},0 v{half_bleed['bottom']}"
                        transform="translate({width},{height}) scale(-1,-1)" />
                  <path d="M{bleed['left']},0 v{half_bleed['bottom']}"
                        transform="translate(0,{height}) scale(1,-1)" />
                  <path d="M{bleed['right']},0 v{half_bleed['top']}"
                        transform="translate({width},0) scale(-1,1)" />
                '''
            if 'cross' in marks:
                svg += f'''
                  <circle r="{half_bleed['top']}" transform="scale(0.5)
                     translate({width},{half_bleed['top']}) scale(0.5)" />
                  <path transform="scale(0.5) translate({width},0)" d="
                    M-{half_bleed['top']},{half_bleed['top']} h{bleed['top']}
                    M0,0 v{bleed['top']}" />
                  <circle r="{half_bleed['bottom']}" transform="
                    translate(0,{height}) scale(0.5)
                    translate({width},-{half_bleed['bottom']}) scale(0.5)" />
                  <path d="M-{half_bleed['bottom']},-{half_bleed['bottom']}
                    h{bleed['bottom']} M0,0 v-{bleed['bottom']}" transform="
                    translate(0,{height}) scale(0.5) translate({width},0)" />
                  <circle r="{half_bleed['left']}" transform="scale(0.5)
                    translate({half_bleed['left']},{height}) scale(0.5)" />
                  <path d="M{half_bleed['left']},-{half_bleed['left']}
                    v{bleed['left']} M0,0 h{bleed['left']}"
                    transform="scale(0.5) translate(0,{height})" />
                  <circle r="{half_bleed['right']}" transform="
                    translate({width},0) scale(0.5)
                    translate(-{half_bleed['right']},{height}) scale(0.5)" />
                  <path d="M-{half_bleed['right']},-{half_bleed['right']}
                    v{bleed['right']} M0,0 h-{bleed['right']}" transform="
                    translate({width},0) scale(0.5) translate(0,{height})" />
                '''
            svg += '</svg>'
            tree = ElementTree.fromstring(svg)
            image = SVGImage(tree, None, None, None)
            # Painting area is the PDF media box
            size = (width, height)
            position = (x, y)
            repeat = ('no-repeat', 'no-repeat')
            unbounded = True
            painting_area = position + size
            positioning_area = (0, 0, width, height)
            clipped_boxes = []
            layer = BackgroundLayer(
                image, size, position, repeat, unbounded, painting_area,
                positioning_area, clipped_boxes)
            bg.layers.insert(0, layer)
        # Paint in reversed order: first layer is "closest" to the viewer.
        for layer in reversed(bg.layers):
            draw_background_image(stream, layer, bg.style)


def draw_background_image(stream, layer, style):
    if layer.image is None or 0 in layer.size:
        return

    painting_x, painting_y, painting_width, painting_height = layer.painting_area
    positioning_x, positioning_y, positioning_width, positioning_height = (
        layer.positioning_area)
    position_x, position_y = layer.position
    repeat_x, repeat_y = layer.repeat
    image_width, image_height = layer.size

    if repeat_x == 'no-repeat' and repeat_y == 'no-repeat':
        with stream.artifact():
            # We don't use a pattern when we don't need to because some viewers
            # (e.g., Preview on Mac) introduce unnecessary pixelation when vector
            # images are used in patterns.
            if not layer.unbounded:
                stream.rectangle(
                    painting_x, painting_y, painting_width, painting_height)
                stream.clip()
                stream.end()
            # Put the image in a group so that masking outside the image and
            # masking within the image don't conflict.
            group = stream.add_group(*stream.page_rectangle)
            group.transform(e=position_x + positioning_x, f=position_y + positioning_y)
            layer.image.draw(group, image_width, image_height, style)
            stream.draw_x_object(group.id)
        return

    if repeat_x == 'no-repeat':
        # We want at least the whole image_width drawn on sub_surface, but we
        # want to be sure it will not be repeated on the painting_width. We
        # double the painting width to ensure viewers don't incorrectly bleed
        # the edge of the pattern into the painting area. (See #1539.)
        repeat_width = max(image_width, 2 * painting_width)
    elif repeat_x in ('repeat', 'round'):
        # We repeat the image each image_width.
        repeat_width = image_width
    else:
        assert repeat_x == 'space'
        n_repeats = floor(positioning_width / image_width)
        if n_repeats >= 2:
            # The repeat width is the whole positioning width with one image
            # removed, divided by (the number of repeated images - 1). This
            # way, we get the width of one image + one space. We ignore
            # background-position for this dimension.
            repeat_width = (positioning_width - image_width) / (n_repeats - 1)
            position_x = 0
        else:
            # We don't repeat the image.
            repeat_width = positioning_width

    # Comments above apply here too.
    if repeat_y == 'no-repeat':
        repeat_height = max(image_height, 2 * painting_height)
    elif repeat_y in ('repeat', 'round'):
        repeat_height = image_height
    else:
        assert repeat_y == 'space'
        n_repeats = floor(positioning_height / image_height)
        if n_repeats >= 2:
            repeat_height = (positioning_height - image_height) / (n_repeats - 1)
            position_y = 0
        else:
            repeat_height = positioning_height

    matrix = Matrix(e=position_x + positioning_x, f=position_y + positioning_y)
    matrix @= stream.ctm
    pattern = stream.add_pattern(
        0, 0, image_width, image_height, repeat_width, repeat_height, matrix)
    group = pattern.add_group(0, 0, repeat_width, repeat_height)

    with stream.artifact(), stream.stacked():
        layer.image.draw(group, image_width, image_height, style)
        with pattern.artifact():
            pattern.draw_x_object(group.id)
        stream.set_color_space('Pattern')
        stream.set_color_special(pattern.id)
        if layer.unbounded:
            x1, y1, x2, y2 = stream.page_rectangle
            stream.rectangle(x1, y1, x2 - x1, y2 - y1)
        else:
            stream.rectangle(painting_x, painting_y, painting_width, painting_height)
        stream.fill()


def draw_table(stream, table):
    # Draw backgrounds.
    draw_background(stream, table.background)
    for column_group in table.column_groups:
        draw_background(stream, column_group.background)
        for column in column_group.children:
            draw_background(stream, column.background)
    for row_group in table.children:
        draw_background(stream, row_group.background)
        for row in row_group.children:
            draw_background(stream, row.background)
            for cell in row.children:
                draw_cell_background = (
                    table.style['border_collapse'] == 'collapse' or
                    cell.style['empty_cells'] == 'show' or
                    not cell.empty)
                if draw_cell_background:
                    draw_background(stream, cell.background)

    # Draw borders.
    if table.style['border_collapse'] == 'collapse':
        return draw_collapsed_borders(stream, table)
    draw_border(stream, table)
    for row_group in table.children:
        for row in row_group.children:
            for cell in row.children:
                if cell.style['empty_cells'] == 'show' or not cell.empty:
                    draw_border(stream, cell)


def draw_collapsed_borders(stream, table):
    """Draw borders of table cells when they collapse."""
    row_heights = [
        row.height for row_group in table.children
        for row in row_group.children]
    column_widths = table.column_widths
    if not (row_heights and column_widths):
        # One of the list is empty: don’t bother with empty tables.
        return
    row_positions = [
        row.position_y for row_group in table.children
        for row in row_group.children]
    column_positions = list(table.column_positions)
    grid_height = len(row_heights)
    grid_width = len(column_widths)
    assert grid_width == len(column_positions)
    vertical_borders, horizontal_borders = table.collapsed_border_grid
    # Add the end of the last column.
    column_positions.append(column_positions[-1] + column_widths[-1])
    # Add the end of the last row.
    row_positions.append(row_positions[-1] + row_heights[-1])
    if table.children[0].is_header:
        header_rows = len(table.children[0].children)
    else:
        header_rows = 0
    if table.children[-1].is_footer:
        footer_rows = len(table.children[-1].children)
    else:
        footer_rows = 0
    skipped_rows = table.skipped_rows
    if skipped_rows:
        body_rows_offset = skipped_rows - header_rows
    else:
        body_rows_offset = 0
    original_grid_height = len(vertical_borders)
    footer_rows_offset = original_grid_height - grid_height

    def row_number(y, horizontal):
        # Examples in comments for 2 headers rows, 5 body rows, 3 footer rows.
        if header_rows and y < header_rows + int(horizontal):
            # Row in header: y < 2 for vertical, y < 3 for horizontal.
            return y
        elif footer_rows and y >= grid_height - footer_rows - int(horizontal):
            # Row in footer: y >= 7 for vertical, y >= 6 for horizontal.
            return y + footer_rows_offset
        else:
            # Row in body: 2 >= y > 7 for vertical, 3 >= y > 6 for horizontal.
            return y + body_rows_offset

    segments = []

    def half_max_width(border_list, yx_pairs, vertical=True):
        result = 0
        for y, x in yx_pairs:
            if vertical:
                inside = 0 <= y < grid_height and 0 <= x <= grid_width
            else:
                inside = 0 <= y <= grid_height and 0 <= x < grid_width
            if inside:
                yy = row_number(y, horizontal=not vertical)
                _, (_, width, _) = border_list[yy][x]
                result = max(result, width)
        return result / 2

    def add_vertical(x, y):
        yy = row_number(y, horizontal=False)
        score, (style, width, color) = vertical_borders[yy][x]
        if width == 0 or color.alpha == 0:
            return
        pos_x = column_positions[x]
        pos_y1 = row_positions[y]
        if y != 0 or not table.skip_cell_border_top:
            pos_y1 -= half_max_width(
                horizontal_borders, [(y, x - 1), (y, x)], vertical=False)
        pos_y2 = row_positions[y + 1]
        if y != grid_height - 1 or not table.skip_cell_border_bottom:
            pos_y2 += half_max_width(
                horizontal_borders, [(y + 1, x - 1), (y + 1, x)], vertical=False)
        segments.append((
            score, style, width, color, 'left', (pos_x, pos_y1, 0, pos_y2 - pos_y1)))

    def add_horizontal(x, y):
        if y == 0 and table.skip_cell_border_top:
            return
        if y == grid_height and table.skip_cell_border_bottom:
            return
        yy = row_number(y, horizontal=True)
        score, (style, width, color) = horizontal_borders[yy][x]
        if width == 0 or color.alpha == 0:
            return
        pos_y = row_positions[y]
        shift_before = half_max_width(vertical_borders, [(y - 1, x), (y, x)])
        shift_after = half_max_width(vertical_borders, [(y - 1, x + 1), (y, x + 1)])
        pos_x1 = column_positions[x] - shift_before
        pos_x2 = column_positions[x + 1] + shift_after
        segments.append((
            score, style, width, color, 'top', (pos_x1, pos_y, pos_x2 - pos_x1, 0)))

    for x in range(grid_width):
        add_horizontal(x, 0)
    for y in range(grid_height):
        add_vertical(0, y)
        for x in range(grid_width):
            add_vertical(x + 1, y)
            add_horizontal(x, y + 1)

    # Sort bigger scores last (painted later, on top).
    segments.sort(key=operator.itemgetter(0))

    for segment in segments:
        _, style, width, color, side, border_box = segment
        bx, by, bw, bh = border_box
        color = styled_color(style, color, side)
        with stream.artifact(), stream.stacked():
            draw_line(stream, bx, by, bx + bw, by + bh, width, style, color)


def draw_replacedbox(stream, box):
    """Draw the given :class:`boxes.ReplacedBox` to a ``pdf.stream.Stream``."""
    if box.style['visibility'] != 'visible' or not box.width or not box.height:
        return

    draw_width, draw_height, draw_x, draw_y = replaced.replacedbox_layout(box)
    if draw_width <= 0 or draw_height <= 0:
        return

    with stream.stacked():
        stream.set_alpha(1)
        stream.transform(e=draw_x, f=draw_y)
        with stream.stacked():
            # TODO: Use the real intrinsic size here, not affected by
            # 'image-resolution'?
            box.replacement.draw(stream, draw_width, draw_height, box.style)


def draw_inline_level(stream, page, box, offset_x=0, text_overflow='clip',
                      block_ellipsis='none'):
    if isinstance(box, StackingContext):
        stacking_context = box
        allowed_boxes = (boxes.InlineBlockBox, boxes.InlineFlexBox, boxes.InlineGridBox)
        assert isinstance(stacking_context.box, allowed_boxes)
        draw_stacking_context(stream, stacking_context)
    else:
        set_mask_border(stream, box)
        draw_background(stream, box.background)
        draw_border(stream, box)
        if isinstance(box, (boxes.InlineBox, boxes.LineBox)):
            if isinstance(box, boxes.LineBox):
                text_overflow = box.text_overflow
                block_ellipsis = box.block_ellipsis
            ellipsis = 'none'
            for i, child in enumerate(box.children):
                if i == len(box.children) - 1:
                    # Last child
                    ellipsis = block_ellipsis
                if isinstance(child, StackingContext):
                    child_offset_x = offset_x
                else:
                    child_offset_x = offset_x + child.position_x - box.position_x
                if isinstance(child, boxes.TextBox):
                    with stream.marked(child, 'Span'):
                        draw_text(
                            stream, child, child_offset_x, text_overflow, ellipsis)
                else:
                    draw_inline_level(
                        stream, page, child, child_offset_x, text_overflow, ellipsis)
        elif isinstance(box, boxes.InlineReplacedBox):
            with stream.marked(box, 'Figure'):
                draw_replacedbox(stream, box)
        else:
            assert isinstance(box, boxes.TextBox)
            # Should only happen for list markers.
            draw_text(stream, box, offset_x, text_overflow)


def draw_block_level(page, stream, blocks_and_cells):
    for block, blocks_and_cells in blocks_and_cells.items():
        if isinstance(block, boxes.ReplacedBox):
            with stream.marked(block, 'Figure'):
                draw_replacedbox(stream, block)
        elif block.children:
            if isinstance(block.children[-1], boxes.LineBox):
                for child in block.children:
                    draw_inline_level(stream, page, child)
        draw_block_level(page, stream, blocks_and_cells)


================================================
FILE: weasyprint/draw/border.py
================================================
"""Draw borders."""

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

SIDES = ('top', 'right', 'bottom', 'left')


def set_mask_border(stream, box):
    """Set ``box`` mask border as alpha state on ``stream``."""
    if box.style['mask_border_source'][0] == 'none' or box.mask_border_image is None:
        return
    x, y, w, h, tl, tr, br, bl = box.rounded_border_box()
    matrix = Matrix(e=x, f=y)
    matrix @= stream.ctm
    mask_stream = stream.set_alpha_state(x, y, w, h, box.style['mask_border_mode'])
    draw_border_image(
        box, mask_stream, box.mask_border_image, box.style['mask_border_slice'],
        box.style['mask_border_repeat'], box.style['mask_border_outset'],
        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.style, 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``."""

    # The box is hidden, easy.
    if box.style['visibility'] != 'visible':
        return

    # 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']:
        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:
        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]

    if set(widths) == {0}:
        # No border, return early.
        return

    colors = [get_color(box.style, f'border_{side}_color') for side in SIDES]
    styles = [
        colors[i].alpha and box.style[f'border_{side}_style']
        for (i, side) in enumerate(SIDES)]

    simple_style = set(styles) in ({'solid'}, {'double'})  # one style, simple lines
    single_color = len(set(colors)) == 1  # one color
    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.
        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
    # draw them side by side. Order is not specified, but this one seems to be
    # close to what other browsers do.
    values = tuple(zip(SIDES, widths, colors, styles))
    for index in (2, 3, 1, 0):
        side, width, color, style = values[index]
        if width == 0 or not color:
            continue
        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))


def draw_border_image(box, stream, image, border_slice, border_repeat, border_outset,
                      border_width):
    """Draw ``image`` as a border image for ``box`` on ``stream`` as specified."""
    # Shared by border-image-* and mask-border-*.
    width, height, ratio = image.get_intrinsic_size(
        box.style['image_resolution'], box.style['font_size'])
    intrinsic_width, intrinsic_height = replaced.default_image_sizing(
        width, height, ratio, specified_width=None, specified_height=None,
        default_width=box.border_width(), default_height=box.border_height())

    image_slice = border_slice[:4]
    should_fill = border_slice[4]

    def compute_slice_dimension(dimension, intrinsic):
        if isinstance(dimension, (int, float)):
            return min(dimension, intrinsic)
        else:
            assert dimension.unit == '%'
            return min(100, dimension.value) / 100 * intrinsic

    slice_top = compute_slice_dimension(image_slice[0], intrinsic_height)
    slice_right = compute_slice_dimension(image_slice[1], intrinsic_width)
    slice_bottom = compute_slice_dimension(image_slice[2], intrinsic_height)
    slice_left = compute_slice_dimension(image_slice[3], intrinsic_width)

    repeat_x, repeat_y = border_repeat

    x, y, w, h, tl, tr, br, bl = box.rounded_border_box()
    px, py, pw, ph, ptl, ptr, pbr, pbl = box.rounded_padding_box()
    border_left = px - x
    border_top = py - y
    border_right = w - pw - border_left
    border_bottom = h - ph - border_top

    def compute_outset_dimension(dimension, from_border):
        if dimension.unit is None:
            return dimension.value * from_border
        else:
            assert dimension.unit == 'px'
            return dimension.value

    outset_top = compute_outset_dimension(border_outset[0], border_top)
    outset_right = compute_outset_dimension(border_outset[1], border_right)
    outset_bottom = compute_outset_dimension(border_outset[2], border_bottom)
    outset_left = compute_outset_dimension(border_outset[3], border_left)

    x -= outset_left
    y -= outset_top
    w += outset_left + outset_right
    h += outset_top + outset_bottom

    def compute_width_adjustment(dimension, original, intrinsic,
                                 area_dimension):
        if dimension == 'auto':
            return intrinsic
        elif isinstance(dimension, (int, float)):
            return dimension * original
        elif dimension.unit == '%':
            return dimension.value / 100 * area_dimension
        else:
            assert dimension.unit == 'px'
            return dimension.value

    # We make adjustments to the border_* variables after handling outsets
    # because numerical outsets are relative to border-width, not
    # border-image-width. Also, the border image area that is used
    # for percentage-based border-image-width values includes any expanded
    # area due to border-image-outset.
    border_top = compute_width_adjustment(
        border_width[0], border_top, slice_top, h)
    border_right = compute_width_adjustment(
        border_width[1], border_right, slice_right, w)
    border_bottom = compute_width_adjustment(
        border_width[2], border_bottom, slice_bottom, h)
    border_left = compute_width_adjustment(
        border_width[3], border_left, slice_left, w)

    def draw_border_image_region(x, y, width, height, slice_x, slice_y, slice_width,
                                 slice_height, repeat_x='stretch', repeat_y='stretch',
                                 scale_x=None, scale_y=None):
        if 0 in (intrinsic_width, width, slice_width):
            scale_x = 0
        else:
            extra_dx = 0
            if not scale_x:
                scale_x = (height / slice_height) if height and slice_height else 1
            if repeat_x == 'repeat':
                n_repeats_x = ceil(width / slice_width / scale_x)
            elif repeat_x == 'space':
                n_repeats_x = floor(width / slice_width / scale_x)
                # Space is before the first repeat and after the last,
                # so there's one more space than repeat.
                extra_dx = (
                    (width / scale_x - n_repeats_x * slice_width) / (n_repeats_x + 1))
            elif repeat_x == 'round':
                n_repeats_x = max(1, round(width / slice_width / scale_x))
                scale_x = width / (n_repeats_x * slice_width)
            else:
                n_repeats_x = 1
                scale_x = width / slice_width

        if 0 in (intrinsic_height, height, slice_height):
            scale_y = 0
        else:
            extra_dy = 0
            if not scale_y:
                scale_y = (width / slice_width) if width and slice_width else 1
            if repeat_y == 'repeat':
                n_repeats_y = ceil(height / slice_height / scale_y)
            elif repeat_y == 'space':
                n_repeats_y = floor(height / slice_height / scale_y)
                # Space is before the first repeat and after the last,
                # so there's one more space than repeat.
                extra_dy = (
                    (height / scale_y - n_repeats_y * slice_height) / (n_repeats_y + 1))
            elif repeat_y == 'round':
                n_repeats_y = max(1, round(height / slice_height / scale_y))
                scale_y = height / (n_repeats_y * slice_height)
            else:
                n_repeats_y = 1
                scale_y = height / slice_height

        if 0 in (scale_x, scale_y):
            return scale_x, scale_y

        rendered_width = intrinsic_width * scale_x
        rendered_height = intrinsic_height * scale_y
        offset_x = rendered_width * slice_x / intrinsic_width
        offset_y = rendered_height * slice_y / intrinsic_height

        with stream.stacked():
            stream.rectangle(x, y, width, height)
            stream.clip()
            stream.end()
            stream.transform(e=x - offset_x + extra_dx, f=y - offset_y + extra_dy)
            stream.transform(a=scale_x, d=scale_y)
            for i in range(n_repeats_x):
                for j in range(n_repeats_y):
                    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)
                        stream.rectangle(
                            offset_x / scale_x, offset_y / scale_y,
                            slice_width, slice_height)
                        stream.clip()
                        stream.end()
                        image.draw(stream, intrinsic_width, intrinsic_height, box.style)

        return scale_x, scale_y

    # Top left.
    scale_left, scale_top = draw_border_image_region(
        x, y, border_left, border_top, 0, 0, slice_left, slice_top)
    # Top right.
    draw_border_image_region(
        x + w - border_right, y, border_right, border_top,
        intrinsic_width - slice_right, 0, slice_right, slice_top)
    # Bottom right.
    scale_right, scale_bottom = draw_border_image_region(
        x + w - border_right, y + h - border_bottom, border_right, border_bottom,
        intrinsic_width - slice_right, intrinsic_height - slice_bottom,
        slice_right, slice_bottom)
    # Bottom left.
    draw_border_image_region(
        x, y + h - border_bottom, border_left, border_bottom,
        0, intrinsic_height - slice_bottom, slice_left, slice_bottom)
    if x_middle := slice_left + slice_right < intrinsic_width:
        # Top middle.
        draw_border_image_region(
            x + border_left, y, w - border_left - border_right, border_top,
            slice_left, 0, intrinsic_width - slice_left - slice_right,
            slice_top, repeat_x=repeat_x)
        # Bottom middle.
        draw_border_image_region(
            x + border_left, y + h - border_bottom,
            w - border_left - border_right, border_bottom,
            slice_left, intrinsic_height - slice_bottom,
            intrinsic_width - slice_left - slice_right, slice_bottom,
            repeat_x=repeat_x)
    if y_middle := slice_top + slice_bottom < intrinsic_height:
        # Right middle.
        draw_border_image_region(
            x + w - border_right, y + border_top,
            border_right, h - border_top - border_bottom,
            intrinsic_width - slice_right, slice_top,
            slice_right, intrinsic_height - slice_top - slice_bottom,
            repeat_y=repeat_y)
        # Left middle.
        draw_border_image_region(
            x, y + border_top, border_left, h - border_top - border_bottom,
            0, slice_top, slice_left,
            intrinsic_height - slice_top - slice_bottom,
            repeat_y=repeat_y)
    if should_fill and x_middle and y_middle:
        # Fill middle.
        draw_border_image_region(
            x + border_left, y + border_top, w - border_left - border_right,
            h - border_top - border_bottom, slice_left, slice_top,
            intrinsic_width - slice_left - slice_right,
            intrinsic_height - slice_top - slice_bottom,
            repeat_x=repeat_x, repeat_y=repeat_y,
            scale_x=scale_left or scale_right, scale_y=scale_top or scale_bottom)


def clip_border_segment(stream, style, width, side, border_box,
                        border_widths=None, radii=None):
    """Clip one segment of box border.

    The strategy is to remove the zones not needed because of the style or the
    side before painting.

    """
    bbx, bby, bbw, bbh = border_box
    (tlh, tlv), (trh, trv), (brh, brv), (blh, blv) = radii or 4 * ((0, 0),)
    bt, br, bb, bl = border_widths or 4 * (width,)

    def transition_point(x1, y1, x2, y2):
        """Get the point use for border transition.

        The extra boolean returned is ``True`` if the point is in the padding
        box (ie. the padding box is rounded).

        This point is not specified. We must be sure to be inside the rounded
        padding box, and in the zone defined in the "transition zone" allowed
        by the specification. We chose the corner of the transition zone. It's
        easy to get and gives quite good results, but it seems to be different
        from what other browsers do.

        """
        return (
            ((x1, y1), True) if abs(x1) > abs(x2) and abs(y1) > abs(y2)
            else ((x2, y2), False))

    def corner_half_length(a, b):
        """Return the length of the half of one ellipsis corner.

        Inspired by [Ramanujan, S., "Modular Equations and Approximations to
        pi" Quart. J. Pure. Appl. Math., vol. 45 (1913-1914), pp. 350-372],
        wonderfully explained by Dr Rob.

        https://mathforum.org/dr.math/faq/formulas/

        """
        x = (a - b) / (a + b)
        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)
        width = bt
        way = 1
        angle = 1
        main_offset = bby
    elif side == 'right':
        (px1, py1), rounded1 = transition_point(-trh, trv, -br, bt)
        (px2, py2), rounded2 = transition_point(-brh, -brv, -br, -bb)
        width = br
        way = 1
        angle = 2
        main_offset = bbx + bbw
    elif side == 'bottom':
        (px1, py1), rounded1 = transition_point(blh, -blv, bl, -bb)
        (px2, py2), rounded2 = transition_point(-brh, -brv, -br, -bb)
        width = bb
        way = -1
        angle = 3
        main_offset = bby + bbh
    elif side == 'left':
        (px1, py1), rounded1 = transition_point(tlh, tlv, bl, bt)
        (px2, py2), rounded2 = transition_point(blh, -blv, bl, -bb)
        width = bl
        way = -1
        angle = 4
        main_offset = bbx

    if side in ('top', 'bottom'):
        a1, b1 = px1 - bl / 2, way * py1 - width / 2
        a2, b2 = -px2 - br / 2, way * py2 - width / 2
        line_length = bbw - px1 + px2
        length = bbw
        stream.move_to(bbx + bbw, main_offset)
        stream.line_to(bbx, main_offset)
        stream.line_to(bbx + px1, main_offset + py1)
        stream.line_to(bbx + bbw + px2, main_offset + py2)
    elif side in ('left', 'right'):
        a1, b1 = -way * px1 - width / 2, py1 - bt / 2
        a2, b2 = -way * px2 - width / 2, -py2 - bb / 2
        line_length = bbh - py1 + py2
        length = bbh
        stream.move_to(main_offset, bby + bbh)
        stream.line_to(main_offset, bby)
        stream.line_to(main_offset + px1, bby + py1)
        stream.line_to(main_offset + px2, bby + bbh + py2)

    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.
            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.
                dash = length / (dash_length + dash_length % 2)
            else:
                # 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_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 = (
                        ((2 * angle - way) + i * way * dash / chl) /
                        4 * pi)
                    angle2 = (min if way > 0 else max)(
                        ((2 * angle - way) + (i + 1) * way * dash / chl) /
                        4 * pi,
                        angle * pi / 2)
                    if side in ('top', 'bottom'):
                        stream.move_to(x + px, main_offset + py)
                        stream.line_to(
                            x + px - way * px * 1 / tan(angle2), main_offset)
                        stream.line_to(
                            x + px - way * px * 1 / tan(angle1), main_offset)
                    elif side in ('left', 'right'):
                        stream.move_to(main_offset + px, y + py)
                        stream.line_to(
                            main_offset, y + py + way * py * tan(angle2))
                        stream.line_to(
                            main_offset, y + py + way * py * tan(angle1))
                    if angle2 == angle * pi / 2:
                        offset = (angle1 - angle2) / ((
                            ((2 * angle - way) + (i + 1) * way * dash / chl) /
                            4 * pi) - angle1)
                        line += 1
                        break
                else:
                    offset = 1 - (
                        (angle * pi / 2 - angle2) / (angle2 - angle1))
                return line, offset

            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 = 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 = bby + py1 + i * dash
                        y2 = bby + py1 + (i + 1) * dash
                        x1 = main_offset - (width if way > 0 else 0)
                        x2 = x1 + width
                    draw_dash(
                        x1 + (x2 - x1) / 2, y1 + (y2 - y1) / 2,
                        x2 - x1, y2 - y1, width / 2)
        else:
            # 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(number_of_dashes + 1):
                advance = i * (space + dash)
                if side == 'top':
                    cx, cy = bbx + advance + dash / 2, bby + width / 2
                    dash_width, dash_height = dash, width
                elif side == 'right':
                    cx, cy = bbx + bbw - width / 2, bby + advance + dash / 2
                    dash_width, dash_height = width, dash
                elif side == 'bottom':
                    cx, cy = bbx + advance + dash / 2, bby + bbh - width / 2
                    dash_width, dash_height = dash, width
                elif side == 'left':
                    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()


def draw_rounded_border(stream, box, style, color):
    if style in ('ridge', 'groove'):
        stream.set_color(color[0])
        rounded_box(stream, box.rounded_padding_box())
        rounded_box(stream, box.rounded_box_ratio(1 / 2))
        stream.fill(even_odd=True)
        stream.set_color(color[1])
        rounded_box(stream, box.rounded_box_ratio(1 / 2))
        rounded_box(stream, box.rounded_border_box())
        stream.fill(even_odd=True)
        return
    stream.set_color(color)
    rounded_box(stream, box.rounded_padding_box())
    if style == 'double':
        rounded_box(stream, box.rounded_box_ratio(1 / 3))
        rounded_box(stream, box.rounded_box_ratio(2 / 3))
    rounded_box(stream, box.rounded_border_box())
    stream.fill(even_odd=True)


def draw_rect_border(stream, box, widths, style, color):
    bbx, bby, bbw, bbh = box
    bt, br, bb, bl = widths
    if style in ('ridge', 'groove'):
        stream.set_color(color[0])
        stream.rectangle(*box)
        stream.rectangle(
            bbx + bl / 2, bby + bt / 2,
            bbw - (bl + br) / 2, bbh - (bt + bb) / 2)
        stream.fill(even_odd=True)
        stream.rectangle(
            bbx + bl / 2, bby + bt / 2,
            bbw - (bl + br) / 2, bbh - (bt + bb) / 2)
        stream.rectangle(bbx + bl, bby + bt, bbw - bl - br, bbh - bt - bb)
        stream.set_color(color[1])
        stream.fill(even_odd=True)
        return
    stream.set_color(color)
    stream.rectangle(*box)
    if style == 'double':
        stream.rectangle(
            bbx + bl / 3, bby + bt / 3,
            bbw - (bl + br) / 3, bbh - (bt + bb) / 3)
        stream.rectangle(
            bbx + bl * 2 / 3, bby + bt * 2 / 3,
            bbw - (bl + br) * 2 / 3, bbh - (bt + bb) * 2 / 3)
    stream.rectangle(bbx + bl, bby + bt, bbw - bl - br, bbh - bt - bb)
    stream.fill(even_odd=True)


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 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_line_cap(1)
            stream.set_dash([0, 2 * thickness], offset)

        if style == 'double':
            stream.set_line_width(thickness / 3)
            if x1 == x2:
                stream.move_to(x1 - thickness / 3, y1)
                stream.line_to(x2 - thickness / 3, y2)
                stream.move_to(x1 + thickness / 3, y1)
                stream.line_to(x2 + thickness / 3, y2)
            elif y1 == y2:
                stream.move_to(x1, y1 - thickness / 3)
                stream.line_to(x2, y2 - thickness / 3)
                stream.move_to(x1, y1 + thickness / 3)
                stream.line_to(x2, y2 + thickness / 3)
        elif style in ('ridge', 'groove'):
            stream.set_line_width(thickness / 2)
            stream.set_color(color[0], stroke=True)
            if x1 == x2:
                stream.move_to(x1 + thickness / 4, y1)
                stream.line_to(x2 + thickness / 4, y2)
            elif y1 == y2:
                stream.move_to(x1, y1 + thickness / 4)
                stream.line_to(x2, y2 + thickness / 4)
            stream.stroke()
            stream.set_color(color[1], stroke=True)
            if x1 == x2:
                stream.move_to(x1 - thickness / 4, y1)
                stream.line_to(x2 - thickness / 4, y2)
            elif y1 == y2:
                stream.move_to(x1, y1 - thickness / 4)
                stream.line_to(x2, y2 - thickness / 4)
        elif style == 'wavy':
            assert y1 == y2  # Only allowed for text decoration
            up = 1
            radius = 0.75 * thickness

            stream.rectangle(x1, y1 - 2 * radius, x2 - x1, 4 * radius)
            stream.clip()
            stream.end()

            x = x1 - offset
            stream.move_to(x, y1)
            while x < x2:
                stream.set_line_width(thickness)
                stream.curve_to(
                    x + radius / 2, y1 + up * radius,
                    x + 3 * radius / 2, y1 + up * radius,
                    x + 2 * radius, y1)
                x += 2 * radius
                up *= -1
        else:
            stream.set_line_width(thickness)
            stream.move_to(x1, y1)
            stream.line_to(x2, y2)
        stream.stroke()


def draw_outline(stream, box):
    width = box.style['outline_width']
    offset = box.style['outline_offset']
    color = get_color(box.style, 'outline_color')
    style = box.style['outline_style']
    if box.style['visibility'] == 'visible' and width and color.alpha:
        outline_box = (
            box.border_box_x() - width - offset,
            box.border_box_y() - width - offset,
            box.border_width() + 2 * width + 2 * offset,
            box.border_height() + 2 * width + 2 * offset)
        for side in SIDES:
            with stream.artifact(), stream.stacked():
                clip_border_segment(stream, style, width, side, outline_box)
                draw_rect_border(
                    stream, outline_box, 4 * (width,), style,
                    styled_color(style, color, side))

    for child in box.children:
        if isinstance(child, boxes.Box):
            draw_outline(stream, child)


def rounded_box(stream, radii):
    """Draw the path of the border radius box.

    ``widths`` is a tuple of the inner widths (top, right, bottom, left) from
    the border box. Radii are adjusted from these values. Default is (0, 0, 0,
    0).

    """
    x, y, w, h, tl, tr, br, bl = radii

    if all(0 in corner for corner in (tl, tr, br, bl)):
        # No radius, draw a rectangle
        stream.rectangle(x, y, w, h)
        return

    r = 0.45

    stream.move_to(x + tl[0], y)
    stream.line_to(x + w - tr[0], y)
    stream.curve_to(
        x + w - tr[0] * r, y, x + w, y + tr[1] * r, x + w, y + tr[1])
    stream.line_to(x + w, y + h - br[1])
    stream.curve_to(
        x + w, y + h - br[1] * r, x + w - br[0] * r, y + h, x + w - br[0],
        y + h)
    stream.line_to(x + bl[0], y + h)
    stream.curve_to(
        x + bl[0] * r, y + h, x, y + h - bl[1] * r, x, y + h - bl[1])
    stream.line_to(x, y + tl[1])
    stream.curve_to(
        x, y + tl[1] * r, x + tl[0] * r, y, x + tl[0], y)


================================================
FILE: weasyprint/draw/color.py
================================================
"""Draw colors."""

from colorsys import hsv_to_rgb, rgb_to_hsv

from tinycss2.color5 import parse_color


def get_color(style, key):
    """Return color, taking care of possible currentColor value."""
    value = style[key]
    return value if value != 'currentcolor' else style['color']


def darken(color):
    """Return a darker color."""
    # TODO: handle color spaces.
    hue, saturation, value = rgb_to_hsv(*color.to('srgb')[:3])
    value /= 1.5
    saturation /= 1.25
    return parse_color(
        'rgb(%f%% %f%% %f%%/%f)' % (*hsv_to_rgb(hue, saturation, value), color.alpha))


def lighten(color):
    """Return a lighter color."""
    # TODO: handle color spaces.
    hue, saturation, value = rgb_to_hsv(*color.to('srgb')[:3])
    value = 1 - (1 - value) / 1.5
    if saturation:
        saturation = 1 - (1 - saturation) / 1.25
    return parse_color(
        'rgb(%f%% %f%% %f%%/%f)' % (*hsv_to_rgb(hue, saturation, value), color.alpha))


def styled_color(style, color, side):
    """Return inset, outset, ridge and groove border colors."""
    if style in ('inset', 'outset'):
        do_lighten = (side in ('top', 'left')) ^ (style == 'inset')
        return (lighten if do_lighten else darken)(color)
    elif style in ('ridge', 'groove'):
        if (side in ('top', 'left')) ^ (style == 'ridge'):
            return lighten(color), darken(color)
        else:
            return darken(color), lighten(color)
    return color


================================================
FILE: weasyprint/draw/text.py
================================================
"""Draw text."""

from io import BytesIO
from xml.etree import ElementTree

from PIL import Image

from ..images import RasterImage, SVGImage
from ..logger import LOGGER
from ..matrix import Matrix
from ..text.ffi import FROM_UNITS, TO_UNITS, ffi, pango
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


def draw_text(stream, textbox, offset_x, text_overflow, block_ellipsis):
    """Draw a textbox to a pydyf stream."""
    from ..layout.percent import percentage

    # Pango crashes with font-size: 0.
    assert textbox.style['font_size']

    # Don’t draw invisible textboxes.
    if textbox.style['visibility'] != 'visible':
        return

    # Draw underline and overline.
    text_decoration_values = textbox.style['text_decoration_line']
    text_decoration_color = get_color(textbox.style, 'text_decoration_color')
    if 'underline' in text_decoration_values or 'overline' in text_decoration_values:
        if textbox.style['text_decoration_thickness'] in ('auto', 'from-font'):
            thickness = textbox.pango_layout.underline_thickness
        else:
            thickness = percentage(
                textbox.style['text_decoration_thickness'], textbox.style,
                textbox.style['font_size'])
    if 'overline' in text_decoration_values:
        offset_y = (
            textbox.baseline - textbox.pango_layout.ascent + thickness / 2)
        draw_text_decoration(
            stream, textbox, offset_x, offset_y, thickness,
            text_decoration_color)
    if 'underline' in text_decoration_values:
        if textbox.style['text_underline_offset'] == 'auto':
            underline_offset = - textbox.pango_layout.underline_position
        else:
            underline_offset = percentage(
                textbox.style['text_underline_offset'], textbox.style,
                textbox.style['font_size'])
        offset_y = textbox.baseline + underline_offset + thickness / 2
        draw_text_decoration(
            stream, textbox, offset_x, offset_y, thickness,
            text_decoration_color)

    # Draw text.
    x, y = textbox.position_x, textbox.position_y + textbox.baseline
    stream.set_color(textbox.style['color'])
    textbox.pango_layout.reactivate(textbox.style)
    stream.begin_text()
    emojis = draw_first_line(
        stream, textbox, text_overflow, block_ellipsis, Matrix(d=-1, e=x, f=y))
    stream.end_text()

    # Draw emojis.
    draw_emojis(stream, textbox.style, x, y, emojis)

    # Draw line through.
    if 'line-through' in text_decoration_values:
        thickness = textbox.pango_layout.strikethrough_thickness
        offset_y = textbox.baseline - textbox.pango_layout.strikethrough_position
        draw_text_decoration(
            stream, textbox, offset_x, offset_y, thickness, text_decoration_color)
    textbox.pango_layout.deactivate()


def draw_emojis(stream, style, x, y, emojis):
    """Draw list of emojis."""
    font_size = style['font_size']
    for image, font, a, d, e, f in emojis:
        with stream.stacked():
            stream.transform(a=a, d=d, e=x + e * font_size, f=y + f)
            image.draw(stream, font_size, font_size, style)


def draw_first_line(stream, textbox, text_overflow, block_ellipsis, matrix):
    """Draw the given ``textbox`` line to the document ``stream``."""
    # Don’t draw lines with only invisible characters.
    if not textbox.text.strip():
        return []

    if textbox.style['font_size'] < 1e-6:  # default float precision used by pydyf
        return []

    pango.pango_layout_set_single_paragraph_mode(textbox.pango_layout.layout, True)

    if text_overflow == 'ellipsis' or block_ellipsis != 'none':
        assert textbox.pango_layout.max_width is not None
        max_width = textbox.pango_layout.max_width
        pango.pango_layout_set_width(
            textbox.pango_layout.layout, int(max_width * TO_UNITS))
        if text_overflow == 'ellipsis':
            pango.pango_layout_set_ellipsize(
                textbox.pango_layout.layout, pango.PANGO_ELLIPSIZE_END)
        else:
            if block_ellipsis == 'auto':
                ellipsis = '…'
            else:
                assert block_ellipsis[0] == 'string'
                ellipsis = block_ellipsis[1]

            # Remove last word if hyphenated.
            new_text = textbox.pango_layout.text
            if new_text.endswith(textbox.style['hyphenate_character']):
                last_word_end = get_last_word_end(
                    new_text[:-len(textbox.style['hyphenate_character'])],
                    textbox.style['lang'])
                if last_word_end:
                    new_text = new_text[:last_word_end]

            textbox.pango_layout.set_text(new_text + ellipsis)

    first_line, index = textbox.pango_layout.get_first_line()

    if block_ellipsis != 'none':
        while index:
            last_word_end = get_last_word_end(
                textbox.pango_layout.text[:-len(ellipsis)],
                textbox.style['lang'])
            if last_word_end is None:
                break
            new_text = textbox.pango_layout.text[:last_word_end]
            textbox.pango_layout.set_text(new_text + ellipsis)
            first_line, index = textbox.pango_layout.get_first_line()

    utf8_text = textbox.pango_layout.text.encode()
    stream.set_text_matrix(*matrix.values)
    previous_pango_font = None
    string = ''
    x_advance = 0
    emojis = []
    run = first_line.runs[0]
    while run != ffi.NULL:
        # Get Pango objects.
        glyph_item = run.data
        run = run.next
        glyph_string = glyph_item.glyphs
        glyphs_info = glyph_string.glyphs
        number_of_glyphs = glyph_string.num_glyphs
        offset = glyph_item.item.offset
        clusters = glyph_string.log_clusters

        # Get positions of the glyphs in the UTF-8 string.
        utf8_positions = [offset + clusters[i] for i in range(number_of_glyphs)]
        if glyph_item.item.analysis.level % 2:
            utf8_positions.insert(0, offset + glyph_item.item.length)  # rtl
        else:
            utf8_positions.append(offset + glyph_item.item.length)  # ltr

        pango_font = glyph_item.item.analysis.font
        if pango_font != previous_pango_font:
            # Add font file content and get font size.
            previous_pango_font = pango_font
            font, font_size = stream.add_font(pango_font)

            # Workaround for https://gitlab.gnome.org/GNOME/pango/-/issues/530.
            if pango.pango_version() < 14802:
                font_size = textbox.style['font_size']

            # Go through the run glyphs.
            if string:
                stream.show_text(string)
            string = ''
            stream.set_font_size(font.hash, 1 if font.bitmap else font_size)
        string += '<'
        for i in range(number_of_glyphs):
            glyph_info = glyphs_info[i]
            glyph_id = glyph_info.glyph
            width = glyph_info.geometry.width

            # Display zero-width empty glyph.
            if glyph_id == pango.PANGO_GLYPH_EMPTY:
                string += f'>{-width / font_size}<'
                continue

            # Display .notdef and log warning for missing glyphs.
            if glyph_id & pango.PANGO_GLYPH_UNKNOWN_FLAG:
                codepoint = glyph_id - pango.PANGO_GLYPH_UNKNOWN_FLAG
                LOGGER.warning(
                    '.notdef glyph rendered for Unicode string unsupported by fonts: '
                    f'"{chr(codepoint)}" (U+{codepoint:04X})')
                glyph_id = font.get_unused_glyph_id(codepoint)
                font.widths[glyph_id] = round(width * 1000 * FROM_UNITS / font_size)
                if 0 not in font.widths:
                    # "width" is actually Pango’s get_approximate_char_width. Force
                    # .notdef’s to use this width, even if it’s not the right, as we
                    # want to keep Pango’s layout for next glyphs.
                    font.widths[0] = font.widths[glyph_id]

            # Create mapping between glyphs and Unicode codepoints.
            if glyph_id not in font.to_unicode:
                utf8_slice = slice(*sorted(utf8_positions[i:i+2]))
                font.to_unicode[glyph_id] = utf8_text[utf8_slice].decode()

            # Set horizontal and vertical offsets.
            offset = glyph_info.geometry.x_offset / font_size
            rise = glyph_info.geometry.y_offset / 1000
            if rise:
                if string[-1] == '<':
                    string = string[:-1]
                else:
                    string += '>'
                stream.show_text(string)
                stream.set_text_rise(-rise)
                string = ''
                if offset:
                    string = f'{-offset}'
                string += f'<{glyph_id:02x}>' if font.bitmap else f'<{glyph_id:04x}>'
                stream.show_text(string)
                stream.set_text_rise(0)
                string = '<'
            else:
                if offset:
                    string += f'>{-offset}<'
                string += f'{glyph_id:02x}' if font.bitmap else f'{glyph_id:04x}'

            # Get glyph logical widths.
            if glyph_id in font.widths:
                logical_width = font.widths[glyph_id]
            else:
                pango.pango_font_get_glyph_extents(
                    pango_font, glyph_id, stream.ink_rect, stream.logical_rect)
                logical_width = font.widths[glyph_id] = round(
                    stream.logical_rect.width * 1000 * FROM_UNITS / font_size)

            # Set kerning, word spacing, letter spacing.
            kerning = logical_width + offset - width * 1000 * FROM_UNITS / font_size
            if kerning:
                string += f'>{int(kerning)}<'

            # Create list of emojis.
            if font.svg:
                svg_data = get_hb_object_data(font.hb_face, 'svg', glyph_id)
                if svg_data:
                    # Do as explained in specification
                    # https://learn.microsoft.com/typography/opentype/spec/svg
                    tree = ElementTree.fromstring(svg_data)
                    if tree.get('id') != f'glyph{glyph_id}':
                        defs = ElementTree.Element('defs')
                        for child in list(tree):
                            defs.append(child)
                            tree.remove(child)
                        tree.append(defs)
                        ElementTree.SubElement(
                            tree, 'use', attrib={'href': f'#glyph{glyph_id}'})
                    if 'viewBox' not in tree.attrib:
                        tree.attrib['viewBox'] = f'0 0 {font.upem} {font.upem}'
                    image = SVGImage(tree, None, None, None)
                    a = d = 1
                    emojis.append([image, font, a, d, x_advance, 0])
            elif font.png:
                png_data = get_hb_object_data(font.hb_font, 'png', glyph_id)
                if png_data:
                    pillow_image = Image.open(BytesIO(png_data))
                    image_id = f'{font.hash}{glyph_id}'
                    image = RasterImage(pillow_image, image_id, png_data)
                    d = logical_width / 1000
                    a = pillow_image.width / pillow_image.height * d
                    pango.pango_font_get_glyph_extents(
                        pango_font, glyph_id, stream.ink_rect,
                        stream.logical_rect)
                    f = -stream.logical_rect.y
                    f = f * FROM_UNITS / font_size - font_size
                    emojis.append([image, font, a, d, x_advance, f])

            x_advance += (logical_width + offset - kerning) / 1000

        # Close the last glyphs list, remove if empty.
        if string[-1] == '<':
            string = string[:-1]
        else:
            string += '>'

    # Draw text.
    stream.show_text(string)

    return emojis


def draw_text_decoration(stream, textbox, offset_x, offset_y, thickness, color):
    """Draw text-decoration of ``textbox`` to a ``pdf.stream.Stream``."""
    draw_line(
        stream, textbox.position_x, textbox.position_y + offset_y,
        textbox.position_x + textbox.width, textbox.position_y + offset_y,
        thickness, textbox.style['text_decoration_style'], color, offset_x)


================================================
FILE: weasyprint/formatting_structure/boxes.py
================================================
"""Classes for all types of boxes in the CSS formatting structure / box model.

See https://www.w3.org/TR/CSS21/visuren.html

Names are the same as in CSS 2.1 with the exception of ``TextBox``. In
WeasyPrint, any text is in a ``TextBox``. What CSS calls anonymous inline boxes
are text boxes but not all text boxes are anonymous inline boxes.

See https://www.w3.org/TR/CSS21/visuren.html#anonymous

Abstract classes, should not be instantiated:

* Box
* BlockLevelBox
* InlineLevelBox
* BlockContainerBox
* ReplacedBox
* ParentBox
* AtomicInlineLevelBox

Concrete classes:

* PageBox
* BlockBox
* InlineBox
* InlineBlockBox
* BlockReplacedBox
* InlineReplacedBox
* TextBox
* LineBox
* Various table-related Box subclasses

All concrete box classes whose name contains "Inline" or "Block" have one of
the following "outside" behavior:

* Block-level (inherits from :class:`BlockLevelBox`)
* Inline-level (inherits from :class:`InlineLevelBox`)

and one of the following "inside" behavior:

* Block container (inherits from :class:`BlockContainerBox`)
* Inline content (InlineBox and :class:`TextBox`)
* Replaced content (inherits from :class:`ReplacedBox`)

… with various combinasions of both.

See respective docstrings for details.

"""

import itertools
import sys

from ..css import AnonymousStyle


class Box:
    """Abstract base class for all boxes."""
    # Definitions for the rules generating anonymous table boxes
    # https://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
    proper_table_child = False
    internal_table_or_caption = False
    tabular_container = False

    # Keep track of removed collapsing spaces for wrap opportunities.
    leading_collapsible_space = False
    trailing_collapsible_space = False

    # Default, may be overriden on instances.
    is_table_wrapper = False
    is_flex_item = False
    is_grid_item = False
    is_for_root_element = False
    is_column = False
    is_leader = False
    is_outside_marker = False

    # Other properties
    transformation_matrix = None
    bookmark_label = None
    string_set = None
    footnote = None
    cached_counter_values = None
    missing_link = None
    link_annotation = None
    force_fragmentation = False

    # Default, overriden on some subclasses
    def all_children(self):
        return self.children

    def descendants(self, placeholders=False):
        """A flat generator for a box, its children and descendants."""
        yield self
        for child in self.children:
            if placeholders or isinstance(child, Box):
                yield from child.descendants(placeholders)
            else:
                yield child

    def __init__(self, element_tag, style, element):
        self.element_tag = element_tag
        self.element = element
        self.style = style
        self.remove_decoration_sides = set()
        self.children = []
        self.first_letter_style = None
        self.first_line_style = None

    def __repr__(self):
        return f'<{type(self).__name__} {self.element_tag}>'

    @classmethod
    def anonymous_from(cls, parent, *args, **kwargs):
        """Return an anonymous box that inherits from ``parent``."""
        style = AnonymousStyle(parent.style)
        return cls(parent.element_tag, style, parent.element, *args, **kwargs)

    def copy(self):
        """Return shallow copy of the box."""
        cls = type(self)
        # Create a new instance without calling __init__: parameters are
        # different depending on the class.
        new_box = cls.__new__(cls)
        # Copy attributes
        new_box.__dict__.update(self.__dict__)
        return new_box

    def deepcopy(self):
        """Return a copy of the box with recursive copies of its children."""
        return self.copy()

    def translate(self, dx=0, dy=0, ignore_floats=False):
        """Change the box’s position.

        Also update the children’s positions accordingly.

        """
        # Overridden in ParentBox to also translate children, if any.
        if dx == dy == 0:
            return
        self.position_x += dx
        self.position_y += dy
        for child in self.all_children():
            if not (ignore_floats and child.is_floated()):
                child.translate(dx, dy, ignore_floats)

    # Heights and widths

    def padding_width(self):
        """Width of the padding box."""
        return self.width + self.padding_left + self.padding_right

    def padding_height(self):
        """Height of the padding box."""
        return self.height + self.padding_top + self.padding_bottom

    def border_width(self):
        """Width of the border box."""
        return self.padding_width() + self.border_left_width + \
            self.border_right_width

    def border_height(self):
        """Height of the border box."""
        return self.padding_height() + self.border_top_width + \
            self.border_bottom_width

    def margin_width(self):
        """Width of the margin box (aka. outer box)."""
        return self.border_width() + self.margin_left + self.margin_right

    def margin_height(self):
        """Height of the margin box (aka. outer box)."""
        return self.border_height() + self.margin_top + self.margin_bottom

    # Corners positions

    def content_box_x(self):
        """Absolute horizontal position of the content box."""
        return self.position_x + self.margin_left + self.padding_left + \
            self.border_left_width

    def content_box_y(self):
        """Absolute vertical position of the content box."""
        return self.position_y + self.margin_top + self.padding_top + \
            self.border_top_width

    def padding_box_x(self):
        """Absolute horizontal position of the padding box."""
        return self.position_x + self.margin_left + self.border_left_width

    def padding_box_y(self):
        """Absolute vertical position of the padding box."""
        return self.position_y + self.margin_top + self.border_top_width

    def border_box_x(self):
        """Absolute horizontal position of the border box."""
        return self.position_x + self.margin_left

    def border_box_y(self):
        """Absolute vertical position of the border box."""
        return self.position_y + self.margin_top

    def hit_area(self):
        """Return the (x, y, w, h) rectangle where the box is clickable."""
        # "Border area. That's the area that hit-testing is done on."
        # https://lists.w3.org/Archives/Public/www-style/2012Jun/0318.html
        # TODO: manage the border radii, use outer_border_radii instead
        return (self.border_box_x(), self.border_box_y(),
                self.border_width(), self.border_height())

    def rounded_box(self, bt, br, bb, bl):
        """Position, size and radii of a box inside the outer border box.

        bt, br, bb, and bl are distances from the outer border box,
        defining a rectangle to be rounded.

        """
        tlrx, tlry = self.border_top_left_radius
        trrx, trry = self.border_top_right_radius
        brrx, brry = self.border_bottom_right_radius
        blrx, blry = self.border_bottom_left_radius

        # TODO: clamp all computed values, see #2705.
        tlrx = min(max(0, tlrx - bl), sys.maxsize)
        tlry = min(max(0, tlry - bt), sys.maxsize)
        trrx = min(max(0, trrx - br), sys.maxsize)
        trry = min(max(0, trry - bt), sys.maxsize)
        brrx = min(max(0, brrx - br), sys.maxsize)
        brry = min(max(0, brry - bb), sys.maxsize)
        blrx = min(max(0, blrx - bl), sys.maxsize)
        blry = min(max(0, blry - bb), sys.maxsize)

        x = self.border_box_x() + bl
        y = self.border_box_y() + bt
        width = self.border_width() - bl - br
        height = self.border_height() - bt - bb

        # Fix overlapping curves
        # See https://www.w3.org/TR/css-backgrounds-3/#corner-overlap
        ratio = min([1] + [
            extent / sum_radii
            for extent, sum_radii in (
                (width, tlrx + trrx),
                (width, blrx + brrx),
                (height, tlry + blry),
                (height, trry + brry),
            )
            if sum_radii > 0
        ])
        return (
            x, y, width, height,
            (tlrx * ratio, tlry * ratio),
            (trrx * ratio, trry * ratio),
            (brrx * ratio, brry * ratio),
            (blrx * ratio, blry * ratio))

    def rounded_box_ratio(self, ratio):
        return self.rounded_box(
            self.border_top_width * ratio,
            self.border_right_width * ratio,
            self.border_bottom_width * ratio,
            self.border_left_width * ratio)

    def rounded_padding_box(self):
        """Return the position, size and radii of the rounded padding box."""
        return self.rounded_box(
            self.border_top_width,
            self.border_right_width,
            self.border_bottom_width,
            self.border_left_width)

    def rounded_border_box(self):
        """Return the position, size and radii of the rounded border box."""
        return self.rounded_box(0, 0, 0, 0)

    def rounded_content_box(self):
        """Return the position, size and radii of the rounded content box."""
        return self.rounded_box(
            self.border_top_width + self.padding_top,
            self.border_right_width + self.padding_right,
            self.border_bottom_width + self.padding_bottom,
            self.border_left_width + self.padding_left)

    # Positioning schemes

    def is_floated(self):
        """Return whether this box is floated."""
        return self.style['float'] in ('left', 'right', 'inline-start', 'inline-end')

    def is_footnote(self):
        """Return whether this box is a footnote."""
        return self.style['float'] == 'footnote'

    def is_absolutely_positioned(self):
        """Return whether this box is in the absolute positioning scheme."""
        return self.style['position'] in ('absolute', 'fixed')

    def is_running(self):
        """Return whether this box is a running element."""
        return self.style['position'][0] == 'running()'

    def is_in_normal_flow(self):
        """Return whether this box is in normal flow."""
        return not (
            self.is_floated() or self.is_absolutely_positioned() or
            self.is_running() or self.is_footnote())

    def is_monolithic(self):
        """Return whether this box is monolithic."""
        # https://www.w3.org/TR/css-break-3/#monolithic
        return (
            isinstance(self, AtomicInlineLevelBox) or
            isinstance(self, ReplacedBox) or
            self.style['overflow'] in ('auto', 'scroll') or
            (self.style['overflow'] == 'hidden' and
             self.style['height'] != 'auto'))

    def establishes_formatting_context(self):
        """Return whether this box establishes a block formatting context."""
        # See https://www.w3.org/TR/CSS2/visuren.html#block-formatting
        return (
            self.is_floated() or
            self.is_absolutely_positioned() or
            self.is_column or
            (isinstance(self, BlockContainerBox) and not isinstance(self, BlockBox)) or
            (isinstance(self, BlockBox) and self.style['overflow'] != 'visible') or
            'flow-root' in self.style['display'])

    # Start and end page values for named pages

    def page_values(self):
        """Return start and end page values."""
        return (self.style['page'], self.style['page'])

    # PDF attachments

    def is_attachment(self):
        """Return whether this link should be stored as a PDF attachment."""
        from ..html import element_has_link_type

        if self.element is not None and self.element.tag == 'a':
            return element_has_link_type(self.element, 'attachment')
        return False

    # Forms

    def is_input(self):
        """Return whether this box is a form input."""
        # https://html.spec.whatwg.org/multipage/forms.html#category-submit
        if self.style['appearance'] == 'auto' and self.element is not None:
            if self.element.tag in ('button', 'input', 'select', 'textarea'):
                return not isinstance(self, (LineBox, TextBox))
        return False

    def is_form(self):
        """Return whether this box is a form element."""
        if self.element is None:
            return False
        return self.element.tag == 'form'


class ParentBox(Box):
    """A box that has children."""
    def __init__(self, element_tag, style, element, children):
        super().__init__(element_tag, style, element)
        self.children = tuple(children)

    def _reset_spacing(self, side):
        """Set to 0 the margin, padding and border of ``side``."""
        self.remove_decoration_sides.add(side)
        setattr(self, f'margin_{side}', 0)
        setattr(self, f'padding_{side}', 0)
        setattr(self, f'border_{side}_width', 0)

    def remove_decoration(self, start, end):
        if self.style['box_decoration_break'] == 'clone':
            return
        if start:
            self._reset_spacing('top')
        if end:
            self._reset_spacing('bottom')

    def copy_with_children(self, new_children):
        """Create a new equivalent box with given ``new_children``."""
        new_box = self.copy()
        new_box.children = new_children

        # Clear and reset removed decorations as we don't want to keep the
        # previous data, for example when a box is split between two pages.
        self.remove_decoration_sides = set()

        return new_box

    def deepcopy(self):
        result = self.copy()
        result.children = list(child.deepcopy() for child in self.children)
        return result

    def get_wrapped_table(self):
        """Get the table wrapped by the box."""
        assert self.is_table_wrapper
        for child in self.children:
            if isinstance(child, TableBox):
                return child
        else:  # pragma: no cover
            raise ValueError('Table wrapper without a table')

    def page_values(self):
        start_value, end_value = super().page_values()
        # TODO: We should find Class A possible page breaks according to
        # https://drafts.csswg.org/css-page-3/#propdef-page
        # Keep only children in normal flow for now.
        children = [
            child for child in self.children if child.is_in_normal_flow()]
        if children:
            if len(children) == 1:
                page_values = children[0].page_values()
                start_value = page_values[0] or start_value
                end_value = page_values[1] or end_value
            else:
                start_box, end_box = children[0], children[-1]
                start_value = start_box.page_values()[0] or start_value
                end_value = end_box.page_values()[1] or end_value
        return start_value, end_value

    def top_margin_collapses(self):
        return not (
            self.border_top_width or self.padding_top or
            self.is_flex_item or self.is_grid_item or
            self.establishes_formatting_context() or
            self.is_table_wrapper or
            self.is_for_root_element)

    def bottom_margin_collapses(self):
        return not (
            self.border_bottom_width or self.padding_bottom or
            self.is_flex_item or self.is_grid_item or
            self.establishes_formatting_context() or
            self.is_table_wrapper or
            self.is_for_root_element)


class BlockLevelBox(Box):
    """A box that participates in an block formatting context.

    An element with a ``display`` value of ``block``, ``list-item`` or
    ``table`` generates a block-level box.

    """
    clearance = None


class BlockContainerBox(ParentBox):
    """A box that contains only block-level boxes or only line boxes.

    A box that either contains only block-level boxes or establishes an inline
    formatting context and thus contains only line boxes.

    A non-replaced element with a ``display`` value of ``block``,
    ``list-item``, ``inline-block`` or 'table-cell' generates a block container
    box.

    """


class BlockBox(BlockContainerBox, BlockLevelBox):
    """A block-level box that is also a block container.

    A non-replaced element with a ``display`` value of ``block``, ``list-item``
    generates a block box.

    """


class LineBox(ParentBox):
    """A box that represents a line in an inline formatting context.

    Can only contain inline-level boxes.

    In early stages of building the box tree a single line box contains many
    consecutive inline boxes. Later, during layout phase, each line boxes will
    be split into multiple line boxes, one for each actual line.

    """
    text_overflow = 'clip'
    block_ellipsis = 'none'

    @classmethod
    def anonymous_from(cls, parent, *args, **kwargs):
        box = super().anonymous_from(parent, *args, **kwargs)
        if parent.style['overflow'] != 'visible':
            box.text_overflow = parent.style['text_overflow']
        return box


class InlineLevelBox(Box):
    """A box that participates in an inline formatting context.

    An inline-level box that is not an inline box is said to be "atomic". Such
    boxes are inline blocks, replaced elements and inline tables.

    An element with a ``display`` value of ``inline``, ``inline-table``, or
    ``inline-block`` generates an inline-level box.

    """
    def remove_decoration(self, start, end):
        if self.style['box_decoration_break'] == 'clone':
            return
        ltr = self.style['direction'] == 'ltr'
        if start:
            self._reset_spacing('left' if ltr else 'right')
        if end:
            self._reset_spacing('right' if ltr else 'left')


class InlineBox(InlineLevelBox, ParentBox):
    """An inline box with inline children.

    A box that participates in an inline formatting context and whose content
    also participates in that inline formatting context.

    A non-replaced element with a ``display`` value of ``inline`` generates an
    inline box.

    """
    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
        return (self.border_box_x(), self.position_y,
                self.border_width(), self.margin_height())


class TextBox(InlineLevelBox):
    """A box that contains only text and has no box children.

    Any text in the document ends up in a text box. What CSS calls "anonymous
    inline boxes" are also text boxes.

    """
    justification_spacing = 0

    def __init__(self, element_tag, style, element, text):
        assert text
        super().__init__(element_tag, style, element)
        self.text = text

    def copy_with_text(self, text):
        """Return a new TextBox identical to this one except for the text."""
        assert text
        new_box = self.copy()
        new_box.text = text
        return new_box


class AtomicInlineLevelBox(InlineLevelBox):
    """An atomic box in an inline formatting context.

    This inline-level box cannot be split for line breaks.

    """


class InlineBlockBox(AtomicInlineLevelBox, BlockContainerBox):
    """A box that is both inline-level and a block container.

    It behaves as inline on the outside and as a block on the inside.

    A non-replaced element with a 'display' value of 'inline-block' generates
    an inline-block box.

    """


class ReplacedBox(Box):
    """A box whose content is replaced.

    For example, ``<img>`` are replaced: their content is rendered externally
    and is opaque from CSS’s point of view.

    """
    def __init__(self, element_tag, style, element, replacement):
        super().__init__(element_tag, style, element)
        self.replacement = replacement


class BlockReplacedBox(ReplacedBox, BlockLevelBox):
    """A box that is both replaced and block-level.

    A replaced element with a ``display`` value of ``block``, ``liste-item`` or
    ``table`` generates a block-level replaced box.

    """


class InlineReplacedBox(ReplacedBox, AtomicInlineLevelBox):
    """A box that is both replaced and inline-level.

    A replaced element with a ``display`` value of ``inline``,
    ``inline-table``, or ``inline-block`` generates an inline-level replaced
    box.

    """


class TableBox(BlockLevelBox, ParentBox):
    """Box for elements with ``display: table``"""
    # Definitions for the rules generating anonymous table boxes
    # https://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
    tabular_container = True

    def all_children(self):
        return itertools.chain(self.children, self.column_groups)

    def translate(self, dx=0, dy=0, ignore_floats=False):
        self.column_positions = [
            position + dx for position in self.column_positions]
        return super().translate(dx, dy, ignore_floats)

    def page_values(self):
        return (self.style['page'], self.style['page'])


class InlineTableBox(TableBox):
    """Box for elements with ``display: inline-table``"""


class TableRowGroupBox(ParentBox):
    """Box for elements with ``display: table-row-group``"""
    proper_table_child = True
    internal_table_or_caption = True
    tabular_container = True
    proper_parents = (TableBox, InlineTableBox)

    # Default values. May be overriden on instances.
    is_header = False
    is_footer = False


class TableRowBox(ParentBox):
    """Box for elements with ``display: table-row``"""
    proper_table_child = True
    internal_table_or_caption = True
    tabular_container = True
    proper_parents = (TableBox, InlineTableBox, TableRowGroupBox)


class TableColumnGroupBox(ParentBox):
    """Box for elements with ``display: table-column-group``"""
    proper_table_child = True
    internal_table_or_caption = True
    proper_parents = (TableBox, InlineTableBox)

    # Columns groups never have margins or paddings
    margin_top = 0
    margin_bottom = 0
    margin_left = 0
    margin_right = 0

    padding_top = 0
    padding_bottom = 0
    padding_left = 0
    padding_right = 0

    def get_cells(self):
        """Return cells that originate in the group's columns."""
        return [
            cell for column in self.children for cell in column.get_cells()]

    @property
    def span(self):
        if self.children:
            return len(self.children)
        else:
            try:
                return max(int(self.element.get('span', '').strip()), 1)
            except ValueError:
                return 1


# Not really a parent box, but pretending to be removes some corner cases.
class TableColumnBox(ParentBox):
    """Box for elements with ``display: table-column``"""
    proper_table_child = True
    internal_table_or_caption = True
    proper_parents = (TableBox, InlineTableBox, TableColumnGroupBox)

    # Columns never have margins or paddings
    margin_top = 0
    margin_bottom = 0
    margin_left = 0
    margin_right = 0

    padding_top = 0
    padding_bottom = 0
    padding_left = 0
    padding_right = 0

    def get_cells(self):
        """Return cells that originate in the column.

        Is set on instances.

        """
        raise NotImplementedError

    @property
    def span(self):
        try:
            return max(int(self.element.get('span', '').strip()), 1)
        except ValueError:
            return 1


class TableCellBox(BlockContainerBox):
    """Box for elements with ``display: table-cell``"""
    internal_table_or_caption = True

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        # HTML 4.01 gives special meaning to colspan=0
        # https://www.w3.org/TR/html401/struct/tables.html#adef-rowspan
        # but HTML 5 removed it
        # https://html.spec.whatwg.org/multipage/tables.html#attr-tdth-colspan
        # rowspan=0 is still there though.
        try:
            self.colspan = max(int(self.element.get('colspan', '').strip()), 1)
        except (AttributeError, ValueError):
            self.colspan = 1
        try:
            self.rowspan = max(int(self.element.get('rowspan', '').strip()), 0)
        except (AttributeError, ValueError):
            self.rowspan = 1


class TableCaptionBox(BlockBox):
    """Box for elements with ``display: table-caption``"""
    proper_table_child = True
    internal_table_or_caption = True
    proper_parents = (TableBox, InlineTableBox)


class PageBox(ParentBox):
    """Box for a page.

    Initially the whole document will be in the box for the root element.
    During layout a new page box is created after every page break.

    """
    def __init__(self, page_type, style):
        self.page_type = page_type
        # Page boxes are not linked to any element.
        super().__init__(
            element_tag=None, style=style, element=None, children=[])

    def __repr__(self):
        return f'<{type(self).__name__} {self.page_type}>'

    @property
    def bleed(self):
        return {
            side: self.style[f'bleed_{side}'].value
            for side in ('top', 'right', 'bottom', 'left')}

    @property
    def bleed_area(self):
        return (
            -self.bleed['left'], -self.bleed['top'],
            self.margin_width() + self.bleed['left'] + self.bleed['right'],
            self.margin_height() + self.bleed['top'] + self.bleed['bottom'])


class MarginBox(BlockContainerBox):
    """Box in page margins, as defined in CSS3 Paged Media"""
    def __init__(self, at_keyword, style):
        self.at_keyword = at_keyword
        # Margin boxes are not linked to any element.
        super().__init__(
            element_tag=None, style=style, element=None, children=[])

    def __repr__(self):
        return f'<{type(self).__name__} {self.at_keyword}>'


class FootnoteAreaBox(BlockBox):
    """Box displaying footnotes, as defined in GCPM."""
    def __init__(self, page, style):
        self.page = page
        # Footnote area boxes are not linked to any element.
        super().__init__(
            element_tag=None, style=style, element=None, children=[])

    def __repr__(self):
        return f'<{type(self).__name__} @footnote>'


class FlexContainerBox(ParentBox):
    """A box that contains only flex-items."""


class FlexBox(FlexContainerBox, BlockLevelBox):
    """A box that is both block-level and a flex container.

    It behaves as block on the outside and as a flex container on the inside.

    """


class InlineFlexBox(FlexContainerBox, InlineLevelBox):
    """A box that is both inline-level and a flex container.

    It behaves as inline on the outside and as a flex container on the inside.

    """


class GridContainerBox(ParentBox):
    """A box that contains only grid-items."""
    def __init__(self, element_tag, style, element, children):
        super().__init__(element_tag, style, element, children)
        # TODO: we shouldn’t store this in the box but in the rendering context instead.
        self.advancements = {}


class GridBox(GridContainerBox, BlockLevelBox):
    """A box that is both block-level and a grid container.

    It behaves as block on the outside and as a grid container on the inside.

    """


class InlineGridBox(GridContainerBox, InlineLevelBox):
    """A box that is both inline-level and a grid container.

    It behaves as inline on the outside and as a grid container on the inside.

    """


================================================
FILE: weasyprint/formatting_structure/build.py
================================================
"""Turn an element tree with style into a "before layout" box tree.

This includes creating anonymous boxes and processing whitespace as necessary.

"""

import re
import unicodedata

from .. import html
from ..css import properties, targets
from ..layout.table import collapse_table_borders
from ..logger import LOGGER
from ..text.constants import get_lang_quotes
from . import boxes

# Maps values of the ``display`` CSS property to box types.
BOX_TYPE_FROM_DISPLAY = {
    ('block', 'flow'): boxes.BlockBox,
    ('inline', 'flow'): boxes.InlineBox,

    ('block', 'flow-root'): boxes.BlockBox,
    ('inline', 'flow-root'): boxes.InlineBlockBox,

    ('block', 'table'): boxes.TableBox,
    ('inline', 'table'): boxes.InlineTableBox,

    ('block', 'flex'): boxes.FlexBox,
    ('inline', 'flex'): boxes.InlineFlexBox,

    ('block', 'grid'): boxes.GridBox,
    ('inline', 'grid'): boxes.InlineGridBox,

    ('table-row',): boxes.TableRowBox,
    ('table-row-group',): boxes.TableRowGroupBox,
    ('table-header-group',): boxes.TableRowGroupBox,
    ('table-footer-group',): boxes.TableRowGroupBox,
    ('table-column',): boxes.TableColumnBox,
    ('table-column-group',): boxes.TableColumnGroupBox,
    ('table-cell',): boxes.TableCellBox,
    ('table-caption',): boxes.TableCaptionBox,
}

# https://stackoverflow.com/questions/16317534/
ASCII_TO_WIDE = {i: chr(i + 0xfee0) for i in range(0x21, 0x7f)}
ASCII_TO_WIDE.update({0x20: '\u3000', 0x2D: '\u2212'})

LINE_FEED_RE = re.compile('\r\n?')
TAB_RE = re.compile('[\t ]*\n[\t ]*')
SPACE_RE = re.compile('[\t ]+')


def create_anonymous_boxes(box):
    """Create anonymous boxes in box descendants according to layout rules."""
    box = anonymous_table_boxes(box)
    box = flex_boxes(box)
    box = grid_boxes(box)
    box = inline_in_block(box)
    box = block_in_inline(box)
    return box


def build_formatting_structure(element_tree, style_for, get_image_from_uri,
                               base_url, target_collector, counter_style,
                               footnotes):
    """Build a formatting structure (box tree) from an element tree."""
    box_list = element_to_box(
        element_tree, style_for, get_image_from_uri, base_url,
        target_collector, counter_style, footnotes)
    if box_list:
        box, = box_list
    else:
        # No root element
        def root_style_for(element, pseudo_type=None):
            style = style_for(element, pseudo_type)
            if style is not None:
                if element == element_tree:
                    style['display'] = ('block', 'flow')
                else:
                    style['display'] = ('none',)
            return style
        box, = element_to_box(
            element_tree, root_style_for, get_image_from_uri, base_url,
            target_collector, counter_style, footnotes)

    target_collector.check_pending_targets()
    process_whitespace(box)
    process_text_transform(box)

    box.is_for_root_element = True
    # If this is changed, maybe update weasy.layout.page.make_margin_boxes()
    box = create_anonymous_boxes(box)
    box = set_viewport_overflow(box)
    return box


def make_box(element_tag, style, content, element):
    return BOX_TYPE_FROM_DISPLAY[style['display'][:2]](
        element_tag, style, element, content)


def element_to_box(element, style_for, get_image_from_uri, base_url,
                   target_collector, counter_style, footnotes, state=None):
    """Convert an element and its children into a box with children.

    Return a list of boxes. Most of the time the list will have one item but
    may have zero or more than one.

    Eg.::

        <p>Some <em>emphasised</em> text.</p>

    gives (not actual syntax)::

        BlockBox[
            TextBox['Some '],
            InlineBox[
                TextBox['emphasised'],
            ],
            TextBox[' text.'],
        ]

    ``TextBox``es are anonymous inline boxes:
    See https://www.w3.org/TR/CSS21/visuren.html#anonymous

    """
    if not isinstance(element.tag, str):
        # We ignore comments and XML processing instructions.
        return []

    style = style_for(element)

    # TODO: should be the used value. When does the used value for `display`
    # differ from the computer value?
    display = style['display']
    if display == ('none',):
        return []

    if style['float'] == 'footnote':
        if style['footnote_display'] == 'block':
            style['display'] = ('block', 'flow')
        else:
            # TODO: handle compact footnotes
            style['display'] = ('inline', 'flow')

    box = make_box(element.tag, style, [], element)
    box.first_letter_style = style_for(element, 'first-letter')
    box.first_line_style = style_for(element, 'first-line')

    if state is None:
        # use a list to have a shared mutable object
        state = (
            # Shared mutable objects:
            [0],  # quote_depth: single integer
            # TODO: define the footnote counter where it can be updated by page
            {'footnote': [0]},  # counter_values: name -> stacked/scoped values
            [{'footnote'}],  # counter_scopes: element depths -> counter names
            [] # page_groups
        )
    quote_depth, counter_values, counter_scopes, _page_groups = state

    update_counters(state, style)

    children = []

    # If this element’s direct children create new scopes, the counter
    # names will be in this new list
    counter_scopes.append(set())

    marker_boxes = []
    if 'list-item' in style['display']:
        marker_boxes = list(marker_to_box(
            element, state, style, style_for, get_image_from_uri,
            target_collector, counter_style))
        children.extend(marker_boxes)

    children.extend(before_after_to_box(
        element, 'before', state, style_for, get_image_from_uri,
        target_collector, counter_style))

    # collect anchor's counter_values, maybe it's a target.
    # to get the spec-conform counter_values we must do it here,
    # after the ::before is parsed and before the ::after is
    if style['anchor']:
        target_collector.store_target(style['anchor'], counter_values, box)

    text = element.text
    if text:
        children.append(boxes.TextBox.anonymous_from(box, text))

    for child_element in element:
        child_boxes = element_to_box(
            child_element, style_for, get_image_from_uri, base_url,
            target_collector, counter_style, footnotes, state)

        if child_boxes and child_boxes[0].style['float'] == 'footnote':
            footnote = child_boxes[0]
            footnote.style['float'] = 'none'
            footnotes.append(footnote)
            call_style = style_for(footnote.element, 'footnote-call')
            footnote_call = make_box(
                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)
            footnote_call.footnote = footnote
            child_boxes = [footnote_call]

        children.extend(child_boxes)
        text = child_element.tail
        if text:
            text_box = boxes.TextBox.anonymous_from(box, text)
            if children and isinstance(children[-1], boxes.TextBox):
                children[-1].text += text_box.text
            else:
                children.append(text_box)

    children.extend(before_after_to_box(
        element, 'after', state, style_for, get_image_from_uri,
        target_collector, counter_style))

    # Scopes created by this element’s children stop here.
    for name in counter_scopes.pop():
        counter_values[name].pop()
        if not counter_values[name]:
            counter_values.pop(name)

    box.children = children
    set_content_lists(
        element, box, style, counter_values, target_collector, counter_style)

    if marker_boxes and len(box.children) == 1:
        # See https://www.w3.org/TR/css-lists-3/#list-style-position-outside
        #
        # "The size or contents of the marker box may affect the height of the
        #  principal block box and/or the height of its first line box, and in
        #  some cases may cause the creation of a new line box; this
        #  interaction is also not defined."
        #
        # We decide here to add a zero-width space to have a minimum
        # height. Adding text boxes is not the best idea, but it's not a good
        # moment to add an empty line box, and the specification lets us do
        # almost what we want, so…
        if style['list_style_position'] == 'outside':
            box.children.append(boxes.TextBox.anonymous_from(box, '​'))

    if style['float'] == 'footnote':
        counter_values['footnote'][-1] += 1
        marker_style = style_for(element, 'footnote-marker')
        marker = make_box(
            f'{element.tag}::footnote-marker', marker_style, [], element)
        marker.children = content_to_boxes(
            marker_style, marker, quote_depth, counter_values, get_image_from_uri,
            target_collector, counter_style)
        box.children.insert(0, marker)

    # Specific handling for the element. (eg. replaced element)
    return html.handle_element(element, box, get_image_from_uri, base_url)


def before_after_to_box(element, pseudo_type, state, style_for,
                        get_image_from_uri, target_collector, counter_style):
    """Return the boxes for ::before or ::after pseudo-element."""
    style = style_for(element, pseudo_type)
    if pseudo_type and style is None:
        # Pseudo-elements with no style at all do not get a style dict.
        # Their initial content property computes to 'none'.
        return []

    # TODO: should be the computed value. When does the used value for
    # `display` differ from the computer value? It's at least wrong for
    # `content` where 'normal' computes as 'inhibit' for pseudo elements.
    display = style['display']
    if display == ('none',):
        return []
    content = style['content']
    if content in ('normal', 'inhibit', 'none'):
        return []
    box = make_box(f'{element.tag}::{pseudo_type}', style, [], element)

    quote_depth, counter_values, _counter_scopes, _page_groups = state
    update_counters(state, style)

    children = []

    if 'list-item' in display:
        marker_boxes = list(marker_to_box(
            element, state, style, style_for, get_image_from_uri,
            target_collector, counter_style))
        children.extend(marker_boxes)

    children.extend(content_to_boxes(
        style, box, quote_depth, counter_values, get_image_from_uri,
        target_collector, counter_style))

    box.children = children

    # calculate the bookmark-label
    if style['bookmark_level'] != 'none':
        _quote_depth, counter_values, _counter_scopes, _page_groups = state
        compute_bookmark_label(
            element, box, style['bookmark_label'], counter_values,
            target_collector, counter_style)
    return [box]


def marker_to_box(element, state, parent_style, style_for, get_image_from_uri,
                  target_collector, counter_style):
    """Yield the box for ::marker pseudo-element if there is one.

    https://drafts.csswg.org/css-lists-3/#marker-pseudo

    """
    style = style_for(element, 'marker')

    children = []

    # TODO: should be the computed value. When does the used value for
    # `display` differ from the computer value? It's at least wrong for
    # `content` where 'normal' computes as 'inhibit' for pseudo elements.
    quote_depth, counter_values, _counter_scopes, _page_groups = state

    box = make_box(f'{element.tag}::marker', style, children, element)

    if style['display'] == ('none',):
        return

    image_type, image = style['list_style_image']

    if style['content'] not in ('normal', 'inhibit'):
        children.extend(content_to_boxes(
            style, box, quote_depth, counter_values, get_image_from_uri,
            target_collector, counter_style))

    else:
        if image_type == 'url':
            # image may be None here too, in case the image is not available.
            image = get_image_from_uri(
                url=image, orientation=style['image_orientation'])
            if image is not None:
                box = boxes.InlineReplacedBox.anonymous_from(box, image)
                children.append(box)

        if not children and style['list_style_type'] != 'none':
            counter_value = counter_values.get('list-item', [0])[-1]
            counter_type = style['list_style_type']
            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'
                children.append(box)

    if not children:
        return

    if parent_style['list_style_position'] == 'outside':
        marker_box = boxes.BlockBox.anonymous_from(box, children)
        # 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'
        marker_box.is_outside_marker = True
    else:
        marker_box = boxes.InlineBox.anonymous_from(box, children)
    yield marker_box


def compute_content_list(content_list, parent_box, counter_values, css_token,
                         parse_again, target_collector, counter_style,
                         get_image_from_uri=None, quote_depth=None,
                         quote_style=None, lang=None, context=None, page=None,
                         element=None):
    """Compute and return the boxes corresponding to the ``content_list``.

    ``parse_again`` is called to compute the ``content_list`` again when
    ``target_collector.lookup_target()`` detected a pending target.

    ``build_formatting_structure`` calls
    ``target_collector.check_pending_targets()`` after the first pass to do
    required reparsing.

    """
    # TODO: Some computation done here may be done in computed_values
    # instead. We currently miss at least style_for, counters and quotes
    # context in computer. Some work will still need to be done here though,
    # like box creation for URIs.

    content_boxes = []
    has_text = set()  # Use a set because variable is modified in add_text

    def add_text(text):
        has_text.add(True)
        if text:
            if content_boxes and isinstance(content_boxes[-1], boxes.TextBox):
                content_boxes[-1].text += text
            else:
                content_boxes.append(
                    boxes.TextBox.anonymous_from(parent_box, text))

    missing_counters = []
    missing_target_counters = {}
    in_page_context = context is not None and page is not None

    # Collect missing counters during build_formatting_structure.
    # Pointless to collect missing target counters in MarginBoxes.
    need_collect_missing = target_collector.collecting and not in_page_context

    if parent_box.cached_counter_values is None:
        # Store the counter_values in the parent_box to make them accessible
        # in @page context.
        parent_box.cached_counter_values = {
            key: value.copy() for key, value in counter_values.items()}
    for type_, value in content_list:
        if type_ == 'string':
            add_text(value)
        elif type_ == 'url' and get_image_from_uri is not None:
            origin, uri = value
            if origin != 'external':
                # Embedding internal references is impossible.
                continue
            image = get_image_from_uri(
                url=uri, orientation=parent_box.style['image_orientation'])
            if image is not None:
                content_boxes.append(
                    boxes.InlineReplacedBox.anonymous_from(parent_box, image))
        elif type_ == 'content()':
            added_text = extract_text(value, parent_box)
            add_text(added_text)
        elif type_ == 'string()':
            if not in_page_context:
                # string() is currently only valid in @page context.
                # See issue #723.
                LOGGER.warning(
                    '"string(%s)" is only allowed in page margins',
                    ' '.join(value))
                continue
            add_text(context.get_string_set_for(page, *value))
        elif type_ in ('counter()', 'counters()'):
            counter_name, counter_type = value[0], value[-1]
            if counter_type == 'none':
                continue
            if need_collect_missing:
                if counter_name not in list(counter_values) + missing_counters:
                    missing_counters.append(counter_name)
            if type_ == 'counter()':
                counter_value = counter_values.get(counter_name, [0])[-1]
                text = counter_style.render_value(counter_value, counter_type)
            else:
                separator = value[1]
                text = separator.join(
                    counter_style.render_value(counter_value, counter_type)
                    for counter_value in counter_values.get(counter_name, [0]))
            add_text(text)
        elif type_ in ('target-counter()', 'target-counters()'):
            (anchor_token, counter_name), counter_type = value[:2], value[-1]
            if counter_type == 'none':
                continue
            lookup_target = target_collector.lookup_target(
                anchor_token, parent_box, css_token, parse_again)
            if lookup_target.state != 'up-to-date':
                break
            target_values = lookup_target.target_box.cached_counter_values
            if need_collect_missing and counter_name not in target_values:
                anchor_name = targets.anchor_name_from_token(anchor_token)
                missing_counters = missing_target_counters.setdefault(
                    anchor_name, [])
                if counter_name not in missing_counters:
                    missing_counters.append(counter_name)
            # Mixin target's cached page counters.
            # cached_page_counter_values are empty during layout.
            local_counters = lookup_target.cached_page_counter_values.copy()
            local_counters.update(target_values)
            if type_ == 'target-counter()':
                counter_value = local_counters.get(counter_name, [0])[-1]
                text = counter_style.render_value(counter_value, counter_type)
            else:
                separator = value[2]
                if separator[0] != 'string':
                    break
                separator_string = separator[1]
                text = separator_string.join(
                    counter_style.render_value(counter_value, counter_type)
                    for counter_value in local_counters.get(counter_name, [0]))
            add_text(text)
        elif type_ == 'target-text()':
            anchor_token, text_style = value
            lookup_target = target_collector.lookup_target(
                anchor_token, parent_box, css_token, parse_again)
            if lookup_target.state == 'up-to-date':
                target_box = lookup_target.target_box
                # TODO: 'before'- and 'after'- content referring missing
                # counters are not properly set.
                text = extract_text(text_style, target_box)
                add_text(text)
            else:
                break
        elif type_ == 'quote' and None not in (quote_depth, quote_style):
            is_open = 'open' in value
            insert = not value.startswith('no-') and quote_style != 'none'
            if not is_open:
                quote_depth[0] = max(0, quote_depth[0] - 1)
            if insert:
                if quote_style == 'auto':
                    open_quotes, close_quotes = get_lang_quotes(lang)
                else:
                    open_quotes, close_quotes = quote_style
                quotes = open_quotes if is_open else close_quotes
                add_text(quotes[min(quote_depth[0], len(quotes) - 1)])
            if is_open:
                quote_depth[0] += 1
        elif type_ == 'element()':
            if not in_page_context:
                LOGGER.warning(
                    '"element(%s)" is only allowed in page margins',
                    ' '.join(value))
                continue
            new_box = context.get_running_element_for(page, *value)
            if new_box is None:
                continue
            new_box = new_box.deepcopy()
            new_box.style['position'] = 'static'
            if isinstance(new_box, boxes.ParentBox):
                for child in new_box.descendants():
                    if child.style['content'] in ('normal', 'none'):
                        continue
                    child.children = content_to_boxes(
                        child.style, child, quote_depth, counter_values,
                        get_image_from_uri, target_collector, counter_style,
                        context=context, page=page)
            content_boxes.append(new_box)
        elif type_ == 'leader()':
            if not value[1]:
                continue
            text_box = boxes.TextBox.anonymous_from(parent_box, value[1])
            leader_box = boxes.InlineBox.anonymous_from(
                parent_box, (text_box,))
            # Avoid breaks inside the leader box
            leader_box.style['white_space'] = 'pre'
            # Prevent whitespaces from being removed from the text box
            text_box.style['white_space'] = 'pre'
            leader_box.is_leader = True
            content_boxes.append(leader_box)

    if has_text or content_boxes:
        # Only add CounterLookupItem if the content_list actually produced text
        target_collector.collect_missing_counters(
            parent_box, css_token, parse_again, missing_counters,
            missing_target_counters)
        return content_boxes


def content_to_boxes(style, parent_box, quote_depth, counter_values,
                     get_image_from_uri, target_collector, counter_style,
                     context=None, page=None):
    """Take the value of a ``content`` property and return boxes."""
    def parse_again(mixin_pagebased_counters=None):
        """Closure to parse the ``parent_boxes`` children all again."""

        # Neither alters the mixed-in nor the cached counter values, no
        # need to deepcopy here
        if mixin_pagebased_counters is None:
            local_counters = {}
        else:
            local_counters = mixin_pagebased_counters.copy()
        local_counters.update(parent_box.cached_counter_values)

        local_children = []
        local_children.extend(content_to_boxes(
            style, parent_box, orig_quote_depth, local_counters,
            get_image_from_uri, target_collector, counter_style))

        # TODO: do we need to add markers here?
        # TODO: redo the formatting structure of the parent instead of hacking
        # the already formatted structure. Find why inline_in_blocks has
        # sometimes already been called, and sometimes not.
        if (len(parent_box.children) == 1 and
                isinstance(parent_box.children[0], boxes.LineBox)):
            parent_box.children[0].children = local_children
        else:
            parent_box.children = local_children

    if style['content'] == 'inhibit':
        return []

    orig_quote_depth = quote_depth[:]
    css_token = 'content'
    box_list = compute_content_list(
        style['content'], parent_box, counter_values, css_token, parse_again,
        target_collector, counter_style, get_image_from_uri, quote_depth,
        style['quotes'], style['lang'], context, page)
    return box_list or []


def compute_string_set(element, box, string_name, content_list,
                       counter_values, target_collector, counter_style):
    """Parse the content-list value of ``string_name`` for ``string-set``."""
    def parse_again(mixin_pagebased_counters=None):
        """Closure to parse the string-set string value all again."""
        # Neither alters the mixed-in nor the cached counter values, no
        # need to deepcopy here
        if mixin_pagebased_counters is None:
            local_counters = {}
        else:
            local_counters = mixin_pagebased_counters.copy()
        local_counters.update(box.cached_counter_values)
        compute_string_set(
            element, box, string_name, content_list, local_counters,
            target_collector, counter_style)

    css_token = f'string-set::{string_name}'
    box_list = compute_content_list(
        content_list, box, counter_values, css_token, parse_again,
        target_collector, counter_style, element=element)
    if box_list is not None:
        string = ''.join(
            box.text for box in box_list if isinstance(box, boxes.TextBox))
        # Avoid duplicates, care for parse_again and missing counters, don't
        # change the pointer
        for string_set_tuple in box.string_set:
            if string_set_tuple[0] == string_name:
                box.string_set.remove(string_set_tuple)
                break
        box.string_set.append((string_name, string))


def compute_bookmark_label(element, box, content_list, counter_values,
                           target_collector, counter_style):
    """Parses the content-list value for ``bookmark-label``."""
    def parse_again(mixin_pagebased_counters=None):
        """Closure to parse the bookmark-label all again."""
        # Neither alters the mixed-in nor the cached counter values, no
        # need to deepcopy here
        if mixin_pagebased_counters is None:
            local_counters = {}
        else:
            local_counters = mixin_pagebased_counters.copy()
        local_counters.update(box.cached_counter_values)
        compute_bookmark_label(
            element, box, content_list, local_counters, target_collector,
            counter_style)

    css_token = 'bookmark-label'
    box_list = compute_content_list(
        content_list, box, counter_values, css_token, parse_again,
        target_collector, counter_style, element=element)
    if box_list:
        box.bookmark_label = ''.join(box_text(box) for box in box_list)


def set_content_lists(element, box, style, counter_values, target_collector,
                      counter_style):
    """Set the content-lists values.

    These content-lists are used in GCPM properties like ``string-set`` and
    ``bookmark-label``.

    """
    box.string_set = []
    if style['string_set'] != 'none':
        for string_name, string_values in style['string_set']:
            compute_string_set(
                element, box, string_name, string_values, counter_values,
                target_collector, counter_style)
    if style['bookmark_level'] != 'none':
        compute_bookmark_label(
            element, box, style['bookmark_label'], counter_values,
            target_collector, counter_style)


def update_counters(state, style):
    """Handle the ``counter-*`` properties."""
    _quote_depth, counter_values, counter_scopes, _page_groups = state
    sibling_scopes = counter_scopes[-1]

    for name, value in style['counter_reset']:
        if name in sibling_scopes:
            counter_values[name].pop()
        else:
            sibling_scopes.add(name)
        counter_values.setdefault(name, []).append(value)

    for name, value in style['counter_set']:
        values = counter_values.setdefault(name, [])
        if not values:
            assert name not in sibling_scopes
            sibling_scopes.add(name)
            values.append(0)
        values[-1] = value

    counter_increment = style['counter_increment']
    if counter_increment == 'auto':
        # 'auto' is the initial value but is not valid in stylesheet:
        # there was no counter-increment declaration for this element.
        # (Or the winning value was 'initial'.)
        # https://drafts.csswg.org/css-lists-3/#declaring-a-list-item
        if 'list-item' in style['display']:
            counter_increment = [('list-item', 1)]
        else:
            counter_increment = []
    for name, value in counter_increment:
        values = counter_values.setdefault(name, [])
        if not values:
            assert name not in sibling_scopes
            sibling_scopes.add(name)
            values.append(0)
        values[-1] += value


def is_whitespace(box, _has_non_whitespace=re.compile('\\S').search):
    """Return True if ``box`` is a TextBox with only whitespace."""
    return isinstance(box, boxes.TextBox) and not _has_non_whitespace(box.text)


def wrap_improper(box, children, wrapper_type, test=None):
    """Wrap consecutive children that do not pass ``test`` in a ``wrapper_type`` box.

    ``test`` defaults to children being of the same type as ``wrapper_type``.

    """
    if test is None:
        def test(child):
            return isinstance(child, wrapper_type)
    improper = []
    for child in children:
        if test(child):
            if improper:
                wrapper = wrapper_type.anonymous_from(box, children=[])
                # Apply the rules again on the new wrapper
                yield table_boxes_children(wrapper, improper)
                improper = []
            yield child
        else:
            improper.append(child)
    if improper:
        wrapper = wrapper_type.anonymous_from(box, children=[])
        # Apply the rules again on the new wrapper
        yield table_boxes_children(wrapper, improper)


def anonymous_table_boxes(box):
    """Remove and add boxes according to the table model.

    Take and return a ``Box`` object.

    See https://www.w3.org/TR/CSS21/tables.html#anonymous-boxes

    """
    if not isinstance(box, boxes.ParentBox) or box.is_running():
        return box

    # Do recursion.
    children = [anonymous_table_boxes(child) for child in box.children]
    return table_boxes_children(box, children)


def table_boxes_children(box, children):
    """Internal implementation of anonymous_table_boxes()."""
    if isinstance(box, boxes.TableColumnBox):  # rule 1.1
        # Remove all children.
        children = []
    elif isinstance(box, boxes.TableColumnGroupBox):  # rule 1.2
        # Remove children other than table-column.
        children = [
            child for child in children
            if isinstance(child, boxes.TableColumnBox)
        ]
        # Rule XXX (not in the spec): column groups have at least
        # one column child.
        if not children:
            if box.span is None or box.span < 1:
                span = 1
            else:
                span = box.span
            children = [boxes.TableColumnBox.anonymous_from(box, [])
                        for _ in range(span)]

    # rule 1.3
    if box.tabular_container and len(children) >= 2:
        # TODO: Maybe only remove text if internal is also
        #       a proper table descendant of box.
        # This is what the spec says, but maybe not what browsers do:
        # https://lists.w3.org/Archives/Public/www-style/2011Oct/0567

        # Last child
        internal, text = children[-2:]
        if (internal.internal_table_or_caption and is_whitespace(text)):
            children.pop()

        # First child
        if len(children) >= 2:
            text, internal = children[:2]
            if (internal.internal_table_or_caption and is_whitespace(text)):
                children.pop(0)

        # Children other than first and last that would be removed by
        # rule 1.3 are also removed by rule 1.4 below.

    children = [
        child
        for prev_child, child, next_child in zip(
            [None, *children[:-1]],
            children,
            [*children[1:], None]
        )
        if not (
            # Ignore some whitespace: rule 1.4
            prev_child and prev_child.internal_table_or_caption and
            next_child and next_child.internal_table_or_caption and
            is_whitespace(child)
        )
    ]

    if isinstance(box, boxes.TableBox):
        # Rule 2.1
        children = wrap_improper(
            box, children, boxes.TableRowBox,
            lambda child: child.proper_table_child)
    elif isinstance(box, boxes.TableRowGroupBox):
        # Rule 2.2
        children = wrap_improper(box, children, boxes.TableRowBox)

    if isinstance(box, boxes.TableRowBox):
        # Rule 2.3
        children = wrap_improper(box, children, boxes.TableCellBox)
    else:
        # Rule 3.1
        children = wrap_improper(
            box, children, boxes.TableRowBox,
            lambda child: not isinstance(child, boxes.TableCellBox))

    # Rule 3.2
    if isinstance(box, boxes.InlineBox):
        children = wrap_improper(
            box, children, boxes.InlineTableBox,
            lambda child: not child.proper_table_child)
    else:
        parent_type = type(box)
        children = wrap_improper(
            box, children, boxes.TableBox,
            lambda child: (not child.proper_table_child or
                           parent_type in child.proper_parents))

    if isinstance(box, boxes.TableBox):
        return wrap_table(box, children)
    else:
        box.children = list(children)
        return box


def wrap_table(box, children):
    """Take a table box and return it in its table wrapper box.

    Also re-order children and assign grid positions to each column and cell.

    Because of colspan/rowspan works, grid_y is implicitly the index of a row,
    but grid_x is an explicit attribute on cells, columns and column group.

    https://www.w3.org/TR/CSS21/tables.html#model
    https://www.w3.org/TR/CSS21/tables.html#table-layout

    """
    # Group table children by type
    columns = []
    rows = []
    all_captions = []
    by_type = {
        boxes.TableColumnBox: columns,
        boxes.TableColumnGroupBox: columns,
        boxes.TableRowBox: rows,
        boxes.TableRowGroupBox: rows,
        boxes.TableCaptionBox: all_captions,
    }
    for child in children:
        by_type[type(child)].append(child)

    # Split top and bottom captions
    captions = {'top': [], 'bottom': []}
    for caption in all_captions:
        captions[caption.style['caption_side']].append(caption)

    # Assign X positions on the grid to column boxes
    column_groups = list(wrap_improper(
        box, columns, boxes.TableColumnGroupBox))
    grid_x = 0
    for group in column_groups:
        group.grid_x = grid_x
        if group.children:
            for column in group.children:
                # There's no need to take care of group's span, as "span=x"
                # already generates x TableColumnBox children
                column.grid_x = grid_x
                grid_x += 1
        else:
            grid_x += group.span
    grid_width = grid_x

    row_groups = wrap_improper(box, rows, boxes.TableRowGroupBox)
    # Extract the optional header and footer groups.
    body_row_groups = []
    header = None
    footer = None
    for group in row_groups:
        display = group.style['display']
        if display == ('table-header-group',) and header is None:
            group.is_header = True
            header = group
        elif display == ('table-footer-group',) and footer is None:
            group.is_footer = True
            footer = group
        else:
            body_row_groups.append(group)
    row_groups = (
        ([header] if header is not None else []) +
        body_row_groups +
        ([footer] if footer is not None else []))

    # Assign a (x,y) position in the grid to each cell.
    # rowspan can not extend beyond a row group, so each row group
    # is independent.
    # https://www.w3.org/TR/CSS21/tables.html#table-layout
    # Column 0 is on the left if direction is ltr, right if rtl.
    # This algorithm does not change.
    grid_height = 0
    for group in row_groups:
        # Indexes: row number in the group.
        # Values: set of cells already occupied by row-spanning cells.
        occupied_cells_by_row = [set() for row in group.children]
        for row in group.children:
            occupied_cells_in_this_row = occupied_cells_by_row.pop(0)
            # The list is now about rows after this one.
            grid_x = 0
            for cell in row.children:
                # Make sure that the first grid cell is free.
                while grid_x in occupied_cells_in_this_row:
                    grid_x += 1
                cell.grid_x = grid_x
                new_grid_x = grid_x + cell.colspan
                # https://www.w3.org/TR/html401/struct/tables.html#adef-rowspan
                if cell.rowspan != 1:
                    max_rowspan = len(occupied_cells_by_row) + 1
                    if cell.rowspan == 0:
                        # All rows until the end of the group
                        spanned_rows = occupied_cells_by_row
                        cell.rowspan = max_rowspan
                    else:
                        cell.rowspan = min(cell.rowspan, max_rowspan)
                        spanned_rows = occupied_cells_by_row[:cell.rowspan - 1]
                    spanned_columns = range(grid_x, new_grid_x)
                    for occupied_cells in spanned_rows:
                        occupied_cells.update(spanned_columns)
                grid_x = new_grid_x
                grid_width = max(grid_width, grid_x)
        grid_height += len(group.children)

    table = box.copy_with_children(row_groups)
    table.style = table.style.copy()
    table.column_groups = tuple(column_groups)
    if table.style['border_collapse'] == 'collapse':
        table.collapsed_border_grid = collapse_table_borders(
            table, grid_width, grid_height)

    if isinstance(box, boxes.InlineTableBox):
        wrapper_type = boxes.InlineBlockBox
    else:
        wrapper_type = boxes.BlockBox

    wrapper = wrapper_type.anonymous_from(
        box, captions['top'] + [table] + captions['bottom'])
    wrapper.style = wrapper.style.copy()
    wrapper.is_table_wrapper = True
    # Non-inherited properties of the table element apply to one
    # of the wrapper and the table. The other get the initial value.
    # TODO: put this in a method of the table object
    for name in properties.TABLE_WRAPPER_BOX_PROPERTIES:
        wrapper.style[name] = table.style[name]
        table.style[name] = properties.INITIAL_VALUES[name]

    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.

    Take and return a ``Box`` object.

    See https://www.w3.org/TR/css-flexbox-1/#flex-items

    """
    if not isinstance(box, boxes.ParentBox) or box.is_running():
        return box

    # Do recursion.
    children = [flex_boxes(child) for child in box.children]
    box.children = flex_children(box, children)
    return box


def flex_children(box, children):
    if isinstance(box, boxes.FlexContainerBox):
        flex_children = []
        for child in children:
            child.is_floated = lambda: False
            if child.is_in_normal_flow():
                child.is_flex_item = True
            if isinstance(child, boxes.TextBox) and not child.text.strip(' '):
                # TODO: ignore texts only containing "characters that can be
                # affected by the white-space property"
                # https://www.w3.org/TR/css-flexbox-1/#flex-items
                continue
            flex_children.append(blockify(child, 'flex'))
        return flex_children
    else:
        return children


def grid_boxes(box):
    """Remove and add boxes according to the grid model.

    Take and return a ``Box`` object.

    See https://drafts.csswg.org/css-grid-2/#grid-item

    """
    if not isinstance(box, boxes.ParentBox) or box.is_running():
        return box

    # Do recursion.
    children = [grid_boxes(child) for child in box.children]
    box.children = grid_children(box, children)
    return box


def grid_children(box, children):
    if isinstance(box, boxes.GridContainerBox):
        grid_children = []
        for child in children:
            if child.is_in_normal_flow():
                child.is_grid_item = True
            if isinstance(child, boxes.TextBox) and not child.text.strip(' '):
                # TODO: ignore texts only containing "characters that can be
                # affected by the white-space property"
                # https://drafts.csswg.org/css-grid-2/#grid-item
                continue
            grid_children.append(blockify(child, 'grid'))
        return grid_children
    else:
        return children


def process_whitespace(box, following_collapsible_space=False):
    """First part of "The 'white-space' processing model".

    See https://www.w3.org/TR/CSS21/text.html#white-space-model
    https://drafts.csswg.org/css-text-3/#white-space-rules

    """
    if isinstance(box, boxes.TextBox):
        text = box.text
        if not text:
            return following_collapsible_space

        # Normalize line feeds
        text = LINE_FEED_RE.sub('\n', text)

        new_line_collapse = box.style['white_space'] in ('normal', 'nowrap')
        space_collapse = box.style['white_space'] in (
            'normal', 'nowrap', 'pre-line')

        if space_collapse:
            # \r characters were removed/converted earlier
            text = TAB_RE.sub('\n', text)

        if new_line_collapse:
            # TODO: this should be language-specific
            # Could also replace with a zero width space character (U+200B),
            # or no character
            # CSS3: https://www.w3.org/TR/css-text-3/#overflow-wrap
            text = text.replace('\n', ' ')

        if space_collapse:
            previous_text = text = SPACE_RE.sub(' ', text)
            if following_collapsible_space and text.startswith(' '):
                text = text[1:]
                box.leading_collapsible_space = True
            following_collapsible_space = previous_text.endswith(' ')
        else:
            following_collapsible_space = False

        box.text = text

    else:
        for child in box.children:
            child_collapsible_space = process_whitespace(
                child, following_collapsible_space)
            if isinstance(child, (boxes.TextBox, boxes.InlineBox)):
                following_collapsible_space = child_collapsible_space
            elif child.is_in_normal_flow():
                following_collapsible_space = False

    return following_collapsible_space


def process_text_transform(box):
    # Rules defined in
    # https://www.unicode.org/versions/latest/core-spec/chapter-3/#G33992
    # https://www.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
    # https://w3c.github.io/i18n-tests/results/text-transform
    # Common transformations should be handled by common algorithm in Python, special
    # casing and tailoring shoud be done here when it depends on the language and not on
    # only on the glyphs.
    if isinstance(box, boxes.TextBox):
        text_transform = box.style['text_transform']
        lang_code = (box.style['lang'] or '').split('-')[0].lower()
        if text_transform != 'none':
            box.text = {
                'uppercase': uppercase,
                'lowercase': lowercase,
                'capitalize': capitalize,
                'full-width': lambda text, lang_code: text.translate(ASCII_TO_WIDE),
            }[text_transform](box.text, lang_code)
        if box.style['hyphens'] == 'none':
            box.text = box.text.replace('\u00AD', '')  # U+00AD is soft hyphen

    elif not box.is_running():
        for child in box.children:
            process_text_transform(child)

def uppercase(text, lang_code):
    mapper = {}

    if lang_code == 'el':
        # https://w3c.github.io/i18n-tests/css-text/text-transform/
        #   text-transform-tailoring-003.html
        # https://en.wikiversity.org/wiki/Greek_Language/Diphthongs
        mapper = {
            'άι': 'ΑΪ',
            'άυ': 'ΑΫ',
            'όι': 'ΟΪ',
            'όυ': 'ΟΫ',
            'έυ': 'ΗΫ',
        }
    elif lang_code in ('tr', 'az'):
        # https://github.com/unicode-org/cldr/blob/main/common/transforms/tr-Upper.xml
        mapper = {
            'i': 'İ',
        }

    for key, value in mapper.items():
        text = text.replace(key, value)

    if lang_code == 'el':
        # Remove diacritics in Greek.
        # https://github.com/unicode-org/cldr/blob/main/common/transforms/el-Upper.xml
        # TODO: we should keep tonos on disjunctive eta.
        # https://w3c.github.io/i18n-tests/css-text/text-transform/
        #   text-transform-tailoring-005.html
        text = unicodedata.normalize('NFD', text)
        for char in '\u0313\u0314\u0301\u0300\u0306\u0342\u0304\u0345':
            text = text.replace(char, '')
        text = unicodedata.normalize('NFC', text)

    return text.upper()


def lowercase(text, lang_code):
    mapper = {}

    if lang_code in ('tr', 'az'):
        # https://github.com/unicode-org/cldr/blob/main/common/transforms/tr-Lower.xml
        mapper = {
            'I': 'ı',
            'İ': 'i',
        }
    elif lang_code == 'lt':
        # https://github.com/unicode-org/cldr/blob/main/common/transforms/lt-Lower.xml
        mapper = {
            'Ì': 'i̇̀',
            'Í': 'i̇́',
            'Ĩ': 'i̇̃',
        }

    for key, value in mapper.items():
        text = text.replace(key, value)

    return text.lower()


def capitalize(text, lang_code):
    """Capitalize words according to CSS’s "text-transform: capitalize"."""
    letter_found = False
    skip_next_letter = False
    output = ''
    for i, letter in enumerate(text):
        if skip_next_letter:
            skip_next_letter = False
            continue
        category = unicodedata.category(letter)[0]
        if not letter_found and category in ('L', 'N'):
            letter_found = True
            if lang_code == 'nl' and text[i:i+2] == 'ij':
                skip_next_letter = True
                letter = 'IJ'
            elif lang_code in ('tr', 'az'):
                letter = uppercase(letter, lang_code)
            else:
                letter = letter.upper()
        elif category == 'Z':
            letter_found = False
        output += letter
    return output


def inline_in_block(box):
    """Build the structure of lines inside blocks and return a new box tree.

    Consecutive inline-level boxes in a block container box are wrapped into a
    line box, itself wrapped into an anonymous block box.

    This line box will be broken into multiple lines later.

    This is the first case in
    https://www.w3.org/TR/CSS21/visuren.html#anonymous-block-level

    Eg.::

        BlockBox[
            TextBox['Some '],
            InlineBox[TextBox['text']],
            BlockBox[
                TextBox['More text'],
            ]
        ]

    is turned into::

        BlockBox[
            AnonymousBlockBox[
                LineBox[
                    TextBox['Some '],
                    InlineBox[TextBox['text']],
                ]
            ]
            BlockBox[
                LineBox[
                    TextBox['More text'],
                ]
            ]
        ]

    """
    if not box.children or box.is_running():
        return box

    box_children = list(box.children)

    if box_children and box.leading_collapsible_space is False:
        box.leading_collapsible_space = (
            box_children[0].leading_collapsible_space)

    children = []
    trailing_collapsible_space = False
    for child in box_children:
        # Keep track of removed collapsing spaces for wrap opportunities, and
        # remove empty text boxes.
        # (They may have been emptied by process_whitespace().)

        if trailing_collapsible_space:
            child.leading_collapsible_space = True

        if isinstance(child, boxes.TextBox) and not child.text:
            trailing_collapsible_space = child.leading_collapsible_space
        else:
            trailing_collapsible_space = False
            children.append(inline_in_block(child))

    if box.trailing_collapsible_space is False:
        box.trailing_collapsible_space = trailing_collapsible_space

    if not isinstance(box, boxes.BlockContainerBox):
        box.children = children
        return box

    new_line_children = []
    new_children = []

    for child_box in children:
        assert not isinstance(child_box, boxes.LineBox)
        if new_line_children and child_box.is_absolutely_positioned():
            new_line_children.append(child_box)
        elif isinstance(child_box, boxes.InlineLevelBox) or (
                new_line_children and not child_box.is_in_normal_flow()):
            # Do not append white space at the start of a line:
            # It would be removed during layout.
            if new_line_children or not (
                    isinstance(child_box, boxes.TextBox) and
                    # Sequence of white-space was collapsed to a single
                    # space by process_whitespace().
                    child_box.text == ' ' and
                    child_box.style['white_space'] in (
                        'normal', 'nowrap', 'pre-line')):
                new_line_children.append(child_box)
        else:
            if new_line_children:
                # Inlines are consecutive no more: add this line box
                # and create a new one.
                line_box = boxes.LineBox.anonymous_from(box, new_line_children)
                anonymous = boxes.BlockBox.anonymous_from(box, [line_box])
                new_children.append(anonymous)
                new_line_children = []
            new_children.append(child_box)
    if new_line_children:
        # There were inlines at the end
        line_box = boxes.LineBox.anonymous_from(box, new_line_children)
        if new_children:
            anonymous = boxes.BlockBox.anonymous_from(box, [line_box])
            new_children.append(anonymous)
        else:
            # Only inline-level children: one line box
            new_children.append(line_box)

    box.children = new_children
    return box


def block_in_inline(box):
    """Build the structure of blocks inside lines.

    Inline boxes containing block-level boxes will be broken in two
    boxes on each side on consecutive block-level boxes, each side wrapped
    in an anonymous block-level box.

    This is the second case in
    https://www.w3.org/TR/CSS21/visuren.html#anonymous-block-level

    Eg. if this is given::

        BlockBox[
            LineBox[
                InlineBox[
                    TextBox['Hello.'],
                ],
                InlineBox[
                    TextBox['Some '],
                    InlineBox[
                        TextBox['text']
                        BlockBox[LineBox[TextBox['More text']]],
                        BlockBox[LineBox[TextBox['More text again']]],
                    ],
                    BlockBox[LineBox[TextBox['And again.']]],
                ]
            ]
        ]

    this is returned::

        BlockBox[
            AnonymousBlockBox[
                LineBox[
                    InlineBox[
                        TextBox['Hello.'],
                    ],
                    InlineBox[
                        TextBox['Some '],
                        InlineBox[TextBox['text']],
                    ]
                ]
            ],
            BlockBox[LineBox[TextBox['More text']]],
            BlockBox[LineBox[TextBox['More text again']]],
            AnonymousBlockBox[
                LineBox[
                    InlineBox[
                    ]
                ]
            ],
            BlockBox[LineBox[TextBox['And again.']]],
            AnonymousBlockBox[
                LineBox[
                    InlineBox[
                    ]
                ]
            ],
        ]

    """
    if not box.children or box.is_running():
        return box

    new_children = []
    changed = False

    for child in box.children:
        if isinstance(child, boxes.LineBox):
            assert len(box.children) == 1, (
                'Line boxes should have no '
                'siblings at this stage, got %r.' % box.children)
            stack = None
            while True:
                new_line, block, stack = _inner_block_in_inline(
                    child, skip_stack=stack)
                if block is None:
                    break
                anon = boxes.BlockBox.anonymous_from(box, [new_line])
                new_children.append(anon)
                new_children.append(block_in_inline(block))
                # Loop with the same child and the new stack.
            if new_children:
                # Some children were already added, this became a block
                # context.
                new_child = boxes.BlockBox.anonymous_from(box, [new_line])
            else:
                # Keep the single line box as-is, without anonymous blocks.
                new_child = new_line
        else:
            # Not in an inline formatting context.
            new_child = block_in_inline(child)

        if new_child is not child:
            changed = True
        new_children.append(new_child)

    if changed:
        box.children = new_children
    return box


def _inner_block_in_inline(box, skip_stack=None):
    """Find a block-level box in an inline formatting context.

    If one is found, return ``(new_box, block_level_box, resume_at)``.
    ``new_box`` contains all of ``box`` content before the block-level box.
    ``resume_at`` can be passed as ``skip_stack`` in a new call to
    this function to resume the search just after the block-level box.

    If no block-level box is found after the position marked by
    ``skip_stack``, return ``(new_box, None, None)``

    """
    new_children = []
    block_level_box = None
    resume_at = None
    changed = False

    is_start = skip_stack is None
    if is_start:
        skip = 0
    else:
        (skip, skip_stack), = skip_stack.items()

    for i, child in enumerate(box.children[skip:]):
        index = i + skip
        if (isinstance(child, boxes.BlockLevelBox) and
                child.is_in_normal_flow()):
            assert skip_stack is None  # Should not skip here
            block_level_box = child
            index += 1  # Resume *after* the block
        else:
            if isinstance(child, boxes.InlineBox):
                recursion = _inner_block_in_inline(child, skip_stack)
                skip_stack = None
                new_child, block_level_box, resume_at = recursion
            else:
                assert skip_stack is None  # Should not skip here
                new_child = block_in_inline(child)
                # block_level_box is still None.
            if new_child is not child:
                changed = True
            new_children.append(new_child)
        if block_level_box is not None:
            resume_at = {index: resume_at}
            box = box.copy_with_children(new_children)
            break
    else:
        if changed or skip:
            box = box.copy_with_children(new_children)

    return box, block_level_box, resume_at


def set_viewport_overflow(root_box):
    """
    Set a ``viewport_overflow`` attribute on the box for the root element.

    Like backgrounds, ``overflow`` on the root element must be propagated
    to the viewport.

    See https://www.w3.org/TR/CSS21/visufx.html#overflow
    """
    chosen_box = root_box
    if (root_box.element_tag.lower() == 'html' and
            root_box.style['overflow'] == 'visible'):
        for child in root_box.children:
            if child.element_tag.lower() == 'body':
                chosen_box = child
                break

    root_box.viewport_overflow = chosen_box.style['overflow']
    chosen_box.style['overflow'] = 'visible'
    return root_box


def box_text(box):
    # Stripping may not be the "right" way, but it seems to be what users usually want
    # in this case. The specification asks for the "text content", probably as defined
    # in DOM.
    box = box.deepcopy()
    process_whitespace(box)
    if isinstance(box, boxes.TextBox):
        return box.text.strip()
    elif isinstance(box, boxes.ParentBox):
        return ''.join(
            child.text for child in box.descendants()
            if not child.element_tag.endswith('::before') and
            not child.element_tag.endswith('::after') and
            not child.element_tag.endswith('::marker') and
            isinstance(child, boxes.TextBox)).strip()
    return ''


def extract_text(text_part, box):
    if text_part in ('text', 'content'):
        return box_text(box)
    elif text_part in ('before', 'after'):
        if isinstance(box, boxes.ParentBox):
            return ''.join(
                box_text(child) for child in box.descendants()
                if child.element_tag.endswith(f'::{text_part}') and
                not isinstance(child, boxes.ParentBox))
        return ''
    elif text_part == 'first-letter':
        # TODO: use the same code as in inlines.first_letter_to_box
        character_found = False
        first_letter = ''
        text = box_text(box)
        for letter in text:
            category = unicodedata.category(letter)
            if category not in ('Ps', 'Pe', 'Pi', 'Pf', 'Po'):
                if character_found:
                    break
                character_found = True
            first_letter += letter
        return first_letter


================================================
FILE: weasyprint/html.py
================================================
"""Specific handling for some HTML elements, especially replaced elements.

Replaced elements (eg. <img> elements) are rendered externally and behave as an
atomic opaque box in CSS. In general, they may or may not have intrinsic
dimensions. But the only replaced elements currently supported in WeasyPrint
are images with intrinsic dimensions.

"""

import re
from importlib.resources import files

from . import CSS, Attachment, css
from .css import get_child_text
from .css.counters import CounterStyle
from .formatting_structure import boxes
from .images import SVGImage
from .logger import LOGGER
from .urls import get_url_attribute

HTML5_UA_COUNTER_STYLE = CounterStyle()
HTML5_UA = (files(css) / 'html5_ua.css').read_text('utf-8')
HTML5_UA_FORM = (files(css) / 'html5_ua_form.css').read_text('utf-8')
HTML5_PH = (files(css) / 'html5_ph.css').read_text('utf-8')
HTML5_UA_STYLESHEET = CSS(
    string=HTML5_UA, counter_style=HTML5_UA_COUNTER_STYLE)
HTML5_UA_FORM_STYLESHEET = CSS(
    string=HTML5_UA_FORM, counter_style=HTML5_UA_COUNTER_STYLE)
HTML5_PH_STYLESHEET = CSS(string=HTML5_PH)

# https://html.spec.whatwg.org/multipage/#space-character
HTML_WHITESPACE = ' \t\n\f\r'
HTML_SPACE_SEPARATED_TOKENS_RE = re.compile(f'[^{HTML_WHITESPACE}]+')


def ascii_lower(string):
    r"""Transform (only) ASCII letters to lower case: A-Z is mapped to a-z.

    This is used for `ASCII case-insensitive
    <https://whatwg.org/C#ascii-case-insensitive>`_ matching.

    This is different from the :meth:`str.lower` method of Unicode strings
    which also affect non-ASCII characters,
    sometimes mapping them into the ASCII range:

    >>> keyword = 'Bac\N{KELVIN SIGN}ground'
    >>> assert keyword.lower() == 'background'
    >>> assert ascii_lower(keyword) != keyword.lower()
    >>> assert ascii_lower(keyword) == 'bac\N{KELVIN SIGN}ground'

    """
    # This turns out to be faster than unicode.translate()
    return string.encode().lower().decode()


def element_has_link_type(element, link_type):
    """Return whether element has a ``rel`` attribute with given link type."""
    tokens = HTML_SPACE_SEPARATED_TOKENS_RE.findall(element.get('rel', ''))
    return any(ascii_lower(token) == link_type for token in tokens)


# Maps HTML tag names to function taking an HTML element and returning a Box.
HTML_HANDLERS = {}


def handle_element(element, box, get_image_from_uri, base_url):
    """Handle HTML elements that need special care.

    :returns: a (possibly empty) list of boxes.
    """
    if box.element_tag in HTML_HANDLERS:
        return HTML_HANDLERS[element.tag](
            element, box, get_image_from_uri, base_url)
    else:
        return [box]


def handler(tag):
    """Return a decorator registering a function handling ``tag`` elements."""
    def decorator(function):
        """Decorator registering a function handling ``tag`` elements."""
        HTML_HANDLERS[tag] = function
        return function
    return decorator


def make_replaced_box(element, box, image):
    """Wrap an image in a replaced box.

    That box is either block-level or inline-level, depending on what the
    element should be.

    """
    type_ = (
        boxes.BlockReplacedBox if 'block' in box.style['display']
        else boxes.InlineReplacedBox)
    new_box = type_(element.tag, box.style, element, image)
    # TODO: check other attributes that need to be copied
    # TODO: find another solution
    new_box.string_set = box.string_set
    new_box.bookmark_label = box.bookmark_label
    return new_box


@handler('img')
def handle_img(element, box, get_image_from_uri, base_url):
    """Handle ``<img>`` elements.

    Return either an image or the alt-text.

    See: https://www.w3.org/TR/html5/embedded-content-1.html#the-img-element

    """
    src = get_url_attribute(element, 'src', base_url)
    alt = element.get('alt')
    if src:
        image = get_image_from_uri(
            url=src, orientation=box.style['image_orientation'])
        if image is not None:
            return [make_replaced_box(element, box, image)]
        else:
            # Invalid image, use the alt-text.
            if alt:
                box.children = [boxes.TextBox.anonymous_from(box, alt)]
                return [box]
            elif alt == '':
                # The element represents nothing
                return []
            else:
                assert alt is None
                # TODO: find some indicator that an image is missing.
                # For now, just remove the image.
                return []
    else:
        if alt:
            box.children = [boxes.TextBox.anonymous_from(box, alt)]
            return [box]
        else:
            return []


@handler('embed')
def handle_embed(element, box, get_image_from_uri, base_url):
    """Handle ``<embed>`` elements, return either an image or nothing.

    See: https://www.w3.org/TR/html5/embedded-content-0.html#the-embed-element

    """
    src = get_url_attribute(element, 'src', base_url)
    type_ = element.get('type', '').strip()
    if src:
        image = get_image_from_uri(
            url=src, forced_mime_type=type_,
            orientation=box.style['image_orientation'])
        if image is not None:
            return [make_replaced_box(element, box, image)]
    # No fallback.
    return []


@handler('object')
def handle_object(element, box, get_image_from_uri, base_url):
    """Handle ``<object>`` elements, return either an image or the fallback.

    See: https://www.w3.org/TR/html5/embedded-content-0.html#the-object-element

    """
    data = get_url_attribute(element, 'data', base_url)
    type_ = element.get('type', '').strip()
    if data:
        image = get_image_from_uri(
            url=data, forced_mime_type=type_,
            orientation=box.style['image_orientation'])
        if image is not None:
            return [make_replaced_box(element, box, image)]
    # The element’s children are the fallback.
    return [box]


@handler('colgroup')
def handle_colgroup(element, box, _get_image_from_uri, _base_url):
    """Handle the ``span`` attribute."""
    if isinstance(box, boxes.TableColumnGroupBox):
        if not any(child.tag == 'col' for child in element):
            box.children = [
                boxes.TableColumnBox.anonymous_from(box, [])
                for _ in range(box.span)]
    return [box]


@handler('col')
def handle_col(element, box, _get_image_from_uri, _base_url):
    """Handle the ``span`` attribute."""
    if isinstance(box, boxes.TableColumnBox) and box.span > 1:
        # Generate multiple boxes
        # https://lists.w3.org/Archives/Public/www-style/2011Nov/0293.html
        return [box.copy() for _i in range(box.span)]
    return [box]


@handler('{http://www.w3.org/2000/svg}svg')
def handle_svg(element, box, get_image_from_uri, base_url):
    """Handle ``<svg>`` elements.

    Return either an image or the fallback content.

    """
    # TODO: handle href base for inline svg tags
    url_fetcher = get_image_from_uri.keywords['url_fetcher']
    context = get_image_from_uri.keywords['context']
    try:
        image = SVGImage(element, base_url, url_fetcher, context)
    except Exception as exception:  # pragma: no cover
        LOGGER.error('Failed to load inline SVG: %s', exception)
        LOGGER.debug('Error while loading inline SVG:', exc_info=exception)
        return []
    else:
        return [make_replaced_box(element, box, image)]


def get_html_metadata(html):
    """Get metadata dictionary out of HTML object.

    Relevant specs:

    https://www.whatwg.org/html#the-title-element
    https://www.whatwg.org/html#standard-metadata-names
    https://wiki.whatwg.org/wiki/MetaExtensions
    https://microformats.org/wiki/existing-rel-values#HTML5_link_type_extensions

    """
    title = None
    description = None
    generator = None
    keywords = []
    authors = []
    created = None
    modified = None
    attachments = []
    custom = {}
    lang = html.etree_element.attrib.get('lang', None)
    for element in html.wrapper_element.query_all('title', 'meta', 'link'):
        element = element.etree_element
        if element.tag == 'title' and title is None:
            title = get_child_text(element)
        elif element.tag == 'meta':
            name = ascii_lower(element.get('name', ''))
            content = element.get('content', '')
            if name == 'keywords':
                for keyword in map(strip_whitespace, content.split(',')):
                    if keyword not in keywords:
                        keywords.append(keyword)
            elif name == 'author':
                authors.append(content)
            elif name == 'description':
                if description is None:
                    description = content
            elif name == 'generator':
                if generator is None:
                    generator = content
            elif name == 'dcterms.created':
                if created is None:
                    created = parse_w3c_date(name, content)
            elif name == 'dcterms.modified':
                if modified is None:
                    modified = parse_w3c_date(name, content)
            elif name and name not in custom:
                custom[name] = content
        elif element.tag == 'link' and element_has_link_type(
                element, 'attachment'):
            url = get_url_attribute(element, 'href', html.base_url)
            attachment_title = element.get('title', None)
            if url is None:
                LOGGER.error('Missing href in <link rel="attachment">')
            else:
                attachment = Attachment(
                    url=url, description=attachment_title,
                    url_fetcher=html.url_fetcher)
                attachments.append(attachment)
    return {
        'title': title,
        'description': description,
        'generator': generator,
        'keywords': keywords,
        'authors': authors,
        'created': created,
        'modified': modified,
        'attachments': attachments,
        'lang': lang,
        'custom': custom,
    }


def strip_whitespace(string):
    """Use the HTML definition of "space character",
    not all Unicode Whitespace.

    https://www.whatwg.org/html#strip-leading-and-trailing-whitespace
    https://www.whatwg.org/html#space-character

    """
    return string.strip(HTML_WHITESPACE)


# YYYY (eg 1997)
# YYYY-MM (eg 1997-07)
# YYYY-MM-DD (eg 1997-07-16)
# YYYY-MM-DDThh:mmTZD (eg 1997-07-16T19:20+01:00)
# YYYY-MM-DDThh:mm:ssTZD (eg 1997-07-16T19:20:30+01:00)
# YYYY-MM-DDThh:mm:ss.sTZD (eg 1997-07-16T19:20:30.45+01:00)

W3C_DATE_RE = re.compile('''
    ^
    [ \t\n\f\r]*
    (?P<year>\\d\\d\\d\\d)
    (?:
        -(?P<month>0\\d|1[012])
        (?:
            -(?P<day>[012]\\d|3[01])
            (?:
                T(?P<hour>[01]\\d|2[0-3])
                :(?P<minute>[0-5]\\d)
                (?:
                    :(?P<second>[0-5]\\d)
                    (?:\\.\\d+)?  # Second fraction, ignored
                )?
                (?:
                    Z |  # UTC
                    (?P<tz_hour>[+-](?:[01]\\d|2[0-3]))
                    :(?P<tz_minute>[0-5]\\d)
                )
            )?
        )?
    )?
    [ \t\n\f\r]*
    $
''', re.VERBOSE)


def parse_w3c_date(meta_name, string):
    """Parse datetimes as defined by the W3C.

    See https://www.w3.org/TR/NOTE-datetime

    """
    if W3C_DATE_RE.match(string):
        return string
    else:
        LOGGER.warning(
            'Invalid date in <meta name="%s"> %r', meta_name, string)


================================================
FILE: weasyprint/images.py
================================================
"""Fetch and decode images in various formats."""

import io
import math
import struct
from hashlib import md5
from io import BytesIO
from itertools import cycle
from pathlib import Path
from xml.etree import ElementTree

import pydyf
from PIL import Image, ImageFile, ImageOps
from tinycss2.color5 import parse_color

from . import DEFAULT_OPTIONS
from .layout.percent import percentage
from .logger import LOGGER
from .svg import SVG
from .urls import URLFetchingError, fetch

# Don’t crash when converting truncated images
ImageFile.LOAD_TRUNCATED_IMAGES = True


class ImageLoadingError(ValueError):
    """An error occured when loading an image.

    The image data is probably corrupted or in an invalid format.

    """


class RasterImage:
    def __init__(self, pillow_image, image_id, image_data, filename=None,
                 cache=None, orientation='none', options=DEFAULT_OPTIONS):
        # Transpose image
        original_pillow_image = pillow_image
        pillow_image = rotate_pillow_image(pillow_image, orientation)
        if original_pillow_image is not pillow_image:
            # Keep image format as it is discarded by transposition
            pillow_image.format = original_pillow_image.format
            # Discard original data, as the image has been transformed
            image_data = filename = None

        self.id = image_id
        self._cache = {} if cache is None else cache
        self._jpeg_quality = jpeg_quality = options['jpeg_quality']
        self._dpi = options['dpi']

        if 'transparency' in pillow_image.info:
            pillow_image = pillow_image.convert('RGBA')
        elif pillow_image.mode in ('1', 'P', 'I'):
            pillow_image = pillow_image.convert('RGB')

        self.mode = pillow_image.mode
        self.width = pillow_image.width
        self.height = pillow_image.height
        self.ratio = (self.width / self.height) if self.height != 0 else math.inf
        self.optimize = optimize = options['optimize_images']

        # 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 PR #2179.
        app14 = getattr(original_pillow_image, 'app', {}).get('APP14')
        self.invert_colors = self.mode == 'CMYK' and app14 is not None

        if pillow_image.format in ('JPEG', 'MPO'):
            self.format = 'JPEG'
            if image_data is None or optimize or jpeg_quality is not None:
                image_file = io.BytesIO()
                options = {'format': 'JPEG', 'optimize': optimize}
                if self._jpeg_quality is not None:
                    options['quality'] = self._jpeg_quality
                pillow_image.save(image_file, **options)
                image_data = image_file.getvalue()
                filename = None
        else:
            self.format = 'PNG'
            if image_data is None or optimize or pillow_image.format != 'PNG':
                image_file = io.BytesIO()
                pillow_image.save(image_file, format='PNG', optimize=optimize)
                image_data = image_file.getvalue()
                filename = None
        self.image_data = self.cache_image_data(image_data, filename)

    def get_intrinsic_size(self, resolution, font_size):
        return self.width / resolution, self.height / resolution, self.ratio

    def draw(self, stream, concrete_width, concrete_height, style):
        if self.width <= 0 or self.height <= 0:
            return

        image_rendering = style['image_rendering']
        interpolate = image_rendering == 'auto'
        ratio = 1
        if self._dpi:
            pt_to_in = 4 / 3 / 96
            width_inches = abs(concrete_width * stream.ctm[0][0] * pt_to_in)
            height_inches = abs(concrete_height * stream.ctm[1][1] * pt_to_in)
            dpi = max(self.width / width_inches, self.height / height_inches)
            if dpi > self._dpi:
                ratio = self._dpi / dpi
        image_name = stream.add_image(self, interpolate, ratio)

        stream.transform(
            concrete_width, 0, 0, -concrete_height, 0, concrete_height)
        stream.draw_x_object(image_name)

    def cache_image_data(self, data, filename=None, slot='source'):
        if filename:
            return LazyLocalImage(filename)
        else:
            key = f'{self.id}-{slot}-{self._dpi or ""}'
            return LazyImage(self._cache, key, data)

    def get_x_object(self, interpolate, dpi_ratio):
        if dpi_ratio == 1:
            width, height = self.width, self.height
        else:
            thumbnail = Image.open(io.BytesIO(self.image_data.data))
            width = max(1, round(self.width * dpi_ratio))
            height = max(1, round(self.height * dpi_ratio))
            thumbnail.thumbnail((width, height))
            image_file = io.BytesIO()
            thumbnail.save(
                image_file, format=thumbnail.format, optimize=self.optimize)
            width, height = thumbnail.width, thumbnail.height
            self.image_data = self.cache_image_data(image_file.getvalue())

        if self.mode in ('RGB', 'RGBA'):
            color_space = '/DeviceRGB'
        elif self.mode in ('L', 'LA'):
            color_space = '/DeviceGray'
        elif self.mode == 'CMYK':
            color_space = '/DeviceCMYK'
        else:
            LOGGER.warning('Unknown image mode: %s', self.mode)
            color_space = '/DeviceRGB'

        extra = pydyf.Dictionary({
            'Type': '/XObject',
            'Subtype': '/Image',
            'Width': width,
            'Height': height,
            'ColorSpace': color_space,
            'BitsPerComponent': 8,
            'Interpolate': 'true' if interpolate else 'false',
        })

        if self.format == 'JPEG':
            if self.invert_colors:
                extra['Decode'] = pydyf.Array((1, 0) * 4)
            extra['Filter'] = '/DCTDecode'
            return pydyf.Stream([self.image_data], extra)

        extra['Filter'] = '/FlateDecode'
        extra['DecodeParms'] = pydyf.Dictionary({
            # Predictor 15 specifies that we're providing PNG data,
            # ostensibly using an "optimum predictor", but doesn't actually
            # matter as long as the predictor value is 10+ according to the
            # spec. (Other PNG predictor values assert that we're using
            # specific predictors that we don't want to commit to, but
            # "optimum" can vary.)
            'Predictor': 15,
            'Columns': width,
        })
        if self.mode in ('RGB', 'RGBA'):
            # Defaults to 1.
            extra['DecodeParms']['Colors'] = 3
        if self.mode in ('RGBA', 'LA'):
            # Remove alpha channel from image
            pillow_image = Image.open(io.BytesIO(self.image_data.data))
            alpha = pillow_image.getchannel('A')
            pillow_image = pillow_image.convert(self.mode[:-1])
            png_data = self._get_png_data(pillow_image)
            # Save alpha channel as mask
            alpha_data = self._get_png_data(alpha)
            stream = self.cache_image_data(alpha_data, slot='streamalpha')
            extra['SMask'] = pydyf.Stream([stream], extra={
                'Filter': '/FlateDecode',
                'Type': '/XObject',
                'Subtype': '/Image',
                'DecodeParms': pydyf.Dictionary({
                    'Predictor': 15,
                    'Columns': width,
                }),
                'Width': width,
                'Height': height,
                'ColorSpace': '/DeviceGray',
                'BitsPerComponent': 8,
                'Interpolate': 'true' if interpolate else 'false',
            })
        else:
            png_data = self._get_png_data(
                Image.open(io.BytesIO(self.image_data.data)))

        return pydyf.Stream([self.cache_image_data(png_data, slot='stream')], extra)

    @staticmethod
    def _get_png_data(pillow_image):
        image_file = BytesIO()
        pillow_image.save(image_file, format='PNG')

        # Read the PNG header, then discard it because we know it's a PNG. If
        # this weren't just output from Pillow, we should actually check it.
        image_file.seek(8)

        png_data = []
        raw_chunk_length = image_file.read(4)
        # PNG files consist of a series of chunks.
        while raw_chunk_length:
            # Each chunk begins with its data length (four bytes, may be zero),
            # then its type (four ASCII characters), then the data, then four
            # bytes of a CRC.
            chunk_length, = struct.unpack('!I', raw_chunk_length)
            chunk_type = image_file.read(4)
            if chunk_type == b'IDAT':
                png_data.append(image_file.read(chunk_length))
            else:
                image_file.seek(chunk_length, io.SEEK_CUR)
            # We aren't checking the CRC, we assume this is a valid PNG.
            image_file.seek(4, io.SEEK_CUR)
            raw_chunk_length = image_file.read(4)

        return b''.join(png_data)


class LazyImage(pydyf.Object):
    def __init__(self, cache, key, data):
        super().__init__()
        self._key = key
        self._cache = cache
        cache[key] = data

    @property
    def data(self):
        return self._cache[self._key]


class LazyLocalImage(pydyf.Object):
    def __init__(self, filename):
        super().__init__()
        self._filename = filename

    @property
    def data(self):
        return Path(self._filename).read_bytes()


class SVGImage:
    def __init__(self, tree, base_url, url_fetcher, context):
        font_config = context.font_config if context else None
        self._svg = SVG(tree, base_url, font_config, url_fetcher)
        self._base_url = base_url
        self._url_fetcher = url_fetcher
        self._context = context

    def get_intrinsic_size(self, image_resolution, font_size):
        width, height = self._svg.get_intrinsic_size(font_size)
        if None in (width, height):
            viewbox = self._svg.get_viewbox()
            if viewbox and viewbox[2] and viewbox[3]:
                ratio = viewbox[2] / viewbox[3]
                if width:
                    height = width / ratio
                elif height:
                    width = height * ratio
            else:
                ratio = None
        elif width and height:
            ratio = width / height
        else:
            ratio = 1
        return width, height, ratio

    def draw(self, stream, concrete_width, concrete_height, _style):
        try:
            self._svg.draw(
                stream, concrete_width, concrete_height, self._base_url,
                self._context)
        except BaseException as exception:
            LOGGER.error('Failed to render SVG image %s', self._base_url)
            LOGGER.debug('Error while rendering SVG image:', exc_info=exception)


def get_image_from_uri(cache, url_fetcher, options, url, forced_mime_type=None,
                       context=None, orientation='from-image'):
    """Get an Image instance from an image URI."""
    if url in cache:
        return cache[url]

    try:
        with fetch(url_fetcher, url) as response:
            bytestring = response.read()
            mime_type = forced_mime_type or response.content_type

        image = None
        svg_exceptions = []
        # Try to rely on given mimetype for SVG
        if mime_type == 'image/svg+xml':
            try:
                tree = ElementTree.fromstring(bytestring)
                image = SVGImage(tree, url, url_fetcher, context)
            except Exception as svg_exception:
                svg_exceptions.append(svg_exception)
        # Try pillow for raster images, or for failing SVG
        if image is None:
            try:
                pillow_image = Image.open(BytesIO(bytestring))
            except Exception as raster_exception:
                if mime_type == 'image/svg+xml':
                    # Tried SVGImage then Pillow for a SVG, abort
                    raise ImageLoadingError from svg_exceptions[0]
                try:
                    # Last chance, try SVG
                    tree = ElementTree.fromstring(bytestring)
                    image = SVGImage(tree, url, url_fetcher, context)
                except Exception:
                    # Tried Pillow then SVGImage for a raster, abort
                    raise ImageLoadingError from raster_exception
            else:
                # Store image id to enable cache in Stream.add_image
                image_id = md5(url.encode(), usedforsecurity=False).hexdigest()
                image = RasterImage(
                    pillow_image, image_id, bytestring, response.path, cache,
                    orientation, options)

    except (URLFetchingError, ImageLoadingError) as exception:
        LOGGER.error('Failed to load image at %r: %s', url, exception)
        LOGGER.debug('Error while loading image:', exc_info=exception)
        image = None

    cache[url] = image
    return image


def rotate_pillow_image(pillow_image, orientation):
    """Return a copy of a Pillow image with modified orientation.

    If orientation is not changed, return the same image.

    """
    image_format = pillow_image.format
    if orientation == 'from-image':
        if 'exif' in pillow_image.info:
            pillow_image = ImageOps.exif_transpose(pillow_image)
    elif orientation != 'none':
        angle, flip = orientation
        if angle > 0:
            rotation = getattr(Image.Transpose, f'ROTATE_{angle}')
            pillow_image = pillow_image.transpose(rotation)
        if flip:
            pillow_image = pillow_image.transpose(
                Image.Transpose.FLIP_LEFT_RIGHT)

    # Keep image format as it is discarded by transposition
    pillow_image.format = image_format
    return pillow_image


def process_color_stops(vector_length, positions, hints, style):
    """Give color stops positions and hints on the gradient vector.

    ``vector_length`` is the distance between the starting point and ending
    point of the vector gradient.

    ``positions`` is a list of ``None``, or ``Dimension`` in px or %. 0 is the
    starting point, 1 the ending point.

    See https://drafts.csswg.org/css-images-3/#color-stop-syntax.

    Return processed color stops, as a list of floats in px.

    """
    # Resolve percentages.
    positions = [percentage(position, style, vector_length) for position in positions]
    hints = [percentage(hint, style, vector_length) / vector_length for hint in hints]

    # First and last default to 100%.
    if positions[0] is None:
        positions[0] = 0
    if positions[-1] is None:
        positions[-1] = vector_length

    # Make sure positions are increasing.
    previous_pos = positions[0]
    for i, position in enumerate(positions):
        if position is not None:
            if position < previous_pos:
                positions[i] = previous_pos
            else:
                previous_pos = position

    # Assign missing values.
    previous_i = -1
    for i, position in enumerate(positions):
        if position is not None:
            base = positions[previous_i]
            increment = (position - base) / (i - previous_i)
            for j in range(previous_i + 1, i):
                positions[j] = base + j * increment
            previous_i = i

    # Calculate exponential value for PDF hints, avoid big numbers.
    hints = [
        0 if hint <= 0 else
        2 ** 32 if hint >= 1 else
        min(2 ** 32, math.log(0.5, hint)) for hint in hints]

    return positions, hints


def normalize_stop_positions(positions):
    """Normalize stop positions between 0 and 1.

    Return ``(first, last, positions)``.

    first: original position of the first position.
    last: original position of the last position.
    positions: list of positions between 0 and 1.

    """
    first, last = positions[0], positions[-1]
    total_length = last - first
    if total_length == 0:
        positions = [0] * len(positions)
    else:
        positions = [(pos - first) / total_length for pos in positions]
    return first, last, positions


def gradient_average_color(colors, positions):
    """
    https://drafts.csswg.org/css-images-3/#gradient-average-color
    """
    # TODO: handle color spaces.
    nb_stops = len(positions)
    assert nb_stops > 1
    assert nb_stops == len(colors)
    total_length = positions[-1] - positions[0]
    if total_length == 0:
        positions = list(range(nb_stops))
        total_length = nb_stops - 1
    premul_r = [r * a for r, g, b, a in colors]
    premul_g = [g * a for r, g, b, a in colors]
    premul_b = [b * a for r, g, b, a in colors]
    alpha = [a for r, g, b, a in colors]
    result_r = result_g = result_b = result_a = 0
    total_weight = 2 * total_length
    for i, position in enumerate(positions[1:], 1):
        weight = (position - positions[i - 1]) / total_weight
        for j in (i - 1, i):
            result_r += premul_r[j] * weight
            result_g += premul_g[j] * weight
            result_b += premul_b[j] * weight
            result_a += alpha[j] * weight
    # Un-premultiply.
    if result_a == 0:
        return parse_color('transparent')
    else:
        return parse_color(
            f'rgb({result_r / result_a * 255} {result_g / result_a * 255} '
            f'{result_b / result_a * 255}/{ result_a })')


class Gradient:
    def __init__(self, color_stops, repeating, color_hints):
        assert color_stops
        # List of (r, g, b, a)
        self.colors = tuple(color for color, _ in color_stops)
        # List of Dimensions
        self.stop_positions = tuple(position for _, position in color_stops)
        # List of Dimensions
        self.color_hints = color_hints
        # Boolean
        self.repeating = repeating

    def get_intrinsic_size(self, image_resolution, font_size):
        return None, None, None

    def draw(self, stream, concrete_width, concrete_height, style):
        scale_y, type_, points, positions, colors, color_hints = self.layout(
            concrete_width, concrete_height, style)

        if type_ == 'solid':
            stream.rectangle(0, 0, concrete_width, concrete_height)
            stream.set_color(colors[0])
            stream.fill()
            return

        alphas = [color[3] for color in colors]
        alpha_couples = [
            [alphas[i], alphas[i + 1], color_hints[i]]
            for i in range(len(alphas) - 1)]
        # TODO: handle other color spaces.
        color_couples = [
            [colors[i].to('srgb')[:3], colors[i + 1].to('srgb')[:3], color_hints[i]]
            for i in range(len(colors) - 1)]

        # Premultiply colors
        for i, alpha in enumerate(alphas):
            if alpha == 0:
                if i > 0:
                    color_couples[i - 1][1] = color_couples[i - 1][0]
                if i < len(colors) - 1:
                    color_couples[i][0] = color_couples[i][1]
        for i, (a0, a1, hint) in enumerate(alpha_couples):
            if 0 not in (a0, a1) and (a0, a1) != (1, 1):
                color_couples[i][2] = a0 / a1

        shading_type = 2 if type_ == 'linear' else 3
        domain = (positions[0], positions[-1])
        extend = not self.repeating
        encode = (len(colors) - 1) * (0, 1)
        bounds = positions[1:-1]
        sub_functions = (
            stream.create_interpolation_function((0, 1), c0, c1, hint)
            for c0, c1, hint in color_couples)
        function = stream.create_stitching_function(
            domain, encode, bounds, sub_functions)
        # TODO: handle other color spaces.
        shading = stream.add_shading(
            shading_type, 'RGB', domain, points, extend, function)
        stream.transform(d=scale_y)

        if any(alpha != 1 for alpha in alphas):
            alpha_stream = stream.set_alpha_state(
                0, 0, concrete_width, concrete_height)

            shading_type = 2 if type_ == 'linear' else 3
            sub_functions = (
                stream.create_interpolation_function((0, 1), (c0,), (c1,), hint)
                for c0, c1, hint in alpha_couples)
            function = stream.create_stitching_function(
                domain, encode, bounds, sub_functions)
            alpha_shading = alpha_stream.add_shading(
                shading_type, 'Gray', domain, points, extend, function)
            alpha_stream.transform(d=scale_y)
            alpha_stream.stream = [f'/{alpha_shading.id} sh']

        stream.paint_shading(shading.id)

    def layout(self, width, height, style):
        """Get layout information about the gradient.

        width, height: Gradient box. Top-left is at coordinates (0, 0).
        style: box computed style.

        Returns (scale_y, type_, points, positions, colors).

        scale_y: vertical scale of the gradient. float, used for ellipses
                 radial gradients. 1 otherwise.
        type_: gradient type.
        points: coordinates of useful points, depending on type_:
            'solid': None.
            'linear': (x0, y0, x1, y1)
                      coordinates of the starting and ending points.
            'radial': (cx0, cy0, radius0, cx1, cy1, radius1)
                      coordinates of the starting end ending circles
        positions: positions of the color stops. list of floats in between 0
                   and 1 (0 at the starting point, 1 at the ending point).
        colors: list of (r, g, b, a).

        """
        raise NotImplementedError


class LinearGradient(Gradient):
    def __init__(self, color_stops, direction, repeating, color_hints):
        super().__init__(color_stops, repeating, color_hints)
        # ('corner', keyword) or ('angle', radians)
        self.direction_type, self.direction = direction

    def layout(self, width, height, style):
        # Only one color, render the gradient as a solid color
        if len(self.colors) == 1:
            return 1, 'solid', None, [], [self.colors[0]], []

        # Define the (dx, dy) unit vector giving the direction of the gradient.
        # Positive dx: right, positive dy: down.
        if self.direction_type == 'corner':
            y, x = self.direction.split('_')
            factor_x = -1 if x == 'left' else 1
            factor_y = -1 if y == 'top' else 1
            diagonal = math.hypot(width, height)
            # Note the direction swap: dx based on height, dy based on width
            # The gradient line is perpendicular to a diagonal.
            dx = factor_x * height / diagonal
            dy = factor_y * width / diagonal
        else:
            assert self.direction_type == 'angle'
            angle = self.direction  # 0 upwards, then clockwise
            dx = math.sin(angle)
            dy = -math.cos(angle)

        # Round dx and dy to avoid floating points errors caused by
        # trigonometry and angle units conversions
        dx, dy = round(dx, 9), round(dy, 9)

        # Normalize colors positions
        colors = list(self.colors)
        vector_length = abs(width * dx) + abs(height * dy)
        positions, hints = process_color_stops(
            vector_length, self.stop_positions, self.color_hints, style)
        if not self.repeating:
            # Add explicit colors at boundaries if needed, because PDF doesn’t
            # extend color stops that are not displayed
            if positions[0] == positions[1]:
                positions.insert(0, positions[0] - 1)
                colors.insert(0, colors[0])
                hints.insert(0, 1)
            if positions[-2] == positions[-1]:
                positions.append(positions[-1] + 1)
                colors.append(colors[-1])
                hints.append(1)
        first, last, positions = normalize_stop_positions(positions)

        if self.repeating:
            # Render as a solid color if the first and last positions are equal
            # See https://drafts.csswg.org/css-images-3/#repeating-gradients
            if first == last:
                color = gradient_average_color(colors, positions)
                return 1, 'solid', None, [], [color], []

            # Define defined gradient length and steps between positions
            stop_length = last - first
            assert stop_length > 0
            position_steps = [
                positions[i + 1] - positions[i]
                for i in range(len(positions) - 1)]

            # Create cycles used to add colors
            next_steps = cycle((0, *position_steps))
            next_colors = cycle(colors)
            next_hints = cycle(hints)
            previous_steps = cycle((0, *position_steps[::-1]))
            previous_colors = cycle(colors[::-1])
            previous_hints = cycle(hints[::-1])

            # Add colors after last step
            while last < vector_length:
                step = next(next_steps)
                colors.append(next(next_colors))
                hints.append(next(next_hints))
                positions.append(positions[-1] + step)
                last += step * stop_length

            # Add colors before first step
            while first > 0:
                step = next(previous_steps)
                colors.insert(0, next(previous_colors))
                hints.insert(0, next(previous_hints))
                positions.insert(0, positions[0] - step)
                first -= step * stop_length

        # Define the coordinates of the starting and ending points
        start_x = (width - dx * vector_length) / 2
        start_y = (height - dy * vector_length) / 2
        points = (
            start_x + dx * first, start_y + dy * first,
            start_x + dx * last, start_y + dy * last)

        return 1, 'linear', points, positions, colors, hints


class RadialGradient(Gradient):
    def __init__(self, color_stops, shape, size, center, repeating, color_hints):
        super().__init__(color_stops, repeating, color_hints)
        # Center of the ending shape. (origin_x, pos_x, origin_y, pos_y)
        self.center = center
        # Type of ending shape: 'circle' or 'ellipse'
        self.shape = shape
        # size_type: 'keyword'
        #   size: 'closest-corner', 'farthest-corner',
        #         'closest-side', or 'farthest-side'
        # size_type: 'explicit'
        #   size: (radius_x, radius_y)
        self.size_type, self.size = size

    def layout(self, width, height, style):
        # Only one color, render the gradient as a solid color
        if len(self.colors) == 1:
            return 1, 'solid', None, [], [self.colors[0]], []

        # Define the center of the gradient
        origin_x, center_x, origin_y, center_y = self.center
        center_x = percentage(center_x, style, width)
        center_y = percentage(center_y, style, height)
        if origin_x == 'right':
            center_x = width - center_x
        if origin_y == 'bottom':
            center_y = height - center_y

        # Resolve sizes and vertical scale
        size_x, size_y = self._handle_degenerate(
            *self._resolve_size(width, height, center_x, center_y, style))
        scale_y = size_y / size_x

        # Normalize colors positions
        colors = list(self.colors)
        positions, hints = process_color_stops(
            size_x, self.stop_positions, self.color_hints, style)
        if not self.repeating:
            # Add explicit colors at boundaries if needed, because PDF doesn’t
            # extend color stops that are not displayed
            if positions[0] > 0 and positions[0] == positions[1]:
                positions.insert(0, 0)
                colors.insert(0, colors[0])
                hints.insert(0, 1)
            if positions[-2] == positions[-1]:
                positions.append(positions[-1] + 1)
                colors.append(colors[-1])
                hints.append(1)
        if positions[0] < 0:
            # PDF doesn’t like negative radiuses, shift into the positive realm
            if self.repeating:
                # Add vector lengths to first position until positive
                vector_length = positions[-1] - positions[0]
                offset = vector_length * (1 + (-positions[0] // vector_length))
                positions = [position + offset for position in positions]
            else:
                # Only keep colors with position >= 0, interpolate if needed
                if positions[-1] <= 0:
                    # All stops are negative, fill with the last color
                    return 1, 'solid', None, [], [self.colors[-1]], []
                for i, position in enumerate(positions):
                    if position == 0:
                        # Keep colors and positions from this rank
                        colors, positions = colors[i:], positions[i:]
                        break
                    if position > 0:
                        # Interpolate with previous rank to get color at 0
                        color = colors[i]
                        previous_color = colors[i - 1]
                        previous_position = positions[i - 1]
                        assert previous_position < 0
                        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:]]
                        break
        first, last, positions = normalize_stop_positions(positions)

        # Render as a solid color if the first and last positions are the same
        # See https://drafts.csswg.org/css-images-3/#repeating-gradients
        if first == last and self.repeating:
            color = gradient_average_color(colors, positions)
            return 1, 'solid', None, [], [color], []

        # Define the coordinates of the gradient circles
        points = (
            center_x, center_y / scale_y, first,
            center_x, center_y / scale_y, last)

        if self.repeating:
            points, positions, colors, hints = self._repeat(
                width, height, scale_y, points, positions, colors, hints)

        return scale_y, 'radial', points, positions, colors, hints

    def _repeat(self, width, height, scale_y, points, positions, colors, hints):
        # Keep original lists and values, they’re useful
        original_colors = colors.copy()
        original_hints = hints.copy()
        original_positions = positions.copy()
        gradient_length = points[5] - points[2]

        # Get the maximum distance between the center and the corners, to find
        # how many times we have to repeat the colors outside
        max_distance = max(
            math.hypot(width - points[0], height / scale_y - points[1]),
            math.hypot(width - points[0], -points[1] * scale_y),
            math.hypot(-points[0], height / scale_y - points[1]),
            math.hypot(-points[0], -points[1] * scale_y))
        repeat_after = math.ceil((max_distance - points[5]) / gradient_length)
        if repeat_after > 0:
            # Repeat colors and extrapolate positions
            repeat = 1 + repeat_after
            colors *= repeat
            hints = ([*hints, 1] * repeat)[:-1]
            positions = [
                i + position for i in range(repeat) for position in positions]
            points = (*points[:5], points[5] + gradient_length * repeat_after)

        if points[2] == 0:
            # Inner circle has 0 radius, no need to repeat inside, return
            return points, positions, colors, hints

        # Find how many times we have to repeat the colors inside
        repeat_before = points[2] / gradient_length

        # Set the inner circle size to 0
        points = (*points[:2], 0, *points[3:])

        # Find how many times the whole gradient can be repeated
        full_repeat = int(repeat_before)
        if full_repeat:
            # Repeat colors and extrapolate positions
            colors += original_colors * full_repeat
            hints += [1, *original_hints] * full_repeat
            positions = [
                i - full_repeat + position for i in range(full_repeat)
                for position in original_positions] + positions

        # Find the ratio of gradient that must be added to reach the center
        partial_repeat = repeat_before - full_repeat
        if partial_repeat == 0:
            # No partial repeat, return
            return points, positions, colors, hints

        # Iterate through positions in reverse order, from the outer
        # circle to the original inner circle, to find positions from
        # the inner circle (including full repeats) to the center
        assert (original_positions[0], original_positions[-1]) == (0, 1)
        assert 0 < partial_repeat < 1
        reverse = original_positions[::-1]
        ratio = 1 - partial_repeat
        for i, position in enumerate(reverse, start=1):
            if position == ratio:
                # The center is a color of the gradient, truncate original
                # colors and positions and prepend them
                colors = original_colors[-i:] + colors
                hints = [*original_hints[-i:], 1, *hints]
                new_positions = [
                    position - full_repeat - 1
                    for position in original_positions[-i:]]
                positions = new_positions + positions
                return points, positions, colors, hints
            if position < ratio:
                # The center is between two colors of the gradient,
                # define the center color as the average of these two
                # gradient colors
                color = original_colors[-i]
                next_color = original_colors[-(i - 1)]
                next_position = original_positions[-(i - 1)]
                average_colors = [color, color, next_color, next_color]
                average_positions = [position, ratio, ratio, next_position]
                zero_color = gradient_average_color(average_colors, average_positions)
                colors = [zero_color, *original_colors[-(i-1):], *colors]
                hints = [1, *original_hints[-(i-1):], 1, *hints]
                new_positions = [
                    position - 1 - full_repeat for position
                    in original_positions[-(i - 1):]]
                positions = (ratio - 1 - full_repeat, *new_positions, *positions)
                return points, positions, colors, hints

    def _resolve_size(self, width, height, center_x, center_y, style):
        """Resolve circle size of the radial gradient."""
        if self.size_type == 'explicit':
            size_x, size_y = self.size
            size_x = percentage(size_x, style, width)
            size_y = percentage(size_y, style, height)
            return size_x, size_y
        left = abs(center_x)
        right = abs(width - center_x)
        top = abs(center_y)
        bottom = abs(height - center_y)
        pick = min if self.size.startswith('closest') else max
        if self.size.endswith('side'):
            if self.shape == 'circle':
                size_xy = pick(left, right, top, bottom)
                return size_xy, size_xy
            # else: ellipse
            return pick(left, right), pick(top, bottom)
        # else: corner
        if self.shape == 'circle':
            size_xy = pick(math.hypot(left, top), math.hypot(left, bottom),
                           math.hypot(right, top), math.hypot(right, bottom))
            return size_xy, size_xy
        # else: ellipse
        corner_x, corner_y = pick(
            (left, top), (left, bottom), (right, top), (right, bottom),
            key=lambda a: math.hypot(*a))
        return corner_x * math.sqrt(2), corner_y * math.sqrt(2)

    def _handle_degenerate(self, size_x, size_y):
        """Handle degenerate radial gradients.

        See https://drafts.csswg.org/css-images-3/#degenerate-radials

        """
        if size_x == size_y == 0:
            size_x = size_y = 1e-7
        elif size_x == 0:
            size_x = 1e-7
            size_y = 1e7
        elif size_y == 0:
            size_x = 1e7
            size_y = 1e-7
        return size_x, size_y


================================================
FILE: weasyprint/layout/__init__.py
================================================
"""Transform a "before layout" box tree into an "after layout" tree.

Break boxes across lines and pages; determine the size and dimension of each
box fragement.

Boxes in the new tree have *used values* in their ``position_x``,
``position_y``, ``width`` and ``height`` attributes, amongst others.

See https://www.w3.org/TR/CSS21/cascade.html#used-value

"""

from collections import defaultdict
from functools import partial
from math import inf

from ..formatting_structure import boxes, build
from ..logger import PROGRESS_LOGGER
from .absolute import absolute_box_layout, absolute_layout
from .background import layout_backgrounds
from .block import block_level_layout
from .page import make_all_pages, make_margin_boxes


def initialize_page_maker(context, root_box):
    """Initialize ``context.page_maker``.

    Collect the pagination's states required for page based counters.

    """
    context.page_maker = []

    # Special case the root box
    page_break = root_box.style['break_before']

    # TODO: take care of text direction and writing mode
    # https://www.w3.org/TR/css-page-3/#progression
    if page_break == 'right':
        right_page = True
    elif page_break == 'left':
        right_page = False
    elif page_break == 'recto':
        right_page = root_box.style['direction'] == 'ltr'
    elif page_break == 'verso':
        right_page = root_box.style['direction'] == 'rtl'
    else:
        right_page = root_box.style['direction'] == 'ltr'
    resume_at = None
    next_page = {'break': 'any', 'page': root_box.page_values()[0]}

    # page_state is prerequisite for filling in missing page based counters
    # although neither a variable quote_depth nor counter_scopes are needed
    # in page-boxes -- reusing
    # `formatting_structure.build.update_counters()` to avoid redundant
    # code requires a full `state`.
    # The value of **pages**, of course, is unknown until we return and
    # might change when 'content_changed' triggers re-pagination...
    # So we start with an empty state
    page_state = (
        # Shared mutable objects:
        [0],  # quote_depth: single integer
        {'pages': [0]},
        [{'pages'}],  # counter_scopes
        [] # page_groups
    )

    # Initial values
    remake_state = {
        'content_changed': False,
        'pages_wanted': False,
        'anchors': [],  # first occurrence of anchor
        'content_lookups': []  # first occurr. of content-CounterLookupItem
    }
    context.page_maker.append((
        resume_at, next_page, right_page, page_state, remake_state))


def layout_fixed_boxes(context, pages, containing_page):
    """Lay out and yield fixed boxes of ``pages`` on ``containing_page``."""
    for page in pages:
        for box in page.fixed_boxes:
            # As replaced boxes are never copied during layout, ensure that we
            # have different boxes (with a possibly different layout) for
            # each pages.
            if isinstance(box, boxes.ReplacedBox):
                box = box.copy()
            # Absolute boxes in fixed boxes are rendered as fixed boxes'
            # children, even when they are fixed themselves.
            absolute_boxes = []
            absolute_box, _ = absolute_box_layout(
                context, box, containing_page, absolute_boxes,
                bottom_space=-inf, skip_stack=None)
            yield absolute_box
            while absolute_boxes:
                new_absolute_boxes = []
                for box in absolute_boxes:
                    absolute_layout(
                        context, box, containing_page, new_absolute_boxes,
                        bottom_space=-inf, skip_stack=None)
                absolute_boxes = new_absolute_boxes


def layout_document(html, root_box, context, max_loops=8):
    """Lay out the whole document.

    This includes line breaks, page breaks, absolute size and position for all
    boxes. Page based counters might require multiple passes.

    :param root_box:
        Root of the box tree (formatting structure of the HTML). The page boxes
        are created from that tree, this structure is not lost during
        pagination.
    :returns:
        A list of laid out Page objects.

    """
    initialize_page_maker(context, root_box)
    pages = []
    original_footnotes = []
    actual_total_pages = 0

    for loop in range(max_loops):
        if loop > 0:
            PROGRESS_LOGGER.info(
                'Step 5 - Creating layout - Repagination #%d', loop)
            context.footnotes = original_footnotes.copy()

        initial_total_pages = actual_total_pages
        if loop == 0:
            original_footnotes = context.footnotes.copy()
        pages = list(make_all_pages(context, root_box, html, pages))
        actual_total_pages = len(pages)

        # Check whether another round is required
        reloop_content = False
        reloop_pages = False
        for page_data in context.page_maker:
            # Update pages
            _, _, _, page_state, remake_state = page_data
            page_counter_values = page_state[1]
            page_counter_values['pages'] = [actual_total_pages]
            if remake_state['content_changed']:
                reloop_content = True
            if remake_state['pages_wanted']:
                reloop_pages = initial_total_pages != actual_total_pages

        # No need for another loop, stop here
        if not reloop_content and not reloop_pages:
            break

    # Calculate string-sets and bookmark-labels containing page based counters
    # when pagination is finished. No need to do that (maybe multiple times) in
    # make_page because they dont create boxes, only appear in MarginBoxes and
    # in the final PDF.
    # Prevent repetition of bookmarks (see #1145).

    watch_elements = []
    watch_elements_before = []
    watch_elements_after = []
    for i, page in enumerate(pages):
        # We need the updated page_counter_values
        _, _, _, page_state, _ = context.page_maker[i + 1]
        page_counter_values = page_state[1]

        for child in page.descendants():
            # Only one bookmark per original box
            if child.bookmark_label:
                if child.element_tag.endswith('::before'):
                    checklist = watch_elements_before
                elif child.element_tag.endswith('::after'):
                    checklist = watch_elements_after
                else:
                    checklist = watch_elements
                if child.element in checklist:
                    child.bookmark_label = ''
                else:
                    checklist.append(child.element)

            if child.missing_link:
                for (box, css_token), item in (
                        context.target_collector.counter_lookup_items.items()):
                    if child.missing_link == box and css_token != 'content':
                        if (css_token == 'bookmark-label' and
                                not child.bookmark_label):
                            # don't refill it!
                            continue
                        item.parse_again(page_counter_values)
                        # string_set is a pointer, but the bookmark_label is
                        # just a string: copy it
                        if css_token == 'bookmark-label':
                            child.bookmark_label = box.bookmark_label
            # Collect the string_sets in the LayoutContext
            string_sets = child.string_set
            if string_sets and string_sets != 'none':
                for string_set in string_sets:
                    string_name, text = string_set
                    context.string_set[string_name][i+1].append(text)

    # Add margin boxes
    for i, page in enumerate(pages):
        root_children = []
        root, footnote_area = page.children
        root_children.extend(layout_fixed_boxes(context, pages[:i], page))
        root_children.extend(root.children)
        root_children.extend(layout_fixed_boxes(context, pages[i + 1:], page))
        root.children = root_children
        context.current_page = i + 1  # page_number starts at 1

        # page_maker's page_state is ready for the MarginBoxes
        state = context.page_maker[context.current_page][3]
        page.children = (root,)
        if footnote_area.children:
            page.children += (footnote_area,)
        page.children += tuple(make_margin_boxes(context, page, state))
        layout_backgrounds(page, context.get_image_from_uri)
        yield page


class FakeList(list):
    """List in which you can’t append objects."""
    def append(self, item):
        pass


class LayoutContext:
    def __init__(self, style_for, get_image_from_uri, font_config,
                 counter_style, target_collector):
        self.style_for = style_for
        self.get_image_from_uri = partial(get_image_from_uri, context=self)
        self.font_config = font_config
        self.counter_style = counter_style
        self.target_collector = target_collector
        self._excluded_shapes_root_boxes = []
        self._excluded_shapes = {}
        self.footnotes = []
        self.page_footnotes = {}
        self.current_page_footnotes = []
        self.reported_footnotes = []
        self.current_footnote_area = None  # Not initialized yet
        self.page_bottom = None
        self.string_set = defaultdict(lambda: defaultdict(list))
        self.running_elements = defaultdict(lambda: defaultdict(list))
        self.current_page = None
        self.forced_break = False
        self.broken_out_of_flow = {}
        self.in_column = False

        # Cache
        self.tables = {}
        self.dictionaries = {}

    def overflows_page(self, bottom_space, position_y):
        return self.overflows(self.page_bottom - bottom_space, position_y)

    @staticmethod
    def overflows(bottom, position_y):
        # Use a small fudge factor to avoid floating numbers errors.
        # The 1e-9 value comes from PEP 485.
        return position_y > bottom * (1 + 1e-9)

    @property
    def excluded_shapes(self):
        return self._excluded_shapes[self._excluded_shapes_root_boxes[-1]]

    @excluded_shapes.setter
    def excluded_shapes(self, excluded_shapes):
        self._excluded_shapes[self._excluded_shapes_root_boxes[-1]] = excluded_shapes

    def create_block_formatting_context(self, root_box=None, new_list=None):
        assert root_box not in self._excluded_shapes_root_boxes
        self._excluded_shapes_root_boxes.append(root_box)
        if root_box not in self._excluded_shapes:
            self._excluded_shapes[root_box] = [] if new_list is None else new_list

    def finish_block_formatting_context(self, root_box=None):
        # See https://www.w3.org/TR/CSS2/visudet.html#root-height
        if root_box and root_box.style['height'] == 'auto' and self.excluded_shapes:
            box_bottom = root_box.content_box_y() + root_box.height
            max_shape_bottom = max([
                shape.position_y + shape.margin_height()
                for shape in self.excluded_shapes] + [box_bottom])
            root_box.height += max_shape_bottom - box_bottom
        self._excluded_shapes.pop(self._excluded_shapes_root_boxes.pop())

    def create_flex_formatting_context(self, root_box):
        self.create_block_formatting_context(root_box, FakeList())

    def finish_flex_formatting_context(self, root_box):
        self.finish_block_formatting_context(root_box)

    def add_broken_out_of_flow(self, new_box, box, containing_block, resume_at):
        self.broken_out_of_flow[new_box] = (
            box, containing_block, self._excluded_shapes_root_boxes[-1], resume_at)

    def get_string_set_for(self, page, name, keyword='first'):
        """Resolve value of string function."""
        return self.get_string_or_element_for(
            self.string_set, page, name, keyword)

    def get_running_element_for(self, page, name, keyword='first'):
        """Resolve value of element function."""
        return self.get_string_or_element_for(
            self.running_elements, page, name, keyword)

    def get_string_or_element_for(self, store, page, name, keyword):
        """Resolve value of string or element function.

        We'll have something like this that represents all assignments on a
        given page:

        {1: ['First Header'], 3: ['Second Header'],
         4: ['Third Header', '3.5th Header']}

        Value depends on current page.
        https://drafts.csswg.org/css-gcpm/#funcdef-string

        :param dict store:
            Dictionary where the resolved value is stored.
        :param page:
            Current page.
        :param str name:
            Name of the named string or running element.
        :param str keyword:
            Indicates which value of the named string or running element to
            use. Default is the first assignment on the current page else the
            most recent assignment.
        :returns:
            Text for string set, box for running element.

        """
        if self.current_page in store[name]:
            # A value was assigned on this page
            first_string = store[name][self.current_page][0]
            last_string = store[name][self.current_page][-1]
            if keyword == 'first':
                return first_string
            elif keyword == 'start':
                element = page
                while element:
                    if element.style['string_set'] != 'none':
                        for (string_name, _) in element.style['string_set']:
                            if string_name == name:
                                return first_string
                    if element.children:
                        element = element.children[0]
                        continue
                    break
            elif keyword == 'last':
                return last_string
            elif keyword == 'first-except':
                return
        # Search backwards through previous pages
        for previous_page in range(self.current_page - 1, 0, -1):
            if previous_page in store[name]:
                return store[name][previous_page][-1]

    def layout_footnote(self, footnote):
        """Add a footnote to the layout for this page."""
        self.footnotes.remove(footnote)
        self.current_page_footnotes.append(footnote)
        return self._update_footnote_area()

    def unlayout_footnote(self, footnote):
        """Remove a footnote from the layout and return it to the waitlist."""
        # TODO: Handle unlayouting a footnote that hasn't been laid out yet or
        # has already been unlayouted
        if footnote not in self.footnotes:
            self.footnotes.append(footnote)
            if footnote in self.current_page_footnotes:
                self.current_page_footnotes.remove(footnote)
            elif footnote in self.reported_footnotes:
                self.reported_footnotes.remove(footnote)
            self._update_footnote_area()

    def report_footnote(self, footnote):
        """Mark a footnote as being moved to the next page."""
        self.current_page_footnotes.remove(footnote)
        self.reported_footnotes.append(footnote)
        self._update_footnote_area()

    def _update_footnote_area(self):
        """Update the page bottom size and our footnote area height."""
        if self.current_footnote_area.height != 'auto' and not self.in_column:
            self.page_bottom += self.current_footnote_area.margin_height()
        self.current_footnote_area.children = self.current_page_footnotes
        if self.current_footnote_area.children:
            footnote_area = build.create_anonymous_boxes(
                self.current_footnote_area.deepcopy())
            footnote_area = block_level_layout(
                self, footnote_area, -inf, None,
                self.current_footnote_area.page)[0]
            self.current_footnote_area.height = footnote_area.height
            if not self.in_column:
                self.page_bottom -= footnote_area.margin_height()
            last_child = footnote_area.children[-1]
            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
            if not self.in_column:
                self.page_bottom -= self.current_footnote_area.margin_height()
            return False


================================================
FILE: weasyprint/layout/absolute.py
================================================
"""Absolutely positioned boxes management."""

from ..formatting_structure import boxes
from .min_max import handle_min_max_width
from .percent import resolve_percentages, resolve_position_percentages
from .preferred import shrink_to_fit
from .replaced import inline_replaced_box_width_height
from .table import table_wrapper_width


class AbsolutePlaceholder:
    """Left where an absolutely-positioned box was taken out of the flow."""
    def __init__(self, box):
        assert not isinstance(box, AbsolutePlaceholder)
        # Work around the overloaded __setattr__
        object.__setattr__(self, '_box', box)
        object.__setattr__(self, '_layout_done', False)

    def set_laid_out_box(self, new_box):
        object.__setattr__(self, '_box', new_box)
        object.__setattr__(self, '_layout_done', True)

    def translate(self, dx=0, dy=0, ignore_floats=False):
        if dx == dy == 0:
            return
        if self._layout_done:
            self._box.translate(dx, dy, ignore_floats)
        else:
            # Descendants do not have a position yet.
            self._box.position_x += dx
            self._box.position_y += dy

    def copy(self):
        new_placeholder = AbsolutePlaceholder(self._box.copy())
        object.__setattr__(new_placeholder, '_layout_done', self._layout_done)
        return new_placeholder

    # Pretend to be the box itself
    def __getattr__(self, name):
        return getattr(self._box, name)

    def __setattr__(self, name, value):
        setattr(self._box, name, value)

    def __repr__(self):
        return '<Placeholder %r>' % self._box


@handle_min_max_width
def absolute_width(box, context, cb_x, cb_y, cb_width, cb_height):
    # https://www.w3.org/TR/CSS2/visudet.html#abs-replaced-width
    ltr = (
        box.style.parent_style is None or
        box.style.parent_style['direction'] == 'ltr')
    paddings_borders = (
        box.padding_left + box.padding_right +
        box.border_left_width + box.border_right_width)
    translate_x = 0
    translate_box_width = False
    default_translate_x = cb_x - box.position_x

    if box.left == box.right == box.width == 'auto':
        if box.margin_left == 'auto':
            box.margin_left = 0
        if box.margin_right == 'auto':
            box.margin_right = 0
        available_width = cb_width - (
            paddings_borders + box.margin_left + box.margin_right)
        box.width = shrink_to_fit(context, box, available_width)
        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':
        width_for_margins = cb_width - (
            box.right + box.left + box.width + paddings_borders)
        if box.margin_left == box.margin_right == 'auto':
            if box.width + paddings_borders + box.right + box.left <= cb_width:
                box.margin_left = box.margin_right = width_for_margins / 2
            else:
                box.margin_left = 0 if ltr else width_for_margins
                box.margin_right = width_for_margins if ltr else 0
        elif box.margin_left == 'auto':
            box.margin_left = width_for_margins
        elif box.margin_right == 'auto':
            box.margin_right = width_for_margins
        elif ltr:
            box.margin_right = width_for_margins
        else:
            box.margin_left = width_for_margins
        translate_x = box.left + default_translate_x
    else:
        if box.margin_left == 'auto':
            box.margin_left = 0
        if box.margin_right == 'auto':
            box.margin_right = 0
        spacing = paddings_borders + box.margin_left + box.margin_right
        if box.left == box.width == 'auto':
            box.width = shrink_to_fit(
                context, box, cb_width - spacing - box.right)
            translate_x = cb_width - box.right - spacing + default_translate_x
            translate_box_width = True
        elif box.left == box.right == 'auto':
            if not ltr:
                available_width = cb_width - (
                    paddings_borders + box.margin_left + box.margin_right)
                translate_box_width = True
                translate_x = default_translate_x + available_width
        elif box.width == box.right == 'auto':
            box.width = shrink_to_fit(
                context, box, cb_width - spacing - box.left)
            translate_x = box.left + default_translate_x
        elif box.left == 'auto':
            translate_x = cb_width + default_translate_x - (
                box.right + spacing + box.width)
        elif box.width == 'auto':
            box.width = cb_width - box.right - box.left - spacing
            translate_x = box.left + default_translate_x
        elif box.right == 'auto':
            translate_x = box.left + default_translate_x

    return translate_box_width, translate_x


def absolute_height(box, context, cb_x, cb_y, cb_width, cb_height):
    # https://www.w3.org/TR/CSS2/visudet.html#abs-non-replaced-height
    paddings_borders = (
        box.padding_top + box.padding_bottom +
        box.border_top_width + box.border_bottom_width)
    translate_y = 0
    translate_box_height = False
    default_translate_y = cb_y - box.position_y

    if box.top == box.bottom == box.height == 'auto':
        # Keep the static position
        if box.margin_top == 'auto':
            box.margin_top = 0
        if box.margin_bottom == 'auto':
            box.margin_bottom = 0
    elif 'auto' not in (box.top, box.bottom, box.height):
        height_for_margins = cb_height - (
            box.top + box.bottom + box.height + paddings_borders)
        if box.margin_top == box.margin_bottom == 'auto':
            box.margin_top = box.margin_bottom = height_for_margins / 2
        elif box.margin_top == 'auto':
            box.margin_top = height_for_margins
        elif box.margin_bottom == 'auto':
            box.margin_bottom = height_for_margins
        else:
            box.margin_bottom = height_for_margins
        translate_y = box.top + default_translate_y
    else:
        if box.margin_top == 'auto':
            box.margin_top = 0
        if box.margin_bottom == 'auto':
            box.margin_bottom = 0
        spacing = paddings_borders + box.margin_top + box.margin_bottom
        if box.top == box.height == 'auto':
            translate_y = (
                cb_height - box.bottom - spacing + default_translate_y)
            translate_box_height = True
        elif box.top == box.bottom == 'auto':
            pass  # Keep the static position
        elif box.height == box.bottom == 'auto':
            translate_y = box.top + default_translate_y
        elif box.top == 'auto':
            translate_y = cb_height + default_translate_y - (
                box.bottom + spacing + box.height)
        elif box.height == 'auto':
            box.height = cb_height - box.bottom - box.top - spacing
            translate_y = box.top + default_translate_y
        elif box.bottom == 'auto':
            translate_y = box.top + default_translate_y

    return translate_box_height, translate_y


def absolute_block(context, box, containing_block, fixed_boxes, bottom_space,
                   skip_stack, cb_x, cb_y, cb_width, cb_height):
    from .block import block_container_layout
    from .flex import flex_layout
    from .grid import grid_layout

    translate_box_width, translate_x = absolute_width(
        box, context, cb_x, cb_y, cb_width, cb_height)
    if skip_stack:
        translate_box_height, translate_y = False, 0
    else:
        translate_box_height, translate_y = absolute_height(
            box, context, cb_x, cb_y, cb_width, cb_height)

    bottom_space += -box.position_y if translate_box_height else translate_y

    # This box is the containing block for absolute descendants.
    absolute_boxes = []

    if box.is_table_wrapper:
        table_wrapper_width(context, box, (cb_width, cb_height))

    if isinstance(box, (boxes.BlockBox)):
        new_box, resume_at, _, _, _, _ = block_container_layout(
            context, box, bottom_space, 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)
    elif isinstance(box, (boxes.FlexContainerBox)):
        new_box, resume_at, _, _, _ = flex_layout(
            context, box, bottom_space, skip_stack, containing_block,
            page_is_empty=True, absolute_boxes=absolute_boxes,
            fixed_boxes=fixed_boxes, discard=False)
    elif isinstance(box, (boxes.GridContainerBox)):
        new_box, resume_at, _, _, _ = grid_layout(
            context, box, bottom_space, skip_stack, containing_block,
            page_is_empty=True, absolute_boxes=absolute_boxes,
            fixed_boxes=fixed_boxes)

    for child_placeholder in absolute_boxes:
        absolute_layout(
            context, child_placeholder, new_box, fixed_boxes, bottom_space,
            skip_stack=None)

    if translate_box_width:
        translate_x -= new_box.width
    if translate_box_height:
        translate_y -= new_box.height
    new_box.translate(translate_x, translate_y)

    return new_box, resume_at


def absolute_layout(context, placeholder, containing_block, fixed_boxes,
                    bottom_space, skip_stack):
    """Set the width of absolute positioned ``box``."""
    assert not placeholder._layout_done
    box = placeholder._box
    new_box, resume_at = absolute_box_layout(
        context, box, containing_block, fixed_boxes, bottom_space, skip_stack)
    placeholder.set_laid_out_box(new_box)
    if resume_at:
        context.add_broken_out_of_flow(placeholder, box, containing_block, resume_at)


def absolute_box_layout(context, box, containing_block, fixed_boxes,
                        bottom_space, skip_stack):
    # TODO: handle inline boxes (point 10.1.4.1)
    # https://www.w3.org/TR/CSS2/visudet.html#containing-block-details
    if isinstance(containing_block, boxes.PageBox):
        cb_x = containing_block.content_box_x()
        cb_y = containing_block.content_box_y()
        cb_width = containing_block.width
        cb_height = containing_block.height
    else:
        cb_x = containing_block.padding_box_x()
        cb_y = containing_block.padding_box_y()
        cb_width = containing_block.padding_width()
        cb_height = containing_block.padding_height()

    resolve_percentages(box, (cb_width, cb_height))
    resolve_position_percentages(box, (cb_width, cb_height))

    if isinstance(box, boxes.BlockReplacedBox):
        new_box = absolute_replaced(
            context, box, cb_x, cb_y, cb_width, cb_height)
        resume_at = None
    else:
        # Absolute tables are wrapped into block boxes
        new_box, resume_at = absolute_block(
            context, box, containing_block, fixed_boxes, bottom_space,
            skip_stack, cb_x, cb_y, cb_width, cb_height)

    return new_box, resume_at


def absolute_replaced(context, box, cb_x, cb_y, cb_width, cb_height):
    inline_replaced_box_width_height(box, (cb_x, cb_y, cb_width, cb_height))
    ltr = (
        box.style.parent_style is None or
        box.style.parent_style['direction'] == 'ltr')

    # https://www.w3.org/TR/CSS21/visudet.html#abs-replaced-width
    if box.left == box.right == 'auto':
        # static position:
        if ltr:
            box.left = box.position_x - cb_x
        else:
            box.right = cb_x + cb_width - box.position_x
    if 'auto' in (box.left, box.right):
        if box.margin_left == 'auto':
            box.margin_left = 0
        if box.margin_right == 'auto':
            box.margin_right = 0
        remaining = cb_width - box.margin_width()
        if box.left == 'auto':
            box.left = remaining - box.right
        if box.right == 'auto':
            box.right = remaining - box.left
    elif 'auto' in (box.margin_left, box.margin_right):
        remaining = cb_width - (box.border_width() + box.left + box.right)
        if box.margin_left == box.margin_right == 'auto':
            if remaining >= 0:
                box.margin_left = box.margin_right = remaining // 2
            else:
                box.margin_left = 0 if ltr else remaining
                box.margin_right = remaining if ltr else 0
        elif box.margin_left == 'auto':
            box.margin_left = remaining
        else:
            box.margin_right = remaining
    else:
        # Over-constrained
        if ltr:
            box.right = cb_width - (box.margin_width() + box.left)
        else:
            box.left = cb_width - (box.margin_width() + box.right)

    # https://www.w3.org/TR/CSS21/visudet.html#abs-replaced-height
    if box.top == box.bottom == 'auto':
        box.top = box.position_y - cb_y
    if 'auto' in (box.top, box.bottom):
        if box.margin_top == 'auto':
            box.margin_top = 0
        if box.margin_bottom == 'auto':
            box.margin_bottom = 0
        remaining = cb_height - box.margin_height()
        if box.top == 'auto':
            box.top = remaining - box.bottom
        if box.bottom == 'auto':
            box.bottom = remaining - box.top
    elif 'auto' in (box.margin_top, box.margin_bottom):
        remaining = cb_height - (box.border_height() + box.top + box.bottom)
        if box.margin_top == box.margin_bottom == 'auto':
            box.margin_top = box.margin_bottom = remaining // 2
        elif box.margin_top == 'auto':
            box.margin_top = remaining
        else:
            box.margin_bottom = remaining
    else:
        # Over-constrained
        box.bottom = cb_height - (box.margin_height() + box.top)

    # No children for replaced boxes, no need to .translate()
    box.position_x = cb_x + box.left
    box.position_y = cb_y + box.top
    return box


================================================
FILE: weasyprint/layout/background.py
================================================
"""Manage background position and size."""

from collections import namedtuple
from itertools import cycle

from tinycss2.color5 import parse_color

from ..formatting_structure import boxes
from . import replaced
from .percent import percentage, resolve_radii_percentages

Background = namedtuple('Background', 'color, layers, style')
BackgroundLayer = namedtuple(
    'BackgroundLayer',
    'image, size, position, repeat, unbounded, '
    'painting_area, positioning_area, clipped_boxes')


def box_rectangle(box, which_rectangle):
    if which_rectangle == 'border-box':
        return (
            box.border_box_x(), box.border_box_y(),
            box.border_width(), box.border_height())
    elif which_rectangle == 'padding-box':
        return (
            box.padding_box_x(), box.padding_box_y(),
            box.padding_width(), box.padding_height())
    else:
        assert which_rectangle == 'content-box', which_rectangle
        return (
            box.content_box_x(), box.content_box_y(),
            box.width, box.height)


def layout_box_backgrounds(page, box, get_image_from_uri, layout_children=True,
                           style=None):
    """Fetch and position background images."""
    from ..draw.color import get_color

    # Resolve percentages in border-radius properties
    resolve_radii_percentages(box)

    if layout_children:
        for child in box.all_children():
            layout_box_backgrounds(page, child, get_image_from_uri)

    if style is None:
        style = box.style

    # This is for the border image, not the background, but this is a
    # convenient place to get the image.
    if style['border_image_source'][0] != 'none':
        type_, value = style['border_image_source']
        if type_ == 'url':
            box.border_image = get_image_from_uri(url=value)
        else:
            box.border_image = value

    if style['mask_border_source'][0] != 'none':
        type_, value = style['mask_border_source']
        if type_ == 'url':
            box.mask_border_image = get_image_from_uri(url=value)
        else:
            box.mask_border_image = value

    if style['visibility'] == 'hidden':
        images = []
        color = parse_color('transparent')
    else:
        orientation = style['image_orientation']
        images = [
            get_image_from_uri(url=value, orientation=orientation)
            if type_ == 'url' else value
            for type_, value in style['background_image']]
        color = get_color(style, 'background_color')

    if color.alpha == 0 and not any(images):
        if box != page:  # Pages need a background for bleed box
            box.background = None
            return

    layers = [
        layout_background_layer(box, page, style['image_resolution'], *layer)
        for layer in zip(images, *map(cycle, [
            style['background_size'],
            style['background_clip'],
            style['background_repeat'],
            style['background_origin'],
            style['background_position'],
            style['background_attachment']]))]
    box.background = Background(color, layers, style)


def layout_background_layer(box, page, resolution, image, size, clip, repeat,
                            origin, position, attachment):

    # TODO: respect box-sizing for table cells?
    clipped_boxes = []
    painting_area = 0, 0, 0, 0
    if box is page:
        # [The page’s] background painting area is the bleed area […]
        # regardless of background-clip.
        # https://drafts.csswg.org/css-page-3/#painting
        painting_area = page.bleed_area
        clipped_boxes = []
    elif isinstance(box, boxes.TableRowGroupBox):
        clipped_boxes = []
        total_height = 0
        for row in box.children:
            if row.children:
                clipped_boxes += [
                    cell.rounded_border_box() for cell in row.children]
                total_height = max(total_height, max(
                    cell.border_height() for cell in row.children))
        painting_area = [
            box.border_box_x(), box.border_box_y(),
            box.border_width(), total_height]
    elif isinstance(box, boxes.TableRowBox):
        if box.children:
            clipped_boxes = [
                cell.rounded_border_box() for cell in box.children]
            height = max(cell.border_height() for cell in box.children)
            painting_area = [
                box.border_box_x(), box.border_box_y(),
                box.border_width(), height]
    elif isinstance(box, (boxes.TableColumnGroupBox, boxes.TableColumnBox)):
        cells = box.get_cells()
        if cells:
            clipped_boxes = [cell.rounded_border_box() for cell in cells]
            min_x = min(cell.border_box_x() for cell in cells)
            max_x = max(
                cell.border_box_x() + cell.border_width() for cell in cells)
            painting_area = [
                min_x, box.border_box_y(), max_x - min_x, box.border_height()]
    else:
        painting_area = box_rectangle(box, clip)
        if clip == 'border-box':
            clipped_boxes = [box.rounded_border_box()]
        elif clip == 'padding-box':
            clipped_boxes = [box.rounded_padding_box()]
        else:
            assert clip == 'content-box', clip
            clipped_boxes = [box.rounded_content_box()]

    if image is not None:
        intrinsic_width, intrinsic_height, ratio = image.get_intrinsic_size(
            resolution, box.style['font_size'])
    if image is None or 0 in (intrinsic_width, intrinsic_height):
        return BackgroundLayer(
            image=None, unbounded=False, painting_area=painting_area,
            size='unused', position='unused', repeat='unused',
            positioning_area='unused', clipped_boxes=clipped_boxes)

    if attachment == 'fixed':
        # Initial containing block
        if isinstance(box, boxes.PageBox):
            # […] if background-attachment is fixed then the image is
            # positioned relative to the page box including its margins […].
            # https://drafts.csswg.org/css-page/#painting
            positioning_area = (0, 0, box.margin_width(), box.margin_height())
        else:
            positioning_area = box_rectangle(page, 'content-box')
    else:
        positioning_area = box_rectangle(box, origin)

    positioning_x, positioning_y, positioning_width, positioning_height = (
        positioning_area)
    painting_x, painting_y, painting_width, painting_height = painting_area

    if size == 'cover':
        image_width, image_height = replaced.cover_constraint_image_sizing(
            positioning_width, positioning_height, ratio)
    elif size == 'contain':
        image_width, image_height = replaced.contain_constraint_image_sizing(
            positioning_width, positioning_height, ratio)
    else:
        size_width, size_height = size
        image_width, image_height = replaced.default_image_sizing(
            intrinsic_width, intrinsic_height, ratio,
            percentage(size_width, box.style, positioning_width),
            percentage(size_height, box.style, positioning_height),
            positioning_width, positioning_height)

    origin_x, position_x, origin_y, position_y = position
    ref_x = positioning_width - image_width
    ref_y = positioning_height - image_height
    position_x = percentage(position_x, box.style, ref_x)
    position_y = percentage(position_y, box.style, ref_y)
    if origin_x == 'right':
        position_x = ref_x - position_x
    if origin_y == 'bottom':
        position_y = ref_y - position_y

    repeat_x, repeat_y = repeat

    if repeat_x == 'round':
        n_repeats = max(1, round(positioning_width / image_width))
        new_width = positioning_width / n_repeats
        position_x = 0  # Ignore background-position for this dimension
        if repeat_y != 'round' and size[1] == 'auto':
            image_height *= new_width / image_width
        image_width = new_width
    if repeat_y == 'round':
        n_repeats = max(1, round(positioning_height / image_height))
        new_height = positioning_height / n_repeats
        position_y = 0  # Ignore background-position for this dimension
        if repeat_x != 'round' and size[0] == 'auto':
            image_width *= new_height / image_height
        image_height = new_height

    return BackgroundLayer(
        image=image,
        size=(image_width, image_height),
        position=(position_x, position_y),
        repeat=repeat,
        unbounded=False,
        painting_area=painting_area,
        positioning_area=positioning_area,
        clipped_boxes=clipped_boxes)


def layout_backgrounds(page, get_image_from_uri):
    """Layout backgrounds on the page box and on its children.

    This function takes care of the canvas background, taken from the root
    elememt or a <body> child of the root element.

    See https://www.w3.org/TR/CSS21/colors.html#background

    """
    layout_box_backgrounds(page, page, get_image_from_uri)
    assert not isinstance(page.children[0], boxes.MarginBox)
    root_box = page.children[0]
    chosen_box = root_box
    if root_box.element_tag.lower() == 'html' and root_box.background is None:
        for child in root_box.children:
            if child.element_tag.lower() == 'body':
                chosen_box = child
                break

    if chosen_box.background:
        painting_area = box_rectangle(page, 'border-box')
        original_background = page.background
        layout_box_backgrounds(
            page, page, get_image_from_uri, layout_children=False,
            style=chosen_box.style)
        page.canvas_background = page.background._replace(
            # TODO: background-clip should be updated
            layers=[
                layer._replace(painting_area=painting_area)
                for layer in page.background.layers])
        page.background = original_background
        chosen_box.background = None
    else:
        page.canvas_background = None


================================================
FILE: weasyprint/layout/block.py
================================================
"""Page breaking and layout for block-level and block-container boxes."""

from functools import partial
from math import inf

from ..formatting_structure import boxes
from .absolute import AbsolutePlaceholder, absolute_layout
from .column import columns_layout
from .flex import flex_layout
from .float import avoid_collisions, float_layout, get_clearance
from .grid import grid_layout
from .inline import iter_line_boxes
from .percent import percentage, resolve_percentages, resolve_position_percentages
from .replaced import block_replaced_box_layout
from .table import table_layout, table_wrapper_width


def block_level_layout(context, box, bottom_space, skip_stack, containing_block,
                       page_is_empty=True, absolute_boxes=None, fixed_boxes=None,
                       adjoining_margins=None, first_letter_style=None,
                       first_line_style=None, discard=False, max_lines=None):
    """Lay out the block-level ``box``."""
    absolute_boxes = [] if absolute_boxes is None else absolute_boxes
    fixed_boxes = [] if fixed_boxes is None else fixed_boxes
    adjoining_margins = [] if adjoining_margins is None else adjoining_margins

    if not isinstance(box, boxes.TableBox):
        resolve_percentages(box, containing_block)

        if box.margin_top == 'auto':
            box.margin_top = 0
        if box.margin_bottom == 'auto':
            box.margin_bottom = 0

        if context.current_page > 1 and page_is_empty:
            # When an unforced break occurs before or after a block-level box,
            # any margins adjoining the break are truncated to zero.
            # TODO: this condition is wrong, it only works for blocks whose
            # parent breaks collapsing margins. It should work for blocks whose
            # one of the ancestors breaks collapsing margins.
            # See test_margin_break_clearance.
            collapse_with_page = (
                containing_block.is_for_root_element or adjoining_margins)
            if collapse_with_page:
                if box.style['margin_break'] == 'discard':
                    box.margin_top = 0
                elif box.style['margin_break'] == 'auto':
                    if not context.forced_break:
                        box.margin_top = 0

        collapsed_margin = collapse_margin([*adjoining_margins, box.margin_top])
        direction = containing_block.style['direction']
        box.clearance = get_clearance(context, box, direction, collapsed_margin)
        if box.clearance is not None:
            top_border_edge = box.position_y + collapsed_margin + box.clearance
            box.position_y = top_border_edge - box.margin_top
            adjoining_margins = []

    return block_level_layout_switch(
        context, box, bottom_space, skip_stack, containing_block, page_is_empty,
        absolute_boxes, fixed_boxes, adjoining_margins, first_letter_style,
        first_line_style, discard, max_lines)


def block_level_layout_switch(context, box, bottom_space, skip_stack, containing_block,
                              page_is_empty, absolute_boxes, fixed_boxes,
                              adjoining_margins, first_letter_style, first_line_style,
                              discard, max_lines):
    """Call the layout function corresponding to the ``box`` type."""
    if isinstance(box, boxes.TableBox):
        result = table_layout(
            context, box, bottom_space, skip_stack, containing_block,
            page_is_empty, absolute_boxes, fixed_boxes)
    elif isinstance(box, boxes.BlockBox):
        return block_box_layout(
            context, box, bottom_space, skip_stack, containing_block,
            page_is_empty, absolute_boxes, fixed_boxes, adjoining_margins,
            first_letter_style, first_line_style, discard, max_lines)
    elif isinstance(box, boxes.BlockReplacedBox):
        result = block_replaced_box_layout(context, box, containing_block)
    elif isinstance(box, boxes.FlexBox):
        result = flex_layout(
            context, box, bottom_space, skip_stack, containing_block,
            page_is_empty, absolute_boxes, fixed_boxes, discard)
    elif isinstance(box, boxes.GridBox):
        result = grid_layout(
            context, box, bottom_space, skip_stack, containing_block,
            page_is_empty, absolute_boxes, fixed_boxes)
    else:  # pragma: no cover
        raise TypeError(f'Layout for {type(box).__name__} not handled yet')
    return (*result, None)


def block_box_layout(context, box, bottom_space, skip_stack,
                     containing_block, page_is_empty, absolute_boxes,
                     fixed_boxes, adjoining_margins, first_letter_style,
                     first_line_style, discard, max_lines):
    """Lay out the block ``box``."""
    if (box.style['column_width'] != 'auto' or
            box.style['column_count'] != 'auto'):
        result = columns_layout(
            context, box, bottom_space, skip_stack, containing_block, page_is_empty,
            absolute_boxes, fixed_boxes, adjoining_margins, first_letter_style,
            first_line_style)
        resume_at = result[1]
        # TODO: this condition and the whole relayout are probably wrong
        if resume_at is None:
            new_box = result[0]
            columns_bottom_space = (
                new_box.margin_bottom + new_box.padding_bottom +
                new_box.border_bottom_width)
            if columns_bottom_space:
                remove_placeholders(
                    context, [new_box], absolute_boxes, fixed_boxes)
                bottom_space += columns_bottom_space
                result = columns_layout(
                    context, box, bottom_space, skip_stack, containing_block,
                    page_is_empty, absolute_boxes, fixed_boxes, adjoining_margins,
                    first_letter_style, first_line_style)
        return (*result, None)
    elif box.is_table_wrapper:
        table_wrapper_width(
            context, box, (containing_block.width, containing_block.height))
    block_level_width(box, containing_block)

    result = block_container_layout(
        context, box, bottom_space, skip_stack, page_is_empty, absolute_boxes,
        fixed_boxes, adjoining_margins, first_letter_style, first_line_style, discard,
        max_lines)
    # TODO: columns and flex items shouldn't be block boxes, this condition
    # would then be useless when this is fixed.
    if not (new_box := result[0]) or new_box.is_column or new_box.is_flex_item:
        return result
    if new_box.is_table_wrapper or new_box.establishes_formatting_context():
        # Don't collide with floats
        # https://www.w3.org/TR/CSS21/visuren.html#floats
        position_x, position_y, _ = avoid_collisions(
            context, new_box, containing_block, outer=False)
        new_box.translate(
            position_x - new_box.position_x, position_y - new_box.position_y)
    return result


def block_level_width(box, containing_block, with_min_max=True):
    """Set the ``box`` width."""
    # 'cb' stands for 'containing block'
    if isinstance(containing_block, boxes.Box):
        cb_width = containing_block.width
        direction = containing_block.style['direction']
    else:
        cb_width = containing_block[0]
        # TODO: what is the real text direction?
        direction = 'ltr'

    padding_plus_border = (
        box.padding_left + box.padding_right +
        box.border_left_width + box.border_right_width)

    # See https://www.w3.org/TR/CSS21/visudet.html#blockwidth.
    # Set width. Only margin-left, margin-right and width can be 'auto'.
    # We want:  width of containing block ==
    #               margin-left + border-left-width + padding-left + width
    #               + padding-right + border-right-width + margin-right
    if box.width == 'auto':
        box.width = cb_width - padding_plus_border
        if box.margin_left != 'auto':
            box.width -= box.margin_left
        if box.margin_right != 'auto':
            box.width -= box.margin_right
    if with_min_max:
        box.width = max(box.min_width, min(box.max_width, box.width))

    # Set auto margins to 0 for boxes larger than containing block.
    margin_width = padding_plus_border + box.width
    if box.margin_left != 'auto':
        margin_width += box.margin_left
    if box.margin_right != 'auto':
        margin_width += box.margin_right
    if margin_width > cb_width:
        if box.margin_left == 'auto':
            box.margin_left = 0
        if box.margin_right == 'auto':
            box.margin_right = 0

    # Right-align right-to-left boxes.
    if direction == 'rtl' and not box.is_column:
        box.position_x += cb_width - padding_plus_border - box.width
        if box.margin_left != 'auto':
            box.position_x -= box.margin_left
        if box.margin_right != 'auto':
            box.position_x -= box.margin_right

    # Set margins according to width.
    margin_sum = cb_width - padding_plus_border - box.width
    if box.margin_left == box.margin_right == 'auto':
        box.margin_left = margin_sum / 2
        box.margin_right = margin_sum / 2
    elif box.margin_left == 'auto' and box.margin_right != 'auto':
        box.margin_left = margin_sum - box.margin_right
    elif box.margin_left != 'auto' and box.margin_right == 'auto':
        box.margin_right = margin_sum - box.margin_left


block_level_width.without_min_max = partial(block_level_width, with_min_max=False)


def relative_positioning(box, containing_block):
    """Translate the ``box`` if it is relatively positioned."""
    if box.style['position'] == 'relative':
        resolve_position_percentages(box, containing_block)

        if box.left != 'auto' and box.right != 'auto':
            if box.style['direction'] == 'ltr':
                translate_x = box.left
            else:
                translate_x = -box.right
        elif box.left != 'auto':
            translate_x = box.left
        elif box.right != 'auto':
            translate_x = -box.right
        else:
            translate_x = 0

        if box.top != 'auto':
            translate_y = box.top
        elif box.bottom != 'auto':
            translate_y = -box.bottom
        else:
            translate_y = 0

        box.translate(translate_x, translate_y)

    if isinstance(box, (boxes.InlineBox, boxes.LineBox)):
        for child in box.children:
            relative_positioning(child, containing_block)


def _out_of_flow_layout(context, box, index, child, new_children,
                        page_is_empty, absolute_boxes, fixed_boxes,
                        adjoining_margins, bottom_space):
    stop = False  # whether we should stop parent rendering after this layout
    resume_at = None  # where to resume in-flow rendering
    new_child = None  # child rendered by this layout
    out_of_flow_resume_at = None  # where to resume out-of-flow rendering

    # Add the parent’s collapsing margins to shift the child’s position. Don’t
    # include the out-of-flow child’s top margin because it doesn’t collapse
    # with its parent.
    child.position_y += collapse_margin(adjoining_margins)

    # Absolute child layout: create placeholder.
    if child.is_absolutely_positioned():
        new_child = placeholder = AbsolutePlaceholder(child)
        placeholder.index = index
        new_children.append(placeholder)
        if child.style['position'] == 'absolute':
            absolute_boxes.append(placeholder)
        else:
            fixed_boxes.append(placeholder)

    # Float child layout.
    elif child.is_floated():
        new_child, out_of_flow_resume_at = float_layout(
            context, child, box, absolute_boxes, fixed_boxes, bottom_space,
            skip_stack=None)

        # Check that child doesn’t overflow page.
        page_overflow = context.overflows_page(
            bottom_space, new_child.position_y + new_child.height)
        add_child = (
            (page_is_empty and not new_children) or
            not page_overflow or
            box.is_monolithic())
        if add_child:
            # Child fits or has to fit, add it.
            new_child.index = index
            new_children.append(new_child)
        else:
            # Child doesn’t fit and we can break, find where to break and stop
            # parent rendering.
            last_in_flow_child = find_last_in_flow_child(new_children)
            page_break = block_level_page_break(last_in_flow_child, child)
            resume_at = {index: None}
            out_of_flow_resume_at = None
            stop = True
            if new_children and avoid_page_break(page_break, context):
                # Can’t break inside float, find an earlier page break.
                result = find_earlier_page_break(
                    context, new_children, absolute_boxes, fixed_boxes)
                if result:
                    # Earlier page break found, drop whole child rendering.
                    new_children[:], resume_at = result
                    new_child = None

    # Running element layout.
    elif child.is_running():
        running_name = child.style['position'][1]
        page = context.current_page
        context.running_elements[running_name][page].append(child)

    return stop, resume_at, new_child, out_of_flow_resume_at


def _break_line(context, box, line, new_children, needed, 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
        # enough lines for orphans, cancel the whole box.
        remove_placeholders(context, line.children, absolute_boxes, fixed_boxes)
        return True, False, resume_at
    # How many lines we need on the next page to satisfy widows
    # -1 for the current line.
    if needed > over_orphans and not page_is_empty:
        # Total number of lines < orphans + widows
        remove_placeholders(context, line.children, absolute_boxes, fixed_boxes)
        return True, False, resume_at
    if needed and needed <= over_orphans:
        # Remove lines to keep them for the next page
        for child in new_children[-needed:]:
            remove_placeholders(
                context, child.children, absolute_boxes, fixed_boxes)
        del new_children[-needed:]
    # Page break here, resume before this line
    remove_placeholders(context, line.children, absolute_boxes, fixed_boxes)
    return False, True, {index: skip_stack}


def _linebox_layout(context, box, index, child, new_children, page_is_empty,
                    absolute_boxes, fixed_boxes, adjoining_margins,
                    bottom_space, position_y, skip_stack, first_letter_style,
                    first_line_style, draw_bottom_decoration, max_lines):
    abort = stop = False
    resume_at = None
    new_footnotes = []

    assert len(box.children) == 1, 'line box with siblings before layout'

    if adjoining_margins:
        position_y += collapse_margin(adjoining_margins)
    new_containing_block = box
    lines_iterator = iter_line_boxes(
        context, child, position_y, bottom_space, skip_stack, new_containing_block,
        absolute_boxes, fixed_boxes, first_letter_style, first_line_style)
    for i, (line, resume_at) in enumerate(lines_iterator):
        # Break box if we reached max-lines
        if max_lines is not None:
            if max_lines == 0:
                new_children[-1].block_ellipsis = box.style['block_ellipsis']
                break
            max_lines -= 1

        # Update line resume_at and position_y
        line.resume_at = resume_at
        new_position_y = line.position_y + line.height

        # Add bottom padding and border to the bottom position of the
        # box if needed
        draw_bottom_decoration |= resume_at is None
        if draw_bottom_decoration:
            offset_y = box.border_bottom_width + box.padding_bottom
        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.
        overflow = (
            (new_children or not page_is_empty) and
            context.overflows_page(bottom_space, new_position_y + offset_y))
        if overflow:
            # 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
            needed = box.style['widows'] - 1
            for _ in lines_iterator:
                needed -= 1
                # Don’t iterate over all lines as it can be long.
                if needed == -1:
                    break
            if len(new_children) + 1 < box.style['orphans']:
                can_break_now = False
            elif needed >= 0:
                can_break_now = False
            if len(new_children) < box.style['orphans']:
                could_break_before = False
            elif needed > 0:
                could_break_before = False
            needed = max(0, needed)
            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, needed, 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 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
            # too high to be drawn in one page
            new_position_y -= box.margin_top
            line.translate(0, -box.margin_top)
            box.margin_top = 0

        if context.footnotes:
            break_linebox = False
            footnotes = (
                descendant.footnote for descendant in line.descendants()
                if descendant.footnote in context.footnotes)
            for footnote in footnotes:
                overflow = context.layout_footnote(footnote)
                new_footnotes.append(footnote)
                overflow = (
                    overflow or
                    context.reported_footnotes or
                    context.overflows_page(bottom_space, new_position_y + offset_y))
                if overflow:
                    context.report_footnote(footnote)
                    # If we've put other content on this page, then we may want
                    # to push this line or block to the next page. Otherwise,
                    # we can't (and would loop forever if we tried), so don't
                    # even try.
                    if new_children or not page_is_empty:
                        if footnote.style['footnote_policy'] == 'line':
                            if needed := box.style['widows'] - 1:
                                for _ in lines_iterator:
                                    needed -= 1
                                    # Don’t iterate over all lines as it can be long.
                                    if needed == 0:
                                        break
                            abort, stop, resume_at = _break_line(
                                context, box, line, new_children, needed, page_is_empty,
                                index, skip_stack, resume_at, absolute_boxes,
                                fixed_boxes)
                            break_linebox = True
                            break
                        elif footnote.style['footnote_policy'] == 'block':
                            abort = break_linebox = True
                            break
            if break_linebox:
                break

        new_children.append(line)
        position_y = new_position_y
        skip_stack = resume_at

    if new_children:
        resume_at = {index: new_children[-1].resume_at}

    return abort, stop, resume_at, position_y, new_footnotes, max_lines


def _in_flow_layout(context, box, index, child, new_children, page_is_empty,
                    absolute_boxes, fixed_boxes, adjoining_margins, bottom_space,
                    position_y, skip_stack, first_letter_style, first_line_style,
                    discard, next_page, max_lines):
    abort = stop = False

    # Find possible page break between in-flow siblings.
    last_in_flow_child = find_last_in_flow_child(new_children)
    if last_in_flow_child is not None:
        page_break = block_level_page_break(last_in_flow_child, child)
        page_name = block_level_page_name(last_in_flow_child, child)
        if page_name or force_page_break(page_break, context):
            page_name = child.page_values()[0]
            next_page = {'break': page_break, 'page': page_name}
            resume_at = {index: None}
            stop = True
            return (
                abort, stop, resume_at, position_y, adjoining_margins,
                next_page, new_children, max_lines)
    else:
        page_break = 'auto'

    # Resolve percentages and collapsing top margins.
    if not box.is_table_wrapper:
        resolve_percentages(child, box)
        if last_in_flow_child is None and box.top_margin_collapses():
            # TODO: add the adjoining descendants' margin top to
            # [child.margin_top].
            old_collapsed_margin = collapse_margin(adjoining_margins)
            # TODO: the margin-top value is set afterwards in
            # block_level_layout, we shouldn’t duplicate this code.
            child_margin_top = child.margin_top
            if child_margin_top == 'auto':
                child_margin_top = 0
            elif context.current_page > 1 and page_is_empty:
                if box.style['margin_break'] == 'discard':
                    child_margin_top = 0
                elif box.style['margin_break'] == 'auto':
                    if not context.forced_break:
                        child_margin_top = 0
            new_collapsed_margin = collapse_margin(
                [*adjoining_margins, child_margin_top])
            collapsed_margin_difference = (
                new_collapsed_margin - old_collapsed_margin)
            for previous_new_child in new_children:
                previous_new_child.translate(dy=collapsed_margin_difference)
            direction = box.style['direction']
            clearance = get_clearance(context, child, direction, new_collapsed_margin)
            if clearance is not None:
                for previous_new_child in new_children:
                    previous_new_child.translate(
                        dy=-collapsed_margin_difference)

                collapsed_margin = collapse_margin(adjoining_margins)
                box.position_y += collapsed_margin - box.margin_top
                # Count box.margin_top as we emptied adjoining_margins
                adjoining_margins = []
                position_y = box.content_box_y()

    # TODO: Merge this with block_container_layout, block_level_layout, _in_flow_layout,
    # and check code above.
    if adjoining_margins:
        if box.is_table_wrapper:  # should not be a special case
            collapsed_margin = collapse_margin(adjoining_margins)
            child.position_y += collapsed_margin
            adjoining_margins = []
        elif not isinstance(child, boxes.BlockBox):  # blocks handle that themselves
            if child.style['margin_top'] == 'auto':
                margin_top = 0
            else:
                margin_top = percentage(
                    child.style['margin_top'], child.style, box.width)
            adjoining_margins.append(margin_top)
            offset_y = collapse_margin(adjoining_margins) - margin_top
            child.position_y += offset_y
            adjoining_margins = []

    page_is_empty_with_no_children = page_is_empty and not any(
        child for child in new_children
        if not isinstance(child, AbsolutePlaceholder))

    (new_child, resume_at, next_page, next_adjoining_margins,
     collapsing_through, max_lines) = block_level_layout(
         context, child, bottom_space, skip_stack, box, page_is_empty_with_no_children,
         absolute_boxes, fixed_boxes, adjoining_margins, first_letter_style,
         first_line_style, discard, max_lines)

    # Check that child doesn’t overflow and set next position_y.
    if new_child is not None:
        if not collapsing_through:
            # Find content position and check that it doesn’t overflow.
            new_content_position_y = new_child.content_box_y() + new_child.height
            content_page_overflow = context.overflows_page(
                bottom_space, new_content_position_y)

            # Update bottom space to include new child bottom spacing and check that it
            # doesn’t overflow.
            bottom_space += new_child.padding_bottom + new_child.border_bottom_width
            if not box.bottom_margin_collapses():
                bottom_space += new_child.margin_bottom
            new_position_y = new_child.border_box_y() + new_child.border_height()
            border_page_overflow = context.overflows_page(bottom_space, new_position_y)

            can_break = not (page_is_empty_with_no_children or box.is_monolithic())
            if can_break and content_page_overflow:
                # Child content overflows the page area, display it on the next page.
                remove_placeholders(context, [new_child], absolute_boxes, fixed_boxes)
                new_child = None
            elif can_break and border_page_overflow:
                # Child border/padding/margin overflows the page area, do the layout
                # again with a bottom_space value that includes them.
                remove_placeholders(context, [new_child], absolute_boxes, fixed_boxes)
                (new_child, resume_at, next_page, next_adjoining_margins,
                 collapsing_through, max_lines) = block_level_layout(
                     context, child, bottom_space, skip_stack, box,
                     page_is_empty_with_no_children, absolute_boxes, fixed_boxes,
                     adjoining_margins, discard, max_lines)
                if new_child:
                    position_y = new_child.border_box_y() + new_child.border_height()
            else:
                position_y = new_position_y

        # Use the new child adjoining margins.
        adjoining_margins = next_adjoining_margins
        if new_child:
            adjoining_margins.append(new_child.margin_bottom)

        # Handle clearance.
        if new_child and new_child.clearance:
            position_y = new_child.border_box_y() + new_child.border_height()

    if new_child is None:
        # Nothing fits in the remaining space of this page: break.
        if avoid_page_break(page_break, context):
            # TODO: fill the blank space at the bottom of the page.
            result = find_earlier_page_break(
                context, new_children, absolute_boxes, fixed_boxes)
            if result:
                new_children, resume_at = result
                stop = True
                return (
                    abort, stop, resume_at, position_y, adjoining_margins,
                    next_page, new_children, max_lines)
            else:
                # We did not find any page break opportunity.
                if not page_is_empty:
                    # The page has content *before* this block: cancel the block and try
                    # to find a break in the parent.
                    abort = True
                    return (
                        abort, stop, resume_at, position_y, adjoining_margins,
                        next_page, new_children, max_lines)
                # else:
                # ignore this 'avoid' and break anyway.

        if all(child.is_absolutely_positioned() for child in new_children):
            # This box has only rendered absolute children, keep them for the next page.
            # This is for example useful for list markers.
            remove_placeholders(context, new_children, absolute_boxes, fixed_boxes)
            new_children = []

        if new_children:
            # We already have children, keep them and stop the box rendering.
            resume_at = {index: None}
            stop = True
        else:
            # This was the first child of this box, cancel the box completly.
            abort = True
        return (
            abort, stop, resume_at, position_y, adjoining_margins, next_page,
            new_children, max_lines)

    # Index in its non-laid-out parent, not in future new parent.
    # May be used in find_earlier_page_break().
    new_child.index = index

    new_children.append(new_child)
    if resume_at is not None:
        resume_at = {index: resume_at}
        stop = True

    return (
        abort, stop, resume_at, position_y, adjoining_margins, next_page,
        new_children, max_lines)


def block_container_layout(context, box, bottom_space, skip_stack, page_is_empty,
                           absolute_boxes, fixed_boxes, adjoining_margins,
                           first_letter_style, first_line_style, discard, max_lines):
    """Set the ``box`` height."""
    assert isinstance(box, boxes.BlockContainerBox)

    if box.establishes_formatting_context():
        context.create_block_formatting_context(box)

    # TODO: merge this with _in_flow_layout, flex_layout…
    is_start = skip_stack is None
    box.remove_decoration(start=not is_start, end=False)

    discard |= box.style['continue'] == 'discard'
    draw_bottom_decoration = discard or box.style['box_decoration_break'] == 'clone'

    if adjoining_margins is None:
        adjoining_margins = []

    if draw_bottom_decoration:
        bottom_space += box.padding_bottom + box.border_bottom_width + box.margin_bottom

    adjoining_margins.append(box.margin_top)
    this_box_adjoining_margins = adjoining_margins

    if box.top_margin_collapses():
        # Not counting margins in adjoining_margins, if any (there are not padding or
        # borders, see above).
        position_y = box.position_y
    else:
        box.position_y += collapse_margin(adjoining_margins) - box.margin_top
        adjoining_margins = []
        position_y = box.content_box_y()

    position_x = box.content_box_x()

    if box.style['position'] == 'relative':
        # New containing block, use a new absolute list.
        absolute_boxes = []

    new_children = []
    next_page = {'break': 'any', 'page': None}

    if box.style['max_lines'] != 'none':
        max_lines = min(box.style['max_lines'], max_lines or inf)

    if box.first_line_style is not None:
        box_first_line_style = {
            key: box.first_line_style[key] for key in box.first_line_style.cascaded}
        if first_line_style is None:
            first_line_style = box_first_line_style
        else:
            first_line_style |= box_first_line_style

    if box.first_letter_style is not None:
        box_first_letter_style = {
            key: box.first_letter_style[key] for key in box.first_letter_style.cascaded}
        if first_letter_style is None:
            first_letter_style = box_first_letter_style
        else:
            first_letter_style |= box_first_letter_style

    # Layout box children.
    if is_start:
        skip = 0
    else:
        (skip, skip_stack), = skip_stack.items()
    for index, child in enumerate(box.children[skip:], start=(skip or 0)):
        child.position_x = position_x
        child.position_y = position_y  # doesn’t count adjoining_margins
        new_footnotes = []

        if not child.is_in_normal_flow():
            # Layout out-of-flow child.
            abort = False
            stop, resume_at, new_child, out_of_flow_resume_at = (
                _out_of_flow_layout(
                    context, box, index, child, new_children, page_is_empty,
                    absolute_boxes, fixed_boxes, adjoining_margins, bottom_space))
            if out_of_flow_resume_at:
                context.add_broken_out_of_flow(
                    new_child, child, box, out_of_flow_resume_at)
            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):
            # Layout line child.
            (abort, stop, resume_at, position_y,
             new_footnotes, max_lines) = _linebox_layout(
                context, box, index, child, new_children, page_is_empty,
                absolute_boxes, fixed_boxes, adjoining_margins, bottom_space,
                position_y, skip_stack, first_letter_style, first_line_style,
                draw_bottom_decoration, max_lines)
            draw_bottom_decoration |= resume_at is None
            adjoining_margins = []
            first_letter_style = first_line_style = None

        else:
            # Layout in-flow child.
            (abort, stop, resume_at, position_y, adjoining_margins,
             next_page, new_children, new_max_lines) = _in_flow_layout(
                 context, box, index, child, new_children, page_is_empty,
                 absolute_boxes, fixed_boxes, adjoining_margins, bottom_space,
                 position_y, skip_stack, first_letter_style, first_line_style,
                 discard, next_page, max_lines)
            skip_stack = None
            first_letter_style = first_line_style = None

            # Handle max-lines.
            if None not in (new_max_lines, max_lines):
                max_lines = new_max_lines
                if max_lines <= 0:
                    # Maximum number of lines reached, stop box rendering.
                    stop = True
                    last_child = (child == box.children[-1])
                    if not last_child:
                        # This is not the last line, recursively find the last line to
                        # set ellipsis on it.
                        children = new_children
                        while children:
                            last_child = children[-1]
                            if isinstance(last_child, boxes.LineBox):
                                last_child.block_ellipsis = box.style['block_ellipsis']
                            elif isinstance(last_child, boxes.ParentBox):
                                children = last_child.children
                                continue
                            break

        if abort:
            # Abort the rendering of box.
            page = child.page_values()[0]
            remove_placeholders(
                context, box.children[skip:], absolute_boxes, fixed_boxes)
            for footnote in new_footnotes:
                context.unlayout_footnote(footnote)
            if box.establishes_formatting_context():
                context.finish_block_formatting_context()
            return (
                None, None, {'break': 'any', 'page': page}, [], False,
                max_lines)
        elif stop:
            # Stop after the rendering of child.
            if box.height != 'auto':
                box_bottom = box.position_y + box.border_height()
                bottom_margin = collapse_margin(adjoining_margins)
                if context.overflows(box_bottom, position_y - bottom_margin):
                    # Box height is fixed and it overflows the page, forget
                    # overflowing children.
                    resume_at = None
            adjoining_margins = []
            break

    else:
        resume_at = None

    box_is_fragmented = resume_at is not None or box.force_fragmentation
    if box.style['continue'] == 'discard':
        resume_at = None

    if (box_is_fragmented and
            avoid_page_break(box.style['break_inside'], context) and
            not page_is_empty):
        remove_placeholders(
            context, [*new_children, *box.children[skip:]], absolute_boxes, fixed_boxes)
        if box.establishes_formatting_context():
            context.finish_block_formatting_context()
        return None, None, {'break': 'any', 'page': None}, [], False, max_lines

    if box.top_margin_collapses():
        box.position_y += collapse_margin(this_box_adjoining_margins) - box.margin_top

    # Detect collapsing-through situation and collapse margins accordingly.
    last_in_flow_child = find_last_in_flow_child(new_children)
    collapsing_through = False
    if last_in_flow_child is None:
        # No in-flow child in box, collapse its top and bottom margins.
        collapsed_margin = collapse_margin(adjoining_margins)
        direction = box.style['direction']  # TODO: should be parent’s one instead
        if (box.height in ('auto', 0) and
            get_clearance(context, box, direction, collapsed_margin) is None and
            all(value == 0 for value in (
                box.min_height, box.border_top_width, box.padding_top,
                box.border_bottom_width, box.padding_bottom))):
            # Collapse through the box.
            collapsing_through = True
        else:
            # Don’t collapse through the box, update position and reset margins.
            position_y += collapsed_margin
            adjoining_margins = []
    else:
        # In-flow children, collapse last child bottom margin and box bottom margin.
        if box.height != 'auto':
            # Not adjoining, reset margins.
            adjoining_margins = []

    if not box.bottom_margin_collapses():
        position_y += collapse_margin(adjoining_margins)
        adjoining_margins = []

    # Add block ellipsis
    if box_is_fragmented and new_children:
        last_child = new_children[-1]
        if isinstance(last_child, boxes.LineBox):
            last_child.block_ellipsis = box.style['block_ellipsis']

    new_box = box.copy_with_children(new_children)
    new_box.remove_decoration(
        start=not is_start, end=box_is_fragmented and not discard)

    # TODO: See corner cases in
    # https://www.w3.org/TR/CSS21/visudet.html#normal-block
    # TODO: See float.float_layout
    if new_box.height == 'auto':
        if context.excluded_shapes and new_box.style['overflow'] != 'visible':
            max_float_position_y = max(
                float_box.position_y + float_box.margin_height()
                for float_box in context.excluded_shapes)
            position_y = max(max_float_position_y, position_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
        for absolute_box in absolute_boxes:
            absolute_layout(
                context, absolute_box, new_box, fixed_boxes, bottom_space,
                skip_stack=None)

    for child in new_box.children:
        relative_positioning(child, (new_box.width, new_box.height))

    if box.establishes_formatting_context():
        context.finish_block_formatting_context(new_box)

    if discard or not box_is_fragmented:
        # After finish_block_formatting_context which may increment
        # new_box.height
        new_box.height = max(
            min(new_box.height, new_box.max_height), new_box.min_height)
    elif bottom_space > -inf and not new_box.is_column:
        # Make the box fill the blank space at the bottom of the page
        # https://www.w3.org/TR/css-break-3/#box-splitting
        new_box_height = (
            context.page_bottom - bottom_space - new_box.position_y -
            (new_box.margin_height() - new_box.height))
        if new_box_height > new_box.height:
            new_box.height = new_box_height
            if draw_bottom_decoration:
                new_box.height += (
                    box.padding_bottom + box.border_bottom_width +
                    box.margin_bottom)

    if next_page['page'] is None:
        next_page['page'] = new_box.page_values()[1]

    return (
        new_box, resume_at, next_page, adjoining_margins, collapsing_through,
        max_lines)


def collapse_margin(adjoining_margins):
    """Get the amount of collapsed margin for a list of adjoining margins."""
    margins = [0]  # add 0 to make sure that max/min don’t get an empty list
    margins.extend(adjoining_margins)
    positives = (m for m in margins if m >= 0)
    negatives = (m for m in margins if m <= 0)
    return max(positives) + min(negatives)


def block_level_page_break(sibling_before, sibling_after):
    """Get the correct page break value between siblings.

    Return the value of ``page-break-before`` or ``page-break-after`` that
    "wins" for boxes that meet at the margin between two sibling boxes.

    For boxes before the margin, the 'page-break-after' value is considered;
    for boxes after the margin the 'page-break-before' value is considered.

    * 'avoid' takes priority over 'auto'
    * 'page' takes priority over 'avoid' or 'auto'
    * 'left' or 'right' take priority over 'always', 'avoid' or 'auto'
    * Among 'left' and 'right', later values in the tree take priority.

    See https://drafts.csswg.org/css-page-3/#allowed-pg-brk

    """
    values = []
    # https://drafts.csswg.org/css-break-3/#possible-breaks
    block_parallel_box_types = (
        boxes.BlockLevelBox, boxes.TableRowGroupBox, boxes.TableRowBox)

    box = sibling_before
    while isinstance(box, block_parallel_box_types):
        values.append(box.style['break_after'])
        if not box.children:
            break
        box = box.children[-1]
    values.reverse()  # Have them in tree order

    box = sibling_after
    while isinstance(box, block_parallel_box_types):
        values.append(box.style['break_before'])
        if not box.children:
            break
        box = box.children[0]

    result = 'auto'
    for value in values:
        if value in ('left', 'right', 'recto', 'verso') or (value, result) in (
                ('page', 'auto'),
                ('page', 'avoid'),
                ('page', 'avoid-page'),
                ('page', 'avoid-column'),
                ('column', 'auto'),
                ('column', 'avoid'),
                ('column', 'avoid-page'),
                ('column', 'avoid-column'),
                ('avoid', 'auto'),
                ('avoid-page', 'auto'),
                ('avoid-column', 'auto')):
            result = value

    return result


def block_level_page_name(sibling_before, sibling_after):
    """Return the next page name when siblings don't have the same names."""
    before_page = sibling_before.page_values()[1]
    after_page = sibling_after.page_values()[0]
    if before_page != after_page:
        return after_page


def find_earlier_page_break(context, children, absolute_boxes, fixed_boxes):
    """Find the last possible page break in ``children``.

    Because of a `page-break-before: avoid` or a `page-break-after: avoid` we
    need to find an earlier page break opportunity inside `children`.

    Absolute or fixed placeholders removed from children should also be
    removed from `absolute_boxes` or `fixed_boxes`.

    Return (new_children, resume_at).

    """
    if children and isinstance(children[0], boxes.LineBox):
        # Normally `orphans` and `widows` apply to the block container, but
        # line boxes inherit them.
        orphans = children[0].style['orphans']
        widows = children[0].style['widows']
        index = len(children) - widows  # how many lines we keep
        if index < orphans:
            return None
        new_children = children[:index]
        resume_at = {0: new_children[-1].resume_at}
        remove_placeholders(
            context, children[index:], absolute_boxes, fixed_boxes)
        return new_children, resume_at

    previous_in_flow = None
    for index, child in reversed_enumerate(children):
        if isinstance(child, boxes.TableRowGroupBox) and (
                child.is_header or child.is_footer):
            # We don’t want to break pages before table headers or footers.
            continue
        elif child.is_column:
            # We don’t want to break pages between columns.
            continue

        if child.is_in_normal_flow():
            page_break = block_level_page_break(child, previous_in_flow)
            if previous_in_flow is not None and (
                    not avoid_page_break(page_break, context)):
                index += 1  # break after child
                new_children = children[:index]
                # Get the index in the original parent
                resume_at = {children[index].index: None}
                break
            previous_in_flow = child

        if child.is_in_normal_flow() and (
                not avoid_page_break(child.style['break_inside'], context)):
            breakable_box_types = (
                boxes.BlockBox, boxes.TableBox, boxes.TableRowGroupBox)
            if isinstance(child, breakable_box_types):
                result = find_earlier_page_break(
                    context, child.children, absolute_boxes, fixed_boxes)
                if result:
                    new_grand_children, resume_at = result
                    new_child = child.copy_with_children(new_grand_children)
                    new_children = [*children[:index], new_child]

                    # Re-add footer at the end of split table
                    # TODO: fix table height and footer position
                    if isinstance(child, boxes.TableRowGroupBox):
                        for next_child in children[index:]:
                            if next_child.is_footer:
                                new_children.append(next_child)

                    # Index in the original parent
                    resume_at = {new_child.index: resume_at}
                    index += 1  # Remove placeholders after child
                    break
    else:
        return None

    # TODO: don’t remove absolute and fixed placeholders found in table footers
    remove_placeholders(context, children[index:], absolute_boxes, fixed_boxes)
    return new_children, resume_at


def find_last_in_flow_child(children):
    """Find and return the last in-flow child of given ``children``."""
    for child in reversed(children):
        if child.is_in_normal_flow():
            return child


def reversed_enumerate(seq):
    """Like reversed(list(enumerate(seq))) without copying the whole seq."""
    return zip(reversed(range(len(seq))), reversed(seq))


def remove_placeholders(context, box_list, absolute_boxes, fixed_boxes):
    """Remove placeholders from absolute and fixed lists.

    For boxes that have been removed in find_earlier_page_break(), remove the
    matching placeholders in absolute_boxes and fixed_boxes.

    Also takes care of removed footnotes and floats.

    """
    for box in box_list:
        if isinstance(box, boxes.ParentBox):
            remove_placeholders(
                context, box.children, absolute_boxes, fixed_boxes)
        if box.style['position'] == 'absolute' and box in absolute_boxes:
            absolute_boxes.remove(box)
        elif box.style['position'] == 'fixed' and box in fixed_boxes:
            fixed_boxes.remove(box)
        if box.footnote:
            context.unlayout_footnote(box.footnote)
        if box in context.broken_out_of_flow:
            context.broken_out_of_flow.pop(box)


def avoid_page_break(page_break, context):
    """Test whether we should avoid breaks."""
    if context.in_column:
        return page_break in ('avoid', 'avoid-page', 'avoid-column')
    return page_break in ('avoid', 'avoid-page')


def force_page_break(page_break, context):
    """Test whether we should force breaks."""
    if context.in_column:
        return page_break in (
            'page', 'left', 'right', 'recto', 'verso', 'column')
    return page_break in ('page', 'left', 'right', 'recto', 'verso')


================================================
FILE: weasyprint/layout/column.py
================================================
"""Layout for columns."""

from math import floor, inf

from .absolute import absolute_layout
from .percent import percentage, resolve_percentages


def columns_layout(context, box, bottom_space, skip_stack, containing_block,
                   page_is_empty, absolute_boxes, fixed_boxes, adjoining_margins,
                   first_letter_style, first_line_style):
    """Lay out a multi-column ``box``."""
    from .block import (  # isort:skip
        block_box_layout, block_level_layout, block_level_width,
        collapse_margin, remove_placeholders)

    style = box.style
    width = style['column_width']
    count = style['column_count']
    height = style['height']
    original_bottom_space = bottom_space
    context.in_column = True

    if style['position'] == 'relative':
        # New containing block, use a new absolute list
        absolute_boxes = []

    box = box.copy_with_children(box.children)
    box.position_y += collapse_margin(adjoining_margins)

    # Set height if defined
    if height != 'auto' and height.unit != '%':
        assert height.unit.lower() == 'px'
        height_defined = True
        empty_space = context.page_bottom - box.content_box_y() - height.value
        bottom_space = max(bottom_space, empty_space)
    else:
        height_defined = False

    # TODO: the columns container width can be unknown if the containing block
    # needs the size of this block to know its own size
    block_level_width(box, containing_block)

    if style['column_gap'] == 'normal':
        # 1em because in column context
        gap = style['font_size']
    else:
        gap = percentage(style['column_gap'], box.style, box.width)

    # Define the number of columns and their widths
    if width == 'auto' and count != 'auto':
        width = max(0, box.width - (count - 1) * gap) / count
    elif width != 'auto' and count == 'auto':
        count = max(1, floor((box.width + gap) / (width + gap)))
        width = (box.width + gap) / count - gap
    else:  # overconstrained, with width != 'auto' and count != 'auto'
        count = max(1, min(count, floor((box.width + gap) / (width + gap))))
        width = (box.width + gap) / count - gap

    # Handle column-span property with the following structure:
    # columns_and_blocks = [
    #     [column_child_1, column_child_2],
    #     spanning_block,
    #     …
    # ]
    columns_and_blocks = []
    column_children = []
    skip, = skip_stack.keys() if skip_stack else (0,)
    for i, child in enumerate(box.children[skip:], start=skip):
        if child.style['column_span'] == 'all':
            if column_children:
                columns_and_blocks.append(
                    (i - len(column_children), column_children))
            columns_and_blocks.append((i, child.copy()))
            column_children = []
            continue
        column_children.append(child.copy())
    if column_children:
        columns_and_blocks.append(
            (i + 1 - len(column_children), column_children))

    if skip_stack:
        skip_stack = {0: skip_stack[skip]}

    if not box.children:
        next_page = {'break': 'any', 'page': None}
        skip_stack = None

    # Find height and balance.
    #
    # The current algorithm starts from the total available height, to check
    # whether the whole content can fit. If it doesn’t fit, we keep the partial
    # rendering. If it fits, we try to balance the columns starting from the
    # ideal height (the total height divided by the number of columns). We then
    # iterate until the last column is not the highest one. At the end of each
    # loop, we add the minimal height needed to make one direct child at the
    # top of one column go to the end of the previous column.
    #
    # We rely on a real rendering for each loop, and with a stupid algorithm
    # like this it can last minutes…

    adjoining_margins = []
    current_position_y = box.content_box_y()
    new_children = []
    column_skip_stack = None
    last_loop = False
    break_page = False
    footnote_area_heights = [
        0 if context.current_footnote_area.height == 'auto'
        else context.current_footnote_area.margin_height()]
    last_footnotes_height = 0
    for index, column_children_or_block in columns_and_blocks:
        if not isinstance(column_children_or_block, list):
            # We have a spanning block, we display it like other blocks
            block = column_children_or_block
            resolve_percentages(block, containing_block)
            block.position_x = box.content_box_x()
            block.position_y = current_position_y
            new_child, resume_at, next_page, adjoining_margins, _, _ = (
                block_level_layout(
                    context, block, original_bottom_space, skip_stack, containing_block,
                    page_is_empty, absolute_boxes, fixed_boxes, adjoining_margins,
                    first_letter_style, first_line_style))
            skip_stack = None
            if new_child is None:
                last_loop = True
                break_page = True
                break
            new_children.append(new_child)
            current_position_y = (
                new_child.border_height() + new_child.border_box_y())
            adjoining_margins.append(new_child.margin_bottom)
            if resume_at:
                last_loop = True
                break_page = True
                column_skip_stack = resume_at
                break
            page_is_empty = False
            continue

        # We have a list of children that we have to balance between columns
        column_children = column_children_or_block

        # Find the total height available for the first run
        current_position_y += collapse_margin(adjoining_margins)
        adjoining_margins = []
        column_box = _create_column_box(
            box, containing_block, column_children, width, current_position_y)
        height = max_height = (
            context.page_bottom - current_position_y - original_bottom_space)

        # Try to render columns until the content fits, increase the column
        # height step by step
        column_skip_stack = skip_stack
        lost_space = inf
        original_excluded_shapes = context.excluded_shapes[:]
        original_page_is_empty = page_is_empty
        page_is_empty = stop_rendering = balancing = False
        while True:
            # Remove extra excluded shapes introduced during the previous loop
            while len(context.excluded_shapes) > len(original_excluded_shapes):
                context.excluded_shapes.pop()

            # Render the columns
            column_skip_stack = skip_stack
            consumed_heights = []
            new_boxes = []
            for i in range(count):
                # Render one column
                new_box, resume_at, next_page, _, _, _ = block_box_layout(
                    context, column_box,
                    context.page_bottom - current_position_y - height,
                    column_skip_stack, containing_block,
                    page_is_empty or not balancing, [], [], [], first_letter_style,
                    first_line_style, discard=False, max_lines=None)
                if new_box is None:
                    # We didn't render anything, retry
                    column_skip_stack = {0: None}
                    break
                new_boxes.append(new_box)
                column_skip_stack = resume_at

                # Calculate consumed height, empty space and next box height
                in_flow_children = [
                    child for child in new_box.children
                    if child.is_in_normal_flow()]
                if in_flow_children:
                    # Get the empty space at the bottom of the column box
                    consumed_height = (
                        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
                    next_box_height = 0
                    if column_skip_stack:
                        next_box = block_box_layout(
                            context, column_box, inf, column_skip_stack,
                            containing_block, True, [], [], [], first_letter_style,
                            first_line_style, discard=False, max_lines=None)[0]
                        for child in next_box.children:
                            if child.is_in_normal_flow():
                                next_box_height = child.margin_height()
                                break
                        remove_placeholders(context, [next_box], [], [])
                else:
                    consumed_height = empty_space = next_box_height = 0

                consumed_heights.append(consumed_height)

                # Append the size needed to render the next box in this
                # column.
                #
                # The next box size may be smaller than the empty space, for
                # example when the next box can't be separated from its own
                # next box. In this case we don't try to find the real value
                # and let the workaround below fix this for us.
                #
                # We also want to avoid very small values that may have been
                # introduced by rounding errors. As the workaround below at
                # least adds 1 pixel for each loop, we can ignore lost spaces
                # lower than 1px.
                if next_box_height - empty_space > 1:
                    lost_space = min(lost_space, next_box_height - empty_space)

                # Stop if we already rendered the whole content
                if resume_at is None:
                    break

            # Remove placeholders but keep the current footnote area height
            last_footnotes_height = (
                0 if context.current_footnote_area.height == 'auto'
                else context.current_footnote_area.margin_height())
            remove_placeholders(context, new_boxes, [], [])

            if last_loop:
                break

            if balancing:
                if column_skip_stack is None:
                    # We rendered the whole content, stop
                    break

                # Increase the column heights and render them again
                add_height = 1 if lost_space == inf else lost_space
                height += add_height

                if height > max_height:
                    # We reached max height, stop rendering
                    height = max_height
                    stop_rendering = True
                    break
            else:
                if last_footnotes_height not in footnote_area_heights:
                    # Footnotes have been rendered, try to re-render with the
                    # new footnote area height
                    height -= last_footnotes_height - footnote_area_heights[-1]
                    footnote_area_heights.append(last_footnotes_height)
                    continue

                everything_fits = (
                    not column_skip_stack and
                    max(consumed_heights) <= max_height)
                if everything_fits:
                    # Everything fits, start expanding columns at the average
                    # of the column heights
                    if (style['column_fill'] == 'balance' or
                            index < columns_and_blocks[-1][0]):
                        balancing = True
                        height = sum(consumed_heights) / count
                    else:
                        break
                else:
                    # Content overflows even at maximum height, stop now and
                    # let the columns continue on the next page
                    stop_rendering = True
                    break

        # TODO: check style['max']-height
        bottom_space = max(
            bottom_space, context.page_bottom - current_position_y - height)

        # Replace the current box children with real columns
        i = 0
        max_column_height = 0
        columns = []
        while True:
            column_box = _create_column_box(
                box, containing_block, column_children, width,
                current_position_y)
            if style['direction'] == 'rtl':
                column_box.position_x += box.width - (i + 1) * width - i * gap
            else:
                column_box.position_x += i * (width + gap)
            new_child, column_skip_stack, column_next_page, _, _, _ = (
                block_box_layout(
                    context, column_box, bottom_space, skip_stack, containing_block,
                    original_page_is_empty, absolute_boxes, fixed_boxes, None,
                    first_letter_style, first_line_style, discard=False,
                    max_lines=None))
            if new_child is None:
                columns = []
                break_page = True
                break
            next_page = column_next_page
            skip_stack = column_skip_stack
            columns.append(new_child)
            max_column_height = max(
                max_column_height, new_child.margin_height())
            if skip_stack is None:
                bottom_space = original_bottom_space
                break
            i += 1
            if i == count and not height_defined:
                # [If] a declaration that constrains the column height
                # (e.g., using height or max-height). In this case,
                # additional column boxes are created in the inline
                # direction.
                break

        # Update the current y position and set the columns’ height
        current_position_y += min(max_height, max_column_height)
        for column in columns:
            column.height = max_column_height
            new_children.append(column)

        skip_stack = None
        page_is_empty = False

        if stop_rendering:
            break

    # Report footnotes above the defined footnotes height
    _report_footnotes(context, footnote_area_heights[-1])

    if box.children and not new_children:
        # The box has children but none can be drawn, let's skip the whole box
        context.in_column = False
        return None, (0, None), {'break': 'any', 'page': None}, [], False

    # Set the height of the containing box
    box.children = new_children
    current_position_y += collapse_margin(adjoining_margins)
    height = current_position_y - box.content_box_y()
    if box.height == 'auto':
        box.height = height
        height_difference = 0
    else:
        height_difference = box.height - height

    # Update the latest columns’ height to respect min-height
    if box.min_height != 'auto' and box.min_height > box.height:
        height_difference += box.min_height - box.height
        box.height = box.min_height
    for child in new_children[::-1]:
        if child.is_column:
            child.height += height_difference
        else:
            break

    if style['position'] == 'relative':
        # New containing block, resolve the layout of the absolute descendants
        for absolute_box in absolute_boxes:
            absolute_layout(
                context, absolute_box, box, fixed_boxes, bottom_space,
                skip_stack=None)

    # Calculate skip stack
    if column_skip_stack:
        skip, = column_skip_stack.keys()
        skip_stack = {index + skip: column_skip_stack[skip]}
    elif break_page:
        skip_stack = {index: None}

    # Update page bottom according to the new footnotes
    if context.current_footnote_area.height != 'auto':
        context.page_bottom += footnote_area_heights[0]
        context.page_bottom -= context.current_footnote_area.margin_height()

    context.in_column = False
    return box, skip_stack, next_page, [], False


def _report_footnotes(context, footnotes_height):
    """Report footnotes above the defined footnotes height."""
    if not context.current_page_footnotes:
        return

    # Report and count footnotes
    reported_footnotes = 0
    while context.current_footnote_area.margin_height() > footnotes_height:
        context.report_footnote(context.current_page_footnotes[-1])
        reported_footnotes += 1

    # 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


def _create_column_box(box, containing_block, children, width, position_y):
    """Create a column box including given children."""
    column_box = box.anonymous_from(box, children=children)
    resolve_percentages(column_box, containing_block)
    column_box.is_column = True
    column_box.width = width
    column_box.position_x = box.content_box_x()
    column_box.position_y = position_y
    return column_box


================================================
FILE: weasyprint/layout/flex.py
================================================
"""Layout for flex containers and flex-items."""

import sys
from math import inf, log10

from ..css.properties import Dimension
from ..formatting_structure import boxes
from . import percent
from .absolute import AbsolutePlaceholder, absolute_layout
from .preferred import max_content_width, min_content_width, min_max
from .table import find_in_flow_baseline, table_wrapper_width


class FlexLine(list):
    """Flex container line."""


def flex_layout(context, box, bottom_space, skip_stack, containing_block, page_is_empty,
                absolute_boxes, fixed_boxes, discard):
    from . import block

    # TODO: merge this with block_container_layout.
    context.create_flex_formatting_context(box)
    resume_at = None
    next_page = {'break': 'any', 'page': None}

    is_start = skip_stack is None
    box.remove_decoration(start=not is_start, end=False)

    discard |= box.style['continue'] == 'discard'
    draw_bottom_decoration = discard or box.style['box_decoration_break'] == 'clone'

    row_gap, column_gap = box.style['row_gap'], box.style['column_gap']

    if draw_bottom_decoration:
        bottom_space += box.padding_bottom + box.border_bottom_width + box.margin_bottom

    if box.style['position'] == 'relative':
        # New containing block, use a new absolute list
        absolute_boxes = []

    # References are to: https://www.w3.org/TR/css-flexbox-1/#layout-algorithm.

    # 1 Initial setup, done in formatting_structure.build.

    # 2 Determine the available main and cross space for the flex items.
    if box.style['flex_direction'].startswith('row'):
        main, cross = 'width', 'height'
    else:
        main, cross = 'height', 'width'

    margin_left = 0 if box.margin_left == 'auto' else box.margin_left
    margin_right = 0 if box.margin_right == 'auto' else box.margin_right

    # Define available main space.
    # TODO: min- and max-content not implemented.
    if getattr(box, main) != 'auto':
        # If that dimension of the flex container’s content box is a definite size…
        available_main_space = getattr(box, main)
    else:
        # Otherwise, subtract the flex container’s margin, border, and padding…
        if main == 'width':
            available_main_space = (
                containing_block.width -
                margin_left - margin_right -
                box.padding_left - box.padding_right -
                box.border_left_width - box.border_right_width)
        else:
            available_main_space = inf

    # Same as above for available cross space.
    # TODO: min- and max-content not implemented.
    if getattr(box, cross) != 'auto':
        available_cross_space = getattr(box, cross)
    else:
        if cross == 'width':
            available_cross_space = (
                containing_block.width -
                margin_left - margin_right -
                box.padding_left - box.padding_right -
                box.border_left_width - box.border_right_width)
        else:
            available_cross_space = inf

    # 3 Determine the flex base size and hypothetical main size of each item.
    parent_box = box.copy()
    percent.resolve_percentages(parent_box, containing_block)
    parent_box.remove_decoration(start=not is_start, end=False)
    block.block_level_width(parent_box, containing_block)
    children = sorted(box.children, key=lambda item: item.style['order'])
    if skip_stack is not None:
        (skip, skip_stack), = skip_stack.items()
        if box.style['flex_direction'].endswith('-reverse'):
            children = children[:skip + 1]
        else:
            children = children[skip:]
        skip_stack = skip_stack
    else:
        skip, skip_stack = 0, None
    child_skip_stack = skip_stack

    if row_gap == 'normal':
        row_gap = 0
    elif row_gap.unit == '%':
        if box.height == 'auto':
            row_gap = 0
        else:
            row_gap = row_gap.value / 100 * box.height
    else:
        row_gap = row_gap.value
    if column_gap == 'normal':
        column_gap = 0
    elif column_gap.unit == '%':
        if box.width == 'auto':
            column_gap = 0
        else:
            column_gap = column_gap.value / 100 * box.width
    else:
        column_gap = column_gap.value
    if main == 'width':
        main_gap, cross_gap = column_gap, row_gap
    else:
        main_gap, cross_gap = row_gap, column_gap

    position_x = (
        parent_box.position_x + parent_box.border_left_width + parent_box.padding_left)
    if parent_box.margin_left != 'auto':
        position_x += parent_box.margin_left
    position_y = (
        parent_box.position_y + parent_box.border_top_width + parent_box.padding_top)
    if parent_box.margin_top != 'auto':
        position_y += parent_box.margin_top
    for index, child in enumerate(children):
        if not child.is_flex_item:
            # Absolute child layout: create placeholder.
            if child.is_absolutely_positioned():
                child.position_x = position_x
                child.position_y = position_y
                new_child = placeholder = AbsolutePlaceholder(child)
                placeholder.index = index
                children[index] = placeholder
                if child.style['position'] == 'absolute':
                    absolute_boxes.append(placeholder)
                else:
                    fixed_boxes.append(placeholder)
            elif child.is_running():
                running_name = child.style['position'][1]
                page = context.current_page
                context.running_elements[running_name][page].append(child)
            continue
        # See https://www.w3.org/TR/css-flexbox-1/#min-size-auto.
        if main == 'width':
            child_containing_block = (available_main_space, parent_box.height)
        else:
            child_containing_block = (parent_box.width, available_main_space)
        percent.resolve_percentages(child, child_containing_block)
        if child.is_table_wrapper:
            table_wrapper_width(context, child, child_containing_block)
        child.position_x = position_x
        child.position_y = position_y
        if child.style['min_width'] == 'auto':
            specified_size = child.width
            new_child = child.copy()
            new_child.style = child.style.copy()
            new_child.style['width'] = 'auto'
            new_child.style['min_width'] = Dimension(0, 'px')
            new_child.style['max_width'] = Dimension(inf, 'px')
            content_size = min_content_width(context, new_child, outer=False)
            transferred_size = None
            if isinstance(child, boxes.ReplacedBox):
                image = child.replacement
                _, intrinsic_height, intrinsic_ratio = image.get_intrinsic_size(
                    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:
                child.min_width = min(transferred_size, content_size)
            else:
                child.min_width = content_size
        if child.style['min_height'] == 'auto':
            # TODO: avoid calling block_level_layout, write min_content_height instead.
            specified_size = child.height
            new_child = child.copy()
            new_child.style = child.style.copy()
            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]
            content_size = new_child.height if new_child else 0
            transferred_size = None
            if isinstance(child, boxes.ReplacedBox):
                image = child.replacement
                intrinsic_width, _, intrinsic_ratio = image.get_intrinsic_size(
                    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:
                child.min_height = min(transferred_size, content_size)
            else:
                child.min_height = content_size

        if child.style['flex_basis'] == 'content':
            flex_basis = 'content'
        else:
            flex_basis = percent.percentage(
                child.style['flex_basis'], child.style, available_main_space)
            if flex_basis == 'auto':
                if (flex_basis := getattr(child, main)) == 'auto':
                    flex_basis = 'content'

        # 3.A If the item has a definite used flex basis…
        if flex_basis != 'content':
            child.flex_base_size = flex_basis
            if main == 'width':
                child.main_outer_extra = (
                    child.border_left_width + child.border_right_width +
                    child.padding_left + child.padding_right)
                if child.margin_left != 'auto':
                    child.main_outer_extra += child.margin_left
                if child.margin_right != 'auto':
                    child.main_outer_extra += child.margin_right
            else:
                child.main_outer_extra = (
                    child.border_top_width + child.border_bottom_width +
                    child.padding_top + child.padding_bottom)
                if child.margin_top != 'auto':
                    child.main_outer_extra += child.margin_top
                if child.margin_bottom != 'auto':
                    child.main_outer_extra += child.margin_bottom
        elif False:
            # TODO: 3.B If the flex item has an intrinsic aspect ratio…
            # TODO: 3.C If the used flex basis is 'content'…
            # TODO: 3.D Otherwise, if the used flex basis is 'content'…
            pass
        else:
            # 3.E Otherwise…
            new_child = child.copy()
            new_child.style = child.style.copy()
            if main == 'width':
                # … 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:
                # … 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, _, _, adjoining_margins, _, _ = block.block_level_layout(
                    context, new_child, bottom_space, child_skip_stack, parent_box,
                    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)
                else:
                    child.flex_base_size = child.main_outer_extra = 0

        if main == 'width':
            position_x += child.flex_base_size + child.main_outer_extra
        else:
            position_y += child.flex_base_size + child.main_outer_extra

        min_size = getattr(child, f'min_{main}')
        max_size = getattr(child, f'max_{main}')
        child.hypothetical_main_size = max(
            min_size, min(child.flex_base_size, max_size))

        # Skip stack is only for the first child.
        child_skip_stack = None

    # 4 Determine the main size of the flex container using the rules of the formatting
    # context in which it participates.
    original_box_height = box.height
    if main == 'width':
        block.block_level_width(box, containing_block)
    else:
        if box.height == 'auto':
            box.height = 0
            flex_items = (child for child in children if child.is_flex_item)
            for i, child in enumerate(flex_items):
                box.height += child.hypothetical_main_size + child.main_outer_extra
                if i:
                    box.height += main_gap
        box.height = max(box.min_height, min(box.height, box.max_height))

    # 5 If the flex container is single-line, collect all the flex items into a single
    # flex line.
    flex_lines = []
    line = []
    line_size = 0
    main_size = getattr(box, main)
    for i, child in enumerate(children, start=skip):
        if not child.is_flex_item:
            continue
        line_size += child.hypothetical_main_size + child.main_outer_extra
        if i > skip:
            line_size += main_gap
        if box.style['flex_wrap'] != 'nowrap' and line_size > main_size:
            if line:
                flex_lines.append(FlexLine(line))
                line = [(i, child)]
                line_size = child.hypothetical_main_size + child.main_outer_extra
            else:
                line.append((i, child))
                flex_lines.append(FlexLine(line))
                line = []
                line_size = 0
        else:
            line.append((i, child))
    if line:
        flex_lines.append(FlexLine(line))

    # TODO: Handle *-reverse using the terminology from the specification.
    if box.style['flex_wrap'] == 'wrap-reverse':
        flex_lines.reverse()
    if box.style['flex_direction'].endswith('-reverse'):
        for line in flex_lines:
            line.reverse()

    # 6 Resolve the flexible lengths of all the flex items to find their used main size.
    available_main_space = getattr(box, main)
    for line in flex_lines:
        # 9.7.1 Determine the used flex factor.
        hypothetical_main_size = sum(
            child.hypothetical_main_size + child.main_outer_extra
            for index, child in line)
        if hypothetical_main_size < available_main_space:
            flex_factor_type = 'grow'
        else:
            flex_factor_type = 'shrink'

        # 9.7.3 Size inflexible items.
        for index, child in line:
            if flex_factor_type == 'grow':
                child.flex_factor = child.style['flex_grow']
                flex_condition = child.flex_base_size > child.hypothetical_main_size
            else:
                child.flex_factor = child.style['flex_shrink']
                flex_condition = child.flex_base_size < child.hypothetical_main_size
            if child.flex_factor == 0 or flex_condition:
                child.target_main_size = child.hypothetical_main_size
                child.frozen = True
            else:
                child.frozen = False

        # 9.7.4 Calculate initial free space.
        initial_free_space = available_main_space
        for i, (index, child) in enumerate(line):
            if child.frozen:
                initial_free_space -= child.target_main_size + child.main_outer_extra
            else:
                initial_free_space -= child.flex_base_size + child.main_outer_extra
            if i:
                initial_free_space -= main_gap

        # 9.7.5.a Check for flexible items.
        while not all(child.frozen for index, child in line):
            unfrozen_factor_sum = 0
            remaining_free_space = available_main_space

            # 9.7.5.b Calculate the remaining free space.
            for i, (index, child) in enumerate(line):
                if child.frozen:
                    remaining_free_space -= (
                        child.target_main_size + child.main_outer_extra)
                else:
                    remaining_free_space -= (
                        child.flex_base_size + child.main_outer_extra)
                    unfrozen_factor_sum += child.flex_factor
                if i:
                    remaining_free_space -= main_gap

            if unfrozen_factor_sum < 1:
                initial_free_space *= unfrozen_factor_sum

            if initial_free_space == inf:
                initial_free_space = sys.maxsize
            if remaining_free_space == inf:
                remaining_free_space = sys.maxsize

            initial_magnitude = (
                int(log10(initial_free_space)) if initial_free_space > 0 else -inf)
            remaining_magnitude = (
                int(log10(remaining_free_space)) if remaining_free_space > 0 else -inf)
            if initial_magnitude < remaining_magnitude:
                remaining_free_space = initial_free_space

            # 9.7.5.c Distribute free space proportional to the flex factors.
            if remaining_free_space == 0:
                # If the remaining free space is zero: "Do nothing", but we at least set
                # the flex_base_size as target_main_size for next step.
                for index, child in line:
                    if not child.frozen:
                        child.target_main_size = child.flex_base_size
            else:
                scaled_flex_shrink_factors_sum = 0
                flex_grow_factors_sum = 0
                for index, child in line:
                    if not child.frozen:
                        child.scaled_flex_shrink_factor = (
                            child.flex_base_size * child.style['flex_shrink'])
                        scaled_flex_shrink_factors_sum += (
                            child.scaled_flex_shrink_factor)
                        flex_grow_factors_sum += child.style['flex_grow']
                for index, child in line:
                    if not child.frozen:
                        # If using the flex grow factor…
                        if flex_factor_type == 'grow':
                            ratio = child.style['flex_grow'] / flex_grow_factors_sum
                            child.target_main_size = (
                                child.flex_base_size + remaining_free_space * ratio)
                        # If using the flex shrink factor…
                        elif flex_factor_type == 'shrink':
                            if scaled_flex_shrink_factors_sum == 0:
                                child.target_main_size = child.flex_base_size
                            else:
                                ratio = (
                                    child.scaled_flex_shrink_factor /
                                    scaled_flex_shrink_factors_sum)
                                child.target_main_size = (
                                    child.flex_base_size + remaining_free_space * ratio)
                        child.target_main_size = min_max(child, child.target_main_size)

            # 9.7.5.d Fix min/max violations.
            for index, child in line:
                child.adjustment = 0
                if not child.frozen:
                    min_size = getattr(child, f'min_{main}')
                    max_size = getattr(child, f'max_{main}')
                    min_size = max(min_size, min(child.target_main_size, max_size))
                    if child.target_main_size < min_size:
                        child.adjustment = min_size - child.target_main_size
                        child.target_main_size = min_size

            # 9.7.5.e Freeze over-flexed items.
            adjustments = sum(child.adjustment for index, child in line)
            for index, child in line:
                # Zero: Freeze all items.
                if adjustments == 0:
                    child.frozen = True
                # Positive: Freeze all the items with min violations.
                elif adjustments > 0 and child.adjustment > 0:
                    child.frozen = True
                # Negative: Freeze all the items with max violations.
                elif adjustments < 0 and child.adjustment < 0:
                    child.frozen = True

        # 9.7.6 Set each item’s used main size to its target main size.
        for index, child in line:
            if main == 'width':
                child.width = child.target_main_size
            else:
                child.height = child.target_main_size

    # 7 Determine the hypothetical cross size of each item.
    # TODO: Handle breaks.
    new_flex_lines = []
    child_skip_stack = skip_stack
    for line in flex_lines:
        new_flex_line = FlexLine()
        for index, child in line:
            # TODO: Fix this value, see test_flex_item_auto_margin_cross.
            if child.margin_top == 'auto':
                child.margin_top = 0
            if child.margin_bottom == 'auto':
                child.margin_bottom = 0
            # TODO: Find another way than calling block_level_layout_switch.
            new_child = child.copy()
            new_child, _, _, adjoining_margins, _, _ = block.block_level_layout_switch(
                context, new_child, -inf, child_skip_stack, parent_box, page_is_empty,
                absolute_boxes, fixed_boxes, adjoining_margins=[],
                first_letter_style=None, first_line_style=None, discard=discard,
                max_lines=None)
            child._baseline = find_in_flow_baseline(new_child) or 0
            if cross == 'height':
                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 height.
                child.height += block.collapse_margin(adjoining_margins)
            else:
                if child.width == 'auto':
                    min_width = min_content_width(context, child, outer=False)
                    max_width = max_content_width(context, child, outer=False)
                    child.width = min(max(min_width, new_child.width), max_width)
                else:
                    child.width = new_child.width

            new_flex_line.append((index, child))

            # Skip stack is only for the first child.
            child_skip_stack = None

        if new_flex_line:
            new_flex_lines.append(new_flex_line)
    flex_lines = new_flex_lines

    # 8 Calculate the cross size of each flex line.
    cross_size = getattr(box, cross)
    if len(flex_lines) == 1 and cross_size != 'auto':
        # If the flex container is single-line…
        flex_lines[0].cross_size = cross_size
    else:
        # Otherwise, for each flex line…
        # 8.1 Collect all the flex items whose inline-axis is parallel to the main-axis…
        for line in flex_lines:
            collected_items = []
            not_collected_items = []
            for index, child in line:
                align_self = child.style['align_self']
                collect = (
                    box.style['flex_direction'].startswith('row') and
                    'baseline' in align_self and
                    'auto' not in (child.margin_top, child.margin_bottom))
                (collected_items if collect else not_collected_items).append(child)
            cross_start_distance = cross_end_distance = 0
            for child in collected_items:
                baseline = child._baseline - child.position_y
                cross_start_distance = max(cross_start_distance, baseline)
                cross_end_distance = max(
                    cross_end_distance, child.margin_height() - baseline)
            collected_cross_size = cross_start_distance + cross_end_distance
            non_collected_cross_size = 0
            # 8.2 Find the largest outer hypothetical cross size.
            if not_collected_items:
                non_collected_cross_size = -inf
                for child in not_collected_items:
                    if cross == 'height':
                        child_cross_size = child.border_height()
                        if child.margin_top != 'auto':
                            child_cross_size += child.margin_top
                        if child.margin_bottom != 'auto':
                            child_cross_size += child.margin_bottom
                    else:
                        child_cross_size = child.border_width()
                        if child.margin_left != 'auto':
                            child_cross_size += child.margin_left
                        if child.margin_right != 'auto':
                            child_cross_size += child.margin_right
                    non_collected_cross_size = max(
                        child_cross_size, non_collected_cross_size)
            # 8.3 Set the used cross-size of the flex line.
            line.cross_size = max(collected_cross_size, non_collected_cross_size)

    # 8.3 If the flex container is single-line…
    if len(flex_lines) == 1:
        line, = flex_lines
        min_cross_size = getattr(box, f'min_{cross}')
        if min_cross_size == 'auto':
            min_cross_size = -inf
        max_cross_size = getattr(box, f'max_{cross}')
        if max_cross_size == 'auto':
            max_cross_size = inf
        line.cross_size = max(min_cross_size, min(line.cross_size, max_cross_size))

    # 9 Handle 'align-content: stretch'.
    align_content = box.style['align_content']
    if 'normal' in align_content:
        align_content = ('stretch',)
    if 'stretch' in align_content:
        definite_cross_size = None
        if cross == 'height' and box.height != 'auto':
            definite_cross_size = box.height
        elif cross == 'width':
            if isinstance(box, boxes.FlexBox):
                if box.width == 'auto':
                    definite_cross_size = available_cross_space
                else:
                    definite_cross_size = box.width
        if definite_cross_size is not None:
            extra_cross_size = definite_cross_size
            extra_cross_size -= sum(line.cross_size for line in flex_lines)
            extra_cross_size -= (len(flex_lines) - 1) * cross_gap
            if extra_cross_size:
                for line in flex_lines:
                    line.cross_size += extra_cross_size / len(flex_lines)

    # TODO: 10 Collapse 'visibility: collapse' items.

    # 11 Determine the used cross size of each flex item.
    align_items = box.style['align_items']
    if 'normal' in align_items:
        align_items = ('stretch',)
    for line in flex_lines:
        for index, child in line:
            align_self = child.style['align_self']
            if 'normal' in align_self:
                align_self = ('stretch',)
            elif 'auto' in align_self:
                align_self = align_items
            if 'stretch' in align_self and child.style[cross] == 'auto':
                cross_margins = (
                    (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':
                        cross_size -= (
                            child.margin_top + child.margin_bottom +
                            child.padding_top + child.padding_bottom +
                            child.border_top_width +
                            child.border_bottom_width)
                    else:
                        cross_size -= (
                            child.margin_left + child.margin_right +
                            child.padding_left + child.padding_right +
                            child.border_left_width +
                            child.border_right_width)
                    setattr(child, cross, cross_size)
            # else: Cross size has been set by step 7.

    # 12 Distribute any remaining free space.
    original_position_main = (
        box.content_box_x() if main == 'width'
        else box.content_box_y())
    justify_content = box.style['justify_content']
    if 'normal' in justify_content:
        justify_content = ('flex-start',)
    if box.style['flex_direction'].endswith('-reverse'):
        if 'flex-start' in justify_content:
            justify_content = ('flex-end',)
        elif 'flex-end' in justify_content:
            justify_content = ('flex-start',)
        elif 'start' in justify_content:
            justify_content = ('end',)
        elif 'end' in justify_content:
            justify_content = ('start',)

    for line in flex_lines:
        position_main = original_position_main
        if main == 'width':
            free_space = box.width
            for index, child in line:
                free_space -= child.border_width()
                if child.margin_left != 'auto':
                    free_space -= child.margin_left
                if child.margin_right != 'auto':
                    free_space -= child.margin_right
        else:
            free_space = box.height
            for index, child in line:
                free_space -= child.border_height()
                if child.margin_top != 'auto':
                    free_space -= child.margin_top
                if child.margin_bottom != 'auto':
                    free_space -= child.margin_bottom
        free_space -= (len(line) - 1) * main_gap

        # 12.1 If the remaining free space is positive…
        margins = 0
        for index, child in line:
            if main == 'width':
                if child.margin_left == 'auto':
                    margins += 1
                if child.margin_right == 'auto':
                    margins += 1
            else:
                if child.margin_top == 'auto':
                    margins += 1
                if child.margin_bottom == 'auto':
                    margins += 1
        if margins:
            free_space /= margins
            for index, child in line:
                if main == 'width':
                    if child.margin_left == 'auto':
                        child.margin_left = free_space
                    if child.margin_right == 'auto':
                        child.margin_right = free_space
                else:
                    if child.margin_top == 'auto':
                        child.margin_top = free_space
                    if child.margin_bottom == 'auto':
                        child.margin_bottom = free_space
            free_space = 0

        if box.style['direction'] == 'rtl' and main == 'width':
            free_space *= -1

        # 12.2 Align the items along the main-axis per justify-content.
        if {'end', 'flex-end', 'right'} & set(justify_content):
            position_main += free_space
        elif 'center' in justify_content:
            position_main += free_space / 2
        elif 'space-around' in justify_content:
            position_main += free_space / len(line) / 2
        elif 'space-evenly' in justify_content:
            position_main += free_space / (len(line) + 1)

        growths = sum(child.style['flex_grow'] for child in children)
        if box.style['direction'] == 'rtl' and main == 'width':
            main_gap *= -1
        for i, (index, child) in enumerate(line):
            if i:
                position_main += main_gap
            if main == 'width':
                child.position_x = position_main
                if 'stretch' in justify_content and growths:
                    child.width += free_space * child.style['flex_grow'] / growths
            else:
                child.position_y = position_main
            margin_main = (
                child.margin_width() if main == 'width' else child.margin_height())
            if box.style['direction'] == 'rtl' and main == 'width':
                margin_main *= -1
            position_main += margin_main
            if 'space-around' in justify_content:
                position_main += free_space / len(line)
            elif 'space-between' in justify_content:
                if len(line) > 1:
                    position_main += free_space / (len(line) - 1)
            elif 'space-evenly' in justify_content:
                position_main += free_space / (len(line) + 1)

    # 13 Resolve cross-axis auto margins.
    if cross == 'width':
        # Make sure width/margins are no longer "auto", as we did not do it above in
        # step 4.
        block.block_level_width(box, containing_block)
    position_cross = box.content_box_y() if cross == 'height' else box.content_box_x()
    for line in flex_lines:
        line.lower_baseline = -inf
        # TODO: Don't duplicate this loop.
        for index, child in line:
            align_self = child.style['align_self']
            if 'auto' in align_self:
                align_self = align_items
            if 'baseline' in align_self and main == 'width':
                # TODO: handle vertical text.
                child.baseline = child._baseline - position_cross
                line.lower_baseline = max(line.lower_baseline, child.baseline)
        if line.lower_baseline == -inf:
            line.lower_baseline = line[0][1]._baseline if line else 0
        for index, child in line:
            cross_margins = (
                (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:
                extra_cross = line.cross_size
                if cross == 'height':
                    extra_cross -= child.border_height()
                    if child.margin_top != 'auto':
                        extra_cross -= child.margin_top
                    if child.margin_bottom != 'auto':
                        extra_cross -= child.margin_bottom
                else:
                    extra_cross -= child.border_width()
                    if child.margin_left != 'auto':
                        extra_cross -= child.margin_left
                    if child.margin_right != 'auto':
                        extra_cross -= child.margin_right
                if extra_cross > 0:
                    # If its outer cross size is less than the cross size…
                    extra_cross /= auto_margins
                    if cross == 'height':
                        if child.style['margin_top'] == 'auto':
                            child.margin_top = extra_cross
                        if child.style['margin_bottom'] == 'auto':
                            child.margin_bottom = extra_cross
                    else:
                        if child.style['margin_left'] == 'auto':
                            child.margin_left = extra_cross
                        if child.style['margin_right'] == 'auto':
                            child.margin_right = extra_cross
                else:
                    # Otherwise…
                    if cross == 'height':
                        if child.margin_top == 'auto':
                            child.margin_top = 0
                        child.margin_bottom = extra_cross
                    else:
                        if child.margin_left == 'auto':
                            child.margin_left = 0
                        child.margin_right = extra_cross
            else:
                # 14 Align all flex items along the cross-axis.
                align_self = child.style['align_self']
                if 'normal' in align_self:
                    align_self = ('stretch',)
                elif 'auto' in align_self:
                    align_self = align_items
                position = 'position_y' if cross == 'height' else 'position_x'
                setattr(child, position, position_cross)
                if {'end', 'self-end', 'flex-end'} & set(align_self):
                    if cross == 'height':
                        child.position_y += line.cross_size - child.margin_height()
                    else:
                        child.position_x += line.cross_size - child.margin_width()
                elif 'center' in align_self:
                    if cross == 'height':
                        child.position_y += (
                            line.cross_size - child.margin_height()) / 2
                    else:
                        child.position_x += (line.cross_size - child.margin_width()) / 2
                elif 'baseline' in align_self:
                    if cross == 'height':
                        child.position_y += line.lower_baseline - child.baseline
                    else:
                        # TODO: Handle vertical text.
                        pass
                elif 'stretch' in align_self:
                    if child.style[cross] == 'auto':
                        if cross == 'height':
                            margins = child.margin_top + child.margin_bottom
                        else:
                            margins = child.margin_left + child.margin_right
                        if child.style['box_sizing'] == 'content-box':
                            if cross == 'height':
                                margins += (
                                    child.border_top_width + child.border_bottom_width +
                                    child.padding_top + child.padding_bottom)
                            else:
                                margins += (
                                    child.border_left_width + child.border_right_width +
                                    child.padding_left + child.padding_right)
        position_cross += line.cross_size

    # 15 Determine the flex container’s used cross size.
    # TODO: Use the updated algorithm.
    if getattr(box, cross) == 'auto':
        # Otherwise, use the sum of the flex lines' cross sizes…
        # TODO: Handle min-max.
        # TODO: What about align-content here?
        cross_size = sum(line.cross_size for line in flex_lines)
        cross_size += (len(flex_lines) - 1) * cross_gap
        setattr(box, cross, cross_size)

    if len(flex_lines) > 1:
        # 15 If the cross size property is a definite size, use that…
        extra_cross_size = getattr(box, cross)
        extra_cross_size -= sum(line.cross_size for line in flex_lines)
        extra_cross_size -= (len(flex_lines) - 1) * cross_gap
        # 16 Align all flex lines per align-content.
        cross_translate = 0
        direction = 'position_y' if cross == 'height' else 'position_x'
        for i, line in enumerate(flex_lines):
            flex_items = tuple(child for _, child in line if child.is_flex_item)
            if i:
                cross_translate += cross_gap
            for child in flex_items:
                current_value = getattr(child, direction) + cross_translate
                setattr(child, direction, current_value)
            if extra_cross_size == 0:
                continue
            for child in flex_items:
                if {'flex-end', 'end'} & set(align_content):
                    setattr(child, direction, current_value + extra_cross_size)
                elif 'center' in align_content:
                    setattr(child, direction, current_value + extra_cross_size / 2)
                elif 'space-around' in align_content:
                    setattr(
                        child, direction,
                        current_value + extra_cross_size / len(flex_lines) / 2)
                elif 'space-evenly' in align_content:
                    setattr(
                        child, direction,
                        current_value + extra_cross_size / (len(flex_lines) + 1))
            if 'space-between' in align_content:
                cross_translate += extra_cross_size / (len(flex_lines) - 1)
            elif 'space-around' in align_content:
                cross_translate += extra_cross_size / len(flex_lines)
            elif 'space-evenly' in align_content:
                cross_translate += extra_cross_size / (len(flex_lines) + 1)

    # Now we are no longer in the flex algorithm.
    box = box.copy_with_children(
        [child for child in children if child.is_absolutely_positioned()])
    child_skip_stack = skip_stack
    for line in flex_lines:
        for index, child in line:
            if child.is_flex_item:
                # TODO: Don't use block_level_layout_switch.
                new_child, child_resume_at, next_page = block.block_level_layout_switch(
                    context, child, bottom_space, child_skip_stack, box, page_is_empty,
                    absolute_boxes, fixed_boxes, adjoining_margins=[],
                    first_letter_style=None, first_line_style=None, discard=discard,
                    max_lines=None)[:3]
                if new_child is None:
                    if resume_at:
                        resume_index, = resume_at
                        resume_index -= 1
                    else:
                        resume_index = 0
                    resume_at = {resume_index + index: None}
                else:
                    page_is_empty = False
                    box.children.append(new_child)
                    position_y = new_child.position_y + new_child.border_height()
                    if child_resume_at is not None:
                        first_level_skip = 0
                        if resume_at:
                            resume_index, = resume_at
                            first_level_skip = resume_index
                        resume_at = {first_level_skip + index: child_resume_at}
                if resume_at:
                    break

            # Skip stack is only for the first child.
            child_skip_stack = None
        if resume_at:
            break

    if original_box_height != 'auto':
        # Don’t resume if flex items overflow flex container bottom.
        box_bottom = box.position_y + box.border_height()
        if context.overflows(box_bottom, position_y):
            resume_at = None

    if box.style['position'] == 'relative':
        # New containing block, resolve the layout of the absolute descendants.
        for absolute_box in absolute_boxes:
            absolute_layout(
                context, absolute_box, box, fixed_boxes, bottom_space, skip_stack=None)

    for child in box.children:
        block.relative_positioning(child, (box.width, box.height))

    # TODO: Use real algorithm, see https://www.w3.org/TR/css-flexbox-1/#flex-baselines.
    if isinstance(box, boxes.InlineFlexBox):
        if main == 'width':  # and main text direction is horizontal
            box.baseline = flex_lines[0].lower_baseline if flex_lines else 0
        else:
            for child in box.children:
                if child.is_in_normal_flow():
                    box.baseline = find_in_flow_baseline(child) or 0
                    break
            else:
                box.baseline = 0

    box.remove_decoration(start=False, end=resume_at and not discard)

    context.finish_flex_formatting_context(box)

    return box, resume_at, next_page, [], False


================================================
FILE: weasyprint/layout/float.py
================================================
"""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
from .preferred import shrink_to_fit
from .replaced import inline_replaced_box_width_height
from .table import table_wrapper_width


@handle_min_max_width
def float_width(box, context, containing_block):
    # Check that box.width is auto even if the caller does it too, because
    # the handle_min_max_width decorator can change the value
    if box.width == 'auto':
        box.width = shrink_to_fit(context, box, containing_block.width)


def float_layout(context, box, containing_block, absolute_boxes, fixed_boxes,
                 bottom_space, skip_stack):
    """Set the width and position of floating ``box``."""
    from .block import block_container_layout
    from .flex import flex_layout
    from .grid import grid_layout

    cb_width, cb_height = (containing_block.width, containing_block.height)
    resolve_percentages(box, (cb_width, cb_height))

    # TODO: This is only handled later in blocks.block_container_layout
    # https://www.w3.org/TR/CSS21/visudet.html#normal-block
    if cb_height == 'auto':
        cb_height = containing_block.position_y - containing_block.content_box_y()

    resolve_position_percentages(box, (cb_width, cb_height))

    if box.margin_left == 'auto':
        box.margin_left = 0
    if box.margin_right == 'auto':
        box.margin_right = 0
    if box.margin_top == 'auto':
        box.margin_top = 0
    if box.margin_bottom == 'auto':
        box.margin_bottom = 0

    clearance = get_clearance(context, box, containing_block.style['direction'])
    if clearance is not None:
        box.position_y += clearance

    if isinstance(box, boxes.BlockReplacedBox):
        inline_replaced_box_width_height(box, containing_block)
    elif box.width == 'auto':
        float_width(box, context, containing_block)

    if box.is_table_wrapper:
        table_wrapper_width(context, box, (cb_width, cb_height))

    if isinstance(box, boxes.BlockContainerBox):
        box, resume_at, _, _, _, _ = block_container_layout(
            context, box, bottom_space=bottom_space, 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)
    elif isinstance(box, boxes.FlexContainerBox):
        box, resume_at, _, _, _ = flex_layout(
            context, box, bottom_space=bottom_space,
            skip_stack=skip_stack, containing_block=containing_block,
            page_is_empty=True, absolute_boxes=absolute_boxes,
            fixed_boxes=fixed_boxes, discard=False)
    elif isinstance(box, boxes.GridContainerBox):
        box, resume_at, _, _, _ = grid_layout(
            context, box, bottom_space=bottom_space,
            skip_stack=skip_stack, containing_block=containing_block,
            page_is_empty=True, absolute_boxes=absolute_boxes,
            fixed_boxes=fixed_boxes)
    else:
        assert isinstance(box, boxes.BlockReplacedBox)
        resume_at = None

    box = find_float_position(context, box, containing_block)

    context.excluded_shapes.append(box)
    return box, resume_at


def find_float_position(context, box, containing_block):
    """Get the right position of the float ``box``."""
    # See https://www.w3.org/TR/CSS2/visuren.html#float-position

    # Point 4 is already handled as box.position_y is set according to the
    # containing box top position, with collapsing margins handled

    # Points 5 and 6, box.position_y is set to the highest position_y possible
    if context.excluded_shapes:
        highest_y = context.excluded_shapes[-1].position_y
        if box.position_y < highest_y:
            box.translate(0, highest_y - box.position_y)

    # Points 1 and 2
    position_x, position_y, available_width = avoid_collisions(
        context, box, containing_block)

    # Point 9
    # position_y is set now, let's define position_x
    # for float: left elements, it's already done!
    float_right = (
        box.style['float'] == 'right' or
        (box.style['direction'] == 'ltr' and box.style['float'] == 'inline-end') or
        (box.style['direction'] == 'rtl' and box.style['float'] == 'inline-start'))
    if float_right:
        position_x += available_width - box.margin_width()

    box.translate(position_x - box.position_x, position_y - box.position_y)

    return box


def get_clearance(context, box, direction, collapsed_margin=0):
    """Return None if there is no clearance, otherwise the clearance value."""

    def clear(clear_value, float_value):
        """Closure returning whether clear and float values match."""
        if clear_value == 'inline-start':
            clear_value = 'left' if direction == 'ltr' else 'right'
        if clear_value == 'inline-end':
            clear_value = 'left' if direction == 'rtl' else 'right'
        if float_value == 'inline-start':
            float_value = 'left' if direction == 'ltr' else 'right'
        if float_value == 'inline-end':
            float_value = 'left' if direction == 'rtl' else 'right'
        return clear_value in (float_value, 'both')

    # 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 clear(box.style['clear'], broken_shape.style['float']):
                return inf
    # Hypothetical position is the position of the top border edge
    clearance = None
    hypothetical_position = box.position_y + collapsed_margin
    for excluded_shape in context.excluded_shapes:
        if clear(box.style['clear'], excluded_shape.style['float']):
            y, h = excluded_shape.position_y, excluded_shape.margin_height()
            if hypothetical_position < y + h:
                clearance = max((clearance or 0), y + h - hypothetical_position)
    return clearance


def avoid_collisions(context, box, containing_block, outer=True):
    excluded_shapes = context.excluded_shapes
    position_y = box.position_y if outer else box.border_box_y()

    box_width = box.margin_width() if outer else box.border_width()
    box_height = box.margin_height() if outer else box.border_height()

    if box.border_height() == 0 and box.is_floated():
        return 0, 0, containing_block.width

    left_keywords = ['left']
    right_keywords = ['right']
    if containing_block.style['direction'] == 'ltr':
        left_keywords.append('inline-start')
        right_keywords.append('inline-end')
    else:
        left_keywords.append('inline-end')
        right_keywords.append('inline-start')

    while True:
        colliding_shapes = []
        for shape in excluded_shapes:
            # Assign locals to avoid slow attribute lookups.
            shape_position_y = shape.position_y
            shape_margin_height = shape.margin_height()
            if ((shape_position_y < position_y <
                 shape_position_y + shape_margin_height) or
                (shape_position_y < position_y + box_height <
                 shape_position_y + shape_margin_height) or
                (shape_position_y >= position_y and
                 shape_position_y + shape_margin_height <=
                 position_y + box_height)):
                colliding_shapes.append(shape)
        left_bounds = [
            shape.position_x + shape.margin_width()
            for shape in colliding_shapes
            if shape.style['float'] in left_keywords]
        right_bounds = [
            shape.position_x
            for shape in colliding_shapes
            if shape.style['float'] in right_keywords]

        # Set the default maximum bounds
        max_left_bound = containing_block.content_box_x()
        max_right_bound = max_left_bound + containing_block.width

        if not outer:
            max_left_bound += box.margin_left
            max_right_bound -= box.margin_right

        # Set the real maximum bounds according to sibling float elements
        if left_bounds or right_bounds:
            if left_bounds:
                max_left_bound = max(max(left_bounds), max_left_bound)
            if right_bounds:
                max_right_bound = min(min(right_bounds), max_right_bound)

            # Points 3, 7 and 8
            if box_width > max_right_bound - max_left_bound:
                # The box does not fit here
                new_position_y = min(
                    shape.position_y + shape.margin_height()
                    for shape in colliding_shapes)
                if new_position_y > position_y:
                    # We can find a solution with a higher position_y
                    position_y = new_position_y
                    continue
                # No solution, we must put the box here
        break

    # See https://www.w3.org/TR/CSS21/visuren.html#floats
    # Boxes that can’t collide with floats are:
    # - floats
    # - line boxes
    # - table wrappers
    # - block-level replaced box
    # - element establishing new formatting contexts
    assert (
        box.is_floated() or
        isinstance(box, boxes.LineBox) or
        box.is_table_wrapper or
        isinstance(box, boxes.BlockReplacedBox) or
        box.establishes_formatting_context())

    # The x-position of the box depends on its type.
    position_x = max_left_bound
    if box.style['float'] == 'none':
        if containing_block.style['direction'] == 'rtl':
            if isinstance(box, boxes.LineBox):
                # The position of the line is the position of the cursor, at
                # the right bound.
                position_x = max_right_bound
            elif box.is_table_wrapper:
                # The position of the right border of the table is at the right
                # bound.
                position_x = max_right_bound - box_width
            else:
                # The position of the right border of the replaced box or
                # formatting context is at the right bound.
                assert (
                    isinstance(box, boxes.BlockReplacedBox) or
                    box.establishes_formatting_context())
                position_x = max_right_bound - box_width

    available_width = max_right_bound - max_left_bound

    if not outer:
        position_x -= box.margin_left
        position_y -= box.margin_top

    return position_x, position_y, available_width


================================================
FILE: weasyprint/layout/grid.py
================================================
"""Layout for grid containers and grid-items."""

from collections import defaultdict
from itertools import count, cycle
from math import inf

from ..css.properties import Dimension
from ..formatting_structure import boxes
from ..logger import LOGGER
from .percent import percentage, resolve_percentages
from .preferred import max_content_width, min_content_width
from .table import find_in_flow_baseline


def _is_length(sizing):
    return isinstance(sizing, Dimension) and sizing.unit.lower() != 'fr'


def _is_fr(sizing):
    return isinstance(sizing, Dimension) and sizing.unit.lower() == 'fr'


def _intersect(position_1, size_1, position_2, size_2):
    return (
        position_1 < position_2 + size_2 and
        position_2 < position_1 + size_1)


def _intersect_with_children(x, y, width, height, positions):
    for full_x, full_y, full_width, full_height in positions:
        x_intersect = _intersect(x, width, full_x, full_width)
        y_intersect = _intersect(y, height, full_y, full_height)
        if x_intersect and y_intersect:
            return True
    return False


def _get_line(line, lines, side):
    span, number, ident = line
    if ident and span is None and number is None:
        for coord, line in enumerate(lines):
            if f'{ident}-{side}' in line:
                break
        else:
            number = 1
    if number is not None and span is None:
        if ident is None:
            coord = number - 1
        else:
            step = 1 if number > 0 else -1
            for coord, line in enumerate(lines[::step]):
                if ident in line:
                    number -= step
                    break
                if number == 0:
                    break
            else:
                coord += abs(number)
            if step == -1:
                coord = len(lines) - 1 - coord
    if span is not None:
        coord = None
    return span, number, ident, coord


def _get_placement(start, end, lines):
    # Input coordinates are 1-indexed, returned coordinates are 0-indexed.
    if start == 'auto' or start[0] == 'span':
        if end == 'auto' or end[0] == 'span':
            return
    if start != 'auto':
        span, number, ident, coord = _get_line(start, lines, 'start')
        if span is not None:
            size = number or 1
            span_ident = ident
    else:
        size = 1
        span_ident = coord = None
    if end != 'auto':
        span, number, ident, coord_end = _get_line(end, lines, 'end')
        if span is not None:
            size = span_number = number or 1
            span_ident = ident
            if span_ident is not None:
                for size, line in enumerate(lines[coord+1:], start=1):
                    if span_ident in line:
                        span_number -= 1
                    if span_number == 0:
                        break
                else:
                    size += span_number
        elif coord is not None:
            size = coord_end - coord
        if coord is None:
            if span_ident is None:
                coord = coord_end - size
            else:
                number = number or 1
                if coord_end > 0:
                    iterable = enumerate(lines[coord_end-1::-1])
                    for coord, line in iterable:
                        if span_ident in line:
                            number -= 1
                        if number == 0:
                            coord = coord_end - 1 - coord
                            break
                    else:
                        coord = -number
                else:
                    coord = -number
            size = coord_end - coord
    else:
        size = 1
    if size < 0:
        size = -size
        coord -= size
    if size == 0:
        size = 1
    return (coord, size)


def _get_span(place):
    # TODO: Handle lines.
    span = 1
    if place[0] == 'span':
        span = place[1] or 1
    return span


def _get_second_placement(first_placement, second_start, second_end,
                          second_tracks, children_positions, first_flow, dense):
    occupied_tracks = set()
    for x, y, width, height in children_positions.values():
        # Test whether cells overlap.
        if first_flow == 'row':
            if _intersect(y, height, *first_placement):
                for x in range(x, x + width):
                    occupied_tracks.add(x)
        else:
            if _intersect(x, width, *first_placement):
                for y in range(y, y + height):
                    occupied_tracks.add(y)
    if dense:
        for track in count():
            if track in occupied_tracks:
                continue
            if second_start == 'auto':
                placement = _get_placement(
                    (None, track + 1, None), second_end, second_tracks)
            else:
                assert second_start[0] == 'span'
                # If the placement contains two spans, remove the one
                # contributed by the end grid-placement property.
                # https://drafts.csswg.org/css-grid/#grid-placement-errors
                assert second_start == 'auto' or second_start[0] == 'span'
                span = _get_span(second_start)
                placement = _get_placement(
                    second_start, (None, track + 1 + span, None), second_tracks)
            tracks = range(placement[0], placement[0] + placement[1])
            if not set(tracks) & occupied_tracks:
                return placement
    else:
        track = max(occupied_tracks or [0]) + 1
        if second_start == 'auto':
            return _get_placement(
                (None, track + 1, None), second_end, second_tracks)
        else:
            assert second_start[0] == 'span'
            # If the placement contains two spans, remove the one contributed
            # by the end grid-placement property.
            # https://drafts.csswg.org/css-grid/#grid-placement-errors
            assert second_start == 'auto' or second_start[0] == 'span'
            for end_track in count(track + 1):
                placement = _get_placement(
                    second_start, (None, end_track + 1, None), second_tracks)
                if placement[0] >= track:
                    return placement


def _get_sizing_functions(size):
    min_sizing = max_sizing = size
    if size[0] == 'minmax()':
        min_sizing, max_sizing = size[1:]
    if min_sizing[0] == 'fit-content()':
        min_sizing = 'auto'
    elif _is_fr(min_sizing):
        min_sizing = 'auto'
    return (min_sizing, max_sizing)


def _get_template_tracks(tracks):
    if tracks == 'none':
        tracks = ((),)
    if 'subgrid' in tracks:
        # TODO: Support subgrids.
        LOGGER.warning('Subgrids are unsupported')
        return [[]]
    tracks_list = []
    for i, track in enumerate(tracks):
        if i % 2:
            # Track size.
            if track[0] == 'repeat()':
                repeat_number, repeat_track_list = track[1:]
                if not isinstance(repeat_number, int):
                    # TODO: Respect auto-fit and auto-fill.
                    LOGGER.warning(
                        '"auto-fit" and "auto-fill" are unsupported in repeat()')
                    repeat_number = 1
                for _ in range(repeat_number):
                    for j, repeat_track in enumerate(repeat_track_list):
                        if j % 2:
                            # Track size in repeat.
                            tracks_list.append(repeat_track)
                        else:
                            # Line names in repeat.
                            if len(tracks_list) % 2:
                                tracks_list[-1].extend(repeat_track)
                            else:
                                tracks_list.append(list(repeat_track))
            else:
                tracks_list.append(track)
        else:
            # Line names.
            if len(tracks_list) % 2:
                tracks_list[-1].extend(track)
            else:
                tracks_list.append(list(track))
    return tracks_list


def _distribute_extra_space(affected_sizes, affected_tracks_types, size_contribution,
                            tracks_children, sizing_functions, tracks_sizes, span,
                            direction, context):
    assert affected_sizes in ('min', 'max')
    assert affected_tracks_types in (
        'intrinsic', 'content-based', 'max-content')
    assert size_contribution in ('minimum', 'min-content', 'max-content')
    assert direction in 'xy'

    # 1. Maintain separately for each affected track a planned increase.
    planned_increases = [0] * len(tracks_sizes)

    # 2. Distribute space.
    affected_tracks = []
    affected_size_index = 0 if affected_sizes == 'min' else 1
    current_span = 0
    for children, functions in zip(tracks_children, sizing_functions):
        if children:
            current_span = span
        if not current_span:
            affected_tracks.append(False)
            continue
        current_span -= 1
        function = functions[affected_size_index]
        if affected_tracks_types == 'intrinsic':
            if (function in ('min-content', 'max-content', 'auto') or
                    function[0] == 'fit-content()'):
                affected_tracks.append(True)
                continue
        elif affected_tracks_types == 'content-based':
            if function in ('min-content', 'max-content'):
                affected_tracks.append(True)
                continue
        elif affected_tracks_types == 'max-content':
            if function in ('max-content', 'auto'):
                affected_tracks.append(True)
                continue
        affected_tracks.append(False)
    for i, children in enumerate(tracks_children):
        if not children:
            continue
        for item, parent in children:
            # 2.1 Find the space distribution.
            # TODO: Differenciate minimum and min-content values.
            # TODO: Find a better way to get height.
            if direction == 'x':
                if size_contribution in ('minimum', 'min-content'):
                    space = min_content_width(context, item)
                else:
                    space = max_content_width(context, item)
            else:
                from .block import block_level_layout
                item = item.deepcopy()
                item.position_x = 0
                item.position_y = 0
                item, _, _, _, _, _ = block_level_layout(
                    context, item, bottom_space=-inf, skip_stack=None,
                    containing_block=parent)
                space = item.margin_height()
            for sizes in tracks_sizes[i:i+span]:
                space -= sizes[affected_size_index]
            space = max(0, space)
            # 2.2 Distribute space up to limits.
            tracks_numbers = list(
                enumerate(affected_tracks[i:i+span], start=i))
            item_incurred_increases = [0] * len(sizing_functions)
            affected_tracks_numbers = [
                j for j, affected in tracks_numbers if affected]
            distributed_space = space / (len(affected_tracks_numbers) or 1)
            for track_number in affected_tracks_numbers:
                base_size, growth_limit = tracks_sizes[track_number]
                item_incurred_increase = distributed_space
                affected_size = tracks_sizes[track_number][affected_size_index]
                limit = tracks_sizes[track_number][1]
                if affected_size + item_incurred_increase >= limit:
                    extra = (
                        item_incurred_increase + affected_size - limit)
                    item_incurred_increase -= extra
                space -= item_incurred_increase
                item_incurred_increases[track_number] = item_incurred_increase
            # 2.3 Distribute space to non-affected tracks.
            if space and affected_tracks_numbers:
                unaffected_tracks_numbers = [
                    j for j, affected in tracks_numbers if not affected]
                distributed_space = (
                    space / (len(unaffected_tracks_numbers) or 1))
                for track_number in unaffected_tracks_numbers:
                    base_size, growth_limit = tracks_sizes[track_number]
                    item_incurred_increase = distributed_space
                    affected_size = (
                        tracks_sizes[track_number][affected_size_index])
                    limit = tracks_sizes[track_number][1]
                    if affected_size + item_incurred_increase >= limit:
                        extra = (
                            item_incurred_increase + affected_size - limit)
                        item_incurred_increase -= extra
                    space -= item_incurred_increase
                    item_incurred_increases[track_number] = (
                        item_incurred_increase)
            # 2.4 Distribute space beyond limits.
            if space:
                # TODO: Distribute space beyond limits.
                pass
            # 2.5. Set the track’s planned increase.
            for k, extra in enumerate(item_incurred_increases):
                if extra > planned_increases[k]:
                    planned_increases[k] = extra

    # 3. Update the tracks’ affected size.
    iterator = zip(affected_tracks, tracks_sizes, planned_increases)
    for affected, track_sizes, increase in iterator:
        if not affected:
            continue
        if affected_sizes == 'max' and track_sizes[1] is inf:
            track_sizes[1] = track_sizes[0] + increase
        else:
            track_sizes[affected_size_index] += increase


def _resolve_tracks_sizes(sizing_functions, box_size, children_positions,
                          implicit_start, direction, gap, context, containing_block,
                          orthogonal_sizes=None):
    assert direction in 'xy'
    tracks_sizes = []
    # TODO: Check that auto box size is 0 for percentages.
    percent_box_size = 0 if box_size == 'auto' else box_size
    # 1.1 Initialize track sizes.
    for min_function, max_function in sizing_functions:
        base_size = None
        if _is_length(min_function):
            base_size = percentage(
                min_function, containing_block.style, percent_box_size)
        elif (min_function in ('min-content', 'max-content', 'auto') or
              min_function[0] == 'fit-content()'):
            base_size = 0
        growth_limit = None
        if _is_length(max_function):
            growth_limit = percentage(
                max_function, containing_block.style, percent_box_size)
        elif (max_function in ('min-content', 'max-content', 'auto') or
              max_function[0] == 'fit-content()' or _is_fr(max_function)):
            growth_limit = inf
        if None not in (base_size, growth_limit):
            growth_limit = max(base_size, growth_limit)
        tracks_sizes.append([base_size, growth_limit])

    # 1.2 Resolve intrinsic track sizes.
    # 1.2.1 Shim baseline-aligned items.
    # TODO: Shim items.
    # 1.2.2 Size tracks to fit non-spanning items.
    tracks_children = [[] for _ in range(len(tracks_sizes))]
    for child, (x, y, width, height) in children_positions.items():
        coord, size = (x, width) if direction == 'x' else (y, height)
        if size != 1:
            continue
        tracks_children[coord - implicit_start].append(child)
    iterable = zip(tracks_children, sizing_functions, tracks_sizes)
    for children, (min_function, max_function), sizes in iterable:
        if not children:
            continue
        if direction == 'y':
            # TODO: Find a better way to get height.
            from .block import block_level_layout
            height = 0
            for child in children:
                x, y, width, _ = children_positions[child]
                width = sum(orthogonal_sizes[x:x+width])
                child = child.deepcopy()
                child.position_x = 0
                child.position_y = 0
                parent = boxes.BlockContainerBox.anonymous_from(containing_block, ())
                resolve_percentages(parent, containing_block)
                parent.position_x = child.position_x
                parent.position_y = child.position_y
                parent.width = width
                parent.height = height
                bottom_space = -inf
                child, _, _, _, _, _ = block_level_layout(
                    context, child, bottom_space, skip_stack=None,
                    containing_block=parent)
                height = max(height, child.margin_height())
            if min_function in ('min-content', 'max_content', 'auto'):
                sizes[0] = height
            if max_function in ('min-content', 'max_content'):
                sizes[1] = height
            if None not in sizes:
                sizes[1] = max(sizes)
            continue
        if min_function == 'min-content':
            sizes[0] = max(0, *(
                min_content_width(context, child) for child in children))
        elif min_function == 'max-content':
            sizes[0] = max(0, *(
                max_content_width(context, child) for child in children))
        elif min_function == 'auto':
            # TODO: Handle min-/max-content constrained parents.
            # TODO: Use real "minimum contributions".
            sizes[0] = max(0, *(
                min_content_width(context, child) for child in children))
        if max_function == 'min-content':
            sizes[1] = max(
                min_content_width(context, child) for child in children)
        elif (max_function in ('auto', 'max-content') or
              max_function[0] == 'fit_content()'):
            sizes[1] = max(
                max_content_width(context, child) for child in children)
        if None not in sizes:
            sizes[1] = max(sizes)
    # 1.2.3 Increase sizes to accommodate items spanning content-sized tracks.
    spans = sorted({
        width if direction == 'x' else height
        for (_, _, width, height) in children_positions.values()
        if (width if direction == 'x' else height) >= 2})
    for span in spans:
        tracks_children = [[] for _ in range(len(sizing_functions))]
        iterable = enumerate(children_positions.items())
        for i, (child, (x, y, width, height)) in iterable:
            coord, size = (x, width) if direction == 'x' else (y, height)
            if size != span:
                continue
            for _, max_function in sizing_functions[i:i+span+1]:
                if _is_fr(max_function):
                    break
            else:
                parent = boxes.BlockContainerBox.anonymous_from(containing_block, ())
                resolve_percentages(parent, containing_block)
                if direction == 'y':
                    parent.width = sum(orthogonal_sizes[x:x+width])
                tracks_children[coord - implicit_start].append((child, parent))
        # 1.2.3.1 For intrinsic minimums.
        # TODO: Respect min-/max-content constraint.
        _distribute_extra_space(
            'min', 'intrinsic', 'minimum', tracks_children,
            sizing_functions, tracks_sizes, span, direction, context)
        # 1.2.3.2 For content-based minimums.
        _distribute_extra_space(
            'min', 'content-based', 'min-content', tracks_children,
            sizing_functions, tracks_sizes, span, direction, context)
        # 1.2.3.3 For max-content minimums.
        # TODO: Respect max-content constraint.
        _distribute_extra_space(
            'min', 'max-content', 'max-content', tracks_children,
            sizing_functions, tracks_sizes, span, direction, context)
        # 1.2.3.4 Increase growth limit.
        # TODO: Increase growth limit.
        # 1.2.3.5 For intrinsic maximums.
        _distribute_extra_space(
            'max', 'intrinsic', 'min-content', tracks_children,
            sizing_functions, tracks_sizes, span, direction, context)
        # 1.2.3.6 For max-content maximums.
        _distribute_extra_space(
            'max', 'max-content', 'max-content', tracks_children,
            sizing_functions, tracks_sizes, span, direction, context)
    # 1.2.4 Increase sizes to accommodate items spanning flexible tracks.
    # TODO: Support spans for flexible tracks.
    # 1.2.5 Fix infinite growth limits.
    for sizes in tracks_sizes:
        if sizes[1] is inf:
            sizes[1] = sizes[0]
    # 1.3 Maximize tracks.
    if box_size == 'auto':
        free_space = None
    else:
        free_space = (
            box_size -
            sum(size[0] for size in tracks_sizes) -
            (len(tracks_sizes) - 1) * gap)
    if free_space is not None and free_space > 0:
        distributed_free_space = free_space / len(tracks_sizes)
        for i, sizes in enumerate(tracks_sizes):
            base_size, growth_limit = sizes
            if base_size + distributed_free_space > growth_limit:
                sizes[0] = growth_limit
                free_space -= growth_limit - base_size
            else:
                sizes[0] += distributed_free_space
                free_space -= distributed_free_space
    # TODO: Respect max-width/-height.
    # 1.4 Expand flexible tracks.
    inflexible_tracks = set()
    if free_space is not None and free_space <= 0:
        # TODO: Respect min-content constraint.
        flex_fraction = 0
    elif free_space is not None:
        stop = False
        while not stop:
            leftover_space = free_space
            flex_factor_sum = 0
            iterable = enumerate(zip(tracks_sizes, sizing_functions))
            for i, (sizes, (_, max_function)) in iterable:
                if _is_fr(max_function):
                    leftover_space += sizes[0]
                    if i not in inflexible_tracks:
                        flex_factor_sum += max_function.value
            flex_factor_sum = max(1, flex_factor_sum)
            hypothetical_fr_size = leftover_space / flex_factor_sum
            stop = True
            iterable = enumerate(zip(tracks_sizes, sizing_functions))
            for i, (sizes, (_, max_function)) in iterable:
                if i not in inflexible_tracks and _is_fr(max_function):
                    if hypothetical_fr_size * max_function.value < sizes[0]:
                        inflexible_tracks.add(i)
                        free_space -= sizes[0]
                        stop = free_space > 0
        flex_fraction = hypothetical_fr_size
    else:
        flex_fraction = 0
        iterable = zip(tracks_sizes, sizing_functions)
        for sizes, (_, max_function) in iterable:
            if _is_fr(max_function):
                if max_function.value > 1:
                    flex_fraction = max(
                        flex_fraction, max_function.value * sizes[0])
                else:
                    flex_fraction = max(flex_fraction, sizes[0])
        # TODO: Respect grid items max-content contribution.
        # TODO: Respect min-* constraint.
    iterable = enumerate(zip(tracks_sizes, sizing_functions))
    for i, (sizes, (_, max_function)) in iterable:
        if _is_fr(max_function) and i not in inflexible_tracks:
            if flex_fraction * max_function.value > sizes[0]:
                if free_space is not None:
                    free_space -= flex_fraction * max_function.value
                sizes[0] = flex_fraction * max_function.value
    # 1.5 Expand stretched auto tracks.
    justify_content = containing_block.style['justify_content']
    align_content = containing_block.style['align_content']
    x_stretch = (
        direction == 'x' and set(justify_content) & {'normal', 'stretch'})
    y_stretch = (
        direction == 'y' and set(align_content) & {'normal', 'stretch'})
    if (x_stretch or y_stretch) and free_space is not None and free_space > 0:
        auto_tracks_sizes = [
            sizes for sizes, (min_function, _)
            in zip(tracks_sizes, sizing_functions)
            if min_function == 'auto']
        if auto_tracks_sizes:
            distributed_free_space = free_space / len(auto_tracks_sizes)
            for sizes in auto_tracks_sizes:
                sizes[0] += distributed_free_space

    return tracks_sizes


def grid_layout(context, box, bottom_space, skip_stack, containing_block,
                page_is_empty, absolute_boxes, fixed_boxes):
    context.create_block_formatting_context(box)

    if skip_stack and box.style['box_decoration_break'] != 'clone':
        box.remove_decoration(start=True, end=False)

    if box.style['position'] == 'relative':
        # New containing block, use a new absolute list
        absolute_boxes = []

    # Define explicit grid
    grid_areas = box.style['grid_template_areas']
    flow = box.style['grid_auto_flow']
    auto_rows = cycle(box.style['grid_auto_rows'])
    auto_columns = cycle(box.style['grid_auto_columns'])
    auto_rows_back = cycle(box.style['grid_auto_rows'][::-1])
    auto_columns_back = cycle(box.style['grid_auto_columns'][::-1])
    column_gap = box.style['column_gap']
    if column_gap == 'normal':
        column_gap = 0
    else:
        refer_to = containing_block.width if box.width == 'auto' else box.width
        column_gap = percentage(column_gap, box.style, refer_to)
    row_gap = box.style['row_gap']
    if row_gap == 'normal':
        row_gap = 0
    else:
        refer_to = 0 if box.height == 'auto' else box.height
        row_gap = percentage(row_gap, box.style, refer_to)

    if grid_areas == 'none':
        grid_areas = ((None,),)
    grid_areas = [list(row) for row in grid_areas]

    rows = _get_template_tracks(box.style['grid_template_rows'])
    columns = _get_template_tracks(box.style['grid_template_columns'])

    # Adjust rows number
    grid_areas_columns = len(grid_areas[0]) if grid_areas else 0
    rows_diff = int((len(rows) - 1) / 2) - len(grid_areas)
    if rows_diff > 0:
        for _ in range(rows_diff):
            grid_areas.append([None] * grid_areas_columns)
    elif rows_diff < 0:
        for _ in range(-rows_diff):
            rows.append(next(auto_rows))
            rows.append([])

    # Adjust columns number
    columns_diff = int((len(columns) - 1) / 2) - grid_areas_columns
    if columns_diff > 0:
        for row in grid_areas:
            for _ in range(columns_diff):
                row.append(None)
    elif columns_diff < 0:
        for _ in range(-columns_diff):
            columns.append(next(auto_columns))
            columns.append([])

    # Add implicit line names
    for y, row in enumerate(grid_areas):
        for x, area_name in enumerate(row):
            if area_name is None:
                continue
            start_name = f'{area_name}-start'
            names = [name for row in rows[::2] for name in row]
            if start_name not in names:
                rows[2*y].append(start_name)
            names = [name for column in columns[::2] for name in column]
            if start_name not in names:
                columns[2*x].append(start_name)
    for y, row in enumerate(grid_areas[::-1]):
        for x, area_name in enumerate(row[::-1]):
            if area_name is None:
                continue
            end_name = f'{area_name}-end'
            names = [name for row in rows[::2] for name in row]
            if end_name not in names:
                rows[-2*y-1].append(end_name)
            names = [name for column in columns[::2] for name in column]
            if end_name not in names:
                columns[-2*x-1].append(end_name)

    # 1. Run the grid placement algorithm.

    first_flow = 'column' if 'column' in flow else 'row'  # auto flow axis
    second_flow = 'row' if 'column' in flow else 'column'  # other axis
    first_tracks = rows if first_flow == 'row' else columns
    second_tracks = rows if second_flow == 'row' else columns

    # 1.1 Position anything that’s not auto-positioned.
    children = sorted(box.children, key=lambda item: item.style['order'])
    children_positions = {}
    for child in children:
        column_start = child.style['grid_column_start']
        column_end = child.style['grid_column_end']
        row_start = child.style['grid_row_start']
        row_end = child.style['grid_row_end']

        column_placement = _get_placement(
            column_start, column_end, columns[::2])
        row_placement = _get_placement(row_start, row_end, rows[::2])

        if column_placement and row_placement:
            x, width = column_placement
            y, height = row_placement
            children_positions[child] = (x, y, width, height)

    # 1.2 Process the items locked to a given row (resp. column).
    for child in children:
        if child in children_positions:
            continue
        first_start = child.style[f'grid_{first_flow}_start']
        first_end = child.style[f'grid_{first_flow}_end']
        first_placement = _get_placement(first_start, first_end, first_tracks[::2])
        if not first_placement:
            continue
        second_start = child.style[f'grid_{second_flow}_start']
        second_end = child.style[f'grid_{second_flow}_end']
        second_placement = _get_second_placement(
            first_placement, second_start, second_end, second_tracks,
            children_positions, first_flow, 'dense' in flow)
        if first_flow == 'row':
            y, height = first_placement
            x, width = second_placement
        else:
            x, width = first_placement
            y, height = second_placement
        children_positions[child] = (x, y, width, height)

    # 1.3 Determine the columns (resp. rows) in the implicit grid.
    # 1.3.1 Start with the columns (resp. rows) from the explicit grid.
    implicit_second_1 = 0
    if second_flow == 'column':
        implicit_second_2 = len(grid_areas[0]) if grid_areas else 0
    else:
        implicit_second_2 = len(grid_areas)
    # 1.3.2 Add columns (resp. rows) to the beginning and end of the implicit grid.
    remaining_grid_items = []
    for child in children:
        if child in children_positions:
            if second_flow == 'column':
                i, _, size, _ = children_positions[child]
            else:
                _, i, _, size = children_positions[child]
        else:
            second_start = child.style[f'grid_{second_flow}_start']
            second_end = child.style[f'grid_{second_flow}_end']
            second_placement = _get_placement(
                second_start, second_end, second_tracks[::2])
            remaining_grid_items.append(child)
            if second_placement:
                i, size = second_placement
            else:
                continue
        implicit_second_1 = min(i, implicit_second_1)
        implicit_second_2 = max(i + size, implicit_second_2)
    # 1.3.3 Add columns (resp. rows) to accommodate max track span.
    for child in remaining_grid_items:
        second_start = child.style[f'grid_{second_flow}_start']
        second_end = child.style[f'grid_{second_flow}_end']
        span = 1
        if second_start != 'auto' and second_start[0] == 'span':
            span = second_start[1]
        elif second_end != 'auto' and second_end[0] == 'span':
            span = second_end[1]
        implicit_second_2 = max(implicit_second_1 + (span or 1), implicit_second_2)

    # 1.4 Position the remaining grid items.
    implicit_first_1 = 0
    if first_flow == 'row':
        implicit_first_2 = len(grid_areas)
    else:
        implicit_first_2 = len(grid_areas[0]) if grid_areas else 0
    for position in children_positions.values():
        if first_flow == 'row':
            _, i, _, size = position
        else:
            i, _, size, _ = position
        implicit_first_1 = min(i, implicit_first_1)
        implicit_first_2 = max(i + size, implicit_first_2)
    cursor_first, cursor_second = implicit_first_1, implicit_second_1
    if 'dense' in flow:
        for child in remaining_grid_items:
            first_start = child.style[f'grid_{first_flow}_start']
            first_end = child.style[f'grid_{first_flow}_end']
            second_start = child.style[f'grid_{second_flow}_start']
            second_end = child.style[f'grid_{second_flow}_end']
            second_placement = _get_placement(
                second_start, second_end, second_tracks[::2])
            if second_placement:
                # 1. Set the row (resp. column) position of the cursor.
                cursor_first = implicit_first_1
                second_i, second_size = second_placement
                cursor_second = second_i
                # 2. Increment the cursor’s row (resp. column) position.
                for first_i in count(cursor_first):
                    if first_start == 'auto':
                        first_i, first_size = _get_placement(
                            (None, first_i + 1, None), first_end, first_tracks[::2])
                    else:
                        assert first_start[0] == 'span'
                        span = _get_span(first_start)
                        first_i, first_size = _get_placement(
                            first_start, (None, first_i + 1 + span, None),
                            first_tracks[::2])
                    if first_i < cursor_first:
                        continue
                    for _ in range(first_i, first_i + first_size):
                        if first_flow == 'row':
                            x, y = second_i, first_i
                            width, height = second_size, first_size
                        else:
                            x, y = first_i, second_i
                            width, height = first_size, second_size
                        intersect = _intersect_with_children(
                            x, y, width, height, children_positions.values())
                        if intersect:
                            # Child intersects with a positioned child on
                            # current row.
                            break
                    else:
                        # Child doesn’t intersect with any positioned child on
                        # any row.
                        break
                first_diff = first_i + first_size - implicit_first_2
                if first_diff > 0:
                    implicit_first_2 += first_diff
                # 3. Set the item’s row-start line.
                if first_flow == 'row':
                    x, y = second_i, first_i
                    width, height = second_size, first_size
                else:
                    x, y = first_i, second_i
                    width, height = first_size, second_size
                children_positions[child] = (x, y, width, height)
            else:
                # 1. Set the cursor’s row and column positions.
                cursor_first, cursor_second = implicit_first_1, implicit_second_1
                while True:
                    # 2. Increment the column (resp. row) position of the cursor.
                    first_i = cursor_first
                    for second_i in range(cursor_second, implicit_second_2):
                        if first_start == 'auto':
                            first_i, first_size = _get_placement(
                                (None, first_i + 1, None), first_end, first_tracks[::2])
                        else:
                            assert first_start[0] == 'span'
                            span = _get_span(first_start)
                            first_i, first_size = _get_placement(
                                first_start, (None, first_i + 1 + span, None),
                                first_tracks[::2])
                        if second_start == 'auto':
                            second_i, second_size = _get_placement(
                                (None, second_i + 1, None), second_end,
                                second_tracks[::2])
                        else:
                            span = _get_span(second_start)
                            second_i, second_size = _get_placement(
                                second_start, (None, second_i + 1 + span, None),
                                second_tracks[::2])
                        if first_flow == 'row':
                            x, y = second_i, first_i
                            width, height = second_size, first_size
                        else:
                            x, y = first_i, second_i
                            width, height = first_size, second_size
                        intersect = _intersect_with_children(
                            x, y, width, height, children_positions.values())
                        overflow = second_i + second_size > implicit_second_2
                        if intersect or overflow:
                            # Child intersects with a positioned child or overflows.
                            continue
                        else:
                            # Free place found.
                            # 3. Set the item’s row-/column-start lines.
                            children_positions[child] = (x, y, width, height)
                            first_diff = (
                                cursor_first + first_size - 1 - implicit_first_2)
                            if first_diff > 0:
                                implicit_first_2 += first_diff
                            break
                    else:
                        # No room found.
                        # 2. Return to the previous step.
                        cursor_first += 1
                        first_diff = cursor_first + 1 - implicit_first_2
                        if first_diff > 0:
                            implicit_first_2 += first_diff
                        cursor_second = implicit_second_1
                        continue
                    break
    else:
        for child in remaining_grid_items:
            first_start = child.style[f'grid_{first_flow}_start']
            first_end = child.style[f'grid_{first_flow}_end']
            second_start = child.style[f'grid_{second_flow}_start']
            second_end = child.style[f'grid_{second_flow}_end']
            second_placement = _get_placement(
                second_start, second_end, second_tracks[::2])
            if second_placement:
                # 1. Set the column (resp. row) position of the cursor.
                second_i, second_size = second_placement
                if second_i < cursor_second:
                    cursor_first += 1
                cursor_second = second_i
                # 2. Increment the cursor’s row (resp. column) position.
                for cursor_first in count(cursor_first):
                    if first_start == 'auto':
                        first_i, first_size = _get_placement(
                            (None, cursor_first + 1, None), first_end,
                            first_tracks[::2])
                    else:
                        assert first_start[0] == 'span'
                        span = _get_span(first_start)
                        first_i, first_size = _get_placement(
                            first_start, (None, first_i + 1 + span, None),
                            first_tracks[::2])
                    if first_i < cursor_first:
                        continue
                    for row in range(first_i, first_i + first_size):
                        if first_flow == 'row':
                            x, y = second_i, first_i
                            width, height = second_size, first_size
                        else:
                            x, y = first_i, second_i
                            width, height = first_size, second_size
                        intersect = _intersect_with_children(
                            x, y, width, height, children_positions.values())
                        if intersect:
                            # Child intersects with a positioned child on
                            # current row.
                            break
                    else:
                        # Child doesn’t intersect with any positioned child on
                        # any row.
                        break
                first_diff = first_i + first_size - implicit_first_2
                if first_diff > 0:
                    implicit_first_2 += first_diff
                # 3. Set the item’s row-start line.
                children_positions[child] = (x, y, width, height)
            else:
                while True:
                    # 1. Increment the column position of the cursor.
                    first_i = cursor_first
                    for second_i in range(cursor_second, implicit_second_2):
                        if first_start == 'auto':
                            first_i, first_size = _get_placement(
                                (None, first_i + 1, None), first_end, first_tracks[::2])
                        else:
                            span = _get_span(first_start)
                            first_i, first_size = _get_placement(
                                first_start, (None, first_i + 1 + span, None),
                                first_tracks[::2])
                        if second_start == 'auto':
                            second_i, second_size = _get_placement(
                                (None, second_i + 1, None), second_end,
                                second_tracks[::2])
                        else:
                            span = _get_span(second_start)
                            second_i, second_size = _get_placement(
                                second_start, (None, second_i + 1 + span, None),
                                second_tracks[::2])
                        if first_flow == 'row':
                            x, y = second_i, first_i
                            width, height = second_size, first_size
                        else:
                            x, y = first_i, second_i
                            width, height = first_size, second_size
                        intersect = _intersect_with_children(
                            x, y, width, height, children_positions.values())
                        overflow = second_i + second_size > implicit_second_2
                        if intersect or overflow:
                            # Child intersects with a positioned child or overflows.
                            continue
                        else:
                            # Free place found.
                            # 2. Set the item’s row-/column-start lines.
                            children_positions[child] = (x, y, width, height)
                            break
                    else:
                        # No room found.
                        # 2. Return to the previous step.
                        cursor_first += 1
                        first_diff = cursor_first + 1 - implicit_first_2
                        if first_diff > 0:
                            implicit_first_2 += first_diff
                        cursor_second = implicit_second_1
                        continue
                    break

    if first_flow == 'row':
        implicit_x1, implicit_x2 = implicit_second_1, implicit_second_2
        implicit_y1, implicit_y2 = implicit_first_1, implicit_first_2
    else:
        implicit_x1, implicit_x2 = implicit_first_1, implicit_first_2
        implicit_y1, implicit_y2 = implicit_second_1, implicit_second_2
    for _ in range(0 - implicit_x1):
        columns.insert(0, next(auto_columns_back))
        columns.insert(0, [])
    for _ in range(len(grid_areas[0]) if grid_areas else 0, implicit_x2):
        columns.append(next(auto_columns))
        columns.append([])
    for _ in range(0 - implicit_y1):
        rows.insert(0, next(auto_rows_back))
        rows.insert(0, [])
    for _ in range(len(grid_areas), implicit_y2):
        rows.append(next(auto_rows))
        rows.append([])

    page_breaks_by_row = defaultdict(
        lambda: {'before': 'auto', 'after': 'auto', 'inside': 'auto'})
    for child, (x, y, width, height) in children_positions.items():
        row_page_break = page_breaks_by_row[y]
        if child.style['break_inside'] in ('avoid', 'avoid-page'):
            row_page_break['inside'] = 'avoid'
        for side in ('before', 'after'):
            if child.style[f'break_{side}'] in ('avoid', 'avoid-page'):
                if row_page_break[side] != 'page':
                    row_page_break[side] = 'avoid'
            elif child.style[f'break_{side}'] in ('page', 'always'):
                row_page_break[side] = 'page'
            elif child.style[f'break_{side}'] in ('left', 'right', 'recto', 'verso'):
                row_page_break[side] = child.style[f'break_{side}']

    # 2. Find the size of the grid container.

    if isinstance(box, boxes.GridBox):
        from .block import block_level_width
        block_level_width(box, containing_block)
    else:
        assert isinstance(box, boxes.InlineGridBox)
        from .inline import inline_block_width
        inline_block_width(box, context, containing_block)
    if box.width == 'auto':
        # TODO: Calculate max-width.
        box.width = containing_block.width

    # 3. Run the grid sizing algorithm.

    # 3.0 List min/max sizing functions.
    row_sizing_functions = [_get_sizing_functions(row) for row in rows[1::2]]
    column_sizing_functions = [
        _get_sizing_functions(column) for column in columns[1::2]]

    # 3.1 Resolve the sizes of the grid columns.
    columns_sizes = _resolve_tracks_sizes(
        column_sizing_functions, box.width, children_positions, implicit_second_1,
        'x', column_gap, context, box)

    # 3.2 Resolve the sizes of the grid rows.
    vertical_sizes = [size for size, _ in columns_sizes]
    rows_sizes = _resolve_tracks_sizes(
        row_sizing_functions, box.height, children_positions, implicit_y1, 'y',
        row_gap, context, box, vertical_sizes)

    # 3.3 Re-resolve the sizes of the grid columns with min-/max-content.
    # TODO: Re-resolve.

    # 3.4 Re-re-resolve the sizes of the grid columns with min-/max-content.
    # TODO: Re-re-resolve.

    # 3.5 Align the tracks within the grid container.
    # TODO: Support safe/unsafe.
    justify_content = set(box.style['justify_content'])
    x = box.content_box_x()
    free_width = max(0, box.width - sum(size for size, _ in columns_sizes))
    columns_positions = []
    columns_number = len(columns_sizes)
    if justify_content & {'center'}:
        x += free_width / 2
        for size, _ in columns_sizes:
            columns_positions.append(x)
            x += size + column_gap
    elif justify_content & {'right', 'end', 'flex-end'}:
        x += free_width
        for size, _ in columns_sizes:
            columns_positions.append(x)
            x += size + column_gap
    elif justify_content & {'space-around'}:
        x += free_width / 2 / columns_number
        for size, _ in columns_sizes:
            columns_positions.append(x)
            x += size + free_width / columns_number + column_gap
    elif justify_content & {'space-between'}:
        for size, _ in columns_sizes:
            columns_positions.append(x)
            if columns_number >= 2:
                x += size + free_width / (columns_number - 1) + column_gap
    elif justify_content & {'space-evenly'}:
        x += free_width / (columns_number + 1)
        for size, _ in columns_sizes:
            columns_positions.append(x)
            x += size + free_width / (columns_number + 1) + column_gap
    else:
        for size, _ in columns_sizes:
            columns_positions.append(x)
            x += size + column_gap

    align_content = set(box.style['align_content'])
    y = box.content_box_y()
    if box.height == 'auto':
        free_height = 0
    else:
        free_height = (
            box.height -
            sum(size for size, _ in rows_sizes) -
            (len(rows_sizes) - 1) * row_gap)
        free_height = max(0, free_height)
    rows_positions = []
    rows_number = len(rows_sizes)
    if align_content & {'center'}:
        y += free_height / 2
        for size, _ in rows_sizes:
            rows_positions.append(y)
            y += size + row_gap
    elif align_content & {'right', 'end', 'flex-end'}:
        y += free_height
        for size, _ in rows_sizes:
            rows_positions.append(y)
            y += size + row_gap
    elif align_content & {'space-around'}:
        y += free_height / 2 / rows_number
        for size, _ in rows_sizes:
            rows_positions.append(y)
            y += size + free_height / rows_number + row_gap
    elif align_content & {'space-between'}:
        for size, _ in rows_sizes:
            rows_positions.append(y)
            if rows_number >= 2:
                y += size + free_height / (rows_number - 1) + row_gap
    elif align_content & {'space-evenly'}:
        y += free_height / (rows_number + 1)
        for size, _ in rows_sizes:
            rows_positions.append(y)
            y += size + free_height / (rows_number + 1) + row_gap
    else:
        if align_content & {'baseline'}:
            # TODO: Support baseline value.
            LOGGER.warning('Baseline alignment is not supported for grid layout')
        for size, _ in rows_sizes:
            rows_positions.append(y)
            y += size + row_gap

    # 4. Lay out the grid items into their respective containing blocks.

    # Find resume_at row.
    this_page_children = []
    resume_row = None
    extra_skip_height = 0
    if skip_stack:
        from .block import block_level_layout
        first_skip_row = min(skip_stack)
        last_skip_row = max(skip_stack)
        skip_height = (
            sum(size for size, _ in rows_sizes[:last_skip_row]) +
            (len(rows_sizes[:last_skip_row]) - 1) * row_gap)
        for child, (x, y, width, height) in children_positions.items():
            if (advancement := box.advancements.get((x, y))) is None:
                continue
            span = _get_span(child.style['grid_row_start'])
            span_height = (
                sum(size for size, _ in rows_sizes[y:y+span]) +
                (span - 1) * row_gap)
            index = tuple(children_positions).index(child)
            width = sum(vertical_sizes[x:x+width])
            child = child.deepcopy()
            child.position_x = 0
            child.position_y = 0
            if y in skip_stack:
                child_skip_stack = skip_stack[y].get(index)
            else:
                child_skip_stack = None
            parent = boxes.BlockContainerBox.anonymous_from(containing_block, ())
            resolve_percentages(parent, containing_block)
            parent.position_x = 0
            parent.position_y = 0
            parent.width = width
            parent.height = 0
            child, _, _, _, _, _ = block_level_layout(
                context, child, bottom_space=-inf, skip_stack=child_skip_stack,
                containing_block=parent)
            skip_stack_advancement = span_height - child.margin_height()
            if skip_stack_advancement < advancement:
                extra_skip_height = max(
                    extra_skip_height, advancement - skip_stack_advancement)
        for (x, y), advancement in box.advancements.items():
            if y != last_skip_row:
                continue
            skip_height += advancement
            break
        else:
            extra_skip_height = 0
        skip_height -= extra_skip_height
    else:
        first_skip_row = last_skip_row = skip_height = 0
    resume_at = None
    total_height = (
        sum(size for size, _ in rows_sizes[last_skip_row:]) +
        (len(rows_sizes[last_skip_row:]) - 1) * row_gap)

    def _add_page_children(max_row=inf):
        for j, child in enumerate(children):
            _, y, _, _ = children_positions[child]
            if not first_skip_row <= y < max_row:
                # Item in previous or next rows.
                continue
            if skip_stack is None:
                # No skip stack, draw on this page.
                this_page_children.append((j, child))
            elif y > last_skip_row:
                # Row after the skip stack, draw on this page.
                this_page_children.append((j, child))
            elif y in skip_stack:
                child_skip_stack = skip_stack[y]
                if child_skip_stack is None or j in child_skip_stack:
                    # Child in skip stack, draw on this page.
                    this_page_children.append((j, child))

    row_lines_positions = (
        [*rows_positions[first_skip_row + 1:], box.content_box_y() + total_height])
    for i, row_y in enumerate(row_lines_positions, start=first_skip_row):
        # TODO: handle break-before and break-after for rows.
        if not context.overflows_page(bottom_space, row_y - skip_height):
            # No need to force rendering, at least a whole row fits in page.
            page_is_empty = False
            continue
        resume_row = i
        if box.style['break_inside'] == 'avoid' and not page_is_empty:
            # Avoid breaks inside grid container, break before.
            context.finish_block_formatting_context(box)
            return None, None, {'break': 'any', 'page': None}, [], False
        if page_breaks_by_row[i]['inside'] == 'avoid' and not page_is_empty:
            # Break before current row.
            if resume_row == 0:
                # First row, break before grid container.
                context.finish_block_formatting_context(box)
                return None, None, {'break': 'any', 'page': None}, [], False
            # Mark all children before and in current row as drawn on the page.
            _add_page_children(resume_row)
            resume_at = {resume_row: None}
        else:
            # Break inside current row.
            # Mark all children before current row as drawn on the page.
            _add_page_children(resume_row + 1)
        break
    else:
        # Mark all children as drawn on the page.
        _add_page_children()
    if box.height == 'auto':
        box.height = (
            sum(size for size, _ in rows_sizes[:resume_row]) +
            (len(rows_sizes[:resume_row]) - 1) * row_gap) - skip_height

    # Lay out grid items.
    justify_items = set(box.style['justify_items'])
    align_items = set(box.style['align_items'])
    new_children = []
    new_children_by_rows = defaultdict(list)
    baseline = None
    next_page = {'break': 'any', 'page': None}
    from .block import block_level_layout
    for i, child in this_page_children:
        x, y, width, height = children_positions[child]
        index = children.index(child)
        if skip_stack and skip_stack.get(y):
            if index in skip_stack[y]:
                child_skip_stack = skip_stack[y][index]
            else:
                assert isinstance(child, boxes.ParentBox)
                child_skip_stack = {len(child.children): None}
        else:
            child_skip_stack = None
        child = child.deepcopy()
        child.position_x = columns_positions[x]
        child.position_y = rows_positions[y] - skip_height
        resolve_percentages(child, box)
        width = (
            sum(size for size, _ in columns_sizes[x:x+width]) +
            (width - 1) * column_gap)
        height = (
            sum(size for size, _ in rows_sizes[y:y+height]) +
            (height - 1) * row_gap)
        if skip_stack and (x, y) in box.advancements:
            child.position_y += box.advancements[x, y] - extra_skip_height
            height -= box.advancements[x, y] - extra_skip_height

        # TODO: Apply auto margin.
        if child.margin_top == 'auto':
            child.margin_top = 0
        if child.margin_right == 'auto':
            child.margin_right = 0
        if child.margin_bottom == 'auto':
            child.margin_bottom = 0
        if child.margin_left == 'auto':
            child.margin_left = 0

        child_border_width = width - (child.margin_left + child.margin_right)
        child_content_width = child_border_width - (
                child.border_left_width + child.padding_left +
                child.border_right_width + child.padding_right)
        child_border_height = height - child.margin_bottom
        child_content_height = child_border_height - (
            child.border_bottom_width + child.padding_bottom)
        if not child_skip_stack or child.style['box_decoration_break'] == 'clone':
            child_border_height -= child.margin_top
            child_content_height -= (
                child.margin_top + child.border_top_width + child.padding_top)

        justify_self = set(child.style['justify_self'])
        if justify_self & {'auto'}:
            justify_self = justify_items
        if justify_self & {'normal', 'stretch'}:
            if child.style['width'] == 'auto':
                child.style = child.style.copy()
                child_width = (
                    child_content_width if child.style['box_sizing'] == 'content-box'
                    else child_border_width)
                child.style['width'] = Dimension(child_width, 'px')
        align_self = set(child.style['align_self'])
        if align_self & {'auto'}:
            align_self = align_items
        if align_self & {'normal', 'stretch'}:
            if child.style['height'] == 'auto':
                child.style = child.style.copy()
                child_height = (
                    child_content_height if child.style['box_sizing'] == 'content-box'
                    else child_border_height)
                child.style['height'] = Dimension(child_height, 'px')

        # TODO: Find a better solution for the layout.
        parent = boxes.BlockContainerBox.anonymous_from(box, ())
        resolve_percentages(parent, containing_block)
        parent.position_x = child.position_x
        parent.position_y = child.position_y
        parent.width = width
        parent.height = height
        new_child, child_resume_at, child_next_page = block_level_layout(
            context, child, bottom_space, child_skip_stack, parent,
            page_is_empty, absolute_boxes, fixed_boxes)[:3]
        if new_child:
            broken_child = False
            span = _get_span(child.style['grid_row_start'])
            if child_resume_at:
                broken_child = True
            elif resume_row is not None and y + span >= resume_row + 1:
                broken_child = True
            if broken_child:
                # Child is broken, add row to resume_at.
                if resume_at is None:
                    resume_at = {}
                if y not in resume_at:
                    resume_at[y] = {}
            if child_resume_at:
                # There is some content left for next page, save the cell’s resume_at.
                resume_at[y][i] = child_resume_at
            elif broken_child:
                # Everything fits but the cell overflows. Only display the bottom of an
                # empty cell on next page, set the cell’s resume_at after the cell’s
                # last child.
                assert isinstance(new_child, boxes.ParentBox)
                previous_skip_child = max(child_skip_stack) if child_skip_stack else 0
                if not page_is_empty:
                    resume_at[y][i] = {
                        previous_skip_child + len(new_child.children): None}
            page_is_empty = False
        else:
            if resume_at is None:
                resume_at = {}
            if y not in resume_at:
                resume_at[y] = {}
            resume_at[y][i] = None
            continue

        if justify_self & {'normal', 'stretch'}:
            new_child.width = max(child_content_width, new_child.width)
        else:
            if new_child.style['width'] == 'auto':
                new_child.width = max_content_width(context, new_child, outer=False)
            diff = child_content_width - new_child.width
            if justify_self & {'center'}:
                new_child.translate(diff / 2, 0)
            elif justify_self & {'right', 'end', 'flex-end', 'self-end'}:
                new_child.translate(diff, 0)

        # TODO: Apply auto margins.
        if align_self & {'normal', 'stretch'}:
            new_child.height = max(child_content_height, new_child.height)
        else:
            diff = child_content_height - new_child.height
            if align_self & {'center'}:
                new_child.translate(0, diff / 2)
            elif align_self & {'end', 'flex-end', 'self-end'}:
                new_child.translate(0, diff)

        new_children.append(new_child)
        new_children_by_rows[y].append((x, new_child))
        if baseline is None and y == implicit_y1:
            baseline = find_in_flow_baseline(new_child)

    # Abort whole grid rendering if no child fits.
    if this_page_children and not new_children:
        context.finish_block_formatting_context(box)
        return None, None, {'break': 'any', 'page': None}, [], False

    old_advancements = box.advancements.copy()
    advancements = box.advancements
    advancements.clear()
    box = box.copy_with_children(new_children)
    if isinstance(box, boxes.InlineGridBox):
        # TODO: Synthetize a real baseline value.
        LOGGER.warning('Inline grids are not supported')
        box.baseline = baseline or 0

    from .absolute import absolute_layout
    from .block import relative_positioning

    if box.style['position'] == 'relative':
        # New containing block, resolve the layout of the absolute descendants
        for absolute_box in absolute_boxes:
            absolute_layout(
                context, absolute_box, box, fixed_boxes, bottom_space,
                skip_stack=None)

    for child in box.children:
        relative_positioning(child, (box.width, box.height))

    # Resume early when there’s no resume_at.
    if not resume_at:
        context.finish_block_formatting_context(box)
        return box, resume_at, next_page, [], False

    # Set broken rows’ bottom at the bottom of the page.
    last_page_row = max(new_children_by_rows)
    next_page_first_row = min(resume_at)
    next_page_last_row = max(resume_at)
    extra_advancement = 0
    for y in range(last_page_row, next_page_first_row - 1, -1):
        for x, child in new_children_by_rows[y]:
            span = _get_span(child.style['grid_row_start'])
            if y + span < last_page_row + 1:
                # Child finishing before the last row, do nothing.
                continue
            broken_child = y + span >= next_page_last_row + 1
            if broken_child and child.style['box_decoration_break'] != 'clone':
                child.remove_decoration(start=False, end=True)
            child.height = max(0, (
                context.page_bottom - bottom_space - child.position_y -
                child.margin_top - child.border_top_width - child.padding_top -
                child.margin_bottom - child.border_bottom_width - child.padding_bottom))
            if broken_child:
                # Child not fully drawn, keep advancement.
                advancements[x, y] = child.margin_height()
                if (x, y) in old_advancements:
                    advancements[x, y] += old_advancements[x, y] - extra_skip_height
            else:
                # Child fully drawn, save the extra height added to reach the bottom of
                # the page to substract it from the advancements.
                extra_advancement = max(
                    extra_advancement, child.height - child_content_height)

    # Substract the extra height added to reach the bottom of the page from all the
    # advancements.
    if extra_advancement:
        for x, y in advancements:
            advancements[x, y] -= extra_advancement

    # Set box height and remove bottom decoration.
    box.height = (
        context.page_bottom - bottom_space - box.position_y -
        box.margin_top - box.border_top_width - box.padding_top)
    if box.style['box_decoration_break'] != 'clone':
        box.remove_decoration(start=False, end=True)
        box.height -= box.margin_bottom + box.border_bottom_width + box.padding_bottom

    context.finish_block_formatting_context(box)
    return box, resume_at, next_page, [], False


================================================
FILE: weasyprint/layout/inline.py
================================================
"""Layout for inline-level boxes."""

import unicodedata
from math import inf

from ..css import AnonymousStyle, Pending
from ..css.properties import INHERITED
from ..formatting_structure import boxes, build
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 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_line_style):
    """Return an iterator of ``(line, resume_at)``.

    ``line`` is a laid-out LineBox with as much content as possible that
    fits in the available width.

    """
    resolve_percentages(box, containing_block)
    if skip_stack is None:
        # 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, first_line_style)
        first_line_style = None
        if line:
            handle_leader(context, line, containing_block)
            position_y = line.position_y + line.height
        if line is None:
            return
        yield line, resume_at
        if resume_at is None:
            return
        skip_stack = resume_at
        box.text_indent = 0
        first_letter_style = None


def get_next_linebox(context, linebox, position_y, bottom_space, skip_stack,
                     containing_block, absolute_boxes, fixed_boxes,
                     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

    skip_stack = first_letter_to_box(linebox, skip_stack, first_letter_style)

    linebox.position_y = position_y

    if context.excluded_shapes:
        # 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(linebox.style)
    else:
        # No float, width and height will be set by the lines
        linebox.width = linebox.height = 0
    position_x, position_y, available_width = avoid_collisions(
        context, linebox, containing_block, outer=False)

    candidate_height = linebox.height

    excluded_shapes = context.excluded_shapes.copy()

    while True:
        original_position_x = linebox.position_x = position_x
        original_position_y = linebox.position_y = position_y
        original_width = linebox.width
        max_x = position_x + available_width
        position_x += linebox.text_indent

        line_placeholders = []
        line_absolutes = []
        line_fixed = []
        waiting_floats = []
        line_children = []

        (line, resume_at, preserved_line_break, first_letter,
         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, first_letter_style, first_line_style)
        linebox.width, linebox.height = line.width, line.height

        if is_phantom_linebox(line) and not preserved_line_break:
            line.height = 0
            break

        remove_last_whitespace(context, line)

        new_position_x, _, new_available_width = avoid_collisions(
            context, linebox, containing_block, outer=False)
        offset_x = text_align(
            context, line, new_available_width,
            last=(resume_at is None or preserved_line_break))
        if containing_block.style['direction'] == 'rtl':
            offset_x *= -1
            offset_x -= line.width

        bottom, top = line_box_verticality(line)
        assert top is not None
        assert bottom is not None
        line.baseline = -top
        line.position_y = top
        line.height = bottom - top
        offset_y = position_y - top
        line.margin_top = 0
        line.margin_bottom = 0

        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 issue #583.
        line.position_y = position_y

        if line.height <= candidate_height:
            break
        candidate_height = line.height

        new_excluded_shapes = context.excluded_shapes
        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)
        else:
            condition = (position_x + line.width, position_y) == (
                original_position_x + original_width, original_position_y)
        if condition:
            context.excluded_shapes = new_excluded_shapes
            break

    absolute_boxes.extend(line_absolutes)
    fixed_boxes.extend(line_fixed)

    for placeholder in line_placeholders:
        if 'inline' in placeholder.style.specified['display']:
            # Inline-level static position:
            placeholder.translate(0, position_y - placeholder.position_y)
        else:
            # Block-level static position: at the start of the next line
            placeholder.translate(
                line.position_x - placeholder.position_x,
                position_y + line.height - placeholder.position_y)

    float_children = []
    waiting_floats_y = line.position_y + line.height
    for waiting_float in waiting_floats:
        waiting_float.position_y = waiting_floats_y
        new_waiting_float, waiting_float_resume_at = float_layout(
            context, waiting_float, containing_block, absolute_boxes,
            fixed_boxes, bottom_space, skip_stack=None)
        float_children.append(new_waiting_float)
        if 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)

    return line, resume_at


def skip_first_whitespace(box, skip_stack):
    """Return ``skip_stack`` to start just after removable leading spaces.

    See https://www.w3.org/TR/CSS21/text.html#white-space-model

    """
    if skip_stack is None:
        index = 0
        next_skip_stack = None
    else:
        (index, next_skip_stack), = skip_stack.items()

    if isinstance(box, boxes.TextBox):
        assert next_skip_stack is None
        white_space = box.style['white_space']
        text = box.text.encode()
        if index == len(text):
            # Starting a the end of the TextBox, no text to see: Continue
            return 'continue'
        if white_space in ('normal', 'nowrap', 'pre-line'):
            text = text[index:]
            while text and text.startswith(b' '):
                index += 1
                text = text[1:]
        return {index: None} if index else None

    if isinstance(box, (boxes.LineBox, boxes.InlineBox)):
        if index == 0 and not box.children:
            return None
        result = skip_first_whitespace(box.children[index], next_skip_stack)
        if result == 'continue':
            index += 1
            if index >= len(box.children):
                return 'continue'
            result = skip_first_whitespace(box.children[index], None)
        return {index: result} if (index or result) else None

    assert skip_stack is None, f'unexpected skip inside {box}'
    return None


def remove_last_whitespace(context, line):
    """Remove in place space characters at the end of a line.

    This also reduces the width and position of the inline parents of the
    modified text.

    """
    ancestors = []
    box = line
    while isinstance(box, (boxes.LineBox, boxes.InlineBox)):
        ancestors.append(box)
        if not box.children:
            return
        box = box.children[-1]
    if not (isinstance(box, boxes.TextBox) and
            box.style['white_space'] in ('normal', 'nowrap', 'pre-line')):
        return
    new_text = box.text.rstrip(' ')
    if new_text:
        if len(new_text) == len(box.text):
            return
        box.text = new_text
        new_box, resume, _ = split_text_box(context, box, None, 0)
        assert new_box is not None
        assert resume is None
        space_width = box.width - new_box.width
        box.width = new_box.width
    else:
        space_width = box.width
        box.width = 0
        box.text = ''

    # RTL line, the trailing space is at the left of the box. We have to translate the
    # box to align the stripped text with the right edge of the box.
    if box.pango_layout.first_line_direction % 2:
        for child in line.children:
            child.translate(dx=-space_width, ignore_floats=True)

    for ancestor in ancestors:
        ancestor.width -= space_width

    # TODO: All tabs (U+0009) are rendered as a horizontal shift that
    # lines up the start edge of the next glyph with the next tab stop.
    # Tab stops occur at points that are multiples of 8 times the width
    # of a space (U+0020) rendered in the block's font from the block's
    # starting content edge.

    # TODO: If spaces (U+0020) or tabs (U+0009) at the end of a line have
    # 'white-space' set to 'pre-wrap', UAs may visually collapse them.


def first_letter_to_box(box, skip_stack, first_letter_style):
    """Create a box for the ::first-letter selector."""
    if first_letter_style and box.children:
        # Some properties must be ignored in first-letter boxes.
        # https://drafts.csswg.org/selectors-3/#application-in-css
        # At least, position is ignored to avoid layout troubles.
        first_letter_style['position'] = 'static'

        first_letter = ''
        child = box.children[0]
        if isinstance(child, boxes.TextBox):
            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,
                    box.element, [child])
                box.children = ((letter_box, *box.children[1:]))
            elif child.text:
                character_found = False
                if skip_stack:
                    child_skip_stack, = skip_stack.values()
                    if child_skip_stack:
                        index, = child_skip_stack
                        child.text = child.text[index:]
                        skip_stack = None
                while child.text:
                    next_letter = child.text[0]
                    category = unicodedata.category(next_letter)
                    if category not in ('Ps', 'Pe', 'Pi', 'Pf', 'Po'):
                        if character_found:
                            break
                        character_found = True
                    first_letter += next_letter
                    child.text = child.text[1:]
                if first_letter.lstrip('\n'):
                    # "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."
                    children_style = AnonymousStyle(letter_style)
                    if letter_style['float'] == 'none':
                        letter_box = boxes.InlineBox(
                            f'{box.element_tag}::first-letter',
                            letter_style, box.element, [])
                        text_box = boxes.TextBox(
                            f'{box.element_tag}::first-letter', children_style,
                            box.element, first_letter)
                        letter_box.children = (text_box,)
                        box.children = (letter_box, *box.children)
                    else:
                        letter_box = boxes.BlockBox(
                            f'{box.element_tag}::first-letter',
                            letter_style, box.element, [])
                        line_box = boxes.LineBox(
                            f'{box.element_tag}::first-letter', children_style,
                            box.element, [])
                        letter_box.children = (line_box,)
                        text_box = boxes.TextBox(
                            f'{box.element_tag}::first-letter', children_style,
                            box.element, first_letter)
                        line_box.children = (text_box,)
                        box.children = (letter_box, *box.children)
                    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}}
        elif isinstance(child, boxes.ParentBox):
            if skip_stack:
                child_skip_stack, = skip_stack.values()
            else:
                child_skip_stack = None
            child_skip_stack = first_letter_to_box(
                child, child_skip_stack, first_letter_style)
            if skip_stack:
                index, = skip_stack
                skip_stack = {index: child_skip_stack}
    return skip_stack


def atomic_box(context, box, position_x, skip_stack, containing_block,
               absolute_boxes, fixed_boxes):
    """Compute the width and the height of the atomic ``box``."""
    if isinstance(box, boxes.ReplacedBox):
        box = box.copy()
        inline_replaced_box_layout(box, containing_block)
        box.baseline = box.margin_height()
    elif isinstance(box, boxes.InlineBlockBox):
        if box.is_table_wrapper:
            containing_size = (containing_block.width, containing_block.height)
            table_wrapper_width(context, box, containing_size)
            width, min_width, max_width = box.width, box.min_width, box.max_width
        box = inline_block_box_layout(
            context, box, position_x, skip_stack, containing_block,
            absolute_boxes, fixed_boxes)
        if box.is_table_wrapper:
            box.width, box.min_width, box.max_width = width, min_width, max_width
    else:  # pragma: no cover
        raise TypeError(f'Layout for {type(box).__name__} not handled yet')
    return box


def inline_block_box_layout(context, box, position_x, skip_stack,
                            containing_block, absolute_boxes, fixed_boxes):
    from .block import block_container_layout

    resolve_percentages(box, containing_block)

    # https://www.w3.org/TR/CSS21/visudet.html#inlineblock-width
    if box.margin_left == 'auto':
        box.margin_left = 0
    if box.margin_right == 'auto':
        box.margin_right = 0
    # https://www.w3.org/TR/CSS21/visudet.html#block-root-margin
    if box.margin_top == 'auto':
        box.margin_top = 0
    if box.margin_bottom == 'auto':
        box.margin_bottom = 0

    inline_block_width(box, context, containing_block)

    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,
        first_letter_style=None, first_line_style=None, discard=False, max_lines=None)
    box.baseline = inline_block_baseline(box)
    return box


def inline_block_baseline(box):
    """Return the y position of the baseline for an inline block.

    Position is taken from the top of its margin box.

    https://www.w3.org/TR/CSS21/visudet.html#propdef-vertical-align

    """
    if box.is_table_wrapper:
        # Inline table's baseline is its first row's baseline
        for child in box.children:
            if isinstance(child, boxes.TableBox):
                if child.children and child.children[0].children:
                    first_row = child.children[0].children[0]
                    return first_row.baseline
    elif box.style['overflow'] == 'visible':
        result = find_in_flow_baseline(box, last=True)
        if result:
            return result
    return box.position_y + box.margin_height()


@handle_min_max_width
def inline_block_width(box, context, containing_block):
    available_content_width = containing_block.width - (
        box.margin_left + box.margin_right +
        box.border_left_width + box.border_right_width +
        box.padding_left + box.padding_right)
    if box.width == 'auto':
        box.width = shrink_to_fit(context, box, available_content_width)


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, 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.

    ``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.)

    """
    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):
        box.position_x = position_x
        if skip_stack is None:
            skip = 0
        else:
            (skip, skip_stack), = skip_stack.items()
            skip = skip or 0
            assert skip_stack is None

        is_line_start = len(line_children) == 0
        new_box, skip, preserved_line_break = split_text_box(
            context, box, max_x - position_x, skip,
            is_line_start=is_line_start)

        if skip is None:
            resume_at = None
        else:
            resume_at = {skip: None}
        if box.text:
            first_letter = box.text[0]
            if skip is None:
                last_letter = box.text[-1]
            else:
                last_letter = box.text.encode()[:skip].decode()[-1]
        else:
            first_letter = last_letter = None
    elif isinstance(box, boxes.InlineBox):
        if box.margin_left == 'auto':
            box.margin_left = 0
        if box.margin_right == 'auto':
            box.margin_right = 0
        (new_box, resume_at, preserved_line_break, first_letter,
         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, first_letter_style, first_line_style)
    elif isinstance(box, boxes.AtomicInlineLevelBox):
        new_box = atomic_box(
            context, box, position_x, skip_stack, containing_block,
            absolute_boxes, fixed_boxes)
        new_box.position_x = position_x
        resume_at = None
        preserved_line_break = False
        # See https://www.w3.org/TR/css-text-3/#line-breaking
        # Atomic inlines behave like ideographic characters.
        first_letter = '\u2e80'
        last_letter = '\u2e80'
    elif isinstance(box, boxes.InlineFlexBox):
        box.position_x = position_x
        box.position_y = 0
        for side in ('top', 'right', 'bottom', 'left'):
            if getattr(box, f'margin_{side}') == 'auto':
                setattr(box, f'margin_{side}', 0)
        new_box, resume_at, _, _, _ = flex_layout(
            context, box, -inf, skip_stack, containing_block, False,
            absolute_boxes, fixed_boxes, False)
        preserved_line_break = False
        first_letter = '\u2e80'
        last_letter = '\u2e80'
    elif isinstance(box, boxes.InlineGridBox):
        box.position_x = position_x
        box.position_y = 0
        for side in ('top', 'right', 'bottom', 'left'):
            if getattr(box, f'margin_{side}') == 'auto':
                setattr(box, f'margin_{side}', 0)
        new_box, resume_at, _, _, _ = grid_layout(
            context, box, -inf, skip_stack, containing_block, False,
            absolute_boxes, fixed_boxes)
        preserved_line_break = False
        first_letter = '\u2e80'
        last_letter = '\u2e80'
    else:  # pragma: no cover
        raise TypeError(f'Layout for {type(box).__name__} not handled yet')
    return (
        new_box, resume_at, preserved_line_break, first_letter, last_letter,
        float_widths)


def _out_of_flow_layout(context, box, containing_block, index, child,
                        children, line_children, waiting_children,
                        waiting_floats, absolute_boxes, fixed_boxes,
                        line_placeholders, float_widths, max_x, position_x,
                        bottom_space):
    if child.is_absolutely_positioned():
        child.position_x = position_x
        placeholder = AbsolutePlaceholder(child)
        line_placeholders.append(placeholder)
        waiting_children.append((index, placeholder, child))
        if child.style['position'] == 'absolute':
            absolute_boxes.append(placeholder)
        else:
            fixed_boxes.append(placeholder)

    elif child.is_floated():
        child.position_x = position_x
        float_width = shrink_to_fit(context, child, containing_block.width)

        # To retrieve the real available space for floats, we must remove
        # the trailing whitespaces from the line
        non_floating_children = [
            child_ for _, child_, _ in (children + waiting_children)
            if not child_.is_floated()]
        if non_floating_children:
            float_width -= trailing_whitespace_size(
                context, non_floating_children[-1])

        if float_width > max_x - position_x or waiting_floats:
            # TODO: the absolute and fixed boxes in the floats must be
            # added here, and not in iter_line_boxes
            waiting_floats.append(child)
        else:
            new_child, float_resume_at = float_layout(
                context, child, containing_block, absolute_boxes, fixed_boxes,
                bottom_space, skip_stack=None)
            if 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

            # Translate previous line children
            dx = max(child.margin_width(), 0)
            float_widths[child.style['float']] += dx

            float_left = child.style['float'] == 'left'
            float_right = child.style['float'] == 'right'
            if box.style['direction'] == 'ltr':
                if child.style['float'] == 'inline-start':
                    float_left = True
                if child.style['float'] == 'inline-end':
                    float_right = True
            else:
                if child.style['float'] == 'inline-start':
                    float_right = True
                if child.style['float'] == 'inline-end':
                    float_left = True

            if float_left:
                if isinstance(box, boxes.LineBox):
                    # The parent is the line, update the current position
                    # for the next child. When the parent is not the line
                    # (it is an inline block), the current position of the
                    # line is updated by the box itself (see next
                    # split_inline_level call).
                    position_x += dx
            elif float_right:
                # Update the maximum x position for the next children
                max_x -= dx
            for _, old_child in line_children:
                if not old_child.is_in_normal_flow():
                    continue
                float_align = (
                    (float_left and box.style['direction'] == 'ltr') or
                    (float_right and box.style['direction'] == 'rtl'))
                if float_align:
                    old_child.translate(dx=dx)

    elif child.is_running():
        running_name = child.style['position'][1]
        page = context.current_page
        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,
                            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,
        # fixed_boxes and other lists.
        waiting_children_copy = waiting_children.copy()
        while waiting_children_copy:
            child_index, child, original_child = waiting_children_copy.pop()
            if not child.is_in_normal_flow() or not can_break_inside(child):
                continue

            if initial_skip_stack and child_index in initial_skip_stack:
                child_skip_stack = initial_skip_stack[child_index]
            else:
                child_skip_stack = None

            # Break the waiting child at its last possible breaking point.
            # TODO: The dirty solution chosen here is to decrease the
            # actual size by 1 and render the waiting child again with this
            # constraint. We may find a better way.
            max_x = child.position_x + child.margin_width() - 1
            while max_x > child.position_x:
                new_child, child_resume_at, _, _, _, _ = split_inline_level(
                    context, original_child, child.position_x, max_x,
                    bottom_space, child_skip_stack, box, absolute_boxes,
                    fixed_boxes, line_placeholders, waiting_floats,
                    line_children, first_letter_style, first_line_style)
                if child_resume_at:
                    break
                max_x -= 1
            else:
                # No line break found
                continue

            children.extend(waiting_children_copy)
            if new_child is None:
                # May be None where we have an empty TextBox.
                assert isinstance(child, boxes.TextBox)
            else:
                children.append((child_index, new_child, child))

            return {child_index: child_resume_at}

    if children:
        # Too wide, can't break waiting children and the inline is
        # non-empty: put child entirely on the next line.
        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, 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,
    # but floating point errors have accumulated:
    #   width2 = (width + X) - X   # in some cases, width2 < width
    # Increase the value a bit to compensate and not introduce
    # an unexpected line break. The 1e-9 value comes from PEP 485.
    max_x *= 1 + 1e-9

    is_start = skip_stack is None
    initial_position_x = position_x
    initial_skip_stack = skip_stack
    assert isinstance(box, (boxes.LineBox, boxes.InlineBox))
    left_spacing = (
        box.padding_left + box.margin_left + box.border_left_width)
    right_spacing = (
        box.padding_right + box.margin_right + box.border_right_width)
    content_box_left = position_x

    children = []
    waiting_children = []
    preserved_line_break = False
    first_letter = last_letter = None
    float_widths = {'left': 0, 'right': 0}
    float_resume_index = 0

    if box.style['position'] == 'relative':
        absolute_boxes = []

    if is_start:
        skip = 0
    else:
        (skip, skip_stack), = skip_stack.items()

    for i, child in enumerate(box.children[skip:]):
        index = i + skip
        child.position_y = box.position_y

        if not child.is_in_normal_flow():
            _out_of_flow_layout(
                context, box, containing_block, index, child, children,
                line_children, waiting_children, waiting_floats,
                absolute_boxes, fixed_boxes, line_placeholders, float_widths,
                max_x, position_x, bottom_space)
            if child.is_floated():
                float_resume_index = index + 1
                if child not in waiting_floats:
                    max_x -= child.margin_width()
            continue

        is_last_child = (index == len(box.children) - 1)
        available_width = max_x
        child_waiting_floats = []
        new_child, resume_at, preserved, first, last, new_float_widths = (
            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,
                first_letter_style, first_line_style))
        if box.style['direction'] == 'rtl':
            end_spacing = left_spacing
            max_x -= new_float_widths['left']
        else:
            end_spacing = right_spacing
            max_x -= new_float_widths['right']
        if is_last_child and end_spacing and resume_at is None:
            # TODO: we should take care of children added into absolute_boxes,
            # fixed_boxes and other lists.
            available_width -= end_spacing
            new_child, resume_at, preserved, first, last, new_float_widths = (
                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,
                    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:
            preserved_line_break = True

        can_break = None
        if last_letter is True:
            last_letter = ' '
        elif last_letter is False:
            last_letter = ' '  # no-break space
        elif box.style['white_space'] in ('pre', 'nowrap'):
            can_break = False
        if can_break is None:
            if None in (last_letter, first):
                can_break = False
            elif first in (True, False):
                can_break = first
            else:
                can_break = can_break_text(
                    last_letter + first, child.style['lang'])

        if can_break:
            children.extend(waiting_children)
            waiting_children = []

        if first_letter is None:
            first_letter = first
        if child.trailing_collapsible_space:
            last_letter = True
        else:
            last_letter = last

        if new_child is None:
            # 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))

            # 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, first_letter_style,
                    first_line_style)
                if previous_resume_at:
                    resume_at = previous_resume_at
                    break

            position_x = new_position_x
            waiting_children.append((index, new_child, child))

        waiting_floats.extend(child_waiting_floats)
        if resume_at is not None:
            children.extend(waiting_children)
            resume_at = {index: resume_at}
            break
    else:
        children.extend(waiting_children)
        resume_at = None

    # Reorder inline blocks when direction is rtl
    if box.style['direction'] == 'rtl' and len(children) > 1:
        in_flow_children = [
            box_child for _, box_child, _ in children
            if box_child.is_in_normal_flow()]
        position_x = in_flow_children[0].position_x
        for child in in_flow_children[::-1]:
            child.translate(
                dx=(position_x - child.position_x), ignore_floats=True)
            position_x += child.margin_width()

    is_end = resume_at is None
    new_box = box.copy_with_children(
        [box_child for index, box_child, _ in children])
    new_box.remove_decoration(start=not is_start, end=not is_end)
    if isinstance(box, boxes.LineBox):
        # We must reset line box width according to its new children
        new_box.width = 0
        children = new_box.children
        if new_box.style['direction'] == 'ltr':
            children = children[::-1]
        for child in children:
            if child.is_in_normal_flow():
                new_box.width = (
                    child.position_x + child.margin_width() -
                    new_box.position_x)
                break
    else:
        new_box.position_x = initial_position_x
        if box.style['box_decoration_break'] == 'clone':
            translation_needed = True
        else:
            translation_needed = (
                is_start if box.style['direction'] == 'ltr' else is_end)
        if translation_needed:
            for child in new_box.children:
                child.translate(dx=left_spacing)
        new_box.width = position_x - content_box_left
        new_box.translate(dx=float_widths['left'], ignore_floats=True)

    _adjust_line_height(new_box)

    if new_box.style['position'] == 'relative':
        for absolute_box in absolute_boxes:
            absolute_layout(
                context, absolute_box, new_box, fixed_boxes, bottom_space,
                skip_stack=None)

    if resume_at is not None:
        index = next(iter(resume_at))
        if index < float_resume_index:
            resume_at = {float_resume_index: None}

    if box.is_leader:
        first_letter = True
        last_letter = False

    return (
        new_box, resume_at, preserved_line_break, first_letter, last_letter,
        float_widths)


def split_text_box(context, box, available_width, skip, is_line_start=True):
    """Keep as much text as possible from a TextBox in a limited width.

    Try not to overflow but always have some text in ``new_box``.

    Return ``(new_box, skip, preserved_line_break)``. ``skip`` is the number of
    UTF-8 bytes to skip form the start of the TextBox for the next line, or
    ``None`` if all of the text fits.

    Also break on preserved line breaks.

    """
    assert isinstance(box, boxes.TextBox)
    font_size = box.style['font_size']
    text = box.text.encode()[skip:]
    if font_size == 0 or not text:
        return None, None, False
    layout, length, resume_index, width, height, baseline = split_first_line(
        text.decode(), box.style, context, available_width,
        box.justification_spacing, is_line_start=is_line_start)
    assert resume_index != 0

    if length > 0:
        box = box.copy_with_text(layout.text)
        box.width = width
        box.pango_layout = layout
        # "The height of the content area should be based on the font,
        #  but this specification does not specify how."
        # https://www.w3.org/TR/CSS21/visudet.html#inline-non-replaced
        # We trust Pango and use the height of the LayoutLine.
        box.height = height
        # "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(box.style)
        half_leading = (line_height - height) / 2
        box.margin_top = half_leading
        box.margin_bottom = half_leading
        # form the top of the content box
        box.baseline = baseline
        # form the top of the margin box
        box.baseline += box.margin_top
    else:
        box = None

    if resume_index is None:
        preserved_line_break = False
    else:
        between = text[length:resume_index].decode()
        preserved_line_break = (
            (length != resume_index) and between.strip(' '))
        if preserved_line_break:
            # See https://unicode.org/reports/tr14/
            # \r is already handled by process_whitespace
            line_breaks = ('\n', '\t', '\f', '\u0085', '\u2028', '\u2029')
            assert between in line_breaks, (
                'Got %r between two lines. '
                'Expected nothing or a preserved line break' % (between,))
        resume_index += skip

    return box, resume_index, preserved_line_break


def line_box_verticality(box):
    """Handle ``vertical-align`` within a :class:`LineBox`.

    Place all boxes vertically assuming that the baseline of ``box``
    is at `y = 0`.

    Return ``(max_y, min_y)``, the maximum and minimum vertical position
    of margin boxes.

    """
    top_bottom_subtrees = []
    max_y, min_y = aligned_subtree_verticality(
        box, top_bottom_subtrees, baseline_y=0)
    subtrees_with_min_max = [
        (subtree, sub_max_y, sub_min_y)
        for subtree in top_bottom_subtrees
        for sub_max_y, sub_min_y in [
            (None, None) if subtree.is_floated()
            else aligned_subtree_verticality(
                subtree, top_bottom_subtrees, baseline_y=0)]]

    if subtrees_with_min_max:
        sub_positions = [
            sub_max_y - sub_min_y
            for subtree, sub_max_y, sub_min_y in subtrees_with_min_max
            if not subtree.is_floated()]
        if sub_positions:
            highest_sub = max(sub_positions)
            max_y = max(max_y, min_y + highest_sub)

    for subtree, sub_max_y, sub_min_y in subtrees_with_min_max:
        if subtree.is_floated():
            dy = min_y - subtree.position_y
        elif subtree.style['vertical_align'] == 'top':
            dy = min_y - sub_min_y
        else:
            assert subtree.style['vertical_align'] == 'bottom'
            dy = max_y - sub_max_y
        translate_subtree(subtree, dy)
    return max_y, min_y


def translate_subtree(box, dy):
    if isinstance(box, boxes.InlineBox):
        box.position_y += dy
        if box.style['vertical_align'] in ('top', 'bottom'):
            for child in box.children:
                translate_subtree(child, dy)
    else:
        # Text or atomic boxes
        box.translate(dy=dy)


def aligned_subtree_verticality(box, top_bottom_subtrees, baseline_y):
    max_y, min_y = inline_box_verticality(box, top_bottom_subtrees, baseline_y)
    # Account for the line box itself:
    top = baseline_y - box.baseline
    bottom = top + box.margin_height()
    if min_y is None or top < min_y:
        min_y = top
    if max_y is None or bottom > max_y:
        max_y = bottom

    return max_y, min_y


def inline_box_verticality(box, top_bottom_subtrees, baseline_y):
    """Handle ``vertical-align`` within an :class:`InlineBox`.

    Place all boxes vertically assuming that the baseline of ``box``
    is at `y = baseline_y`.

    Return ``(max_y, min_y)``, the maximum and minimum vertical position
    of margin boxes.

    """
    max_y = None
    min_y = None
    if not isinstance(box, (boxes.LineBox, boxes.InlineBox)):
        return max_y, min_y

    for child in box.children:
        if not child.is_in_normal_flow():
            if child.is_floated():
                top_bottom_subtrees.append(child)
            continue
        vertical_align = child.style['vertical_align']
        if vertical_align == 'baseline':
            child_baseline_y = baseline_y
        elif vertical_align == 'middle':
            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':
            # align top with the top of the parent’s content area
            top = (baseline_y - box.baseline + box.margin_top +
                   box.border_top_width + box.padding_top)
            child_baseline_y = top + child.baseline
        elif vertical_align == 'text-bottom':
            # align bottom with the bottom of the parent’s content area
            bottom = (baseline_y - box.baseline + box.margin_top +
                      box.border_top_width + box.padding_top + box.height)
            child_baseline_y = bottom - child.margin_height() + child.baseline
        elif vertical_align in ('top', 'bottom'):
            # TODO: actually implement vertical-align: top and bottom
            # 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.
            child_baseline_y = baseline_y - vertical_align

        # the child’s `top` is `child.baseline` above (lower y) its baseline.
        top = child_baseline_y - child.baseline
        box_types = (boxes.InlineBlockBox, boxes.InlineFlexBox, boxes.InlineGridBox)
        if isinstance(child, box_types):
            # This also includes table wrappers for inline tables.
            child.translate(dy=top - child.position_y)
        else:
            child.position_y = top
            # grand-children for inline boxes are handled below

        if vertical_align in ('top', 'bottom'):
            # top or bottom are special, they need to be handled in
            # a later pass.
            top_bottom_subtrees.append(child)
            continue

        bottom = top + child.margin_height()
        if min_y is None or top < min_y:
            min_y = top
        if max_y is None or bottom > max_y:
            max_y = bottom
        if isinstance(child, boxes.InlineBox):
            children_max_y, children_min_y = inline_box_verticality(
                child, top_bottom_subtrees, child_baseline_y)
            if children_min_y is not None and children_min_y < min_y:
                min_y = children_min_y
            if children_max_y is not None and children_max_y > max_y:
                max_y = children_max_y
    return max_y, min_y


def text_align(context, line, available_width, last):
    """Return the line horizontal offset according to ``text-align``."""

    # "When the total width of the inline-level boxes on a line is less than
    # the width of the line box containing them, their horizontal distribution
    # within the line box is determined by the 'text-align' property."
    if line.width >= available_width:
        return 0

    align = line.style['text_align_all']
    if last:
        align_last = line.style['text_align_last']
        align = align if align_last == 'auto' else align_last
    space_collapse = line.style['white_space'] in (
        'normal', 'nowrap', 'pre-line')
    if align in ('left', 'right'):
        if (align == 'left') ^ (line.style['direction'] == 'rtl'):
            align = 'start'
        else:
            align = 'end'
    if align == 'start':
        return 0
    offset = available_width - line.width
    if align == 'justify':
        if space_collapse:
            # Justification of texts where white space is not collapsing is
            # - forbidden by CSS 2, and
            # - not required by CSS 3 Text.
            justify_line(context, line, offset)
        return 0
    if align == 'center':
        return offset / 2
    else:
        assert align == 'end'
        return offset


def justify_line(context, line, extra_width):
    # TODO: We should use a better algorithm here, see
    # https://www.w3.org/TR/css-text-3/#justify-algos
    if (nb_spaces := count_expandable_spaces(line)):
        add_word_spacing(context, line, extra_width / nb_spaces, 0)


def count_expandable_spaces(box):
    """Count expandable spaces (space and nbsp) for justification."""
    if isinstance(box, boxes.TextBox):
        # TODO: remove trailing spaces correctly
        return box.text.count(' ') + box.text.count('\u00a0')
    elif isinstance(box, (boxes.LineBox, boxes.InlineBox)):
        return sum(count_expandable_spaces(child) for child in box.children)
    else:
        return 0


def add_word_spacing(context, box, justification_spacing, x_advance):
    if isinstance(box, boxes.TextBox):
        box.justification_spacing = justification_spacing
        box.position_x += x_advance
        nb_spaces = count_expandable_spaces(box)
        if nb_spaces > 0:
            layout = create_layout(
                box.text, box.style, context, max_width=None,
                justification_spacing=box.justification_spacing)
            layout.deactivate()
            extra_space = justification_spacing * nb_spaces
            x_advance += extra_space
            box.width += extra_space
            box.pango_layout = layout
    elif isinstance(box, (boxes.LineBox, boxes.InlineBox)):
        box.position_x += x_advance
        previous_x_advance = x_advance
        children = box.children
        if box.style['direction'] == 'rtl':
            children = children[::-1]
        for child in children:
            if child.is_in_normal_flow():
                x_advance = add_word_spacing(
                    context, child, justification_spacing, x_advance)
        box.width += x_advance - previous_x_advance
    else:
        # Atomic inline-level box
        box.translate(x_advance, 0)
    return x_advance


def is_phantom_linebox(linebox):
    # See https://www.w3.org/TR/CSS21/visuren.html#phantom-line-box
    for child in linebox.children:
        if isinstance(child, boxes.InlineBox):
            if not is_phantom_linebox(child):
                return False
            for side in ('top', 'right', 'bottom', 'left'):
                if (getattr(child.style[f'margin_{side}'], 'value', None) or
                        child.style[f'border_{side}_width'] or
                        child.style[f'padding_{side}'].value):
                    return False
        elif child.is_in_normal_flow():
            return False
    return True


def can_break_inside(box):
    # See https://www.w3.org/TR/css-text-3/#white-space-property
    text_wrap = box.style['white_space'] in ('normal', 'pre-wrap', 'pre-line')
    if isinstance(box, boxes.AtomicInlineLevelBox):
        return False
    elif text_wrap and isinstance(box, boxes.TextBox):
        return can_break_text(box.text, box.style['lang'])
    elif text_wrap and isinstance(box, boxes.ParentBox):
        return any(can_break_inside(child) for child in box.children)
    return False


================================================
FILE: weasyprint/layout/leader.py
================================================
"""Leaders management."""

from ..formatting_structure import boxes


def leader_index(box):
    """Get the index of the first leader box in ``box``."""
    for i, child in enumerate(box.children):
        if child.is_leader:
            return (i, None), child
        if isinstance(child, boxes.ParentBox):
            child_leader_index, child_leader = leader_index(child)
            if child_leader_index is not None:
                return (i, child_leader_index), child_leader
    return None, None


def handle_leader(context, line, containing_block):
    """Find a leader box in ``line`` and handle its text and its position."""
    index, leader_box = leader_index(line)
    extra_width = 0
    if index is not None and leader_box.children:
        text_box, = leader_box.children

        # Abort if the leader text has no width
        if text_box.width <= 0:
            return

        # Extra width is the additional width taken by the leader box
        extra_width = containing_block.width - sum(
            child.margin_width() for child in line.children
            if child.is_in_normal_flow())

        # Take care of excluded shapes
        for shape in context.excluded_shapes:
            if shape.position_y + shape.height > line.position_y:
                extra_width -= shape.width

        # Available width is the width available for the leader box
        available_width = extra_width + text_box.width
        line.width = containing_block.width

        # Add text boxes into the leader box
        number_of_leaders = int(line.width // text_box.width)
        position_x = line.position_x + line.width
        children = []
        for i in range(number_of_leaders):
            position_x -= text_box.width
            if position_x < leader_box.position_x:
                # Don’t add leaders behind the text on the left
                continue
            elif (position_x + text_box.width >
                    leader_box.position_x + available_width):
                # Don’t add leaders behind the text on the right
                continue
            text_box = text_box.copy()
            text_box.position_x = position_x
            children.append(text_box)
        leader_box.children = tuple(children)

        if line.style['direction'] == 'rtl':
            leader_box.translate(dx=-extra_width)

    # Widen leader parent boxes and translate following boxes
    box = line
    while index is not None:
        for child in box.children[index[0] + 1:]:
            if child.is_in_normal_flow():
                if line.style['direction'] == 'ltr':
                    child.translate(dx=extra_width)
                else:
                    child.translate(dx=-extra_width)
        box = box.children[index[0]]
        box.width += extra_width
        index = index[1]


================================================
FILE: weasyprint/layout/min_max.py
================================================
"""Decorators handling min- and max- widths and heights."""

import functools


def handle_min_max_width(function):
    """Decorate a function setting used width, handling {min,max}-width."""
    @functools.wraps(function)
    def wrapper(box, *args):
        result = function(box, *args)
        if box.width > box.max_width:
            box.width = box.max_width
            result = function(box, *args)
        if box.width < box.min_width:
            box.width = box.min_width
            result = function(box, *args)
        return result
    wrapper.without_min_max = function
    return wrapper


def handle_min_max_height(function):
    """Decorate a function setting used height, handling {min,max}-height."""
    @functools.wraps(function)
    def wrapper(box, *args):
        result = function(box, *args)
        if box.height > box.max_height:
            box.height = box.max_height
            result = function(box, *args)
        if box.height < box.min_height:
            box.height = box.min_height
            result = function(box, *args)
        return result
    wrapper.without_min_max = function
    return wrapper


================================================
FILE: weasyprint/layout/page.py
================================================
"""Layout for pages and CSS3 margin boxes."""

import copy
from collections import defaultdict, namedtuple
from math import inf

from ..css import AnonymousStyle
from ..formatting_structure import boxes, build
from ..logger import PROGRESS_LOGGER
from .absolute import absolute_box_layout, absolute_layout
from .block import block_container_layout, block_level_layout
from .float import float_layout
from .min_max import handle_min_max_height, handle_min_max_width
from .percent import resolve_percentages
from .preferred import max_content_width, min_content_width

PageType = namedtuple('PageType', ['side', 'blank', 'name', 'index', 'groups'])


class OrientedBox:
    @property
    def sugar(self):
        return self.padding_plus_border + self.margin_a + self.margin_b

    @property
    def outer(self):
        return self.sugar + self.inner

    @outer.setter
    def outer(self, new_outer_width):
        self.inner = min(
            max(self.min_content_size, new_outer_width - self.sugar),
            self.max_content_size)

    @property
    def outer_min_content_size(self):
        return self.sugar + (
            self.min_content_size if self.inner == 'auto' else self.inner)

    @property
    def outer_max_content_size(self):
        return self.sugar + (
            self.max_content_size if self.inner == 'auto' else self.inner)


class VerticalBox(OrientedBox):
    def __init__(self, context, box):
        self.context = context
        self.box = box
        # Inner dimension: that of the content area, as opposed to the
        # outer dimension: that of the margin area.
        self.inner = box.height
        self.margin_a = box.margin_top
        self.margin_b = box.margin_bottom
        self.padding_plus_border = (
            box.padding_top + box.padding_bottom +
            box.border_top_width + box.border_bottom_width)

    def restore_box_attributes(self):
        box = self.box
        box.height = self.inner
        box.margin_top = self.margin_a
        box.margin_bottom = self.margin_b

    # TODO: Define what are the min-content and max-content heights
    @property
    def min_content_size(self):
        return 0

    @property
    def max_content_size(self):
        return 1e6


class HorizontalBox(OrientedBox):
    def __init__(self, context, box):
        self.context = context
        self.box = box
        self.inner = box.width
        self.margin_a = box.margin_left
        self.margin_b = box.margin_right
        self.padding_plus_border = (
            box.padding_left + box.padding_right +
            box.border_left_width + box.border_right_width)
        self._min_content_size = None
        self._max_content_size = None

    def restore_box_attributes(self):
        box = self.box
        box.width = self.inner
        box.margin_left = self.margin_a
        box.margin_right = self.margin_b

    @property
    def min_content_size(self):
        if self._min_content_size is None:
            self._min_content_size = min_content_width(
                self.context, self.box, outer=False)
        return self._min_content_size

    @property
    def max_content_size(self):
        if self._max_content_size is None:
            self._max_content_size = max_content_width(
                self.context, self.box, outer=False)
        return self._max_content_size


def compute_fixed_dimension(context, box, outer, vertical, top_or_left):
    """Compute and set a margin box fixed dimension on ``box``.

    Described in: https://drafts.csswg.org/css-page-3/#margin-constraints

    :param box:
        The margin box to work on
    :param outer:
        The target outer dimension (value of a page margin)
    :param vertical:
        True to set height, margin-top and margin-bottom; False for width,
        margin-left and margin-right
    :param top_or_left:
        True if the margin box in if the top half (for vertical==True) or
        left half (for vertical==False) of the page.
        This determines which margin should be 'auto' if the values are
        over-constrained. (Rule 3 of the algorithm.)
    """
    box = (VerticalBox if vertical else HorizontalBox)(context, box)

    # Rule 2
    total = box.padding_plus_border + sum(
        value for value in (box.margin_a, box.margin_b, box.inner)
        if value != 'auto')
    if total > outer:
        if box.margin_a == 'auto':
            box.margin_a = 0
        if box.margin_b == 'auto':
            box.margin_b = 0
        if box.inner == 'auto':
            # XXX this is not in the spec, but without it box.inner
            # would end up with a negative value.
            # Instead, this will trigger rule 3 below.
            # https://lists.w3.org/Archives/Public/www-style/2012Jul/0006.html
            box.inner = 0
    # Rule 3
    if 'auto' not in [box.margin_a, box.margin_b, box.inner]:
        # Over-constrained
        if top_or_left:
            box.margin_a = 'auto'
        else:
            box.margin_b = 'auto'
    # Rule 4
    if [box.margin_a, box.margin_b, box.inner].count('auto') == 1:
        if box.inner == 'auto':
            box.inner = (outer - box.padding_plus_border -
                         box.margin_a - box.margin_b)
        elif box.margin_a == 'auto':
            box.margin_a = (outer - box.padding_plus_border -
                            box.margin_b - box.inner)
        elif box.margin_b == 'auto':
            box.margin_b = (outer - box.padding_plus_border -
                            box.margin_a - box.inner)
    # Rule 5
    if box.inner == 'auto':
        if box.margin_a == 'auto':
            box.margin_a = 0
        if box.margin_b == 'auto':
            box.margin_b = 0
        box.inner = (outer - box.padding_plus_border -
                     box.margin_a - box.margin_b)
    # Rule 6
    if box.margin_a == box.margin_b == 'auto':
        box.margin_a = box.margin_b = (
            outer - box.padding_plus_border - box.inner) / 2

    assert 'auto' not in [box.margin_a, box.margin_b, box.inner]

    box.restore_box_attributes()


def compute_variable_dimension(context, side_boxes, vertical, available_size):
    """Compute and set a margin box fixed dimension on ``box``

    Described in: https://drafts.csswg.org/css-page-3/#margin-dimension

    :param side_boxes:
        Three boxes on a same side (as opposed to a corner).
        A list of:
        - A @*-left or @*-top margin box
        - A @*-center or @*-middle margin box
        - A @*-right or @*-bottom margin box
    :param vertical:
        ``True`` to set height, margin-top and margin-bottom;
        ``False`` for width, margin-left and margin-right.
    :param available_size:
        The distance between the page box’s left right border edges

    """
    box_class = VerticalBox if vertical else HorizontalBox
    side_boxes = [box_class(context, box) for box in side_boxes]
    box_a, box_b, box_c = side_boxes

    for box in side_boxes:
        if box.margin_a == 'auto':
            box.margin_a = 0
        if box.margin_b == 'auto':
            box.margin_b = 0

    if not box_b.box.is_generated:
        # Non-generated boxes get zero for every box-model property
        assert box_b.inner == 0
        if box_a.inner == box_c.inner == 'auto':
            # A and C both have 'width: auto'
            if available_size > (
                    box_a.outer_max_content_size +
                    box_c.outer_max_content_size):
                # sum of the outer max-content widths
                # is less than the available width
                flex_space = (
                    available_size -
                    box_a.outer_max_content_size -
                    box_c.outer_max_content_size)
                flex_factor_a = box_a.outer_max_content_size
                flex_factor_c = box_c.outer_max_content_size
                flex_factor_sum = flex_factor_a + flex_factor_c
                if flex_factor_sum == 0:
                    flex_factor_sum = 1
                box_a.outer = box_a.max_content_size + (
                    flex_space * flex_factor_a / flex_factor_sum)
                box_c.outer = box_c.max_content_size + (
                    flex_space * flex_factor_c / flex_factor_sum)
            elif available_size > (
                    box_a.outer_min_content_size +
                    box_c.outer_min_content_size):
                # sum of the outer min-content widths
                # is less than the available width
                flex_space = (
                    available_size -
                    box_a.outer_min_content_size -
                    box_c.outer_min_content_size)
                flex_factor_a = (
                    box_a.max_content_size - box_a.min_content_size)
                flex_factor_c = (
                    box_c.max_content_size - box_c.min_content_size)
                flex_factor_sum = flex_factor_a + flex_factor_c
                if flex_factor_sum == 0:
                    flex_factor_sum = 1
                box_a.outer = box_a.min_content_size + (
                    flex_space * flex_factor_a / flex_factor_sum)
                box_c.outer = box_c.min_content_size + (
                    flex_space * flex_factor_c / flex_factor_sum)
            else:
                # otherwise
                flex_space = (
                    available_size -
                    box_a.outer_min_content_size -
                    box_c.outer_min_content_size)
                flex_factor_a = box_a.min_content_size
                flex_factor_c = box_c.min_content_size
                flex_factor_sum = flex_factor_a + flex_factor_c
                if flex_factor_sum == 0:
                    flex_factor_sum = 1
                box_a.outer = box_a.min_content_size + (
                    flex_space * flex_factor_a / flex_factor_sum)
                box_c.outer = box_c.min_content_size + (
                    flex_space * flex_factor_c / flex_factor_sum)
        else:
            # only one box has 'width: auto'
            if box_a.inner == 'auto':
                box_a.outer = available_size - box_c.outer
            elif box_c.inner == 'auto':
                box_c.outer = available_size - box_a.outer
    else:
        if box_b.inner == 'auto':
            # resolve any auto width of the middle box (B)
            ac_max_content_size = 2 * max(
                box_a.outer_max_content_size, box_c.outer_max_content_size)
            if available_size > (
                    box_b.outer_max_content_size + ac_max_content_size):
                flex_space = (
                    available_size -
                    box_b.outer_max_content_size -
                    ac_max_content_size)
                flex_factor_b = box_b.outer_max_content_size
                flex_factor_ac = ac_max_content_size
                flex_factor_sum = flex_factor_b + flex_factor_ac
                if flex_factor_sum == 0:
                    flex_factor_sum = 1
                box_b.outer = box_b.max_content_size + (
                    flex_space * flex_factor_b / flex_factor_sum)
            else:
                ac_min_content_size = 2 * max(
                    box_a.outer_min_content_size, box_c.outer_min_content_size)
                if available_size > (
                        box_b.outer_min_content_size + ac_min_content_size):
                    flex_space = (
                        available_size -
                        box_b.outer_min_content_size -
                        ac_min_content_size)
                    flex_factor_b = (
                        box_b.max_content_size - box_b.min_content_size)
                    flex_factor_ac = ac_max_content_size - ac_min_content_size
                    flex_factor_sum = flex_factor_b + flex_factor_ac
                    if flex_factor_sum == 0:
                        flex_factor_sum = 1
                    box_b.outer = box_b.min_content_size + (
                        flex_space * flex_factor_b / flex_factor_sum)
                else:
                    flex_space = (
                        available_size -
                        box_b.outer_min_content_size -
                        ac_min_content_size)
                    flex_factor_b = box_b.min_content_size
                    flex_factor_ac = ac_min_content_size
                    flex_factor_sum = flex_factor_b + flex_factor_ac
                    if flex_factor_sum == 0:
                        flex_factor_sum = 1
                    box_b.outer = box_b.min_content_size + (
                        flex_space * flex_factor_b / flex_factor_sum)
        if box_a.inner == 'auto':
            box_a.outer = (available_size - box_b.outer) / 2
        if box_c.inner == 'auto':
            box_c.outer = (available_size - box_b.outer) / 2

    # And, we’re done!
    assert 'auto' not in [box.inner for box in side_boxes]
    # Set the actual attributes back.
    for box in side_boxes:
        box.restore_box_attributes()


def _standardize_page_based_counters(style, pseudo_type):
    """Drop 'pages' counter from style in @page and @margin context.

    Ensure `counter-increment: page` for @page context if not otherwise
    manipulated by the style.

    """
    page_counter_touched = False
    for propname in ('counter_set', 'counter_reset', 'counter_increment'):
        if style[propname] == 'auto':
            style[propname] = ()
            continue
        justified_values = []
        for name, value in style[propname]:
            if name == 'page':
                page_counter_touched = True
            if name != 'pages':
                justified_values.append((name, value))
        style[propname] = tuple(justified_values)

    if pseudo_type is None and not page_counter_touched:
        style['counter_increment'] = (
            ('page', 1),) + style['counter_increment']


def make_margin_boxes(context, page, state):
    """Yield laid-out margin boxes for this page.

    ``state`` is the actual, up-to-date page-state from
    ``context.page_maker[context.current_page]``.

    """
    # This is a closure only to make calls shorter
    def make_box(at_keyword, containing_block):
        """Return a margin box with resolved percentages.

        The margin box may still have 'auto' values.

        Return ``None`` if this margin box should not be generated.

        :param at_keyword:
            Which margin box to return, e.g. '@top-left'
        :param containing_block:
            As expected by :func:`resolve_percentages`.

        """
        style = context.style_for(page.page_type, at_keyword)
        if style is None:
            # doesn't affect counters
            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
        # the layout of their neighbors.
        # TODO: should be the computed value.
        box.is_generated = style['content'] not in (
            'normal', 'inhibit', 'none')
        # TODO: get actual counter values at the time of the last page break
        if box.is_generated:
            # @margins mustn't manipulate page-context counters
            margin_state = copy.deepcopy(state)
            quote_depth, counter_values, counter_scopes, _page_groups = margin_state
            # TODO: check this, probably useless
            counter_scopes.append(set())
            build.update_counters(margin_state, box.style)
            box.children = build.content_to_boxes(
                box.style, box, quote_depth, counter_values,
                context.get_image_from_uri, context.target_collector,
                context.counter_style, context, page)
            build.process_whitespace(box)
            build.process_text_transform(box)
            box = build.create_anonymous_boxes(box)
        resolve_percentages(box, containing_block)
        if not box.is_generated:
            box.width = box.height = 0
            for side in ('top', 'right', 'bottom', 'left'):
                box._reset_spacing(side)
        return box

    margin_top = page.margin_top
    margin_bottom = page.margin_bottom
    margin_left = page.margin_left
    margin_right = page.margin_right
    max_box_width = page.border_width()
    max_box_height = page.border_height()

    # bottom right corner of the border box
    page_end_x = margin_left + max_box_width
    page_end_y = margin_top + max_box_height

    # Margin box dimensions, described in
    # https://drafts.csswg.org/css-page-3/#margin-box-dimensions
    generated_boxes = []

    for prefix, vertical, containing_block, position_x, position_y in (
        ('top', False, (max_box_width, margin_top),
            margin_left, 0),
        ('bottom', False, (max_box_width, margin_bottom),
            margin_left, page_end_y),
        ('left', True, (margin_left, max_box_height),
            0, margin_top),
        ('right', True, (margin_right, max_box_height),
            page_end_x, margin_top),
    ):
        if vertical:
            suffixes = ['top', 'middle', 'bottom']
            fixed_outer, variable_outer = containing_block
        else:
            suffixes = ['left', 'center', 'right']
            variable_outer, fixed_outer = containing_block
        side_boxes = [
            make_box(f'@{prefix}-{suffix}', containing_block)
            for suffix in suffixes]
        if not any(box.is_generated for box in side_boxes):
            continue
        # We need the three boxes together for the variable dimension:
        compute_variable_dimension(
            context, side_boxes, vertical, variable_outer)
        for box, offset in zip(side_boxes, [0, 0.5, 1]):
            if not box.is_generated:
                continue
            box.position_x = position_x
            box.position_y = position_y
            if vertical:
                box.position_y += offset * (
                    variable_outer - box.margin_height())
            else:
                box.position_x += offset * (
                    variable_outer - box.margin_width())
            compute_fixed_dimension(
                context, box, fixed_outer, not vertical,
                prefix in ('top', 'left'))
            generated_boxes.append(box)

    # Corner boxes

    for at_keyword, cb_width, cb_height, position_x, position_y in (
        ('@top-left-corner', margin_left, margin_top, 0, 0),
        ('@top-right-corner', margin_right, margin_top, page_end_x, 0),
        ('@bottom-left-corner', margin_left, margin_bottom, 0, page_end_y),
        ('@bottom-right-corner', margin_right, margin_bottom,
            page_end_x, page_end_y),
    ):
        box = make_box(at_keyword, (cb_width, cb_height))
        if not box.is_generated:
            continue
        box.position_x = position_x
        box.position_y = position_y
        compute_fixed_dimension(
            context, box, cb_height, True, 'top' in at_keyword)
        compute_fixed_dimension(
            context, box, cb_width, False, 'left' in at_keyword)
        generated_boxes.append(box)

    for box in generated_boxes:
        yield margin_box_content_layout(context, page, box)


def margin_box_content_layout(context, page, box):
    """Layout a margin box’s content once the box has dimensions."""
    positioned_boxes = []
    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, 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(
            context, absolute_box, box, positioned_boxes, bottom_space=0,
            skip_stack=None)

    vertical_align = box.style['vertical_align']
    # Every other value is read as 'top', ie. no change.
    if vertical_align in ('middle', 'bottom') and box.children:
        first_child = box.children[0]
        last_child = box.children[-1]
        top = first_child.position_y
        # Not always exact because floating point errors
        # assert top == box.content_box_y()
        bottom = last_child.position_y + last_child.margin_height()
        content_height = bottom - top
        offset = box.height - content_height
        if vertical_align == 'middle':
            offset /= 2
        for child in box.children:
            child.translate(0, offset)
    return box


def page_width_or_height(box, containing_block_size):
    """Take a :class:`OrientedBox` object and set either width, margin-left
    and margin-right; or height, margin-top and margin-bottom.

    "The width and horizontal margins of the page box are then calculated
     exactly as for a non-replaced block element in normal flow. The height
     and vertical margins of the page box are calculated analogously (instead
     of using the block height formulas). In both cases if the values are
     over-constrained, instead of ignoring any margins, the containing block
     is resized to coincide with the margin edges of the page box."

    https://drafts.csswg.org/css-page-3/#page-box-page-rule
    https://www.w3.org/TR/CSS21/visudet.html#blockwidth

    """
    remaining = containing_block_size - box.padding_plus_border
    if box.inner == 'auto':
        if box.margin_a == 'auto':
            box.margin_a = 0
        if box.margin_b == 'auto':
            box.margin_b = 0
        box.inner = remaining - box.margin_a - box.margin_b
    elif box.margin_a == box.margin_b == 'auto':
        box.margin_a = box.margin_b = (remaining - box.inner) / 2
    elif box.margin_a == 'auto':
        box.margin_a = remaining - box.inner - box.margin_b
    elif box.margin_b == 'auto':
        box.margin_b = remaining - box.inner - box.margin_a
    box.restore_box_attributes()


@handle_min_max_width
def page_width(box, context, containing_block_width):
    page_width_or_height(HorizontalBox(context, box), containing_block_width)


@handle_min_max_height
def page_height(box, context, containing_block_height):
    page_width_or_height(VerticalBox(context, box), containing_block_height)


def make_page(context, root_box, page_type, resume_at, page_number,
              page_state):
    """Take just enough content from the beginning to fill one page.

    Return ``(page, finished)``. ``page`` is a laid out PageBox object
    and ``resume_at`` indicates where in the document to start the next page,
    or is ``None`` if this was the last page.

    :param int page_number:
        Page number, starts at 1 for the first page.
    :param resume_at:
        As returned by ``make_page()`` for the previous page, or ``None`` for
        the first page.

    """
    style = context.style_for(page_type)

    # Propagated from the root or <body>.
    style['overflow'] = root_box.viewport_overflow
    page = boxes.PageBox(page_type, style)

    device_size = page.style['size']

    resolve_percentages(page, device_size)

    page.position_x = 0
    page.position_y = 0
    cb_width, cb_height = device_size
    page_width(page, context, cb_width)
    page_height(page, context, cb_height)

    if page_number == 1:
        context.style_for.initial_page_sizes['box'] = device_size
        context.style_for.initial_page_sizes['area'] = (page.width, page.height)

    root_box.position_x = page.content_box_x()
    root_box.position_y = page.content_box_y()
    context.page_bottom = root_box.position_y + page.height
    initial_containing_block = page

    footnote_area_style = context.style_for(page_type, '@footnote')
    footnote_area = boxes.FootnoteAreaBox(page, footnote_area_style)
    resolve_percentages(footnote_area, page)
    footnote_area.position_x = page.content_box_x()
    footnote_area.position_y = context.page_bottom

    if page_type.blank:
        previous_resume_at = resume_at
        root_box = root_box.copy_with_children([])

    # https://www.w3.org/TR/css-display-4/#root
    assert isinstance(root_box, boxes.BlockLevelBox)
    context.create_block_formatting_context()
    context.current_page = page_number
    context.current_page_footnotes = []
    context.current_footnote_area = footnote_area

    reported_footnotes = context.reported_footnotes
    context.reported_footnotes = []
    for i, reported_footnote in enumerate(reported_footnotes):
        context.footnotes.append(reported_footnote)
        overflow = context.layout_footnote(reported_footnote)
        if overflow and i != 0:
            context.report_footnote(reported_footnote)
            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, 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:
            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)
    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, 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 = [
        placeholder._box for placeholder in positioned_boxes
        if placeholder._box.style['position'] == 'fixed']
    for absolute_box in positioned_boxes:
        absolute_layout(
            context, absolute_box, page, positioned_boxes, bottom_space=0,
            skip_stack=None)

    context.finish_block_formatting_context()

    page.children = [root_box, footnote_area]

    # Update page counter values
    _standardize_page_based_counters(style, None)
    build.update_counters(page_state, style)
    page_counter_values = page_state[1]
    # page_counter_values will be cached in the page_maker

    target_collector = context.target_collector
    page_maker = context.page_maker

    # remake_state tells the make_all_pages-loop in layout_document()
    # whether and what to re-make.
    remake_state = page_maker[page_number - 1][-1]

    # Evaluate and cache page values only once (for the first LineBox)
    # otherwise we suffer endless loops when the target/pseudo-element
    # spans across multiple pages
    cached_anchors = []
    cached_lookups = []
    for (_, _, _, _, x_remake_state) in page_maker[:page_number - 1]:
        cached_anchors.extend(x_remake_state.get('anchors', []))
        cached_lookups.extend(x_remake_state.get('content_lookups', []))

    for child in page.descendants(placeholders=True):
        # Cache target's page counters
        anchor = child.style['anchor']
        if anchor and anchor not in cached_anchors:
            remake_state['anchors'].append(anchor)
            cached_anchors.append(anchor)
            # Re-make of affected targeting boxes is inclusive
            target_collector.cache_target_page_counters(
                anchor, page_counter_values, page_number - 1, page_maker)

        # string-set and bookmark-labels don't create boxes, only `content`
        # requires another call to make_page. There is maximum one 'content'
        # item per box.
        if child.missing_link:
            # A CounterLookupItem exists for the css-token 'content'
            counter_lookup = target_collector.counter_lookup_items.get(
                (child.missing_link, 'content'))
        else:
            counter_lookup = None

        # Resolve missing (page based) counters
        if counter_lookup is not None:
            call_parse_again = False

            # Prevent endless loops
            counter_lookup_id = id(counter_lookup)
            refresh_missing_counters = counter_lookup_id not in cached_lookups
            if refresh_missing_counters:
                remake_state['content_lookups'].append(counter_lookup_id)
                cached_lookups.append(counter_lookup_id)
                counter_lookup.page_maker_index = page_number - 1

            # Step 1: page based back-references
            # Marked as pending by target_collector.cache_target_page_counters
            if counter_lookup.pending:
                if (page_counter_values !=
                        counter_lookup.cached_page_counter_values):
                    counter_lookup.cached_page_counter_values = copy.deepcopy(
                        page_counter_values)
                counter_lookup.pending = False
                call_parse_again = True

            # Step 2: local counters
            # If the box mixed-in page counters changed, update the content
            # and cache the new values.
            missing_counters = counter_lookup.missing_counters
            if missing_counters:
                if 'pages' in missing_counters:
                    remake_state['pages_wanted'] = True
                if refresh_missing_counters and page_counter_values != \
                        counter_lookup.cached_page_counter_values:
                    counter_lookup.cached_page_counter_values = \
                        copy.deepcopy(page_counter_values)
                    for counter_name in missing_counters:
                        counter_value = page_counter_values.get(
                            counter_name, None)
                        if counter_value is not None:
                            call_parse_again = True
                            # no need to loop them all
                            break

            # Step 3: targeted counters
            target_missing = counter_lookup.missing_target_counters
            for anchor_name, missed_counters in target_missing.items():
                if 'pages' not in missed_counters:
                    continue
                # Adjust 'pages_wanted'
                item = target_collector.target_lookup_items.get(
                    anchor_name, None)
                page_maker_index = item.page_maker_index
                if page_maker_index >= 0 and anchor_name in cached_anchors:
                    page_maker[page_maker_index][-1]['pages_wanted'] = True
                # 'content_changed' is triggered in
                # targets.cache_target_page_counters()

            if call_parse_again:
                remake_state['content_changed'] = True
                counter_lookup.parse_again(page_counter_values)

    if page_type.blank:
        resume_at = previous_resume_at
        next_page = page_maker[page_number - 1][1]

    return page, resume_at, next_page


def set_page_type_computed_styles(page_type, html, style_for):
    """Set style for page types and pseudo-types matching ``page_type``."""
    style_for.add_page_declarations(page_type)

    # Apply style for page
    style_for.set_computed_styles(
        page_type,
        # @page inherits from the root element:
        # https://lists.w3.org/Archives/Public/www-style/2012Jan/1164.html
        root=html.etree_element, parent=html.etree_element,
        base_url=html.base_url)

    # Apply style for page pseudo-elements (margin boxes)
    for element, pseudo_type in style_for.get_cascaded_styles():
        if pseudo_type and element == page_type:
            style_for.set_computed_styles(
                element, pseudo_type=pseudo_type,
                # The pseudo-element inherits from the element.
                root=html.etree_element, parent=element,
                base_url=html.base_url)


def _includes_resume_at(resume_at, page_group_resume_at):
    if not page_group_resume_at:
        return True
    (page_child_index, page_child_resume_at), = page_group_resume_at.items()
    if resume_at is None or page_child_index not in resume_at:
        return False
    if page_child_resume_at is None:
        return True
    return _includes_resume_at(resume_at[page_child_index], page_child_resume_at)


def _update_page_groups(page_groups, resume_at, next_page, root_box, blank):
    # https://www.w3.org/TR/css-gcpm-3/#document-sequence-selectors

    # Remove or increment page groups.
    page_groups_length = len(page_groups)
    for i, page_group in enumerate(page_groups[:]):
        if _includes_resume_at(resume_at, page_group[2]):
            page_group[1] += 1
        else:
            page_groups.pop(i - page_groups_length)

    # Add page groups.
    if not blank:
        if (resume_at and next_page['break'] == 'any') or not next_page['page']:
            # We don’t have a forced page break or a named page.
            return next_page['page']
        if page_groups and page_groups[-1][0] == next_page['page']:
            # We’re already in an element whose page name is the next page name.
            return next_page['page']

    # Find the box that has the named page. It is a first in-flow child of the
    # element corresponding to resume_at.

    # Find element corrensponding to resume_at.
    current_resume_at = page_group_resume_at = copy.deepcopy(resume_at) or {0: None}
    current_element = root_box
    while True:
        child_index, child_resume_at = tuple(current_resume_at.items())[-1]
        parent_element = current_element
        current_element = current_element.children[child_index]
        if child_resume_at is None:
            break
        current_resume_at = child_resume_at

    if blank:
        # Page is blank, don’t create a new page group and return parent’s page name.
        return parent_element.style['page']

    # Find the descendant with named page.
    while True:
        if current_element.style['page'] == next_page['page']:
            page_groups.append([next_page['page'], 0, page_group_resume_at])
            return next_page['page']
        if not isinstance(current_element, boxes.ParentBox):
            # Shouldn’t happen.
            return next_page['page']
        for i, child in enumerate(current_element.children):
            if not child.is_in_normal_flow():
                continue
            current_resume_at[child_index] = {i: None}
            current_resume_at = current_resume_at[child_index]
            child_index = i
            current_element = child
            break
        else:
            # Shouldn’t happen.
            return next_page['page']


def remake_page(index, context, root_box, html):
    """Return one laid out page without margin boxes.

    Start with the initial values from ``context.page_maker[index]``.
    The resulting values / initial values for the next page are stored in
    the ``page_maker``.

    As the function's name suggests: the plan is not to make all pages
    repeatedly when a missing counter was resolved, but rather re-make the
    single page where the ``content_changed`` happened.

    """
    page_maker = context.page_maker
    resume_at, next_page, right_page, page_state, _ = page_maker[index]

    # PageType for current page, values for page_maker[index + 1].
    # Don't modify actual page_maker[index] values!
    page_state = copy.deepcopy(page_state)
    if next_page['break'] in ('left', 'right'):
        next_page_side = next_page['break']
    elif next_page['break'] in ('recto', 'verso'):
        direction_ltr = root_box.style['direction'] == 'ltr'
        break_verso = next_page['break'] == 'verso'
        next_page_side = 'right' if direction_ltr ^ break_verso else 'left'
    else:
        next_page_side = None
    blank = bool(
        (next_page_side == 'left' and right_page) or
        (next_page_side == 'right' and not right_page) or
        (context.reported_footnotes and resume_at is None))
    side = 'right' if right_page else 'left'
    page_groups = page_state[3]
    name = _update_page_groups(page_groups, resume_at, next_page, root_box, blank)
    groups = tuple((name, index) for name, index, _ in page_groups)
    page_type = PageType(side, blank, name, index, groups)
    set_page_type_computed_styles(page_type, html, context.style_for)

    context.forced_break = (next_page['break'] != 'any' or next_page['page'])
    context.margin_clearance = False

    # make_page wants a page_number of index + 1
    page_number = index + 1
    page, resume_at, next_page = make_page(
        context, root_box, page_type, resume_at, page_number, page_state)
    assert next_page
    right_page = not right_page

    # Check whether we need to append or update the next page_maker item
    if index + 1 >= len(page_maker):
        # New page
        page_maker_next_changed = True
    else:
        # Check whether something changed
        next_resume_at, next_next_page, next_right_page, next_page_state, _ = (
            page_maker[index + 1])
        page_maker_next_changed = (
            next_resume_at != resume_at or
            next_next_page != next_page or
            next_right_page != right_page or
            next_page_state != page_state)

    if page_maker_next_changed:
        # Reset remake_state
        remake_state = {
            'content_changed': False,
            'pages_wanted': False,
            'anchors': [],
            'content_lookups': [],
        }
        # Setting content_changed to True ensures remake.
        # If resume_at is None (last page) it must be False to prevent endless
        # loops and list index out of range (see #794).
        remake_state['content_changed'] = resume_at is not None
        item = resume_at, next_page, right_page, page_state, remake_state
        if index + 1 >= len(page_maker):
            page_maker.append(item)
        else:
            page_maker[index + 1] = item

    return page, resume_at


def make_all_pages(context, root_box, html, pages):
    """Return a list of laid out pages without margin boxes.

    Re-make pages only if necessary.

    """
    i = 0
    reported_footnotes = None
    while True:
        remake_state = context.page_maker[i][-1]
        if (len(pages) == 0 or
                remake_state['content_changed'] or
                remake_state['pages_wanted']):
            PROGRESS_LOGGER.info('Step 5 - Creating layout - Page %d', i + 1)
            # Reset remake_state
            remake_state['content_changed'] = False
            remake_state['pages_wanted'] = False
            remake_state['anchors'] = []
            remake_state['content_lookups'] = []
            page, resume_at = remake_page(i, context, root_box, html)
            reported_footnotes = context.reported_footnotes
            yield page
        else:
            PROGRESS_LOGGER.info(
                'Step 5 - Creating layout - Page %d (up-to-date)', i + 1)
            resume_at = context.page_maker[i + 1][0]
            reported_footnotes = None
            yield pages[i]

        i += 1
        if resume_at is None and not reported_footnotes:
            # Throw away obsolete pages and content
            context.page_maker = context.page_maker[:i + 1]
            context.broken_out_of_flow.clear()
            context.reported_footnotes.clear()
            return


================================================
FILE: weasyprint/layout/percent.py
================================================
"""Resolve percentages into fixed values."""

from math import inf

from ..css import resolve_math
from ..css.functions import check_math
from ..formatting_structure import boxes


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 check_math(value):
        value = resolve_math(value, computed, refer_to=refer_to)
    if value is None or value == 'auto':
        return value
    elif value.unit.lower() == 'px':
        return value.value
    else:
        assert value.unit == '%'
        return refer_to * value.value / 100


def resolve_one_percentage(box, property_name, refer_to):
    """Set a used length value from a computed length value.

    ``refer_to`` is the length for 100%. If ``refer_to`` is not a number, it
    just replaces percentages.

    """
    # box.style has computed values
    value = box.style[property_name]
    # box attributes are used values
    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)


def resolve_position_percentages(box, containing_block):
    cb_width, cb_height = containing_block
    resolve_one_percentage(box, 'left', cb_width)
    resolve_one_percentage(box, 'right', cb_width)
    resolve_one_percentage(box, 'top', cb_height)
    resolve_one_percentage(box, 'bottom', cb_height)


def resolve_percentages(box, containing_block):
    """Set used values as attributes of the box object."""
    if isinstance(containing_block, boxes.Box):
        # cb is short for containing block
        cb_width = containing_block.width
        cb_height = containing_block.height
    else:
        cb_width, cb_height = containing_block
    if isinstance(box, boxes.PageBox):
        maybe_height = cb_height
    else:
        maybe_height = cb_width
    resolve_one_percentage(box, 'margin_left', cb_width)
    resolve_one_percentage(box, 'margin_right', cb_width)
    resolve_one_percentage(box, 'margin_top', maybe_height)
    resolve_one_percentage(box, 'margin_bottom', maybe_height)
    resolve_one_percentage(box, 'padding_left', cb_width)
    resolve_one_percentage(box, 'padding_right', cb_width)
    resolve_one_percentage(box, 'padding_top', maybe_height)
    resolve_one_percentage(box, 'padding_bottom', maybe_height)
    resolve_one_percentage(box, 'width', cb_width)
    resolve_one_percentage(box, 'min_width', cb_width)
    resolve_one_percentage(box, 'max_width', cb_width)

    # XXX later: top, bottom, left and right on positioned elements

    if cb_height == 'auto':
        # Special handling when the height of the containing block
        # depends on its content.
        height = box.style['height']
        if height == 'auto' or check_math(height) or height.unit == '%':
            box.height = 'auto'
        else:
            assert height.unit.lower() == 'px'
            box.height = height.value
        resolve_one_percentage(box, 'min_height', 0)
        resolve_one_percentage(box, 'max_height', inf)
    else:
        resolve_one_percentage(box, 'height', cb_height)
        resolve_one_percentage(box, 'min_height', cb_height)
        resolve_one_percentage(box, 'max_height', cb_height)

    collapse = box.style['border_collapse'] == 'collapse'
    # Used value == computed value
    for side in ('top', 'right', 'bottom', 'left'):
        prop = f'border_{side}_width'
        # border-{side}-width would have been resolved
        # during border conflict resolution for collapsed-borders
        if not (collapse and hasattr(box, prop)):
            setattr(box, prop, box.style[prop])

    # Shrink *content* widths and heights according to box-sizing
    adjust_box_sizing(box, 'width')
    adjust_box_sizing(box, 'height')


def resolve_radii_percentages(box):
    for corner in ('top_left', 'top_right', 'bottom_right', 'bottom_left'):
        property_name = f'border_{corner}_radius'
        computed = box.style[property_name]
        rx, ry = computed

        # Short track for common case
        if (0, 'px') in (rx, ry):
            setattr(box, property_name, (0, 0))
            continue

        for side in corner.split('_'):
            if side in box.remove_decoration_sides:
                setattr(box, property_name, (0, 0))
                break
        else:
            rx = percentage(rx, box.style, box.border_width())
            ry = percentage(ry, box.style, box.border_height())
            setattr(box, property_name, (rx, ry))


def adjust_box_sizing(box, axis):
    if box.style['box_sizing'] == 'border-box':
        if axis == 'width':
            delta = (
                box.padding_left + box.padding_right +
                box.border_left_width + box.border_right_width)
        else:
            delta = (
                box.padding_top + box.padding_bottom +
                box.border_top_width + box.border_bottom_width)
    elif box.style['box_sizing'] == 'padding-box':
        if axis == 'width':
            delta = box.padding_left + box.padding_right
        else:
            delta = box.padding_top + box.padding_bottom
    else:
        assert box.style['box_sizing'] == 'content-box'
        delta = 0

    # Keep at least min_* >= 0 to prevent funny output in case box.width or
    # box.height become negative.
    # Restricting max_* seems reasonable, too.
    if delta > 0:
        if getattr(box, axis) != 'auto':
            setattr(box, axis, max(0, getattr(box, axis) - delta))
        setattr(box, f'max_{axis}', max(0, getattr(box, f'max_{axis}') - delta))
        if getattr(box, f'min_{axis}') != 'auto':
            setattr(box, f'min_{axis}', max(0, getattr(box, f'min_{axis}') - delta))


================================================
FILE: weasyprint/layout/preferred.py
================================================
"""Preferred and minimum preferred width.

Also known as max-content and min-content width, also known as the
shrink-to-fit algorithm.

Terms used (max-content width, min-content width) are defined in David
Baron's unofficial draft (https://dbaron.org/css/intrinsic/).

"""

import sys
from functools import cache
from math import inf

from ..css import resolve_math
from ..css.functions import check_math
from ..css.validation import validate_non_shorthand
from ..formatting_structure import boxes
from ..text.line_break import can_break_text, split_first_line
from .replaced import default_image_sizing


def shrink_to_fit(context, box, available_content_width):
    """Return the shrink-to-fit width of ``box``.

    *Warning:* both available_content_width and the return value are
    for width of the *content area*, not margin area.

    https://www.w3.org/TR/CSS21/visudet.html#float-width

    """
    return min(
        max(
            min_content_width(context, box, outer=False),
            available_content_width),
        max_content_width(context, box, outer=False))


def min_content_width(context, box, outer=True):
    """Return the min-content width for ``box``.

    This is the width by breaking at every line-break opportunity.

    """
    if box.is_table_wrapper:
        return table_and_columns_preferred_widths(context, box, outer)[0]
    elif isinstance(box, boxes.TableCellBox):
        return table_cell_min_content_width(context, box, outer)
    elif isinstance(box, (boxes.BlockContainerBox, boxes.TableColumnBox)):
        return block_min_content_width(context, box, outer)
    elif isinstance(box, boxes.TableColumnGroupBox):
        return column_group_content_width(context, box)
    elif isinstance(box, (boxes.InlineBox, boxes.LineBox)):
        return inline_min_content_width(context, box, outer, is_line_start=True)
    elif isinstance(box, boxes.ReplacedBox):
        return replaced_min_content_width(box, outer)
    elif isinstance(box, boxes.FlexContainerBox):
        return flex_min_content_width(context, box, outer)
    elif isinstance(box, boxes.GridContainerBox):
        # TODO: Get real grid size.
        return block_min_content_width(context, box, outer)
    else:
        raise TypeError(f'min-content width for {type(box).__name__} not handled yet')


def max_content_width(context, box, outer=True):
    """Return the max-content width for ``box``.

    This is the width by only breaking at forced line breaks.

    """
    if box.is_table_wrapper:
        return table_and_columns_preferred_widths(context, box, outer)[1]
    elif isinstance(box, boxes.TableCellBox):
        return table_cell_min_max_content_width(context, box, outer)[1]
    elif isinstance(box, (boxes.BlockContainerBox, boxes.TableColumnBox)):
        return block_max_content_width(context, box, outer)
    elif isinstance(box, boxes.TableColumnGroupBox):
        return column_group_content_width(context, box)
    elif isinstance(box, (boxes.InlineBox, boxes.LineBox)):
        return inline_max_content_width(context, box, outer, is_line_start=True)
    elif isinstance(box, boxes.ReplacedBox):
        return replaced_max_content_width(box, outer)
    elif isinstance(box, boxes.FlexContainerBox):
        return flex_max_content_width(context, box, outer)
    elif isinstance(box, boxes.GridContainerBox):
        # TODO: Get real grid size.
        return block_max_content_width(context, box, outer)
    else:
        raise TypeError(f'max-content width for {type(box).__name__} not handled yet')


def _block_content_width(context, box, function, outer):
    """Helper to create ``block_*_content_width.``"""
    width = box.style['width']
    if width == 'auto' or check_math(width) or width.unit == '%':
        # "percentages on the following properties are treated instead as
        # though they were the following: width: auto"
        # https://dbaron.org/css/intrinsic/#outer-intrinsic
        children_widths = [
            function(context, child, outer=True) for child in box.children
            if not child.is_absolutely_positioned()]
        width = max(children_widths) if children_widths else 0
    elif box.style['box_sizing'] == 'content-box':
        width = width.value
    else:
        width = width.value
        percentages = 0

        for value in ('padding_left', 'padding_right'):
            style_value = box.style[value]
            if style_value != 'auto' and not check_math(style_value):
                if style_value.unit.lower() == 'px':
                    width -= style_value.value
                else:
                    assert style_value.unit == '%'
                    percentages += style_value.value

        # Same as margin_width().
        collapse = box.style['border_collapse'] == 'collapse'
        if collapse and hasattr(box, 'border_left_width'):
            width -= box.border_left_width
        else:
            width -= box.style['border_left_width']
        if collapse and hasattr(box, 'border_right_width'):
            width -= box.border_right_width
        else:
            width -= box.style['border_right_width']
        width = (100 - min(100, percentages)) * max(0, width) / 100

    return adjust(box, outer, width)


def min_max(box, width):
    """Get box width from given width and box min- and max-widths."""
    min_width = box.style['min_width']
    max_width = box.style['max_width']
    min_pending = check_math(min_width)
    max_pending = check_math(max_width)
    if min_width == 'auto' or min_pending or min_width.unit == '%':
        min_width = 0
    else:
        min_width = min_width.value
    if max_width == 'auto' or max_pending or max_width.unit == '%':
        max_width = inf
    else:
        max_width = max_width.value

    if isinstance(box, boxes.ReplacedBox):
        _, _, ratio = box.replacement.get_intrinsic_size(
            1, box.style['font_size'])
        if ratio is not None:
            min_height = box.style['min_height']
            max_height = box.style['max_height']
            min_pending = check_math(min_height)
            max_pending = check_math(max_height)
            if min_height != 'auto' and not min_pending and min_height.unit != '%':
                min_width = max(min_width, min_height.value * ratio)
            if max_height != 'auto' and not min_pending and max_height.unit != '%':
                max_width = min(max_width, max_height.value * ratio)

    return max(min_width, min(width, max_width))


def margin_width(box, width, left=True, right=True):
    """Add box paddings, borders and margins to ``width``."""
    percentages = 0

    # See https://drafts.csswg.org/css-tables-3/#cell-intrinsic-offsets
    # It is a set of computed values for border-left-width, padding-left,
    # padding-right, and border-right-width (along with zero values for
    # margin-left and margin-right)
    for value in (
        (['margin_left', 'padding_left'] if left else []) +
        (['margin_right', 'padding_right'] if right else [])
    ):
        style_value = box.style[value]
        if style_value != 'auto' and not check_math(style_value):
            if style_value.unit.lower() == 'px':
                width += style_value.value
            else:
                assert style_value.unit == '%'
                percentages += style_value.value

    collapse = box.style['border_collapse'] == 'collapse'
    if left:
        if collapse and hasattr(box, 'border_left_width'):
            # In collapsed-borders mode: the computed horizontal padding of the
            # cell and, for border values, the used border-width values of the
            # cell (half the winning border-width)
            width += box.border_left_width
        else:
            # In separated-borders mode: the computed horizontal padding and
            # border of the table-cell
            width += box.style['border_left_width']
    if right:
        if collapse and hasattr(box, 'border_right_width'):
            # [...] the used border-width values of the cell
            width += box.border_right_width
        else:
            # [...] the computed border of the table-cell
            width += box.style['border_right_width']

    if percentages < 100:
        return width / (1 - percentages / 100)
    else:
        # Pathological case, ignore
        return 0


def adjust(box, outer, width, left=True, right=True):
    """Respect min/max and adjust width depending on ``outer``.

    If ``outer`` is set to ``True``, return margin width, else return content
    width.

    """
    fixed = min_max(box, width)

    if outer:
        return margin_width(box, fixed, left, right)
    else:
        return fixed


def block_min_content_width(context, box, outer=True):
    """Return the min-content width for a ``BlockBox``."""
    return _block_content_width(
        context, box, min_content_width, outer)


def block_max_content_width(context, box, outer=True):
    """Return the max-content width for a ``BlockBox``."""
    return _block_content_width(context, box, max_content_width, outer)


def inline_min_content_width(context, box, outer=True, skip_stack=None,
                             first_line=False, is_line_start=False):
    """Return the min-content width for an ``InlineBox``.

    The width is calculated from the lines from ``skip_stack``. If
    ``first_line`` is ``True``, only the first line minimum width is
    calculated.

    """
    widths = inline_line_widths(
        context, box, outer, is_line_start, minimum=True,
        skip_stack=skip_stack, first_line=first_line)
    width = next(widths) if first_line else max(widths)
    return adjust(box, outer, width)


def inline_max_content_width(context, box, outer=True, is_line_start=False):
    """Return the max-content width for an ``InlineBox``."""
    widths = list(
        inline_line_widths(context, box, outer, is_line_start, minimum=False))
    # Remove trailing space, as split_first_line keeps trailing spaces when
    # max_width is not set.
    widths[-1] -= trailing_whitespace_size(context, box)
    return adjust(box, outer, max(widths))


def column_group_content_width(context, box):
    """Return the *-content width for a ``TableColumnGroupBox``."""
    width = box.style['width']
    if width == 'auto' or check_math(width) or width.unit == '%':
        width = 0
    else:
        assert width.unit.lower() == 'px'
        width = width.value

    return adjust(box, False, width)


def table_cell_min_content_width(context, box, outer):
    """Return the min-content width for a ``TableCellBox``."""
    # See https://www.w3.org/TR/css-tables-3/#outer-min-content
    # The outer min-content width of a table-cell is
    # max(min-width, min-content width) adjusted by
    # the cell intrinsic offsets.
    children_widths = [
        min_content_width(context, child)
        for child in box.children
        if not child.is_absolutely_positioned()]
    children_min_width = adjust(
        box,
        outer,
        max(children_widths) if children_widths else 0)

    return children_min_width


def table_cell_min_max_content_width(context, box, outer=True):
    """Return the min- and max-content width for a ``TableCellBox``."""
    # This is much faster than calling min and max separately.
    min_width = table_cell_min_content_width(context, box, outer)
    max_width = max(min_width, block_max_content_width(context, box, outer))
    return min_width, max_width


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):
        indent_token = box.style['text_indent']
        if check_math(indent_token):
            # Ignore percentages by setting refer_to to 0.
            result = resolve_math(indent_token, box.style, 'text_indent', refer_to=0)
            value = validate_non_shorthand((result,), 'text-indent')[0][1]
            if value and value.unit != '%':
                text_indent = value.value
        elif indent_token.unit != '%':
            text_indent = box.style['text_indent'].value

    # 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

        # 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)
            if first_line:
                lines = [next(lines) or None]
            else:
                lines = [line or None for line in lines]
            if len(lines) == 1:
                lines[0] = adjust(child, outer, lines[0] or 0)
            else:
                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):
            # 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:
                (skip, skip_stack), = skip_stack.items()
                assert skip_stack is None
            child_text = child.text.encode()[(skip or 0):]
            if is_line_start and space_collapse:
                child_text = child_text.lstrip(b' ')
            max_width = 0 if minimum else None
            lines = []
            resume_index = new_resume_index = 0
            while new_resume_index is not None:
                resume_index += new_resume_index
                _, _, new_resume_index, width, _, _ = split_first_line(
                    child_text[resume_index:].decode(), child.style, context, max_width,
                    child.justification_spacing, is_line_start=is_line_start,
                    minimum=True)
                lines.append(width or None)
                if first_line:
                    break
            if first_line and new_resume_index:
                # 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.
            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:
                # 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
            #  of the Object Replacement Character (U+FFFC)."
            # https://www.unicode.org/reports/tr14/#DescriptionOfProperties
            # "By default, there is a break opportunity
            #  both before and after any inline object."
            if minimum:
                # "For soft wrap opportunities defined by the boundary between two
                # characters or atomic inlines, the white-space property on the nearest
                # common ancestor of the two characters controls breaking; which
                # elements’ line-break, word-break, and overflow-wrap properties control
                # the determination of soft wrap opportunities at such boundaries is
                # undefined in this level." We choose to always follow the parent’s
                # value here, other parts of the line-breaking algorithm do the same.
                if box.style['white_space'] in ('normal', 'pre-wrap', 'pre-line'):
                    lines = [None, min_content_width(context, child), None]
                else:
                    lines = [min_content_width(context, child)]
            else:
                lines = [max_content_width(context, child)]
        # The first text line goes on the current line.
        current_line += lines[0] or 0
        if len(lines) > 1:
            # Forced line break(s).
            yield current_line + text_indent
            text_indent = 0
            if len(lines) > 2:
                for line in lines[1:-1]:
                    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


def _percentage_contribution(box):
    """Return the percentage contribution of a cell, column or column group.

    https://dbaron.org/css/intrinsic/#pct-contrib

    """
    min_width = box.style['min_width']
    min_width = (
        min_width.value if min_width != 'auto' and
        not check_math(min_width) and min_width.unit == '%' else 0)
    max_width = box.style['max_width']
    max_width = (
        max_width.value if max_width != 'auto' and
        not check_math(max_width) and max_width.unit == '%' else inf)
    width = box.style['width']
    width = (
        width.value if width != 'auto' and
        not check_math(width) and width.unit == '%' else 0)
    return max(min_width, min(width, max_width))


def table_and_columns_preferred_widths(context, box, outer=True):
    """Return content widths for the auto layout table and its columns.

    The tuple returned is
    ``(table_min_content_width, table_max_content_width,
       column_min_content_widths, column_max_content_widths,
       column_intrinsic_percentages, constrainedness,
       total_horizontal_border_spacing, grid)``

    https://dbaron.org/css/intrinsic/

    """
    from .table import distribute_excess_width

    table = box.get_wrapped_table()
    result = context.tables.get(table)
    if result:
        return result[outer]

    # Create the grid
    grid_width, grid_height = 0, 0
    row_number = 0
    for row_group in table.children:
        for row in row_group.children:
            for cell in row.children:
                grid_width = max(cell.grid_x + cell.colspan, grid_width)
                grid_height = max(row_number + cell.rowspan, grid_height)
            row_number += 1
    grid = [[None] * grid_width for i in range(grid_height)]
    row_number = 0
    for row_group in table.children:
        for row in row_group.children:
            for cell in row.children:
                grid[row_number][cell.grid_x] = cell
            row_number += 1

    zipped_grid = list(zip(*grid))

    # Define the total horizontal border spacing
    if table.style['border_collapse'] == 'separate' and grid_width > 0:
        total_horizontal_border_spacing = (
            table.style['border_spacing'][0] *
            (1 + len([column for column in zipped_grid if any(column)])))
    else:
        total_horizontal_border_spacing = 0

    if grid_width == 0 or grid_height == 0:
        table.children = []
        min_width = block_min_content_width(context, table, outer=False)
        max_width = block_max_content_width(context, table, outer=False)
        outer_min_width = adjust(
            box, outer=True, width=block_min_content_width(context, table))
        outer_max_width = adjust(
            box, outer=True, width=block_max_content_width(context, table))
        result = ([], [], [], [], total_horizontal_border_spacing, [])
        context.tables[table] = result = {
            False: (min_width, max_width, *result),
            True: (outer_min_width, outer_max_width, *result),
        }
        return result[outer]

    column_groups = [None] * grid_width
    columns = [None] * grid_width
    column_number = 0
    for column_group in table.column_groups:
        for column in column_group.children:
            column_groups[column_number] = column_group
            columns[column_number] = column
            column_number += 1
            if column_number == grid_width:
                break
        else:
            continue
        break

    colspan_cells = []
    colspans = set()

    # Define the intermediate content widths
    min_content_widths = [0] * grid_width
    max_content_widths = [0] * grid_width
    intrinsic_percentages = [0] * grid_width

    # Intermediate content widths for span 1
    for i in range(grid_width):
        for groups in (column_groups, columns):
            if group := groups[i]:
                min_content_widths[i] = max(
                    min_content_widths[i], min_content_width(context, group))
                max_content_widths[i] = max(
                    max_content_widths[i], max_content_width(context, group))
                intrinsic_percentages[i] = max(
                    intrinsic_percentages[i], _percentage_contribution(group))
        for cell in zipped_grid[i]:
            if not cell:
                continue
            if cell.colspan == 1:
                min_width, max_width = table_cell_min_max_content_width(context, cell)
                min_content_widths[i] = max(min_content_widths[i], min_width)
                max_content_widths[i] = max(max_content_widths[i], max_width)
                intrinsic_percentages[i] = max(
                    intrinsic_percentages[i], _percentage_contribution(cell))
            else:
                colspan_cells.append(cell)
                colspans.add(cell.colspan - 1)

    # Intermediate content widths for span > 1 is wrong in the 4.1 section, as
    # explained in its third issue. Min- and max-content widths are handled by
    # the excess width distribution method, and percentages do not distribute
    # widths to columns that have originating cells.

    # Intermediate intrinsic percentage widths for span > 1
    rows_origins = []
    for y, row in enumerate(grid):
        origin = None
        rows_origins.append(row_origins := [])
        for x, cell in enumerate(row):
            if cell:
                origin = x
            row_origins.append(origin)

    @cache
    def get_percentage_contribution(origin_cell, origin, max_content_width):
        # Cached for big colspan values, see #1155.
        cell_slice = slice(origin, origin + origin_cell.colspan)
        baseline_percentage = sum(intrinsic_percentages[cell_slice])
        cell_percentage_contribution = _percentage_contribution(origin_cell)
        diff = max(0, cell_percentage_contribution - baseline_percentage)
        other_columns_contributions = [
            max_content_widths[j]
            for j in range(origin, origin + origin_cell.colspan)
            if intrinsic_percentages[j] == 0]
        other_columns_contributions_sum = sum(other_columns_contributions)
        if other_columns_contributions_sum == 0:
            ratio = 1 / (len(other_columns_contributions) or 1)
        else:
            ratio = max_content_width / other_columns_contributions_sum
        return diff * ratio

    for span in sorted(colspans):
        percentage_contributions = []
        for i in range(grid_width):
            if percentage_contribution := intrinsic_percentages[i]:
                percentage_contributions.append(percentage_contribution)
                continue
            for row, row_origins in zip(grid, rows_origins):
                if (origin := row_origins[i]) is None:
                    continue
                origin_cell = row[origin]
                if origin_cell.colspan - 1 != span:
                    continue
                cell_percentage_contribution = get_percentage_contribution(
                    origin_cell, origin, max_content_widths[i])
                percentage_contribution = max(
                    percentage_contribution, cell_percentage_contribution)

            percentage_contributions.append(percentage_contribution)

        intrinsic_percentages = percentage_contributions

    # Define constrainedness
    constrainedness = [False for i in range(grid_width)]
    for i in range(grid_width):
        if column_groups[i]:
            width = column_groups[i].style['width']
            if width != 'auto' and not check_math(width) and width.unit != '%':
                constrainedness[i] = True
                continue
        if columns[i]:
            width = columns[i].style['width']
            if width != 'auto' and not check_math(width) and width.unit != '%':
                constrainedness[i] = True
                continue
        for cell in zipped_grid[i]:
            if cell and cell.colspan == 1:
                width = cell.style['width']
                if width != 'auto' and not check_math(width) and width.unit != '%':
                    constrainedness[i] = True
                    break

    intrinsic_percentages = [
        min(percentage, 100 - sum(intrinsic_percentages[:i]))
        for i, percentage in enumerate(intrinsic_percentages)]

    # Max- and min-content widths for span > 1
    for cell in colspan_cells:
        min_content = min_content_width(context, cell)
        max_content = max_content_width(context, cell)
        column_slice = slice(cell.grid_x, cell.grid_x + cell.colspan)
        columns_min_content = sum(min_content_widths[column_slice])
        columns_max_content = sum(max_content_widths[column_slice])
        if table.style['border_collapse'] == 'separate':
            spacing = (cell.colspan - 1) * table.style['border_spacing'][0]
        else:
            spacing = 0

        if min_content > columns_min_content + spacing:
            excess_width = min_content - (columns_min_content + spacing)
            distribute_excess_width(
                context, zipped_grid, excess_width, min_content_widths,
                constrainedness, intrinsic_percentages, max_content_widths,
                column_slice)

        if max_content > columns_max_content + spacing:
            excess_width = max_content - (columns_max_content + spacing)
            distribute_excess_width(
                context, zipped_grid, excess_width, max_content_widths,
                constrainedness, intrinsic_percentages, max_content_widths,
                column_slice)

    # Calculate the max- and min-content widths of table and columns
    small_percentage_contributions = [
        max_content_widths[i] / (intrinsic_percentages[i] / 100)
        for i in range(grid_width)
        if intrinsic_percentages[i]]
    large_percentage_contribution_numerator = sum(
        max_content_widths[i] for i in range(grid_width)
        if intrinsic_percentages[i] == 0)
    large_percentage_contribution_denominator = (
        (100 - sum(intrinsic_percentages)) / 100)
    if large_percentage_contribution_denominator == 0:
        if large_percentage_contribution_numerator == 0:
            large_percentage_contribution = 0
        else:
            # "the large percentage contribution of the table [is] an
            # infinitely large number if the numerator is nonzero [and] the
            # denominator of that ratio is 0."
            #
            # https://dbaron.org/css/intrinsic/#autotableintrinsic
            #
            # Please note that "an infinitely large number" is not "infinite",
            # and that's probably not a coincindence: putting 'inf' here breaks
            # some cases (see #305).
            large_percentage_contribution = sys.maxsize
    else:
        large_percentage_contribution = (
            large_percentage_contribution_numerator /
            large_percentage_contribution_denominator)

    table_min_content_width = (
        total_horizontal_border_spacing + sum(min_content_widths))
    table_max_content_width = (
        total_horizontal_border_spacing + max([
            sum(max_content_widths), large_percentage_contribution,
            *small_percentage_contributions]))

    width = table.style['width']
    if width != 'auto' and not check_math(width) and width.unit.lower() == 'px':
        # "percentages on the following properties are treated instead as
        # though they were the following: width: auto"
        # https://dbaron.org/css/intrinsic/#outer-intrinsic
        table_min_width = table_max_width = table.style['width'].value
    else:
        table_min_width = table_min_content_width
        table_max_width = table_max_content_width

    table_min_content_width = max(
        table_min_content_width, adjust(
            table, outer=False, width=table_min_width))
    table_max_content_width = max(
        table_max_content_width, adjust(
            table, outer=False, width=table_max_width))
    table_outer_min_content_width = margin_width(
        table, margin_width(box, table_min_content_width))
    table_outer_max_content_width = margin_width(
        table, margin_width(box, table_max_content_width))

    result = (
        min_content_widths, max_content_widths, intrinsic_percentages,
        constrainedness, total_horizontal_border_spacing, zipped_grid)
    context.tables[table] = result = {
        False: (table_min_content_width, table_max_content_width, *result),
        True: (table_outer_min_content_width, table_outer_max_content_width, *result),
    }
    return result[outer]


def replaced_min_content_width(box, outer=True):
    """Return the min-content width for an ``InlineReplacedBox``."""
    width = box.style['width']
    if width == 'auto':
        height = box.style['height']
        if height == 'auto' or check_math(height) or height.unit == '%':
            height = 'auto'
        else:
            assert height.unit.lower() == 'px'
            height = height.value
        unknown_max_width = (
            box.style['max_width'] != 'auto' and
            not check_math(box.style['max_width']) and
            box.style['max_width'].unit == '%')
        if unknown_max_width:
            # See https://drafts.csswg.org/css-sizing/#intrinsic-contribution
            width = 0
        else:
            image = box.replacement
            intrinsic_width, intrinsic_height, intrinsic_ratio = (
                image.get_intrinsic_size(
                    box.style['image_resolution'], box.style['font_size']))
            width, _ = default_image_sizing(
                intrinsic_width, intrinsic_height, intrinsic_ratio, 'auto',
                height, default_width=0, default_height=0)
    elif check_math(box.style['width']) or box.style['width'].unit == '%':
        # See https://drafts.csswg.org/css-sizing/#intrinsic-contribution
        width = 0
    else:
        assert width.unit.lower() == 'px'
        width = width.value
    return adjust(box, outer, width)


def replaced_max_content_width(box, outer=True):
    """Return the max-content width for an ``InlineReplacedBox``."""
    width = box.style['width']
    if width == 'auto':
        height = box.style['height']
        if height == 'auto' or check_math(height) or height.unit == '%':
            height = 'auto'
        else:
            assert height.unit.lower() == 'px'
            height = height.value
        image = box.replacement
        intrinsic_width, intrinsic_height, intrinsic_ratio = (
            image.get_intrinsic_size(
                box.style['image_resolution'], box.style['font_size']))
        width, _ = default_image_sizing(
            intrinsic_width, intrinsic_height, intrinsic_ratio, 'auto', height,
            default_width=300, default_height=150)
    elif check_math(box.style['width']) or box.style['width'].unit == '%':
        # See https://drafts.csswg.org/css-sizing/#intrinsic-contribution
        width = 0
    else:
        assert width.unit.lower() == 'px'
        width = width.value
    return adjust(box, outer, width)


def flex_min_content_width(context, box, outer=True):
    """Return the min-content width for an ``FlexContainerBox``."""
    # TODO: use real values, see
    # https://www.w3.org/TR/css-flexbox-1/#intrinsic-sizes
    min_contents = [
        min_content_width(context, child)
        for child in box.children if child.is_flex_item]
    if not min_contents:
        return adjust(box, outer, 0)
    if (box.style['flex_direction'].startswith('row') and
            box.style['flex_wrap'] == 'nowrap'):
        return adjust(box, outer, sum(min_contents))
    else:
        return adjust(box, outer, max(min_contents))


def flex_max_content_width(context, box, outer=True):
    """Return the max-content width for an ``FlexContainerBox``."""
    # TODO: use real values, see
    # https://www.w3.org/TR/css-flexbox-1/#intrinsic-sizes
    max_contents = [
        max_content_width(context, child)
        for child in box.children if child.is_flex_item]
    if not max_contents:
        return adjust(box, outer, 0)
    if box.style['flex_direction'].startswith('row'):
        return adjust(box, outer, sum(max_contents))
    else:
        return adjust(box, outer, max(max_contents))


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
        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
    elif box.style['white_space'] not in ('normal', 'nowrap', 'pre-line'):
        # Spaces don’t collapse.
        return 0
    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
            old_box, resume, _ = split_text_box(context, box, None, resume)
        assert old_box
        stripped_box = box.copy_with_text(stripped_text)
        stripped_box, resume, _ = split_text_box(
            context, stripped_box, None, old_resume)
        if stripped_box is None:
            # 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


================================================
FILE: weasyprint/layout/replaced.py
================================================
"""Layout for images and other replaced elements.

See https://drafts.csswg.org/css-images-3/#sizing

"""

from .min_max import handle_min_max_height, handle_min_max_width
from .percent import percentage


def default_image_sizing(intrinsic_width, intrinsic_height, intrinsic_ratio,
                         specified_width, specified_height,
                         default_width, default_height):
    """Default sizing algorithm for the concrete object size.

    Return a ``(concrete_width, concrete_height)`` tuple.

    See https://drafts.csswg.org/css-images-3/#default-sizing

    """
    if specified_width == 'auto':
        specified_width = None
    if specified_height == 'auto':
        specified_height = None

    if specified_width is not None and specified_height is not None:
        return specified_width, specified_height
    elif specified_width is not None:
        return specified_width, (
            specified_width / intrinsic_ratio if intrinsic_ratio is not None
            else intrinsic_height if intrinsic_height is not None
            else default_height)
    elif specified_height is not None:
        return (
            specified_height * intrinsic_ratio if intrinsic_ratio is not None
            else intrinsic_width if intrinsic_width is not None
            else default_width
        ), specified_height
    else:
        if intrinsic_width is not None or intrinsic_height is not None:
            return default_image_sizing(
                intrinsic_width, intrinsic_height, intrinsic_ratio,
                intrinsic_width, intrinsic_height, default_width,
                default_height)
        else:
            return contain_constraint_image_sizing(
                default_width, default_height, intrinsic_ratio)


def contain_constraint_image_sizing(constraint_width, constraint_height,
                                    intrinsic_ratio):
    """Contain constraint sizing algorithm for the concrete object size.

    Return a ``(concrete_width, concrete_height)`` tuple.

    See https://drafts.csswg.org/css-images-3/#contain-constraint

    """
    return _constraint_image_sizing(
        constraint_width, constraint_height, intrinsic_ratio, cover=False)


def cover_constraint_image_sizing(constraint_width, constraint_height,
                                  intrinsic_ratio):
    """Cover constraint sizing algorithm for the concrete object size.

    Return a ``(concrete_width, concrete_height)`` tuple.

    See https://drafts.csswg.org/css-images-3/#cover-constraint

    """
    return _constraint_image_sizing(
        constraint_width, constraint_height, intrinsic_ratio, cover=True)


def _constraint_image_sizing(constraint_width, constraint_height,
                             intrinsic_ratio, cover):
    if intrinsic_ratio is None:
        return constraint_width, constraint_height
    elif cover ^ (constraint_width > constraint_height * intrinsic_ratio):
        return constraint_height * intrinsic_ratio, constraint_height
    else:
        return constraint_width, constraint_width / intrinsic_ratio


def replacedbox_layout(box):
    # TODO: respect box-sizing ?
    object_fit = box.style['object_fit']
    position = box.style['object_position']

    image = box.replacement
    intrinsic_width, intrinsic_height, intrinsic_ratio = (
        image.get_intrinsic_size(
            box.style['image_resolution'], box.style['font_size']))
    if None in (intrinsic_width, intrinsic_height):
        intrinsic_width, intrinsic_height = contain_constraint_image_sizing(
            box.width, box.height, intrinsic_ratio)

    if object_fit == 'fill':
        draw_width, draw_height = box.width, box.height
    else:
        if object_fit in ('contain', 'scale-down'):
            draw_width, draw_height = contain_constraint_image_sizing(
                box.width, box.height, intrinsic_ratio)
        elif object_fit == 'cover':
            draw_width, draw_height = cover_constraint_image_sizing(
                box.width, box.height, intrinsic_ratio)
        else:
            assert object_fit == 'none', object_fit
            draw_width, draw_height = intrinsic_width, intrinsic_height

        if object_fit == 'scale-down':
            draw_width = min(draw_width, intrinsic_width)
            draw_height = min(draw_height, intrinsic_height)

    origin_x, position_x, origin_y, position_y = position[0]
    ref_x = box.width - draw_width
    ref_y = box.height - draw_height

    position_x = percentage(position_x, box.style, ref_x)
    position_y = percentage(position_y, box.style, ref_y)
    if origin_x == 'right':
        position_x = ref_x - position_x
    if origin_y == 'bottom':
        position_y = ref_y - position_y

    position_x += box.content_box_x()
    position_y += box.content_box_y()

    return draw_width, draw_height, position_x, position_y


@handle_min_max_width
def replaced_box_width(box, containing_block):
    """Set the used width for replaced boxes."""
    from .block import block_level_width

    width, height, ratio = box.replacement.get_intrinsic_size(
        box.style['image_resolution'], box.style['font_size'])

    # This algorithm simply follows the different points of the specification:
    # https://www.w3.org/TR/CSS21/visudet.html#inline-replaced-width
    if box.height == box.width == 'auto':
        if width is not None:
            # Point #1
            box.width = width
        elif ratio is not None:
            if height is not None:
                # Point #2 first part
                box.width = height * ratio
            else:
                # Point #3
                block_level_width(box, containing_block)

    if box.width == 'auto':
        if ratio is not None:
            # Point #2 second part
            box.width = box.height * ratio
        elif width is not None:
            # Point #4
            box.width = width
        else:
            # Point #5
            # It's pretty useless to rely on device size to set width.
            box.width = 300


@handle_min_max_height
def replaced_box_height(box):
    """Compute and set the used height for replaced boxes."""
    # https://www.w3.org/TR/CSS21/visudet.html#inline-replaced-height
    width, height, ratio = box.replacement.get_intrinsic_size(
        box.style['image_resolution'], box.style['font_size'])

    # Test 'auto' on the computed width, not the used width
    if box.height == box.width == 'auto':
        box.height = height
    elif box.height == 'auto' and ratio:
        box.height = box.width / ratio

    if box.height == box.width == 'auto' and height is not None:
        box.height = height
    elif ratio is not None and box.height == 'auto':
        box.height = box.width / ratio
    elif box.height == 'auto' and height is not None:
        box.height = height
    elif box.height == 'auto':
        # It's pretty useless to rely on device size to set width.
        box.height = 150


def inline_replaced_box_layout(box, containing_block):
    """Lay out an inline :class:`boxes.ReplacedBox` ``box``."""
    for side in ('top', 'right', 'bottom', 'left'):
        if getattr(box, f'margin_{side}') == 'auto':
            setattr(box, f'margin_{side}', 0)
    inline_replaced_box_width_height(box, containing_block)


def inline_replaced_box_width_height(box, containing_block):
    if box.style['width'] == box.style['height'] == 'auto':
        replaced_box_width.without_min_max(box, containing_block)
        replaced_box_height.without_min_max(box)
        min_max_auto_replaced(box)
    else:
        replaced_box_width(box, containing_block)
        replaced_box_height(box)


def min_max_auto_replaced(box):
    """Resolve min/max constraints on replaced elements with 'auto' sizes."""
    width = box.width
    height = box.height
    min_width = box.min_width
    min_height = box.min_height
    max_width = max(min_width, box.max_width)
    max_height = max(min_height, box.max_height)

    # (violation_width, violation_height)
    violations = (
        'min' if width < min_width else 'max' if width > max_width else '',
        'min' if height < min_height else 'max' if height > max_height else '')

    # Work around divisions by zero. These are pathological cases anyway.
    # TODO: is there a cleaner way?
    if width == 0:
        width = 1e-6
    if height == 0:
        height = 1e-6

    # ('', ''): nothing to do
    if violations == ('max', ''):
        box.width = max_width
        box.height = max(max_width * height / width, min_height)
    elif violations == ('min', ''):
        box.width = min_width
        box.height = min(min_width * height / width, max_height)
    elif violations == ('', 'max'):
        box.width = max(max_height * width / height, min_width)
        box.height = max_height
    elif violations == ('', 'min'):
        box.width = min(min_height * width / height, max_width)
        box.height = min_height
    elif violations == ('max', 'max'):
        if max_width / width <= max_height / height:
            box.width = max_width
            box.height = max(min_height, max_width * height / width)
        else:
            box.width = max(min_width, max_height * width / height)
            box.height = max_height
    elif violations == ('min', 'min'):
        if min_width / width <= min_height / height:
            box.width = min(max_width, min_height * width / height)
            box.height = min_height
        else:
            box.width = min_width
            box.height = min(max_height, min_width * height / width)
    elif violations == ('min', 'max'):
        box.width = min_width
        box.height = max_height
    elif violations == ('max', 'min'):
        box.width = max_width
        box.height = min_height


def block_replaced_box_layout(context, box, containing_block):
    """Lay out the block :class:`boxes.ReplacedBox` ``box``."""
    from .block import block_level_width
    from .float import avoid_collisions

    box = box.copy()
    if box.style['width'] == box.style['height'] == 'auto':
        computed_margins = box.margin_left, box.margin_right
        block_replaced_width.without_min_max(
            box, containing_block)
        replaced_box_height.without_min_max(box)
        min_max_auto_replaced(box)
        box.margin_left, box.margin_right = computed_margins
        block_level_width.without_min_max(box, containing_block)
    else:
        block_replaced_width(box, containing_block)
        replaced_box_height(box)

    # TODO: flex items shouldn't be block boxes, this condition
    # would then be useless when this is fixed.
    if not box.is_flex_item:
        # Don't collide with floats
        # https://www.w3.org/TR/CSS21/visuren.html#floats
        box.position_x, box.position_y, _ = avoid_collisions(
            context, box, containing_block, outer=False)
    resume_at = None
    next_page = {'break': 'any', 'page': None}
    adjoining_margins = []
    collapsing_through = False
    return box, resume_at, next_page, adjoining_margins, collapsing_through


@handle_min_max_width
def block_replaced_width(box, containing_block):
    from .block import block_level_width

    # https://www.w3.org/TR/CSS21/visudet.html#block-replaced-width
    replaced_box_width.without_min_max(box, containing_block)
    block_level_width.without_min_max(box, containing_block)


================================================
FILE: weasyprint/layout/table.py
================================================
"""Layout for tables and internal table boxes."""

from math import inf

import tinycss2.color5

from ..formatting_structure import boxes
from ..logger import LOGGER
from .percent import resolve_one_percentage, resolve_percentages
from .preferred import table_and_columns_preferred_widths


def table_layout(context, table, bottom_space, skip_stack, containing_block,
                 page_is_empty, absolute_boxes, fixed_boxes):
    """Layout for a table box."""
    from .block import (  # isort:skip
        avoid_page_break, block_container_layout, block_level_page_break,
        find_earlier_page_break, force_page_break, remove_placeholders)

    # Remove top and bottom decorations for split tables.
    has_header = table.children and table.children[0].is_header
    has_footer = table.children and table.children[-1].is_footer
    collapse = table.style['border_collapse'] == 'collapse'
    remove_start_decoration = skip_stack is not None and not has_header
    table.remove_decoration(remove_start_decoration, end=False)

    # Set border spacings.
    if collapse:
        border_spacing_x = border_spacing_y = 0
    else:
        border_spacing_x, border_spacing_y = table.style['border_spacing']

    # Define column positions.
    column_widths = table.column_widths
    column_positions = table.column_positions = []
    rows_left_x = table.content_box_x() + border_spacing_x
    if table.style['direction'] == 'ltr':
        position_x = table.content_box_x()
        rows_x = position_x + border_spacing_x
        for width in column_widths:
            position_x += border_spacing_x
            column_positions.append(position_x)
            position_x += width
        rows_width = position_x - rows_x
    else:
        position_x = table.content_box_x() + table.width
        rows_x = position_x - border_spacing_x
        for width in column_widths:
            position_x -= border_spacing_x
            position_x -= width
            column_positions.append(position_x)
        rows_width = rows_x - position_x

    # Set border top width on tables with collapsed borders and split cells.
    if collapse:
        table.skip_cell_border_top = False
        table.skip_cell_border_bottom = False
        split_cells = False
        if skip_stack:
            (skipped_groups, group_skip_stack), = skip_stack.items()
            if group_skip_stack:
                (skipped_rows, cells_skip_stack), = group_skip_stack.items()
                if cells_skip_stack:
                    split_cells = True
            else:
                skipped_rows = 0
            for group in table.children[:skipped_groups]:
                skipped_rows += len(group.children)
        else:
            skipped_rows = 0
        if not split_cells and not has_header:
            _, horizontal_borders = table.collapsed_border_grid
            if horizontal_borders:
                table.border_top_width = max(
                    width for _, (_, width, _)
                    in horizontal_borders[skipped_rows]) / 2

    # Make this a sub-function so that many local variables like rows_x
    # don't need to be passed as parameters.
    def group_layout(group, position_y, bottom_space, page_is_empty, skip_stack):
        resume_at = None
        next_page = {'break': 'any', 'page': None}
        original_page_is_empty = page_is_empty
        resolve_percentages(group, containing_block=table)
        group.position_x = rows_left_x
        group.position_y = position_y
        group.width = rows_width
        new_group_children = []
        # For each row, cells for which this is the last row (with rowspan).
        ending_cells_by_row = [[] for row in group.children]

        is_group_start = skip_stack is None
        if is_group_start:
            skip = 0
        else:
            (skip, skip_stack), = skip_stack.items()
        for index_row, row in enumerate(group.children[skip:], start=skip):
            row.index = index_row

            if new_group_children:
                page_break = block_level_page_break(
                    new_group_children[-1], row)
                if force_page_break(page_break, context):
                    next_page['break'] = page_break
                    resume_at = {index_row: None}
                    break

            resolve_percentages(row, containing_block=table)
            row.position_x = rows_left_x
            row.position_y = position_y
            row.width = rows_width
            # Place cells at the top of the row and layout their content.
            new_row_children = []
            for index_cell, cell in enumerate(row.children):
                spanned_widths = column_widths[cell.grid_x:][:cell.colspan]
                # In the fixed layout the grid width is set by cells in
                # the first row and column elements.
                # This may be less than the previous value of cell.colspan
                # if that would bring the cell beyond the grid width.
                cell.colspan = len(spanned_widths)
                if cell.colspan == 0:
                    # The cell is entierly beyond the grid width, remove it
                    # entierly. Subsequent cells in the same row have greater
                    # grid_x, so they are beyond too.
                    cell_index = row.children.index(cell)
                    ignored_cells = row.children[cell_index:]
                    LOGGER.warning(
                        'This table row has more columns than the table, '
                        f'ignored {len(ignored_cells)} cells: {ignored_cells}')
                    break
                resolve_percentages(cell, containing_block=table)
                if table.style['direction'] == 'ltr':
                    cell.position_x = column_positions[cell.grid_x]
                else:
                    cell.position_x = column_positions[cell.grid_x + cell.colspan - 1]
                cell.position_y = row.position_y
                cell.margin_top = 0
                cell.margin_left = 0
                cell.width = 0
                borders_plus_padding = cell.border_width()  # with width==0
                # TODO: we should remove the number of columns with no
                # originating cells to cell.colspan, see test_layout_table_auto_49.
                cell.width = (
                    sum(spanned_widths) +
                    border_spacing_x * (cell.colspan - 1) -
                    borders_plus_padding)
                if skip_stack:
                    if index_cell in skip_stack:
                        cell_skip_stack = skip_stack[index_cell]
                    else:
                        cell_skip_stack = {len(cell.children): None}
                else:
                    cell_skip_stack = None

                # Adapt cell and table collapsing borders when a row is split.
                if cell_skip_stack and collapse:
                    if has_header:
                        # We have a header, we have to adapt the position of
                        # the split cell to match the header’s bottom border.
                        header_rows = table.children[0].children
                        if header_rows and header_rows[-1].children:
                            cell.position_y += max(
                                header.border_bottom_width
                                for header in header_rows[-1].children)
                    else:
                        # We don’t have a header, we have to skip the
                        # decoration at the top of the table when it’s drawn.
                        table.skip_cell_border_top = True

                # First try to render content as if there was already something
                # on the page to avoid hitting block_level_layout’s TODO. Then
                # force to render something if the page is actually empty, or
                # just draw an empty cell otherwise. See
                # test_table_break_children_margin.
                # Pretend that height is not set, keeping computed height as a minimum.
                cell.computed_height = cell.height
                cell.height = 'auto'
                original_style = cell.style
                if cell.style['height'] != 'auto':
                    style_copy = cell.style.copy()
                    style_copy['height'] = 'auto'
                    cell.style = style_copy
                new_cell, cell_resume_at, _, _, _, _ = block_container_layout(
                    context, cell, bottom_space, cell_skip_stack,
                    page_is_empty=page_is_empty, absolute_boxes=absolute_boxes,
                    fixed_boxes=fixed_boxes, adjoining_margins=None,
                    first_letter_style=None, first_line_style=None, discard=False,
                    max_lines=None)
                cell.style = original_style
                if new_cell is None:
                    cell = cell.copy_with_children([])
                    cell, _, _, _, _, _ = block_container_layout(
                        context, cell, bottom_space, cell_skip_stack,
                        page_is_empty=True, absolute_boxes=[], fixed_boxes=[],
                        adjoining_margins=None, first_letter_style=None,
                        first_line_style=None, discard=False, max_lines=None)
                    cell_resume_at = {0: None}
                else:
                    cell = new_cell

                cell.remove_decoration(start=cell_skip_stack is not None, end=False)
                if cell_resume_at:
                    if resume_at is None:
                        resume_at = {index_row: {}}
                    resume_at[index_row][index_cell] = cell_resume_at
                cell.empty = not any(
                    child.is_floated() or child.is_in_normal_flow()
                    for child in cell.children)
                cell.content_height = cell.height
                if cell.computed_height != 'auto':
                    cell.height = max(cell.height, cell.computed_height)
                new_row_children.append(cell)

            if resume_at and not page_is_empty:
                # Avoid break when "break-inside: avoid" is set on row or any
                # on its cells.
                avoid_break = (
                    avoid_page_break(row.style['break_inside'], context) or any(
                        avoid_page_break(cell.style['break_inside'], context)
                        for cell in row.children))
                if avoid_break:
                    resume_at = {index_row: {}}
                    remove_placeholders(
                        context, new_row_children, absolute_boxes, fixed_boxes)
                    break

            if resume_at:
                # Remove bottom decoration if row is split.
                for cell in new_row_children:
                    cell.remove_decoration(start=False, end=True)

            row = row.copy_with_children(new_row_children)

            # Table height algorithm
            # https://www.w3.org/TR/CSS21/tables.html#height-layout

            # Set row baseline with cells with vertical-align: baseline.
            baseline_cells = []
            for cell in row.children:
                vertical_align = cell.style['vertical_align']
                if vertical_align in ('top', 'middle', 'bottom'):
                    cell.vertical_align = vertical_align
                else:
                    # Assume 'baseline' for any other value
                    cell.vertical_align = 'baseline'
                    cell.baseline = cell_baseline(cell)
                    baseline_cells.append(cell)
            if baseline_cells:
                row.baseline = max(cell.baseline for cell in baseline_cells)
                for cell in baseline_cells:
                    extra = row.baseline - cell.baseline
                    if cell.baseline != row.baseline and extra:
                        add_top_padding(cell, extra)

            # Set row height.
            for cell in row.children:
                ending_cells_by_row[cell.rowspan - 1].append(cell)
            ending_cells = ending_cells_by_row.pop(0)
            if ending_cells:  # in this row
                if row.height == 'auto':
                    row_bottom_y = max(
                        cell.position_y + cell.border_height()
                        for cell in ending_cells)
                    row.height = max(row_bottom_y - row.position_y, 0)
                else:
                    row.height = max(row.height, max(
                        row_cell.border_height() for row_cell in ending_cells))
                    row_bottom_y = row.position_y + row.height
            else:
                row_bottom_y = row.position_y
                row.height = 0

            if not baseline_cells:
                row.baseline = row_bottom_y

            # Add extra padding to make the cells the same height as the row
            # and honor vertical-align.
            for cell in ending_cells:
                cell_bottom_y = cell.position_y + cell.border_height()
                extra = row_bottom_y - cell_bottom_y
                if extra:
                    if cell.vertical_align == 'bottom':
                        add_top_padding(cell, extra)
                    elif cell.vertical_align == 'middle':
                        extra /= 2
                        add_top_padding(cell, extra)
                        cell.padding_bottom += extra
                    else:
                        cell.padding_bottom += extra
                if cell.computed_height != 'auto':
                    vertical_align_shift = 0
                    if cell.vertical_align == 'middle':
                        vertical_align_shift = (
                            cell.computed_height - cell.content_height) / 2
                    elif cell.vertical_align == 'bottom':
                        vertical_align_shift = (
                            cell.computed_height - cell.content_height)
                    if vertical_align_shift > 0:
                        for child in cell.children:
                            child.translate(dy=vertical_align_shift)

            next_position_y = row.position_y + row.height
            if resume_at is None:
                next_position_y += border_spacing_y

            # Break if one cell was broken.
            break_cell = False
            if resume_at:
                if all(child.empty for child in row.children):
                    # No cell was displayed, give up row.
                    next_position_y = inf
                    page_is_empty = False
                    resume_at = None
                else:
                    break_cell = True

            # Break if this row overflows the page, unless there is no
            # other content on the page.
            overflow = context.overflows_page(bottom_space, next_position_y)
            if not page_is_empty and overflow:
                remove_placeholders(context, row.children, absolute_boxes, fixed_boxes)
                if new_group_children:
                    previous_row = new_group_children[-1]
                    page_break = block_level_page_break(previous_row, row)
                    if avoid_page_break(page_break, context):
                        earlier_page_break = find_earlier_page_break(
                            context, new_group_children, absolute_boxes, fixed_boxes)
                        if earlier_page_break:
                            new_group_children, resume_at = earlier_page_break
                            break
                    else:
                        resume_at = {index_row: None}
                        break
                if original_page_is_empty:
                    resume_at = {index_row: None}
                else:
                    return None, None, next_page
                break

            new_group_children.append(row)
            position_y = next_position_y
            page_is_empty = False
            skip_stack = None

            if break_cell and collapse and not has_footer:
                table.skip_cell_border_bottom = True

            if break_cell or resume_at:
                break

        # Do not keep the row group if we made a page break
        # before any of its rows or with 'avoid'.
        abort = (
            resume_at and
            not original_page_is_empty and (
                avoid_page_break(group.style['break_inside'], context) or
                not new_group_children))
        if abort:
            remove_placeholders(
                context, new_group_children, absolute_boxes, fixed_boxes)
            return None, None, next_page

        group = group.copy_with_children(new_group_children)
        group.remove_decoration(start=not is_group_start, end=resume_at is not None)

        # Set missing baselines in a second loop because of rowspan.
        for row in group.children:
            if row.baseline is None:
                if row.children:
                    # Set baseline to lowest bottom content edge.
                    row.baseline = max(
                        cell.content_box_y() + cell.height
                        for cell in row.children) - row.position_y
                else:
                    row.baseline = 0
        group.height = position_y - group.position_y
        if group.children:
            # The last border spacing is outside of the group.
            group.height -= border_spacing_y

        return group, resume_at, next_page

    def body_groups_layout(skip_stack, position_y, bottom_space, page_is_empty):
        if skip_stack is None:
            skip = 0
        else:
            (skip, skip_stack), = skip_stack.items()
        new_table_children = []
        resume_at = None
        next_page = {'break': 'any', 'page': None}

        for i, group in enumerate(table.children[skip:]):
            if group.is_header or group.is_footer:
                continue

            # Index is useless for headers and footers, as we never want to
            # break pages after the header or before the footer.
            index_group = i + skip
            group.index = index_group

            if new_table_children:
                page_break = block_level_page_break(new_table_children[-1], group)
                if force_page_break(page_break, context):
                    next_page['break'] = page_break
                    resume_at = {index_group: None}
                    break

            new_group, resume_at, next_page = group_layout(
                group, position_y, bottom_space, page_is_empty, skip_stack)
            skip_stack = None

            if new_group is None:
                if new_table_children:
                    previous_group = new_table_children[-1]
                    page_break = block_level_page_break(previous_group, group)
                    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 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
                break

            new_table_children.append(new_group)
            position_y += new_group.height + border_spacing_y
            page_is_empty = False

            if resume_at:
                resume_at = {index_group: resume_at}
                break

        return new_table_children, resume_at, next_page, position_y

    # Layout row groups, rows and cells.
    position_y = table.content_box_y()
    if skip_stack is None:
        position_y += border_spacing_y
    initial_position_y = position_y
    table_rows = [
        child for child in table.children
        if not child.is_header and not child.is_footer]

    def all_groups_layout():
        # If the page is not empty, we try to render the header and the footer
        # on it. If the table does not fit on the page, we try to render it on
        # the next page.

        # If the page is empty and the header and footer are too big, there
        # are not rendered. If no row can be rendered because of the header and
        # the footer, the header and/or the footer are not rendered.

        if page_is_empty:
            header_footer_bottom_space = bottom_space
        else:
            header_footer_bottom_space = -inf

        if has_header:
            header = table.children[0]
            header, resume_at, next_page = group_layout(
                header, position_y, header_footer_bottom_space,
                skip_stack=None, page_is_empty=False)
            if header and not resume_at:
                header_height = header.height + border_spacing_y
            else:
                # Header too big for the page.
                header = None
        else:
            header = None

        if has_footer:
            footer = table.children[-1]
            footer, resume_at, next_page = group_layout(
                footer, position_y, header_footer_bottom_space,
                skip_stack=None, page_is_empty=False)
            if footer and not resume_at:
                footer_height = footer.height + border_spacing_y
            else:
                # Footer too big for the page.
                footer = None
        else:
            footer = None

        # Don't remove headers and footers if breaks are avoided in line groups
        if skip_stack:
            skip, = skip_stack
        else:
            skip = 0
        avoid_breaks = False
        for group in table.children[skip:]:
            if not group.is_header and not group.is_footer:
                avoid_breaks = avoid_page_break(group.style['break_inside'], context)
                break

        if header and footer:
            # Try with both the header and footer.
            new_table_children, resume_at, next_page, end_position_y = (
                body_groups_layout(
                    skip_stack, position_y + header_height,
                    bottom_space + footer_height, page_is_empty=avoid_breaks))
            if new_table_children or not table_rows or not page_is_empty:
                footer.translate(dy=end_position_y - footer.position_y)
                end_position_y += footer_height
                return (
                    header, new_table_children, footer, end_position_y, resume_at,
                    next_page)
            else:
                # We could not fit any content, drop the footer.
                footer = None

        if header and not footer:
            # Try with just the header.
            new_table_children, resume_at, next_page, end_position_y = (
                body_groups_layout(
                    skip_stack, position_y + header_height, bottom_space,
                    page_is_empty=avoid_breaks))
            if new_table_children or not table_rows or not page_is_empty:
                return (
                    header, new_table_children, footer, end_position_y, resume_at,
                    next_page)
            else:
                # We could not fit any content, drop the header.
                header = None

        if footer and not header:
            # Try with just the footer.
            new_table_children, resume_at, next_page, end_position_y = (
                body_groups_layout(
                    skip_stack, position_y, bottom_space + footer_height,
                    page_is_empty=avoid_breaks))
            if new_table_children or not table_rows or not page_is_empty:
                footer.translate(dy=end_position_y - footer.position_y)
                end_position_y += footer_height
                return (
                    header, new_table_children, footer, end_position_y, resume_at,
                    next_page)
            else:
                # We could not fit any content, drop the footer.
                footer = None

        assert not header
        assert not footer
        new_table_children, resume_at, next_page, end_position_y = (
            body_groups_layout(skip_stack, position_y, bottom_space, page_is_empty))
        return header, new_table_children, footer, end_position_y, resume_at, next_page

    def get_column_cells(table, column):
        """Return closure getting the column cells."""
        return lambda: [
            cell
            for row_group in table.children
            for row in row_group.children
            for cell in row.children
            if cell.grid_x == column.grid_x]

    header, new_table_children, footer, position_y, resume_at, next_page = (
        all_groups_layout())

    if new_table_children is None:
        assert resume_at is None
        table = None
        adjoining_margins = []
        collapsing_through = False
        return table, resume_at, next_page, adjoining_margins, collapsing_through

    table = table.copy_with_children(
        ([header] if header is not None else []) +
        new_table_children +
        ([footer] if footer is not None else []))
    table.column_groups = tuple(
        column_group.deepcopy() for column_group in table.column_groups)
    remove_end_decoration = resume_at is not None and not has_footer
    table.remove_decoration(remove_start_decoration, remove_end_decoration)
    if collapse:
        table.skipped_rows = skipped_rows

    # If the height property has a bigger value, just add blank space
    # below the last row group.
    table.height = max(
        table.height if table.height != 'auto' else 0,
        position_y - table.content_box_y())

    # Layout column groups and columns.
    columns_height = position_y - initial_position_y
    if table.children:
        # The last border spacing is below the columns.
        columns_height -= border_spacing_y
    for group in table.column_groups:
        for column in group.children:
            resolve_percentages(column, containing_block=table)
            if column.grid_x < len(column_positions):
                column.position_x = column_positions[column.grid_x]
                column.position_y = initial_position_y
                column.width = column_widths[column.grid_x]
                column.height = columns_height
            else:
                # Ignore extra empty columns.
                column.position_x = 0
                column.position_y = 0
                column.width = 0
                column.height = 0
            resolve_percentages(group, containing_block=table)
            column.get_cells = get_column_cells(table, column)
        first = group.children[0]
        last = group.children[-1]
        group.position_x = first.position_x
        group.position_y = initial_position_y
        group.width = last.position_x + last.width - first.position_x
        group.height = columns_height

    # Invert columns for drawing.
    if table.style['direction'] == 'rtl':
        column_widths.reverse()
        column_positions.reverse()

    avoid_break = avoid_page_break(table.style['break_inside'], context)
    if resume_at and not page_is_empty and avoid_break:
        remove_placeholders(context, [table], absolute_boxes, fixed_boxes)
        table = None
        resume_at = None
    adjoining_margins = []
    collapsing_through = False

    return table, resume_at, next_page, adjoining_margins, collapsing_through


def add_top_padding(box, extra_padding):
    """Increase the top padding of a box.

    This also translates the children.

    """
    box.padding_top += extra_padding
    for child in box.children:
        child.translate(dy=extra_padding)


def fixed_table_layout(box):
    """Run the fixed table layout and return a list of column widths.

    https://www.w3.org/TR/CSS21/tables.html#fixed-table-layout

    """
    table = box.get_wrapped_table()
    assert table.width != 'auto'

    all_columns = [
        column for column_group in table.column_groups
        for column in column_group.children]
    if table.children and table.children[0].children:
        first_rowgroup = table.children[0]
        first_row_cells = first_rowgroup.children[0].children
    else:
        first_row_cells = []
    num_columns = max(len(all_columns), sum(cell.colspan for cell in first_row_cells))
    # ``None`` means not know yet.
    column_widths = [None] * num_columns

    # Set width on column boxes.
    for i, column in enumerate(all_columns):
        resolve_one_percentage(column, 'width', table.width)
        if column.width != 'auto':
            column_widths[i] = column.width

    if table.style['border_collapse'] == 'separate':
        border_spacing_x, _ = table.style['border_spacing']
    else:
        border_spacing_x = 0

    # Set width on cells of the first row.
    i = 0
    for cell in first_row_cells:
        resolve_percentages(cell, table)
        if cell.width != 'auto':
            width = cell.border_width()
            width -= border_spacing_x * (cell.colspan - 1)
            # In the general case, this width affects several columns (through
            # colspan) some of which already have a width. Subtract these
            # known widths and divide among remaining columns.
            columns_without_width = []  # and occupied by this cell
            for j in range(i, i + cell.colspan):
                if column_widths[j] is None:
                    columns_without_width.append(j)
                else:
                    width -= column_widths[j]
            if columns_without_width:
                width_per_column = width / len(columns_without_width)
                for j in columns_without_width:
                    column_widths[j] = width_per_column
        i += cell.colspan

    # Distribute the remaining space equally on columns that do not have
    # a width yet.
    all_border_spacing = border_spacing_x * (num_columns + 1)
    min_table_width = (sum(w for w in column_widths if w is not None) +
                       all_border_spacing)
    columns_without_width = [i for i, w in enumerate(column_widths)
                             if w is None]
    if columns_without_width and table.width >= min_table_width:
        remaining_width = table.width - min_table_width
        width_per_column = remaining_width / len(columns_without_width)
        for i in columns_without_width:
            column_widths[i] = width_per_column
    else:
        # This is bad, but we were given a broken table.
        for i in columns_without_width:
            column_widths[i] = 0

    # If the sum is less than the table width, distribute the remaining space
    # equally.
    extra_width = table.width - sum(column_widths) - all_border_spacing
    if extra_width <= 0:
        # Substract a negative: widen the table.
        table.width -= extra_width
    elif num_columns:
        extra_per_column = extra_width / num_columns
        column_widths = [w + extra_per_column for w in column_widths]

    # Now we have table.width == sum(column_widths) + all_border_spacing
    # with possible floating point rounding errors (unless there is zero column).
    table.column_widths = column_widths


def auto_table_layout(context, box, containing_block):
    """Run the auto table layout and return a list of column widths.

    https://www.w3.org/TR/CSS21/tables.html#auto-table-layout

    """
    table = box.get_wrapped_table()
    (table_min_content_width, table_max_content_width,
     column_min_content_widths, column_max_content_widths,
     column_intrinsic_percentages, constrainedness,
     total_horizontal_border_spacing, grid) = table_and_columns_preferred_widths(
         context, box, outer=False)

    margins = 0
    if box.margin_left != 'auto':
        margins += box.margin_left
    if box.margin_right != 'auto':
        margins += box.margin_right
    paddings = table.padding_left + table.padding_right
    borders = table.border_left_width + table.border_right_width

    cb_width, _ = containing_block
    available_width = cb_width - margins - paddings - borders

    if table.width == 'auto':
        if available_width <= table_min_content_width:
            table.width = table_min_content_width
        elif available_width < table_max_content_width:
            table.width = available_width
        else:
            table.width = table_max_content_width
    else:
        if table.width < table_min_content_width:
            table.width = table_min_content_width

    if not grid:
        table.column_widths = []
        return

    assignable_width = table.width - total_horizontal_border_spacing
    min_content_guess = column_min_content_widths[:]
    min_content_percentage_guess = column_min_content_widths[:]
    min_content_specified_guess = column_min_content_widths[:]
    max_content_guess = column_max_content_widths[:]
    guesses = (
        min_content_guess, min_content_percentage_guess,
        min_content_specified_guess, max_content_guess)
    # See https://www.w3.org/TR/css-tables-3/#width-distribution-algorithm.
    for i in range(len(grid)):
        if column_intrinsic_percentages[i]:
            min_content_percentage_guess[i] = max(
                column_intrinsic_percentages[i] / 100 * assignable_width,
                column_min_content_widths[i])
            min_content_specified_guess[i] = min_content_percentage_guess[i]
            max_content_guess[i] = min_content_percentage_guess[i]
        elif constrainedness[i]:
            # Any other column that is constrained is assigned its max-content
            # width.
            min_content_specified_guess[i] = column_max_content_widths[i]

    if assignable_width < sum(max_content_guess):
        # Default values shouldn't be used, but we never know.
        # See issue #770.
        lower_guess = guesses[0]
        upper_guess = guesses[-1]

        # We have to work around floating point rounding errors here.
        # The 1e-9 value comes from PEP 485.
        for guess in guesses:
            if sum(guess) <= assignable_width * (1 + 1e-9):
                lower_guess = guess
            else:
                break
        for guess in guesses[::-1]:
            if sum(guess) >= assignable_width * (1 - 1e-9):
                upper_guess = guess
            else:
                break
        if upper_guess == lower_guess:
            table.column_widths = upper_guess
        else:
            added_widths = [
                upper_guess[i] - lower_guess[i] for i in range(len(grid))]
            available_ratio = (assignable_width - sum(lower_guess)) / sum(added_widths)
            table.column_widths = [
                lower_guess[i] + added_widths[i] * available_ratio
                for i in range(len(grid))]
    else:
        table.column_widths = max_content_guess
        excess_width = assignable_width - sum(max_content_guess)
        distribute_excess_width(
            context, grid, excess_width, table.column_widths, constrainedness,
            column_intrinsic_percentages, column_max_content_widths)


def table_wrapper_width(context, wrapper, containing_block):
    """Find the width of each column and derive the wrapper width."""
    table = wrapper.get_wrapped_table()
    resolve_percentages(table, containing_block)

    if table.style['table_layout'] == 'fixed' and table.width != 'auto':
        fixed_table_layout(wrapper)
    else:
        auto_table_layout(context, wrapper, containing_block)

    wrapper.width = table.border_width()


def cell_baseline(cell):
    """Return the y position of a cell baseline from the top of its border box.

    See https://www.w3.org/TR/CSS21/tables.html#height-layout

    """
    baseline_types = (boxes.LineBox, boxes.TableRowBox)
    result = find_in_flow_baseline(cell, baseline_types=baseline_types)
    if result is not None:
        return result - cell.position_y
    else:
        # Default to the bottom of the content area.
        return cell.border_top_width + cell.padding_top + cell.height


def find_in_flow_baseline(box, last=False, baseline_types=(boxes.LineBox,)):
    """Return the absolute y position for the first (or last) in-flow baseline.

    If there’s no in-flow baseline, return None.

    """
    # TODO: synthetize baseline when needed.
    # See https://www.w3.org/TR/css-align-3/#synthesize-baseline.
    if isinstance(box, baseline_types):
        return box.position_y + box.baseline
    elif isinstance(box, boxes.TableCaptionBox):
        return
    children = reversed(box.children) if last else box.children
    for child in children:
        if child.is_in_normal_flow():
            result = find_in_flow_baseline(child, last, baseline_types)
            if result is not None:
                return result


def distribute_excess_width(context, grid, excess_width, column_widths, constrainedness,
                            column_intrinsic_percentages, column_max_content_widths,
                            column_slice=slice(0, None)):
    """Distribute available width to columns.

    See https://www.w3.org/TR/css-tables-3/#distributing-width-to-columns

    """
    # First group.
    columns = [
        i for i, _ in enumerate(grid[column_slice], start=column_slice.start)
        if not constrainedness[i] and
        column_intrinsic_percentages[i] == 0 and
        column_max_content_widths[i] > 0]
    if columns:
        sum_max_content_widths = sum(column_max_content_widths[i] for i in columns)
        ratio = excess_width / sum_max_content_widths
        for i in columns:
            column_widths[i] += column_max_content_widths[i] * ratio
        return

    # Second group.
    columns = [
        i for i, _ in enumerate(grid[column_slice], start=column_slice.start)
        if not constrainedness[i] and column_intrinsic_percentages[i] == 0]
    if columns:
        for i in columns:
            column_widths[i] += excess_width / len(columns)
        return

    # Third group.
    columns = [
        i for i, _ in enumerate(grid[column_slice], start=column_slice.start)
        if constrainedness[i] and
        column_intrinsic_percentages[i] == 0 and
        column_max_content_widths[i] > 0]
    if columns:
        sum_max_content_widths = sum(column_max_content_widths[i] for i in columns)
        ratio = excess_width / sum_max_content_widths
        for i in columns:
            column_widths[i] += column_max_content_widths[i] * ratio
        return

    # Fourth group.
    columns = [
        i for i, _ in enumerate(grid[column_slice], start=column_slice.start)
        if column_intrinsic_percentages[i] > 0 and column_max_content_widths[i] > 0]
    if columns:
        sum_intrinsic_percentages = sum(
            column_intrinsic_percentages[i] for i in columns)
        ratio = excess_width / sum_intrinsic_percentages
        for i in columns:
            column_widths[i] += column_intrinsic_percentages[i] * ratio
        return

    # Fifth group.
    columns = [
        i for i, column in enumerate(grid[column_slice], start=column_slice.start)
        if column]
    if columns:
        for i in columns:
            column_widths[i] += excess_width / len(columns)
        return

    # Sixth group.
    columns = [i for i, _ in enumerate(grid[column_slice], start=column_slice.start)]
    for i in columns:
        column_widths[i] += excess_width / len(columns)


TRANSPARENT = tinycss2.color5.parse_color('transparent')


def collapse_table_borders(table, grid_width, grid_height):
    """Resolve border conflicts for a table in the collapsing border model.

    Take a :class:`TableBox`; set appropriate border widths on the table,
    column group, column, row group, row, and cell boxes; and return
    a data structure for the resolved collapsed border grid.

    """
    if not (grid_width and grid_height):
        # Don’t bother with empty tables.
        return [], []

    styles = reversed([
        'hidden', 'double', 'solid', 'dashed', 'dotted', 'ridge', 'outset',
        'groove', 'inset', 'none'])
    style_scores = {style: score for score, style in enumerate(styles)}
    style_map = {'inset': 'ridge', 'outset': 'groove'}
    weak_null_border = ((0, 0, style_scores['none']), ('none', 0, TRANSPARENT))

    # Borders are always stored left to right, top to bottom.
    vertical_borders = [
        [weak_null_border] * (grid_width + 1) for _ in range(grid_height)]
    horizontal_borders = [
        [weak_null_border] * grid_width for _ in range(grid_height + 1)]

    def set_one_border(border_grid, box_style, side, grid_x, grid_y):
        from ..draw.color import get_color

        style = box_style[f'border_{side}_style']
        width = box_style[f'border_{side}_width']
        color = get_color(box_style, f'border_{side}_color')

        # See https://www.w3.org/TR/CSS21/tables.html#border-conflict-resolution.
        score = ((1 if style == 'hidden' else 0), width, style_scores[style])

        style = style_map.get(style, style)
        previous_score, _ = border_grid[grid_y][grid_x]
        # Strict < so that the earlier call wins in case of a tie.
        if previous_score < score:
            border_grid[grid_y][grid_x] = (score, (style, width, color))

    def set_borders(box, x, y, w, h):
        style = box.style

        # x and y are logical (possibly rtl), but borders are graphical (always ltr).
        if table.style['direction'] == 'ltr':
            for yy in range(y, y + h):
                set_one_border(vertical_borders, style, 'left', x, yy)
                set_one_border(vertical_borders, style, 'right', x + w, yy)
            for xx in range(x, x + w):
                set_one_border(horizontal_borders, style, 'top', xx, y)
                set_one_border(horizontal_borders, style, 'bottom', xx, y + h)
        else:
            for yy in range(y, y + h):
                set_one_border(vertical_borders, style, 'left', -1 - w - x, yy)
                set_one_border(vertical_borders, style, 'right', -1 - x, yy)
            for xx in range(-1 - x, -1 - x - w, -1):
                set_one_border(horizontal_borders, style, 'top', xx, y)
                set_one_border(horizontal_borders, style, 'bottom', xx, y + h)

    # Set cell borders. The order is important here:
    # "A style set on a cell wins over one on a row, which wins over a
    #  row group, column, column group and, lastly, table"
    # See https://www.w3.org/TR/CSS21/tables.html#border-conflict-resolution.
    strong_null_border = ((1, 0, style_scores['hidden']), ('hidden', 0, TRANSPARENT))
    grid_y = 0
    for row_group in table.children:
        for row in row_group.children:
            for cell in row.children:
                # Force null border inside of a cell with rowspan or colspan.
                grid_x, colspan, rowspan = cell.grid_x, cell.colspan, cell.rowspan
                if table.style['direction'] == 'ltr':
                    vertical_x_range = range(grid_x + 1, grid_x + colspan)
                    horizontal_x_range = range(grid_x, grid_x + colspan)
                else:
                    vertical_x_range = range(-2 - grid_x, -1 - grid_x - colspan, -1)
                    horizontal_x_range = range(-1 - grid_x, -1 - grid_x - colspan, -1)
                for xx in vertical_x_range:
                    for yy in range(grid_y, grid_y + rowspan):
                        vertical_borders[yy][xx] = strong_null_border
                for xx in horizontal_x_range:
                    for yy in range(grid_y + 1, grid_y + rowspan):
                        horizontal_borders[yy][xx] = strong_null_border
                # Set cell border.
                set_borders(cell, grid_x, grid_y, colspan, rowspan)
            grid_y += 1

    # Set row borders.
    grid_y = 0
    for row_group in table.children:
        for row in row_group.children:
            set_borders(row, 0, grid_y, grid_width, 1)
            grid_y += 1

    # Set row group borders.
    grid_y = 0
    for row_group in table.children:
        rowspan = len(row_group.children)
        set_borders(row_group, 0, grid_y, grid_width, rowspan)
        grid_y += rowspan

    # Set column borders.
    for column_group in table.column_groups:
        for column in column_group.children:
            set_borders(column, column.grid_x, 0, 1, grid_height)

    # Set column group group borders.
    for column_group in table.column_groups:
        set_borders(
            column_group, column_group.grid_x, 0, column_group.span, grid_height)

    # Set table borders.
    set_borders(table, 0, 0, grid_width, grid_height)

    # Now that all conflicts are resolved, set transparent borders of the
    # correct widths on each box. The actual border grid will be painted
    # separately.
    def set_border_used_width(box, side, twice_width):
        prop = f'border_{side}_width'
        setattr(box, prop, twice_width / 2)

    def remove_borders(box):
        set_border_used_width(box, 'top', 0)
        set_border_used_width(box, 'right', 0)
        set_border_used_width(box, 'bottom', 0)
        set_border_used_width(box, 'left', 0)

    def max_vertical_width(x, y1, y2):
        return max(grid_row[x][1][1] for grid_row in vertical_borders[y1:y2])

    def max_horizontal_width(x1, y, x2):
        return max(width for _, (_, width, _) in horizontal_borders[y][x1:x2])

    grid_y = 0
    for row_group in table.children:
        remove_borders(row_group)
        for row in row_group.children:
            remove_borders(row)
            for cell in row.children:
                x, y = cell.grid_x, grid_y
                colspan, rowspan = cell.colspan, cell.rowspan
                if table.style['direction'] == 'ltr':
                    top = max_horizontal_width(x, y, x + colspan)
                    bottom = max_horizontal_width(x, y + rowspan, x + colspan)
                    left = max_vertical_width(x, y, y + rowspan)
                    right = max_vertical_width(x + colspan, y, y + rowspan)
                else:
                    top = max_horizontal_width(-colspan - x, y, -x or None)
                    bottom = max_horizontal_width(-colspan - x, y + rowspan, -x or None)
                    left = max_vertical_width(-1 - colspan - x, y, y + rowspan)
                    right = max_vertical_width(-1 - x, y, y + rowspan)
                set_border_used_width(cell, 'top', top)
                set_border_used_width(cell, 'bottom', bottom)
                set_border_used_width(cell, 'left', left)
                set_border_used_width(cell, 'right', right)
            grid_y += 1

    for column_group in table.column_groups:
        remove_borders(column_group)
        for column in column_group.children:
            remove_borders(column)

    set_border_used_width(table, 'top', max_horizontal_width(0, 0, grid_width))
    set_border_used_width(
        table, 'bottom', max_horizontal_width(0, grid_height, grid_width))
    # "UAs must compute an initial left and right border width for the table
    #  by examining the first and last cells in the first row of the table."
    # https://www.w3.org/TR/CSS21/tables.html#collapsing-borders
    # ... so h=1, not grid_height:
    set_border_used_width(table, 'left', max_vertical_width(0, 0, 1))
    set_border_used_width(table, 'right', max_vertical_width(grid_width, 0, 1))

    return vertical_borders, horizontal_borders


================================================
FILE: weasyprint/logger.py
================================================
"""Logging setup.

The rest of the code gets the logger through this module rather than
``logging.getLogger`` to make sure that it is configured.

Logging levels are used for specific purposes:

- errors are used in ``LOGGER`` for unreachable or unusable external resources,
  including unreachable stylesheets, unreachables images and unreadable images;
- warnings are used in ``LOGGER`` for unknown or bad HTML/CSS syntaxes,
  unreachable local fonts and various non-fatal problems;
- infos are used in ``PROCESS_LOGGER`` to advertise rendering steps.

"""

import contextlib
import logging

LOGGER = logging.getLogger('weasyprint')
if not LOGGER.handlers:  # pragma: no cover
    LOGGER.setLevel(logging.WARNING)
    LOGGER.addHandler(logging.NullHandler())

PROGRESS_LOGGER = logging.getLogger('weasyprint.progress')


class CallbackHandler(logging.Handler):
    """A logging handler that calls a function for every message."""
    def __init__(self, callback):
        logging.Handler.__init__(self)
        self.emit = callback


@contextlib.contextmanager
def capture_logs(logger='weasyprint', level=None):
    """Return a context manager that captures all logged messages."""
    if level is None:
        level = logging.INFO
    logger = logging.getLogger(logger)
    messages = []

    def emit(record):
        if record.name == 'weasyprint.progress':
            return
        if record.levelno < level:
            return
        messages.append(f'{record.levelname.upper()}: {record.getMessage()}')

    previous_handlers = logger.handlers
    previous_level = logger.level
    logger.handlers = []
    logger.addHandler(CallbackHandler(emit))
    logger.setLevel(logging.DEBUG)
    try:
        yield messages
    finally:
        logger.handlers = previous_handlers
        logger.setLevel(previous_level)


================================================
FILE: weasyprint/matrix.py
================================================
"""Transformation matrix."""


class Matrix(list):
    def __init__(self, a=1, b=0, c=0, d=1, e=0, f=0, matrix=None):
        if matrix is None:
            matrix = [[a, b, 0], [c, d, 0], [e, f, 1]]
        super().__init__(matrix)

    def __matmul__(self, other):
        assert len(self[0]) == len(other) == len(other[0]) == 3
        return Matrix(matrix=[
            [sum(self[i][k] * other[k][j] for k in range(3)) for j in range(3)]
            for i in range(len(self))])

    @property
    def invert(self):
        d = self.determinant
        return Matrix(matrix=[
            [
                (self[1][1] * self[2][2] - self[1][2] * self[2][1]) / d,
                (self[0][1] * self[2][2] - self[0][2] * self[2][1]) / -d,
                (self[0][1] * self[1][2] - self[0][2] * self[1][1]) / d,
            ],
            [
                (self[1][0] * self[2][2] - self[1][2] * self[2][0]) / -d,
                (self[0][0] * self[2][2] - self[0][2] * self[2][0]) / d,
                (self[0][0] * self[1][2] - self[0][2] * self[1][0]) / -d,
            ],
            [
                (self[1][0] * self[2][1] - self[1][1] * self[2][0]) / d,
                (self[0][0] * self[2][1] - self[0][1] * self[2][0]) / -d,
                (self[0][0] * self[1][1] - self[0][1] * self[1][0]) / d,
            ],
        ])

    @property
    def determinant(self):
        assert len(self) == len(self[0]) == 3
        return (
            self[0][0] * (self[1][1] * self[2][2] - self[1][2] * self[2][1]) -
            self[1][0] * (self[0][1] * self[2][2] - self[0][2] * self[2][1]) +
            self[2][0] * (self[0][1] * self[1][2] - self[0][2] * self[1][1]))

    def transform_point(self, x, y):
        return (Matrix(matrix=[[x, y, 1]]) @ self)[0][:2]

    @property
    def values(self):
        (a, b), (c, d), (e, f) = [column[:2] for column in self]
        return a, b, c, d, e, f


================================================
FILE: weasyprint/pdf/__init__.py
================================================
"""PDF generation management."""

from importlib.resources import files

import pydyf
from tinycss2.color5 import D50, D65

from .. import VERSION, Attachment
from ..html import W3C_DATE_RE
from ..logger import LOGGER, PROGRESS_LOGGER
from ..matrix import Matrix
from ..urls import select_source
from . import debug, pdfa, pdfua, pdfx
from .fonts import build_fonts_dictionary
from .stream import Stream
from .tags import add_tags

from .anchors import (  # isort:skip
    add_annotations, add_forms, add_links, add_outlines, resolve_links,
    write_pdf_attachment)

VARIANTS = {
    name: data
    for variants in (pdfa.VARIANTS, pdfua.VARIANTS, pdfx.VARIANTS, debug.VARIANTS)
    for (name, data) in variants.items()}


def _w3c_date_to_pdf(string, attr_name):
    """Tranform W3C date to PDF format."""
    if string is None:
        return None
    match = W3C_DATE_RE.match(string)
    if match is None:
        LOGGER.warning(f'Invalid {attr_name} date: {string!r}')
        return None
    groups = match.groupdict()
    pdf_date = ''
    found = groups['hour']
    for key in ('second', 'minute', 'hour', 'day', 'month', 'year'):
        if groups[key]:
            found = True
            pdf_date = groups[key] + pdf_date
        elif found:
            pdf_date = f'{(key in ("day", "month")):02d}{pdf_date}'
    if groups['hour']:
        assert groups['minute']
        if groups['tz_hour']:
            assert groups['tz_hour'].startswith(('+', '-'))
            assert groups['tz_minute']
            tz_hour = int(groups['tz_hour'])
            tz_minute = int(groups['tz_minute'])
            pdf_date += f"{tz_hour:+03d}'{tz_minute:02d}"
        else:
            pdf_date += 'Z'
    return f'D:{pdf_date}'


def _reference_resources(pdf, resources, images, fonts, color_profiles):
    if 'Font' in resources:
        assert resources['Font'] is None
        resources['Font'] = fonts
    _use_references(pdf, resources, images, color_profiles)
    pdf.add_object(resources)
    return resources.reference


def _use_references(pdf, resources, images, color_profiles):
    # XObjects
    for key, x_object in resources.get('XObject', {}).items():
        # Images
        if x_object is None:
            image_data = images[key]
            x_object = image_data['x_object']

            if x_object is not None:
                # Image already added to PDF
                resources['XObject'][key] = x_object.reference
                continue

            image = image_data['image']
            dpi_ratio = max(image_data['dpi_ratios'])
            x_object = image.get_x_object(image_data['interpolate'], dpi_ratio)
            image_data['x_object'] = x_object

        pdf.add_object(x_object)
        resources['XObject'][key] = x_object.reference

        # Masks
        if 'SMask' in x_object.extra:
            pdf.add_object(x_object.extra['SMask'])
            x_object.extra['SMask'] = x_object.extra['SMask'].reference

        # Resources
        if 'Resources' in x_object.extra:
            x_object.extra['Resources'] = _reference_resources(
                pdf, x_object.extra['Resources'], images, resources['Font'],
                color_profiles)

    # Patterns
    for key, pattern in resources.get('Pattern', {}).items():
        pdf.add_object(pattern)
        resources['Pattern'][key] = pattern.reference
        if 'Resources' in pattern.extra:
            pattern.extra['Resources'] = _reference_resources(
                pdf, pattern.extra['Resources'], images, resources['Font'],
                color_profiles)

    # Shadings
    for key, shading in resources.get('Shading', {}).items():
        pdf.add_object(shading)
        resources['Shading'][key] = shading.reference

    # Alpha states
    for key, alpha in resources.get('ExtGState', {}).items():
        if 'SMask' in alpha and 'G' in alpha['SMask']:
            alpha['SMask']['G'] = alpha['SMask']['G'].reference


def generate_pdf(document, target, zoom, **options):
    # 0.75 = 72 PDF point per inch / 96 CSS pixel per inch
    scale = zoom * 0.75

    PROGRESS_LOGGER.info('Step 6 - Creating PDF')

    compress = not options['uncompressed_pdf']

    # Set properties according to PDF variants
    srgb = options['srgb']
    pdf_tags = options['pdf_tags']
    variant = options['pdf_variant']
    if variant:
        variant_function, properties = VARIANTS[variant]
        if 'srgb' in properties:
            srgb = properties['srgb']
        if 'pdf_tags' in properties:
            pdf_tags = properties['pdf_tags']

    pdf = pydyf.PDF()
    images = {}
    color_space = pydyf.Dictionary({
        'lab-d50': pydyf.Array(('/Lab', pydyf.Dictionary({
            'WhitePoint': pydyf.Array(D50),
            'Range': pydyf.Array((-125, 125, -125, 125)),
        }))),
        'lab-d65': pydyf.Array(('/Lab', pydyf.Dictionary({
            'WhitePoint': pydyf.Array(D65),
            'Range': pydyf.Array((-125, 125, -125, 125)),
        }))),
    })
    # Custom color profiles
    for key, color_profile in document.color_profiles.items():
        if key == 'device-cmyk':
            # Device CMYK profile is stored as OutputIntent.
            continue
        profile = pydyf.Stream(
            [color_profile.content],
            pydyf.Dictionary({'N': len(color_profile.components)}),
            compress=compress)
        pdf.add_object(profile)
        color_space[key] = pydyf.Array(('/ICCBased', profile.reference))
    pdf.add_object(color_space)
    resources = pydyf.Dictionary({
        'ExtGState': pydyf.Dictionary(),
        'XObject': pydyf.Dictionary(),
        'Pattern': pydyf.Dictionary(),
        'Shading': pydyf.Dictionary(),
        'ColorSpace': color_space.reference,
    })
    pdf.add_object(resources)
    pdf_names = []

    # Links and anchors
    page_links_and_anchors = list(resolve_links(document.pages))

    annot_files = {}
    pdf_pages, page_streams = [], []
    for page_number, (page, links_and_anchors) in enumerate(
            zip(document.pages, page_links_and_anchors)):
        tags = {} if pdf_tags else None

        # Draw from the top-left corner
        matrix = Matrix(scale, 0, 0, -scale, 0, page.height * scale)

        page_width = scale * (
            page.width + page.bleed['left'] + page.bleed['right'])
        page_height = scale * (
            page.height + page.bleed['top'] + page.bleed['bottom'])
        left = -scale * page.bleed['left']
        top = -scale * page.bleed['top']
        right = left + page_width
        bottom = top + page_height

        page_rectangle = (
            left / scale, top / scale,
            (right - left) / scale, (bottom - top) / scale)
        stream = Stream(
            document.fonts, page_rectangle, resources, images, tags,
            document.color_profiles, compress=compress)
        stream.transform(d=-1, f=(page.height * scale))
        pdf.add_object(stream)
        page_streams.append(stream)

        pdf_page = pydyf.Dictionary({
            'Type': '/Page',
            'Parent': pdf.pages.reference,
            'MediaBox': pydyf.Array([left, top, right, bottom]),
            'Contents': stream.reference,
            'Resources': resources.reference,
        })
        if pdf_tags:
            pdf_page['Tabs'] = '/S'
            pdf_page['StructParents'] = page_number
        pdf.add_page(pdf_page)
        pdf_pages.append(pdf_page)

        add_links(links_and_anchors, matrix, pdf, pdf_page, pdf_names, tags)
        add_annotations(
            links_and_anchors[0], matrix, document, pdf, pdf_page, annot_files,
            compress)
        add_forms(
            page.forms, matrix, pdf, pdf_page, resources, stream,
            document.font_config.font_map)
        page.paint(stream, scale)

        # Bleed
        bleed = {key: value * 0.75 for key, value in page.bleed.items()}

        trim_left = left + bleed['left']
        trim_top = top + bleed['top']
        trim_right = right - bleed['right']
        trim_bottom = bottom - bleed['bottom']

        # Arbitrarly set PDF BleedBox between CSS bleed box (MediaBox) and
        # CSS page box (TrimBox) at most 10 points from the TrimBox.
        bleed_left = trim_left - min(10, bleed['left'])
        bleed_top = trim_top - min(10, bleed['top'])
        bleed_right = trim_right + min(10, bleed['right'])
        bleed_bottom = trim_bottom + min(10, bleed['bottom'])

        pdf_page['TrimBox'] = pydyf.Array([
            trim_left, trim_top, trim_right, trim_bottom])
        pdf_page['BleedBox'] = pydyf.Array([
            bleed_left, bleed_top, bleed_right, bleed_bottom])

    # Outlines
    add_outlines(pdf, document.make_bookmark_tree(scale, transform_pages=True))

    PROGRESS_LOGGER.info('Step 7 - Adding PDF metadata')

    # PDF information
    pdf.info['Producer'] = pydyf.String(f'WeasyPrint {VERSION}')
    metadata = document.metadata
    if metadata.title:
        pdf.info['Title'] = pydyf.String(metadata.title)
    if metadata.authors:
        pdf.info['Author'] = pydyf.String(', '.join(metadata.authors))
    if metadata.description:
        pdf.info['Subject'] = pydyf.String(metadata.description)
    if metadata.keywords:
        pdf.info['Keywords'] = pydyf.String(', '.join(metadata.keywords))
    if metadata.generator:
        pdf.info['Creator'] = pydyf.String(metadata.generator)
    if metadata.created:
        pdf.info['CreationDate'] = pydyf.String(
            _w3c_date_to_pdf(metadata.created, 'created'))
    if metadata.modified:
        pdf.info['ModDate'] = pydyf.String(
            _w3c_date_to_pdf(metadata.modified, 'modified'))
    if metadata.lang:
        pdf.catalog['Lang'] = pydyf.String(metadata.lang)
    if options['custom_metadata']:
        for key, value in metadata.custom.items():
            key = ''.join(char for char in key if char.isalnum())
            key = key.encode('ascii', errors='ignore').decode()
            if key:
                pdf.info[key] = pydyf.String(value)
    if options['xmp_metadata']:
        for url in options['xmp_metadata']:
            result = select_source(url)
            with result as (file_obj, base_url, charset, _):
                xmp_metadata = file_obj.read()
                if charset:
                    xmp_metadata = xmp_metadata.decode(charset).encode()
                metadata.xmp_metadata.append(xmp_metadata)

    # Embedded files
    attachments = metadata.attachments.copy()
    if options['attachments']:
        relationships = iter(options['attachment_relationships'] or [])
        for attachment in options['attachments']:
            if not isinstance(attachment, Attachment):
                attachment = Attachment(
                    attachment, url_fetcher=document.url_fetcher,
                    relationship=next(relationships, 'Unspecified'))
            attachments.append(attachment)
    pdf_attachments = []
    for attachment in attachments:
        pdf_attachment = write_pdf_attachment(pdf, attachment, compress)
        if pdf_attachment is not None:
            pdf_attachments.append(pdf_attachment)
    if pdf_attachments:
        content = pydyf.Dictionary({'Names': pydyf.Array()})
        for i, pdf_attachment in enumerate(pdf_attachments):
            content['Names'].append(pdf_attachment['F'])
            content['Names'].append(pdf_attachment.reference)
        pdf.add_object(content)
        if 'Names' not in pdf.catalog:
            pdf.catalog['Names'] = pydyf.Dictionary()
        pdf.catalog['Names']['EmbeddedFiles'] = content.reference

    # Embedded fonts
    subset = not options['full_fonts']
    pdf_fonts = build_fonts_dictionary(
        pdf, document.fonts, compress, subset, options)
    pdf.add_object(pdf_fonts)
    if 'AcroForm' in pdf.catalog:
        # Include Dingbats for forms
        dingbats = pydyf.Dictionary({
            'Type': '/Font',
            'Subtype': '/Type1',
            'BaseFont': '/ZapfDingbats',
        })
        pdf.add_object(dingbats)
        pdf_fonts['ZaDb'] = dingbats.reference
    resources['Font'] = pdf_fonts.reference
    _use_references(pdf, resources, images, document.color_profiles)

    # Anchors
    if pdf_names:
        # Anchors are name trees that have to be sorted
        name_array = pydyf.Array()
        for anchor in sorted(pdf_names):
            name_array.append(pydyf.String(anchor[0]))
            name_array.append(anchor[1])
        dests = pydyf.Dictionary({'Names': name_array})
        if 'Names' not in pdf.catalog:
            pdf.catalog['Names'] = pydyf.Dictionary()
        pdf.catalog['Names']['Dests'] = dests

    # Add output ICC profile.
    # TODO: we should allow the user or the PDF variant code to set custom values in
    # OutputIntents and remove the "srgb" option. See PDF 2.0 chapter 14.11.5, and
    # https://www.color.org/chardata/drsection1.xalter for a list of "standard
    # production conditions".
    if 'device-cmyk' in document.color_profiles:
        color_profile = document.color_profiles['device-cmyk']
        profile = pydyf.Stream(
            [color_profile.content], pydyf.Dictionary({'N': 4}), compress=compress)
        pdf.add_object(profile)
        pdf.catalog['OutputIntents'] = pydyf.Array([
            pydyf.Dictionary({
                'Type': '/OutputIntent',
                'S': '/GTS_PDFX',
                'OutputConditionIdentifier': pydyf.String(color_profile.name),
                'DestOutputProfile': profile.reference,
            }),
        ])
    elif srgb:
        profile = pydyf.Stream(
            [(files(__package__) / 'sRGB2014.icc').read_bytes()],
            pydyf.Dictionary({'N': 3, 'Alternate': '/DeviceRGB'}),
            compress=compress)
        pdf.add_object(profile)
        pdf.catalog['OutputIntents'] = pydyf.Array([
            pydyf.Dictionary({
                'Type': '/OutputIntent',
                'S': '/GTS_PDFA1',
                'OutputConditionIdentifier': pydyf.String('sRGB IEC61966-2.1'),
                'DestOutputProfile': profile.reference,
            }),
        ])

    # Add tags
    if pdf_tags:
        add_tags(pdf, document, page_streams)

    # Apply PDF variants functions
    if variant:
        variant_function(
            pdf, metadata, document, page_streams, attachments, compress)

    return pdf


================================================
FILE: weasyprint/pdf/anchors.py
================================================
"""Insert anchors, links, bookmarks and inputs in PDFs."""

import collections
import mimetypes
from hashlib import md5
from os.path import basename
from urllib.parse import unquote, urlsplit

import pydyf

from .. import Attachment
from ..logger import LOGGER
from ..text.ffi import ffi, gobject, pango
from ..text.fonts import get_font_description
from ..urls import URLFetchingError

# Get mimetypes from Python code, not from various files. See #2707.
MIMETYPES = mimetypes.MimeTypes()


def add_links(links_and_anchors, matrix, pdf, page, names, tags):
    """Include hyperlinks in given PDF page."""
    links, anchors = links_and_anchors

    for link_type, link_target, rectangle, box in links:
        x1, y1 = matrix.transform_point(*rectangle[:2])
        x2, y2 = matrix.transform_point(*rectangle[2:])
        if link_type in ('internal', 'external'):
            box.link_annotation = pydyf.Dictionary({
                'Type': '/Annot',
                'Subtype': '/Link',
                'Rect': pydyf.Array([x1, y1, x2, y2]),
                'BS': pydyf.Dictionary({'W': 0}),
            })
            if tags is not None:
                box.link_annotation['Contents'] = pydyf.String(link_target)
            if link_type == 'internal':
                box.link_annotation['Dest'] = pydyf.String(link_target)
            else:
                box.link_annotation['A'] = pydyf.Dictionary({
                    'Type': '/Action',
                    'S': '/URI',
                    'URI': pydyf.String(link_target),
                })
            pdf.add_object(box.link_annotation)
            if 'Annots' not in page:
                page['Annots'] = pydyf.Array()
            page['Annots'].append(box.link_annotation.reference)

    for anchor in anchors:
        anchor_name, x, y = anchor
        x, y = matrix.transform_point(x, y)
        names.append([
            anchor_name, pydyf.Array([page.reference, '/XYZ', x, y, 0])])


def add_outlines(pdf, bookmarks, parent=None):
    """Include bookmark outlines in PDF."""
    count = len(bookmarks)
    outlines = []
    for title, (page, x, y), children, state in bookmarks:
        destination = pydyf.Array((pdf.page_references[page], '/XYZ', x, y, 0))
        outline = pydyf.Dictionary({
            'Title': pydyf.String(title), 'Dest': destination})
        pdf.add_object(outline)
        children_outlines, children_count = add_outlines(
            pdf, children, parent=outline)
        outline['Count'] = children_count
        if state == 'closed':
            outline['Count'] *= -1
        else:
            count += children_count
        if outlines:
            outline['Prev'] = outlines[-1].reference
            outlines[-1]['Next'] = outline.reference
        if children_outlines:
            outline['First'] = children_outlines[0].reference
            outline['Last'] = children_outlines[-1].reference
        if parent is not None:
            outline['Parent'] = parent.reference
        outlines.append(outline)

    if parent is None and outlines:
        outlines_dictionary = pydyf.Dictionary({
            'Count': count,
            'First': outlines[0].reference,
            'Last': outlines[-1].reference,
        })
        pdf.add_object(outlines_dictionary)
        for outline in outlines:
            outline['Parent'] = outlines_dictionary.reference
        pdf.catalog['Outlines'] = outlines_dictionary.reference

    return outlines, count


def add_forms(forms, matrix, pdf, page, resources, stream, font_map):
    """Include form inputs in PDF."""
    if not forms or not any(forms.values()):
        return

    if 'Annots' not in page:
        page['Annots'] = pydyf.Array()
    if 'AcroForm' not in pdf.catalog:
        pdf.catalog['AcroForm'] = pydyf.Dictionary({
            'Fields': pydyf.Array(),
            'DR': resources.reference,
            'NeedAppearances': 'true',
        })
    page_reference = page['Contents'].split()[0]
    context = ffi.gc(
        pango.pango_font_map_create_context(font_map),
        gobject.g_object_unref)
    inputs_with_forms = [
        (form, element, style, rectangle)
        for form, inputs in forms.items()
        for element, style, rectangle in inputs
    ]
    radio_groups = collections.defaultdict(dict)
    forms = collections.defaultdict(dict)
    for i, (form, element, style, rectangle) in enumerate(inputs_with_forms):
        rectangle = (
            *matrix.transform_point(*rectangle[:2]),
            *matrix.transform_point(*rectangle[2:]))

        input_type = element.attrib.get('type')
        input_value = element.attrib.get('value', 'Yes')
        default_name = f'unknown-{page_reference.decode()}-{i}'
        input_name = element.attrib.get('name', default_name)
        # TODO: where does this 0.75 scale come from?
        font_size = style['font_size'] * 0.75
        field_stream = stream.clone()
        field_stream.set_color(style['color'])
        field = pydyf.Dictionary({
            'Type': '/Annot',
            'Subtype': '/Widget',
            'Rect': pydyf.Array(rectangle),
            'P': page.reference,
            'F': 1 << (3 - 1),  # Print flag
            'T': pydyf.String(input_name),
        })
        if input_type in ('radio', 'checkbox'):
            if input_type == 'radio':
                if input_name not in radio_groups[form]:
                    radio_groups[form][input_name] = group = pydyf.Dictionary({
                        'FT': '/Btn',
                        'Ff': (1 << (15 - 1)) + (1 << (16 - 1)),  # NoToggle & Radio
                        'T': pydyf.String(input_name),
                        'V': '/Off',
                        'Kids': pydyf.Array(),
                        'Opt': pydyf.Array(),
                    })
                    pdf.add_object(group)
                    pdf.catalog['AcroForm']['Fields'].append(group.reference)
                group = radio_groups[form][input_name]
                font_size = style['font_size'] * 0.5
                character = 'l'  # Disc character in Dingbats
            else:
                character = '4'  # Check character in Dingbats

            # Create stream when input is checked.
            width = rectangle[2] - rectangle[0]
            height = rectangle[1] - rectangle[3]
            checked_stream = stream.clone(extra={
                'Resources': resources.reference,
                'Type': '/XObject',
                'Subtype': '/Form',
                'BBox': pydyf.Array((0, 0, width, height)),
            })
            checked_stream.push_state()
            checked_stream.begin_text()
            checked_stream.set_color(style['color'])
            checked_stream.set_font_size('ZaDb', font_size)
            # Center (assuming that Dingbat’s characters have a 0.75em size).
            x = (width - font_size * 0.75) / 2
            y = (height - font_size * 0.75) / 2
            checked_stream.move_text_to(x, y)
            checked_stream.show_text_string(character)
            checked_stream.end_text()
            checked_stream.pop_state()
            pdf.add_object(checked_stream)

            field_stream.set_font_size('ZaDb', font_size)

            checked = 'checked' in element.attrib
            key = len(group['Kids']) if input_type == 'radio' else 'on'
            appearance = pydyf.Dictionary({key: checked_stream.reference})
            field['FT'] = '/Btn'
            field['DA'] = pydyf.String(b' '.join(field_stream.stream))
            field['AS'] = f'/{key}' if checked else '/Off'
            field['AP'] = pydyf.Dictionary({'N': appearance})
            field['MK'] = pydyf.Dictionary({'CA': pydyf.String(character)})
            pdf.add_object(field)
            if input_type == 'radio':
                field['Parent'] = group.reference
                if checked:
                    group['V'] = f'/{key}'
                group['Kids'].append(field.reference)
                group['Opt'].append(pydyf.String(input_value))
            else:
                field['T'] = pydyf.String(input_name)
                field['V'] = field['AS']

        elif element.tag == 'select':
            font_description = get_font_description(style)
            font = pango.pango_font_map_load_font(
                font_map, context, font_description)
            font, _ = stream.add_font(font)
            font.used_in_forms = True

            field_stream.set_font_size(font.hash, font_size)
            options = []
            selected_values = []
            for option in element:
                value = pydyf.String(option.attrib.get('value', ''))
                text = pydyf.String(option.text or '')
                options.append(pydyf.Array([value, text]))
                if 'selected' in option.attrib:
                    selected_values.append(value)

            field['FT'] = '/Ch'
            field['DA'] = pydyf.String(b' '.join(field_stream.stream))
            field['Opt'] = pydyf.Array(options)
            if 'multiple' in element.attrib:
                field['Ff'] = 1 << (22 - 1)
                field['V'] = pydyf.Array(selected_values)
            else:
                field['Ff'] = 1 << (18 - 1)
                field['V'] = (
                    selected_values[-1] if selected_values
                    else pydyf.String(''))
            pdf.add_object(field)

        elif input_type == 'submit' or element.tag == 'button':
            flags = 1 << (3 - 1)  # HTML form format
            if form.attrib.get('method', '').lower() != 'post':
                flags += 1 << (4 - 1)  # GET method
            fields = pydyf.Array(field.reference for field in forms[form].values())
            field['FT'] = '/Btn'
            field['DA'] = pydyf.String(b' '.join(field_stream.stream))
            field['V'] = pydyf.String(form.attrib.get('value', ''))
            field['Ff'] = 1 << (17 - 1)  # Push-button
            field['A'] = pydyf.Dictionary({
                'Type': '/Action',
                'S': '/SubmitForm',
                'F': pydyf.String(form.attrib.get('action')),
                'Fields': fields,
                'Flags': flags,
            })
            pdf.add_object(field)

        else:
            # Text, password, textarea, files, and other unknown fields.
            font_description = get_font_description(style)
            font = pango.pango_font_map_load_font(
                font_map, context, font_description)
            font, _ = stream.add_font(font)
            font.used_in_forms = True

            field_stream.set_font_size(font.hash, font_size)
            field['FT'] = '/Tx'
            field['DA'] = pydyf.String(b' '.join(field_stream.stream))
            field['V'] = pydyf.String(element.attrib.get('value', ''))
            if element.tag == 'textarea':
                field['Ff'] = 1 << (13 - 1)
                field['V'] = pydyf.String(element.text or '')
            elif input_type == 'password':
                field['Ff'] = 1 << (14 - 1)
            elif input_type == 'file':
                field['Ff'] = 1 << (21 - 1)
            if (max_length := element.get('maxlength', '')).isdigit():
                field['MaxLen'] = max_length
            pdf.add_object(field)

        page['Annots'].append(field.reference)
        pdf.catalog['AcroForm']['Fields'].append(field.reference)
        if input_name not in forms:
            forms[form][input_name] = field


def add_annotations(links, matrix, document, pdf, page, annot_files, compress):
    """Include annotations in PDF."""
    # TODO: splitting a link into multiple independent rectangular
    # annotations works well for pure links, but rather mediocre for
    # other annotations and fails completely for transformed (CSS) or
    # complex link shapes (area). It would be better to use /AP for all
    # links and coalesce link shapes that originate from the same HTML
    # link. This would give a feeling similiar to what browsers do with
    # links that span multiple lines.
    for link_type, annot_target, rectangle, _ in links:
        if link_type != 'attachment':
            continue
        if annot_target not in annot_files:
            # A single link can be split in multiple regions. We don't want
            # to embed a file multiple times of course, so keep a reference
            # to every embedded URL and reuse the object number.
            # TODO: Use the title attribute as description. The comment
            # above about multiple regions won't always be correct, because
            # two links might have the same href, but different titles.
            attachment = Attachment(
                url=annot_target, url_fetcher=document.url_fetcher)
            annot_files[annot_target] = write_pdf_attachment(
                pdf, attachment, compress)
        annot_file = annot_files[annot_target]
        if annot_file is None:
            continue
        rectangle = (
            *matrix.transform_point(*rectangle[:2]),
            *matrix.transform_point(*rectangle[2:]))
        stream = pydyf.Stream([], {
            'Type': '/XObject',
            'Subtype': '/Form',
            'BBox': pydyf.Array(rectangle),
        }, compress)
        pdf.add_object(stream)
        annot = pydyf.Dictionary({
            'Type': '/Annot',
            'Rect': pydyf.Array(rectangle),
            'Subtype': '/FileAttachment',
            'T': pydyf.String(),
            'FS': annot_file.reference,
            'AP': pydyf.Dictionary({'N': stream.reference}),
            'AS': '/N',
        })
        pdf.add_object(annot)
        if 'Annots' not in page:
            page['Annots'] = pydyf.Array()
        page['Annots'].append(annot.reference)


def write_pdf_attachment(pdf, attachment, compress):
    """Write an attachment to the PDF stream."""
    # Attachments from document links like <link> or <a> can only be URLs.
    # They're passed in as tuples
    url = mime_type = None
    try:
        with attachment.source as (file_obj, url, _, mime_type):
            stream = file_obj.read()
            if isinstance(stream, str):
                stream = stream.encode()
    except URLFetchingError as exception:
        LOGGER.error('Failed to load attachment: %s', exception)
        LOGGER.debug('Error while loading attachment:', exc_info=exception)
        return
    attachment.md5 = md5(stream, usedforsecurity=False).hexdigest()

    # TODO: Use the result object from a URL fetch operation to provide more
    # details on the possible filename and MIME type.
    if attachment.name:
        filename = attachment.name
    elif url and urlsplit(url).path:
        filename = basename(unquote(urlsplit(url).path))
    else:
        filename = 'attachment.bin'
    mime_type = (
        mime_type or
        MIMETYPES.guess_type(filename, strict=False)[0] or
        'application/octet-stream')

    creation = pydyf.String(attachment.created.strftime('D:%Y%m%d%H%M%SZ'))
    mod = pydyf.String(attachment.modified.strftime('D:%Y%m%d%H%M%SZ'))
    file_extra = pydyf.Dictionary({
        'Type': '/EmbeddedFile',
        'Subtype': f'/{mime_type.replace("/", "#2f")}',
        'Params': pydyf.Dictionary({
            'CheckSum': f'<{attachment.md5}>',
            'Size': len(stream),
            'CreationDate': creation,
            'ModDate': mod,
        })
    })
    file_stream = pydyf.Stream([stream], file_extra, compress=compress)
    pdf.add_object(file_stream)

    pdf_attachment = pydyf.Dictionary({
        'Type': '/Filespec',
        'F': pydyf.String(filename.encode(errors='ignore')),
        'UF': pydyf.String(filename),
        'EF': pydyf.Dictionary({'F': file_stream.reference}),
        'Desc': pydyf.String(attachment.description or ''),
    })
    pdf.add_object(pdf_attachment)
    return pdf_attachment


def resolve_links(pages):
    """Resolve internal hyperlinks.

    Links to a missing anchor are removed with a warning.

    If multiple anchors have the same name, the first one is used.

    :returns:
        A generator yielding lists (one per page) like :attr:`Page.links`,
        except that ``target`` for internal hyperlinks is
        ``(page_number, x, y)`` instead of an anchor name.
        The page number is a 0-based index into the :attr:`pages` list,
        and ``x, y`` are in CSS pixels from the top-left of the page.

    """
    anchors = set()
    paged_anchors = []
    for i, page in enumerate(pages):
        paged_anchors.append([])
        for anchor_name, (point_x, point_y, _, _) in page.anchors.items():
            if anchor_name not in anchors:
                paged_anchors[-1].append((anchor_name, point_x, point_y))
                anchors.add(anchor_name)
    for page in pages:
        page_links = []
        for link in page.links:
            link_type, anchor_name, _, _ = link
            if link_type == 'internal':
                if anchor_name not in anchors:
                    LOGGER.error(
                        'No anchor #%s for internal URI reference',
                        anchor_name)
                else:
                    page_links.append(link)
            else:
                # External link
                page_links.append(link)
        yield page_links, paged_anchors.pop(0)


================================================
FILE: weasyprint/pdf/debug.py
================================================
"""PDF generation with debug information."""

import pydyf

from ..matrix import Matrix


def debug(pdf, metadata, document, page_streams, attachments, compress):
    """Set debug PDF metadata."""

    # Add links on ids.
    pages = zip(pdf.pages['Kids'][::3], document.pages, page_streams)
    for pdf_page_number, document_page, stream in pages:
        if not document_page.anchors:
            continue

        page = pdf.objects[pdf_page_number]
        if 'Annots' not in page:
            page['Annots'] = pydyf.Array()

        for id, (x1, y1, x2, y2) in document_page.anchors.items():
            # TODO: handle zoom correctly.
            matrix = Matrix(0.75, 0, 0, 0.75) @ stream.ctm
            x1, y1 = matrix.transform_point(x1, y1)
            x2, y2 = matrix.transform_point(x2, y2)
            annotation = pydyf.Dictionary({
                'Type': '/Annot',
                'Subtype': '/Link',
                'Rect': pydyf.Array([x1, y1, x2, y2]),
                'BS': pydyf.Dictionary({'W': 0}),
                'P': page.reference,
                'T': pydyf.String(id),  # id added as metadata
            })

            # The next line makes all of this relevent to use
            # with PDFjs
            annotation['Dest'] = pydyf.String(id)

            pdf.add_object(annotation)
            page['Annots'].append(annotation.reference)


VARIANTS = {'debug': (debug, {})}


================================================
FILE: weasyprint/pdf/fonts.py
================================================
"""Fonts integration in PDF."""

import io
import re
from hashlib import md5
from logging import WARNING
from math import ceil

import pydyf
from fontTools import subset
from fontTools.ttLib import TTFont, TTLibError, ttFont
from fontTools.varLib.instancer import instantiateVariableFont

from ..logger import LOGGER, capture_logs
from ..text.constants import PANGO_STRETCH_PERCENT
from ..text.ffi import FROM_UNITS, ffi, harfbuzz, harfbuzz_subset, pango
from ..text.fonts import get_hb_object_data, get_pango_font_hb_face


class Font:
    def __init__(self, pango_font, description, font_size):
        self.hb_font = pango.pango_font_get_hb_font(pango_font)
        self.hb_face = get_pango_font_hb_face(pango_font)
        self.file_content = get_hb_object_data(self.hb_face)
        self.index = harfbuzz.hb_face_get_index(self.hb_face)

        self.font_size = font_size
        self.style = pango.pango_font_description_get_style(description)
        self.family = ffi.string(
            pango.pango_font_description_get_family(description)).decode()

        self.variations = {}
        variations = pango.pango_font_description_get_variations(description)
        if variations != ffi.NULL:
            self.variations = {
                part.split('=')[0]: float(part.split('=')[1])
                for part in ffi.string(variations).decode().split(',')}
        if weight := self.variations.get('weight'):
            self.weight = round(weight)
            pango.pango_font_description_set_weight(description, weight)
        else:
            self.weight = pango.pango_font_description_get_weight(description)
        if self.variations.get('ital'):
            pango.pango_font_description_set_style(
                description, pango.PANGO_STYLE_ITALIC)
        elif self.variations.get('slnt'):
            pango.pango_font_description_set_style(
                description, pango.PANGO_STYLE_OBLIQUE)
        if (width := self.variations.get('wdth')) is not None:
            stretch = min(
                PANGO_STRETCH_PERCENT.items(),
                key=lambda item: abs(item[0] - width))[1]
            pango.pango_font_description_set_stretch(description, stretch)
        description_string = ffi.string(
            pango.pango_font_description_to_string(description))

        # Never use the built-in hash function here: it’s not stable.
        self.hash = ''.join(
            chr(65 + letter % 26) for letter
            in md5(description_string, usedforsecurity=False).digest()[:6])

        # Set font name.
        name = re.split(b' [#@]', description_string)[0]
        self.name = b'/' + self.hash.encode() + b'+' + name.replace(b' ', b'-')

        # Set ascent and descent.
        if self.font_size:
            pango_metrics = pango.pango_font_get_metrics(pango_font, ffi.NULL)
            self.ascent = round(
                pango.pango_font_metrics_get_ascent(pango_metrics) * FROM_UNITS /
                self.font_size * 1000)
            self.descent = -round(
                pango.pango_font_metrics_get_descent(pango_metrics) * FROM_UNITS /
                self.font_size * 1000)
        else:
            self.ascent = self.descent = 0

        # Get font tables and set metadata.
        table_count = ffi.new('unsigned int *', 100)
        table_tags = ffi.new('hb_tag_t[100]')
        table_name = ffi.new('char[4]')
        harfbuzz.hb_face_get_table_tags(self.hb_face, 0, table_count, table_tags)
        self.tables = []
        for i in range(table_count[0]):
            harfbuzz.hb_tag_to_string(table_tags[i], table_name)
            self.tables.append(ffi.string(table_name).decode())
        self.bitmap = False
        if 'EBDT' in self.tables and 'EBLC' in self.tables:
            if 'glyf' in self.tables:
                tag = harfbuzz.hb_tag_from_string(b'glyf', -1)
                blob = harfbuzz.hb_face_reference_table(self.hb_face, tag)
                if harfbuzz.hb_blob_get_length(blob) == 0:
                    self.bitmap = True
                harfbuzz.hb_blob_destroy(blob)
            else:
                self.bitmap = True
        self.italic_angle = 0  # TODO: this should be different
        self.upem = harfbuzz.hb_face_get_upem(self.hb_face)
        self.png = harfbuzz.hb_ot_color_has_png(self.hb_face)
        self.svg = harfbuzz.hb_ot_color_has_svg(self.hb_face)
        self.glyph_count = harfbuzz.hb_face_get_glyph_count(self.hb_face)
        self.stemv = 80
        self.stemh = 80
        self.widths = {}
        self.to_unicode = {}
        self.missing = {}
        self.used_in_forms = False

        # Set font flags.
        self.flags = 2 ** (3 - 1)  # Symbolic, custom character set
        if self.style:
            self.flags += 2 ** (7 - 1)  # Italic
        if b'Serif' in name.split(b' '):
            self.flags += 2 ** (2 - 1)  # Serif

    def get_unused_glyph_id(self, codepoint):
        """Get a glyph id that’s not used in the font, for given Unicode codepoint."""
        if codepoint not in self.missing:
            next_unused_glyph_id = self.glyph_count + len(self.missing)
            if next_unused_glyph_id > 2 ** 16 - 1:
                LOGGER.warning(
                    f'Too many glyphs missing from "{self.family}", '
                    'expect text selection problems')
                next_unused_glyph_id = 2 ** 16 - 1
            self.missing[codepoint] = next_unused_glyph_id
        return self.missing[codepoint]

    def clean(self, to_unicode, hinting):
        """Remove useless data from font."""

        # Subset font.
        self.subset(to_unicode, hinting)

        # Transform variable into static font.
        if 'fvar' in self.tables:
            full_font = io.BytesIO(self.file_content)
            ttfont = TTFont(full_font, fontNumber=self.index)
            axes = {axis.axisTag: axis for axis in ttfont['fvar'].axes}
            if 'wght' in axes and 'wght' not in self.variations:
                self.variations['wght'] = self.weight
            if 'opsz' in axes and 'opsz' not in self.variations:
                self.variations['opsz'] = self.font_size
            if 'slnt' in axes and 'slnt' not in self.variations:
                slnt = 0
                if self.style == 1:
                    if axes['slnt'].maxValue == 0:
                        slnt = axes['slnt'].minValue
                    else:
                        slnt = axes['slnt'].maxValue
                self.variations['slnt'] = slnt
            if 'ital' in axes and 'ital' not in self.variations:
                self.variations['ital'] = int(self.style == 2)
            partial_font = io.BytesIO()
            try:
                ttfont = instantiateVariableFont(ttfont, self.variations, static=True)
                ttfont.save(partial_font)
            except Exception as exception:
                LOGGER.warning(f'Unable to instantiate "{self.family}" variable font')
                LOGGER.debug('Original exception:', exc_info=exception)
            else:
                self.file_content = partial_font.getvalue()

        # Remove images.
        if self.png or self.svg:
            full_font = io.BytesIO(self.file_content)
            ttfont = TTFont(full_font, fontNumber=self.index)
            try:
                # Add empty glyphs instead of PNG or SVG emojis.
                if 'loca' not in self.tables or 'glyf' not in self.tables:
                    ttfont['loca'] = ttFont.getTableClass('loca')()
                    ttfont['glyf'] = ttFont.getTableClass('glyf')()
                    ttfont['glyf'].glyphOrder = ttfont.getGlyphOrder()
                    ttfont['glyf'].glyphs = {
                        name: ttFont.getTableModule('glyf').Glyph()
                        for name in ttfont['glyf'].glyphOrder}
                else:
                    for glyph in ttfont['glyf'].glyphs:
                        ttfont['glyf'][glyph] = ttFont.getTableModule('glyf').Glyph()
                for table_name in ('CBDT', 'CBLC', 'SVG '):
                    if table_name in ttfont:
                        del ttfont[table_name]
                output_font = io.BytesIO()
                ttfont.save(output_font)
                self.file_content = output_font.getvalue()
            except TTLibError as exception:
                LOGGER.warning(f'Unable to save emoji font "{self.family}"')
                LOGGER.debug('Original exception:', exc_info=exception)

    @property
    def type(self):
        return 'otf' if self.file_content[:4] == b'OTTO' else 'ttf'

    def subset(self, to_unicode, hinting):
        """Remove unused glyphs and tables from font."""
        if not to_unicode:
            return

        if harfbuzz_subset and harfbuzz.hb_version_atleast(4, 1, 0):
            # 4.1.0 is required for hb_set_add_sorted_array.
            self._harfbuzz_subset(to_unicode, hinting)
        else:
            self._fonttools_subset(to_unicode, hinting)

    def _harfbuzz_subset(self, to_unicode, hinting):
        """Subset font using Harfbuzz."""
        hb_subset = ffi.gc(
            harfbuzz_subset.hb_subset_input_create_or_fail(),
            harfbuzz_subset.hb_subset_input_destroy)

        # Only keep used glyphs.
        gid_set = harfbuzz_subset.hb_subset_input_glyph_set(hb_subset)
        gid_array = ffi.new(f'hb_codepoint_t[{len(to_unicode)}]', sorted(to_unicode))
        harfbuzz.hb_set_add_sorted_array(gid_set, gid_array, len(to_unicode))

        # Set flags.
        flags = (
            harfbuzz_subset.HB_SUBSET_FLAGS_RETAIN_GIDS |
            harfbuzz_subset.HB_SUBSET_FLAGS_PASSTHROUGH_UNRECOGNIZED |
            harfbuzz_subset.HB_SUBSET_FLAGS_DESUBROUTINIZE)
        if self.missing:
            flags |= harfbuzz_subset.HB_SUBSET_FLAGS_NOTDEF_OUTLINE
        harfbuzz_subset.hb_subset_input_set_flags(hb_subset, flags)

        # Drop useless tables.
        drop_set = harfbuzz_subset.hb_subset_input_set(
            hb_subset, harfbuzz_subset.HB_SUBSET_SETS_DROP_TABLE_TAG)
        drop_tables = tuple(harfbuzz.hb_tag_from_string(name, -1) for name in (
            b'BASE', b'DSIG', b'EBDT', b'EBLC', b'EBSC', b'GPOS', b'GSUB', b'JSTF',
            b'LTSH', b'PCLT', b'SVG '))
        drop_tables_array = ffi.new(f'hb_codepoint_t[{len(drop_tables)}]', drop_tables)
        harfbuzz.hb_set_add_sorted_array(drop_set, drop_tables_array, len(drop_tables))

        # Subset font.
        hb_face = ffi.gc(
            harfbuzz_subset.hb_subset_or_fail(self.hb_face, hb_subset),
            harfbuzz.hb_face_destroy)

        # Drop empty glyphs after last one used.
        gid_set = harfbuzz_subset.hb_subset_input_glyph_set(hb_subset)
        keep = tuple(range(max(to_unicode) + 1))
        gid_array = ffi.new(f'hb_codepoint_t[{len(keep)}]', keep)
        harfbuzz.hb_set_add_sorted_array(gid_set, gid_array, len(keep))

        # Set flags.
        flags = (
            harfbuzz_subset.HB_SUBSET_FLAGS_PASSTHROUGH_UNRECOGNIZED |
            harfbuzz_subset.HB_SUBSET_FLAGS_DESUBROUTINIZE)
        if not hinting:
            flags |= harfbuzz_subset.HB_SUBSET_FLAGS_NO_HINTING
        if self.missing:
            flags |= harfbuzz_subset.HB_SUBSET_FLAGS_NOTDEF_OUTLINE
        harfbuzz_subset.hb_subset_input_set_flags(hb_subset, flags)

        # Subset font.
        hb_face = ffi.gc(
            harfbuzz_subset.hb_subset_or_fail(hb_face, hb_subset),
            harfbuzz.hb_face_destroy)

        # Store new font.
        if hb_face:
            file_content = get_hb_object_data(hb_face)
            if file_content:
                self.file_content = file_content
                return

        LOGGER.warning(f'Unable to subset "{self.family}" with HarfBuzz')

    def _fonttools_subset(self, to_unicode, hinting):
        """Subset font using Fonttools."""
        full_font = io.BytesIO(self.file_content)

        # Set subset options.
        options = subset.Options(
            retain_gids=True, passthrough_tables=True, ignore_missing_glyphs=True,
            hinting=hinting, desubroutinize=True, notdef_outline=bool(self.missing))
        options.drop_tables += ['GSUB', 'GPOS', 'SVG']
        subsetter = subset.Subsetter(options)
        subsetter.populate(gids=to_unicode)

        # Subset font.
        try:
            ttfont = TTFont(full_font, fontNumber=self.index)
            with capture_logs('fontTools', level=WARNING) as logs:
                subsetter.subset(ttfont)
            for log in logs:
                LOGGER.warning(
                    'fontTools warning when subsetting '
                    f'"{self.family}": {log}')
        except TTLibError as exception:
            LOGGER.warning(f'Unable to subset "{self.family}" with fontTools')
            LOGGER.debug('Original exception:', exc_info=exception)
        else:
            optimized_font = io.BytesIO()
            ttfont.save(optimized_font)
            self.file_content = optimized_font.getvalue()


def build_fonts_dictionary(pdf, fonts, compress, subset, options):
    """Build PDF dictionary for fonts."""
    pdf_fonts = pydyf.Dictionary()
    fonts_by_file_hash = {}
    for font in fonts.values():
        fonts_by_file_hash.setdefault(font.hash, []).append(font)
    font_references_by_file_hash = {}
    for file_hash, file_fonts in fonts_by_file_hash.items():
        # TODO: Find why we can have multiple fonts for one font file.
        font = file_fonts[0]
        if font.bitmap:
            continue

        # Clean font, optimize and handle emojis.
        to_unicode = {}
        if subset and not font.used_in_forms:
            for file_font in file_fonts:
                to_unicode = {**to_unicode, **file_font.to_unicode}
        font.clean(to_unicode, options['hinting'])

        # Include font.
        if font.type == 'otf':
            font_extra = pydyf.Dictionary({'Subtype': '/OpenType'})
        else:
            font_extra = pydyf.Dictionary({'Length1': len(font.file_content)})
        font_stream = pydyf.Stream([font.file_content], font_extra, compress=compress)
        pdf.add_object(font_stream)
        font_references_by_file_hash[file_hash] = font_stream.reference

    for font in fonts.values():
        if subset and not font.used_in_forms:
            # Only store widths and map for used glyphs
            font_widths = font.widths
            to_unicode = font.to_unicode
        else:
            # Store width and Unicode map for all glyphs
            full_font = io.BytesIO(font.file_content)
            ttfont = TTFont(full_font, fontNumber=font.index)
            font_widths, to_unicode = {}, {}
            for i, glyph in enumerate(ttfont.getGlyphSet().values()):
                font_widths[i] = glyph.width * 1000 / font.upem
            for letter, key in ttfont.getBestCmap().items():
                glyph_id = ttfont.getGlyphID(key)
                if glyph_id not in to_unicode:
                    to_unicode[glyph_id] = chr(letter)

        to_unicode_object = pydyf.Stream([
            b'/CIDInit /ProcSet findresource begin',
            b'12 dict begin',
            b'begincmap',
            b'/CIDSystemInfo',
            b'<< /Registry (Adobe)',
            b'/Ordering (UCS)',
            b'/Supplement 0',
            b'>> def',
            b'/CMapName /Adobe-Identity-UCS def',
            b'/CMapType 2 def',
            b'1 begincodespacerange',
            b'<0000> <ffff>',
            b'endcodespacerange'], compress=compress)
        to_unicode_stream = to_unicode_object.stream
        to_unicode_length = len(to_unicode)
        to_unicode_items = tuple(to_unicode.items())
        for i in range(ceil(to_unicode_length / 100)):
            batch_length = min(100, to_unicode_length - i * 100)
            to_unicode_stream.append(f'{batch_length} beginbfchar'.encode())
            for glyph, text in to_unicode_items[i*100:(i+1)*100]:
                unicode_codepoints = ''.join(
                    f'{letter.encode("utf-16-be").hex()}' for letter in text)
                to_unicode_stream.append(
                    f'<{glyph:04x}> <{unicode_codepoints}>'.encode())
            to_unicode_stream.append(b'endbfchar')
        to_unicode_stream.extend([
            b'endcmap',
            b'CMapName currentdict /CMap defineresource pop',
            b'end',
            b'end'])
        pdf.add_object(to_unicode_object)
        font_dictionary = pydyf.Dictionary({
            'Type': '/Font',
            'Subtype': f'/Type{3 if font.bitmap else 0}',
            'BaseFont': font.name,
            'ToUnicode': to_unicode_object.reference,
        })

        if font.bitmap:
            _build_bitmap_font_dictionary(
                font_dictionary, pdf, font, font_widths, compress, subset)
        else:
            _build_vector_font_dictionary(
                font_dictionary, pdf, font, font_widths, compress,
                font_references_by_file_hash[font.hash], options['pdf_version'])
        pdf.add_object(font_dictionary)
        pdf_fonts[font.hash] = font_dictionary.reference

    return pdf_fonts


def _build_bitmap_font_dictionary(font_dictionary, pdf, font, widths, compress, subset):
    # https://docs.microsoft.com/typography/opentype/spec/ebdt
    font_dictionary['FontBBox'] = pydyf.Array([0, 0, 1, 1])
    font_dictionary['FontMatrix'] = pydyf.Array([1, 0, 0, 1, 0, 0])
    if subset:
        chars = tuple(sorted(font.to_unicode))
    else:
        chars = tuple(range(256))
    first, last = chars[0], chars[-1]
    differences = []
    for glyph in sorted(widths):
        if glyph - 1 not in widths:
            differences.append(glyph)
        differences.append(f'/{glyph}')
    font_dictionary['FirstChar'] = first
    font_dictionary['LastChar'] = last
    font_dictionary['Encoding'] = pydyf.Dictionary({
        'Type': '/Encoding',
        'Differences': pydyf.Array(differences),
    })
    char_procs = pydyf.Dictionary({})
    full_font = io.BytesIO(font.file_content)
    ttfont = TTFont(full_font, fontNumber=font.index)
    font_glyphs = ttfont['EBDT'].strikeData[0]
    widths = [0] * (last - first + 1)
    glyphs_info = {}
    for key, glyph in font_glyphs.items():
        glyph_format = glyph.getFormat()
        glyph_id = ttfont.getGlyphID(key)

        # Get and store glyph metrics.
        if glyph_format == 5:
            data = glyph.data
            subtables = ttfont['EBLC'].strikes[0].indexSubTables
            for subtable in subtables:
                first_index = subtable.firstGlyphIndex
                last_index = subtable.lastGlyphIndex
                if first_index <= glyph_id <= last_index:
                    height = subtable.metrics.height
                    advance = width = subtable.metrics.width
                    bearing_x = subtable.metrics.horiBearingX
                    bearing_y = subtable.metrics.horiBearingY
                    break
            else:
                LOGGER.warning(
                    f'Unknown bitmap metrics in "{font.family}" for glyph: {glyph_id}')
                continue
        else:
            data_start = 5 if glyph_format in (1, 2, 8) else 8
            data = glyph.data[data_start:]
            height, width = glyph.data[0:2]
            bearing_x = int.from_bytes(glyph.data[2:3], 'big', signed=True)
            bearing_y = int.from_bytes(glyph.data[3:4], 'big', signed=True)
            advance = glyph.data[4]
        position_y = bearing_y - height
        if glyph_id in chars:
            widths[glyph_id - first] = advance
        stride = ceil(width / 8)
        glyph_info = glyphs_info[glyph_id] = {
            'width': width,
            'height': height,
            'x': bearing_x,
            'y': position_y,
            'stride': stride,
            'bitmap': None,
            'subglyphs': None,
        }

        # Decode bitmaps.
        if 0 in (width, height) or not data:
            glyph_info['bitmap'] = b''
        elif glyph_format in (1, 6):
            glyph_info['bitmap'] = data
        elif glyph_format in (2, 5, 7):
            padding = (8 - (width % 8)) % 8
            bits = bin(int(data.hex(), 16))[2:]
            bits = bits.zfill(8 * len(data))
            bitmap_bits = ''.join(
                bits[i * width:(i + 1) * width] + padding * '0'
                for i in range(height))
            glyph_info['bitmap'] = int(bitmap_bits, 2).to_bytes(height * stride, 'big')
        elif glyph_format in (8, 9):
            subglyphs = glyph_info['subglyphs'] = []
            i = 0 if glyph_format == 9 else 1
            number_of_components = int.from_bytes(data[i:i+2], 'big')
            for j in range(number_of_components):
                index = (i + 2) + (j * 4)
                subglyph_id = int.from_bytes(data[index:index+2], 'big')
                x = int.from_bytes(data[index+2:index+3], 'big', signed=True)
                y = int.from_bytes(data[index+3:index+4], 'big', signed=True)
                subglyphs.append({'id': subglyph_id, 'x': x, 'y': y})
        else:  # pragma: no cover
            LOGGER.warning(
                f'Unsupported bitmap glyph format in "{font.family}": {glyph_format}')
            glyph_info['bitmap'] = bytes(height * stride)

    for glyph_id, glyph_info in glyphs_info.items():
        # Don’t store glyph not in to_unicode.
        if glyph_id not in chars:
            continue

        # Draw glyph.
        stride = glyph_info['stride']
        width = glyph_info['width']
        height = glyph_info['height']
        x = glyph_info['x']
        y = glyph_info['y']
        if glyph_info['bitmap'] is None:
            length = height * stride
            bitmap_int = int.from_bytes(bytes(length), 'big')
            for subglyph in glyph_info['subglyphs']:
                sub_x = subglyph['x']
                sub_y = subglyph['y']
                sub_id = subglyph['id']
                if sub_id not in glyphs_info:
                    LOGGER.warning(f'Unknown subglyph in "{font.family}": {sub_id}')
                    continue
                subglyph = glyphs_info[sub_id]
                if subglyph['bitmap'] is None:
                    # TODO: Support subglyph in subglyph.
                    LOGGER.warning(
                        'Unsupported subglyph in subglyph in '
                        f'"{font.family}": {sub_id}')
                    continue
                for row_y in range(subglyph['height']):
                    row_slice = slice(
                        row_y * subglyph['stride'],
                        (row_y + 1) * subglyph['stride'])
                    row = subglyph['bitmap'][row_slice]
                    row_int = int.from_bytes(row, 'big')
                    shift = stride * 8 * (height - sub_y - row_y - 1)
                    stride_difference = stride - subglyph['stride']
                    if stride_difference > 0:
                        row_int <<= stride_difference * 8
                    elif stride_difference < 0:
                        row_int >>= -stride_difference * 8
                    if sub_x > 0:
                        row_int >>= sub_x
                    elif sub_x < 0:
                        row_int <<= -sub_x
                    row_int %= 1 << stride * 8
                    row_int <<= shift
                    bitmap_int |= row_int
            bitmap = bitmap_int.to_bytes(length, 'big')
        else:
            bitmap = glyph_info['bitmap']
        bitmap_stream = pydyf.Stream([
            b'0 0 d0',
            f'{width} 0 0 {height} {x} {y} cm'.encode(),
            b'BI',
            b'/IM true',
            b'/W', width,
            b'/H', height,
            b'/BPC 1',
            b'/D [1 0]',
            b'ID', bitmap, b'EI'
        ], compress=compress)
        pdf.add_object(bitmap_stream)
        char_procs[glyph_id] = bitmap_stream.reference

    pdf.add_object(char_procs)
    font_dictionary['Widths'] = pydyf.Array(widths)
    font_dictionary['CharProcs'] = char_procs.reference


def _build_vector_font_dictionary(font_dictionary, pdf, font, widths, compress,
                                  reference, pdf_version):
    font_file = f'FontFile{3 if font.type == "otf" else 2}'
    max_x = max(widths.values()) if widths else 0
    bbox = (0, font.descent, max_x, font.ascent)
    flags = font.flags
    if len(widths) > 1 and len(set(font.widths.values())) == 1:
        flags += 2 ** (1 - 1)  # FixedPitch
    font_descriptor = pydyf.Dictionary({
        'Type': '/FontDescriptor',
        'FontName': font.name,
        'FontFamily': pydyf.String(font.family),
        'Flags': flags,
        'FontBBox': pydyf.Array(bbox),
        'ItalicAngle': font.italic_angle,
        'Ascent': font.ascent,
        'Descent': font.descent,
        'CapHeight': bbox[3],
        'StemV': font.stemv,
        'StemH': font.stemh,
        font_file: reference,
    })
    if str(pdf_version) <= '1.4':  # Cast for bytes and None
        cids = sorted(font.widths)
        padded_width = ceil((cids[-1] + 1) / 8)
        bits = ['0'] * padded_width * 8
        for cid in cids:
            bits[cid] = '1'
        stream = pydyf.Stream(
            (int(''.join(bits), 2).to_bytes(padded_width, 'big'),),
            compress=compress)
        pdf.add_object(stream)
        font_descriptor['CIDSet'] = stream.reference
    pdf.add_object(font_descriptor)

    pdf_widths = pydyf.Array()
    for i in sorted(widths):
        if i - 1 not in widths:
            pdf_widths.append(i)
            current_widths = pydyf.Array()
            pdf_widths.append(current_widths)
        current_widths.append(widths[i])

    subfont_dictionary = pydyf.Dictionary({
        'Type': '/Font',
        'Subtype': f'/CIDFontType{0 if font.type == "otf" else 2}',
        'BaseFont': font.name,
        'CIDSystemInfo': pydyf.Dictionary({
            'Registry': pydyf.String('Adobe'),
            'Ordering': pydyf.String('Identity'),
            'Supplement': 0,
        }),
        'CIDToGIDMap': '/Identity',
        'W': pdf_widths,
        'FontDescriptor': font_descriptor.reference,
    })
    pdf.add_object(subfont_dictionary)
    if font.missing:
        # Add CMap that doesn’t include missing glyphs, so that they can be replaced by
        # .notdef.
        cmap_extra = pydyf.Dictionary({
            'Type': '/CMap',
            'CMapName': '/WP-Encod-0',
            'CIDSystemInfo': pydyf.Dictionary({
                'Registry': pydyf.String('Adobe'),
                'Ordering': pydyf.String('Identity'),
                'Supplement': 0,
            }),
        })
        encoding = pydyf.Stream([
            b'/CIDInit /ProcSet findresource begin',
            b'12 dict begin',
            b'begincmap',
            b'/CIDSystemInfo',
            b'3 dict dup begin',
            b'/Registry (Adobe) def',
            b'/Ordering (Identity) def',
            b'/Supplement 0 def',
            b'end def',
            b'/CMapName /WP-Encod-0 def',
            b'/CMapType 1 def',
            b'1 begincodespacerange',
            b'<0000> <ffff>',
            b'endcodespacerange',
        ], cmap_extra, compress=compress)
        available = tuple(font.to_unicode)
        available_length = len(available)
        for i in range(ceil(available_length / 100)):
            batch_length = min(100, available_length - i * 100)
            encoding.stream.append(f'{batch_length} begincidchar'.encode())
            for glyph_id in available[i*100:(i+1)*100]:
                font_glyph_id = 0 if glyph_id in font.missing.values() else glyph_id
                encoding.stream.append(f'<{glyph_id:04x}> {font_glyph_id}'.encode())
            encoding.stream.append(b'endcidchar')
        encoding.stream.extend([
            b'endcmap',
            b'CMapName currentdict /CMap defineresource pop',
            b'end',
            b'end'])
        pdf.add_object(encoding)
        font_dictionary['Encoding'] = encoding.reference
    else:
        # No missing glyph in this font, use the identity mapping to map all glyphs.
        font_dictionary['Encoding'] = '/Identity-H'
    font_dictionary['DescendantFonts'] = pydyf.Array([subfont_dictionary.reference])


================================================
FILE: weasyprint/pdf/metadata.py
================================================
"""PDF metadata stream generation."""

from uuid import uuid4
from xml.etree.ElementTree import Element, SubElement, register_namespace, tostring

import pydyf

from .. import __version__

# XML namespaces used for metadata
NS = {
    'rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
    'dc': 'http://purl.org/dc/elements/1.1/',
    '': '',
    'xmp': 'http://ns.adobe.com/xap/1.0/',
    'xmpMM': 'http://ns.adobe.com/xap/1.0/mm/',
    'pdf': 'http://ns.adobe.com/pdf/1.3/',
    'pdfaid': 'http://www.aiim.org/pdfa/ns/id/',
    'pdfuaid': 'http://www.aiim.org/pdfua/ns/id/',
    'pdfxid': 'http://www.npes.org/pdfx/ns/id/',
    'pdfx': 'http://ns.adobe.com/pdfx/1.3/',
}
for key, value in NS.items():
    register_namespace(key, value)


class DocumentMetadata:
    """Meta-information belonging to a whole :class:`Document`.

    New attributes may be added in future versions of WeasyPrint.
    """
    def __init__(self, title=None, authors=None, description=None, keywords=None,
                 generator=None, created=None, modified=None, attachments=None,
                 lang=None, custom=None, xmp_metadata=None):
        #: The title of the document, as a string or :obj:`None`.
        #: Extracted from the ``<title>`` element in HTML
        #: and written to the ``/Title`` info field in PDF.
        self.title = title
        #: The authors of the document, as a list of strings.
        #: (Defaults to the empty list.)
        #: Extracted from the ``<meta name=author>`` elements in HTML
        #: and written to the ``/Author`` info field in PDF.
        self.authors = authors or []
        #: The description of the document, as a string or :obj:`None`.
        #: Extracted from the ``<meta name=description>`` element in HTML
        #: and written to the ``/Subject`` info field in PDF.
        self.description = description
        #: Keywords associated with the document, as a list of strings.
        #: (Defaults to the empty list.)
        #: Extracted from ``<meta name=keywords>`` elements in HTML
        #: and written to the ``/Keywords`` info field in PDF.
        self.keywords = keywords or []
        #: The name of one of the software packages
        #: used to generate the document, as a string or :obj:`None`.
        #: Extracted from the ``<meta name=generator>`` element in HTML
        #: and written to the ``/Creator`` info field in PDF.
        self.generator = generator
        #: The creation date of the document, as a string or :obj:`None`.
        #: Dates are in one of the six formats specified in
        #: `W3C’s profile of ISO 8601 <https://www.w3.org/TR/NOTE-datetime>`_.
        #: Extracted from the ``<meta name=dcterms.created>`` element in HTML
        #: and written to the ``/CreationDate`` info field in PDF.
        self.created = created
        #: The modification date of the document, as a string or :obj:`None`.
        #: Dates are in one of the six formats specified in
        #: `W3C’s profile of ISO 8601 <https://www.w3.org/TR/NOTE-datetime>`_.
        #: Extracted from the ``<meta name=dcterms.modified>`` element in HTML
        #: and written to the ``/ModDate`` info field in PDF.
        self.modified = modified
        #: A list of :class:`attachments <weasyprint.Attachment>`, empty by default.
        #: Extracted from the ``<link rel=attachment>`` elements in HTML
        #: and written to the ``/EmbeddedFiles`` dictionary in PDF.
        self.attachments = attachments or []
        #: Document language as BCP 47 language tags.
        #: Extracted from ``<html lang=lang>`` in HTML.
        self.lang = lang
        #: Custom metadata, as a dict whose keys are the metadata names and
        #: values are the metadata values.
        self.custom = custom or {}
        #: A list of XML bytestrings to add into the XMP metadata.
        self.xmp_metadata = xmp_metadata or []


    def include_in_pdf(self, pdf, variant, version, conformance, compress):
        """Add PDF stream of metadata.

        Described in ISO-32000-1:2008, 14.3.2.

        """
        header = b'<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>\n'
        header += b'<x:xmpmeta xmlns:x="adobe:ns:meta/">'
        footer = b'</x:xmpmeta>\n<?xpacket end="r"?>'
        xml_data = self.generate_rdf_metadata(variant, version, conformance)
        stream_content = b'\n'.join((header, xml_data, *self.xmp_metadata, footer))
        extra = {'Type': '/Metadata', 'Subtype': '/XML'}
        metadata = pydyf.Stream([stream_content], extra, compress)
        pdf.add_object(metadata)
        pdf.catalog['Metadata'] = metadata.reference


    def generate_rdf_metadata(self, variant, version, conformance):
        """Generate RDF metadata as a bytestring."""
        namespace = f'pdf{variant}id'
        rdf = Element(f'{{{NS["rdf"]}}}RDF')

        if version:
            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
            element.attrib[f'{{{NS[namespace]}}}part'] = str(version)
        if conformance:
            assert version
            if variant == 'x':
                for key in (
                    f'{{{NS["pdfxid"]}}}GTS_PDFXVersion',
                    f'{{{NS["pdfx"]}}}GTS_PDFXVersion',
                    f'{{{NS["pdfx"]}}}GTS_PDFXConformance',
                ):
                    subelement = SubElement(element, key)
                    subelement.text = conformance
                subelement = SubElement(element, f'{{{NS["pdf"]}}}Trapped')
                subelement.text = 'False'
                if version >= 4:
                    # TODO: these values could be useful instead of using random values.
                    assert self.modified
                    subelement = SubElement(element, f'{{{NS["xmp"]}}}MetadataDate')
                    subelement.text = self.modified
                    subelement = SubElement(element, f'{{{NS["xmpMM"]}}}DocumentID')
                    subelement.text = f'xmp.did:{uuid4()}'
                    subelement = SubElement(element, f'{{{NS["xmpMM"]}}}RenditionClass')
                    subelement.text = 'proof:pdf'
                    subelement = SubElement(element, f'{{{NS["xmpMM"]}}}VersionID')
                    subelement.text = '1'
            else:
                element.attrib[f'{{{NS[namespace]}}}conformance'] = conformance
                if variant == 'a' and version == 4:
                    subelement = SubElement(element, f'{{{NS["pdfaid"]}}}rev')
                    subelement.text = '2020'

        element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
        element.attrib[f'{{{NS["rdf"]}}}about'] = ''
        element.attrib[f'{{{NS["pdf"]}}}Producer'] = f'WeasyPrint {__version__}'

        if self.title:
            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
            element = SubElement(element, f'{{{NS["dc"]}}}title')
            element = SubElement(element, f'{{{NS["rdf"]}}}Alt')
            element = SubElement(element, f'{{{NS["rdf"]}}}li')
            element.attrib['xml:lang'] = 'x-default'
            element.text = self.title
        if self.authors:
            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
            element = SubElement(element, f'{{{NS["dc"]}}}creator')
            element = SubElement(element, f'{{{NS["rdf"]}}}Seq')
            for author in self.authors:
                author_element = SubElement(element, f'{{{NS["rdf"]}}}li')
                author_element.text = author
        if self.description:
            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
            element = SubElement(element, f'{{{NS["dc"]}}}subject')
            element = SubElement(element, f'{{{NS["rdf"]}}}Bag')
            element = SubElement(element, f'{{{NS["rdf"]}}}li')
            element.attrib['xml:lang'] = 'x-default'
            element.text = self.description
        if self.keywords:
            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
            element = SubElement(element, f'{{{NS["pdf"]}}}Keywords')
            element.text = ', '.join(self.keywords)
        if self.generator:
            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
            element = SubElement(element, f'{{{NS["xmp"]}}}CreatorTool')
            element.text = self.generator
        if self.created:
            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
            element = SubElement(element, f'{{{NS["xmp"]}}}CreateDate')
            element.text = self.created
        if self.modified:
            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
            element = SubElement(element, f'{{{NS["xmp"]}}}ModifyDate')
            element.text = self.modified
        return tostring(rdf, encoding='utf-8')


================================================
FILE: weasyprint/pdf/pdfa.py
================================================
"""PDF/A generation."""

from functools import partial

import pydyf


def pdfa(pdf, metadata, document, page_streams, attachments, compress,
         version, variant):
    """Set metadata for PDF/A documents."""

    # Handle attachments.
    if version == 1:
        # Remove embedded files dictionary.
        if 'Names' in pdf.catalog and 'EmbeddedFiles' in pdf.catalog['Names']:
            del pdf.catalog['Names']['EmbeddedFiles']
    if version <= 2:
        # Remove attachments.
        for pdf_object in pdf.objects:
            if not isinstance(pdf_object, dict):
                continue
            if pdf_object.get('Type') != '/Filespec':
                continue
            reference = int(pdf_object['EF']['F'].split()[0])
            stream = pdf.objects[reference]
            # Remove all attachments for version 1.
            # Remove non-PDF attachments for version 2.
            # TODO: check that PDFs are actually PDF/A-2+ files.
            if version == 1 or stream.extra['Subtype'] != '/application#2fpdf':
                del pdf_object['EF']
    if version >= 3:
        # Add AF for attachments.
        relationships = {
            f'<{attachment.md5}>': attachment.relationship
            for attachment in attachments if attachment.md5}
        pdf_attachments = []
        if 'Names' in pdf.catalog and 'EmbeddedFiles' in pdf.catalog['Names']:
            reference = int(pdf.catalog['Names']['EmbeddedFiles'].split()[0])
            names = pdf.objects[reference]
            for name in names['Names'][1::2]:
                pdf_attachments.append(name)
        for pdf_object in pdf.objects:
            if not isinstance(pdf_object, dict):
                continue
            if pdf_object.get('Type') != '/Filespec':
                continue
            reference = int(pdf_object['EF']['F'].split()[0])
            checksum = pdf.objects[reference].extra['Params']['CheckSum']
            relationship = relationships.get(checksum, 'Unspecified')
            pdf_object['AFRelationship'] = f'/{relationship}'
            pdf_attachments.append(pdf_object.reference)
        if pdf_attachments:
            if 'AF' not in pdf.catalog:
                pdf.catalog['AF'] = pydyf.Array()
            pdf.catalog['AF'].extend(pdf_attachments)

    # Print annotations.
    for pdf_object in pdf.objects:
        if isinstance(pdf_object, dict) and pdf_object.get('Type') == '/Annot':
            pdf_object['F'] = 2 ** (3 - 1)

    # Common PDF metadata stream.
    if version == 1:
        # Metadata compression is forbidden for version 1.
        compress = False
    metadata.include_in_pdf(pdf, 'a', version, variant, compress)

    # Remove document information.
    if version >= 4:
        pdf.info.clear()


VARIANTS = {
    'pdf/a-1b': (
        partial(pdfa, version=1, variant='B'),
        {'version': '1.4', 'identifier': True, 'srgb': True}),
    'pdf/a-2b': (
        partial(pdfa, version=2, variant='B'),
        {'version': '1.7', 'identifier': True, 'srgb': True}),
    'pdf/a-3b': (
        partial(pdfa, version=3, variant='B'),
        {'version': '1.7', 'identifier': True, 'srgb': True}),
    'pdf/a-2u': (
        partial(pdfa, version=2, variant='U'),
        {'version': '1.7', 'identifier': True, 'srgb': True}),
    'pdf/a-3u': (
        partial(pdfa, version=3, variant='U'),
        {'version': '1.7', 'identifier': True, 'srgb': True}),
    'pdf/a-4u': (
        partial(pdfa, version=4, variant='U'),
        {'version': '2.0', 'identifier': True, 'srgb': True}),
    'pdf/a-1a': (
        partial(pdfa, version=1, variant='A'),
        {'version': '1.4', 'identifier': True, 'srgb': True, 'pdf_tags': True}),
    'pdf/a-2a': (
        partial(pdfa, version=2, variant='A'),
        {'version': '1.7', 'identifier': True, 'srgb': True, 'pdf_tags': True}),
    'pdf/a-3a': (
        partial(pdfa, version=3, variant='A'),
        {'version': '1.7', 'identifier': True, 'srgb': True, 'pdf_tags': True}),
    'pdf/a-4e': (
        partial(pdfa, version=4, variant='E'),
        {'version': '2.0', 'identifier': True, 'srgb': True}),
    'pdf/a-4f': (
        partial(pdfa, version=4, variant='F'),
        {'version': '2.0', 'identifier': True, 'srgb': True}),
}


================================================
FILE: weasyprint/pdf/pdfua.py
================================================
"""PDF/UA generation."""

from functools import partial


def pdfua(pdf, metadata, document, page_streams, attachments, compress, version):
    """Set metadata for PDF/UA documents."""
    # Common PDF metadata stream
    metadata.include_in_pdf(pdf, 'ua', version, conformance=None, compress=compress)


VARIANTS = {
    'pdf/ua-1': (partial(pdfua, version=1), {'version': '1.7', 'pdf_tags': True}),
    'pdf/ua-2': (partial(pdfua, version=2), {'version': '2.0', 'pdf_tags': True}),
}


================================================
FILE: weasyprint/pdf/pdfx.py
================================================
"""PDF/X generation."""

from functools import partial
from time import localtime

import pydyf


def pdfx(pdf, metadata, document, page_streams, attachments, compress, version,
         variant):
    """Set metadata for PDF/X documents."""

    # Add conformance metadata.
    conformance = f'PDF/X-{version}{variant}'
    if version < 4:
        pdf.info['GTS_PDFXVersion'] = pydyf.String(conformance)
        pdf.info['GTS_PDFXConformance'] = pydyf.String(conformance)
    pdf.info['Trapped'] = '/False'
    now = localtime()
    year, month, day, hour, minute, second = now[:6]
    tz_hour, tz_minute = divmod(now.tm_gmtoff, 3600)
    now_iso = (
        f'{year:04}-{month:02}-{day:02}T{hour:02}:{minute:02}:{second:02}'
        f'{tz_hour:+03}:{tz_minute:02}')
    now_pdf = (
        f'(D:{year:04}{month:02}{day:02}{hour:02}{minute:02}{second:02}'
        f"{tz_hour:+03}'{tz_minute:02}')")
    if not metadata.modified:
        metadata.modified = now_iso
        pdf.info['ModDate'] = now_pdf
    if not metadata.created:
        metadata.created = now_iso
        pdf.info['CreationDate'] = now_pdf

    # Add output intents.
    if 'device-cmyk' not in document.color_profiles:
        # Add standard CMYK profile.
        pdf.catalog['OutputIntents'] = pydyf.Array([
            pydyf.Dictionary({
                'Type': '/OutputIntent',
                'S': '/GTS_PDFX',
                'OutputConditionIdentifier': pydyf.String('CGATS TR 001'),
                'RegistryName': pydyf.String('http://www.color.org'),
            }),
        ])

    # Common PDF metadata stream.
    metadata.include_in_pdf(pdf, 'x', version, conformance, compress=compress)


VARIANTS = {
    'pdf/x-1a': (
        partial(pdfx, version=1, variant='a:2003'),
        {'version': '1.4', 'identifier': True},
    ),
    'pdf/x-3': (
        partial(pdfx, version=3, variant=':2003'),
        {'version': '1.4', 'identifier': True},
    ),
    'pdf/x-4': (
        partial(pdfx, version=4, variant=''),
        {'version': '1.6', 'identifier': True},
    ),
    'pdf/x-5g': (
        partial(pdfx, version=5, variant='g'),
        {'version': '1.6', 'identifier': True},
    ),
    # TODO: these variants forbid OutputIntent to include ICC file.
    # 'pdf/x-4p': (
    #     partial(pdfx, version=4, variant='p'),
    #     {'version': '1.6', 'identifier': True},
    # ),
    # 'pdf/x-5pg': (
    #     partial(pdfx, version=5, variant='pg'),
    #     {'version': '1.6', 'identifier': True},
    # ),
    # 'pdf/x-5n': (
    #     partial(pdfx, version=5, variant='n'),
    #     {'version': '1.6', 'identifier': True},
    # ),
}


================================================
FILE: weasyprint/pdf/stream.py
================================================
"""PDF stream."""

from contextlib import contextmanager

import pydyf

from ..logger import LOGGER
from ..matrix import Matrix
from ..text.ffi import ffi
from ..text.fonts import get_pango_font_key
from .fonts import Font


class Stream(pydyf.Stream):
    """PDF stream object with extra features."""
    def __init__(self, fonts, page_rectangle, resources, images, tags, color_profiles,
                 *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.page_rectangle = page_rectangle
        self._fonts = fonts
        self._resources = resources
        self._images = images
        self._tags = tags
        self._color_profiles = color_profiles
        self._current_color = self._current_color_stroke = None
        self._current_alpha = self._current_alpha_stroke = None
        self._current_font = self._current_font_size = None
        self._old_font = self._old_font_size = None
        self._ctm_stack = [Matrix()]

        # These objects are used in text.show_first_line
        self.length = ffi.new('unsigned int *')
        self.ink_rect = ffi.new('PangoRectangle *')
        self.logical_rect = ffi.new('PangoRectangle *')

    def clone(self, **kwargs):
        if 'fonts' not in kwargs:
            kwargs['fonts'] = self._fonts
        if 'page_rectangle' not in kwargs:
            kwargs['page_rectangle'] = self.page_rectangle
        if 'resources' not in kwargs:
            kwargs['resources'] = self._resources
        if 'images' not in kwargs:
            kwargs['images'] = self._images
        if 'tags' not in kwargs:
            kwargs['tags'] = self._tags
        if 'color_profiles' not in kwargs:
            kwargs['color_profiles'] = self._color_profiles
        if 'compress' not in kwargs:
            kwargs['compress'] = self.compress
        return Stream(**kwargs)

    @property
    def ctm(self):
        return self._ctm_stack[-1]

    def push_state(self):
        super().push_state()
        self._ctm_stack.append(self.ctm)

    def pop_state(self):
        if self.stream and self.stream[-1] == b'q':
            self.stream.pop()
        else:
            super().pop_state()
        self._current_color = self._current_color_stroke = None
        self._current_alpha = self._current_alpha_stroke = None
        self._current_font = None
        self._ctm_stack.pop()
        assert self._ctm_stack

    def transform(self, a=1, b=0, c=0, d=1, e=0, f=0):
        super().set_matrix(a, b, c, d, e, f)
        self._ctm_stack[-1] = Matrix(a, b, c, d, e, f) @ self.ctm

    def begin_text(self):
        if self.stream and self.stream[-1] == b'ET':
            self._current_font = self._old_font
            self.stream.pop()
        else:
            super().begin_text()

    def end_text(self):
        self._old_font, self._current_font = self._current_font, None
        super().end_text()

    def set_color(self, color, stroke=False):
        *channels, alpha = color
        self.set_alpha(alpha, stroke)

        if stroke:
            if (color.space, *channels) == self._current_color_stroke:
                return
            else:
                self._current_color_stroke = (color.space, *channels)
        else:
            if (color.space, *channels) == self._current_color:
                return
            else:
                self._current_color = (color.space, *channels)

        if color.space in ('srgb', 'hsl', 'hwb'):
            self.set_color_rgb(*color.to('srgb').coordinates, stroke)
        elif color.space in ('xyz-d65', 'oklab', 'oklch'):
            self.set_color_space('lab-d65', stroke)
            lightness, a, b = color.to('lab').coordinates
            self.set_color_special(None, stroke, lightness, a, b)
        elif color.space in ('xyz-d50', 'lab', 'lch'):
            self.set_color_space('lab-d50', stroke)
            lightness, a, b = color.to('lab').coordinates
            self.set_color_special(None, stroke, lightness, a, b)
        elif color.space == 'device-cmyk':
            self.set_color_space('DeviceCMYK', stroke)
            c, m, y, k = color.coordinates
            self.set_color_special(None, stroke, c, m, y, k)
        elif color.space.startswith('--') and color.space in self._color_profiles:
            self.set_color_space(color.space, stroke)
            self.set_color_special(None, stroke, *color.coordinates)
        else:
            LOGGER.warning('Unsupported color space %s, use sRGB instead', color.space)
            if len(channels) > 3:
                channels = channels[:3]
            elif len(channels) == 2:
                channels = *channels, 0
            elif len(channels) == 1:
                channels = *channels, 0, 0
            self.set_color_rgb(*channels, stroke)

    def set_font_size(self, font, size):
        if (font, size) == self._current_font:
            return
        self._current_font = (font, size)
        super().set_font_size(font, size)

    def set_state(self, state):
        key = f's{len(self._resources["ExtGState"])}'
        self._resources['ExtGState'][key] = state
        super().set_state(key)

    def set_alpha(self, alpha, stroke=False, fill=None):
        if fill is None:
            fill = not stroke

        if stroke:
            key = f'A{alpha}'
            if key != self._current_alpha_stroke:
                self._current_alpha_stroke = key
                if key not in self._resources['ExtGState']:
                    self._resources['ExtGState'][key] = pydyf.Dictionary({'CA': alpha})
                super().set_state(key)

        if fill:
            key = f'a{alpha}'
            if key != self._current_alpha:
                self._current_alpha = key
                if key not in self._resources['ExtGState']:
                    self._resources['ExtGState'][key] = pydyf.Dictionary({'ca': alpha})
                super().set_state(key)

    def set_alpha_state(self, x, y, width, height, mode='luminosity'):
        alpha_stream = self.add_group(x, y, width, height)
        alpha_state = pydyf.Dictionary({
            'Type': '/ExtGState',
            'SMask': pydyf.Dictionary({
                'Type': '/Mask',
                'S': f'/{mode.capitalize()}',
                'G': alpha_stream,
            }),
            'ca': 1,
            'AIS': 'false',
        })
        self.set_state(alpha_state)
        return alpha_stream

    def set_blend_mode(self, mode):
        self.set_state(pydyf.Dictionary({
            'Type': '/ExtGState',
            'BM': f'/{mode}',
        }))

    def add_font(self, pango_font):
        key, description, font_size = get_pango_font_key(pango_font)
        if key not in self._fonts:
            self._fonts[key] = Font(pango_font, description, font_size)
        return self._fonts[key], font_size

    def add_group(self, x, y, width, height):
        resources = pydyf.Dictionary({
            'ExtGState': pydyf.Dictionary(),
            'XObject': pydyf.Dictionary(),
            'Pattern': pydyf.Dictionary(),
            'Shading': pydyf.Dictionary(),
            'ColorSpace': self._resources['ColorSpace'],
            'Font': None,  # Will be set by _use_references
        })
        extra = pydyf.Dictionary({
            'Type': '/XObject',
            'Subtype': '/Form',
            'BBox': pydyf.Array((x, y, x + width, y + height)),
            'Resources': resources,
            'Group': pydyf.Dictionary({
                'Type': '/Group',
                'S': '/Transparency',
                'I': 'true',
                'CS': '/DeviceRGB',
            }),
        })
        group = self.clone(resources=resources, extra=extra)
        group.id = f'x{len(self._resources["XObject"])}'
        self._resources['XObject'][group.id] = group
        return group

    def add_image(self, image, interpolate, ratio):
        image_name = f'i{image.id}{int(interpolate)}'
        self._resources['XObject'][image_name] = None  # Set by write_pdf
        if image_name in self._images:
            # Reuse image already stored in document
            self._images[image_name]['dpi_ratios'].add(ratio)
            return image_name

        self._images[image_name] = {
            'image': image,
            'interpolate': interpolate,
            'dpi_ratios': {ratio},
            'x_object': None,  # Set by write_pdf
        }
        return image_name

    def add_pattern(self, x, y, width, height, repeat_width, repeat_height, matrix):
        resources = pydyf.Dictionary({
            'ExtGState': pydyf.Dictionary(),
            'XObject': pydyf.Dictionary(),
            'Pattern': pydyf.Dictionary(),
            'Shading': pydyf.Dictionary(),
            'ColorSpace': self._resources['ColorSpace'],
            'Font': None,  # Will be set by _use_references
        })
        extra = pydyf.Dictionary({
            'Type': '/Pattern',
            'PatternType': 1,
            'BBox': pydyf.Array([x, y, x + width, y + height]),
            'XStep': repeat_width,
            'YStep': repeat_height,
            'TilingType': 1,
            'PaintType': 1,
            'Matrix': pydyf.Array(matrix.values),
            'Resources': resources,
        })
        pattern = self.clone(resources=resources, extra=extra)
        pattern.id = f'p{len(self._resources["Pattern"])}'
        self._resources['Pattern'][pattern.id] = pattern
        return pattern

    def add_shading(self, shading_type, color_space, domain, coords, extend,
                    function):
        shading = pydyf.Dictionary({
            'ShadingType': shading_type,
            'ColorSpace': f'/Device{color_space}',
            'Domain': pydyf.Array(domain),
            'Coords': pydyf.Array(coords),
            'Function': function,
        })
        if extend:
            shading['Extend'] = pydyf.Array((b'true', b'true'))
        shading.id = f's{len(self._resources["Shading"])}'
        self._resources['Shading'][shading.id] = shading
        return shading

    @contextmanager
    def stacked(self):
        """Save and restore stream context when used with the ``with`` keyword."""
        self.push_state()
        try:
            yield
        finally:
            self.pop_state()

    @contextmanager
    def marked(self, box, tag):
        if self._tags is not None:
            property_list = None
            mcid = len(self._tags)
            assert box not in self._tags
            self._tags[box] = {'tag': tag, 'mcid': mcid}
            property_list = pydyf.Dictionary({'MCID': mcid})
            super().begin_marked_content(tag, property_list)
        try:
            yield
        finally:
            if self._tags is not None:
                super().end_marked_content()

    @contextmanager
    def artifact(self):
        if self._tags is not None:
            super().begin_marked_content('Artifact')
        try:
            yield
        finally:
            if self._tags is not None:
                super().end_marked_content()

    @staticmethod
    def create_interpolation_function(domain, c0, c1, n):
        return pydyf.Dictionary({
            'FunctionType': 2,
            'Domain': pydyf.Array(domain),
            'C0': pydyf.Array(c0),
            'C1': pydyf.Array(c1),
            'N': n,
        })

    @staticmethod
    def create_stitching_function(domain, encode, bounds, sub_functions):
        return pydyf.Dictionary({
            'FunctionType': 3,
            'Domain': pydyf.Array(domain),
            'Encode': pydyf.Array(encode),
            'Bounds': pydyf.Array(bounds),
            'Functions': pydyf.Array(sub_functions),
        })


================================================
FILE: weasyprint/pdf/tags.py
================================================
"""PDF tagging."""

from collections import defaultdict

import pydyf

from ..formatting_structure import boxes
from ..layout.absolute import AbsolutePlaceholder
from ..logger import LOGGER


def add_tags(pdf, document, page_streams):
    """Add tag tree to the document."""

    # Add root structure.
    content_mapping = pydyf.Dictionary({})
    pdf.add_object(content_mapping)
    structure_root = pydyf.Dictionary({
        'Type': '/StructTreeRoot',
        'ParentTree': content_mapping.reference,
    })
    pdf.add_object(structure_root)
    structure_document = pydyf.Dictionary({
        'Type': '/StructElem',
        'S': '/Document',
        'K': pydyf.Array(),
        'P': structure_root.reference,
    })
    pdf.add_object(structure_document)
    structure_root['K'] = pydyf.Array([structure_document.reference])
    pdf.catalog['StructTreeRoot'] = structure_root.reference

    # Map content.
    content_mapping['Nums'] = pydyf.Array()
    links = []
    for page_number, (page, stream) in enumerate(zip(document.pages, page_streams)):
        tags = stream._tags
        page_box = page._page_box

        # Prepare array for this page’s MCID-to-StructElem mapping.
        content_mapping['Nums'].append(page_number)
        content_mapping['Nums'].append(pydyf.Array())
        page_nums = {}

        # Map page box content.
        elements = _build_box_tree(
            page_box, structure_document, pdf, page_number, page_nums, links, tags)
        for element in elements:
            structure_document['K'].append(element.reference)
        assert not tags

        # Flatten page-local nums into global mapping.
        sorted_refs = [ref for _, ref in sorted(page_nums.items())]
        content_mapping['Nums'][-1].extend(sorted_refs)

    # Add annotations for links.
    for i, (link_reference, annotation) in enumerate(links, start=len(document.pages)):
        content_mapping['Nums'].append(i)
        content_mapping['Nums'].append(link_reference)
        annotation['StructParent'] = i

    # Add required metadata.
    pdf.catalog['ViewerPreferences'] = pydyf.Dictionary({'DisplayDocTitle': 'true'})
    pdf.catalog['MarkInfo'] = pydyf.Dictionary({'Marked': 'true'})
    if 'Lang' not in pdf.catalog:
        LOGGER.error('Missing required "lang" attribute at the root of the document')
        pdf.catalog['Lang'] = pydyf.String()


def _get_pdf_tag(tag):
    """Get PDF tag corresponding to HTML tag."""
    if tag is None:
        return 'NonStruct'
    elif tag == 'div':
        return 'Div'
    elif tag.split(':')[0] == 'a':
        # Links and link pseudo elements create link annotations.
        return 'Link'
    elif tag == 'span':
        return 'Span'
    elif tag == 'main':
        return 'Part'
    elif tag == 'article':
        return 'Art'
    elif tag == 'section':
        return 'Sect'
    elif tag == 'blockquote':
        return 'BlockQuote'
    elif tag == 'p':
        return 'P'
    elif tag in ('h1', 'h2', 'h3', 'h4', 'h5', 'h6'):
        return tag.upper()
    elif tag in ('dl', 'ul', 'ol'):
        return 'L'
    elif tag in ('li', 'dt', 'dd'):
        # TODO: dt should be different.
        return 'LI'
    elif tag == 'li::marker':
        return 'Lbl'
    elif tag == 'table':
        return 'Table'
    elif tag in ('tr', 'th', 'td'):
        return tag.upper()
    elif tag in ('thead', 'tbody', 'tfoot'):
        return tag[:2].upper() + tag[2:]
    elif tag == 'img':
        return 'Figure'
    elif tag in ('caption', 'figcaption'):
        return 'Caption'
    else:
        return 'NonStruct'


def _build_box_tree(box, parent, pdf, page_number, nums, links, tags):
    """Recursively build tag tree for given box and yield children."""

    # Special case for absolute elements.
    if isinstance(box, AbsolutePlaceholder):
        box = box._box

    element_tag = None if box.element is None else box.element_tag
    tag = _get_pdf_tag(element_tag)

    # Special case for html, body, page boxes and margin boxes.
    if element_tag in ('html', 'body') or isinstance(box, boxes.PageBox):
        # Avoid generate page, html and body boxes as a semantic node, yield children.
        if isinstance(box, boxes.ParentBox) and not isinstance(box, boxes.LineBox):
            for child in box.children:
                yield from _build_box_tree(
                    child, parent, pdf, page_number, nums, links, tags)
            return
    elif isinstance(box, boxes.MarginBox):
        # Build tree for margin boxes but don’t link it to main tree. It ensures that
        # marked content is mapped in document and removed from list. It could be
        # included in tree as Artifact, but that’s only allowed in PDF 2.0.
        for child in box.children:
            tuple(_build_box_tree(child, parent, pdf, page_number, nums, links, tags))
        return

    # Create box element.
    if tag == 'LI':
        anonymous_list_element = parent['S'] == '/LI'
        anonymous_li_child = parent['S'] == '/LBody'
        dl_item = box.element_tag in ('dt', 'dd')
        no_bullet_li = box.element_tag == 'li' and (
            'list-item' not in box.style['display'] or
            box.style['list_style_type'] == 'none')
        if anonymous_list_element:
            # Store as list item body.
            tag = 'LBody'
        elif anonymous_li_child:
            # Store as non struct list item body child.
            tag = 'NonStruct'
        elif dl_item or no_bullet_li:
            # Wrap in list item.
            tag = 'LBody'
            parent = pydyf.Dictionary({
                'Type': '/StructElem',
                'S': '/LI',
                'K': pydyf.Array([]),
                'Pg': pdf.page_references[page_number],
                'P': parent.reference,
            })
            pdf.add_object(parent)
            children = _build_box_tree(box, parent, pdf, page_number, nums, links, tags)
            for child in children:
                parent['K'].append(child.reference)
            yield parent
            return

    element = pydyf.Dictionary({
        'Type': '/StructElem',
        'S': f'/{tag}',
        'K': pydyf.Array([]),
        'Pg': pdf.page_references[page_number],
        'P': parent.reference,
    })
    pdf.add_object(element)

    # Handle special cases.
    if tag == 'Figure':
        # Add extra data for images.
        x1, y1 = box.content_box_x(), box.content_box_y()
        x2, y2 = x1 + box.width, y1 + box.height
        element['A'] = pydyf.Dictionary({
            'O': '/Layout',
            'BBox': pydyf.Array((x1, y1, x2, y2)),
        })
        if alt := box.element.attrib.get('alt'):
            element['Alt'] = pydyf.String(alt)
        else:
            source = box.element.attrib.get('src', 'unknown')
            LOGGER.error(f'Image "{source}" has no required alt description')
    elif tag == 'Table':
        # Use wrapped table as tagged box, and put captions in it.
        if box.is_table_wrapper:
            # Can be false if table has another display type.
            wrapper, table = box, box.get_wrapped_table()
            box = table.copy_with_children([])
            for child in wrapper.children:
                box.children.extend(child.children if child is table else [child])
    elif tag == 'TH':
        # Set identifier for table headers to reference them in cells.
        element['ID'] = pydyf.String(id(box))
    elif tag == 'TD':
        # Store table cell element to map it to headers later.
        # TODO: don’t use the box to store this.
        box.mark = element

    # Include link annotations.
    if box.link_annotation:
        annotation = box.link_annotation
        object_reference = pydyf.Dictionary({
            'Type': '/OBJR',
            'Obj': annotation.reference,
            'Pg': pdf.page_references[page_number],
        })
        pdf.add_object(object_reference)
        links.append((element.reference, annotation))
        element['K'].append(object_reference.reference)

    if isinstance(box, boxes.ParentBox):
        # Build tree for box children.
        for child in box.children:
            children = child.children if isinstance(child, boxes.LineBox) else [child]
            for child in children:
                if isinstance(child, boxes.TextBox):
                    # Add marked element from the stream.
                    kid = tags.pop(child)
                    assert kid['mcid'] not in nums
                    if tag == 'Link':
                        # Associate MCID directly with link reference.
                        element['K'].append(kid['mcid'])
                        nums[kid['mcid']] = element.reference
                    else:
                        kid_element = pydyf.Dictionary({
                            'Type': '/StructElem',
                            'S': f'/{kid["tag"]}',
                            'K': pydyf.Array([kid['mcid']]),
                            'Pg': pdf.page_references[page_number],
                            'P': element.reference,
                        })
                        pdf.add_object(kid_element)
                        element['K'].append(kid_element.reference)
                        nums[kid['mcid']] = kid_element.reference
                else:
                    # Recursively build tree for child.
                    if child.element_tag in ('ul', 'ol') and element['S'] == '/LI':
                        # In PDFs, nested lists are linked to the parent list, but in
                        # HTML, nested lists are linked to a parent’s list item.
                        child_parent = parent
                    else:
                        child_parent = element
                    child_elements = _build_box_tree(
                        child, child_parent, pdf, page_number, nums, links, tags)

                    # Check if it is already been referenced before.
                    for child_element in child_elements:
                        child_parent['K'].append(child_element.reference)

    else:
        # Add replaced box.
        assert isinstance(box, boxes.ReplacedBox)
        kid = tags.pop(box)
        element['K'].append(kid['mcid'])
        assert kid['mcid'] not in nums
        nums[kid['mcid']] = element.reference

    # Link table cells to related headers.
    if tag == 'Table':
        def _get_rows(table_box):
            for child in table_box.children:
                if child.element_tag == 'tr':
                    yield child
                else:
                    yield from _get_rows(child)

        # Get headers and rows.
        column_headers = defaultdict(list)
        row_headers = defaultdict(list)
        rows = tuple(_get_rows(box))

        # Find column and row headers.
        # TODO: handle rowspan and colspan values.
        for i, row in enumerate(rows):
            for j, cell in enumerate(row.children):
                if cell.element is None:
                    continue
                if cell.element_tag == 'th':
                    # TODO: handle rowgroup and colgroup values.
                    if cell.element.attrib.get('scope') == 'row':
                        row_headers[i].append(pydyf.String(id(cell)))
                    else:
                        column_headers[j].append(pydyf.String(id(cell)))

        # Map headers to cells.
        for i, row in enumerate(rows):
            for j, cell in enumerate(row.children):
                if cell.element is None:
                    continue
                if cell.element_tag == 'td':
                    cell.mark['A'] = pydyf.Dictionary({
                        'O': '/Table',
                        'Headers': pydyf.Array(row_headers[i] + column_headers[j]),
                    })

    yield element


================================================
FILE: weasyprint/stacking.py
================================================
"""Stacking contexts management."""

from .formatting_structure import boxes
from .layout.absolute import AbsolutePlaceholder


class StackingContext:
    """Stacking contexts define the paint order of all pieces of a document.

    https://www.w3.org/TR/CSS21/visuren.html#x43
    https://www.w3.org/TR/CSS21/zindex.html

    """
    def __init__(self, box, child_contexts, blocks, floats, blocks_and_cells,
                 page):
        self.box = box
        self.page = page
        self.block_level_boxes = blocks  # 4: In flow, non positioned
        self.float_contexts = floats  # 5: Non positioned
        self.negative_z_contexts = []  # 3: Child contexts, z-index < 0
        self.zero_z_contexts = []  # 8: Child contexts, z-index = 0
        self.positive_z_contexts = []  # 9: Child contexts, z-index > 0
        self.blocks_and_cells = blocks_and_cells  # 7: Non positioned

        for context in child_contexts:
            if context.z_index < 0:
                self.negative_z_contexts.append(context)
            elif context.z_index == 0:
                self.zero_z_contexts.append(context)
            else:  # context.z_index > 0
                self.positive_z_contexts.append(context)
        self.negative_z_contexts.sort(key=lambda context: context.z_index)
        self.positive_z_contexts.sort(key=lambda context: context.z_index)
        # sort() is stable, so the lists are now storted
        # by z-index, then tree order.

        self.z_index = box.style['z_index']
        if self.z_index == 'auto':
            self.z_index = 0

    @classmethod
    def from_page(cls, page):
        # Page children (the box for the root element and margin boxes)
        # as well as the page box itself are unconditionally stacking contexts.
        child_contexts = [cls.from_box(child, page) for child in page.children]
        # Children are sub-contexts, remove them from the "normal" tree.
        page = page.copy_with_children([])
        return cls(page, child_contexts, [], [], {}, page)

    @classmethod
    def from_box(cls, box, page, child_contexts=None):
        children = []  # What will be passed to this box
        if child_contexts is None:
            child_contexts = children
        # child_contexts: where to put sub-contexts that we find here.
        # May not be the same as children for:
        #   "treat the element as if it created a new stacking context, but any
        #    positioned descendants and descendants which actually create a new
        #    stacking context should be considered part of the parent stacking
        #    context, not this new one."
        blocks = []
        floats = []
        blocks_and_cells = {}
        box = _dispatch_children(
            box, page, child_contexts, blocks, floats, blocks_and_cells)
        return cls(box, children, blocks, floats, blocks_and_cells, page)


def _dispatch(box, page, child_contexts, blocks, floats, blocks_and_cells):
    if isinstance(box, AbsolutePlaceholder):
        box = box._box
    style = box.style

    # Remove boxes defining a new stacking context from the children list.
    defines_stacking_context = (
        (style['position'] != 'static' and style['z_index'] != 'auto') or
        (box.is_grid_item and style['z_index'] != 'auto') or
        style['opacity'] < 1 or
        style['transform'] or  # 'transform: none' gives a "falsy" empty list
        style['overflow'] != 'visible')
    if defines_stacking_context:
        child_contexts.append(StackingContext.from_box(box, page))
        return

    stacking_classes = (boxes.InlineBlockBox, boxes.InlineFlexBox, boxes.InlineGridBox)
    if style['position'] != 'static':
        assert style['z_index'] == 'auto'
        # "Fake" context: sub-contexts will go in this `child_contexts` list.
        # Insert at the position before creating the sub-context.
        index = len(child_contexts)
        stacking_context = StackingContext.from_box(box, page, child_contexts)
        child_contexts.insert(index, stacking_context)
    elif box.is_floated():
        floats.append(StackingContext.from_box(box, page, child_contexts))
    elif isinstance(box, stacking_classes):
        # Have this fake stacking context be part of the "normal" box tree,
        # because we need its position in the middle of a tree of inline boxes.
        return StackingContext.from_box(box, page, child_contexts)
    else:
        if isinstance(box, boxes.BlockLevelBox):
            blocks_index = len(blocks)
            box_blocks_and_cells = {}
            box = _dispatch_children(
                box, page, child_contexts, blocks, floats, box_blocks_and_cells)
            blocks.insert(blocks_index, box)
            blocks_and_cells[box] = box_blocks_and_cells
        elif isinstance(box, boxes.TableCellBox):
            box_blocks_and_cells = {}
            box = _dispatch_children(
                box, page, child_contexts, blocks, floats, box_blocks_and_cells)
            blocks_and_cells[box] = box_blocks_and_cells
        else:
            blocks_index = None
            box_blocks_and_cells = None
            box = _dispatch_children(
                box, page, child_contexts, blocks, floats, blocks_and_cells)

        return box


def _dispatch_children(box, page, child_contexts, blocks, floats,
                       blocks_and_cells):
    if not isinstance(box, boxes.ParentBox):
        return box

    new_children = []
    for child in box.children:
        result = _dispatch(
            child, page, child_contexts, blocks, floats, blocks_and_cells)
        if result is not None:
            new_children.append(result)
    return box.copy_with_children(new_children)


================================================
FILE: weasyprint/svg/__init__.py
================================================
"""Render SVG images."""

import re
from contextlib import suppress
from math import cos, hypot, pi, radians, sin, sqrt
from xml.etree import ElementTree

from cssselect2 import ElementWrapper

from ..urls import get_url_attribute
from .css import parse_declarations, parse_stylesheets
from .defs import apply_filters, draw_gradient_or_pattern, paint_mask, use
from .images import image, svg
from .path import path
from .shapes import circle, ellipse, line, polygon, polyline, rect
from .text import text

from .bounding_box import (  # isort:skip
    EMPTY_BOUNDING_BOX, bounding_box, extend_bounding_box, is_valid_bounding_box)
from .utils import (  # isort:skip
    PointError, alpha_value, color, normalize, parse_url, preserve_ratio, size,
    transform)

TAGS = {
    'a': text,
    'circle': circle,
    'ellipse': ellipse,
    'image': image,
    'line': line,
    'path': path,
    'polyline': polyline,
    'polygon': polygon,
    'rect': rect,
    'svg': svg,
    'text': text,
    'textPath': text,
    'tspan': text,
    'use': use,
}

NOT_INHERITED_ATTRIBUTES = frozenset((
    'clip',
    'clip-path',
    'filter',
    'height',
    'id',
    'mask',
    'opacity',
    'overflow',
    'rotate',
    'stop-color',
    'stop-opacity',
    'style',
    'transform',
    'transform-origin',
    'viewBox',
    'width',
    'x',
    'y',
    'dx',
    'dy',
    '{http://www.w3.org/1999/xlink}href',
    'href',
))

COLOR_ATTRIBUTES = frozenset((
    'fill',
    'flood-color',
    'lighting-color',
    'stop-color',
    'stroke',
))

DEF_TYPES = frozenset((
    'clipPath',
    'filter',
    'gradient',
    'image',
    'marker',
    'mask',
    'path',
    'pattern',
    'symbol',
))


class Node:
    """An SVG document node."""

    def __init__(self, wrapper, style):
        self._wrapper = wrapper
        self._etree_node = wrapper.etree_element
        self._style = style
        self._children = None

        self.attrib = wrapper.etree_element.attrib.copy()

        self.vertices = []
        self.bounding_box = None

    def copy(self):
        """Create a deep copy of the node as it was when first created."""
        return Node(self._wrapper, self._style)

    def get(self, key, default=None):
        """Get attribute."""
        return self.attrib.get(key, default)

    @property
    def tag(self):
        """XML tag name with no namespace."""
        return self._etree_node.tag.split('}', 1)[-1]

    @property
    def text(self):
        """XML node text."""
        return self._etree_node.text

    @property
    def tail(self):
        """Text after the XML node."""
        return self._etree_node.tail

    @property
    def display(self):
        """Whether node should be displayed."""
        return self.get('display') != 'none'

    @property
    def visible(self):
        """Whether node is visible."""
        return self.display and self.get('visibility') != 'hidden'

    def cascade(self, child):
        """Apply CSS cascade and other related operations to given child."""
        wrapper = child._wrapper

        # Cascade
        for key, value in self.attrib.items():
            if key not in NOT_INHERITED_ATTRIBUTES:
                if key not in child.attrib:
                    child.attrib[key] = value

        # Apply style attribute
        if style_attr := child.get('style'):
            normal_attr, important_attr = parse_declarations(style_attr)
        else:
            normal_attr, important_attr = [], []
        normal_matcher, important_matcher = self._style
        normal = [rule[-1] for rule in normal_matcher.match(wrapper)]
        important = [rule[-1] for rule in important_matcher.match(wrapper)]
        for declarations_list in (normal, [normal_attr], important, [important_attr]):
            for declarations in declarations_list:
                for name, value in declarations:
                    child.attrib[name] = value.strip()

        # Expand
        # TODO: simplified expanders, use CSS expander code instead.
        if font := child.attrib.pop('font', None):
            parts = font.strip().split(maxsplit=1)
            if len(parts) == 2:
                child.attrib['font-size'] = parts[0]
                child.attrib['font-family'] = parts[1]

        # Replace 'currentColor' value
        for key in COLOR_ATTRIBUTES:
            if child.get(key) == 'currentColor':
                child.attrib[key] = child.get('color', 'black')

        # Handle 'inherit' values
        for key, value in child.attrib.copy().items():
            if value == 'inherit':
                value = self.get(key)
                if value is None:
                    del child.attrib[key]
                else:
                    child.attrib[key] = value

        # Fix text in text tags
        if child.tag in ('text', 'textPath', 'a'):
            children, _ = child.text_children(
                wrapper, trailing_space=True, text_root=True)
            child._wrapper.etree_children = [
                child._etree_node for child in children]

    def __iter__(self):
        """Yield node children, handling cascade."""
        if self._children is None:
            children = []
            for wrapper in self._wrapper:
                child = Node(wrapper, self._style)
                self.cascade(child)
                children.append(child)
            self._children = children
        return iter(self._children)

    def get_viewbox(self):
        """Get node viewBox as a tuple of floats."""
        viewbox = self.get('viewBox')
        if viewbox:
            return tuple(float(number) for number in normalize(viewbox).split())

    def get_href(self, base_url):
        """Get the href attribute, with or without a namespace."""
        for attr_name in ('{http://www.w3.org/1999/xlink}href', 'href'):
            if url := get_url_attribute(self, attr_name, base_url, allow_relative=True):
                return url

    def del_href(self):
        """Remove the href attributes, with or without a namespace."""
        for attr_name in ('{http://www.w3.org/1999/xlink}href', 'href'):
            self.attrib.pop(attr_name, None)

    @staticmethod
    def process_whitespace(string, preserve):
        """Replace newlines by spaces, and merge spaces if not preserved."""
        # TODO: should be merged with build.process_whitespace
        if not string:
            return ''
        if preserve:
            return re.sub('[\n\r\t]', ' ', string)
        else:
            string = re.sub('[\n\r]', '', string)
            string = string.replace('\t', ' ')
            return re.sub(' +', ' ', string)

    def get_child(self, id_):
        """Get a child with given id in the whole child tree."""
        if self._etree_node.find(f'.//*[@id="{id_}"]') is None:
            return
        for child in self:
            if child.get('id') == id_:
                return child
            grandchild = child.get_child(id_)
            if grandchild:
                return grandchild

    def text_children(self, element, trailing_space, text_root=False):
        """Handle text node by fixing whitespaces and flattening tails."""
        children = []
        space = '{http://www.w3.org/XML/1998/namespace}space'
        preserve = self.get(space) == 'preserve'
        self._etree_node.text = self.process_whitespace(
            element.etree_element.text, preserve)
        if trailing_space and not preserve:
            self._etree_node.text = self.text.lstrip(' ')

        original_rotate = [
            float(i) for i in
            normalize(self.get('rotate')).strip().split(' ') if i]
        rotate = original_rotate.copy()
        if original_rotate:
            self.pop_rotation(original_rotate, rotate)
        if self.text:
            trailing_space = self.text.endswith(' ')
        element_children = tuple(element.iter_children())
        for child_element in element_children:
            child = child_element.etree_element
            if child.tag in ('{http://www.w3.org/2000/svg}tref', 'tref'):
                child_node = Node(child_element, self._style)
                child_node._etree_node.tag = 'tspan'
                # Retrieve the referenced node and get its flattened text
                # and remove the node children.
                child = child_node._etree_node
                child._etree_node.text = child.flatten()
                child_element = ElementWrapper.from_xml_root(child)
            else:
                child_node = Node(child_element, self._style)
            child_preserve = child_node.get(space) == 'preserve'
            child_node._etree_node.text = self.process_whitespace(
                child.text, child_preserve)
            child_node.children, trailing_space = child_node.text_children(
                child_element, trailing_space)
            trailing_space = child_node.text.endswith(' ')
            if original_rotate and 'rotate' not in child_node:
                child_node.pop_rotation(original_rotate, rotate)
            children.append(child_node)
            tail = self.process_whitespace(child.tail, preserve)
            if text_root and child_element is element_children[-1]:
                if not preserve:
                    tail = tail.rstrip(' ')
            if tail:
                anonymous_etree = ElementTree.Element(
                    '{http://www.w3.org/2000/svg}tspan')
                anonymous = Node(
                    ElementWrapper.from_xml_root(anonymous_etree), self._style)
                anonymous._etree_node.text = tail
                if original_rotate:
                    anonymous.pop_rotation(original_rotate, rotate)
                if trailing_space and not preserve:
                    anonymous._etree_node.text = anonymous.text.lstrip(' ')
                if anonymous.text:
                    trailing_space = anonymous.text.endswith(' ')
                children.append(anonymous)

        if text_root and not children and not preserve:
            self._etree_node.text = self.text.rstrip(' ')

        return children, trailing_space

    def flatten(self):
        """Flatten text in node and in its children."""
        flattened_text = [self.text or '']
        for child in list(self):
            flattened_text.append(child.flatten())
            flattened_text.append(child.tail or '')
            self.remove(child)
        return ''.join(flattened_text)

    def pop_rotation(self, original_rotate, rotate):
        """Merge nested letter rotations."""
        self.attrib['rotate'] = ' '.join(
            str(rotate.pop(0) if rotate else original_rotate[-1])
            for i in range(len(self.text)))

    def override_iter(self, iterator):
        """Override node’s children iterator."""
        # As special methods are bound to classes and not instances, we have to
        # create and assign a new type.
        self.__class__ = type(
            'Node', (Node,), {'__iter__': lambda _: iterator})

    def set_svg_size(self, svg, concrete_width, concrete_height):
        """"Set SVG concrete and inner widths and heights from svg node."""
        svg.concrete_width = concrete_width
        svg.concrete_height = concrete_height
        svg.normalized_diagonal = hypot(concrete_width, concrete_height) / sqrt(2)

        if viewbox := self.get_viewbox():
            svg.inner_width, svg.inner_height = viewbox[2], viewbox[3]
        else:
            svg.inner_width, svg.inner_height = svg.concrete_width, svg.concrete_height
        svg.inner_diagonal = hypot(svg.inner_width, svg.inner_height) / sqrt(2)


class LazyDefs:
    def __init__(self, name, svg):
        self._name = name
        self._svg = svg
        self._data = {}

    def __getitem__(self, name):
        return self.get(name)

    def get(self, name):
        if not name:
            return
        if name in self._data:
            return self._data[name]
        node = self._svg.tree.get_child(name)
        if node is not None and self._name in node.tag.lower():
            self._data[name] = node
            if self._name in ('gradient', 'pattern'):
                self._svg.inherit_element(node, self)
        else:
            self._data[name] = None
        return self._data[name]

    def __contains__(self, name):
        return self.get(name)


class SVG:
    """An SVG document."""

    def __init__(self, tree, url, font_config, url_fetcher=None):
        wrapper = ElementWrapper.from_xml_root(tree)
        style = parse_stylesheets(wrapper, url, font_config, url_fetcher)
        self.tree = Node(wrapper, style)
        self.font_config = font_config
        self.url_fetcher = url_fetcher
        self.url = url

        self.filters = LazyDefs('filter', self)
        self.gradients = LazyDefs('gradient', self)
        self.images = LazyDefs('image', self)
        self.markers = LazyDefs('marker', self)
        self.masks = LazyDefs('mask', self)
        self.patterns = LazyDefs('pattern', self)
        self.paths = LazyDefs('path', self)
        self.symbols = LazyDefs('symbol', self)

        self.use_cache = {}

        self.cursor_position = [0, 0]
        self.cursor_d_position = [0, 0]
        self.text_path_width = 0

        self.tree.cascade(self.tree)

    def get_intrinsic_size(self, font_size):
        """Get intrinsic size of the image."""
        intrinsic_width = self.tree.get('width', '100%')
        if '%' in intrinsic_width:
            intrinsic_width = None
        else:
            intrinsic_width = size(intrinsic_width, font_size)

        intrinsic_height = self.tree.get('height', '100%')
        if '%' in intrinsic_height:
            intrinsic_height = None
        else:
            intrinsic_height = size(intrinsic_height, font_size)

        return intrinsic_width, intrinsic_height

    def get_viewbox(self):
        """Get document viewBox as a tuple of floats."""
        return self.tree.get_viewbox()

    def point(self, x, y, font_size):
        """Compute size of an x/y or width/height couple."""
        return (
            size(x, font_size, self.inner_width),
            size(y, font_size, self.inner_height))

    def length(self, length, font_size):
        """Compute size of an arbirtary attribute."""
        return size(length, font_size, self.inner_diagonal)

    def draw(self, stream, concrete_width, concrete_height, base_url, context):
        """Draw image on a stream."""
        self.stream = stream

        self.tree.set_svg_size(self, concrete_width, concrete_height)

        self.base_url = base_url
        self.context = context

        self.draw_node(self.tree, size('12pt'))

    def draw_node(self, node, font_size, fill_stroke=True):
        """Draw a node."""
        if node.tag == 'defs':
            return

        # Update font size
        font_size = size(node.get('font-size', '1em'), font_size, font_size)

        original_streams = []

        call_fill_stroke = fill_stroke and node.tag in (
            'circle', 'ellipse', 'line', 'path', 'polyline', 'polygon', 'rect')

        if fill_stroke:
            self.stream.push_state()

        # Apply filters
        filter_ = self.filters.get(parse_url(node.get('filter')).fragment)
        if filter_:
            apply_filters(self, node, filter_, font_size)

        # Apply transform attribute
        self.transform(node, font_size)

        # Create substream for opacity
        opacity = alpha_value(node.get('opacity', 1))
        if fill_stroke and 0 <= opacity < 1:
            original_streams.append(self.stream)
            self.stream = self.stream.add_group(0, 0, 0, 0)  # BBox set after drawing

        # Set graphical state
        if call_fill_stroke:
            self.set_graphical_state(node, font_size)

        # Clip
        clip_path = parse_url(node.get('clip-path')).fragment
        if clip_path and clip_path in self.paths:
            old_ctm = self.stream.ctm
            clip_path = self.paths[clip_path]
            if clip_path.get('clipPathUnits') == 'objectBoundingBox':
                x, y = self.point(node.get('x'), node.get('y'), font_size)
                width, height = self.point(
                    node.get('width'), node.get('height'), font_size)
                self.stream.transform(a=width, d=height, e=x, f=y)
            original_tag = clip_path._etree_node.tag
            clip_path._etree_node.tag = 'g'
            self.draw_node(clip_path, font_size, fill_stroke=False)
            clip_path._etree_node.tag = original_tag
            # At least set the clipping area to an empty path, so that it’s
            # totally clipped when the clipping path is empty.
            self.stream.rectangle(0, 0, 0, 0)
            self.stream.clip()
            self.stream.end()
            new_ctm = self.stream.ctm
            if new_ctm.determinant:
                self.stream.transform(*(old_ctm @ new_ctm.invert).values)

        # Handle text anchor and set text bounding box
        text_anchor_shift = False
        if node.display and TAGS.get(node.tag) == text:
            if (text_anchor := node.get('text-anchor')) in ('middle', 'end'):
                text_anchor_shift = True
                group = self.stream.add_group(0, 0, 0, 0)  # BBox set after drawing
                original_streams.append(self.stream)
                self.stream = group
            node.text_bounding_box = EMPTY_BOUNDING_BOX

        # Save concrete size of root svg tag
        if node.tag == 'svg':
            concrete_width = self.concrete_width
            concrete_height = self.concrete_height

        # Draw node
        if node.visible and node.tag in TAGS:
            with suppress(PointError):
                TAGS[node.tag](self, node, font_size)

        # Draw node children
        if node.display and node.tag not in DEF_TYPES:
            for child in node:
                new_chunk = text_anchor_shift and (
                    child.tag == 'text' or 'x' in child.attrib or 'y' in child.attrib)
                if new_chunk:
                    new_stream = self.stream
                    self.stream = original_streams[-1]
                self.draw_node(child, font_size, fill_stroke)
                if new_chunk:
                    self.stream = new_stream
                visible_text_child = (
                    TAGS.get(node.tag) == text and
                    TAGS.get(child.tag) == text and
                    child.visible)
                if visible_text_child:
                    if not is_valid_bounding_box(child.text_bounding_box):
                        continue
                    x1, y1 = child.text_bounding_box[:2]
                    x2 = x1 + child.text_bounding_box[2]
                    y2 = y1 + child.text_bounding_box[3]
                    node.text_bounding_box = extend_bounding_box(
                        node.text_bounding_box, ((x1, y1), (x2, y2)))

        # Restore concrete and inner size of root svg tag
        if node.tag == 'svg':
            self.tree.set_svg_size(svg, concrete_width, concrete_height)

        # Handle text anchor
        if text_anchor_shift:
            group_id = self.stream.id
            self.stream = original_streams.pop()
            self.stream.push_state()
            if is_valid_bounding_box(node.text_bounding_box):
                x, y, width, height = node.text_bounding_box
                # Add extra space to include ink extents
                group.extra['BBox'][:] = (
                    x - font_size, y - font_size,
                    x + width + font_size, y + height + font_size)
                x_align = width / 2 if text_anchor == 'middle' else width
                if node.tag == 'text' or 'x' in node.attrib or 'y' in node.attrib:
                    self.stream.transform(e=-x_align)
            self.stream.draw_x_object(group_id)
            self.stream.pop_state()

        # Apply mask
        mask = self.masks.get(parse_url(node.get('mask')).fragment)
        if mask:
            paint_mask(self, node, mask, opacity)

        # Fill and stroke
        if call_fill_stroke:
            self.fill_stroke(node, font_size)

        # Draw markers
        self.draw_markers(node, font_size, fill_stroke)

        # Apply opacity stream and restore original stream
        if fill_stroke and 0 <= opacity < 1:
            box = self.calculate_bounding_box(node, font_size)
            if not is_valid_bounding_box(box):
                box = (0, 0, self.inner_width, self.inner_height)
            x, y, width, height = box
            self.stream.extra['BBox'][:] = x, y, x + width, y + height

            group_id = self.stream.id
            self.stream = original_streams.pop()
            self.stream.set_alpha(opacity, stroke=True, fill=True)
            self.stream.draw_x_object(group_id)

        # Clean text tag
        if node.tag == 'text':
            self.cursor_position = [0, 0]
            self.cursor_d_position = [0, 0]
            self.text_path_width = 0

        if fill_stroke:
            self.stream.pop_state()

    def draw_markers(self, node, font_size, fill_stroke):
        """Draw markers defined in a node."""
        if not node.vertices:
            return

        markers = {}
        common_marker = parse_url(node.get('marker')).fragment
        for position in ('start', 'mid', 'end'):
            attribute = f'marker-{position}'
            if attribute in node.attrib:
                markers[position] = parse_url(node.attrib[attribute]).fragment
            else:
                markers[position] = common_marker

        angle1, angle2 = None, None
        position = 'start'

        while node.vertices:
            # Calculate position and angle
            point = node.vertices.pop(0)
            angles = node.vertices.pop(0) if node.vertices else None
            if angles:
                if position == 'start':
                    angle = pi - angles[0]
                else:
                    angle = (angle2 + pi - angles[0]) / 2
                angle1, angle2 = angles
            else:
                angle = angle2
                position = 'end'

            # Draw marker
            if not (marker_node := self.markers.get(markers[position])):
                position = 'mid' if angles else 'start'
                continue

            # Calculate position, scale and clipping
            translate_x, translate_y = self.point(
                marker_node.get('refX'), marker_node.get('refY'),
                font_size)
            marker_width, marker_height = self.point(
                marker_node.get('markerWidth', 3),
                marker_node.get('markerHeight', 3),
                font_size)
            if 'viewBox' in marker_node.attrib:
                scale_x, scale_y, _, _ = preserve_ratio(
                    self, marker_node, font_size, marker_width, marker_height)

                clip_x, clip_y, viewbox_width, viewbox_height = (
                    marker_node.get_viewbox())

                align = marker_node.get(
                    'preserveAspectRatio', 'xMidYMid').split(' ')[0]
                if align == 'none':
                    x_position = y_position = 'min'
                else:
                    x_position = align[1:4].lower()
                    y_position = align[5:].lower()

                if x_position == 'mid':
                    clip_x += (viewbox_width - marker_width / scale_x) / 2
                elif x_position == 'max':
                    clip_x += viewbox_width - marker_width / scale_x

                if y_position == 'mid':
                    clip_y += (
                        viewbox_height - marker_height / scale_y) / 2
                elif y_position == 'max':
                    clip_y += viewbox_height - marker_height / scale_y

                clip_box = (
                    clip_x, clip_y,
                    marker_width / scale_x, marker_height / scale_y)
            else:
                scale_x = scale_y = 1
                clip_box = (0, 0, marker_width, marker_height)

            # Scale
            if marker_node.get('markerUnits') != 'userSpaceOnUse':
                scale = self.length(node.get('stroke-width', 1), font_size)
                scale_x *= scale
                scale_y *= scale

            # Override angle
            node_angle = marker_node.get('orient', 0)
            if node_angle not in ('auto', 'auto-start-reverse'):
                angle = radians(float(node_angle))
            elif node_angle == 'auto-start-reverse' and position == 'start':
                angle += radians(180)

            # Draw marker path
            for child in marker_node:
                self.stream.push_state()

                self.stream.transform(
                    scale_x * cos(angle), scale_x * sin(angle),
                    -scale_y * sin(angle), scale_y * cos(angle),
                    *point)
                self.stream.transform(e=-translate_x, f=-translate_y)

                overflow = marker_node.get('overflow', 'hidden')
                if overflow in ('hidden', 'scroll'):
                    self.stream.rectangle(*clip_box)
                    self.stream.clip()
                    self.stream.end()

                self.draw_node(child, font_size, fill_stroke)
                self.stream.pop_state()

            position = 'mid' if angles else 'start'

    @staticmethod
    def get_paint(value):
        """Get paint fill or stroke attribute with a color or a URL."""
        if not value or value == 'none':
            return None, None

        value = value.strip()
        match = re.compile(r'(url\(.+\)) *(.*)').search(value)
        if match:
            source = parse_url(match.group(1)).fragment
            color = match.group(2) or None
        else:
            source = None
            color = value or None

        return source, color

    def set_graphical_state(self, node, font_size, text=False):
        """Set stroke and fill colors, and line options."""
        # Get fill data
        fill_source, fill_color = self.get_paint(node.get('fill', 'black'))
        fill_opacity = alpha_value(node.get('fill-opacity', 1))
        fill_in_gradient = fill_source in self.gradients
        fill_in_pattern = fill_source in self.patterns
        if fill_color and not (fill_in_gradient or fill_in_pattern):
            stream_color = color(fill_color)
            stream_color.alpha *= fill_opacity
            self.stream.set_color(stream_color)

        # Get stroke data
        stroke_source, stroke_color = self.get_paint(node.get('stroke'))
        stroke_opacity = alpha_value(node.get('stroke-opacity', 1))
        stroke_in_gradient = stroke_source in self.gradients
        stroke_in_pattern = stroke_source in self.patterns
        if stroke_color and not (stroke_in_gradient or stroke_in_pattern):
            stream_color = color(stroke_color)
            stream_color.alpha *= stroke_opacity
            self.stream.set_color(stream_color, stroke=True)
        stroke_width = self.length(node.get('stroke-width', '1px'), font_size)
        if stroke_width:
            self.stream.set_line_width(stroke_width)

        # Apply dash array
        dash_array = tuple(
            self.length(value, font_size) for value in
            normalize(node.get('stroke-dasharray')).split() if value != 'none')
        dash_condition = (
            dash_array and
            not all(value == 0 for value in dash_array) and
            not any(value < 0 for value in dash_array))
        if dash_condition:
            offset = self.length(node.get('stroke-dashoffset'), font_size)
            if offset < 0:
                sum_dashes = sum(float(value) for value in dash_array)
                offset = sum_dashes - abs(offset) % sum_dashes
            self.stream.set_dash(dash_array, offset)

        # Apply line cap
        line_cap = node.get('stroke-linecap', 'butt')
        if line_cap == 'round':
            line_cap = 1
        elif line_cap == 'square':
            line_cap = 2
        else:
            line_cap = 0
        self.stream.set_line_cap(line_cap)

        # Apply line join
        line_join = node.get('stroke-linejoin', 'miter')
        if line_join == 'round':
            line_join = 1
        elif line_join == 'bevel':
            line_join = 2
        else:
            line_join = 0
        self.stream.set_line_join(line_join)

        # Apply miter limit
        miter_limit = float(node.get('stroke-miterlimit', 4))
        if miter_limit < 0:
            miter_limit = 4
        self.stream.set_miter_limit(miter_limit)

    def fill_stroke(self, node, font_size, text=False):
        """Paint fill and stroke for a node."""
        # Get fill data
        fill_source, fill_color = self.get_paint(node.get('fill', 'black'))
        fill_opacity = alpha_value(node.get('fill-opacity', 1))
        fill_drawn = draw_gradient_or_pattern(
            self, node, fill_source, font_size, fill_opacity, stroke=False)
        fill = fill_color or fill_drawn

        # Get stroke data
        stroke_source, stroke_color = self.get_paint(node.get('stroke'))
        stroke_opacity = alpha_value(node.get('stroke-opacity', 1))
        stroke_drawn = draw_gradient_or_pattern(
            self, node, stroke_source, font_size, stroke_opacity, stroke=True)
        stroke_width = self.length(node.get('stroke-width', '1px'), font_size)
        stroke = (stroke_color or stroke_drawn) and stroke_width

        # Fill and stroke
        even_odd = node.get('fill-rule') == 'evenodd'
        if text:
            if stroke and fill:
                text_rendering = 2
            elif stroke:
                text_rendering = 1
            elif fill:
                text_rendering = 0
            else:
                text_rendering = 3
            self.stream.set_text_rendering(text_rendering)
        else:
            if fill and stroke:
                self.stream.fill_and_stroke(even_odd)
            elif stroke:
                self.stream.stroke()
            elif fill:
                self.stream.fill(even_odd)
            else:
                self.stream.end()

    def transform(self, node, font_size):
        """Apply a transformation string to the node."""
        transform_origin = node.get('transform-origin')
        transform_string = node.get('transform')
        if not transform_string:
            return

        matrix = transform(
            transform_string, transform_origin, font_size, self.inner_diagonal)
        if matrix.determinant:
            self.stream.transform(*matrix.values)

    def inherit_element(self, element, defs):
        """Recursively handle inheritance of defined element."""
        href = element.get_href(self.url)
        if not href:
            return
        element.del_href()
        parent = defs.get(parse_url(href).fragment)
        if not parent:
            return
        self.inherit_element(parent, defs)
        for key, value in parent.attrib.items():
            if key not in element.attrib:
                element.attrib[key] = value
        if next(iter(element), None) is None:
            element.override_iter(parent.__iter__())

    def calculate_bounding_box(self, node, font_size, stroke=True):
        """Calculate the bounding box of a node."""
        if stroke or node.bounding_box is None:
            box = bounding_box(self, node, font_size, stroke)
            if is_valid_bounding_box(box) and 0 not in box[2:]:
                if stroke:
                    return box
                node.bounding_box = box
        return node.bounding_box


class Pattern(SVG):
    """SVG node applied as a pattern."""
    def __init__(self, tree, svg):
        super().__init__(tree._etree_node, svg.url, svg.font_config, svg.url_fetcher)
        self.svg = svg
        self.tree = tree

    def draw_node(self, node, font_size, fill_stroke=True):
        # Store the original tree in self.tree when calling draw(), so that we
        # can reach defs outside the pattern
        if node == self.tree:
            self.tree = self.svg.tree
        super().draw_node(node, font_size, fill_stroke=True)


================================================
FILE: weasyprint/svg/bounding_box.py
================================================
"""Calculate bounding boxes of SVG tags."""

from math import atan, atan2, cos, inf, isinf, pi, radians, sin, sqrt, tan

from .path import PATH_LETTERS
from .utils import normalize, point

EMPTY_BOUNDING_BOX = inf, inf, 0, 0


def bounding_box(svg, node, font_size, stroke):
    """Bounding box for any node."""
    if node.tag not in BOUNDING_BOX_METHODS:
        return EMPTY_BOUNDING_BOX
    box = BOUNDING_BOX_METHODS[node.tag](svg, node, font_size)
    if not is_valid_bounding_box(box):
        return EMPTY_BOUNDING_BOX
    if stroke and node.tag != 'g' and any(svg.get_paint(node.get('stroke'))):
        stroke_width = svg.length(node.get('stroke-width', '1px'), font_size)
        box = (
            box[0] - stroke_width / 2, box[1] - stroke_width / 2,
            box[2] + stroke_width, box[3] + stroke_width)
    return box


def bounding_box_rect(svg, node, font_size):
    """Bounding box for rect node."""
    x, y = svg.point(node.get('x'), node.get('y'), font_size)
    width, height = svg.point(
        node.get('width'), node.get('height'), font_size)
    return x, y, width, height


def bounding_box_circle(svg, node, font_size):
    """Bounding box for circle node."""
    cx, cy = svg.point(node.get('cx'), node.get('cy'), font_size)
    r = svg.length(node.get('r'), font_size)
    return cx - r, cy - r, 2 * r, 2 * r


def bounding_box_ellipse(svg, node, font_size):
    """Bounding box for ellipse node."""
    rx, ry = svg.point(node.get('rx'), node.get('ry'), font_size)
    cx, cy = svg.point(node.get('cx'), node.get('cy'), font_size)
    return cx - rx, cy - ry, 2 * rx, 2 * ry


def bounding_box_line(svg, node, font_size):
    """Bounding box for line node."""
    x1, y1 = svg.point(node.get('x1'), node.get('y1'), font_size)
    x2, y2 = svg.point(node.get('x2'), node.get('y2'), font_size)
    x, y = min(x1, x2), min(y1, y2)
    width, height = max(x1, x2) - x, max(y1, y2) - y
    return x, y, width, height


def bounding_box_polyline(svg, node, font_size):
    """Bounding box for polyline node."""
    bounding_box = EMPTY_BOUNDING_BOX
    points = []
    normalized_points = normalize(node.get('points', ''))
    while normalized_points:
        x, y, normalized_points = point(svg, normalized_points, font_size)
        points.append((x, y))
    return extend_bounding_box(bounding_box, points)


def bounding_box_path(svg, node, font_size):
    """Bounding box for path node."""
    path_data = node.get('d', '')

    # Normalize path data for correct parsing
    for letter in PATH_LETTERS:
        path_data = path_data.replace(letter, f' {letter} ')
    path_data = normalize(path_data)

    bounding_box = EMPTY_BOUNDING_BOX
    previous_x = 0
    previous_y = 0
    letter = 'M'    # Move as default
    while path_data:
        path_data = path_data.strip()
        if path_data.split(' ', 1)[0] in PATH_LETTERS:
            letter, path_data = (f'{path_data} ').split(' ', 1)

        if letter in 'aA':
            # Elliptical arc curve
            rx, ry, path_data = point(svg, path_data, font_size)
            rotation, path_data = path_data.split(' ', 1)
            rotation = radians(float(rotation))

            # The large and sweep values are not always separated from the
            # following values, here is the crazy parser
            large, path_data = path_data[0], path_data[1:].strip()
            while not large[-1].isdigit():
                large, path_data = large + path_data[0], path_data[1:].strip()
            sweep, path_data = path_data[0], path_data[1:].strip()
            while not sweep[-1].isdigit():
                sweep, path_data = sweep + path_data[0], path_data[1:].strip()

            large, sweep = bool(int(large)), bool(int(sweep))

            x, y, path_data = point(svg, path_data, font_size)

            # Relative coordinate, convert to absolute
            if letter == 'a':
                x += previous_x
                y += previous_y

            # Extend bounding box with start and end coordinates
            arc_bounding_box = _bounding_box_elliptical_arc(
                previous_x, previous_y, rx, ry, rotation, large, sweep, x, y)
            x1, y1, width, height = arc_bounding_box
            x2 = x1 + width
            y2 = y1 + height
            points = (x1, y1), (x2, y2)
            bounding_box = extend_bounding_box(bounding_box, points)
            previous_x = x
            previous_y = y

        elif letter in 'cC':
            # Curve
            x1, y1, path_data = point(svg, path_data, font_size)
            x2, y2, path_data = point(svg, path_data, font_size)
            x, y, path_data = point(svg, path_data, font_size)

            # Relative coordinates, convert to absolute
            if letter == 'c':
                x1 += previous_x
                y1 += previous_y
                x2 += previous_x
                y2 += previous_y
                x += previous_x
                y += previous_y

            # Extend bounding box with all coordinates
            bounding_box = extend_bounding_box(
                bounding_box, ((x1, y1), (x2, y2), (x, y)))
            previous_x = x
            previous_y = y

        elif letter in 'hH':
            # Horizontal line
            x, path_data = (f'{path_data} ').split(' ', 1)
            x, _ = svg.point(x, 0, font_size)

            # Relative coordinate, convert to absolute
            if letter == 'h':
                x += previous_x

            # Extend bounding box with coordinate
            bounding_box = extend_bounding_box(
                bounding_box, ((x, previous_y),))
            previous_x = x

        elif letter in 'lLmMtT':
            # Line/Move/Smooth quadratic curve
            x, y, path_data = point(svg, path_data, font_size)

            # Relative coordinate, convert to absolute
            if letter in 'lmt':
                x += previous_x
                y += previous_y

            # Extend bounding box with coordinate
            bounding_box = extend_bounding_box(bounding_box, ((x, y),))
            previous_x = x
            previous_y = y

        elif letter in 'qQsS':
            # Quadratic curve/Smooth curve
            x1, y1, path_data = point(svg, path_data, font_size)
            x, y, path_data = point(svg, path_data, font_size)

            # Relative coordinates, convert to absolute
            if letter in 'qs':
                x1 += previous_x
                y1 += previous_y
                x += previous_x
                y += previous_y

            # Extend bounding box with coordinates
            bounding_box = extend_bounding_box(
                bounding_box, ((x1, y1), (x, y)))
            previous_x = x
            previous_y = y

        elif letter in 'vV':
            # Vertical line
            y, path_data = (f'{path_data} ').split(' ', 1)
            _, y = svg.point(0, y, font_size)

            # Relative coordinate, convert to absolute
            if letter == 'v':
                y += previous_y

            # Extend bounding box with coordinate
            bounding_box = extend_bounding_box(
                bounding_box, ((previous_x, y),))
            previous_y = y

        path_data = path_data.strip()

    return bounding_box


def bounding_box_text(svg, node, font_size):
    """Bounding box for text node."""
    return getattr(node, 'text_bounding_box', None)


def bounding_box_g(svg, node, font_size):
    """Bounding box for g node."""
    bounding_box = EMPTY_BOUNDING_BOX
    for child in node:
        child_bounding_box = svg.calculate_bounding_box(child, font_size)
        if is_valid_bounding_box(child_bounding_box):
            minx, miny, width, height = child_bounding_box
            maxx, maxy = minx + width, miny + height
            bounding_box = extend_bounding_box(
                bounding_box, ((minx, miny), (maxx, maxy)))
    return bounding_box


def bounding_box_use(svg, node, font_size):
    """Bounding box for use node."""
    from .defs import get_use_tree

    if (tree := get_use_tree(svg, node, font_size)) is None:
        return EMPTY_BOUNDING_BOX
    else:
        x, y = svg.point(node.get('x'), node.get('y'), font_size)
        box = bounding_box(svg, tree, font_size, True)
        return box[0] + x, box[1] + y, box[2], box[3]


def _bounding_box_elliptical_arc(x1, y1, rx, ry, phi, large, sweep, x, y):
    """Bounding box of an elliptical arc in path node."""
    rx, ry = abs(rx), abs(ry)
    if 0 in (rx, ry):
        return min(x, x1), min(y, y1), abs(x - x1), abs(y - y1)

    x1prime = cos(phi) * (x1 - x) / 2 + sin(phi) * (y1 - y) / 2
    y1prime = -sin(phi) * (x1 - x) / 2 + cos(phi) * (y1 - y) / 2

    radicant = (
        rx ** 2 * ry ** 2 - rx ** 2 * y1prime ** 2 - ry ** 2 * x1prime ** 2)
    radicant /= rx ** 2 * y1prime ** 2 + ry ** 2 * x1prime ** 2
    cxprime = cyprime = 0

    if radicant < 0:
        ratio = rx / ry
        radicant = y1prime ** 2 + x1prime ** 2 / ratio ** 2
        if radicant < 0:
            return min(x, x1), min(y, y1), abs(x - x1), abs(y - y1)
        ry = sqrt(radicant)
        rx = ratio * ry
    else:
        factor = (-1 if large == sweep else 1) * sqrt(radicant)

        cxprime = factor * rx * y1prime / ry
        cyprime = -factor * ry * x1prime / rx

    cx = cxprime * cos(phi) - cyprime * sin(phi) + (x1 + x) / 2
    cy = cxprime * sin(phi) + cyprime * cos(phi) + (y1 + y) / 2

    if phi in (0, pi):
        minx = cx - rx
        tminx = atan2(0, -rx)
        maxx = cx + rx
        tmaxx = atan2(0, rx)
        miny = cy - ry
        tminy = atan2(-ry, 0)
        maxy = cy + ry
        tmaxy = atan2(ry, 0)
    elif phi in (pi / 2, 3 * pi / 2):
        minx = cx - ry
        tminx = atan2(0, -ry)
        maxx = cx + ry
        tmaxx = atan2(0, ry)
        miny = cy - rx
        tminy = atan2(-rx, 0)
        maxy = cy + rx
        tmaxy = atan2(rx, 0)
    else:
        tminx = -atan(ry * tan(phi) / rx)
        tmaxx = pi - atan(ry * tan(phi) / rx)
        minx = cx + rx * cos(tminx) * cos(phi) - ry * sin(tminx) * sin(phi)
        maxx = cx + rx * cos(tmaxx) * cos(phi) - ry * sin(tmaxx) * sin(phi)
        if minx > maxx:
            minx, maxx = maxx, minx
            tminx, tmaxx = tmaxx, tminx
        tmp_y = cy + rx * cos(tminx) * sin(phi) + ry * sin(tminx) * cos(phi)
        tminx = atan2(minx - cx, tmp_y - cy)
        tmp_y = cy + rx * cos(tmaxx) * sin(phi) + ry * sin(tmaxx) * cos(phi)
        tmaxx = atan2(maxx - cx, tmp_y - cy)

        tminy = atan(ry / (tan(phi) * rx))
        tmaxy = atan(ry / (tan(phi) * rx)) + pi
        miny = cy + rx * cos(tminy) * sin(phi) + ry * sin(tminy) * cos(phi)
        maxy = cy + rx * cos(tmaxy) * sin(phi) + ry * sin(tmaxy) * cos(phi)
        if miny > maxy:
            miny, maxy = maxy, miny
            tminy, tmaxy = tmaxy, tminy
        tmp_x = cx + rx * cos(tminy) * cos(phi) - ry * sin(tminy) * sin(phi)
        tminy = atan2(tmp_x - cx, miny - cy)
        tmp_x = cx + rx * cos(tmaxy) * cos(phi) - ry * sin(tmaxy) * sin(phi)
        tmaxy = atan2(maxy - cy, tmp_x - cx)

    angle1 = atan2(y1 - cy, x1 - cx)
    angle2 = atan2(y - cy, x - cx)

    if not sweep:
        angle1, angle2 = angle2, angle1

    other_arc = False
    if angle1 > angle2:
        angle1, angle2 = angle2, angle1
        other_arc = True

    if ((not other_arc and (angle1 > tminx or angle2 < tminx)) or
            (other_arc and not (angle1 > tminx or angle2 < tminx))):
        minx = min(x, x1)
    if ((not other_arc and (angle1 > tmaxx or angle2 < tmaxx)) or
            (other_arc and not (angle1 > tmaxx or angle2 < tmaxx))):
        maxx = max(x, x1)
    if ((not other_arc and (angle1 > tminy or angle2 < tminy)) or
            (other_arc and not (angle1 > tminy or angle2 < tminy))):
        miny = min(y, y1)
    if ((not other_arc and (angle1 > tmaxy or angle2 < tmaxy)) or
            (other_arc and not (angle1 > tmaxy or angle2 < tmaxy))):
        maxy = max(y, y1)

    return minx, miny, maxx - minx, maxy - miny


def extend_bounding_box(bounding_box, points):
    """Extend a bounding box to include given points."""
    minx, miny, width, height = bounding_box
    maxx, maxy = (
        -inf if isinf(minx) else minx + width,
        -inf if isinf(miny) else miny + height)
    x_list, y_list = zip(*points)
    minx, miny, maxx, maxy = (
        min(minx, *x_list), min(miny, *y_list),
        max(maxx, *x_list), max(maxy, *y_list))
    return minx, miny, maxx - minx, maxy - miny


def is_valid_bounding_box(bounding_box):
    """Check that a bounding box doesn’t have infinite boundaries."""
    return bounding_box and not isinf(bounding_box[0] + bounding_box[1])


BOUNDING_BOX_METHODS = {
    'rect': bounding_box_rect,
    'circle': bounding_box_circle,
    'ellipse': bounding_box_ellipse,
    'line': bounding_box_line,
    'polyline': bounding_box_polyline,
    'polygon': bounding_box_polyline,
    'path': bounding_box_path,
    'g': bounding_box_g,
    'use': bounding_box_use,
    'marker': bounding_box_g,
    'text': bounding_box_text,
    'tspan': bounding_box_text,
    'textPath': bounding_box_text,
}


================================================
FILE: weasyprint/svg/css.py
================================================
"""Apply CSS to SVG documents."""

from urllib.parse import urljoin

import cssselect2
import tinycss2

from ..css.validation.descriptors import preprocess_descriptors
from ..logger import LOGGER
from .utils import parse_url


def find_stylesheets_rules(tree, stylesheet_rules, url, font_config, url_fetcher):
    """Find rules among stylesheet rules and imports."""
    for rule in stylesheet_rules:
        if rule.type == 'at-rule':
            if rule.lower_at_keyword == 'import' and rule.content is None:
                # TODO: support media types in @import
                url_token = tinycss2.parse_one_component_value(rule.prelude)
                if url_token.type not in ('string', 'url'):
                    continue
                css_url = parse_url(urljoin(url, url_token.value))
                stylesheet = tinycss2.parse_stylesheet(
                    tree.fetch_url(css_url, 'text/css').decode())
                url = css_url.geturl()
                yield from find_stylesheets_rules(
                    tree, stylesheet, url, font_config, url_fetcher)
            elif rule.lower_at_keyword == 'font-face':
                if font_config is not None and url_fetcher is not None:
                    content = tinycss2.parse_blocks_contents(rule.content)
                    rule_descriptors = dict(
                        preprocess_descriptors('font-face', url, content))
                    for key in ('src', 'font_family'):
                        if key not in rule_descriptors:
                            LOGGER.warning(
                                "Missing %s descriptor in '@font-face' rule at "
                                "%d:%d", key.replace('_', '-'),
                                rule.source_line, rule.source_column)
                            break
                    else:
                        font_config.add_font_face(rule_descriptors, url_fetcher)
            # TODO: support media types
            # if rule.lower_at_keyword == 'media':
        elif rule.type == 'qualified-rule':
            yield rule
        # TODO: warn on error
        # if rule.type == 'error':


def parse_declarations(input):
    """Parse declarations in a given rule content."""
    normal_declarations = []
    important_declarations = []
    for declaration in tinycss2.parse_blocks_contents(input):
        # TODO: warn on error
        # if declaration.type == 'error':
        if (declaration.type == 'declaration' and
                not declaration.name.startswith('-')):
            # Serializing perfectly good tokens just to re-parse them later :(
            value = tinycss2.serialize(declaration.value).strip()
            declarations = (
                important_declarations if declaration.important
                else normal_declarations)
            declarations.append((declaration.lower_name, value))
    return normal_declarations, important_declarations


def parse_stylesheets(tree, url, font_config, url_fetcher):
    """Find stylesheets and return rule matchers in given tree."""
    normal_matcher = cssselect2.Matcher()
    important_matcher = cssselect2.Matcher()

    # Find stylesheets
    # TODO: support contentStyleType on <svg>
    stylesheets = []
    for element in tree.etree_element.iter():
        # https://www.w3.org/TR/SVG/styling.html#StyleElement
        if (element.tag == '{http://www.w3.org/2000/svg}style' and
                element.get('type', 'text/css') == 'text/css' and
                element.text):
            # TODO: pass href for relative URLs
            # TODO: support media types
            # TODO: what if <style> has children elements?
            stylesheets.append(tinycss2.parse_stylesheet(
                element.text, skip_comments=True, skip_whitespace=True))

    # Parse rules and fill matchers
    for stylesheet in stylesheets:
        for rule in find_stylesheets_rules(
                tree, stylesheet, url, font_config, url_fetcher):
            normal_declarations, important_declarations = parse_declarations(
                rule.content)
            try:
                selectors = cssselect2.compile_selector_list(rule.prelude)
            except cssselect2.parser.SelectorError as exception:
                LOGGER.warning(
                    'Failed to apply CSS rule in SVG rule: %s', exception)
                break
            for selector in selectors:
                if (selector.pseudo_element is None and
                        not selector.never_matches):
                    if normal_declarations:
                        normal_matcher.add_selector(
                            selector, normal_declarations)
                    if important_declarations:
                        important_matcher.add_selector(
                            selector, important_declarations)

    return normal_matcher, important_matcher


================================================
FILE: weasyprint/svg/defs.py
================================================
"""Parse and draw definitions: gradients, patterns, masks, uses…"""

from itertools import cycle
from math import ceil, hypot

from ..matrix import Matrix
from .bounding_box import bounding_box, is_valid_bounding_box
from .utils import alpha_value, color, parse_url, size, transform


def get_use_tree(svg, node, font_size):
    from . import SVG

    parsed_url = parse_url(node.get_href(svg.url))
    svg_url = parse_url(svg.url)
    if svg_url.scheme == 'data':
        svg_url = parse_url('')
    same_origin = (
        parsed_url[:3] == ('', '', '') or
        parsed_url[:3] == svg_url[:3])
    if parsed_url.fragment and same_origin:
        if parsed_url.fragment in svg.use_cache:
            tree = svg.use_cache[parsed_url.fragment].copy()
        else:
            try:
                tree = svg.tree.get_child(parsed_url.fragment).copy()
            except Exception:
                return
            else:
                svg.use_cache[parsed_url.fragment] = tree
    else:
        url = parsed_url.geturl()
        try:
            bytestring_svg = svg.url_fetcher(url)
            use_svg = SVG(bytestring_svg, url)
        except Exception:
            return
        else:
            use_svg.get_intrinsic_size(font_size)
            tree = use_svg.tree

    return tree


def use(svg, node, font_size):
    """Draw use tags."""
    if (tree := get_use_tree(svg, node, font_size)) is None:
        return

    if tree.tag in ('svg', 'symbol'):
        # Explicitely specified
        # https://www.w3.org/TR/SVG11/struct.html#UseElement
        if 'width' in node.attrib and 'height' in node.attrib:
            tree.attrib['width'] = node.attrib['width']
            tree.attrib['height'] = node.attrib['height']
        else:
            tree._etree_node.tag = 'g'
            box = bounding_box(svg, tree, font_size, stroke=True)
            if is_valid_bounding_box(box):
                tree.attrib['width'] = box[0] + box[2]
                tree.attrib['height'] = box[1] + box[3]
        tree._etree_node.tag = 'svg'

    tree._children = None  # Force cascade to go through children again
    node.cascade(tree)
    node.override_iter(iter((tree,)))
    x, y = svg.point(node.get('x'), node.get('y'), font_size)
    svg.stream.transform(e=x, f=y)


def draw_gradient_or_pattern(svg, node, name, font_size, opacity, stroke):
    """Draw given gradient or pattern."""
    if name in svg.gradients:
        return draw_gradient(
            svg, node, svg.gradients[name], font_size, opacity, stroke)
    elif name in svg.patterns:
        return draw_pattern(
            svg, node, svg.patterns[name], font_size, opacity, stroke)


def draw_gradient(svg, node, gradient, font_size, opacity, stroke):
    """Draw given gradient node."""
    # TODO: merge with Gradient.draw
    positions = []
    colors = []
    for child in gradient:
        positions.append(max(
            positions[-1] if positions else 0,
            size(child.get('offset'), font_size, 1)))
        stop_opacity = alpha_value(child.get('stop-opacity', 1)) * opacity
        stop_color = color(child.get('stop-color', 'black'))
        stop_color.alpha *= stop_opacity
        colors.append(stop_color)

    if not colors:
        return False
    elif len(colors) == 1:
        svg.stream.set_color(colors[0])
        return True

    bounding_box = svg.calculate_bounding_box(node, font_size, stroke)
    if not is_valid_bounding_box(bounding_box):
        return False
    if gradient.get('gradientUnits') == 'userSpaceOnUse':
        width, height = svg.inner_width, svg.inner_height
        bx1, by1 = bounding_box[:2]
        matrix = Matrix()
    else:
        width, height = 1, 1
        e, f, a, d = bounding_box
        bx1, by1 = 0, 0
        matrix = Matrix(a=a, d=d, e=e, f=f)

    spread = gradient.get('spreadMethod', 'pad')
    if spread in ('repeat', 'reflect'):
        if positions[0] > 0:
            positions.insert(0, 0)
            colors.insert(0, colors[0])
        if positions[-1] < 1:
            positions.append(1)
            colors.append(colors[-1])
    else:
        # Add explicit colors at boundaries if needed, because PDF doesn’t
        # extend color stops that are not displayed
        if positions[0] == positions[1]:
            if gradient.tag == 'radialGradient':
                # Avoid negative radius for radial gradients
                positions.insert(0, 0)
            else:
                positions.insert(0, positions[0] - 1)
            colors.insert(0, colors[0])
        if positions[-2] == positions[-1]:
            positions.append(positions[-1] + 1)
            colors.append(colors[-1])

    if 'gradientTransform' in gradient.attrib:
        transform_matrix = transform(
            gradient.get('gradientTransform'), '0 0', font_size,
            svg.normalized_diagonal)
        matrix = transform_matrix @ matrix

    if gradient.tag == 'linearGradient':
        shading_type = 2
        x1, y1 = (
            size(gradient.get('x1', 0), font_size, width),
            size(gradient.get('y1', 0), font_size, height))
        x2, y2 = (
            size(gradient.get('x2', '100%'), font_size, width),
            size(gradient.get('y2', 0), font_size, height))
        positions, colors, coords = spread_linear_gradient(
            spread, positions, colors, x1, y1, x2, y2, bounding_box, matrix)
    else:
        assert gradient.tag == 'radialGradient'
        shading_type = 3
        cx, cy = (
            size(gradient.get('cx', '50%'), font_size, width),
            size(gradient.get('cy', '50%'), font_size, height))
        r = size(gradient.get('r', '50%'), font_size, hypot(width, height))
        fx, fy = (
            size(gradient.get('fx', cx), font_size, width),
            size(gradient.get('fy', cy), font_size, height))
        fr = size(gradient.get('fr', 0), font_size, hypot(width, height))
        positions, colors, coords = spread_radial_gradient(
            spread, positions, colors, fx, fy, fr, cx, cy, r, width, height,
            matrix)

    alphas = [color[3] for color in colors]
    alpha_couples = [
        (alphas[i], alphas[i + 1])
        for i in range(len(alphas) - 1)]
    color_couples = [
        [colors[i][:3], colors[i + 1][:3], 1]
        for i in range(len(colors) - 1)]

    # Premultiply colors
    for i, alpha in enumerate(alphas):
        if alpha == 0:
            if i > 0:
                color_couples[i - 1][1] = color_couples[i - 1][0]
            if i < len(colors) - 1:
                color_couples[i][0] = color_couples[i][1]
    for i, (a0, a1) in enumerate(alpha_couples):
        if 0 not in (a0, a1) and (a0, a1) != (1, 1):
            color_couples[i][2] = a0 / a1

    if 'gradientTransform' in gradient.attrib:
        bx2, by2 = bx1 + width, by1 + height
        bx1, by1 = transform_matrix.invert.transform_point(bx1, by1)
        bx2, by2 = transform_matrix.invert.transform_point(bx2, by2)
        width, height = bx2 - bx1, by2 - by1

        # Ensure that width and height are positive to please some PDF readers
        if bx1 > bx2:
            width = -width
            bx1, bx2 = bx2, bx1
        if by1 > by2:
            height = -height
            by1, by2 = by2, by1

    pattern = svg.stream.add_pattern(
        bx1, by1, width, height, width, height, matrix @ svg.stream.ctm)
    group = pattern.add_group(bx1, by1, width, height)

    domain = (positions[0], positions[-1])
    extend = spread not in ('repeat', 'reflect')
    encode = (len(colors) - 1) * (0, 1)
    bounds = positions[1:-1]
    sub_functions = (
        group.create_interpolation_function(domain, c0, c1, n)
        for c0, c1, n in color_couples)
    function = group.create_stitching_function(
        domain, encode, bounds, sub_functions)
    shading = group.add_shading(
        shading_type, 'RGB', domain, coords, extend, function)

    if any(alpha != 1 for alpha in alphas):
        alpha_stream = group.set_alpha_state(bx1, by1, width, height)
        domain = (positions[0], positions[-1])
        extend = spread not in ('repeat', 'reflect')
        encode = (len(colors) - 1) * (0, 1)
        bounds = positions[1:-1]
        sub_functions = (
            group.create_interpolation_function((0, 1), [c0], [c1], 1)
            for c0, c1 in alpha_couples)
        function = group.create_stitching_function(
            domain, encode, bounds, sub_functions)
        alpha_shading = alpha_stream.add_shading(
            shading_type, 'Gray', domain, coords, extend, function)
        alpha_stream.stream = [f'/{alpha_shading.id} sh']

    group.paint_shading(shading.id)
    pattern.set_alpha(1)
    pattern.draw_x_object(group.id)
    svg.stream.set_color_space('Pattern', stroke=stroke)
    svg.stream.set_color_special(pattern.id, stroke=stroke)
    return True


def spread_linear_gradient(spread, positions, colors, x1, y1, x2, y2,
                           bounding_box, matrix):
    """Repeat linear gradient."""
    # TODO: merge with LinearGradient.layout
    from ..images import gradient_average_color, normalize_stop_positions

    first, last, positions = normalize_stop_positions(positions)
    if spread in ('repeat', 'reflect'):
        # Render as a solid color if the first and last positions are equal
        # See https://drafts.csswg.org/css-images-3/#repeating-gradients
        if first == last:
            average_color = gradient_average_color(colors, positions)
            return 1, 'solid', None, [], [average_color]

        # Define defined gradient length and steps between positions
        stop_length = last - first
        position_steps = [
            positions[i + 1] - positions[i]
            for i in range(len(positions) - 1)]

        # Create cycles used to add colors
        if spread == 'repeat':
            next_steps = cycle((0, *position_steps))
            next_colors = cycle(colors)
            previous_steps = cycle((0, *position_steps[::-1]))
            previous_colors = cycle(colors[::-1])
        else:
            assert spread == 'reflect'
            next_steps = cycle((0, *position_steps[::-1], 0, *position_steps))
            next_colors = cycle(colors[::-1] + colors)
            previous_steps = cycle((0, *position_steps, 0, *position_steps[::-1]))
            previous_colors = cycle(colors + colors[::-1])

        # Normalize bounding box
        bx1, by1, bw, bh = bounding_box
        bx1, bx2 = (bx1, bx1 + bw) if bw > 0 else (bx1 + bw, bx1)
        by1, by2 = (by1, by1 + bh) if bh > 0 else (by1 + bh, by1)

        # Transform gradient vector coordinates
        tx1, ty1 = matrix.transform_point(x1, y1)
        tx2, ty2 = matrix.transform_point(x2, y2)

        # Find the extremities of the repeating vector, by projecting the
        # bounding box corners on the gradient vector
        xb, yb = tx1, ty1
        xv, yv = tx2 - tx1, ty2 - ty1
        xa1, xa2 = (bx1, bx2) if tx1 < tx2 else (bx2, bx1)
        ya1, ya2 = (by1, by2) if ty1 < ty2 else (by2, by1)
        min_vector = ((xa1 - xb) * xv + (ya1 - yb) * yv) / hypot(xv, yv) ** 2
        max_vector = ((xa2 - xb) * xv + (ya2 - yb) * yv) / hypot(xv, yv) ** 2

        # Add colors after last step
        while last < max_vector:
            step = next(next_steps)
            colors.append(next(next_colors))
            positions.append(positions[-1] + step)
            last += step * stop_length

        # Add colors before first step
        while first > min_vector:
            step = next(previous_steps)
            colors.insert(0, next(previous_colors))
            positions.insert(0, positions[0] - step)
            first -= step * stop_length

    x1, x2 = x1 + (x2 - x1) * first, x1 + (x2 - x1) * last
    y1, y2 = y1 + (y2 - y1) * first, y1 + (y2 - y1) * last
    coords = (x1, y1, x2, y2)
    return positions, colors, coords


def spread_radial_gradient(spread, positions, colors, fx, fy, fr, cx, cy, r,
                           width, height, matrix):
    """Repeat radial gradient."""
    # TODO: merge with RadialGradient._repeat
    from ..images import gradient_average_color, normalize_stop_positions

    first, last, positions = normalize_stop_positions(positions)
    fr, r = fr + (r - fr) * first, fr + (r - fr) * last

    if spread in ('repeat', 'reflect'):
        # Keep original lists and values, they’re useful
        original_colors = colors.copy()
        original_positions = positions.copy()

        # Get the maximum distance between the center and the corners, to find
        # how many times we have to repeat the colors outside
        tw, th = matrix.invert.transform_point(width, height)
        max_distance = hypot(
            max(abs(fx), abs(tw - fx)), max(abs(fy), abs(th - fy)))
        gradient_length = r - fr
        repeat_after = ceil((max_distance - r) / gradient_length)
        if repeat_after > 0:
            # Repeat colors and extrapolate positions
            repeat = 1 + repeat_after
            if spread == 'repeat':
                colors *= repeat
            else:
                assert spread == 'reflect'
                colors = []
                for i in range(repeat):
                    colors += original_colors[::-1 if i % 2 else 1]
            positions = [
                i + position for i in range(repeat) for position in positions]
            r += gradient_length * repeat_after

        if fr == 0:
            # Inner circle has 0 radius, no need to repeat inside, return
            coords = (fx, fy, fr, cx, cy, r)
            return positions, colors, coords

        # Find how many times we have to repeat the colors inside
        repeat_before = fr / gradient_length

        # Set the inner circle size to 0
        fr = 0

        # Find how many times the whole gradient can be repeated
        full_repeat = int(repeat_before)
        if full_repeat:
            # Repeat colors and extrapolate positions
            if spread == 'repeat':
                colors += original_colors * full_repeat
            else:
                assert spread == 'reflect'
                for i in range(full_repeat):
                    colors += original_colors[
                        ::-1 if (i + repeat_after) % 2 else 1]
            positions = [
                i - full_repeat + position for i in range(full_repeat)
                for position in original_positions] + positions

        # Find the ratio of gradient that must be added to reach the center
        partial_repeat = repeat_before - full_repeat
        if partial_repeat == 0:
            # No partial repeat, return
            coords = (fx, fy, fr, cx, cy, r)
            return positions, colors, coords

        # Iterate through positions in reverse order, from the outer
        # circle to the original inner circle, to find positions from
        # the inner circle (including full repeats) to the center
        assert (original_positions[0], original_positions[-1]) == (0, 1)
        assert 0 < partial_repeat < 1
        reverse = original_positions[::-1]
        ratio = 1 - partial_repeat
        if spread == 'reflect':
            original_colors = original_colors[::-1]
        for i, position in enumerate(reverse, start=1):
            if position == ratio:
                # The center is a color of the gradient, truncate original
                # colors and positions and prepend them
                colors = original_colors[-i:] + colors
                new_positions = [
                    position - full_repeat - 1
                    for position in original_positions[-i:]]
                positions = new_positions + positions
                break
            if position < ratio:
                # The center is between two colors of the gradient,
                # define the center color as the average of these two
                # gradient colors
                color = original_colors[-i]
                next_color = original_colors[-(i - 1)]
                next_position = original_positions[-(i - 1)]
                average_colors = [color, color, next_color, next_color]
                average_positions = [position, ratio, ratio, next_position]
                zero_color = gradient_average_color(
                    average_colors, average_positions)
                colors = [zero_color, *original_colors[-(i - 1):], *colors]
                new_positions = [
                    position - 1 - full_repeat for position
                    in original_positions[-(i - 1):]]
                positions = [ratio - 1 - full_repeat, *new_positions, *positions]
                break

    coords = (fx, fy, fr, cx, cy, r)
    return positions, colors, coords


def draw_pattern(svg, node, pattern, font_size, opacity, stroke):
    """Draw given gradient node."""
    from . import Pattern

    pattern._etree_node.tag = 'svg'

    bounding_box = svg.calculate_bounding_box(node, font_size, stroke)
    if not is_valid_bounding_box(bounding_box):
        return False
    x, y = bounding_box[0], bounding_box[1]
    matrix = Matrix(e=x, f=y)
    if pattern.get('patternUnits') == 'userSpaceOnUse':
        pattern_width = size(pattern.get('width', 0), font_size, 1)
        pattern_height = size(pattern.get('height', 0), font_size, 1)
    else:
        width, height = bounding_box[2], bounding_box[3]
        pattern_width = (
            size(pattern.attrib.pop('width', '1'), font_size, 1) * width)
        pattern_height = (
            size(pattern.attrib.pop('height', '1'), font_size, 1) * height)
        if 'viewBox' not in pattern:
            pattern.attrib['width'] = pattern_width
            pattern.attrib['height'] = pattern_height
            if pattern.get('patternContentUnits') == 'objectBoundingBox':
                pattern.attrib['transform'] = f'scale({width}, {height})'

    # Fail if pattern has an invalid size
    if pattern_width == 0 or pattern_height == 0:
        return False

    if 'patternTransform' in pattern.attrib:
        transform_matrix = transform(
            pattern.get('patternTransform'), '0 0', font_size, svg.inner_diagonal)
        matrix = transform_matrix @ matrix

    matrix = matrix @ svg.stream.ctm
    stream_pattern = svg.stream.add_pattern(
        0, 0, pattern_width, pattern_height, pattern_width, pattern_height,
        matrix)
    stream_pattern.set_alpha(opacity)

    group = stream_pattern.add_group(0, 0, pattern_width, pattern_height)
    Pattern(pattern, svg).draw(
        group, pattern_width, pattern_height, svg.base_url,
        svg.context)
    stream_pattern.draw_x_object(group.id)
    svg.stream.set_color_space('Pattern', stroke=stroke)
    svg.stream.set_color_special(stream_pattern.id, stroke=stroke)
    return True


def apply_filters(svg, node, filter_node, font_size):
    """Apply filters defined in given filter node."""
    for child in filter_node:
        if child.tag == 'feOffset':
            if filter_node.get('primitiveUnits') == 'objectBoundingBox':
                bounding_box = svg.calculate_bounding_box(node, font_size)
                if is_valid_bounding_box(bounding_box):
                    _, _, width, height = bounding_box
                    dx = size(child.get('dx', 0), font_size, 1) * width
                    dy = size(child.get('dy', 0), font_size, 1) * height
                else:
                    dx = dy = 0
            else:
                dx, dy = svg.point(
                    child.get('dx', 0), child.get('dy', 0), font_size)
            svg.stream.transform(e=dx, f=dy)
        elif child.tag == 'feBlend':
            mode = child.get('mode', 'normal')
            mode = mode.replace('-', ' ').title().replace(' ', '')
            svg.stream.set_blend_mode(mode)


def paint_mask(svg, node, mask, font_size):
    """Apply given mask node."""
    mask._etree_node.tag = 'g'

    if mask.get('maskUnits') == 'userSpaceOnUse':
        width_ref, height_ref = svg.inner_width, svg.inner_height
    else:
        width_ref, height_ref = svg.point(
            node.get('width'), node.get('height'), font_size)

    mask.attrib['x'] = size(mask.get('x', '-10%'), font_size, width_ref)
    mask.attrib['y'] = size(mask.get('y', '-10%'), font_size, height_ref)
    mask.attrib['height'] = size(
        mask.get('height', '120%'), font_size, height_ref)
    mask.attrib['width'] = size(
        mask.get('width', '120%'), font_size, width_ref)

    if mask.get('maskUnits') == 'userSpaceOnUse':
        x, y = mask.get('x'), mask.get('y')
        width, height = mask.get('width'), mask.get('height')
        mask.attrib['viewBox'] = f'{x} {y} {width} {height}'
    else:
        x, y = 0, 0
        width, height = width_ref, height_ref

    svg_stream = svg.stream
    svg.stream = svg.stream.set_alpha_state(x, y, width, height)
    svg.draw_node(mask, font_size)
    svg.stream = svg_stream


================================================
FILE: weasyprint/svg/images.py
================================================
"""Draw image and svg tags."""

from .bounding_box import bounding_box, is_valid_bounding_box
from .utils import preserve_ratio


def svg(svg, node, font_size):
    """Draw svg tags."""
    x, y = svg.point(node.get('x'), node.get('y'), font_size)
    svg.stream.transform(e=x, f=y)
    if svg.tree == node:
        width, height = svg.concrete_width, svg.concrete_height
    else:
        width, height = node.get('width'), node.get('height')
        if None in (width, height):
            node._etree_node.tag = 'g'
            box = bounding_box(svg, node, font_size, stroke=True)
            if is_valid_bounding_box(box):
                width = box[0] + box[2]
                height = box[1] + box[3]
            else:
                width = height = 0
            node._etree_node.tag = 'svg'
        else:
            width, height = svg.point(width, height, font_size)
    node.set_svg_size(svg, width, height)
    scale_x, scale_y, translate_x, translate_y = preserve_ratio(
        svg, node, font_size, width, height)
    if svg.tree != node and node.get('overflow', 'hidden') == 'hidden':
        svg.stream.rectangle(0, 0, width, height)
        svg.stream.clip()
        svg.stream.end()
    svg.stream.transform(a=scale_x, d=scale_y, e=translate_x, f=translate_y)


def image(svg, node, font_size):
    """Draw image tags."""
    x, y = svg.point(node.get('x'), node.get('y'), font_size)
    svg.stream.transform(e=x, f=y)
    base_url = node.get('{http://www.w3.org/XML/1998/namespace}base')
    url = node.get_href(base_url or svg.url)
    image = svg.context.get_image_from_uri(url=url, forced_mime_type='image/*')
    if image is None:
        return

    width, height = svg.point(node.get('width'), node.get('height'), font_size)
    intrinsic_width, intrinsic_height, intrinsic_ratio = (
        image.get_intrinsic_size(1, font_size))
    if intrinsic_width is None and intrinsic_height is None:
        if intrinsic_ratio is None or (not width and not height):
            intrinsic_width, intrinsic_height = 300, 150
        elif not width:
            intrinsic_width, intrinsic_height = (
                intrinsic_ratio * height, height)
        else:
            intrinsic_width, intrinsic_height = width, width / intrinsic_ratio
    elif intrinsic_width is None:
        intrinsic_width = intrinsic_ratio * intrinsic_height
    elif intrinsic_height is None:
        intrinsic_height = intrinsic_width / intrinsic_ratio

    # Calculate final dimensions while preserving aspect ratio
    if width and not height:
        height = width / intrinsic_ratio
    elif height and not width:
        width = height * intrinsic_ratio
    else:
        width = width or intrinsic_width
        height = height or intrinsic_height

    scale_x, scale_y, translate_x, translate_y = preserve_ratio(
        svg, node, font_size, width, height,
        (0, 0, intrinsic_width, intrinsic_height))
    svg.stream.rectangle(0, 0, width, height)
    svg.stream.clip()
    svg.stream.end()
    svg.stream.push_state()
    svg.stream.transform(a=scale_x, d=scale_y, e=translate_x, f=translate_y)
    # TODO: pass real style instead of dict.
    image.draw(
        svg.stream, intrinsic_width, intrinsic_height,
        {'image_rendering': node.attrib.get('image-rendering', 'auto')},
    )
    svg.stream.pop_state()


================================================
FILE: weasyprint/svg/path.py
================================================
"""Draw paths."""

from math import atan2, cos, isclose, pi, radians, sin, tan

from ..matrix import Matrix
from .utils import normalize, point

PATH_LETTERS = 'achlmqstvzACHLMQSTVZ'


def _rotate(x, y, angle):
    """Rotate (x, y) point of given angle around (0, 0)."""
    return x * cos(angle) - y * sin(angle), y * cos(angle) + x * sin(angle)


def path(svg, node, font_size):
    """Draw path node."""
    string = node.get('d', '')

    for letter in PATH_LETTERS:
        string = string.replace(letter, f' {letter} ')
    string = normalize(string)

    # TODO: get current point
    current_point = 0, 0
    svg.stream.move_to(*current_point)
    last_letter = None

    while string:
        string = string.strip()
        if string.split(' ', 1)[0] in PATH_LETTERS:
            letter, string = (f'{string} ').split(' ', 1)
            if last_letter in (None, 'z', 'Z') and letter not in 'mM':
                node.vertices.append(current_point)
                first_path_point = current_point
        elif letter == 'M':
            letter = 'L'
        elif letter == 'm':
            letter = 'l'

        if last_letter in (None, 'm', 'M', 'z', 'Z'):
            first_path_point = None
        if letter not in (None, 'm', 'M', 'z', 'Z') and (
                first_path_point is None):
            first_path_point = current_point

        if letter in 'aA':
            # Elliptic curve
            # Drawn as an approximation using Bézier curves
            x1, y1 = current_point
            rx, ry, string = point(svg, string, font_size)
            rotation, string = string.split(' ', 1)
            rotation = radians(float(rotation))

            # The large and sweep values are not always separated from the
            # following values. These flags can only be 0 or 1, so reading a
            # single digit suffices.
            large, string = string[0], string[1:].strip()
            sweep, string = string[0], string[1:].strip()

            # Retrieve end point and set remainder (before checking flags)
            x3, y3, string = point(svg, string, font_size)
            if letter == 'a':
                x3 += x1
                y3 += y1

            # Only allow 0 or 1 for flags
            large, sweep = int(large), int(sweep)
            if large not in (0, 1) or sweep not in (0, 1):
                continue
            large, sweep = bool(large), bool(sweep)

            # rx=0 or ry=0 means straight line
            if not rx or not ry:
                if string and string[0] not in PATH_LETTERS:
                    # As we replace the current operation by l, we must be sure
                    # that the next letter is set to the real current letter (a
                    # or A) in case it’s omitted
                    next_letter = f'{letter} '
                else:
                    next_letter = ''
                string = f'L {x3} {y3} {next_letter}{string}'
                continue

            # Cancel the rotation of the second point
            xe, ye = _rotate(x3 - x1, y3 - y1, -rotation)
            y_scale = ry / rx
            ye /= y_scale

            # Find the angle between the second point and the x axis
            angle = atan2(ye, xe)

            # Put the second point onto the x axis
            xe = (xe ** 2 + ye ** 2) ** .5
            ye = 0

            # Update the x radius if it is too small
            rx = max(rx, xe / 2)

            # Find one circle centre
            xc = xe / 2
            yc = (rx ** 2 - xc ** 2) ** .5

            # Choose between the two circles according to flags
            if large == sweep:
                yc = -yc

            # Put the second point and the center back to their positions
            xe, ye = _rotate(xe, ye, angle)
            xc, yc = _rotate(xc, yc, angle)

            # Find the drawing angles
            angle1 = atan2(-yc, -xc)
            angle2 = atan2(ye - yc, xe - xc)
            while angle1 < 0 or angle2 < 0:
                angle1 += 2 * pi
                angle2 += 2 * pi

            # Store the tangent angles
            node.vertices.append((-angle1, -angle2))

            # Fix angles to follow large arc flag
            if isclose(abs(angle2 - angle1), pi):
                if sweep and (angle2 < angle1):
                    angle1 -= 2 * pi
                elif not sweep and (angle2 > angle1):
                    angle2 -= 2 * pi
            elif large == (abs(angle2 - angle1) < pi):
                if angle1 > angle2:
                    angle1 -= 2 * pi
                else:
                    angle2 -= 2 * pi

            # Split arc into 3 Bézier curves when larger than pi
            if large:
                step = (angle2 - angle1) / 3
                angles = (
                    (angle1, angle1 + step),
                    (angle1 + step, angle1 + 2 * step),
                    (angle1 + 2 * step, angle2))
            else:
                angles = ((angle1, angle2),)

            # Draw Bézier curves
            matrix = Matrix(
                cos(rotation), sin(rotation),
                -sin(rotation) * y_scale, cos(rotation) * y_scale,
                x1, y1)
            h = 4 / 3 * tan((angles[0][1] - angles[0][0]) / 4)
            for angle1, angle2 in angles:
                point1 = matrix.transform_point(
                    xc + rx * cos(angle1) - h * rx * sin(angle1),
                    yc + rx * sin(angle1) + h * rx * cos(angle1))
                point2 = matrix.transform_point(
                    xc + rx * cos(angle2) + h * rx * sin(angle2),
                    yc + rx * sin(angle2) - h * rx * cos(angle2))
                point3 = matrix.transform_point(
                    xc + rx * cos(angle2),
                    yc + rx * sin(angle2))
                svg.stream.curve_to(*point1, *point2, *point3)

            current_point = x3, y3

        elif letter in 'cC':
            # Curve
            x1, y1, string = point(svg, string, font_size)
            x2, y2, string = point(svg, string, font_size)
            x3, y3, string = point(svg, string, font_size)
            if letter == 'c':
                x, y = current_point
                x1 += x
                x2 += x
                x3 += x
                y1 += y
                y2 += y
                y3 += y
            node.vertices.append((
                atan2(y1 - y2, x1 - x2), atan2(y3 - y2, x3 - x2)))
            svg.stream.curve_to(x1, y1, x2, y2, x3, y3)
            current_point = x3, y3

        elif letter in 'hH':
            # Horizontal line
            x, string = (f'{string} ').split(' ', 1)
            old_x, old_y = current_point
            x, _ = svg.point(x, 0, font_size)
            if letter == 'h':
                x += old_x
            angle = 0 if x > old_x else pi
            node.vertices.append((pi - angle, angle))
            svg.stream.line_to(x, old_y)
            current_point = x, old_y

        elif letter in 'lL':
            # Straight line
            x, y, string = point(svg, string, font_size)
            old_x, old_y = current_point
            if letter == 'l':
                x += old_x
                y += old_y
            angle = atan2(y - old_y, x - old_x)
            node.vertices.append((pi - angle, angle))
            svg.stream.line_to(x, y)
            current_point = x, y

        elif letter in 'mM':
            # Current point move
            x, y, string = point(svg, string, font_size)
            if last_letter and last_letter not in 'zZ':
                node.vertices.append(None)
            if letter == 'm':
                x += current_point[0]
                y += current_point[1]
            svg.stream.move_to(x, y)
            current_point = x, y

        elif letter in 'qQtT':
            # Quadratic curve
            x1, y1 = current_point
            if letter in 'qQ':
                x2, y2, string = point(svg, string, font_size)
            else:
                if last_letter not in 'QqTt':
                    x2, y2, x3, y3 = x, y, x, y
                x2 = x1 + x3 - x2
                y2 = y1 + y3 - y2
            x3, y3, string = point(svg, string, font_size)
            if letter == 'q':
                x2 += x1
                y2 += y1
            if letter in 'qt':
                x3 += x1
                y3 += y1
            xq1 = x2 * 2 / 3 + x1 / 3
            yq1 = y2 * 2 / 3 + y1 / 3
            xq2 = x2 * 2 / 3 + x3 / 3
            yq2 = y2 * 2 / 3 + y3 / 3
            svg.stream.curve_to(xq1, yq1, xq2, yq2, x3, y3)
            node.vertices.append((0, 0))
            current_point = x3, y3

        elif letter in 'sS':
            # Smooth curve
            x, y = current_point
            x1 = x3 + (x3 - x2) if last_letter in 'csCS' else x
            y1 = y3 + (y3 - y2) if last_letter in 'csCS' else y
            x2, y2, string = point(svg, string, font_size)
            x3, y3, string = point(svg, string, font_size)
            if letter == 's':
                x2 += x
                x3 += x
                y2 += y
                y3 += y
            node.vertices.append((
                atan2(y1 - y2, x1 - x2), atan2(y3 - y2, x3 - x2)))
            svg.stream.curve_to(x1, y1, x2, y2, x3, y3)
            current_point = x3, y3

        elif letter in 'vV':
            # Vertical line
            y, string = (f'{string} ').split(' ', 1)
            old_x, old_y = current_point
            _, y = svg.point(0, y, font_size)
            if letter == 'v':
                y += old_y
            angle = pi / 2 if y > old_y else -pi / 2
            node.vertices.append((pi - angle, angle))
            svg.stream.line_to(old_x, y)
            current_point = old_x, y

        elif letter in 'zZ' and first_path_point:
            # End of path
            node.vertices.append(None)
            svg.stream.close()
            current_point = first_path_point

        if letter not in 'zZ':
            node.vertices.append(current_point)

        string = string.strip()
        last_letter = letter


================================================
FILE: weasyprint/svg/shapes.py
================================================
"""Draw simple shapes."""

from math import atan2, pi, sqrt

from .utils import normalize, point


def circle(svg, node, font_size):
    """Draw circle tag."""
    r = svg.length(node.get('r'), font_size)
    if not r:
        return
    ratio = r / sqrt(pi)
    cx, cy = svg.point(node.get('cx'), node.get('cy'), font_size)

    svg.stream.move_to(cx + r, cy)
    svg.stream.curve_to(cx + r, cy + ratio, cx + ratio, cy + r, cx, cy + r)
    svg.stream.curve_to(cx - ratio, cy + r, cx - r, cy + ratio, cx - r, cy)
    svg.stream.curve_to(cx - r, cy - ratio, cx - ratio, cy - r, cx, cy - r)
    svg.stream.curve_to(cx + ratio, cy - r, cx + r, cy - ratio, cx + r, cy)
    svg.stream.close()


def ellipse(svg, node, font_size):
    """Draw ellipse tag."""
    rx, ry = svg.point(node.get('rx'), node.get('ry'), font_size)
    if not rx or not ry:
        return
    ratio_x = rx / sqrt(pi)
    ratio_y = ry / sqrt(pi)
    cx, cy = svg.point(node.get('cx'), node.get('cy'), font_size)

    svg.stream.move_to(cx + rx, cy)
    svg.stream.curve_to(
        cx + rx, cy + ratio_y, cx + ratio_x, cy + ry, cx, cy + ry)
    svg.stream.curve_to(
        cx - ratio_x, cy + ry, cx - rx, cy + ratio_y, cx - rx, cy)
    svg.stream.curve_to(
        cx - rx, cy - ratio_y, cx - ratio_x, cy - ry, cx, cy - ry)
    svg.stream.curve_to(
        cx + ratio_x, cy - ry, cx + rx, cy - ratio_y, cx + rx, cy)
    svg.stream.close()


def rect(svg, node, font_size):
    """Draw rect tag."""
    width, height = svg.point(node.get('width'), node.get('height'), font_size)
    if width <= 0 or height <= 0:
        return

    x, y = svg.point(node.get('x'), node.get('y'), font_size)

    rx = node.get('rx')
    ry = node.get('ry')
    if rx and ry is None:
        ry = rx
    elif ry and rx is None:
        rx = ry
    rx, ry = svg.point(rx, ry, font_size)

    if rx == 0 or ry == 0:
        svg.stream.rectangle(x, y, width, height)
        return

    if rx > width / 2:
        rx = width / 2
    if ry > height / 2:
        ry = height / 2

    # Inspired by Cairo Cookbook
    # https://cairographics.org/cookbook/roundedrectangles/
    arc_to_bezier = 4 * (2 ** .5 - 1) / 3
    c1, c2 = arc_to_bezier * rx, arc_to_bezier * ry

    svg.stream.move_to(x + rx, y)
    svg.stream.line_to(x + width - rx, y)
    svg.stream.curve_to(
        x + width - rx + c1, y, x + width, y + c2, x + width, y + ry)
    svg.stream.line_to(x + width, y + height - ry)
    svg.stream.curve_to(
        x + width, y + height - ry + c2, x + width + c1 - rx, y + height,
        x + width - rx, y + height)
    svg.stream.line_to(x + rx, y + height)
    svg.stream.curve_to(
        x + rx - c1, y + height, x, y + height - c2, x, y + height - ry)
    svg.stream.line_to(x, y + ry)
    svg.stream.curve_to(x, y + ry - c2, x + rx - c1, y, x + rx, y)
    svg.stream.close()


def line(svg, node, font_size):
    """Draw line tag."""
    x1, y1 = svg.point(node.get('x1'), node.get('y1'), font_size)
    x2, y2 = svg.point(node.get('x2'), node.get('y2'), font_size)
    svg.stream.move_to(x1, y1)
    svg.stream.line_to(x2, y2)
    angle = atan2(y2 - y1, x2 - x1)
    node.vertices = [(x1, y1), (pi - angle, angle), (x2, y2)]


def polygon(svg, node, font_size):
    """Draw polygon tag."""
    polyline(svg, node, font_size)
    svg.stream.close()


def polyline(svg, node, font_size):
    """Draw polyline tag."""
    points = normalize(node.get('points'))
    if points:
        x, y, points = point(svg, points, font_size)
        svg.stream.move_to(x, y)
        node.vertices = [(x, y)]
        while points:
            x_old, y_old = x, y
            x, y, points = point(svg, points, font_size)
            angle = atan2(x - x_old, y - y_old)
            node.vertices.append((pi - angle, angle))
            svg.stream.line_to(x, y)
            node.vertices.append((x, y))


================================================
FILE: weasyprint/svg/text.py
================================================
"""Draw text."""

from math import cos, inf, radians, sin

from ..matrix import Matrix
from .bounding_box import extend_bounding_box
from .utils import normalize, size


class TextBox:
    """Dummy text box used to draw text."""
    def __init__(self, pango_layout, style):
        self.pango_layout = pango_layout
        self.style = style

    @property
    def text(self):
        return self.pango_layout.text


class Style(dict):
    """Dummy class to store dict."""


def text(svg, node, font_size):
    """Draw text node."""
    from ..css.properties import INITIAL_VALUES
    from ..draw.text import draw_emojis, draw_first_line
    from ..text.line_break import split_first_line

    # TODO: use real computed values
    style = Style()
    style.update(INITIAL_VALUES)
    style.font_config = svg.font_config
    style['font_family'] = [
        font.strip('"\'') for font in
        node.get('font-family', 'sans-serif').split(',')]
    style['font_style'] = node.get('font-style', 'normal')
    style['font_weight'] = node.get('font-weight', 400)
    style['font_size'] = font_size
    if style['font_weight'] == 'normal':
        style['font_weight'] = 400
    elif style['font_weight'] == 'bold':
        style['font_weight'] = 700
    else:
        try:
            style['font_weight'] = int(style['font_weight'])
        except ValueError:
            style['font_weight'] = 400

    layout, _, _, width, height, _ = split_first_line(
        node.text, style, svg.context, inf, 0)

    # Get rotations and translations
    x, y, dx, dy, rotate = [], [], [], [], [0]
    if 'x' in node.attrib:
        x = [size(i, font_size, svg.inner_width)
             for i in normalize(node.attrib['x']).strip().split(' ')]
    if 'y' in node.attrib:
        y = [size(i, font_size, svg.inner_height)
             for i in normalize(node.attrib['y']).strip().split(' ')]
    if 'dx' in node.attrib:
        dx = [size(i, font_size, svg.inner_width)
              for i in normalize(node.attrib['dx']).strip().split(' ')]
    if 'dy' in node.attrib:
        dy = [size(i, font_size, svg.inner_height)
              for i in normalize(node.attrib['dy']).strip().split(' ')]
    if 'rotate' in node.attrib:
        rotate = [radians(float(i)) if i else 0
                  for i in normalize(node.attrib['rotate']).strip().split(' ')]
    last_r = rotate[-1]
    letters_positions = [
        ([pl.pop(0) if pl else None for pl in (x, y, dx, dy, rotate)], char)
        for char in node.text]

    letter_spacing = svg.length(node.get('letter-spacing'), font_size)
    text_length = svg.length(node.get('textLength'), font_size)
    scale_x = 1
    if text_length and node.text:
        # calculate the number of spaces to be considered for the text
        spaces_count = len(node.text) - 1
        if normalize(node.attrib.get('lengthAdjust')) == 'spacingAndGlyphs':
            # scale letter_spacing up/down to textLength
            width_with_spacing = width + spaces_count * letter_spacing
            letter_spacing *= text_length / width_with_spacing
            # calculate the glyphs scaling factor by:
            # - deducting the scaled letter_spacing from textLength
            # - dividing the calculated value by the original width
            spaceless_text_length = text_length - spaces_count * letter_spacing
            scale_x = spaceless_text_length / width
        elif spaces_count:
            # adjust letter spacing to fit textLength
            letter_spacing = (text_length - width) / spaces_count
        width = text_length

    # TODO: use real values
    ascent, descent = font_size * .8, font_size * .2

    # Align text box vertically
    # TODO: This is a hack. Other baseline alignment tags are not supported.
    # See https://www.w3.org/TR/SVG2/text.html#TextPropertiesSVG
    y_align = 0
    display_anchor = node.get('display-anchor')
    alignment_baseline = node.get(
        'dominant-baseline', node.get('alignment-baseline'))
    if display_anchor == 'middle':
        y_align = -height / 2
    elif display_anchor == 'top':
        pass
    elif display_anchor == 'bottom':
        y_align = -height
    elif alignment_baseline in ('central', 'middle'):
        # TODO: This is wrong, we use font top-to-bottom
        y_align = (ascent + descent) / 2 - descent
    elif alignment_baseline in (
            'text-before-edge', 'before_edge', 'top', 'hanging', 'text-top'):
        y_align = ascent
    elif alignment_baseline in (
            'text-after-edge', 'after_edge', 'bottom', 'text-bottom'):
        y_align = -descent

    # Return early when there’s no text
    if not node.text:
        x = x[0] if x else svg.cursor_position[0]
        y = y[0] if y else svg.cursor_position[1]
        dx = dx[0] if dx else 0
        dy = dy[0] if dy else 0
        svg.cursor_position = (x + dx, y + dy)
        return

    svg.stream.push_state()
    svg.set_graphical_state(node, font_size, text=True)
    svg.stream.begin_text()
    emoji_lines = []

    # Draw letters
    for i, ((x, y, dx, dy, r), letter) in enumerate(letters_positions):
        if x:
            svg.cursor_d_position[0] = 0
        if y:
            svg.cursor_d_position[1] = 0
        svg.cursor_d_position[0] += dx or 0
        svg.cursor_d_position[1] += dy or 0
        layout, _, _, width, height, baseline = split_first_line(
            letter, style, svg.context, inf, 0)
        x = svg.cursor_position[0] if x is None else x
        y = svg.cursor_position[1] if y is None else y
        width *= scale_x
        if i:
            x += letter_spacing
        svg.cursor_position = x + width, y

        x_position = x + svg.cursor_d_position[0]
        y_position = y + svg.cursor_d_position[1] + y_align
        angle = last_r if r is None else r
        points = (
            (x_position, y_position - baseline),
            (x_position + width, y_position - baseline + height))
        # TODO: Use ink extents instead of logical from line_break.line_size().
        node.text_bounding_box = extend_bounding_box(
            node.text_bounding_box, points)

        layout.reactivate(style)
        svg.fill_stroke(node, font_size, text=True)
        matrix = Matrix(a=scale_x, d=-1, e=x_position, f=y_position)
        if angle:
            a, c = cos(angle), sin(angle)
            matrix = Matrix(a, -c, c, a) @ matrix
        emojis = draw_first_line(
            svg.stream, TextBox(layout, style), 'none', 'none', matrix)
        emoji_lines.append((x, y, emojis))

    svg.stream.end_text()
    svg.stream.pop_state()

    for x, y, emojis in emoji_lines:
        draw_emojis(svg.stream, style, x, y, emojis)


================================================
FILE: weasyprint/svg/utils.py
================================================
"""Util functions for SVG rendering."""

import re
from contextlib import suppress
from math import cos, radians, sin, tan
from urllib.parse import urlparse

from tinycss2.color5 import parse_color

from ..matrix import Matrix


class PointError(Exception):
    """Exception raised when parsing a point fails."""


def normalize(string):
    """Give a canonical version of a given value string."""
    string = (string or '').replace('E', 'e')
    string = re.sub('(?<!e)-', ' -', string)
    string = re.sub('[ \n\r\t,]+', ' ', string)
    string = re.sub(r'(\.[0-9-]+)(?=\.)', r'\1 ', string)
    return string.strip()


def size(string, font_size=None, percentage_reference=None):
    """Compute size from string, resolving units and percentages."""
    from ..css.units import LENGTHS_TO_PIXELS

    if not string:
        return 0

    with suppress(ValueError):
        return float(string)

    # Not a float, try something else
    string = normalize(string).split(' ', 1)[0]
    if string.endswith('%'):
        assert percentage_reference is not None
        return float(string[:-1]) * percentage_reference / 100
    elif string.endswith('rem'):
        assert font_size is not None
        return font_size * float(string[:-3])
    elif string.endswith('em'):
        assert font_size is not None
        return font_size * float(string[:-2])
    elif string.endswith('ex'):
        # Assume that 1em == 2ex
        assert font_size is not None
        return font_size * float(string[:-2]) / 2

    for unit, coefficient in LENGTHS_TO_PIXELS.items():
        if string.endswith(unit):
            return float(string[:-len(unit)]) * coefficient

    # Unknown size
    return 0


def alpha_value(value):
    """Return opacity between 0 and 1 from str, number or percentage."""
    ratio = 1
    if isinstance(value, str):
        value = value.strip()
        if value.endswith('%'):
            ratio = 100
            value = value[:-1].strip()
    return min(1, max(0, float(value) / ratio))


def point(svg, string, font_size):
    """Pop first two size values from a string."""
    match = re.match('(.*?) (.*?)(?: |$)', string)
    if match:
        x, y = match.group(1, 2)
        string = string[match.end():]
        return (*svg.point(x, y, font_size), string)
    else:
        raise PointError


def preserve_ratio(svg, node, font_size, width, height, viewbox=None):
    """Compute scale and translation needed to preserve ratio."""
    viewbox = viewbox or node.get_viewbox()
    if viewbox:
        viewbox_width, viewbox_height = viewbox[2:]
    elif svg.tree == node:
        viewbox_width, viewbox_height = svg.get_intrinsic_size(font_size)
        if None in (viewbox_width, viewbox_height):
            return 1, 1, 0, 0
    else:
        return 1, 1, 0, 0

    scale_x = width / viewbox_width if viewbox_width else 1
    scale_y = height / viewbox_height if viewbox_height else 1

    if viewbox:
        aspect_ratio = node.get('preserveAspectRatio', 'xMidYMid').split()
    else:
        aspect_ratio = ('none',)
    align = aspect_ratio[0]
    if align == 'none':
        x_position = 'min'
        y_position = 'min'
    else:
        meet_or_slice = aspect_ratio[1] if len(aspect_ratio) > 1 else None
        if meet_or_slice == 'slice':
            scale_value = max(scale_x, scale_y)
        else:
            scale_value = min(scale_x, scale_y)
        scale_x = scale_y = scale_value
        x_position = align[1:4].lower()
        y_position = align[5:].lower()

    if node.tag == 'marker':
        translate_x, translate_y = svg.point(
            node.get('refX'), node.get('refY', '0'), font_size)
    else:
        translate_x = 0
        if x_position == 'mid':
            translate_x = (width - viewbox_width * scale_x) / 2
        elif x_position == 'max':
            translate_x = width - viewbox_width * scale_x

        translate_y = 0
        if y_position == 'mid':
            translate_y += (height - viewbox_height * scale_y) / 2
        elif y_position == 'max':
            translate_y += height - viewbox_height * scale_y

    if viewbox:
        translate_x -= viewbox[0] * scale_x
        translate_y -= viewbox[1] * scale_y

    return scale_x, scale_y, translate_x, translate_y


def parse_url(url):
    """Parse a URL, possibly in a "url(…)" string."""
    if url and url.startswith('url(') and url.endswith(')'):
        url = url[4:-1]
        if len(url) >= 2:
            for quote in ("'", '"'):
                if url[0] == url[-1] == quote:
                    url = url[1:-1]
                    break
    return urlparse(url or '')


def color(string):
    """Safely parse a color string and return a RGBA tuple."""
    return parse_color(string or '') or parse_color('black')


def transform(transform_string, transform_origin, font_size, normalized_diagonal):
    """Get a matrix corresponding to the transform string."""
    # TODO: merge with gather_anchors and css.validation.properties.transform

    origin_x, origin_y = 0, 0
    size_strings = normalize(transform_origin).split()
    if len(size_strings) == 2:
        origin_x, origin_y = size(size_strings[0]), size(size_strings[1])
    matrix = Matrix(e=origin_x, f=origin_y)

    transformations = re.findall(r'(\w+) ?\( ?(.*?) ?\)', normalize(transform_string))
    for transformation_type, transformation in transformations:
        values = [
            size(value, font_size, normalized_diagonal)
            for value in transformation.split(' ')]
        if transformation_type == 'matrix':
            matrix = Matrix(*values) @ matrix
        elif transformation_type == 'rotate':
            if len(values) == 3:
                matrix = Matrix(e=values[1], f=values[2]) @ matrix
            matrix = Matrix(
                cos(radians(float(values[0]))),
                sin(radians(float(values[0]))),
                -sin(radians(float(values[0]))),
                cos(radians(float(values[0])))) @ matrix
            if len(values) == 3:
                matrix = Matrix(e=-values[1], f=-values[2]) @ matrix
        elif transformation_type.startswith('skew'):
            if len(values) == 1:
                values.append(0)
            if transformation_type in ('skewX', 'skew'):
                matrix = Matrix(
                    c=tan(radians(float(values.pop(0))))) @ matrix
            if transformation_type in ('skewY', 'skew'):
                matrix = Matrix(
                    b=tan(radians(float(values.pop(0))))) @ matrix
        elif transformation_type.startswith('translate'):
            if len(values) == 1:
                values.append(0)
            if transformation_type in ('translateX', 'translate'):
                matrix = Matrix(e=values.pop(0)) @ matrix
            if transformation_type in ('translateY', 'translate'):
                matrix = Matrix(f=values.pop(0)) @ matrix
        elif transformation_type.startswith('scale'):
            if len(values) == 1:
                values.append(values[0])
            if transformation_type in ('scaleX', 'scale'):
                matrix = Matrix(a=values.pop(0)) @ matrix
            if transformation_type in ('scaleY', 'scale'):
                matrix = Matrix(d=values.pop(0)) @ matrix

    return Matrix(e=-origin_x, f=-origin_y) @ matrix


================================================
FILE: weasyprint/text/constants.py
================================================
"""Constants used for text layout."""

from functools import lru_cache

from .ffi import pango

# Pango features
PANGO_STYLE = {
    'normal': pango.PANGO_STYLE_NORMAL,
    'oblique': pango.PANGO_STYLE_OBLIQUE,
    'italic': pango.PANGO_STYLE_ITALIC,
}
PANGO_STRETCH = {
    'ultra-condensed': pango.PANGO_STRETCH_ULTRA_CONDENSED,
    'extra-condensed': pango.PANGO_STRETCH_EXTRA_CONDENSED,
    'condensed': pango.PANGO_STRETCH_CONDENSED,
    'semi-condensed': pango.PANGO_STRETCH_SEMI_CONDENSED,
    'normal': pango.PANGO_STRETCH_NORMAL,
    'semi-expanded': pango.PANGO_STRETCH_SEMI_EXPANDED,
    'expanded': pango.PANGO_STRETCH_EXPANDED,
    'extra-expanded': pango.PANGO_STRETCH_EXTRA_EXPANDED,
    'ultra-expanded': pango.PANGO_STRETCH_ULTRA_EXPANDED,
}
# From https://drafts.csswg.org/css-fonts/#font-stretch-prop
PANGO_STRETCH_PERCENT = {
    50: pango.PANGO_STRETCH_ULTRA_CONDENSED,
    62.5: pango.PANGO_STRETCH_EXTRA_CONDENSED,
    75: pango.PANGO_STRETCH_CONDENSED,
    87.5: pango.PANGO_STRETCH_SEMI_CONDENSED,
    100: pango.PANGO_STRETCH_NORMAL,
    112.5: pango.PANGO_STRETCH_SEMI_EXPANDED,
    125: pango.PANGO_STRETCH_EXPANDED,
    150: pango.PANGO_STRETCH_EXTRA_EXPANDED,
    200: pango.PANGO_STRETCH_ULTRA_EXPANDED,
}
PANGO_WRAP_MODE = {
    'WRAP_WORD': pango.PANGO_WRAP_WORD,
    'WRAP_CHAR': pango.PANGO_WRAP_CHAR,
    'WRAP_WORD_CHAR': pango.PANGO_WRAP_WORD_CHAR
}
# Some variants have been added in Pango 1.50 and are ignored when used.
PANGO_VARIANT = {
    'normal': pango.PANGO_VARIANT_NORMAL,
    'small-caps': pango.PANGO_VARIANT_SMALL_CAPS,
    'all-small-caps': pango.PANGO_VARIANT_ALL_SMALL_CAPS,
    'petite-caps': pango.PANGO_VARIANT_PETITE_CAPS,
    'all-petite-caps': pango.PANGO_VARIANT_ALL_PETITE_CAPS,
    'unicase': pango.PANGO_VARIANT_UNICASE,
    'titling-caps': pango.PANGO_VARIANT_TITLE_CAPS,
}

PANGO_DIRECTION = {
    'ltr': pango.PANGO_DIRECTION_LTR,
    'rtl': pango.PANGO_DIRECTION_RTL,
}

# Language system tags
# From https://docs.microsoft.com/typography/opentype/spec/languagetags
LST_TO_ISO = {
    'aba': 'abq',
    'afk': 'afr',
    'afr': 'aar',
    'agw': 'ahg',
    'als': 'gsw',
    'alt': 'atv',
    'ari': 'aiw',
    'ark': 'mhv',
    'ath': 'apk',
    'avr': 'ava',
    'bad': 'bfq',
    'bad0': 'bad',
    'bag': 'bfy',
    'bal': 'krc',
    'bau': 'bci',
    'bch': 'bcq',
    'bgr': 'bul',
    'bil': 'byn',
    'bkf': 'bla',
    'bli': 'bal',
    'bln': 'bjt',
    'blt': 'bft',
    'bmb': 'bam',
    'bri': 'bra',
    'brm': 'mya',
    'bsh': 'bak',
    'bti': 'btb',
    'chg': 'sgw',
    'chh': 'hne',
    'chi': 'nya',
    'chk': 'ckt',
    'chk0': 'chk',
    'chu': 'chv',
    'chy': 'chy',
    'cmr': 'swb',
    'crr': 'crx',
    'crt': 'crh',
    'csl': 'chu',
    'csy': 'ces',
    'dcr': 'cwd',
    'dgr': 'doi',
    'djr': 'dje',
    'djr0': 'djr',
    'dng': 'ada',
    'dnk': 'din',
    'dri': 'prs',
    'dun': 'dng',
    'dzn': 'dzo',
    'ebi': 'igb',
    'ecr': 'crj',
    'edo': 'bin',
    'erz': 'myv',
    'esp': 'spa',
    'eti': 'est',
    'euq': 'eus',
    'evk': 'evn',
    'evn': 'eve',
    'fan': 'acf',
    'fan0': 'fan',
    'far': 'fas',
    'fji': 'fij',
    'fle': 'vls',
    'fne': 'enf',
    'fos': 'fao',
    'fri': 'fry',
    'frl': 'fur',
    'frp': 'frp',
    'fta': 'fuf',
    'gad': 'gaa',
    'gae': 'gla',
    'gal': 'glg',
    'gaw': 'gbm',
    'gil': 'niv',
    'gil0': 'gil',
    'gmz': 'guk',
    'grn': 'kal',
    'gro': 'grt',
    'gua': 'grn',
    'hai': 'hat',
    'hal': 'flm',
    'har': 'hoj',
    'hbn': 'amf',
    'hma': 'mrj',
    'hnd': 'hno',
    'ho': 'hoc',
    'hri': 'har',
    'hye0': 'hye',
    'ijo': 'ijc',
    'ing': 'inh',
    'inu': 'iku',
    'iri': 'gle',
    'irt': 'gle',
    'ism': 'smn',
    'iwr': 'heb',
    'jan': 'jpn',
    'jii': 'yid',
    'jud': 'lad',
    'jul': 'dyu',
    'kab': 'kbd',
    'kab0': 'kab',
    'kac': 'kfr',
    'kal': 'kln',
    'kar': 'krc',
    'keb': 'ktb',
    'kge': 'kat',
    'kha': 'kjh',
    'khk': 'kca',
    'khs': 'kca',
    'khv': 'kca',
    'kis': 'kqs',
    'kkn': 'kex',
    'klm': 'xal',
    'kmb': 'kam',
    'kmn': 'kfy',
    'kmo': 'kmw',
    'kms': 'kxc',
    'knr': 'kau',
    'kod': 'kfa',
    'koh': 'okm',
    'kon': 'ktu',
    'kon0': 'kon',
    'kop': 'koi',
    'koz': 'kpv',
    'kpl': 'kpe',
    'krk': 'kaa',
    'krm': 'kdr',
    'krn': 'kar',
    'krt': 'kqy',
    'ksh': 'kas',
    'ksh0': 'ksh',
    'ksi': 'kha',
    'ksm': 'sjd',
    'kui': 'kxu',
    'kul': 'kfx',
    'kuu': 'kru',
    'kuy': 'kdt',
    'kyk': 'kpy',
    'lad': 'lld',
    'lah': 'bfu',
    'lak': 'lbe',
    'lam': 'lmn',
    'laz': 'lzz',
    'lcr': 'crm',
    'ldk': 'lbj',
    'lma': 'mhr',
    'lmb': 'lif',
    'lmw': 'ngl',
    'lsb': 'dsb',
    'lsm': 'smj',
    'lth': 'lit',
    'luh': 'luy',
    'lvi': 'lav',
    'maj': 'mpe',
    'mak': 'vmw',
    'man': 'mns',
    'map': 'arn',
    'maw': 'mwr',
    'mbn': 'kmb',
    'mch': 'mnc',
    'mcr': 'crm',
    'mde': 'men',
    'men': 'mym',
    'miz': 'lus',
    'mkr': 'mak',
    'mle': 'mdy',
    'mln': 'mlq',
    'mlr': 'mal',
    'mly': 'msa',
    'mnd': 'mnk',
    'mng': 'mon',
    'mnk': 'man',
    'mnx': 'glv',
    'mok': 'mdf',
    'mon': 'mnw',
    'mth': 'mai',
    'mts': 'mlt',
    'mun': 'unr',
    'nan': 'gld',
    'nas': 'nsk',
    'ncr': 'csw',
    'ndg': 'ndo',
    'nhc': 'csw',
    'nis': 'dap',
    'nkl': 'nyn',
    'nko': 'nqo',
    'nor': 'nob',
    'nsm': 'sme',
    'nta': 'nod',
    'nto': 'epo',
    'nyn': 'nno',
    'ocr': 'ojs',
    'ojb': 'oji',
    'oro': 'orm',
    'paa': 'sam',
    'pal': 'pli',
    'pap': 'plp',
    'pap0': 'pap',
    'pas': 'pus',
    'pgr': 'ell',
    'pil': 'fil',
    'plg': 'pce',
    'plk': 'pol',
    'ptg': 'por',
    'qin': 'bgr',
    'rbu': 'bxr',
    'rcr': 'atj',
    'rms': 'roh',
    'rom': 'ron',
    'roy': 'rom',
    'rsy': 'rue',
    'rua': 'kin',
    'sad': 'sck',
    'say': 'chp',
    'sek': 'xan',
    'sel': 'sel',
    'sgo': 'sag',
    'sgs': 'sgs',
    'sib': 'sjo',
    'sig': 'xst',
    'sks': 'sms',
    'sky': 'slk',
    'sla': 'scs',
    'sml': 'som',
    'sna': 'seh',
    'sna0': 'sna',
    'snh': 'sin',
    'sog': 'gru',
    'srb': 'srp',
    'ssl': 'xsl',
    'ssm': 'sma',
    'sur': 'suq',
    'sve': 'swe',
    'swa': 'aii',
    'swk': 'swa',
    'swz': 'ssw',
    'sxt': 'ngo',
    'taj': 'tgk',
    'tcr': 'cwd',
    'tgn': 'ton',
    'tgr': 'tig',
    'tgy': 'tir',
    'tht': 'tah',
    'tib': 'bod',
    'tkm': 'tuk',
    'tmn': 'tem',
    'tna': 'tsn',
    'tne': 'enh',
    'tng': 'toi',
    'tod': 'xal',
    'tod0': 'tod',
    'trk': 'tur',
    'tsg': 'tso',
    'tua': 'tru',
    'tul': 'tcy',
    'tuv': 'tyv',
    'twi': 'aka',
    'usb': 'hsb',
    'uyg': 'uig',
    'vit': 'vie',
    'vro': 'vro',
    'wa': 'wbm',
    'wag': 'wbr',
    'wcr': 'crk',
    'wel': 'cym',
    'wlf': 'wol',
    'xbd': 'khb',
    'xhs': 'xho',
    'yak': 'sah',
    'yba': 'yor',
    'ycr': 'cre',
    'yim': 'iii',
    'zhh': 'zho',
    'zhp': 'zho',
    'zhs': 'zho',
    'zht': 'zho',
    'znd': 'zne',
}

# Quotes, from https://github.com/unicode-org/cldr/tree/main/common/main
LANG_QUOTES = {
    None: (('“', '‘'), ('”', '’')),  # Default, chosen by user agent
    'ab': (('«', '„'), ('»', '“')),
    'agq': (('„', '‚'), ('”', '’')),
    'am': (('«', '‹'), ('»', '›')),
    'an': (('«', '”'), ('»', '”')),
    'ar': (('”', '’'), ('“', '‘')),
    'ast': (('«', '“'), ('»', '”')),
    'az_Arab': (('«', '‹'), ('»', '›')),
    'az_Cyrl': (('«', '‹'), ('»', '›')),
    'bas': (('«', '„'), ('»', '“')),
    'be': (('«', '„'), ('»', '“')),
    'bg': (('„',), ('“',)),
    'blo': (('«', '“'), ('»', '”')),
    'bm': (('«', '“'), ('»', '”')),
    'br': (('«', '“'), ('»', '”')),
    'bs': (('„', '‘'), ('”', '’')),
    'bs_Cyrl': (('„', '‚'), ('“', '‘')),
    'ca': (('«', '“'), ('»', '”')),
    'co': (('«',), ('»',)),
    'cs': (('„', '‚'), ('“', '‘')),
    'cu': (('«', '„'), ('»', '“')),
    'cv': (('«', '„'), ('»', '“')),
    'de': (('„', '‚'), ('“', '‘')),
    'dsb': (('„', '‚'), ('“', '‘')),
    'dua': (('«', '‘'), ('»', '’')),
    'dyo': (('«', '“'), ('»', '”')),
    'el': (('«', '“'), ('»', '”')),
    'el_POLYTON': (('«', '‘'), ('»', '’')),
    'es_US': (('«', '“'), ('»', '”')),
    'et': (('„', '‚'), ('“', '‘')),
    'eu': (('«', '“'), ('»', '”')),
    'ewo': (('«', '“'), ('»', '”')),
    'fa': (('«', '‹'), ('»', '›')),
    'ff': (('„', '‚'), ('”', '’')),
    'fi': (('”', '’'), ('”', '’')),
    'fr': (('«',), ('»',)),
    'fr_CA': (('«', '”'), ('»', '“')),
    'fr_CH': (('«', '‹'), ('»', '›')),
    'fur': (('‘', '“'), ('’', '”')),
    'gsw': (('«', '‹'), ('»', '›')),
    'he': (('”', '’'), ('”', '’')),
    'hr': (('„', '‚'), ('“', '‘')),
    'hsb': (('„', '‚'), ('“', '‘')),
    'hu': (('„', '»'), ('”', '«')),
    'hy': (('«',), ('»',)),
    'ia': (('‘', '“'), ('’', '”')),
    'ie': (('«', '“'), ('»', '”')),
    'is': (('„', '‚'), ('“', '‘')),
    'it': (('«', '“'), ('»', '”')),
    'it_CH': (('«', '‹'), ('»', '›')),
    'ja': (('「', '『'), ('」', '』')),
    'jgo': (('«', '‹'), ('»', '›')),
    'ka': (('„', '«'), ('“', '»')),
    'kab': (('«', '“'), ('»', '”')),
    'kk': (('«', '“'), ('»', '”')),
    'kkj': (('«', '‹'), ('»', '›')),
    'kl': (('»', '›'), ('«', '‹')),
    'ksf': (('«', '‘'), ('»', '’')),
    'ksh': (('„', '‚'), ('“', '‘')),
    'ky': (('«', '„'), ('»', '“')),
    'lag': (('”', '’'), ('”', '’')),
    'lb': (('„', '‚'), ('“', '‘')),
    'lij': (('«', '“'), ('»', '”')),
    'lt': (('„',), ('“',)),
    'luy': (('„', '‚'), ('“', '‘')),
    'mg': (('«', '“'), ('»', '”')),
    'mk': (('„', '‚'), ('“', '‘')),
    'ms_Arab': (('”', '’'), ('“', '‘')),
    'mua': (('«', '“'), ('»', '”')),
    'mzn': (('«', '‹'), ('»', '›')),
    'nds': (('„', '‚'), ('“', '‘')),
    'nl': (('‘',), ('’',)),
    'nmg': (('„', '«'), ('”', '»')),
    'nnh': (('«', '“'), ('»', '”')),
    'no': (('«', '‘'), ('»', '’')),
    'nr': (('‘', '“'), ('’', '”')),
    'nso': (('‘', '“'), ('’', '”')),
    'oc': (('«',), ('»',)),
    'oc_ES': (('«', '“'), ('»', '”')),
    'os': (('«', '„'), ('»', '“')),
    'pl': (('„', '«'), ('”', '»')),
    'prg': (('„',), ('“',)),
    'pt_PT': (('«', '“'), ('»', '”')),
    'rm': (('«', '‹'), ('»', '›')),
    'rn': (('”', '’'), ('”', '’')),
    'ro': (('„', '«'), ('”', '»')),
    'ru': (('«', '„'), ('»', '“')),
    'rw': (('«', '‘'), ('»', '’')),
    'sah': (('«', '„'), ('»', '“')),
    'sc': (('«', '“'), ('»', '”')),
    'sdh': (('«', '‹'), ('»', '›')),
    'se': (('”', '’'), ('”', '’')),
    'sg': (('«', '“'), ('»', '”')),
    'shi': (('«', '„'), ('»', '”')),
    'sk': (('„', '‚'), ('“', '‘')),
    'sl': (('„', '‚'), ('“', '‘')),
    'sn': (('”', '’'), ('”', '’')),
    'sq': (('«', '“'), ('»', '”')),
    'sr': (('„', '‘'), ('“', '‘')),
    'sr_Latn': (('„', '‘'), ('“', '‘')),
    'ss': (('‘', '“'), ('’', '”')),
    'st': (('‘', '“'), ('’', '”')),
    'sv': (('”', '’'), ('”', '’')),
    'syr': (('”', '’'), ('“', '‘')),
    'szl': (('„', '»'), ('”', '«')),
    'tg': (('»', '‘'), ('«', '’')),
    'ti': (('«', '“'), ('»', '”')),
    'ti_ER': (('‘', '“'), ('’', '”')),
    'tk': (('“',), ('”',)),
    'tn': (('‘', '“'), ('’', '”')),
    'ts': (('‘', '“'), ('’', '”')),
    'ug': (('»', '›'), ('«', '‹')),
    'uk': (('«', '„'), ('»', '“')),
    'ur': (('”', '’'), ('“', '‘')),
    'uz': (('“', '’'), ('”', '‘')),
    've': (('‘', '“'), ('’', '”')),
    'wae': (('«', '‹'), ('»', '›')),
    'yav': (('«',), ('»',)),
    'yi': (('”', '’'), ('”', '’')),
    'yue': (('「', '『'), ('」', '』')),
    'zgh': (('«', '„'), ('»', '”')),
    'zh_Hant': (('「', '『'), ('」', '』')),
}


@lru_cache
def get_lang_quotes(lang):
    if lang in LANG_QUOTES:
        return LANG_QUOTES[lang]
    # Revert to find long names before short ones
    for key, value in tuple(LANG_QUOTES.items())[::-1]:
        if key and lang.startswith(key):
            return value
    return LANG_QUOTES[None]


# Font features
LIGATURE_KEYS = {
    'common-ligatures': ['liga', 'clig'],
    'historical-ligatures': ['hlig'],
    'discretionary-ligatures': ['dlig'],
    'contextual': ['calt'],
}
CAPS_KEYS = {
    'small-caps': ['smcp'],
    'all-small-caps': ['c2sc', 'smcp'],
    'petite-caps': ['pcap'],
    'all-petite-caps': ['c2pc', 'pcap'],
    'unicase': ['unic'],
    'titling-caps': ['titl'],
}
NUMERIC_KEYS = {
    'lining-nums': 'lnum',
    'oldstyle-nums': 'onum',
    'proportional-nums': 'pnum',
    'tabular-nums': 'tnum',
    'diagonal-fractions': 'frac',
    'stacked-fractions': 'afrc',
    'ordinal': 'ordn',
    'slashed-zero': 'zero',
}
EAST_ASIAN_KEYS = {
    'jis78': 'jp78',
    'jis83': 'jp83',
    'jis90': 'jp90',
    'jis04': 'jp04',
    'simplified': 'smpl',
    'traditional': 'trad',
    'full-width': 'fwid',
    'proportional-width': 'pwid',
    'ruby': 'ruby',
}

# Fontconfig features
FONTCONFIG_WEIGHT = {
    'normal': 80,
    'bold': 200,
    100: 0,
    200: 40,
    300: 50,
    400: 80,
    500: 100,
    600: 180,
    700: 200,
    800: 205,
    900: 210,
}
FONTCONFIG_STYLE = {
    'normal': 'roman',
    'italic': 'italic',
    'oblique': 'oblique',
}
FONTCONFIG_STRETCH = {
    'normal': 'normal',
    'ultra-condensed': 'ultracondensed',
    'extra-condensed': 'extracondensed',
    'condensed': 'condensed',
    'semi-condensed': 'semicondensed',
    'semi-expanded': 'semiexpanded',
    'expanded': 'expanded',
    'extra-expanded': 'extraexpanded',
    'ultra-expanded': 'ultraexpanded',
}


================================================
FILE: weasyprint/text/ffi.py
================================================
"""Imports of dynamic libraries used for text layout."""

import os
import sys
from contextlib import suppress

import cffi

ffi = cffi.FFI()
ffi.cdef('''
    // HarfBuzz

    typedef ... hb_font_t;
    typedef ... hb_face_t;
    typedef ... hb_blob_t;
    typedef int hb_bool_t;
    typedef uint32_t hb_tag_t;
    typedef uint32_t hb_codepoint_t;
    hb_tag_t hb_tag_from_string (const char *str, int len);
    void hb_tag_to_string (hb_tag_t tag, char *buf);
    void hb_face_destroy (hb_face_t *face);
    hb_blob_t * hb_face_reference_blob (hb_face_t *face);
    unsigned int hb_face_get_index (const hb_face_t *face);
    unsigned int hb_face_get_upem (const hb_face_t *face);
    unsigned int hb_face_get_glyph_count (const hb_face_t *face);
    hb_blob_t * hb_face_reference_table (const hb_face_t *face, hb_tag_t tag);
    const char * hb_blob_get_data (hb_blob_t *blob, unsigned int *length);
    unsigned int hb_blob_get_length (hb_blob_t *blob);
    bool hb_ot_color_has_png (hb_face_t *face);
    hb_blob_t * hb_ot_color_glyph_reference_png (hb_font_t *font, hb_codepoint_t glyph);
    bool hb_ot_color_has_svg (hb_face_t *face);
    hb_blob_t * hb_ot_color_glyph_reference_svg (hb_face_t *face, hb_codepoint_t glyph);
    void hb_blob_destroy (hb_blob_t *blob);
    unsigned int hb_face_get_table_tags (
        const hb_face_t *face, unsigned int start_offset, unsigned int *table_count,
        hb_tag_t *table_tags);
    hb_bool_t hb_version_atleast (
        unsigned int major, unsigned int minor, unsigned int micro);

    // HarfBuzz Subset

    typedef ... hb_subset_input_t;
    typedef ... hb_set_t;

    typedef enum {
        HB_SUBSET_FLAGS_DEFAULT = 0x00000000u,
        HB_SUBSET_FLAGS_NO_HINTING = 0x00000001u,
        HB_SUBSET_FLAGS_RETAIN_GIDS = 0x00000002u,
        HB_SUBSET_FLAGS_DESUBROUTINIZE = 0x00000004u,
        HB_SUBSET_FLAGS_NAME_LEGACY = 0x00000008u,
        HB_SUBSET_FLAGS_SET_OVERLAPS_FLAG = 0x00000010u,
        HB_SUBSET_FLAGS_PASSTHROUGH_UNRECOGNIZED = 0x00000020u,
        HB_SUBSET_FLAGS_NOTDEF_OUTLINE = 0x00000040u,
        HB_SUBSET_FLAGS_GLYPH_NAMES = 0x00000080u,
        HB_SUBSET_FLAGS_NO_PRUNE_UNICODE_RANGES = 0x00000100u,
        HB_SUBSET_FLAGS_NO_LAYOUT_CLOSURE = 0x00000200u,
    } hb_subset_flags_t;

    typedef enum {
        HB_SUBSET_SETS_GLYPH_INDEX = 0,
        HB_SUBSET_SETS_UNICODE,
        HB_SUBSET_SETS_NO_SUBSET_TABLE_TAG,
        HB_SUBSET_SETS_DROP_TABLE_TAG,
        HB_SUBSET_SETS_NAME_ID,
        HB_SUBSET_SETS_NAME_LANG_ID,
        HB_SUBSET_SETS_LAYOUT_FEATURE_TAG,
        HB_SUBSET_SETS_LAYOUT_SCRIPT_TAG,
    } hb_subset_sets_t;

    hb_subset_input_t * hb_subset_input_create_or_fail (void);
    void hb_subset_input_destroy (hb_subset_input_t *input);
    hb_set_t * hb_subset_input_glyph_set (hb_subset_input_t *input);
    void hb_set_add_sorted_array (
        hb_set_t *set, const hb_codepoint_t *sorted_codepoints,
        unsigned int num_codepoints);
    hb_face_t * hb_subset_or_fail (hb_face_t *source, const hb_subset_input_t *input);
    void hb_subset_input_set_flags (hb_subset_input_t *input, unsigned  value);
    hb_set_t * hb_subset_input_set (
        hb_subset_input_t *input, hb_subset_sets_t set_type);

    // Pango

    typedef unsigned int guint;
    typedef int gint;
    typedef char gchar;
    typedef gint gboolean;
    typedef void* gpointer;
    typedef ... PangoLayout;
    typedef ... PangoContext;
    typedef ... PangoFontMap;
    typedef ... PangoFontMetrics;
    typedef ... PangoLanguage;
    typedef ... PangoTabArray;
    typedef ... PangoFontDescription;
    typedef ... PangoLayoutIter;
    typedef ... PangoAttrList;
    typedef ... PangoAttrClass;
    typedef ... PangoFont;
    typedef guint PangoGlyph;
    typedef gint PangoGlyphUnit;

    const guint PANGO_GLYPH_EMPTY = 0x0FFFFFFF;
    const guint PANGO_GLYPH_UNKNOWN_FLAG = 0x10000000;

    typedef enum {
        PANGO_STYLE_NORMAL,
        PANGO_STYLE_OBLIQUE,
        PANGO_STYLE_ITALIC
    } PangoStyle;

    typedef enum {
        PANGO_WEIGHT_THIN = 100,
        PANGO_WEIGHT_ULTRALIGHT = 200,
        PANGO_WEIGHT_LIGHT = 300,
        PANGO_WEIGHT_BOOK = 380,
        PANGO_WEIGHT_NORMAL = 400,
        PANGO_WEIGHT_MEDIUM = 500,
        PANGO_WEIGHT_SEMIBOLD = 600,
        PANGO_WEIGHT_BOLD = 700,
        PANGO_WEIGHT_ULTRABOLD = 800,
        PANGO_WEIGHT_HEAVY = 900,
        PANGO_WEIGHT_ULTRAHEAVY = 1000
    } PangoWeight;

    typedef enum {
        PANGO_FONT_MASK_SIZE = 1 << 5,
        PANGO_FONT_MASK_GRAVITY = 1 << 6,
        PANGO_FONT_MASK_VARIATIONS = 1 << 7
    } PangoFontMask;

    typedef enum {
        PANGO_STRETCH_ULTRA_CONDENSED,
        PANGO_STRETCH_EXTRA_CONDENSED,
        PANGO_STRETCH_CONDENSED,
        PANGO_STRETCH_SEMI_CONDENSED,
        PANGO_STRETCH_NORMAL,
        PANGO_STRETCH_SEMI_EXPANDED,
        PANGO_STRETCH_EXPANDED,
        PANGO_STRETCH_EXTRA_EXPANDED,
        PANGO_STRETCH_ULTRA_EXPANDED
    } PangoStretch;

    typedef enum {
        PANGO_WRAP_WORD,
        PANGO_WRAP_CHAR,
        PANGO_WRAP_WORD_CHAR
    } PangoWrapMode;

    typedef enum {
        PANGO_VARIANT_NORMAL,
        PANGO_VARIANT_SMALL_CAPS,
        PANGO_VARIANT_ALL_SMALL_CAPS,
        PANGO_VARIANT_PETITE_CAPS,
        PANGO_VARIANT_ALL_PETITE_CAPS,
        PANGO_VARIANT_UNICASE,
        PANGO_VARIANT_TITLE_CAPS,
    } PangoVariant;

    typedef enum {
        PANGO_TAB_LEFT
    } PangoTabAlign;

    typedef enum {
        PANGO_ELLIPSIZE_NONE,
        PANGO_ELLIPSIZE_START,
        PANGO_ELLIPSIZE_MIDDLE,
        PANGO_ELLIPSIZE_END
    } PangoEllipsizeMode;

    typedef enum {
        PANGO_DIRECTION_LTR,
        PANGO_DIRECTION_RTL,
        PANGO_DIRECTION_TTB_LTR,
        PANGO_DIRECTION_TTB_RTL,
        PANGO_DIRECTION_WEAK_LTR,
        PANGO_DIRECTION_WEAK_RTL,
        PANGO_DIRECTION_NEUTRAL
    } PangoDirection;

    typedef struct GSList {
       gpointer data;
       struct GSList *next;
    } GSList;

    typedef struct {
        void *shape_engine;
        void *lang_engine;
        PangoFont *font;
        guint level;
        guint gravity;
        guint flags;
        guint script;
        PangoLanguage *language;
        GSList *extra_attrs;
    } PangoAnalysis;

    typedef struct {
        gint offset;
        gint length;
        gint num_chars;
        PangoAnalysis analysis;
    } PangoItem;

    typedef struct {
        PangoGlyphUnit width;
        PangoGlyphUnit x_offset;
        PangoGlyphUnit y_offset;
    } PangoGlyphGeometry;

    typedef struct {
        guint is_cluster_start : 1;
    } PangoGlyphVisAttr;

    typedef struct {
        PangoGlyph         glyph;
        PangoGlyphGeometry geometry;
        PangoGlyphVisAttr  attr;
    } PangoGlyphInfo;

    typedef struct {
        gint num_glyphs;
        PangoGlyphInfo *glyphs;
        gint *log_clusters;
    } PangoGlyphString;

    typedef struct {
        PangoItem        *item;
        PangoGlyphString *glyphs;
    } PangoGlyphItem;

    typedef struct GSListRuns {
       PangoGlyphItem    *data;
       struct GSListRuns *next;
    } GSListRuns;

    typedef struct {
        const PangoAttrClass *klass;
        guint start_index;
        guint end_index;
    } PangoAttribute;

    typedef struct {
        PangoLayout *layout;
        gint         start_index;
        gint         length;
        GSListRuns  *runs;
        guint        is_paragraph_start : 1;
        guint        resolved_dir : 3;
    } PangoLayoutLine;

    typedef struct  {
        int x;
        int y;
        int width;
        int height;
    } PangoRectangle;

    typedef struct {
        guint is_line_break: 1;
        guint is_mandatory_break : 1;
        guint is_char_break : 1;
        guint is_white : 1;
        guint is_cursor_position : 1;
        guint is_word_start : 1;
        guint is_word_end : 1;
        guint is_sentence_boundary : 1;
        guint is_sentence_start : 1;
        guint is_sentence_end : 1;
        guint backspace_deletes_character : 1;
        guint is_expandable_space : 1;
        guint is_word_boundary : 1;
    } PangoLogAttr;

    int pango_version (void);

    double pango_units_to_double (int i);
    int pango_units_from_double (double d);
    void g_object_unref (gpointer object);
    void g_type_init (void);

    PangoLayout * pango_layout_new (PangoContext *context);
    void pango_layout_set_width (PangoLayout *layout, int width);
    PangoAttrList * pango_layout_get_attributes (PangoLayout *layout);
    void pango_layout_set_attributes (PangoLayout *layout, PangoAttrList *attrs);
    void pango_layout_set_text (PangoLayout *layout, const char *text, int length);
    void pango_layout_set_tabs (PangoLayout *layout, PangoTabArray *tabs);
    void pango_layout_set_font_description (
        PangoLayout *layout, const PangoFontDescription *desc);
    void pango_layout_set_wrap (PangoLayout *layout, PangoWrapMode wrap);
    void pango_layout_set_single_paragraph_mode (PangoLayout *layout, gboolean setting);
    void pango_layout_set_ellipsize (PangoLayout *layout, PangoEllipsizeMode ellipsize);
    void pango_layout_set_auto_dir (PangoLayout *layout, gboolean auto_dir);
    int pango_layout_get_baseline (PangoLayout *layout);
    void pango_layout_line_get_extents (
        PangoLayoutLine *line, PangoRectangle *ink_rect, PangoRectangle *logical_rect);
    PangoLayoutLine * pango_layout_get_line_readonly (PangoLayout *layout, int line);
    const PangoLogAttr* pango_layout_get_log_attrs_readonly (
        PangoLayout* layout, gint* n_attrs);

    hb_font_t * pango_font_get_hb_font (PangoFont *font);

    PangoFontDescription * pango_font_description_new (void);
    void pango_font_description_free (PangoFontDescription *desc);
    PangoFontMap* pango_font_get_font_map (PangoFont* font);

    void pango_font_description_set_family (
        PangoFontDescription *desc, const char *family);
    void pango_font_description_set_style (
        PangoFontDescription *desc, PangoStyle style);
    void pango_font_description_set_stretch (
        PangoFontDescription *desc, PangoStretch stretch);
    void pango_font_description_set_weight (
        PangoFontDescription *desc, PangoWeight weight);
    void pango_font_description_set_absolute_size (
        PangoFontDescription *desc, double size);
    void pango_font_description_set_variations (
        PangoFontDescription* desc, const char* variations);
    void pango_font_description_set_variant (
        PangoFontDescription* desc, PangoVariant variant);

    PangoStyle pango_font_description_get_style (const PangoFontDescription *desc);
    const char* pango_font_description_get_variations (
        const PangoFontDescription* desc);
    PangoWeight pango_font_description_get_weight (const PangoFontDescription* desc);
    int pango_font_description_get_size (PangoFontDescription *desc);

    void pango_font_description_unset_fields (
        PangoFontDescription* desc, PangoFontMask to_unset);

    char * pango_font_description_to_string (const PangoFontDescription *desc);

    PangoFontDescription * pango_font_describe_with_absolute_size (PangoFont *font);
    const char * pango_font_description_get_family (const PangoFontDescription *desc);
    guint pango_font_description_hash (const PangoFontDescription *desc);

    PangoContext * pango_font_map_create_context (PangoFontMap *fontmap);
    PangoFont* pango_font_map_load_font (
        PangoFontMap* fontmap, PangoContext* context, const PangoFontDescription* desc);

    PangoFontMetrics * pango_context_get_metrics (
        PangoContext *context, const PangoFontDescription *desc,
        PangoLanguage *language);
    PangoFontMetrics * pango_font_get_metrics (
        PangoFont *font, PangoLanguage *language);
    void pango_font_metrics_unref (PangoFontMetrics *metrics);
    int pango_font_metrics_get_ascent (PangoFontMetrics *metrics);
    int pango_font_metrics_get_descent (PangoFontMetrics *metrics);
    int pango_font_metrics_get_underline_thickness (PangoFontMetrics *metrics);
    int pango_font_metrics_get_underline_position (PangoFontMetrics *metrics);
    int pango_font_metrics_get_strikethrough_thickness (PangoFontMetrics *metrics);
    int pango_font_metrics_get_strikethrough_position (PangoFontMetrics *metrics);
    void pango_font_get_glyph_extents (
        PangoFont *font, PangoGlyph glyph, PangoRectangle *ink_rect,
        PangoRectangle *logical_rect);

    void pango_context_set_round_glyph_positions (
        PangoContext *context, gboolean round_positions);

    PangoAttrList * pango_attr_list_new (void);
    void pango_attr_list_unref (PangoAttrList *list);
    void pango_attr_list_insert (PangoAttrList *list, PangoAttribute *attr);
    void pango_attr_list_change (PangoAttrList *list, PangoAttribute *attr);
    PangoAttribute * pango_attr_font_features_new (const gchar *features);
    PangoAttribute * pango_attr_letter_spacing_new (int letter_spacing);
    PangoAttribute * pango_attr_insert_hyphens_new (gboolean insert_hyphens);

    PangoTabArray * pango_tab_array_new_with_positions (
        gint size, gboolean positions_in_pixels, PangoTabAlign first_alignment,
        gint first_position, ...);
    void pango_tab_array_free (PangoTabArray *tab_array);

    PangoLanguage * pango_language_from_string (const char *language);
    PangoLanguage * pango_language_get_default (void);
    void pango_context_set_language (PangoContext *context, PangoLanguage *language);
    void pango_context_set_base_dir (PangoContext *context, PangoDirection direction);

    void pango_get_log_attrs (
        const char *text, int length, int level, PangoLanguage *language,
        PangoLogAttr *log_attrs, int attrs_len);


    // FontConfig

    typedef int FcBool;
    typedef struct _FcConfig FcConfig;
    typedef struct _FcPattern FcPattern;
    typedef struct _FcStrList FcStrList;
    typedef unsigned char FcChar8;

    typedef enum {
        FcResultMatch, FcResultNoMatch, FcResultTypeMismatch, FcResultNoId,
        FcResultOutOfMemory
    } FcResult;

    typedef enum {
        FcMatchPattern, FcMatchFont, FcMatchScan
    } FcMatchKind;

    typedef struct _FcFontSet {
        int nfont;
        int sfont;
        FcPattern **fonts;
    } FcFontSet;

    typedef enum _FcSetName {
        FcSetSystem = 0,
        FcSetApplication = 1
    } FcSetName;

    FcConfig * FcInitLoadConfigAndFonts (void);
    void FcConfigDestroy (FcConfig *config);
    FcBool FcConfigAppFontAddFile (FcConfig *config, const FcChar8 *file);
    FcBool FcConfigParseAndLoadFromMemory (
        FcConfig *config, const FcChar8 *buffer, FcBool complain);

    FcFontSet * FcConfigGetFonts (FcConfig *config, FcSetName set);
    FcStrList * FcConfigGetConfigFiles (FcConfig *config);
    FcChar8 * FcStrListNext (FcStrList *list);

    void FcDefaultSubstitute (FcPattern *pattern);
    FcBool FcConfigSubstitute (FcConfig *config, FcPattern *p, FcMatchKind kind);

    FcPattern * FcPatternCreate (void);
    FcPattern * FcPatternDestroy (FcPattern *p);
    FcBool FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s);
    FcResult FcPatternGetString (FcPattern *p, const char *object, int n, FcChar8 **s);
    FcPattern * FcFontMatch (FcConfig *config, FcPattern *p, FcResult *result);


    // PangoFT2

    typedef ... PangoFcFont;
    typedef ... PangoFcFontMap;

    PangoFontMap * pango_ft2_font_map_new (void);
    void pango_fc_font_map_set_config (PangoFcFontMap *fcfontmap, FcConfig *fcconfig);
    void pango_fc_font_map_config_changed (PangoFcFontMap *fcfontmap);
    hb_face_t* pango_fc_font_map_get_hb_face (
         PangoFcFontMap* fcfontmap, PangoFcFont* fcfont);
''')


def _dlopen(ffi, *names, allow_fail=False):
    """Try various names for the same library, for different platforms."""
    if os.name == 'nt':
        flags = 0x00001000  # LOAD_LIBRARY_SEARCH_DEFAULT_DIRS
    else:
        flags = ffi.RTLD_NOW  # default
    for name in names:
        with suppress(OSError):
            return ffi.dlopen(name, flags)
    if allow_fail:
        return
    # Print error message and re-raise the exception.
    print(  # noqa: T201, logger is not configured yet
        '\n-----\n\n'
        'WeasyPrint could not import some external libraries. Please '
        'carefully follow the installation steps before reporting an issue:\n'
        'https://doc.courtbouillon.org/weasyprint/stable/'
        'first_steps.html#installation\n'
        'https://doc.courtbouillon.org/weasyprint/stable/'
        'first_steps.html#troubleshooting',
        '\n\n-----\n')  # pragma: no cover
    return ffi.dlopen(names[0], flags)  # pragma: no cover


if hasattr(os, 'add_dll_directory') and not hasattr(sys, 'frozen'):  # pragma: no cover
    dll_directories = os.getenv(
        'WEASYPRINT_DLL_DIRECTORIES',
        'C:\\msys64\\mingw64\\bin;'
        'C:\\Program Files\\GTK3-Runtime Win64\\bin').split(';')
    for dll_directory in dll_directories:
        with suppress((OSError, FileNotFoundError)):
            os.add_dll_directory(dll_directory)

gobject = _dlopen(
    ffi, 'libgobject-2.0-0', 'gobject-2.0-0', 'gobject-2.0',
    'libgobject-2.0.so.0', 'libgobject-2.0.0.dylib', 'libgobject-2.0-0.dll')
pango = _dlopen(
    ffi, 'libpango-1.0-0', 'pango-1.0-0', 'pango-1.0', 'libpango-1.0.so.0',
    'libpango-1.0.dylib', 'libpango-1.0-0.dll')
harfbuzz = _dlopen(
    ffi, 'libharfbuzz-0', 'harfbuzz', 'harfbuzz-0.0',
    'libharfbuzz.so.0', 'libharfbuzz.0.dylib', 'libharfbuzz-0.dll')
harfbuzz_subset = _dlopen(
    ffi, 'libharfbuzz-subset-0', 'harfbuzz-subset', 'harfbuzz-subset-0.0',
    'libharfbuzz-subset.so.0', 'libharfbuzz-subset.0.dylib', 'libharfbuzz-subset-0.dll',
    allow_fail=True)
fontconfig = _dlopen(
    ffi, 'libfontconfig-1', 'fontconfig-1', 'fontconfig',
    'libfontconfig.so.1', 'libfontconfig.1.dylib', 'libfontconfig-1.dll')
pangoft2 = _dlopen(
    ffi, 'libpangoft2-1.0-0', 'pangoft2-1.0-0', 'pangoft2-1.0',
    'libpangoft2-1.0.so.0', 'libpangoft2-1.0.dylib', 'libpangoft2-1.0-0.dll')

gobject.g_type_init()

# Call once to avoid int overflows.
TO_UNITS = pango.pango_units_from_double(1)
FROM_UNITS = pango.pango_units_to_double(1)


def unicode_to_char_p(string):
    """Return ``(pointer, bytestring)``.

    The byte string must live at least as long as the pointer is used.

    """
    bytestring = string.encode().replace(b'\x00', b'')
    return ffi.new('char[]', bytestring), bytestring


================================================
FILE: weasyprint/text/fonts.py
================================================
"""Interface with external libraries managing fonts installed on the system."""

from hashlib import md5
from io import BytesIO
from locale import getpreferredencoding
from pathlib import Path
from shutil import rmtree
from tempfile import mkdtemp
from warnings import warn
from xml.etree.ElementTree import Element, SubElement, tostring

from fontTools.ttLib import TTFont, woff2

from ..logger import LOGGER
from ..urls import fetch

from .constants import (  # isort:skip
    CAPS_KEYS, EAST_ASIAN_KEYS, FONTCONFIG_STRETCH, FONTCONFIG_STYLE, FONTCONFIG_WEIGHT,
    LIGATURE_KEYS, NUMERIC_KEYS, PANGO_STRETCH, PANGO_STYLE, PANGO_VARIANT)
from .ffi import (  # isort:skip
    FROM_UNITS, TO_UNITS, ffi, fontconfig, gobject, harfbuzz, pango, pangoft2,
    unicode_to_char_p)

PREFERRED_ENCODING = getpreferredencoding(False)


def _check_font_configuration(font_config):  # pragma: no cover
    """Check whether the given font_config has fonts.

    The default fontconfig configuration file may be missing (particularly
    on Windows or macOS, where installation of fontconfig isn't as
    standardized as on Linux), resulting in "Fontconfig error: Cannot load
    default config file".

    Fontconfig tries to retrieve the system fonts as fallback, which may or
    may not work, especially on macOS, where fonts can be installed at
    various loactions. On Windows (at least since fontconfig 2.13) the
    fallback seems to work.

    If there’s no default configuration and the system fonts fallback
    fails, or if the configuration file exists but doesn’t provide fonts,
    output will be ugly.

    If you happen to have no fonts and an HTML document without a valid
    @font-face, all letters turn into rectangles.

    If you happen to have an HTML document with at least one valid
    @font-face, all text is styled with that font.

    On Windows and macOS we can cause Pango to use native font rendering
    instead of rendering fonts with FreeType. But then we must do without
    @font-face. Expect other missing features and ugly output.

    """
    # Having fonts means: fontconfig's config file returns fonts or
    # fontconfig managed to retrieve system fallback-fonts. On Windows the
    # fallback stragegy seems to work since fontconfig >= 2.13.
    fonts = fontconfig.FcConfigGetFonts(font_config, fontconfig.FcSetSystem)
    # Of course, with nfont == 1 the user wont be happy, too…
    if fonts.nfont > 0:
        return

    # Find the reason why we have no fonts.
    config_files = fontconfig.FcConfigGetConfigFiles(font_config)
    config_file = fontconfig.FcStrListNext(config_files)
    if config_file == ffi.NULL:
        warn('FontConfig cannot load default config file. Expect ugly output.')
    else:
        # Useless config file, or indeed no fonts.
        warn('No fonts configured in FontConfig. Expect ugly output.')


_check_font_configuration(ffi.gc(
    fontconfig.FcInitLoadConfigAndFonts(), fontconfig.FcConfigDestroy))


class FontConfiguration:
    """A Fontconfig font configuration.

    Keep a list of fonts, including fonts installed on the system, fonts
    installed for the current user, and fonts referenced by cascading
    stylesheets.

    When created, an instance of this class gathers available fonts. It can
    then be given to :class:`weasyprint.HTML` methods or to
    :class:`weasyprint.CSS` to find fonts in ``@font-face`` rules.

    """
    _folder = None  # required by __del__ when code stops before __init__ finishes

    def __init__(self):
        """Create a Fontconfig font configuration.

        See Behdad's blog:
        https://mces.blogspot.fr/2015/05/how-to-use-custom-application-fonts.html

        """
        # Load the main config file and the fonts.
        self._config = ffi.gc(
            fontconfig.FcInitLoadConfigAndFonts(), fontconfig.FcConfigDestroy)
        self.font_map = ffi.gc(
            pangoft2.pango_ft2_font_map_new(), gobject.g_object_unref)
        pangoft2.pango_fc_font_map_set_config(
            ffi.cast('PangoFcFontMap *', self.font_map), self._config)
        # pango_fc_font_map_set_config keeps a reference to config.
        fontconfig.FcConfigDestroy(self._config)

        # Temporary folder storing fonts.
        self._folder = None

        # Cache.
        self.strut_layouts = {}
        self.font_features = {}

    def add_font_face(self, rule_descriptors, url_fetcher):
        """Add a font face to the Fontconfig configuration."""

        # Define path where to save font, depending on the rule descriptors.
        config_key = str(rule_descriptors)
        config_digest = md5(config_key.encode(), usedforsecurity=False).hexdigest()
        if self._folder is None:
            self._folder = Path(mkdtemp(prefix='weasyprint-'))
        font_path = self._folder / config_digest
        if font_path.exists():
            # Font already exists, we have nothing more to do.
            return

        # Try values in "src" descriptor until one works.
        string = ffi.new('FcChar8 **')
        for font_type, url in rule_descriptors['src']:
            # Abort if font URL is broken.
            if url is None or font_type == 'internal':
                continue

            # Try to find a font installed on the system that matches descriptors.
            if font_type == 'local':
                # Create a pattern that matches font name.
                font_name = url.encode()
                pattern = ffi.gc(
                    fontconfig.FcPatternCreate(), fontconfig.FcPatternDestroy)
                fontconfig.FcConfigSubstitute(
                    self._config, pattern, fontconfig.FcMatchFont)
                fontconfig.FcDefaultSubstitute(pattern)
                fontconfig.FcPatternAddString(pattern, b'fullname', font_name)
                fontconfig.FcPatternAddString(pattern, b'postscriptname', font_name)
                result = ffi.new('FcResult *')
                matching_pattern = fontconfig.FcFontMatch(self._config, pattern, result)
                if matching_pattern == ffi.NULL:
                    # No font has been found, abort.
                    LOGGER.debug('Failed to get matching local font for %r', url)
                    continue

                # Check that the font name in descriptor matches name in font.
                for tag in b'fullname', b'postscriptname':
                    fontconfig.FcPatternGetString(matching_pattern, tag, 0, string)
                    name = ffi.string(string[0])
                    if font_name.lower() == name.lower():
                        fontconfig.FcPatternGetString(
                            matching_pattern, b'file', 0, string)
                        path = ffi.string(string[0]).decode(PREFERRED_ENCODING)
                        url = Path(path).as_uri()
                        break
                else:
                    # Names don’t match, abort.
                    LOGGER.debug('Failed to load local font %r', font_name.decode())
                    continue

            # Get font content.
            try:
                with fetch(url_fetcher, url) as response:
                    font = response.read()
            except Exception as exception:
                LOGGER.debug('Failed to load font at %r (%s)', url, exception)
                continue

            # Store font content.
            try:
                # Decode woff and woff2 fonts.
                if font[:3] == b'wOF':
                    out = BytesIO()
                    woff_version_byte = font[3:4]
                    if woff_version_byte == b'F':  # woff font
                        ttfont = TTFont(BytesIO(font))
                        ttfont.flavor = ttfont.flavorData = None
                        ttfont.save(out)
                    elif woff_version_byte == b'2':  # woff2 font
                        woff2.decompress(BytesIO(font), out)
                    font = out.getvalue()
            except Exception as exc:
                LOGGER.debug('Failed to handle woff font at %r (%s)', url, exc)
                continue
            font_path.write_bytes(font)

            # Create Fontconfig XML config file.
            mode = 'assign_replace'
            root = Element('fontconfig')
            match = SubElement(root, 'match', target='scan')
            test = SubElement(match, 'test', name='file', compare='eq')
            SubElement(test, 'string').text = str(font_path)
            # Prepend, as replacing the font family breaks Pango, see #2510.
            edit = SubElement(match, 'edit', name='family', mode='prepend')
            SubElement(edit, 'string').text = rule_descriptors['font_family']
            if 'font_style' in rule_descriptors:
                edit = SubElement(match, 'edit', name='slant', mode=mode)
                text = FONTCONFIG_STYLE[rule_descriptors['font_style']]
                SubElement(edit, 'const').text = text
            if 'font_weight' in rule_descriptors:
                edit = SubElement(match, 'edit', name='weight', mode=mode)
                integer = FONTCONFIG_WEIGHT[rule_descriptors['font_weight']]
                SubElement(edit, 'int').text = str(integer)
            if 'font_stretch' in rule_descriptors:
                edit = SubElement(match, 'edit', name='width', mode=mode)
                text = FONTCONFIG_STRETCH[rule_descriptors['font_stretch']]
                SubElement(edit, 'const').text = text
            match = SubElement(root, 'match', target='font')
            test = SubElement(match, 'test', name='file', compare='eq')
            SubElement(test, 'string').text = str(font_path)
            descriptors = {
                rules[0][0].replace('-', '_'): rules[0][1] for rules in
                rule_descriptors.get('font_variant', [])}
            settings = rule_descriptors.get('font_feature_settings', 'normal')
            features = font_features(font_feature_settings=settings, **descriptors)
            if features:
                edit = SubElement(match, 'edit', name='fontfeatures', mode=mode)
                for key, value in features.items():
                    SubElement(edit, 'string').text = f'{key} {value}'
            if unicode_ranges := rule_descriptors.get('unicode_range'):
                edit = SubElement(match, 'edit', name='charset', mode=mode)
                plus = SubElement(edit, 'plus')
                for unicode_range in unicode_ranges:
                    charset = SubElement(plus, 'charset')
                    range_ = SubElement(charset, 'range')
                    for value in (unicode_range.start, unicode_range.end):
                        SubElement(range_, 'int').text = f'0x{value:x}'
            header = (
                b'<?xml version="1.0"?>',
                b'<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">')
            xml = b'\n'.join((*header, tostring(root, encoding='utf-8')))

            # Register font and configuration in Fontconfig.
            # TODO: We should mask local fonts with the same name
            # too as explained in Behdad's blog entry.
            fontconfig.FcConfigParseAndLoadFromMemory(self._config, xml, True)
            font_added = fontconfig.FcConfigAppFontAddFile(
                self._config, str(font_path).encode(PREFERRED_ENCODING))
            if font_added:
                return pangoft2.pango_fc_font_map_config_changed(
                    ffi.cast('PangoFcFontMap *', self.font_map))
            LOGGER.debug('Failed to load font at %r', url)
        LOGGER.warning('Font-face %r cannot be loaded', rule_descriptors['font_family'])

    def __del__(self):
        """Clean a font configuration for a document."""
        if self._folder:
            rmtree(self._folder, ignore_errors=True)


def font_features(font_kerning='normal', font_variant_ligatures='normal',
                  font_variant_position='normal', font_variant_caps='normal',
                  font_variant_numeric='normal', font_variant_alternates='normal',
                  font_variant_east_asian='normal', font_feature_settings='normal'):
    """Get the font features from the different properties in style.

    See https://www.w3.org/TR/css-fonts-3/#feature-precedence

    """
    features = {}

    # Step 1: getting the default, we rely on Pango for this.
    # Step 2: @font-face font-variant, done in fonts.add_font_face.
    # Step 3: @font-face font-feature-settings, done in fonts.add_font_face.

    # Step 4: font-variant and OpenType features.

    if font_kerning != 'auto':
        features['kern'] = int(font_kerning == 'normal')

    if font_variant_ligatures == 'none':
        for keys in LIGATURE_KEYS.values():
            for key in keys:
                features[key] = 0
    elif font_variant_ligatures != 'normal':
        for ligature_type in font_variant_ligatures:
            value = 1
            if ligature_type.startswith('no-'):
                value = 0
                ligature_type = ligature_type[3:]
            for key in LIGATURE_KEYS[ligature_type]:
                features[key] = value

    if font_variant_position == 'sub':
        # TODO: the specification asks for additional checks
        # https://www.w3.org/TR/css-fonts-3/#font-variant-position-prop
        features['subs'] = 1
    elif font_variant_position == 'super':
        features['sups'] = 1

    if font_variant_caps != 'normal':
        # TODO: the specification asks for additional checks
        # https://www.w3.org/TR/css-fonts-3/#font-variant-caps-prop
        for key in CAPS_KEYS[font_variant_caps]:
            features[key] = 1

    if font_variant_numeric != 'normal':
        for key in font_variant_numeric:
            features[NUMERIC_KEYS[key]] = 1

    if font_variant_alternates != 'normal':
        # TODO: support other values
        # See https://drafts.csswg.org/css-fonts/#font-variant-alternates-prop
        if font_variant_alternates == 'historical-forms':
            features['hist'] = 1

    if font_variant_east_asian != 'normal':
        for key in font_variant_east_asian:
            features[EAST_ASIAN_KEYS[key]] = 1

    # Step 5: incompatible non-OpenType features, already handled by Pango.

    # Step 6: font-feature-settings.

    if font_feature_settings != 'normal':
        features.update(dict(font_feature_settings))

    return features


def get_font_description(style):
    """Get font description string out of given style."""
    font_description = ffi.gc(
        pango.pango_font_description_new(), pango.pango_font_description_free)
    family_p, family = unicode_to_char_p(','.join(style['font_family']))
    pango.pango_font_description_set_family(font_description, family_p)
    font_style = PANGO_STYLE[style['font_style']]
    pango.pango_font_description_set_style(font_description, font_style)
    font_stretch = PANGO_STRETCH[style['font_stretch']]
    pango.pango_font_description_set_stretch(font_description, font_stretch)
    font_weight = style['font_weight']
    pango.pango_font_description_set_weight(font_description, font_weight)
    font_size = int(style['font_size'] * TO_UNITS)
    pango.pango_font_description_set_absolute_size(font_description, font_size)
    font_variant = PANGO_VARIANT[style['font_variant_caps']]
    pango.pango_font_description_set_variant(font_description, font_variant)
    if style['font_variation_settings'] != 'normal':
        string = ','.join(
            f'{key}={value}' for key, value in
            style['font_variation_settings']).encode()
        pango.pango_font_description_set_variations(font_description, string)
    return font_description


def get_pango_font_hb_face(pango_font):
    """Get Harfbuzz face out of given Pango font."""
    fc_font = ffi.cast('PangoFcFont *', pango_font)
    fontmap = ffi.cast('PangoFcFontMap *', pango.pango_font_get_font_map(pango_font))
    return pangoft2.pango_fc_font_map_get_hb_face(fontmap, fc_font)


def get_hb_object_data(hb_object, ot_color=None, glyph=None):
    """Get binary data out of given Harfbuzz font or face.

    If ``ot_color`` is 'svg', return the SVG color glyph reference. If it’s 'png',
    return the PNG color glyph reference. Otherwise, return the whole face blob.

    """
    if ot_color == 'png':
        hb_blob = harfbuzz.hb_ot_color_glyph_reference_png(hb_object, glyph)
    elif ot_color == 'svg':
        hb_blob = harfbuzz.hb_ot_color_glyph_reference_svg(hb_object, glyph)
    else:
        hb_blob = harfbuzz.hb_face_reference_blob(hb_object)
    with ffi.new('unsigned int *') as length:
        hb_data = harfbuzz.hb_blob_get_data(hb_blob, length)
        data = None if hb_data == ffi.NULL else ffi.unpack(hb_data, int(length[0]))
        harfbuzz.hb_blob_destroy(hb_blob)
        return data


def get_pango_font_key(pango_font):
    """Get key corresponding to given Pango font."""
    # TODO: This value is stable for a given Pango font in a given Pango map, but can’t
    # be cached with just the Pango font as a key because two Pango fonts could point to
    # the same address for two different Pango maps. We should cache it in the
    # FontConfiguration object. See issue #2144.
    description = ffi.gc(
        pango.pango_font_describe_with_absolute_size(pango_font),
        pango.pango_font_description_free)
    font_size = pango.pango_font_description_get_size(description) * FROM_UNITS
    mask = pango.PANGO_FONT_MASK_SIZE + pango.PANGO_FONT_MASK_GRAVITY
    pango.pango_font_description_unset_fields(description, mask)
    return pango.pango_font_description_hash(description), description, font_size


================================================
FILE: weasyprint/text/line_break.py
================================================
"""Decide where to break text lines."""

import re
from math import inf

import pyphen

from .constants import LST_TO_ISO, PANGO_DIRECTION, PANGO_WRAP_MODE
from .ffi import FROM_UNITS, TO_UNITS, ffi, gobject, pango, unicode_to_char_p
from .fonts import font_features, get_font_description


def line_size(line, style):
    """Get logical width and height of the given ``line``.

    ``style`` is used to add letter spacing (if needed).

    """
    logical_extents = ffi.new('PangoRectangle *')
    pango.pango_layout_line_get_extents(line, ffi.NULL, logical_extents)
    width = logical_extents.width * FROM_UNITS
    height = logical_extents.height * FROM_UNITS
    ffi.release(logical_extents)
    if style['letter_spacing'] != 'normal':
        width += style['letter_spacing']
    return width, height


def first_line_metrics(first_line, text, layout, resume_at, space_collapse,
                       style, hyphenated=False, hyphenation_character=None):
    length = first_line.length
    if hyphenated:
        length -= len(hyphenation_character.encode())
    elif resume_at:
        # Set an infinite width as we don't want to break lines when drawing,
        # the lines have already been split and the size may differ. Rendering
        # is also much faster when no width is set.
        pango.pango_layout_set_width(layout.layout, -1)

        # Create layout with final text
        first_line_text = text.encode()[:length].decode()

        # Remove trailing spaces if spaces collapse
        if space_collapse:
            first_line_text = first_line_text.rstrip(' ')

        layout.set_text(first_line_text)
        first_line, _ = layout.get_first_line()
        length = first_line.length if first_line is not None else 0

    width, height = line_size(first_line, style)
    baseline = pango.pango_layout_get_baseline(layout.layout) * FROM_UNITS
    layout.deactivate()
    return layout, length, resume_at, width, height, baseline


class Layout:
    """Object holding PangoLayout-related cdata pointers."""
    def __init__(self, style, justification_spacing=0, max_width=None):
        self.justification_spacing = justification_spacing
        self.setup(style)
        self.max_width = max_width

    def setup(self, style):
        self.style = style
        self.first_line_direction = 0

        font_map = style.font_config.font_map
        pango_context = ffi.gc(
            pango.pango_font_map_create_context(font_map),
            gobject.g_object_unref)
        pango.pango_context_set_round_glyph_positions(pango_context, False)
        pango.pango_context_set_base_dir(
            pango_context, PANGO_DIRECTION[style['direction']])

        if style['font_language_override'] != 'normal':
            lang_p, lang = unicode_to_char_p(LST_TO_ISO.get(
                style['font_language_override'].lower(),
                style['font_language_override']))
        elif style['lang']:
            lang_p, lang = unicode_to_char_p(style['lang'])
        else:
            lang = None
            self.language = pango.pango_language_get_default()
        if lang:
            self.language = pango.pango_language_from_string(lang_p)
            pango.pango_context_set_language(pango_context, self.language)

        assert not isinstance(style['font_family'], str), (
            'font_family should be a list')
        font_description = get_font_description(style)
        self.layout = ffi.gc(
            pango.pango_layout_new(pango_context),
            gobject.g_object_unref)
        pango.pango_layout_set_auto_dir(self.layout, False)
        pango.pango_layout_set_font_description(self.layout, font_description)

        text_decoration = style['text_decoration_line']
        if text_decoration != 'none':
            metrics = ffi.gc(
                pango.pango_context_get_metrics(
                    pango_context, font_description, self.language),
                pango.pango_font_metrics_unref)
            self.ascent = FROM_UNITS * (
                pango.pango_font_metrics_get_ascent(metrics))
            self.underline_position = FROM_UNITS * (
                pango.pango_font_metrics_get_underline_position(metrics))
            self.strikethrough_position = FROM_UNITS * (
                pango.pango_font_metrics_get_strikethrough_position(metrics))
            self.underline_thickness = FROM_UNITS * (
                pango.pango_font_metrics_get_underline_thickness(metrics))
            self.strikethrough_thickness = FROM_UNITS * (
                pango.pango_font_metrics_get_strikethrough_thickness(metrics))
        else:
            self.ascent = None
            self.underline_position = None
            self.strikethrough_position = None

        features = font_features(
            style['font_kerning'], style['font_variant_ligatures'],
            style['font_variant_position'], style['font_variant_caps'],
            style['font_variant_numeric'], style['font_variant_alternates'],
            style['font_variant_east_asian'], style['font_feature_settings'])
        if features:
            features = ','.join(
                f'{key} {value}' for key, value in features.items()).encode()
            # In the meantime, keep a cache to avoid leaking too many of them.
            attr = style.font_config.font_features.setdefault(
                features, pango.pango_attr_font_features_new(features))
            attr_list = pango.pango_attr_list_new()
            pango.pango_attr_list_insert(attr_list, attr)
            pango.pango_layout_set_attributes(self.layout, attr_list)

    def get_first_line(self):
        first_line = pango.pango_layout_get_line_readonly(self.layout, 0)
        second_line = pango.pango_layout_get_line_readonly(self.layout, 1)
        index = None if second_line == ffi.NULL else second_line.start_index
        self.first_line_direction = first_line.resolved_dir
        return first_line, index

    def set_text(self, text, justify=False):
        index = text.find('\n')
        if index != -1:
            # Keep only the first line plus one character, we don't need more
            text = text[:index+2]
        self.text = text
        text, bytestring = unicode_to_char_p(text)
        pango.pango_layout_set_text(self.layout, text, -1)

        word_spacing = self.style['word_spacing']
        if justify:
            # Justification is needed when drawing text but is useless during
            # layout, when it can be ignored.
            word_spacing += self.justification_spacing

        letter_spacing = self.style['letter_spacing']
        if letter_spacing == 'normal':
            letter_spacing = 0

        word_breaking = (
            self.style['overflow_wrap'] in ('anywhere', 'break-word'))

        if self.text and (word_spacing or letter_spacing or word_breaking):
            attr_list = pango.pango_layout_get_attributes(self.layout)
            if attr_list == ffi.NULL:
                attr_list = ffi.gc(
                    pango.pango_attr_list_new(),
                    pango.pango_attr_list_unref)

            def add_attr(start, end, spacing):
                attr = pango.pango_attr_letter_spacing_new(spacing)
                attr.start_index, attr.end_index = start, end
                pango.pango_attr_list_change(attr_list, attr)

            if letter_spacing:
                letter_spacing = int(letter_spacing * TO_UNITS)
                add_attr(0, len(bytestring), letter_spacing)

            if word_spacing:
                if bytestring == b' ':
                    # We need more than one space to set word spacing
                    self.text = ' \u200b'  # Space + zero-width space
                    text, bytestring = unicode_to_char_p(self.text)
                    pango.pango_layout_set_text(self.layout, text, -1)

                space_spacing = int(word_spacing * TO_UNITS + letter_spacing)
                # Pango gives only half of word-spacing on boundaries
                boundary_positions = (0, len(bytestring) - 1)
                for match in re.finditer(' |\u00a0'.encode(), bytestring):
                    factor = 1 + (match.start() in boundary_positions)
                    add_attr(match.start(), match.end(), factor * space_spacing)

            if word_breaking:
                attr = pango.pango_attr_insert_hyphens_new(False)
                attr.start_index, attr.end_index = 0, len(bytestring)
                pango.pango_attr_list_change(attr_list, attr)

            pango.pango_layout_set_attributes(self.layout, attr_list)

        # Tabs width
        if b'\t' in bytestring:
            self.set_tabs()

    def set_tabs(self):
        if isinstance(self.style['tab_size'], int):
            layout = Layout(self.style, self.justification_spacing)
            layout.set_text(' ' * self.style['tab_size'])
            line, _ = layout.get_first_line()
            width, _ = line_size(line, self.style)
            width = round(width)
        else:
            width = int(self.style['tab_size'].value)
        # 0 is not handled correctly by Pango
        array = ffi.gc(
            pango.pango_tab_array_new_with_positions(
                1, True, pango.PANGO_TAB_LEFT, width or 1),
            pango.pango_tab_array_free)
        pango.pango_layout_set_tabs(self.layout, array)

    def deactivate(self):
        del self.layout, self.language, self.style

    def reactivate(self, style):
        self.setup(style)
        self.set_text(self.text, justify=True)


def create_layout(text, style, context, max_width, justification_spacing):
    """Return an opaque Pango layout with default Pango line-breaks."""
    layout = Layout(style, justification_spacing, max_width)

    # Make sure that max_width * Pango.SCALE == max_width * 1024 fits in a
    # signed integer. Treat bigger values same as None: unconstrained width.
    text_wrap = style['white_space'] in ('normal', 'pre-wrap', 'pre-line')
    if max_width is not None and text_wrap and max_width < 2 ** 21:
        pango.pango_layout_set_width(layout.layout, int(max(0, max_width) * TO_UNITS))

    layout.set_text(text)
    return layout


def split_first_line(text, style, context, max_width, justification_spacing,
                     is_line_start=True, minimum=False):
    """Fit as much as possible in the available width for one line of text.

    Return ``(layout, length, resume_index, width, height, baseline)``.

    ``layout``: a pango Layout with the first line
    ``length``: length in UTF-8 bytes of the first line
    ``resume_index``: The number of UTF-8 bytes to skip for the next line.
                      May be ``None`` if the whole text fits in one line.
                      This may be greater than ``length`` in case of preserved
                      newline characters.
    ``width``: width in pixels of the first line
    ``height``: height in pixels of the first line
    ``baseline``: baseline in pixels of the first line

    """
    from ..layout.percent import percentage

    # See https://www.w3.org/TR/css-text-3/#white-space-property
    text_wrap = style['white_space'] in ('normal', 'pre-wrap', 'pre-line')
    space_collapse = style['white_space'] in ('normal', 'nowrap', 'pre-line')

    original_max_width = max_width
    if not text_wrap:
        max_width = None

    # Step #1: Get a draft layout with the first line.
    ratio = 4  # number that almost always respects char_height / char_width > ratio
    short_text = text
    if max_width is not None and max_width != inf and style['font_size']:
        # Try to use a small amount of text to avoid the whole layout. We need
        # at least one line, and one possible line break point on the second line.
        if style['font_size'] * ratio > max_width:
            # Trying to find minimum or very small size, let's naively split on
            # spaces and keep one word + one letter.
            space_index = text.find(' ')
            if space_index != -1:
                short_text = text[:space_index+2]  # index + space + one letter
        else:
            # Use the magic ration and hope that we’ll get the right amount of text.
            short_text = text[:int(max_width / style['font_size'] * ratio)]
        layout = create_layout(
            short_text, style, context, max_width, justification_spacing)
        first_line, resume_index = layout.get_first_line()
        if resume_index is None and short_text != text:
            # The small amount of text fits in one line, give up and use the
            # whole text.
            short_text = text
            layout.set_text(text)
            first_line, resume_index = layout.get_first_line()
        else:
            # If the second line of the short text can break, we have the next
            # line break point required for step #3 in it, drop the end of the text.
            first_line_text = short_text.encode()[:resume_index].decode()
            if first_line_text != short_text:
                start, end = len(first_line_text) + 1, len(short_text)
                text_end_log_attrs = pango.pango_layout_get_log_attrs_readonly(
                    layout.layout, ffi.NULL)[start:end]
                if get_next_break_point(text_end_log_attrs) is not None:
                    text = short_text
    else:
        layout = create_layout(
            text, style, context, original_max_width, justification_spacing)
        first_line, resume_index = layout.get_first_line()

    # Step #2: Don't split lines when it's not needed.
    if max_width is None:
        # The first line can take all the place needed.
        return first_line_metrics(
            first_line, text, layout, resume_index, space_collapse, style)
    first_line_width, _ = line_size(first_line, style)
    if resume_index is None and first_line_width <= max_width:
        # The first line fits in the available width.
        return first_line_metrics(
            first_line, text, layout, resume_index, space_collapse, style)

    # Step #3: Try to put the first word of the second line on the first line
    # https://mail.gnome.org/archives/gtk-i18n-list/2013-September/msg00006
    # is a good thread related to this problem.
    if first_line_width <= max_width:
        # The first line fits but may have been cut too early by Pango.
        encoded_text = text.encode()
        first_line_text = encoded_text[:resume_index].decode()
        second_line_text = encoded_text[resume_index:].decode()
    else:
        # The line can't be split earlier, try to hyphenate the first word.
        first_line_text = ''
        second_line_text = text
    if first_line_text == short_text:
        # There’s no second line, don’t try to find a next word.
        break_point = None
    else:
        # Find then second line’s first break point.
        log_attrs = pango.pango_layout_get_log_attrs_readonly(layout.layout, ffi.NULL)
        start, end = len(first_line_text) + 1, len(short_text)
        second_line_log_attrs = log_attrs[start:end]
        break_point = get_next_break_point(second_line_log_attrs)
        if break_point is not None:
            break_point -= len(first_line_text) + 1
    next_word = second_line_text[:break_point].rstrip(' ')
    if next_word:
        if space_collapse and second_line_text[break_point or -1] == ' ':
            # Next word might fit without a space afterwards only try when
            # space collapsing is allowed.
            new_first_line_text = first_line_text + next_word
            layout.set_text(new_first_line_text)
            first_line, resume_index = layout.get_first_line()
            if resume_index is None:
                if first_line_text:
                    # The next word fits in the first line, keep the layout.
                    resume_index = len(new_first_line_text.encode()) + 1
                    return first_line_metrics(
                        first_line, text, layout, resume_index, space_collapse, style)
                else:
                    # Second line is None.
                    resume_index = first_line.length + 1
                    if resume_index >= len(text.encode()):
                        resume_index = None
    elif first_line_text:
        # We found something on the first line but we did not find a word on
        # the next line, no need to hyphenate, we can keep the current layout.
        return first_line_metrics(
            first_line, text, layout, resume_index, space_collapse, style)

    # Step #4: Try to hyphenate
    hyphens = style['hyphens']
    lang = style['lang'] and pyphen.language_fallback(style['lang'])
    total, left, right = style['hyphenate_limit_chars']
    hyphenated = False
    soft_hyphen = '\xad'

    auto_hyphenation = manual_hyphenation = False

    if hyphens != 'none':
        manual_hyphenation = soft_hyphen in first_line_text + second_line_text

    if hyphens == 'auto' and lang:
        # Get text until next line break opportunity.
        next_text = second_line_text
        if (next_break_point := get_next_break_point_from_text(second_line_text, lang)):
            next_text = next_text[:next_break_point]

        # Try all words included in this text.
        next_text_index = 0
        while next_text:
            next_word_boundaries = get_next_word_boundaries(next_text, lang)
            if next_word_boundaries:
                # We have a word to hyphenate.
                start_word, stop_word = next_word_boundaries
                next_word = next_text[start_word:stop_word]
                if stop_word - start_word >= total:
                    # This word is long enough.
                    first_line_width, _ = line_size(first_line, style)
                    space = max_width - first_line_width
                    limit_zone = percentage(
                        style['hyphenate_limit_zone'], style, max_width)
                    if space > limit_zone or space < 0:
                        # Available space is worth the try, or the line is even too long
                        # to fit: try to hyphenate.
                        auto_hyphenation = True
                        next_text_index += start_word
                        break

                # This word doesn’t work, try next one.
                next_text = next_text[stop_word:]
                next_text_index += stop_word
            else:
                break

    # Automatic hyphenation opportunities within a word must be ignored if the
    # word contains a conditional hyphen, in favor of the conditional
    # hyphen(s).
    # See https://drafts.csswg.org/css-text-3/#valdef-hyphens-auto
    if manual_hyphenation:
        # Manual hyphenation: check that the line ends with a soft
        # hyphen and add the missing hyphen
        if first_line_text.endswith(soft_hyphen):
            # The first line has been split on a soft hyphen
            first_line_text, second_line_text = '', first_line_text
        soft_hyphen_indexes = [
            match.start() for match in re.finditer(soft_hyphen, second_line_text)]
        soft_hyphen_indexes.reverse()
        dictionary_iterations = [second_line_text[:i+1] for i in soft_hyphen_indexes]
    elif auto_hyphenation:
        dictionary_key = (lang, left, right, total)
        dictionary = context.dictionaries.get(dictionary_key)
        if dictionary is None:
            dictionary = pyphen.Pyphen(lang=lang, left=left, right=right)
            context.dictionaries[dictionary_key] = dictionary
        previous_words = second_line_text[:next_text_index]
        dictionary_iterations = [
            previous_words + start for start, end in dictionary.iterate(next_word)]
    else:
        dictionary_iterations = []

    if dictionary_iterations:
        for first_word_part in dictionary_iterations:
            new_first_line_text = first_line_text + first_word_part
            hyphenated_first_line_text = (
                new_first_line_text + style['hyphenate_character'])
            new_layout = create_layout(
                hyphenated_first_line_text, style, context, max_width,
                justification_spacing)
            new_first_line, index = new_layout.get_first_line()
            new_first_line_width, _ = line_size(new_first_line, style)
            new_space = max_width - new_first_line_width
            hyphenated = index is None and (
                new_space >= 0 or first_word_part == dictionary_iterations[-1])
            if hyphenated:
                layout = new_layout
                first_line = new_first_line
                resume_index = len(new_first_line_text.encode())
                break

        if not hyphenated and not first_line_text:
            # Recreate the layout with no max_width to be sure that
            # we don't break before or inside the hyphenate character
            hyphenated = True
            layout.set_text(hyphenated_first_line_text)
            pango.pango_layout_set_width(layout.layout, -1)
            first_line, _ = layout.get_first_line()
            resume_index = len(new_first_line_text.encode())
            if text[len(first_line_text)] == soft_hyphen:
                resume_index += len(soft_hyphen.encode())

    if not hyphenated and first_line_text.endswith(soft_hyphen):
        # Recreate the layout with no max_width to be sure that
        # we don't break inside the hyphenate-character string
        hyphenated = True
        hyphenated_first_line_text = (
            first_line_text + style['hyphenate_character'])
        layout.set_text(hyphenated_first_line_text)
        pango.pango_layout_set_width(layout.layout, -1)
        first_line, _ = layout.get_first_line()
        resume_index = len(first_line_text.encode())

    # Step 5: Try to break word if it's too long for the line
    overflow_wrap = style['overflow_wrap']
    first_line_width, _ = line_size(first_line, style)
    space = max_width - first_line_width
    # If we can break words and the first line is too long
    can_break = (
        style['word_break'] == 'break-all' or (
            is_line_start and (
                overflow_wrap == 'anywhere' or
                (overflow_wrap == 'break-word' and not minimum))))
    if space < 0 and can_break:
        # Is it really OK to remove hyphenation for word-break ?
        hyphenated = False
        # TODO: Modify code to preserve W3C condition:
        # "Shaping characters are still shaped as if the word were not broken"
        # The way new lines are processed in this function (one by one with no
        # memory of the last) prevents shaping characters (arabic, for
        # instance) from keeping their shape when wrapped on the next line with
        # pango layout. Maybe insert Unicode shaping characters in text?
        layout.set_text(text)
        pango.pango_layout_set_width(layout.layout, int(max_width * TO_UNITS))
        pango.pango_layout_set_wrap(layout.layout, PANGO_WRAP_MODE['WRAP_CHAR'])
        first_line, index = layout.get_first_line()
        resume_index = index or first_line.length
        if resume_index >= len(text.encode()):
            resume_index = None

    return first_line_metrics(
        first_line, text, layout, resume_index, space_collapse, style,
        hyphenated, style['hyphenate_character'])


def _font_style_cache_key(style, include_size=False):
    key = str((
        style['font_family'],
        style['font_style'],
        style['font_stretch'],
        style['font_weight'],
        style['font_variant_ligatures'],
        style['font_variant_position'],
        style['font_variant_caps'],
        style['font_variant_numeric'],
        style['font_variant_alternates'],
        style['font_variant_east_asian'],
        style['font_feature_settings'],
        style['font_variation_settings'],
        style['font_language_override'],
        style['lang'],
    ))
    if include_size:
        key += str(style['font_size']) + str(style['line_height'])
    return key


def strut(style):
    """Return a tuple of the used value of ``line-height`` and the baseline.

    The baseline is given from the top edge of line height.

    """
    if style['font_size'] == 0:
        return 0, 0

    key = _font_style_cache_key(style, include_size=True)
    if key in style.font_config.strut_layouts:
        return style.font_config.strut_layouts[key]

    layout = Layout(style)
    layout.set_text(' ')
    line, _ = layout.get_first_line()
    _, _, _, _, text_height, baseline = first_line_metrics(
        line, '', layout, resume_at=None, space_collapse=False, style=style)
    if style['line_height'] == 'normal':
        result = text_height, baseline
        style.font_config.strut_layouts[key] = result
        return result
    type_, line_height = style['line_height']
    if type_ == 'NUMBER':
        line_height *= style['font_size']
    result = line_height, baseline + (line_height - text_height) / 2
    style.font_config.strut_layouts[key] = result
    return result


def character_ratio(style, unit):
    """Return the font size ratio used by given unit."""
    character = {'ex': 'x', 'cap': 'O', 'ic': '水', 'ch': '0'}.get(unit)
    assert character

    cache = style.cache.setdefault(unit, {})
    cache_key = _font_style_cache_key(style)
    if cache_key in cache:
        return cache[cache_key]

    # Avoid recursion for letter-spacing and word-spacing properties
    style = style.copy()
    style['letter_spacing'] = 'normal'
    style['word_spacing'] = 0
    # Random big value
    style['font_size'] = 1000

    layout = Layout(style)
    layout.set_text(character)
    line, _ = layout.get_first_line()

    ink_extents = ffi.new('PangoRectangle *')
    logical_extents = ffi.new('PangoRectangle *')
    pango.pango_layout_line_get_extents(line, ink_extents, logical_extents)
    if unit == 'ex':
        measure = -ink_extents.y * FROM_UNITS
    elif character == 'cap':
        measure = logical_extents.height * FROM_UNITS
    else:
        measure = logical_extents.width * FROM_UNITS
    ffi.release(ink_extents)
    ffi.release(logical_extents)

    # Zero means some kind of failure, fallback is 0.5.
    # We round to try keeping exact values that were altered by Pango.
    cache[cache_key] = round(measure / style['font_size'], 5) or 0.5
    return cache[cache_key]


def get_log_attrs(text, lang):
    if lang:
        lang_p, lang = unicode_to_char_p(lang)
    else:
        lang = None
        language = pango.pango_language_get_default()
    if lang:
        language = pango.pango_language_from_string(lang_p)
    # TODO: this should be removed when bidi is supported
    for char in ('\u202a', '\u202b', '\u202c', '\u202d', '\u202e'):
        text = text.replace(char, '\u200b')
    text_p, bytestring = unicode_to_char_p(text)
    length = len(text) + 1
    log_attrs = ffi.new('PangoLogAttr[]', length)
    pango.pango_get_log_attrs(
        text_p, len(bytestring), -1, language, log_attrs, length)
    return log_attrs


def get_next_break_point(log_attrs):
    for i, attr in enumerate(log_attrs):
        if attr.is_line_break:
            return i


def get_next_break_point_from_text(text, lang):
    if not text or len(text) < 2:
        return None
    log_attrs = get_log_attrs(text, lang)
    length = len(text) + 1
    return get_next_break_point(log_attrs[1:length-1])


def can_break_text(text, lang):
    return get_next_break_point_from_text(text, lang) is not None


def get_next_word_boundaries(text, lang):
    if not text or len(text) < 2:
        return None
    log_attrs = get_log_attrs(text, lang)
    for i, attr in enumerate(log_attrs):
        if attr.is_word_end:
            word_end = i
            break
        if attr.is_word_boundary:
            word_start = i
    else:
        return None
    return word_start, word_end


def get_last_word_end(text, lang):
    if not text or len(text) < 2:
        return None
    log_attrs = get_log_attrs(text, lang)
    for i, attr in enumerate(list(log_attrs)[::-1]):
        if i and attr.is_word_end:
            return len(text) - i


================================================
FILE: weasyprint/urls.py
================================================
"""Various utility functions and classes for URL management."""

import contextlib
import os.path
import re
import sys
import traceback
import warnings
import zlib
from email.message import EmailMessage
from gzip import GzipFile
from io import BytesIO, StringIO
from pathlib import Path
from urllib import request
from urllib.parse import quote, unquote, urljoin, urlsplit

from . import __version__
from .logger import LOGGER

# See https://stackoverflow.com/a/11687993/1162888
# Both are needed in Python 3 as the re module does not like to mix
# https://datatracker.ietf.org/doc/html/rfc3986#section-3.1
UNICODE_SCHEME_RE = re.compile('^([a-zA-Z][a-zA-Z0-9.+-]+):')
BYTES_SCHEME_RE = re.compile(b'^([a-zA-Z][a-zA-Z0-9.+-]+):')

FILESYSTEM_ENCODING = sys.getfilesystemencoding()

HTTP_HEADERS = {
    'User-Agent': f'WeasyPrint {__version__}',
    'Accept': '*/*',
    'Accept-Encoding': 'gzip, deflate',
}


class StreamingGzipFile(GzipFile):
    def __init__(self, fileobj):
        GzipFile.__init__(self, fileobj=fileobj)
        self.fileobj_to_close = fileobj

    def close(self):
        GzipFile.close(self)
        self.fileobj_to_close.close()

    def seekable(self):
        return False


def iri_to_uri(url):
    """Turn a Unicode IRI into an ASCII-only URI that conforms to RFC 3986."""
    if url.startswith('data:'):
        # Data URIs can be huge, but don’t need this anyway.
        return url
    # Use UTF-8 as per RFC 3987 (IRI), except for file://
    url = url.encode(FILESYSTEM_ENCODING if url.startswith('file:') else 'utf-8')
    # This is a full URI, not just a component. Only %-encode characters
    # that are not allowed at all in URIs. Everthing else is "safe":
    # * Reserved characters: /:?#[]@!$&'()*+,;=
    # * Unreserved characters: ASCII letters, digits and -._~
    #   Of these, only '~' is not in urllib’s "always safe" list.
    # * '%' to avoid double-encoding
    return quote(url, safe=b"/:?#[]@!$&'()*+,;=~%")


def path2url(path):
    """Return file URL of `path`.

    Accepts 'str', 'bytes' or 'Path', returns 'str'.

    """
    # Ensure 'str'
    if isinstance(path, Path):
        path = str(path)
    elif isinstance(path, bytes):
        path = path.decode(FILESYSTEM_ENCODING)
    # If a trailing path.sep is given, keep it
    wants_trailing_slash = path.endswith((os.path.sep, '/'))
    path = os.path.abspath(path)
    if wants_trailing_slash or os.path.isdir(path):
        # Make sure directory names have a trailing slash.
        # Otherwise relative URIs are resolved from the parent directory.
        path += os.path.sep
        wants_trailing_slash = True
    path = request.pathname2url(path)
    # On Windows pathname2url cuts off trailing slash
    if wants_trailing_slash and not path.endswith('/'):
        path += '/'  # pragma: no cover
    if path.startswith('///'):
        # On Windows pathname2url(r'C:\foo') is apparently '///C:/foo'
        # That enough slashes already.
        return f'file:{path}'  # pragma: no cover
    else:
        return f'file://{path}'


def url_is_absolute(url):
    """Return whether an URL (bytes or string) is absolute."""
    scheme = UNICODE_SCHEME_RE if isinstance(url, str) else BYTES_SCHEME_RE
    return bool(scheme.match(url))


def get_url_attribute(element, attr_name, base_url, allow_relative=False):
    """Get the URI corresponding to the ``attr_name`` attribute.

    Return ``None`` if:

    * the attribute is empty or missing or,
    * the value is a relative URI but the document has no base URI and
      ``allow_relative`` is ``False``.

    Otherwise return an URI, absolute if possible.

    """
    value = element.get(attr_name, '').strip()
    if value:
        return url_join(
            base_url or '', value, allow_relative, '<%s %s="%s">',
            (element.tag, attr_name, value))


def get_url_tuple(url, base_url):
    """Get tuple describing internal or external URI."""
    if url.startswith('#'):
        return ('internal', unquote(url[1:]))
    elif url_is_absolute(url):
        return ('external', iri_to_uri(url))
    elif base_url:
        return ('external', iri_to_uri(urljoin(base_url, url)))


def url_join(base_url, url, allow_relative, context, context_args):
    """Like urllib.urljoin, but warn if base_url is required but missing."""
    if url_is_absolute(url):
        return iri_to_uri(url)
    elif base_url:
        return iri_to_uri(urljoin(base_url, url))
    elif allow_relative:
        return iri_to_uri(url)
    else:
        LOGGER.error(
            f'Relative URI reference without a base URI: {context}',
            *context_args)
        return None


def get_link_attribute(element, attr_name, base_url):
    """Get the URL value of an element attribute.

    Return ``('external', absolute_uri)``, or ``('internal',
    unquoted_fragment_id)``, or ``None``.

    """
    attr_value = element.get(attr_name, '').strip()
    if attr_value.startswith('#') and len(attr_value) > 1:
        # Do not require a base_url when the value is just a fragment.
        return ('url', ('internal', unquote(attr_value[1:])))
    uri = get_url_attribute(element, attr_name, base_url, allow_relative=True)
    if uri:
        if base_url:
            try:
                parsed = urlsplit(uri)
            except ValueError:
                LOGGER.warning('Malformed URL: %s', uri)
            else:
                try:
                    parsed_base = urlsplit(base_url)
                except ValueError:
                    LOGGER.warning('Malformed base URL: %s', base_url)
                else:
                    # Compare with fragments removed
                    if parsed.fragment and parsed[:-1] == parsed_base[:-1]:
                        return ('url', ('internal', unquote(parsed.fragment)))
        return ('url', ('external', uri))


def ensure_url(string):
    """Get a ``scheme://path`` URL from ``string``.

    If ``string`` looks like an URL, return it unchanged. Otherwise assume a
    filename and convert it to a ``file://`` URL.

    """
    return string if url_is_absolute(string) else path2url(string)


def default_url_fetcher(url, timeout=10, ssl_context=None, http_headers=None,
                        allowed_protocols=None):
    """Fetch an external resource such as an image or stylesheet.

    This function is deprecated, use ``URLFetcher`` instead.

    """
    warnings.warn(
        'default_url_fetcher is deprecated and will be removed in WeasyPrint 69.0, '
        'please use URLFetcher instead. For security reasons, HTTP redirects are not '
        'supported anymore with default_url_fetcher, but are with URLFetcher.\n\nSee '
        'https://doc.courtbouillon.org/weasyprint/stable/first_steps.html#url-fetchers',
        category=DeprecationWarning)
    fetcher = URLFetcher(
        timeout, ssl_context, http_headers, allowed_protocols, allow_redirects=False)
    return fetcher.fetch(url)


@contextlib.contextmanager
def select_source(guess=None, filename=None, url=None, file_obj=None, string=None,
                  base_url=None, url_fetcher=None, check_css_mime_type=False):
    """If only one input is given, return it.

    Yield a file object, the base url, the protocol encoding and the protocol mime-type.

    """
    if base_url is not None:
        base_url = ensure_url(base_url)
    if url_fetcher is None:
        url_fetcher = URLFetcher()

    selected_params = [
        param for param in (guess, filename, url, file_obj, string) if
        param is not None]
    if len(selected_params) != 1:
        source = ', '.join(selected_params) or 'nothing'
        raise TypeError(f'Expected exactly one source, got {source}')
    elif guess is not None:
        kwargs = {
            'base_url': base_url,
            'url_fetcher': url_fetcher,
            'check_css_mime_type': check_css_mime_type,
        }
        if hasattr(guess, 'read'):
            kwargs['file_obj'] = guess
        elif isinstance(guess, Path):
            kwargs['filename'] = guess
        elif url_is_absolute(guess):
            kwargs['url'] = guess
        else:
            kwargs['filename'] = guess
        result = select_source(**kwargs)
        with result as result:
            yield result
    elif filename is not None:
        if base_url is None:
            base_url = path2url(filename)
        with open(filename, 'rb') as file_obj:
            yield file_obj, base_url, None, None
    elif url is not None:
        with fetch(url_fetcher, url) as response:
            if check_css_mime_type and response.content_type != 'text/css':
                LOGGER.error(
                    f'Unsupported stylesheet type {response.content_type} '
                    f'for {response.url}')
                yield StringIO(''), base_url, None, None
            else:
                if base_url is None:
                    base_url = response.url
                yield response, base_url, response.charset, response.content_type
    elif file_obj is not None:
        if base_url is None:
            # filesystem file-like objects have a 'name' attribute.
            name = getattr(file_obj, 'name', None)
            # Some streams have a .name like '<stdin>', not a filename.
            if name and not name.startswith('<'):
                base_url = ensure_url(name)
        yield file_obj, base_url, None, None
    else:
        if isinstance(string, str):
            yield StringIO(string), base_url, None, None
        else:
            yield BytesIO(string), base_url, None, None


class URLFetchingError(IOError):
    """Some error happened when fetching an URL."""


class FatalURLFetchingError(BaseException):
    """Some error happened when fetching an URL and must stop the rendering."""


class URLFetcher(request.OpenerDirector):
    """Fetcher of external resources such as images or stylesheets.

    :param int timeout: The number of seconds before HTTP requests are dropped.
    :param ssl.SSLContext ssl_context: An SSL context used for HTTPS requests.
    :param dict http_headers: Additional HTTP headers used for HTTP requests.
    :type allowed_protocols: :term:`sequence`
    :param allowed_protocols: A set of authorized protocols, :obj:`None` means all.
    :param bool allow_redirects: Whether HTTP redirects must be followed.
    :param bool fail_on_errors: Whether HTTP errors should stop the rendering.

    Another class inheriting from this class, with a ``fetch`` method that has a
    compatible signature, can be given as the ``url_fetcher`` argument to
    :class:`weasyprint.HTML` or :class:`weasyprint.CSS`.

    See :ref:`URL Fetchers` for more information and examples.

    """

    def __init__(self, timeout=10, ssl_context=None, http_headers=None,
                 allowed_protocols=None, allow_redirects=True, fail_on_errors=False,
                 **kwargs):
        super().__init__()
        handlers = [
            request.ProxyHandler(), request.UnknownHandler(), request.HTTPHandler(),
            request.HTTPDefaultErrorHandler(), request.FTPHandler(),
            request.FileHandler(), request.HTTPErrorProcessor(), request.DataHandler(),
            request.HTTPSHandler(context=ssl_context)]
        if allow_redirects:
            handlers.append(request.HTTPRedirectHandler())
        for handler in handlers:
            self.add_handler(handler)

        self._timeout = timeout
        self._http_headers = {**HTTP_HEADERS, **(http_headers or {})}
        self._allowed_protocols = allowed_protocols
        self._fail_on_errors = fail_on_errors
        self._request = None

    def fetch(self, url, headers=None):
        """Fetch a given URL.

        :returns: A :obj:`URLFetcherResponse` instance.
        :raises: An exception indicating failure, e.g. :obj:`ValueError` on
            syntactically invalid URL. All exceptions are catched internally by
            WeasyPrint, except when they inherit from :obj:`FatalURLFetchingError`.

        """
        # Discard URLs with no or invalid protocol.
        if not (match := UNICODE_SCHEME_RE.match(url)):  # pragma: no cover
            raise ValueError(f'Not an absolute URI: {url}')
        scheme = match[1].lower()

        # Discard URLs with forbidden protocol.
        if self._allowed_protocols is not None:
            if scheme not in self._allowed_protocols:
                raise ValueError(f'URI uses disallowed protocol: {url}')

        # Remove query and fragment parts from file URLs.
        # See https://bugs.python.org/issue34702.
        if scheme == 'file':
            url = url.split('?')[0]

        # Transform Unicode IRI to ASCII URI.
        url = iri_to_uri(url)

        # Open URL.
        headers = {**self._http_headers, **(headers or {})}
        http_request = self._request or request.Request(url, headers=headers)
        self._request = None
        response = super().open(http_request, timeout=self._timeout)

        # Decompress response.
        body = response
        if 'Content-Encoding' in response.headers:
            content_encoding = response.headers['Content-Encoding']
            del response.headers['Content-Encoding']
            if content_encoding == 'gzip':
                body = StreamingGzipFile(fileobj=response)
            elif content_encoding == 'deflate':
                data = response.read()
                try:
                    body = zlib.decompress(data)
                except zlib.error:
                    # Try without zlib header or checksum.
                    body = zlib.decompress(data, -15)

        return URLFetcherResponse(response.url, body, response.headers, response.status)

    def open(self, url, data=None, timeout=None):
        if isinstance(url, request.Request):
            self._request = url
            return self.fetch(url.full_url, url.headers)
        return self.fetch(url)

    def __call__(self, url):
        return self.fetch(url)


class URLFetcherResponse:
    """The HTTP response of an URL fetcher.

    :param str url: The URL of the HTTP response.
    :type body: :class:`str`, :class:`bytes` or :term:`file object`
    :param body: The body of the HTTP response.
    :type headers: dict or email.message.EmailMessage
    :param headers: The headers of the HTTP response.
    :param int status: The status of the HTTP response.

    Has the same interface as :class:`urllib.response.addinfourl`.

    If a :term:`file object` is given for the body, it is the caller’s responsibility to
    call ``close()`` on it. The default function used internally to fetch data in
    WeasyPrint tries to close the file object after retreiving; but if this URL fetcher
    is used elsewhere, the file object has to be closed manually.

    """
    def __init__(self, url, body=None, headers=None, status=200, **kwargs):
        self.url = url
        self.status = status

        if isinstance(headers, EmailMessage):
            self.headers = headers
        else:
            self.headers = EmailMessage()
            for key, value in (headers or {}).items():
                try:
                    self.headers[key] = value
                except ValueError:
                    pass  # Ignore forbidden duplicated headers.

        if hasattr(body, 'read'):
            self._file_obj = body
        elif isinstance(body, str):
            self.headers.set_param('charset', 'utf-8')
            self._file_obj = BytesIO(body.encode('utf-8'))
        else:
            self._file_obj = BytesIO(body)

    def read(self, *args, **kwargs):
        return self._file_obj.read(*args, **kwargs)

    def close(self):
        try:
            self._file_obj.close()
        except Exception:  # pragma: no cover
            # May already be closed or something.
            # This is just cleanup anyway: log but make it non-fatal.
            LOGGER.warning(
                'Error when closing stream for %s:\n%s',
                self.url, traceback.format_exc())

    @property
    def path(self):
        if self.url.startswith('file:'):
            return request.url2pathname(self.url.split('?')[0].removeprefix('file:'))

    @property
    def content_type(self):
        return self.headers.get_content_type()

    @property
    def charset(self):
        return self.headers.get_param('charset')

    def geturl(self):
        return self.url

    def info(self):
        return self.headers

    @property
    def code(self):
        return self.status

    def getcode(self):
        return self.status


@contextlib.contextmanager
def fetch(url_fetcher, url):
    """Fetch an ``url`` with ```url_fetcher``, fill in optional data, and clean up.

    Fatal errors must raise a ``FatalURLFetchingError`` that stops the rendering. All
    other exceptions are catched and raise an ``URLFetchingError``, that is usually
    catched by the code that fetches the resource and emits a warning.

    """
    try:
        resource = url_fetcher(url)
    except Exception as exception:
        if getattr(url_fetcher, '_fail_on_errors', False):
            raise FatalURLFetchingError(f'Error fetching "{url}"') from exception
        raise URLFetchingError(f'{type(exception).__name__}: {exception}')

    if isinstance(resource, dict):
        warnings.warn(
            'Returning dicts in URL fetchers is deprecated and will be removed '
            'in WeasyPrint 69.0, please return URLFetcherResponse instead.',
            category=DeprecationWarning)
        if 'url' not in resource:
            resource['url'] = resource.get('redirected_url', url)
        resource['body'] = resource.get('file_obj', resource.get('string'))
        content_type = resource.get('mime_type', 'application/octet-stream')
        if charset := resource.get('encoding'):
            content_type += f'; charset={charset}'
        resource['headers'] = {'Content-Type': content_type}
        resource = URLFetcherResponse(**resource)

    assert isinstance(resource, URLFetcherResponse), (
        'URL fetcher must return either a dict or a URLFetcherResponse instance')

    try:
        yield resource
    finally:
        resource.close()