Initial commit

vendor/phpunit/php-code-coverage/src/Report/Clover.php

@@ -0,0 +1,231 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report;
+
+use function count;
+use function dirname;
+use function file_put_contents;
+use function is_string;
+use function ksort;
+use function max;
+use function range;
+use function str_contains;
+use function time;
+use DOMDocument;
+use SebastianBergmann\CodeCoverage\CodeCoverage;
+use SebastianBergmann\CodeCoverage\Driver\WriteOperationFailedException;
+use SebastianBergmann\CodeCoverage\Node\File;
+use SebastianBergmann\CodeCoverage\Util\Filesystem;
+
+final class Clover
+{
+    /**
+     * @throws WriteOperationFailedException
+     */
+    public function process(CodeCoverage $coverage, ?string $target = null, ?string $name = null): string
+    {
+        $time = (string) time();
+
+        $xmlDocument               = new DOMDocument('1.0', 'UTF-8');
+        $xmlDocument->formatOutput = true;
+
+        $xmlCoverage = $xmlDocument->createElement('coverage');
+        $xmlCoverage->setAttribute('generated', $time);
+        $xmlDocument->appendChild($xmlCoverage);
+
+        $xmlProject = $xmlDocument->createElement('project');
+        $xmlProject->setAttribute('timestamp', $time);
+
+        if (is_string($name)) {
+            $xmlProject->setAttribute('name', $name);
+        }
+
+        $xmlCoverage->appendChild($xmlProject);
+
+        $packages = [];
+        $report   = $coverage->getReport();
+
+        foreach ($report as $item) {
+            if (!$item instanceof File) {
+                continue;
+            }
+
+            /* @var File $item */
+
+            $xmlFile = $xmlDocument->createElement('file');
+            $xmlFile->setAttribute('name', $item->pathAsString());
+
+            $classes      = $item->classesAndTraits();
+            $coverageData = $item->lineCoverageData();
+            $lines        = [];
+            $namespace    = 'global';
+
+            foreach ($classes as $className => $class) {
+                $classStatements        = 0;
+                $coveredClassStatements = 0;
+                $coveredMethods         = 0;
+                $classMethods           = 0;
+
+                // Assumption: one namespace per file
+                if ($class['namespace'] !== '') {
+                    $namespace = $class['namespace'];
+                }
+
+                foreach ($class['methods'] as $methodName => $method) {
+                    if ($method['executableLines'] == 0) {
+                        continue;
+                    }
+
+                    $classMethods++;
+                    $classStatements        += $method['executableLines'];
+                    $coveredClassStatements += $method['executedLines'];
+
+                    if ($method['coverage'] == 100) {
+                        $coveredMethods++;
+                    }
+
+                    $methodCount = 0;
+
+                    foreach (range($method['startLine'], $method['endLine']) as $line) {
+                        if (isset($coverageData[$line])) {
+                            $methodCount = max($methodCount, count($coverageData[$line]));
+                        }
+                    }
+
+                    $lines[$method['startLine']] = [
+                        'ccn'        => $method['ccn'],
+                        'count'      => $methodCount,
+                        'crap'       => $method['crap'],
+                        'type'       => 'method',
+                        'visibility' => $method['visibility'],
+                        'name'       => $methodName,
+                    ];
+                }
+
+                $xmlClass = $xmlDocument->createElement('class');
+                $xmlClass->setAttribute('name', $className);
+                $xmlClass->setAttribute('namespace', $namespace);
+
+                $xmlFile->appendChild($xmlClass);
+
+                $xmlMetrics = $xmlDocument->createElement('metrics');
+                $xmlMetrics->setAttribute('complexity', (string) $class['ccn']);
+                $xmlMetrics->setAttribute('methods', (string) $classMethods);
+                $xmlMetrics->setAttribute('coveredmethods', (string) $coveredMethods);
+                $xmlMetrics->setAttribute('conditionals', (string) $class['executableBranches']);
+                $xmlMetrics->setAttribute('coveredconditionals', (string) $class['executedBranches']);
+                $xmlMetrics->setAttribute('statements', (string) $classStatements);
+                $xmlMetrics->setAttribute('coveredstatements', (string) $coveredClassStatements);
+                $xmlMetrics->setAttribute('elements', (string) ($classMethods + $classStatements + $class['executableBranches']));
+                $xmlMetrics->setAttribute('coveredelements', (string) ($coveredMethods + $coveredClassStatements + $class['executedBranches']));
+                $xmlClass->appendChild($xmlMetrics);
+            }
+
+            foreach ($coverageData as $line => $data) {
+                if ($data === null || isset($lines[$line])) {
+                    continue;
+                }
+
+                $lines[$line] = [
+                    'count' => count($data), 'type' => 'stmt',
+                ];
+            }
+
+            ksort($lines);
+
+            foreach ($lines as $line => $data) {
+                $xmlLine = $xmlDocument->createElement('line');
+                $xmlLine->setAttribute('num', (string) $line);
+                $xmlLine->setAttribute('type', $data['type']);
+
+                if (isset($data['name'])) {
+                    $xmlLine->setAttribute('name', $data['name']);
+                }
+
+                if (isset($data['visibility'])) {
+                    $xmlLine->setAttribute('visibility', $data['visibility']);
+                }
+
+                if (isset($data['ccn'])) {
+                    $xmlLine->setAttribute('complexity', (string) $data['ccn']);
+                }
+
+                if (isset($data['crap'])) {
+                    $xmlLine->setAttribute('crap', (string) $data['crap']);
+                }
+
+                $xmlLine->setAttribute('count', (string) $data['count']);
+                $xmlFile->appendChild($xmlLine);
+            }
+
+            $linesOfCode = $item->linesOfCode();
+
+            $xmlMetrics = $xmlDocument->createElement('metrics');
+            $xmlMetrics->setAttribute('loc', (string) $linesOfCode['linesOfCode']);
+            $xmlMetrics->setAttribute('ncloc', (string) $linesOfCode['nonCommentLinesOfCode']);
+            $xmlMetrics->setAttribute('classes', (string) $item->numberOfClassesAndTraits());
+            $xmlMetrics->setAttribute('methods', (string) $item->numberOfMethods());
+            $xmlMetrics->setAttribute('coveredmethods', (string) $item->numberOfTestedMethods());
+            $xmlMetrics->setAttribute('conditionals', (string) $item->numberOfExecutableBranches());
+            $xmlMetrics->setAttribute('coveredconditionals', (string) $item->numberOfExecutedBranches());
+            $xmlMetrics->setAttribute('statements', (string) $item->numberOfExecutableLines());
+            $xmlMetrics->setAttribute('coveredstatements', (string) $item->numberOfExecutedLines());
+            $xmlMetrics->setAttribute('elements', (string) ($item->numberOfMethods() + $item->numberOfExecutableLines() + $item->numberOfExecutableBranches()));
+            $xmlMetrics->setAttribute('coveredelements', (string) ($item->numberOfTestedMethods() + $item->numberOfExecutedLines() + $item->numberOfExecutedBranches()));
+            $xmlFile->appendChild($xmlMetrics);
+
+            if ($namespace === 'global') {
+                $xmlProject->appendChild($xmlFile);
+            } else {
+                if (!isset($packages[$namespace])) {
+                    $packages[$namespace] = $xmlDocument->createElement(
+                        'package',
+                    );
+
+                    $packages[$namespace]->setAttribute('name', $namespace);
+                    $xmlProject->appendChild($packages[$namespace]);
+                }
+
+                $packages[$namespace]->appendChild($xmlFile);
+            }
+        }
+
+        $linesOfCode = $report->linesOfCode();
+
+        $xmlMetrics = $xmlDocument->createElement('metrics');
+        $xmlMetrics->setAttribute('files', (string) count($report));
+        $xmlMetrics->setAttribute('loc', (string) $linesOfCode['linesOfCode']);
+        $xmlMetrics->setAttribute('ncloc', (string) $linesOfCode['nonCommentLinesOfCode']);
+        $xmlMetrics->setAttribute('classes', (string) $report->numberOfClassesAndTraits());
+        $xmlMetrics->setAttribute('methods', (string) $report->numberOfMethods());
+        $xmlMetrics->setAttribute('coveredmethods', (string) $report->numberOfTestedMethods());
+        $xmlMetrics->setAttribute('conditionals', (string) $report->numberOfExecutableBranches());
+        $xmlMetrics->setAttribute('coveredconditionals', (string) $report->numberOfExecutedBranches());
+        $xmlMetrics->setAttribute('statements', (string) $report->numberOfExecutableLines());
+        $xmlMetrics->setAttribute('coveredstatements', (string) $report->numberOfExecutedLines());
+        $xmlMetrics->setAttribute('elements', (string) ($report->numberOfMethods() + $report->numberOfExecutableLines() + $report->numberOfExecutableBranches()));
+        $xmlMetrics->setAttribute('coveredelements', (string) ($report->numberOfTestedMethods() + $report->numberOfExecutedLines() + $report->numberOfExecutedBranches()));
+        $xmlProject->appendChild($xmlMetrics);
+
+        $buffer = $xmlDocument->saveXML();
+
+        if ($target !== null) {
+            if (!str_contains($target, '://')) {
+                Filesystem::createDirectory(dirname($target));
+            }
+
+            if (@file_put_contents($target, $buffer) === false) {
+                throw new WriteOperationFailedException($target);
+            }
+        }
+
+        return $buffer;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Cobertura.php

@@ -0,0 +1,306 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report;
+
+use const DIRECTORY_SEPARATOR;
+use function basename;
+use function count;
+use function dirname;
+use function file_put_contents;
+use function preg_match;
+use function range;
+use function str_contains;
+use function str_replace;
+use function time;
+use DOMImplementation;
+use SebastianBergmann\CodeCoverage\CodeCoverage;
+use SebastianBergmann\CodeCoverage\Driver\WriteOperationFailedException;
+use SebastianBergmann\CodeCoverage\Node\File;
+use SebastianBergmann\CodeCoverage\Util\Filesystem;
+
+final class Cobertura
+{
+    /**
+     * @throws WriteOperationFailedException
+     */
+    public function process(CodeCoverage $coverage, ?string $target = null): string
+    {
+        $time = (string) time();
+
+        $report = $coverage->getReport();
+
+        $implementation = new DOMImplementation;
+
+        $documentType = $implementation->createDocumentType(
+            'coverage',
+            '',
+            'http://cobertura.sourceforge.net/xml/coverage-04.dtd',
+        );
+
+        $document               = $implementation->createDocument('', '', $documentType);
+        $document->xmlVersion   = '1.0';
+        $document->encoding     = 'UTF-8';
+        $document->formatOutput = true;
+
+        $coverageElement = $document->createElement('coverage');
+
+        $linesValid   = $report->numberOfExecutableLines();
+        $linesCovered = $report->numberOfExecutedLines();
+        $lineRate     = $linesValid === 0 ? 0 : ($linesCovered / $linesValid);
+        $coverageElement->setAttribute('line-rate', (string) $lineRate);
+
+        $branchesValid   = $report->numberOfExecutableBranches();
+        $branchesCovered = $report->numberOfExecutedBranches();
+        $branchRate      = $branchesValid === 0 ? 0 : ($branchesCovered / $branchesValid);
+        $coverageElement->setAttribute('branch-rate', (string) $branchRate);
+
+        $coverageElement->setAttribute('lines-covered', (string) $report->numberOfExecutedLines());
+        $coverageElement->setAttribute('lines-valid', (string) $report->numberOfExecutableLines());
+        $coverageElement->setAttribute('branches-covered', (string) $report->numberOfExecutedBranches());
+        $coverageElement->setAttribute('branches-valid', (string) $report->numberOfExecutableBranches());
+        $coverageElement->setAttribute('complexity', '');
+        $coverageElement->setAttribute('version', '0.4');
+        $coverageElement->setAttribute('timestamp', $time);
+
+        $document->appendChild($coverageElement);
+
+        $sourcesElement = $document->createElement('sources');
+        $coverageElement->appendChild($sourcesElement);
+
+        $sourceElement = $document->createElement('source', $report->pathAsString());
+        $sourcesElement->appendChild($sourceElement);
+
+        $packagesElement = $document->createElement('packages');
+        $coverageElement->appendChild($packagesElement);
+
+        $complexity = 0;
+
+        foreach ($report as $item) {
+            if (!$item instanceof File) {
+                continue;
+            }
+
+            $packageElement    = $document->createElement('package');
+            $packageComplexity = 0;
+
+            $packageElement->setAttribute('name', str_replace($report->pathAsString() . DIRECTORY_SEPARATOR, '', $item->pathAsString()));
+
+            $linesValid   = $item->numberOfExecutableLines();
+            $linesCovered = $item->numberOfExecutedLines();
+            $lineRate     = $linesValid === 0 ? 0 : ($linesCovered / $linesValid);
+
+            $packageElement->setAttribute('line-rate', (string) $lineRate);
+
+            $branchesValid   = $item->numberOfExecutableBranches();
+            $branchesCovered = $item->numberOfExecutedBranches();
+            $branchRate      = $branchesValid === 0 ? 0 : ($branchesCovered / $branchesValid);
+
+            $packageElement->setAttribute('branch-rate', (string) $branchRate);
+
+            $packageElement->setAttribute('complexity', '');
+            $packagesElement->appendChild($packageElement);
+
+            $classesElement = $document->createElement('classes');
+
+            $packageElement->appendChild($classesElement);
+
+            $classes      = $item->classesAndTraits();
+            $coverageData = $item->lineCoverageData();
+
+            foreach ($classes as $className => $class) {
+                $complexity        += $class['ccn'];
+                $packageComplexity += $class['ccn'];
+
+                $linesValid   = $class['executableLines'];
+                $linesCovered = $class['executedLines'];
+                $lineRate     = $linesValid === 0 ? 0 : ($linesCovered / $linesValid);
+
+                $branchesValid   = $class['executableBranches'];
+                $branchesCovered = $class['executedBranches'];
+                $branchRate      = $branchesValid === 0 ? 0 : ($branchesCovered / $branchesValid);
+
+                $classElement = $document->createElement('class');
+
+                $classElement->setAttribute('name', $className);
+                $classElement->setAttribute('filename', str_replace($report->pathAsString() . DIRECTORY_SEPARATOR, '', $item->pathAsString()));
+                $classElement->setAttribute('line-rate', (string) $lineRate);
+                $classElement->setAttribute('branch-rate', (string) $branchRate);
+                $classElement->setAttribute('complexity', (string) $class['ccn']);
+
+                $classesElement->appendChild($classElement);
+
+                $methodsElement = $document->createElement('methods');
+
+                $classElement->appendChild($methodsElement);
+
+                $classLinesElement = $document->createElement('lines');
+
+                $classElement->appendChild($classLinesElement);
+
+                foreach ($class['methods'] as $methodName => $method) {
+                    if ($method['executableLines'] === 0) {
+                        continue;
+                    }
+
+                    preg_match("/\((.*?)\)/", $method['signature'], $signature);
+
+                    $linesValid   = $method['executableLines'];
+                    $linesCovered = $method['executedLines'];
+                    $lineRate     = $linesValid === 0 ? 0 : ($linesCovered / $linesValid);
+
+                    $branchesValid   = $method['executableBranches'];
+                    $branchesCovered = $method['executedBranches'];
+                    $branchRate      = $branchesValid === 0 ? 0 : ($branchesCovered / $branchesValid);
+
+                    $methodElement = $document->createElement('method');
+
+                    $methodElement->setAttribute('name', $methodName);
+                    $methodElement->setAttribute('signature', $signature[1]);
+                    $methodElement->setAttribute('line-rate', (string) $lineRate);
+                    $methodElement->setAttribute('branch-rate', (string) $branchRate);
+                    $methodElement->setAttribute('complexity', (string) $method['ccn']);
+
+                    $methodLinesElement = $document->createElement('lines');
+
+                    $methodElement->appendChild($methodLinesElement);
+
+                    foreach (range($method['startLine'], $method['endLine']) as $line) {
+                        if (!isset($coverageData[$line])) {
+                            continue;
+                        }
+                        $methodLineElement = $document->createElement('line');
+
+                        $methodLineElement->setAttribute('number', (string) $line);
+                        $methodLineElement->setAttribute('hits', (string) count($coverageData[$line]));
+
+                        $methodLinesElement->appendChild($methodLineElement);
+
+                        $classLineElement = $methodLineElement->cloneNode();
+
+                        $classLinesElement->appendChild($classLineElement);
+                    }
+
+                    $methodsElement->appendChild($methodElement);
+                }
+            }
+
+            if ($item->numberOfFunctions() === 0) {
+                $packageElement->setAttribute('complexity', (string) $packageComplexity);
+
+                continue;
+            }
+
+            $functionsComplexity      = 0;
+            $functionsLinesValid      = 0;
+            $functionsLinesCovered    = 0;
+            $functionsBranchesValid   = 0;
+            $functionsBranchesCovered = 0;
+
+            $classElement = $document->createElement('class');
+            $classElement->setAttribute('name', basename($item->pathAsString()));
+            $classElement->setAttribute('filename', str_replace($report->pathAsString() . DIRECTORY_SEPARATOR, '', $item->pathAsString()));
+
+            $methodsElement = $document->createElement('methods');
+
+            $classElement->appendChild($methodsElement);
+
+            $classLinesElement = $document->createElement('lines');
+
+            $classElement->appendChild($classLinesElement);
+
+            $functions = $item->functions();
+
+            foreach ($functions as $functionName => $function) {
+                if ($function['executableLines'] === 0) {
+                    continue;
+                }
+
+                $complexity          += $function['ccn'];
+                $packageComplexity   += $function['ccn'];
+                $functionsComplexity += $function['ccn'];
+
+                $linesValid   = $function['executableLines'];
+                $linesCovered = $function['executedLines'];
+                $lineRate     = $linesValid === 0 ? 0 : ($linesCovered / $linesValid);
+
+                $functionsLinesValid   += $linesValid;
+                $functionsLinesCovered += $linesCovered;
+
+                $branchesValid   = $function['executableBranches'];
+                $branchesCovered = $function['executedBranches'];
+                $branchRate      = $branchesValid === 0 ? 0 : ($branchesCovered / $branchesValid);
+
+                $functionsBranchesValid   += $branchesValid;
+                $functionsBranchesCovered += $branchesValid;
+
+                $methodElement = $document->createElement('method');
+
+                $methodElement->setAttribute('name', $functionName);
+                $methodElement->setAttribute('signature', $function['signature']);
+                $methodElement->setAttribute('line-rate', (string) $lineRate);
+                $methodElement->setAttribute('branch-rate', (string) $branchRate);
+                $methodElement->setAttribute('complexity', (string) $function['ccn']);
+
+                $methodLinesElement = $document->createElement('lines');
+
+                $methodElement->appendChild($methodLinesElement);
+
+                foreach (range($function['startLine'], $function['endLine']) as $line) {
+                    if (!isset($coverageData[$line])) {
+                        continue;
+                    }
+                    $methodLineElement = $document->createElement('line');
+
+                    $methodLineElement->setAttribute('number', (string) $line);
+                    $methodLineElement->setAttribute('hits', (string) count($coverageData[$line]));
+
+                    $methodLinesElement->appendChild($methodLineElement);
+
+                    $classLineElement = $methodLineElement->cloneNode();
+
+                    $classLinesElement->appendChild($classLineElement);
+                }
+
+                $methodsElement->appendChild($methodElement);
+            }
+
+            $packageElement->setAttribute('complexity', (string) $packageComplexity);
+
+            if ($functionsLinesValid === 0) {
+                continue;
+            }
+
+            $lineRate   = $functionsLinesCovered / $functionsLinesValid;
+            $branchRate = $functionsBranchesValid === 0 ? 0 : ($functionsBranchesCovered / $functionsBranchesValid);
+
+            $classElement->setAttribute('line-rate', (string) $lineRate);
+            $classElement->setAttribute('branch-rate', (string) $branchRate);
+            $classElement->setAttribute('complexity', (string) $functionsComplexity);
+
+            $classesElement->appendChild($classElement);
+        }
+
+        $coverageElement->setAttribute('complexity', (string) $complexity);
+
+        $buffer = $document->saveXML();
+
+        if ($target !== null) {
+            if (!str_contains($target, '://')) {
+                Filesystem::createDirectory(dirname($target));
+            }
+
+            if (@file_put_contents($target, $buffer) === false) {
+                throw new WriteOperationFailedException($target);
+            }
+        }
+
+        return $buffer;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Crap4j.php

@@ -0,0 +1,153 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report;
+
+use function date;
+use function dirname;
+use function file_put_contents;
+use function htmlspecialchars;
+use function is_string;
+use function round;
+use function str_contains;
+use DOMDocument;
+use SebastianBergmann\CodeCoverage\CodeCoverage;
+use SebastianBergmann\CodeCoverage\Driver\WriteOperationFailedException;
+use SebastianBergmann\CodeCoverage\Node\File;
+use SebastianBergmann\CodeCoverage\Util\Filesystem;
+
+final class Crap4j
+{
+    private readonly int $threshold;
+
+    public function __construct(int $threshold = 30)
+    {
+        $this->threshold = $threshold;
+    }
+
+    /**
+     * @throws WriteOperationFailedException
+     */
+    public function process(CodeCoverage $coverage, ?string $target = null, ?string $name = null): string
+    {
+        $document               = new DOMDocument('1.0', 'UTF-8');
+        $document->formatOutput = true;
+
+        $root = $document->createElement('crap_result');
+        $document->appendChild($root);
+
+        $project = $document->createElement('project', is_string($name) ? $name : '');
+        $root->appendChild($project);
+        $root->appendChild($document->createElement('timestamp', date('Y-m-d H:i:s')));
+
+        $stats       = $document->createElement('stats');
+        $methodsNode = $document->createElement('methods');
+
+        $report = $coverage->getReport();
+        unset($coverage);
+
+        $fullMethodCount     = 0;
+        $fullCrapMethodCount = 0;
+        $fullCrapLoad        = 0;
+        $fullCrap            = 0;
+
+        foreach ($report as $item) {
+            $namespace = 'global';
+
+            if (!$item instanceof File) {
+                continue;
+            }
+
+            $file = $document->createElement('file');
+            $file->setAttribute('name', $item->pathAsString());
+
+            $classes = $item->classesAndTraits();
+
+            foreach ($classes as $className => $class) {
+                foreach ($class['methods'] as $methodName => $method) {
+                    $crapLoad = $this->crapLoad((float) $method['crap'], $method['ccn'], $method['coverage']);
+
+                    $fullCrap     += $method['crap'];
+                    $fullCrapLoad += $crapLoad;
+                    $fullMethodCount++;
+
+                    if ($method['crap'] >= $this->threshold) {
+                        $fullCrapMethodCount++;
+                    }
+
+                    $methodNode = $document->createElement('method');
+
+                    if (!empty($class['namespace'])) {
+                        $namespace = $class['namespace'];
+                    }
+
+                    $methodNode->appendChild($document->createElement('package', $namespace));
+                    $methodNode->appendChild($document->createElement('className', $className));
+                    $methodNode->appendChild($document->createElement('methodName', $methodName));
+                    $methodNode->appendChild($document->createElement('methodSignature', htmlspecialchars($method['signature'])));
+                    $methodNode->appendChild($document->createElement('fullMethod', htmlspecialchars($method['signature'])));
+                    $methodNode->appendChild($document->createElement('crap', (string) $this->roundValue((float) $method['crap'])));
+                    $methodNode->appendChild($document->createElement('complexity', (string) $method['ccn']));
+                    $methodNode->appendChild($document->createElement('coverage', (string) $this->roundValue($method['coverage'])));
+                    $methodNode->appendChild($document->createElement('crapLoad', (string) round($crapLoad)));
+
+                    $methodsNode->appendChild($methodNode);
+                }
+            }
+        }
+
+        $stats->appendChild($document->createElement('name', 'Method Crap Stats'));
+        $stats->appendChild($document->createElement('methodCount', (string) $fullMethodCount));
+        $stats->appendChild($document->createElement('crapMethodCount', (string) $fullCrapMethodCount));
+        $stats->appendChild($document->createElement('crapLoad', (string) round($fullCrapLoad)));
+        $stats->appendChild($document->createElement('totalCrap', (string) $fullCrap));
+
+        $crapMethodPercent = 0;
+
+        if ($fullMethodCount > 0) {
+            $crapMethodPercent = $this->roundValue((100 * $fullCrapMethodCount) / $fullMethodCount);
+        }
+
+        $stats->appendChild($document->createElement('crapMethodPercent', (string) $crapMethodPercent));
+
+        $root->appendChild($stats);
+        $root->appendChild($methodsNode);
+
+        $buffer = $document->saveXML();
+
+        if ($target !== null) {
+            if (!str_contains($target, '://')) {
+                Filesystem::createDirectory(dirname($target));
+            }
+
+            if (@file_put_contents($target, $buffer) === false) {
+                throw new WriteOperationFailedException($target);
+            }
+        }
+
+        return $buffer;
+    }
+
+    private function crapLoad(float $crapValue, int $cyclomaticComplexity, float $coveragePercent): float
+    {
+        $crapLoad = 0;
+
+        if ($crapValue >= $this->threshold) {
+            $crapLoad += $cyclomaticComplexity * (1.0 - $coveragePercent / 100);
+            $crapLoad += $cyclomaticComplexity / $this->threshold;
+        }
+
+        return $crapLoad;
+    }
+
+    private function roundValue(float $value): float
+    {
+        return round($value, 2);
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Html/Colors.php

@@ -0,0 +1,66 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Html;
+
+/**
+ * @immutable
+ */
+final class Colors
+{
+    private readonly string $successLow;
+    private readonly string $successMedium;
+    private readonly string $successHigh;
+    private readonly string $warning;
+    private readonly string $danger;
+
+    public static function default(): self
+    {
+        return new self('#dff0d8', '#c3e3b5', '#99cb84', '#fcf8e3', '#f2dede');
+    }
+
+    public static function from(string $successLow, string $successMedium, string $successHigh, string $warning, string $danger): self
+    {
+        return new self($successLow, $successMedium, $successHigh, $warning, $danger);
+    }
+
+    private function __construct(string $successLow, string $successMedium, string $successHigh, string $warning, string $danger)
+    {
+        $this->successLow    = $successLow;
+        $this->successMedium = $successMedium;
+        $this->successHigh   = $successHigh;
+        $this->warning       = $warning;
+        $this->danger        = $danger;
+    }
+
+    public function successLow(): string
+    {
+        return $this->successLow;
+    }
+
+    public function successMedium(): string
+    {
+        return $this->successMedium;
+    }
+
+    public function successHigh(): string
+    {
+        return $this->successHigh;
+    }
+
+    public function warning(): string
+    {
+        return $this->warning;
+    }
+
+    public function danger(): string
+    {
+        return $this->danger;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Html/CustomCssFile.php

@@ -0,0 +1,50 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Html;
+
+use function is_file;
+use SebastianBergmann\CodeCoverage\InvalidArgumentException;
+
+/**
+ * @immutable
+ */
+final class CustomCssFile
+{
+    private readonly string $path;
+
+    public static function default(): self
+    {
+        return new self(__DIR__ . '/Renderer/Template/css/custom.css');
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public static function from(string $path): self
+    {
+        if (!is_file($path)) {
+            throw new InvalidArgumentException(
+                '$path does not exist',
+            );
+        }
+
+        return new self($path);
+    }
+
+    private function __construct(string $path)
+    {
+        $this->path = $path;
+    }
+
+    public function path(): string
+    {
+        return $this->path;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Html/Facade.php

@@ -0,0 +1,152 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Html;
+
+use const DIRECTORY_SEPARATOR;
+use function copy;
+use function date;
+use function dirname;
+use function str_ends_with;
+use SebastianBergmann\CodeCoverage\CodeCoverage;
+use SebastianBergmann\CodeCoverage\FileCouldNotBeWrittenException;
+use SebastianBergmann\CodeCoverage\Node\Directory as DirectoryNode;
+use SebastianBergmann\CodeCoverage\Report\Thresholds;
+use SebastianBergmann\CodeCoverage\Util\Filesystem;
+use SebastianBergmann\Template\Exception;
+use SebastianBergmann\Template\Template;
+
+final class Facade
+{
+    private readonly string $templatePath;
+    private readonly string $generator;
+    private readonly Colors $colors;
+    private readonly Thresholds $thresholds;
+    private readonly CustomCssFile $customCssFile;
+
+    public function __construct(string $generator = '', ?Colors $colors = null, ?Thresholds $thresholds = null, ?CustomCssFile $customCssFile = null)
+    {
+        $this->generator     = $generator;
+        $this->colors        = $colors ?? Colors::default();
+        $this->thresholds    = $thresholds ?? Thresholds::default();
+        $this->customCssFile = $customCssFile ?? CustomCssFile::default();
+        $this->templatePath  = __DIR__ . '/Renderer/Template/';
+    }
+
+    public function process(CodeCoverage $coverage, string $target): void
+    {
+        $target = $this->directory($target);
+        $report = $coverage->getReport();
+        $date   = date('D M j G:i:s T Y');
+
+        $dashboard = new Dashboard(
+            $this->templatePath,
+            $this->generator,
+            $date,
+            $this->thresholds,
+            $coverage->collectsBranchAndPathCoverage(),
+        );
+
+        $directory = new Directory(
+            $this->templatePath,
+            $this->generator,
+            $date,
+            $this->thresholds,
+            $coverage->collectsBranchAndPathCoverage(),
+        );
+
+        $file = new File(
+            $this->templatePath,
+            $this->generator,
+            $date,
+            $this->thresholds,
+            $coverage->collectsBranchAndPathCoverage(),
+        );
+
+        $directory->render($report, $target . 'index.html');
+        $dashboard->render($report, $target . 'dashboard.html');
+
+        foreach ($report as $node) {
+            $id = $node->id();
+
+            if ($node instanceof DirectoryNode) {
+                Filesystem::createDirectory($target . $id);
+
+                $directory->render($node, $target . $id . '/index.html');
+                $dashboard->render($node, $target . $id . '/dashboard.html');
+            } else {
+                $dir = dirname($target . $id);
+
+                Filesystem::createDirectory($dir);
+
+                $file->render($node, $target . $id);
+            }
+        }
+
+        $this->copyFiles($target);
+        $this->renderCss($target);
+    }
+
+    private function copyFiles(string $target): void
+    {
+        $dir = $this->directory($target . '_css');
+
+        copy($this->templatePath . 'css/bootstrap.min.css', $dir . 'bootstrap.min.css');
+        copy($this->templatePath . 'css/nv.d3.min.css', $dir . 'nv.d3.min.css');
+        copy($this->customCssFile->path(), $dir . 'custom.css');
+        copy($this->templatePath . 'css/octicons.css', $dir . 'octicons.css');
+
+        $dir = $this->directory($target . '_icons');
+        copy($this->templatePath . 'icons/file-code.svg', $dir . 'file-code.svg');
+        copy($this->templatePath . 'icons/file-directory.svg', $dir . 'file-directory.svg');
+
+        $dir = $this->directory($target . '_js');
+        copy($this->templatePath . 'js/bootstrap.bundle.min.js', $dir . 'bootstrap.bundle.min.js');
+        copy($this->templatePath . 'js/d3.min.js', $dir . 'd3.min.js');
+        copy($this->templatePath . 'js/jquery.min.js', $dir . 'jquery.min.js');
+        copy($this->templatePath . 'js/nv.d3.min.js', $dir . 'nv.d3.min.js');
+        copy($this->templatePath . 'js/file.js', $dir . 'file.js');
+    }
+
+    private function renderCss(string $target): void
+    {
+        $template = new Template($this->templatePath . 'css/style.css', '{{', '}}');
+
+        $template->setVar(
+            [
+                'success-low'    => $this->colors->successLow(),
+                'success-medium' => $this->colors->successMedium(),
+                'success-high'   => $this->colors->successHigh(),
+                'warning'        => $this->colors->warning(),
+                'danger'         => $this->colors->danger(),
+            ],
+        );
+
+        try {
+            $template->renderTo($this->directory($target . '_css') . 'style.css');
+        } catch (Exception $e) {
+            throw new FileCouldNotBeWrittenException(
+                $e->getMessage(),
+                $e->getCode(),
+                $e,
+            );
+        }
+    }
+
+    private function directory(string $directory): string
+    {
+        if (!str_ends_with($directory, DIRECTORY_SEPARATOR)) {
+            $directory .= DIRECTORY_SEPARATOR;
+        }
+
+        Filesystem::createDirectory($directory);
+
+        return $directory;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer.php

@@ -0,0 +1,286 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Html;
+
+use function array_pop;
+use function count;
+use function sprintf;
+use function str_repeat;
+use function substr_count;
+use SebastianBergmann\CodeCoverage\Node\AbstractNode;
+use SebastianBergmann\CodeCoverage\Node\Directory as DirectoryNode;
+use SebastianBergmann\CodeCoverage\Node\File as FileNode;
+use SebastianBergmann\CodeCoverage\Report\Thresholds;
+use SebastianBergmann\CodeCoverage\Version;
+use SebastianBergmann\Environment\Runtime;
+use SebastianBergmann\Template\Template;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+abstract class Renderer
+{
+    protected string $templatePath;
+    protected string $generator;
+    protected string $date;
+    protected Thresholds $thresholds;
+    protected bool $hasBranchCoverage;
+    protected string $version;
+
+    public function __construct(string $templatePath, string $generator, string $date, Thresholds $thresholds, bool $hasBranchCoverage)
+    {
+        $this->templatePath      = $templatePath;
+        $this->generator         = $generator;
+        $this->date              = $date;
+        $this->thresholds        = $thresholds;
+        $this->version           = Version::id();
+        $this->hasBranchCoverage = $hasBranchCoverage;
+    }
+
+    protected function renderItemTemplate(Template $template, array $data): string
+    {
+        $numSeparator = '&nbsp;/&nbsp;';
+
+        if (isset($data['numClasses']) && $data['numClasses'] > 0) {
+            $classesLevel = $this->colorLevel($data['testedClassesPercent']);
+
+            $classesNumber = $data['numTestedClasses'] . $numSeparator .
+                $data['numClasses'];
+
+            $classesBar = $this->coverageBar(
+                $data['testedClassesPercent'],
+            );
+        } else {
+            $classesLevel                         = '';
+            $classesNumber                        = '0' . $numSeparator . '0';
+            $classesBar                           = '';
+            $data['testedClassesPercentAsString'] = 'n/a';
+        }
+
+        if ($data['numMethods'] > 0) {
+            $methodsLevel = $this->colorLevel($data['testedMethodsPercent']);
+
+            $methodsNumber = $data['numTestedMethods'] . $numSeparator .
+                $data['numMethods'];
+
+            $methodsBar = $this->coverageBar(
+                $data['testedMethodsPercent'],
+            );
+        } else {
+            $methodsLevel                         = '';
+            $methodsNumber                        = '0' . $numSeparator . '0';
+            $methodsBar                           = '';
+            $data['testedMethodsPercentAsString'] = 'n/a';
+        }
+
+        if ($data['numExecutableLines'] > 0) {
+            $linesLevel = $this->colorLevel($data['linesExecutedPercent']);
+
+            $linesNumber = $data['numExecutedLines'] . $numSeparator .
+                $data['numExecutableLines'];
+
+            $linesBar = $this->coverageBar(
+                $data['linesExecutedPercent'],
+            );
+        } else {
+            $linesLevel                           = '';
+            $linesNumber                          = '0' . $numSeparator . '0';
+            $linesBar                             = '';
+            $data['linesExecutedPercentAsString'] = 'n/a';
+        }
+
+        if ($data['numExecutablePaths'] > 0) {
+            $pathsLevel = $this->colorLevel($data['pathsExecutedPercent']);
+
+            $pathsNumber = $data['numExecutedPaths'] . $numSeparator .
+                $data['numExecutablePaths'];
+
+            $pathsBar = $this->coverageBar(
+                $data['pathsExecutedPercent'],
+            );
+        } else {
+            $pathsLevel                           = '';
+            $pathsNumber                          = '0' . $numSeparator . '0';
+            $pathsBar                             = '';
+            $data['pathsExecutedPercentAsString'] = 'n/a';
+        }
+
+        if ($data['numExecutableBranches'] > 0) {
+            $branchesLevel = $this->colorLevel($data['branchesExecutedPercent']);
+
+            $branchesNumber = $data['numExecutedBranches'] . $numSeparator .
+                $data['numExecutableBranches'];
+
+            $branchesBar = $this->coverageBar(
+                $data['branchesExecutedPercent'],
+            );
+        } else {
+            $branchesLevel                           = '';
+            $branchesNumber                          = '0' . $numSeparator . '0';
+            $branchesBar                             = '';
+            $data['branchesExecutedPercentAsString'] = 'n/a';
+        }
+
+        $template->setVar(
+            [
+                'icon'                      => $data['icon'] ?? '',
+                'crap'                      => $data['crap'] ?? '',
+                'name'                      => $data['name'],
+                'lines_bar'                 => $linesBar,
+                'lines_executed_percent'    => $data['linesExecutedPercentAsString'],
+                'lines_level'               => $linesLevel,
+                'lines_number'              => $linesNumber,
+                'paths_bar'                 => $pathsBar,
+                'paths_executed_percent'    => $data['pathsExecutedPercentAsString'],
+                'paths_level'               => $pathsLevel,
+                'paths_number'              => $pathsNumber,
+                'branches_bar'              => $branchesBar,
+                'branches_executed_percent' => $data['branchesExecutedPercentAsString'],
+                'branches_level'            => $branchesLevel,
+                'branches_number'           => $branchesNumber,
+                'methods_bar'               => $methodsBar,
+                'methods_tested_percent'    => $data['testedMethodsPercentAsString'],
+                'methods_level'             => $methodsLevel,
+                'methods_number'            => $methodsNumber,
+                'classes_bar'               => $classesBar,
+                'classes_tested_percent'    => $data['testedClassesPercentAsString'] ?? '',
+                'classes_level'             => $classesLevel,
+                'classes_number'            => $classesNumber,
+            ],
+        );
+
+        return $template->render();
+    }
+
+    protected function setCommonTemplateVariables(Template $template, AbstractNode $node): void
+    {
+        $template->setVar(
+            [
+                'id'               => $node->id(),
+                'full_path'        => $node->pathAsString(),
+                'path_to_root'     => $this->pathToRoot($node),
+                'breadcrumbs'      => $this->breadcrumbs($node),
+                'date'             => $this->date,
+                'version'          => $this->version,
+                'runtime'          => $this->runtimeString(),
+                'generator'        => $this->generator,
+                'low_upper_bound'  => $this->thresholds->lowUpperBound(),
+                'high_lower_bound' => $this->thresholds->highLowerBound(),
+            ],
+        );
+    }
+
+    protected function breadcrumbs(AbstractNode $node): string
+    {
+        $breadcrumbs = '';
+        $path        = $node->pathAsArray();
+        $pathToRoot  = [];
+        $max         = count($path);
+
+        if ($node instanceof FileNode) {
+            $max--;
+        }
+
+        for ($i = 0; $i < $max; $i++) {
+            $pathToRoot[] = str_repeat('../', $i);
+        }
+
+        foreach ($path as $step) {
+            if ($step !== $node) {
+                $breadcrumbs .= $this->inactiveBreadcrumb(
+                    $step,
+                    array_pop($pathToRoot),
+                );
+            } else {
+                $breadcrumbs .= $this->activeBreadcrumb($step);
+            }
+        }
+
+        return $breadcrumbs;
+    }
+
+    protected function activeBreadcrumb(AbstractNode $node): string
+    {
+        $buffer = sprintf(
+            '         <li class="breadcrumb-item active">%s</li>' . "\n",
+            $node->name(),
+        );
+
+        if ($node instanceof DirectoryNode) {
+            $buffer .= '         <li class="breadcrumb-item">(<a href="dashboard.html">Dashboard</a>)</li>' . "\n";
+        }
+
+        return $buffer;
+    }
+
+    protected function inactiveBreadcrumb(AbstractNode $node, string $pathToRoot): string
+    {
+        return sprintf(
+            '         <li class="breadcrumb-item"><a href="%sindex.html">%s</a></li>' . "\n",
+            $pathToRoot,
+            $node->name(),
+        );
+    }
+
+    protected function pathToRoot(AbstractNode $node): string
+    {
+        $id    = $node->id();
+        $depth = substr_count($id, '/');
+
+        if ($id !== 'index' &&
+            $node instanceof DirectoryNode) {
+            $depth++;
+        }
+
+        return str_repeat('../', $depth);
+    }
+
+    protected function coverageBar(float $percent): string
+    {
+        $level = $this->colorLevel($percent);
+
+        $templateName = $this->templatePath . ($this->hasBranchCoverage ? 'coverage_bar_branch.html' : 'coverage_bar.html');
+        $template     = new Template(
+            $templateName,
+            '{{',
+            '}}',
+        );
+
+        $template->setVar(['level' => $level, 'percent' => sprintf('%.2F', $percent)]);
+
+        return $template->render();
+    }
+
+    protected function colorLevel(float $percent): string
+    {
+        if ($percent <= $this->thresholds->lowUpperBound()) {
+            return 'danger';
+        }
+
+        if ($percent > $this->thresholds->lowUpperBound() &&
+            $percent < $this->thresholds->highLowerBound()) {
+            return 'warning';
+        }
+
+        return 'success';
+    }
+
+    private function runtimeString(): string
+    {
+        $runtime = new Runtime;
+
+        return sprintf(
+            '<a href="%s" target="_top">%s %s</a>',
+            $runtime->getVendorUrl(),
+            $runtime->getName(),
+            $runtime->getVersion(),
+        );
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Dashboard.php

@@ -0,0 +1,298 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Html;
+
+use function array_values;
+use function arsort;
+use function asort;
+use function count;
+use function explode;
+use function floor;
+use function json_encode;
+use function sprintf;
+use function str_replace;
+use SebastianBergmann\CodeCoverage\FileCouldNotBeWrittenException;
+use SebastianBergmann\CodeCoverage\Node\AbstractNode;
+use SebastianBergmann\CodeCoverage\Node\Directory as DirectoryNode;
+use SebastianBergmann\Template\Exception;
+use SebastianBergmann\Template\Template;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+final class Dashboard extends Renderer
+{
+    public function render(DirectoryNode $node, string $file): void
+    {
+        $classes      = $node->classesAndTraits();
+        $templateName = $this->templatePath . ($this->hasBranchCoverage ? 'dashboard_branch.html' : 'dashboard.html');
+        $template     = new Template(
+            $templateName,
+            '{{',
+            '}}',
+        );
+
+        $this->setCommonTemplateVariables($template, $node);
+
+        $baseLink             = $node->id() . '/';
+        $complexity           = $this->complexity($classes, $baseLink);
+        $coverageDistribution = $this->coverageDistribution($classes);
+        $insufficientCoverage = $this->insufficientCoverage($classes, $baseLink);
+        $projectRisks         = $this->projectRisks($classes, $baseLink);
+
+        $template->setVar(
+            [
+                'insufficient_coverage_classes' => $insufficientCoverage['class'],
+                'insufficient_coverage_methods' => $insufficientCoverage['method'],
+                'project_risks_classes'         => $projectRisks['class'],
+                'project_risks_methods'         => $projectRisks['method'],
+                'complexity_class'              => $complexity['class'],
+                'complexity_method'             => $complexity['method'],
+                'class_coverage_distribution'   => $coverageDistribution['class'],
+                'method_coverage_distribution'  => $coverageDistribution['method'],
+            ],
+        );
+
+        try {
+            $template->renderTo($file);
+        } catch (Exception $e) {
+            throw new FileCouldNotBeWrittenException(
+                $e->getMessage(),
+                $e->getCode(),
+                $e,
+            );
+        }
+    }
+
+    protected function activeBreadcrumb(AbstractNode $node): string
+    {
+        return sprintf(
+            '         <li class="breadcrumb-item"><a href="index.html">%s</a></li>' . "\n" .
+            '         <li class="breadcrumb-item active">(Dashboard)</li>' . "\n",
+            $node->name(),
+        );
+    }
+
+    /**
+     * Returns the data for the Class/Method Complexity charts.
+     */
+    private function complexity(array $classes, string $baseLink): array
+    {
+        $result = ['class' => [], 'method' => []];
+
+        foreach ($classes as $className => $class) {
+            foreach ($class['methods'] as $methodName => $method) {
+                if ($className !== '*') {
+                    $methodName = $className . '::' . $methodName;
+                }
+
+                $result['method'][] = [
+                    $method['coverage'],
+                    $method['ccn'],
+                    sprintf(
+                        '<a href="%s">%s</a>',
+                        str_replace($baseLink, '', $method['link']),
+                        $methodName,
+                    ),
+                ];
+            }
+
+            $result['class'][] = [
+                $class['coverage'],
+                $class['ccn'],
+                sprintf(
+                    '<a href="%s">%s</a>',
+                    str_replace($baseLink, '', $class['link']),
+                    $className,
+                ),
+            ];
+        }
+
+        return [
+            'class'  => json_encode($result['class']),
+            'method' => json_encode($result['method']),
+        ];
+    }
+
+    /**
+     * Returns the data for the Class / Method Coverage Distribution chart.
+     */
+    private function coverageDistribution(array $classes): array
+    {
+        $result = [
+            'class' => [
+                '0%'      => 0,
+                '0-10%'   => 0,
+                '10-20%'  => 0,
+                '20-30%'  => 0,
+                '30-40%'  => 0,
+                '40-50%'  => 0,
+                '50-60%'  => 0,
+                '60-70%'  => 0,
+                '70-80%'  => 0,
+                '80-90%'  => 0,
+                '90-100%' => 0,
+                '100%'    => 0,
+            ],
+            'method' => [
+                '0%'      => 0,
+                '0-10%'   => 0,
+                '10-20%'  => 0,
+                '20-30%'  => 0,
+                '30-40%'  => 0,
+                '40-50%'  => 0,
+                '50-60%'  => 0,
+                '60-70%'  => 0,
+                '70-80%'  => 0,
+                '80-90%'  => 0,
+                '90-100%' => 0,
+                '100%'    => 0,
+            ],
+        ];
+
+        foreach ($classes as $class) {
+            foreach ($class['methods'] as $methodName => $method) {
+                if ($method['coverage'] === 0) {
+                    $result['method']['0%']++;
+                } elseif ($method['coverage'] === 100) {
+                    $result['method']['100%']++;
+                } else {
+                    $key = floor($method['coverage'] / 10) * 10;
+                    $key = $key . '-' . ($key + 10) . '%';
+                    $result['method'][$key]++;
+                }
+            }
+
+            if ($class['coverage'] === 0) {
+                $result['class']['0%']++;
+            } elseif ($class['coverage'] === 100) {
+                $result['class']['100%']++;
+            } else {
+                $key = floor($class['coverage'] / 10) * 10;
+                $key = $key . '-' . ($key + 10) . '%';
+                $result['class'][$key]++;
+            }
+        }
+
+        return [
+            'class'  => json_encode(array_values($result['class'])),
+            'method' => json_encode(array_values($result['method'])),
+        ];
+    }
+
+    /**
+     * Returns the classes / methods with insufficient coverage.
+     */
+    private function insufficientCoverage(array $classes, string $baseLink): array
+    {
+        $leastTestedClasses = [];
+        $leastTestedMethods = [];
+        $result             = ['class' => '', 'method' => ''];
+
+        foreach ($classes as $className => $class) {
+            foreach ($class['methods'] as $methodName => $method) {
+                if ($method['coverage'] < $this->thresholds->highLowerBound()) {
+                    $key = $methodName;
+
+                    if ($className !== '*') {
+                        $key = $className . '::' . $methodName;
+                    }
+
+                    $leastTestedMethods[$key] = $method['coverage'];
+                }
+            }
+
+            if ($class['coverage'] < $this->thresholds->highLowerBound()) {
+                $leastTestedClasses[$className] = $class['coverage'];
+            }
+        }
+
+        asort($leastTestedClasses);
+        asort($leastTestedMethods);
+
+        foreach ($leastTestedClasses as $className => $coverage) {
+            $result['class'] .= sprintf(
+                '       <tr><td><a href="%s">%s</a></td><td class="text-right">%d%%</td></tr>' . "\n",
+                str_replace($baseLink, '', $classes[$className]['link']),
+                $className,
+                $coverage,
+            );
+        }
+
+        foreach ($leastTestedMethods as $methodName => $coverage) {
+            [$class, $method] = explode('::', $methodName);
+
+            $result['method'] .= sprintf(
+                '       <tr><td><a href="%s"><abbr title="%s">%s</abbr></a></td><td class="text-right">%d%%</td></tr>' . "\n",
+                str_replace($baseLink, '', $classes[$class]['methods'][$method]['link']),
+                $methodName,
+                $method,
+                $coverage,
+            );
+        }
+
+        return $result;
+    }
+
+    /**
+     * Returns the project risks according to the CRAP index.
+     */
+    private function projectRisks(array $classes, string $baseLink): array
+    {
+        $classRisks  = [];
+        $methodRisks = [];
+        $result      = ['class' => '', 'method' => ''];
+
+        foreach ($classes as $className => $class) {
+            foreach ($class['methods'] as $methodName => $method) {
+                if ($method['coverage'] < $this->thresholds->highLowerBound() && $method['ccn'] > 1) {
+                    $key = $methodName;
+
+                    if ($className !== '*') {
+                        $key = $className . '::' . $methodName;
+                    }
+
+                    $methodRisks[$key] = $method['crap'];
+                }
+            }
+
+            if ($class['coverage'] < $this->thresholds->highLowerBound() &&
+                $class['ccn'] > count($class['methods'])) {
+                $classRisks[$className] = $class['crap'];
+            }
+        }
+
+        arsort($classRisks);
+        arsort($methodRisks);
+
+        foreach ($classRisks as $className => $crap) {
+            $result['class'] .= sprintf(
+                '       <tr><td><a href="%s">%s</a></td><td class="text-right">%d</td></tr>' . "\n",
+                str_replace($baseLink, '', $classes[$className]['link']),
+                $className,
+                $crap,
+            );
+        }
+
+        foreach ($methodRisks as $methodName => $crap) {
+            [$class, $method] = explode('::', $methodName);
+
+            $result['method'] .= sprintf(
+                '       <tr><td><a href="%s"><abbr title="%s">%s</abbr></a></td><td class="text-right">%d</td></tr>' . "\n",
+                str_replace($baseLink, '', $classes[$class]['methods'][$method]['link']),
+                $methodName,
+                $method,
+                $crap,
+            );
+        }
+
+        return $result;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Directory.php

@@ -0,0 +1,123 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Html;
+
+use function count;
+use function sprintf;
+use function str_repeat;
+use SebastianBergmann\CodeCoverage\FileCouldNotBeWrittenException;
+use SebastianBergmann\CodeCoverage\Node\AbstractNode as Node;
+use SebastianBergmann\CodeCoverage\Node\Directory as DirectoryNode;
+use SebastianBergmann\Template\Exception;
+use SebastianBergmann\Template\Template;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+final class Directory extends Renderer
+{
+    public function render(DirectoryNode $node, string $file): void
+    {
+        $templateName = $this->templatePath . ($this->hasBranchCoverage ? 'directory_branch.html' : 'directory.html');
+        $template     = new Template($templateName, '{{', '}}');
+
+        $this->setCommonTemplateVariables($template, $node);
+
+        $items = $this->renderItem($node, true);
+
+        foreach ($node->directories() as $item) {
+            $items .= $this->renderItem($item);
+        }
+
+        foreach ($node->files() as $item) {
+            $items .= $this->renderItem($item);
+        }
+
+        $template->setVar(
+            [
+                'id'    => $node->id(),
+                'items' => $items,
+            ],
+        );
+
+        try {
+            $template->renderTo($file);
+        } catch (Exception $e) {
+            throw new FileCouldNotBeWrittenException(
+                $e->getMessage(),
+                $e->getCode(),
+                $e,
+            );
+        }
+    }
+
+    private function renderItem(Node $node, bool $total = false): string
+    {
+        $data = [
+            'numClasses'                      => $node->numberOfClassesAndTraits(),
+            'numTestedClasses'                => $node->numberOfTestedClassesAndTraits(),
+            'numMethods'                      => $node->numberOfFunctionsAndMethods(),
+            'numTestedMethods'                => $node->numberOfTestedFunctionsAndMethods(),
+            'linesExecutedPercent'            => $node->percentageOfExecutedLines()->asFloat(),
+            'linesExecutedPercentAsString'    => $node->percentageOfExecutedLines()->asString(),
+            'numExecutedLines'                => $node->numberOfExecutedLines(),
+            'numExecutableLines'              => $node->numberOfExecutableLines(),
+            'branchesExecutedPercent'         => $node->percentageOfExecutedBranches()->asFloat(),
+            'branchesExecutedPercentAsString' => $node->percentageOfExecutedBranches()->asString(),
+            'numExecutedBranches'             => $node->numberOfExecutedBranches(),
+            'numExecutableBranches'           => $node->numberOfExecutableBranches(),
+            'pathsExecutedPercent'            => $node->percentageOfExecutedPaths()->asFloat(),
+            'pathsExecutedPercentAsString'    => $node->percentageOfExecutedPaths()->asString(),
+            'numExecutedPaths'                => $node->numberOfExecutedPaths(),
+            'numExecutablePaths'              => $node->numberOfExecutablePaths(),
+            'testedMethodsPercent'            => $node->percentageOfTestedFunctionsAndMethods()->asFloat(),
+            'testedMethodsPercentAsString'    => $node->percentageOfTestedFunctionsAndMethods()->asString(),
+            'testedClassesPercent'            => $node->percentageOfTestedClassesAndTraits()->asFloat(),
+            'testedClassesPercentAsString'    => $node->percentageOfTestedClassesAndTraits()->asString(),
+        ];
+
+        if ($total) {
+            $data['name'] = 'Total';
+        } else {
+            $up           = str_repeat('../', count($node->pathAsArray()) - 2);
+            $data['icon'] = sprintf('<img src="%s_icons/file-code.svg" class="octicon" />', $up);
+
+            if ($node instanceof DirectoryNode) {
+                $data['name'] = sprintf(
+                    '<a href="%s/index.html">%s</a>',
+                    $node->name(),
+                    $node->name(),
+                );
+                $data['icon'] = sprintf('<img src="%s_icons/file-directory.svg" class="octicon" />', $up);
+            } elseif ($this->hasBranchCoverage) {
+                $data['name'] = sprintf(
+                    '%s <a class="small" href="%s.html">[line]</a> <a class="small" href="%s_branch.html">[branch]</a> <a class="small" href="%s_path.html">[path]</a>',
+                    $node->name(),
+                    $node->name(),
+                    $node->name(),
+                    $node->name(),
+                );
+            } else {
+                $data['name'] = sprintf(
+                    '<a href="%s.html">%s</a>',
+                    $node->name(),
+                    $node->name(),
+                );
+            }
+        }
+
+        $templateName = $this->templatePath . ($this->hasBranchCoverage ? 'directory_item_branch.html' : 'directory_item.html');
+
+        return $this->renderItemTemplate(
+            new Template($templateName, '{{', '}}'),
+            $data,
+        );
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/branches.html.dist

@@ -0,0 +1,9 @@
+<hr/>
+<h4>Branches</h4>
+<p>
+    Below are the source code lines that represent each code branch as identified by Xdebug. Please note a branch is not
+    necessarily coterminous with a line, a line may contain multiple branches and therefore show up more than once.
+    Please also be aware that some branches may be implicit rather than explicit, e.g. an <code>if</code> statement
+    <i>always</i> has an <code>else</code> as part of its logical flow even if you didn't write one.
+</p>
+{{branches}}

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/coverage_bar.html.dist

@@ -0,0 +1,5 @@
+       <div class="progress">
+         <div class="progress-bar bg-{{level}}" role="progressbar" aria-valuenow="{{percent}}" aria-valuemin="0" aria-valuemax="100" style="width: {{percent}}%">
+           <span class="visually-hidden">{{percent}}% covered ({{level}})</span>
+         </div>
+       </div>

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/coverage_bar_branch.html.dist

@@ -0,0 +1,5 @@
+       <div class="progress">
+         <div class="progress-bar bg-{{level}}" role="progressbar" aria-valuenow="{{percent}}" aria-valuemin="0" aria-valuemax="100" style="width: {{percent}}%">
+           <span class="visually-hidden">{{percent}}% covered ({{level}})</span>
+         </div>
+       </div>

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/css/octicons.css

@@ -0,0 +1,5 @@
+.octicon {
+  display: inline-block;
+  vertical-align: text-top;
+  fill: currentColor;
+}

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/css/style.css

@@ -0,0 +1,202 @@
+:root {
+ --phpunit-breadcrumbs: var(--bs-gray-200);
+ --phpunit-success-bar: #28a745;
+ --phpunit-success-high: {{success-high}};
+ --phpunit-success-medium: {{success-medium}};
+ --phpunit-success-low: {{success-low}};
+ --phpunit-warning: {{warning}};
+ --phpunit-warning-bar: #ffc107;
+ --phpunit-danger: {{danger}};
+ --phpunit-danger-bar: #dc3545;
+}
+
+body {
+ font-family: sans-serif;
+ font-size: 1em;
+ font-kerning: normal;
+ font-variant-ligatures: common-ligatures;
+ text-rendering: optimizeLegibility;
+ padding-top: 10px;
+}
+
+nav .breadcrumb {
+  border-radius: var(--bs-border-radius);
+  background-color: var(--phpunit-breadcrumbs);
+  padding: .75rem 1rem;
+}
+
+.popover {
+ max-width: none;
+}
+
+.popover-body {
+ max-height: 90vh;
+ overflow-y: auto;
+}
+
+.octicon {
+ margin-right:.25em;
+ vertical-align: baseline;
+ width: 0.75em;
+}
+
+.table-bordered>thead>tr>td {
+ border-bottom-width: 1px;
+}
+
+.table tbody>tr>td, .table thead>tr>td {
+ padding-top: 3px;
+ padding-bottom: 3px;
+}
+
+.table-condensed tbody>tr>td {
+ padding-top: 0;
+ padding-bottom: 0;
+}
+
+.table .progress {
+ margin-bottom: inherit;
+}
+
+.table-borderless th, .table-borderless td {
+ border: 0 !important;
+}
+
+.table tbody tr.covered-by-large-tests, .table tbody tr.covered-by-large-tests td, li.covered-by-large-tests, tr.success, tr.success td, td.success, li.success, span.success {
+ background-color: var(--phpunit-success-low);
+}
+
+.table tbody tr.covered-by-medium-tests, .table tbody tr.covered-by-medium-tests td, li.covered-by-medium-tests {
+ background-color: var(--phpunit-success-medium);
+}
+
+.table tbody tr.covered-by-small-tests, .table tbody tr.covered-by-small-tests td, li.covered-by-small-tests {
+ background-color: var(--phpunit-success-high);
+}
+
+.table tbody tr.warning, .table tbody tr.warning td, .table tbody td.warning, li.warning, span.warning {
+ background-color: var(--phpunit-warning);
+}
+
+.table tbody tr.danger, .table tbody tr.danger td, .table tbody td.danger, li.danger, span.danger {
+ background-color: var(--phpunit-danger);
+}
+
+.table tbody td.info {
+ background-color: rgb(from var(--bs-info) r g b / 0.25);
+}
+
+td.big {
+ vertical-align: middle;
+ width: 117px;
+}
+
+td.small {
+}
+
+td.codeLine {
+ font-family: "Source Code Pro", var(--bs-font-monospace);
+ white-space: pre-wrap;
+}
+
+td span.comment {
+ color: var(--bs-secondary-color);
+}
+
+td span.default {
+ color: var(--bs-body-color);
+}
+
+td span.html {
+ color: var(--bs-secondary-color);
+}
+
+td span.keyword {
+ color: var(--bs-body-color);
+ font-weight: bold;
+}
+
+pre span.string {
+ color: var(--bs-body-color);
+}
+
+span.success, span.warning, span.danger {
+ margin-right: 2px;
+ padding-left: 10px;
+ padding-right: 10px;
+ text-align: center;
+}
+
+#toplink {
+ position: fixed;
+ left: 5px;
+ bottom: 5px;
+ outline: 0;
+}
+
+svg text {
+ font-family: var(--bs-font-sans-serif);
+ font-size: 11px;
+ color: var(--bs-gray);
+ fill: var(--bs-gray);
+}
+
+.scrollbox {
+ height:245px;
+ overflow-x:scroll;
+ overflow-y:scroll;
+}
+
+table + .structure-heading {
+ border-top: 1px solid var(--bs-gray-200);
+ padding-top: 0.5em;
+}
+
+table#code td:first-of-type {
+  padding-left: .75em;
+  padding-right: .75em;
+}
+
+table#code td:first-of-type a {
+  text-decoration: none;
+}
+
+.legend {
+ font-weight: bold;
+ margin-right: 2px;
+ padding-left: 10px;
+ padding-right: 10px;
+ text-align: center;
+}
+
+.covered-by-small-tests {
+ background-color: var(--phpunit-success-high);
+}
+
+.covered-by-medium-tests {
+ background-color: var(--phpunit-success-medium);
+}
+
+.covered-by-large-tests {
+ background-color: var(--phpunit-success-low);
+}
+
+.not-covered {
+ background-color: var(--phpunit-danger);
+}
+
+.not-coverable {
+ background-color: var(--phpunit-warning);
+}
+
+.progress-bar.bg-success {
+ background-color: var(--phpunit-success-bar) !important;
+}
+
+.progress-bar.bg-warning {
+ background-color: var(--phpunit-warning-bar) !important;
+}
+
+.progress-bar.bg-danger {
+ background-color: var(--phpunit-danger-bar) !important;
+}

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/dashboard.html.dist

@@ -0,0 +1,281 @@
+<!DOCTYPE html>
+<html lang="en">
+ <head>
+  <meta charset="UTF-8">
+  <title>Dashboard for {{full_path}}</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link href="{{path_to_root}}_css/bootstrap.min.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/nv.d3.min.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/style.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/custom.css" rel="stylesheet" type="text/css">
+ </head>
+ <body>
+  <header>
+   <div class="container-fluid">
+    <div class="row">
+     <div class="col-md-12">
+      <nav aria-label="breadcrumb">
+       <ol class="breadcrumb">
+{{breadcrumbs}}
+       </ol>
+      </nav>
+     </div>
+    </div>
+   </div>
+  </header>
+  <div class="container-fluid">
+   <div class="row">
+    <div class="col-md-12">
+     <h2>Classes</h2>
+    </div>
+   </div>
+   <div class="row">
+    <div class="col-md-6">
+     <h3>Coverage Distribution</h3>
+     <div id="classCoverageDistribution" style="height: 300px;">
+       <svg></svg>
+     </div>
+    </div>
+    <div class="col-md-6">
+     <h3>Complexity</h3>
+     <div id="classComplexity" style="height: 300px;">
+       <svg></svg>
+     </div>
+    </div>
+   </div>
+   <div class="row">
+    <div class="col-md-6">
+     <h3>Insufficient Coverage</h3>
+     <div class="scrollbox">
+      <table class="table">
+       <thead>
+        <tr>
+         <th>Class</th>
+         <th class="text-right">Coverage</th>
+        </tr>
+       </thead>
+       <tbody>
+{{insufficient_coverage_classes}}
+       </tbody>
+      </table>
+     </div>
+    </div>
+    <div class="col-md-6">
+     <h3>Project Risks</h3>
+     <div class="scrollbox">
+      <table class="table">
+       <thead>
+        <tr>
+         <th>Class</th>
+         <th class="text-right"><abbr title="Change Risk Anti-Patterns (CRAP) Index">CRAP</abbr></th>
+        </tr>
+       </thead>
+       <tbody>
+{{project_risks_classes}}
+       </tbody>
+      </table>
+     </div>
+    </div>
+   </div>
+   <div class="row">
+    <div class="col-md-12">
+     <h2>Methods</h2>
+    </div>
+   </div>
+   <div class="row">
+    <div class="col-md-6">
+     <h3>Coverage Distribution</h3>
+     <div id="methodCoverageDistribution" style="height: 300px;">
+       <svg></svg>
+     </div>
+    </div>
+    <div class="col-md-6">
+     <h3>Complexity</h3>
+     <div id="methodComplexity" style="height: 300px;">
+       <svg></svg>
+     </div>
+    </div>
+   </div>
+   <div class="row">
+    <div class="col-md-6">
+     <h3>Insufficient Coverage</h3>
+     <div class="scrollbox">
+      <table class="table">
+       <thead>
+        <tr>
+         <th>Method</th>
+         <th class="text-right">Coverage</th>
+        </tr>
+       </thead>
+       <tbody>
+{{insufficient_coverage_methods}}
+       </tbody>
+      </table>
+     </div>
+    </div>
+    <div class="col-md-6">
+     <h3>Project Risks</h3>
+     <div class="scrollbox">
+      <table class="table">
+       <thead>
+        <tr>
+         <th>Method</th>
+         <th class="text-right"><abbr title="Change Risk Anti-Patterns (CRAP) Index">CRAP</abbr></th>
+        </tr>
+       </thead>
+       <tbody>
+{{project_risks_methods}}
+       </tbody>
+      </table>
+     </div>
+    </div>
+   </div>
+   <footer>
+    <hr/>
+    <p>
+     <small>Generated by <a href="https://github.com/sebastianbergmann/php-code-coverage" target="_top">php-code-coverage {{version}}</a> using {{runtime}}{{generator}} at {{date}}.</small>
+    </p>
+   </footer>
+  </div>
+  <script src="{{path_to_root}}_js/jquery.min.js?v={{version}}" type="text/javascript"></script>
+  <script src="{{path_to_root}}_js/d3.min.js?v={{version}}" type="text/javascript"></script>
+  <script src="{{path_to_root}}_js/nv.d3.min.js?v={{version}}" type="text/javascript"></script>
+  <script type="text/javascript">
+$(document).ready(function() {
+  nv.addGraph(function() {
+    var chart = nv.models.multiBarChart();
+    chart.tooltips(false)
+      .showControls(false)
+      .showLegend(false)
+      .reduceXTicks(false)
+      .staggerLabels(true)
+      .yAxis.tickFormat(d3.format('d'));
+
+    d3.select('#classCoverageDistribution svg')
+      .datum(getCoverageDistributionData({{class_coverage_distribution}}, "Class Coverage"))
+      .transition().duration(500).call(chart);
+
+    nv.utils.windowResize(chart.update);
+
+    return chart;
+  });
+
+  nv.addGraph(function() {
+    var chart = nv.models.multiBarChart();
+    chart.tooltips(false)
+      .showControls(false)
+      .showLegend(false)
+      .reduceXTicks(false)
+      .staggerLabels(true)
+      .yAxis.tickFormat(d3.format('d'));
+
+    d3.select('#methodCoverageDistribution svg')
+      .datum(getCoverageDistributionData({{method_coverage_distribution}}, "Method Coverage"))
+      .transition().duration(500).call(chart);
+
+    nv.utils.windowResize(chart.update);
+
+    return chart;
+  });
+
+  function getCoverageDistributionData(data, label) {
+    var labels = [
+      '0%',
+      '0-10%',
+      '10-20%',
+      '20-30%',
+      '30-40%',
+      '40-50%',
+      '50-60%',
+      '60-70%',
+      '70-80%',
+      '80-90%',
+      '90-100%',
+      '100%'
+    ];
+    var values = [];
+    $.each(labels, function(key) {
+      values.push({x: labels[key], y: data[key]});
+    });
+
+    return [
+      {
+        key: label,
+        values: values,
+        color: "#4572A7"
+      }
+    ];
+  }
+  nv.addGraph(function() {
+    var chart = nv.models.scatterChart()
+      .showDistX(true)
+      .showDistY(true)
+      .showLegend(false)
+      .forceX([0, 100]);
+    chart.tooltipContent(function(graph) {
+      return '<p>' + graph.point.class + '</p>';
+    });
+
+    chart.xAxis.axisLabel('Code Coverage (in percent)');
+    chart.yAxis.axisLabel('Cyclomatic Complexity');
+
+    d3.select('#classComplexity svg')
+      .datum(getComplexityData({{complexity_class}}, 'Class Complexity'))
+      .transition()
+      .duration(500)
+      .call(chart);
+
+    nv.utils.windowResize(chart.update);
+
+    return chart;
+  });
+
+  nv.addGraph(function() {
+    var chart = nv.models.scatterChart()
+      .showDistX(true)
+      .showDistY(true)
+      .showLegend(false)
+      .forceX([0, 100]);
+    chart.tooltipContent(function(graph) {
+      return '<p>' + graph.point.class + '</p>';
+    });
+
+    chart.xAxis.axisLabel('Code Coverage (in percent)');
+    chart.yAxis.axisLabel('Method Complexity');
+
+    d3.select('#methodComplexity svg')
+      .datum(getComplexityData({{complexity_method}}, 'Method Complexity'))
+      .transition()
+      .duration(500)
+      .call(chart);
+
+    nv.utils.windowResize(chart.update);
+
+    return chart;
+  });
+
+  function getComplexityData(data, label) {
+    var values = [];
+    $.each(data, function(key) {
+      var value = Math.round(data[key][0]*100) / 100;
+      values.push({
+        x: value,
+        y: data[key][1],
+        class: data[key][2],
+        size: 0.05,
+        shape: 'diamond'
+      });
+    });
+
+    return [
+      {
+        key: label,
+        values: values,
+        color: "#4572A7"
+      }
+    ];
+  }
+});
+  </script>
+ </body>
+</html>

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/dashboard_branch.html.dist

@@ -0,0 +1,281 @@
+<!DOCTYPE html>
+<html lang="en">
+ <head>
+  <meta charset="UTF-8">
+  <title>Dashboard for {{full_path}}</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link href="{{path_to_root}}_css/bootstrap.min.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/nv.d3.min.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/style.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/custom.css" rel="stylesheet" type="text/css">
+ </head>
+ <body>
+  <header>
+   <div class="container-fluid">
+    <div class="row">
+     <div class="col-md-12">
+      <nav aria-label="breadcrumb">
+       <ol class="breadcrumb">
+{{breadcrumbs}}
+       </ol>
+      </nav>
+     </div>
+    </div>
+   </div>
+  </header>
+  <div class="container-fluid">
+   <div class="row">
+    <div class="col-md-12">
+     <h2>Classes</h2>
+    </div>
+   </div>
+   <div class="row">
+    <div class="col-md-6">
+     <h3>Coverage Distribution</h3>
+     <div id="classCoverageDistribution" style="height: 300px;">
+       <svg></svg>
+     </div>
+    </div>
+    <div class="col-md-6">
+     <h3>Complexity</h3>
+     <div id="classComplexity" style="height: 300px;">
+       <svg></svg>
+     </div>
+    </div>
+   </div>
+   <div class="row">
+    <div class="col-md-6">
+     <h3>Insufficient Coverage</h3>
+     <div class="scrollbox">
+      <table class="table">
+       <thead>
+        <tr>
+         <th>Class</th>
+         <th class="text-right">Coverage</th>
+        </tr>
+       </thead>
+       <tbody>
+{{insufficient_coverage_classes}}
+       </tbody>
+      </table>
+     </div>
+    </div>
+    <div class="col-md-6">
+     <h3>Project Risks</h3>
+     <div class="scrollbox">
+      <table class="table">
+       <thead>
+        <tr>
+         <th>Class</th>
+         <th class="text-right"><abbr title="Change Risk Anti-Patterns (CRAP) Index">CRAP</abbr></th>
+        </tr>
+       </thead>
+       <tbody>
+{{project_risks_classes}}
+       </tbody>
+      </table>
+     </div>
+    </div>
+   </div>
+   <div class="row">
+    <div class="col-md-12">
+     <h2>Methods</h2>
+    </div>
+   </div>
+   <div class="row">
+    <div class="col-md-6">
+     <h3>Coverage Distribution</h3>
+     <div id="methodCoverageDistribution" style="height: 300px;">
+       <svg></svg>
+     </div>
+    </div>
+    <div class="col-md-6">
+     <h3>Complexity</h3>
+     <div id="methodComplexity" style="height: 300px;">
+       <svg></svg>
+     </div>
+    </div>
+   </div>
+   <div class="row">
+    <div class="col-md-6">
+     <h3>Insufficient Coverage</h3>
+     <div class="scrollbox">
+      <table class="table">
+       <thead>
+        <tr>
+         <th>Method</th>
+         <th class="text-right">Coverage</th>
+        </tr>
+       </thead>
+       <tbody>
+{{insufficient_coverage_methods}}
+       </tbody>
+      </table>
+     </div>
+    </div>
+    <div class="col-md-6">
+     <h3>Project Risks</h3>
+     <div class="scrollbox">
+      <table class="table">
+       <thead>
+        <tr>
+         <th>Method</th>
+         <th class="text-right"><abbr title="Change Risk Anti-Patterns (CRAP) Index">CRAP</abbr></th>
+        </tr>
+       </thead>
+       <tbody>
+{{project_risks_methods}}
+       </tbody>
+      </table>
+     </div>
+    </div>
+   </div>
+   <footer>
+    <hr/>
+    <p>
+     <small>Generated by <a href="https://github.com/sebastianbergmann/php-code-coverage" target="_top">php-code-coverage {{version}}</a> using {{runtime}}{{generator}} at {{date}}.</small>
+    </p>
+   </footer>
+  </div>
+  <script src="{{path_to_root}}_js/jquery.min.js?v={{version}}" type="text/javascript"></script>
+  <script src="{{path_to_root}}_js/d3.min.js?v={{version}}" type="text/javascript"></script>
+  <script src="{{path_to_root}}_js/nv.d3.min.js?v={{version}}" type="text/javascript"></script>
+  <script type="text/javascript">
+$(document).ready(function() {
+  nv.addGraph(function() {
+    var chart = nv.models.multiBarChart();
+    chart.tooltips(false)
+      .showControls(false)
+      .showLegend(false)
+      .reduceXTicks(false)
+      .staggerLabels(true)
+      .yAxis.tickFormat(d3.format('d'));
+
+    d3.select('#classCoverageDistribution svg')
+      .datum(getCoverageDistributionData({{class_coverage_distribution}}, "Class Coverage"))
+      .transition().duration(500).call(chart);
+
+    nv.utils.windowResize(chart.update);
+
+    return chart;
+  });
+
+  nv.addGraph(function() {
+    var chart = nv.models.multiBarChart();
+    chart.tooltips(false)
+      .showControls(false)
+      .showLegend(false)
+      .reduceXTicks(false)
+      .staggerLabels(true)
+      .yAxis.tickFormat(d3.format('d'));
+
+    d3.select('#methodCoverageDistribution svg')
+      .datum(getCoverageDistributionData({{method_coverage_distribution}}, "Method Coverage"))
+      .transition().duration(500).call(chart);
+
+    nv.utils.windowResize(chart.update);
+
+    return chart;
+  });
+
+  function getCoverageDistributionData(data, label) {
+    var labels = [
+      '0%',
+      '0-10%',
+      '10-20%',
+      '20-30%',
+      '30-40%',
+      '40-50%',
+      '50-60%',
+      '60-70%',
+      '70-80%',
+      '80-90%',
+      '90-100%',
+      '100%'
+    ];
+    var values = [];
+    $.each(labels, function(key) {
+      values.push({x: labels[key], y: data[key]});
+    });
+
+    return [
+      {
+        key: label,
+        values: values,
+        color: "#4572A7"
+      }
+    ];
+  }
+  nv.addGraph(function() {
+    var chart = nv.models.scatterChart()
+      .showDistX(true)
+      .showDistY(true)
+      .showLegend(false)
+      .forceX([0, 100]);
+    chart.tooltipContent(function(graph) {
+      return '<p>' + graph.point.class + '</p>';
+    });
+
+    chart.xAxis.axisLabel('Code Coverage (in percent)');
+    chart.yAxis.axisLabel('Cyclomatic Complexity');
+
+    d3.select('#classComplexity svg')
+      .datum(getComplexityData({{complexity_class}}, 'Class Complexity'))
+      .transition()
+      .duration(500)
+      .call(chart);
+
+    nv.utils.windowResize(chart.update);
+
+    return chart;
+  });
+
+  nv.addGraph(function() {
+    var chart = nv.models.scatterChart()
+      .showDistX(true)
+      .showDistY(true)
+      .showLegend(false)
+      .forceX([0, 100]);
+    chart.tooltipContent(function(graph) {
+      return '<p>' + graph.point.class + '</p>';
+    });
+
+    chart.xAxis.axisLabel('Code Coverage (in percent)');
+    chart.yAxis.axisLabel('Method Complexity');
+
+    d3.select('#methodComplexity svg')
+      .datum(getComplexityData({{complexity_method}}, 'Method Complexity'))
+      .transition()
+      .duration(500)
+      .call(chart);
+
+    nv.utils.windowResize(chart.update);
+
+    return chart;
+  });
+
+  function getComplexityData(data, label) {
+    var values = [];
+    $.each(data, function(key) {
+      var value = Math.round(data[key][0]*100) / 100;
+      values.push({
+        x: value,
+        y: data[key][1],
+        class: data[key][2],
+        size: 0.05,
+        shape: 'diamond'
+      });
+    });
+
+    return [
+      {
+        key: label,
+        values: values,
+        color: "#4572A7"
+      }
+    ];
+  }
+});
+  </script>
+ </body>
+</html>

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/directory.html.dist

@@ -0,0 +1,60 @@
+<!DOCTYPE html>
+<html lang="en">
+ <head>
+  <meta charset="UTF-8">
+  <title>Code Coverage for {{full_path}}</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link href="{{path_to_root}}_css/bootstrap.min.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/octicons.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/style.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/custom.css" rel="stylesheet" type="text/css">
+ </head>
+ <body>
+  <header>
+   <div class="container-fluid">
+    <div class="row">
+     <div class="col-md-12">
+      <nav aria-label="breadcrumb">
+       <ol class="breadcrumb">
+{{breadcrumbs}}
+       </ol>
+      </nav>
+     </div>
+    </div>
+   </div>
+  </header>
+  <div class="container-fluid">
+   <div class="table-responsive">
+    <table class="table table-bordered">
+     <thead>
+      <tr>
+       <td>&nbsp;</td>
+       <td colspan="9"><div align="center"><strong>Code Coverage</strong></div></td>
+      </tr>
+      <tr>
+       <td>&nbsp;</td>
+       <td colspan="3"><div align="center"><strong>Lines</strong></div></td>
+       <td colspan="3"><div align="center"><strong>Functions and Methods</strong></div></td>
+       <td colspan="3"><div align="center"><strong>Classes and Traits</strong></div></td>
+      </tr>
+     </thead>
+     <tbody>
+{{items}}
+     </tbody>
+    </table>
+   </div>
+   <footer>
+    <hr/>
+    <h4>Legend</h4>
+    <p>
+     <span class="danger"><strong>Low</strong>: 0% to {{low_upper_bound}}%</span>
+     <span class="warning"><strong>Medium</strong>: {{low_upper_bound}}% to {{high_lower_bound}}%</span>
+     <span class="success"><strong>High</strong>: {{high_lower_bound}}% to 100%</span>
+    </p>
+    <p>
+     <small>Generated by <a href="https://github.com/sebastianbergmann/php-code-coverage" target="_top">php-code-coverage {{version}}</a> using {{runtime}}{{generator}} at {{date}}.</small>
+    </p>
+   </footer>
+  </div>
+ </body>
+</html>

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/directory_branch.html.dist

@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<html lang="en">
+ <head>
+  <meta charset="UTF-8">
+  <title>Code Coverage for {{full_path}}</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link href="{{path_to_root}}_css/bootstrap.min.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/octicons.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/style.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/custom.css" rel="stylesheet" type="text/css">
+ </head>
+ <body>
+  <header>
+   <div class="container-fluid">
+    <div class="row">
+     <div class="col-md-12">
+      <nav aria-label="breadcrumb">
+       <ol class="breadcrumb">
+{{breadcrumbs}}
+       </ol>
+      </nav>
+     </div>
+    </div>
+   </div>
+  </header>
+  <div class="container-fluid">
+   <div class="table-responsive">
+    <table class="table table-bordered">
+     <thead>
+      <tr>
+       <td>&nbsp;</td>
+       <td colspan="15"><div align="center"><strong>Code Coverage</strong></div></td>
+      </tr>
+      <tr>
+       <td>&nbsp;</td>
+       <td colspan="3"><div align="center"><strong>Lines</strong></div></td>
+       <td colspan="3"><div align="center"><strong>Branches</strong></div></td>
+       <td colspan="3"><div align="center"><strong>Paths</strong></div></td>
+       <td colspan="3"><div align="center"><strong>Functions and Methods</strong></div></td>
+       <td colspan="3"><div align="center"><strong>Classes and Traits</strong></div></td>
+      </tr>
+     </thead>
+     <tbody>
+{{items}}
+     </tbody>
+    </table>
+   </div>
+   <footer>
+    <hr/>
+    <h4>Legend</h4>
+    <p>
+     <span class="danger"><strong>Low</strong>: 0% to {{low_upper_bound}}%</span>
+     <span class="warning"><strong>Medium</strong>: {{low_upper_bound}}% to {{high_lower_bound}}%</span>
+     <span class="success"><strong>High</strong>: {{high_lower_bound}}% to 100%</span>
+    </p>
+    <p>
+     <small>Generated by <a href="https://github.com/sebastianbergmann/php-code-coverage" target="_top">php-code-coverage {{version}}</a> using {{runtime}}{{generator}} at {{date}}.</small>
+    </p>
+   </footer>
+  </div>
+ </body>
+</html>

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/directory_item.html.dist

@@ -0,0 +1,13 @@
+      <tr>
+       <td class="{{lines_level}}">{{icon}}{{name}}</td>
+       <td class="{{lines_level}} big">{{lines_bar}}</td>
+       <td class="{{lines_level}} small"><div align="right">{{lines_executed_percent}}</div></td>
+       <td class="{{lines_level}} small"><div align="right">{{lines_number}}</div></td>
+       <td class="{{methods_level}} big">{{methods_bar}}</td>
+       <td class="{{methods_level}} small"><div align="right">{{methods_tested_percent}}</div></td>
+       <td class="{{methods_level}} small"><div align="right">{{methods_number}}</div></td>
+       <td class="{{classes_level}} big">{{classes_bar}}</td>
+       <td class="{{classes_level}} small"><div align="right">{{classes_tested_percent}}</div></td>
+       <td class="{{classes_level}} small"><div align="right">{{classes_number}}</div></td>
+      </tr>
+

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/directory_item_branch.html.dist

@@ -0,0 +1,19 @@
+      <tr>
+       <td class="{{lines_level}}">{{icon}}{{name}}</td>
+       <td class="{{lines_level}} big">{{lines_bar}}</td>
+       <td class="{{lines_level}} small"><div align="right">{{lines_executed_percent}}</div></td>
+       <td class="{{lines_level}} small"><div align="right">{{lines_number}}</div></td>
+       <td class="{{branches_level}} big">{{branches_bar}}</td>
+       <td class="{{branches_level}} small"><div align="right">{{branches_executed_percent}}</div></td>
+       <td class="{{branches_level}} small"><div align="right">{{branches_number}}</div></td>
+       <td class="{{paths_level}} big">{{paths_bar}}</td>
+       <td class="{{paths_level}} small"><div align="right">{{paths_executed_percent}}</div></td>
+       <td class="{{paths_level}} small"><div align="right">{{paths_number}}</div></td>
+       <td class="{{methods_level}} big">{{methods_bar}}</td>
+       <td class="{{methods_level}} small"><div align="right">{{methods_tested_percent}}</div></td>
+       <td class="{{methods_level}} small"><div align="right">{{methods_number}}</div></td>
+       <td class="{{classes_level}} big">{{classes_bar}}</td>
+       <td class="{{classes_level}} small"><div align="right">{{classes_tested_percent}}</div></td>
+       <td class="{{classes_level}} small"><div align="right">{{classes_number}}</div></td>
+      </tr>
+

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/file.html.dist

@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html lang="en">
+ <head>
+  <meta charset="UTF-8">
+  <title>Code Coverage for {{full_path}}</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link href="{{path_to_root}}_css/bootstrap.min.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/octicons.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/style.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/custom.css" rel="stylesheet" type="text/css">
+ </head>
+ <body>
+  <header>
+   <div class="container-fluid">
+    <div class="row">
+     <div class="col-md-12">
+      <nav aria-label="breadcrumb">
+       <ol class="breadcrumb">
+{{breadcrumbs}}
+       </ol>
+      </nav>
+     </div>
+    </div>
+   </div>
+  </header>
+  <div class="container-fluid">
+   <div class="table-responsive">
+    <table class="table table-bordered">
+     <thead>
+      <tr>
+       <td>&nbsp;</td>
+       <td colspan="10"><div align="center"><strong>Code Coverage</strong></div></td>
+      </tr>
+      <tr>
+       <td>&nbsp;</td>
+       <td colspan="3"><div align="center"><strong>Lines</strong></div></td>
+       <td colspan="4"><div align="center"><strong>Functions and Methods</strong></div></td>
+       <td colspan="3"><div align="center"><strong>Classes and Traits</strong></div></td>
+      </tr>
+     </thead>
+     <tbody>
+{{items}}
+     </tbody>
+    </table>
+   </div>
+{{lines}}
+{{structure}}
+   <footer>
+    <hr/>
+    <h4>Legend</h4>
+    {{legend}}
+    <p>
+     <small>Generated by <a href="https://github.com/sebastianbergmann/php-code-coverage" target="_top">php-code-coverage {{version}}</a> using {{runtime}}{{generator}} at {{date}}.</small>
+    </p>
+    <a title="Back to the top" id="toplink" href="#">
+        <svg xmlns="http://www.w3.org/2000/svg" width="12" height="16" viewBox="0 0 12 16"><path fill-rule="evenodd" d="M12 11L6 5l-6 6h12z"/></svg>
+    </a>
+   </footer>
+  </div>
+  <script src="{{path_to_root}}_js/jquery.min.js?v={{version}}" type="text/javascript"></script>
+  <script src="{{path_to_root}}_js/bootstrap.bundle.min.js?v={{version}}" type="text/javascript"></script>
+  <script src="{{path_to_root}}_js/file.js?v={{version}}" type="text/javascript"></script>
+ </body>
+</html>

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/file_branch.html.dist

@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html lang="en">
+ <head>
+  <meta charset="UTF-8">
+  <title>Code Coverage for {{full_path}}</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link href="{{path_to_root}}_css/bootstrap.min.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/octicons.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/style.css?v={{version}}" rel="stylesheet" type="text/css">
+  <link href="{{path_to_root}}_css/custom.css" rel="stylesheet" type="text/css">
+ </head>
+ <body>
+  <header>
+   <div class="container-fluid">
+    <div class="row">
+     <div class="col-md-12">
+      <nav aria-label="breadcrumb">
+       <ol class="breadcrumb">
+{{breadcrumbs}}
+       </ol>
+      </nav>
+     </div>
+    </div>
+   </div>
+  </header>
+  <div class="container-fluid">
+   <div class="table-responsive">
+    <table class="table table-bordered">
+     <thead>
+      <tr>
+       <td>&nbsp;</td>
+       <td colspan="16"><div align="center"><strong>Code Coverage</strong></div></td>
+      </tr>
+      <tr>
+       <td>&nbsp;</td>
+       <td colspan="3"><div align="center"><strong>Lines</strong></div></td>
+       <td colspan="3"><div align="center"><strong>Branches</strong></div></td>
+       <td colspan="3"><div align="center"><strong>Paths</strong></div></td>
+       <td colspan="4"><div align="center"><strong>Functions and Methods</strong></div></td>
+       <td colspan="3"><div align="center"><strong>Classes and Traits</strong></div></td>
+      </tr>
+     </thead>
+     <tbody>
+{{items}}
+     </tbody>
+    </table>
+   </div>
+{{lines}}
+{{structure}}
+   <footer>
+    <hr/>
+    <h4>Legend</h4>
+    {{legend}}
+    <p>
+     <small>Generated by <a href="https://github.com/sebastianbergmann/php-code-coverage" target="_top">php-code-coverage {{version}}</a> using {{runtime}}{{generator}} at {{date}}.</small>
+    </p>
+    <a title="Back to the top" id="toplink" href="#">
+        <svg xmlns="http://www.w3.org/2000/svg" width="12" height="16" viewBox="0 0 12 16"><path fill-rule="evenodd" d="M12 11L6 5l-6 6h12z"/></svg>
+    </a>
+   </footer>
+  </div>
+  <script src="{{path_to_root}}_js/jquery.min.js?v={{version}}" type="text/javascript"></script>
+  <script src="{{path_to_root}}_js/bootstrap.bundle.min.js?v={{version}}" type="text/javascript"></script>
+  <script src="{{path_to_root}}_js/file.js?v={{version}}" type="text/javascript"></script>
+ </body>
+</html>

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/file_item.html.dist

@@ -0,0 +1,14 @@
+      <tr>
+       <td class="{{lines_level}}">{{name}}</td>
+       <td class="{{lines_level}} big">{{lines_bar}}</td>
+       <td class="{{lines_level}} small"><div align="right">{{lines_executed_percent}}</div></td>
+       <td class="{{lines_level}} small"><div align="right">{{lines_number}}</div></td>
+       <td class="{{methods_level}} big">{{methods_bar}}</td>
+       <td class="{{methods_level}} small"><div align="right">{{methods_tested_percent}}</div></td>
+       <td class="{{methods_level}} small"><div align="right">{{methods_number}}</div></td>
+       <td class="{{methods_level}} small">{{crap}}</td>
+       <td class="{{classes_level}} big">{{classes_bar}}</td>
+       <td class="{{classes_level}} small"><div align="right">{{classes_tested_percent}}</div></td>
+       <td class="{{classes_level}} small"><div align="right">{{classes_number}}</div></td>
+      </tr>
+

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/file_item_branch.html.dist

@@ -0,0 +1,20 @@
+      <tr>
+       <td class="{{lines_level}}">{{name}}</td>
+       <td class="{{lines_level}} big">{{lines_bar}}</td>
+       <td class="{{lines_level}} small"><div align="right">{{lines_executed_percent}}</div></td>
+       <td class="{{lines_level}} small"><div align="right">{{lines_number}}</div></td>
+       <td class="{{branches_level}} big">{{branches_bar}}</td>
+       <td class="{{branches_level}} small"><div align="right">{{branches_executed_percent}}</div></td>
+       <td class="{{branches_level}} small"><div align="right">{{branches_number}}</div></td>
+       <td class="{{paths_level}} big">{{paths_bar}}</td>
+       <td class="{{paths_level}} small"><div align="right">{{paths_executed_percent}}</div></td>
+       <td class="{{paths_level}} small"><div align="right">{{paths_number}}</div></td>
+       <td class="{{methods_level}} big">{{methods_bar}}</td>
+       <td class="{{methods_level}} small"><div align="right">{{methods_tested_percent}}</div></td>
+       <td class="{{methods_level}} small"><div align="right">{{methods_number}}</div></td>
+       <td class="{{methods_level}} small">{{crap}}</td>
+       <td class="{{classes_level}} big">{{classes_bar}}</td>
+       <td class="{{classes_level}} small"><div align="right">{{classes_tested_percent}}</div></td>
+       <td class="{{classes_level}} small"><div align="right">{{classes_number}}</div></td>
+      </tr>
+

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/icons/file-code.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="12" height="16" viewBox="0 0 12 16"><path fill-rule="evenodd" d="M8.5 1H1c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h10c.55 0 1-.45 1-1V4.5L8.5 1zM11 14H1V2h7l3 3v9zM5 6.98L3.5 8.5 5 10l-.5 1L2 8.5 4.5 6l.5.98zM7.5 6L10 8.5 7.5 11l-.5-.98L8.5 8.5 7 7l.5-1z"/></svg>

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/icons/file-directory.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="14" height="16" viewBox="0 0 14 16"><path fill-rule="evenodd" d="M13 4H7V3c0-.66-.31-1-1-1H1c-.55 0-1 .45-1 1v10c0 .55.45 1 1 1h12c.55 0 1-.45 1-1V5c0-.55-.45-1-1-1zM6 4H1V3h5v1z"/></svg>

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/js/file.js

@@ -0,0 +1,53 @@
+$(function () {
+  var $window = $(window)
+    , $top_link = $('#toplink')
+    , $body = $('body, html')
+    , offset = $('#code').offset().top;
+
+  $top_link.hide().click(function (event) {
+    event.preventDefault();
+    $body.animate({scrollTop: 0}, 800);
+  });
+
+  $window.scroll(function () {
+    if ($window.scrollTop() > offset) {
+      $top_link.fadeIn();
+    } else {
+      $top_link.fadeOut();
+    }
+  });
+
+  var $popovers = $('.popin > :first-child');
+  $('.popin').on({
+    'click.popover': function (event) {
+      event.stopPropagation();
+
+      var $container = $(this).children().first();
+
+      //Close all other popovers:
+      $popovers.each(function () {
+        var $current = $(this);
+        if (!$current.is($container)) {
+          $current.popover('hide');
+        }
+      });
+
+      // Toggle this popover:
+      $container.popover('toggle');
+    },
+  });
+
+  //Hide all popovers on outside click:
+  $(document).click(function (event) {
+    if ($(event.target).closest($('.popover')).length === 0) {
+      $popovers.popover('hide');
+    }
+  });
+
+  //Hide all popovers on escape:
+  $(document).keyup(function (event) {
+    if (event.key === 'Escape') {
+      $popovers.popover('hide');
+    }
+  });
+});

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/line.html.dist

@@ -0,0 +1 @@
+    <tr class="{{class}} d-flex"><td {{popover}} class="col-1 text-end"><a id="{{lineNumber}}" href="#{{lineNumber}}">{{lineNumber}}</a></td><td class="col-11 codeLine">{{lineContent}}</td></tr>

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/lines.html.dist

@@ -0,0 +1,5 @@
+<table id="code" class="table table-borderless table-condensed">
+<tbody>
+{{lines}}
+</tbody>
+</table>

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/method_item.html.dist

@@ -0,0 +1,12 @@
+      <tr>
+       <td class="{{lines_level}}">{{name}}</td>
+       <td class="{{lines_level}} big">{{lines_bar}}</td>
+       <td class="{{lines_level}} small"><div align="right">{{lines_executed_percent}}</div></td>
+       <td class="{{lines_level}} small"><div align="right">{{lines_number}}</div></td>
+       <td class="{{methods_level}} big">{{methods_bar}}</td>
+       <td class="{{methods_level}} small"><div align="right">{{methods_tested_percent}}</div></td>
+       <td class="{{methods_level}} small"><div align="right">{{methods_number}}</div></td>
+       <td class="{{methods_level}} small">{{crap}}</td>
+       <td class="{{methods_level}}" colspan="3"></td>
+      </tr>
+

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/method_item_branch.html.dist

@@ -0,0 +1,18 @@
+      <tr>
+       <td class="{{lines_level}}">{{name}}</td>
+       <td class="{{lines_level}} big">{{lines_bar}}</td>
+       <td class="{{lines_level}} small"><div align="right">{{lines_executed_percent}}</div></td>
+       <td class="{{lines_level}} small"><div align="right">{{lines_number}}</div></td>
+       <td class="{{branches_level}} big">{{branches_bar}}</td>
+       <td class="{{branches_level}} small"><div align="right">{{branches_executed_percent}}</div></td>
+       <td class="{{branches_level}} small"><div align="right">{{branches_number}}</div></td>
+       <td class="{{paths_level}} big">{{paths_bar}}</td>
+       <td class="{{paths_level}} small"><div align="right">{{paths_executed_percent}}</div></td>
+       <td class="{{paths_level}} small"><div align="right">{{paths_number}}</div></td>
+       <td class="{{methods_level}} big">{{methods_bar}}</td>
+       <td class="{{methods_level}} small"><div align="right">{{methods_tested_percent}}</div></td>
+       <td class="{{methods_level}} small"><div align="right">{{methods_number}}</div></td>
+       <td class="{{methods_level}} small">{{crap}}</td>
+       <td class="{{methods_level}}" colspan="3"></td>
+      </tr>
+

vendor/phpunit/php-code-coverage/src/Report/Html/Renderer/Template/paths.html.dist

@@ -0,0 +1,9 @@
+<hr/>
+<h4>Paths</h4>
+<p>
+    Below are the source code lines that represent each code path as identified by Xdebug. Please note a path is not
+    necessarily coterminous with a line, a line may contain multiple paths and therefore show up more than once.
+    Please also be aware that some paths may include implicit rather than explicit branches, e.g. an <code>if</code> statement
+    <i>always</i> has an <code>else</code> as part of its logical flow even if you didn't write one.
+</p>
+{{paths}}

vendor/phpunit/php-code-coverage/src/Report/PHP.php

@@ -0,0 +1,42 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report;
+
+use const PHP_EOL;
+use function dirname;
+use function file_put_contents;
+use function serialize;
+use function str_contains;
+use SebastianBergmann\CodeCoverage\CodeCoverage;
+use SebastianBergmann\CodeCoverage\Driver\WriteOperationFailedException;
+use SebastianBergmann\CodeCoverage\Util\Filesystem;
+
+final class PHP
+{
+    public function process(CodeCoverage $coverage, ?string $target = null): string
+    {
+        $coverage->clearCache();
+
+        $buffer = "<?php
+return \unserialize(<<<'END_OF_COVERAGE_SERIALIZATION'" . PHP_EOL . serialize($coverage) . PHP_EOL . 'END_OF_COVERAGE_SERIALIZATION' . PHP_EOL . ');';
+
+        if ($target !== null) {
+            if (!str_contains($target, '://')) {
+                Filesystem::createDirectory(dirname($target));
+            }
+
+            if (@file_put_contents($target, $buffer) === false) {
+                throw new WriteOperationFailedException($target);
+            }
+        }
+
+        return $buffer;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Text.php

@@ -0,0 +1,315 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report;
+
+use const PHP_EOL;
+use function array_map;
+use function date;
+use function ksort;
+use function max;
+use function sprintf;
+use function str_pad;
+use function strlen;
+use SebastianBergmann\CodeCoverage\CodeCoverage;
+use SebastianBergmann\CodeCoverage\Node\File;
+use SebastianBergmann\CodeCoverage\Util\Percentage;
+
+final class Text
+{
+    /**
+     * @var string
+     */
+    private const COLOR_GREEN = "\x1b[30;42m";
+
+    /**
+     * @var string
+     */
+    private const COLOR_YELLOW = "\x1b[30;43m";
+
+    /**
+     * @var string
+     */
+    private const COLOR_RED = "\x1b[37;41m";
+
+    /**
+     * @var string
+     */
+    private const COLOR_HEADER = "\x1b[1;37;40m";
+
+    /**
+     * @var string
+     */
+    private const COLOR_RESET = "\x1b[0m";
+    private readonly Thresholds $thresholds;
+    private readonly bool $showUncoveredFiles;
+    private readonly bool $showOnlySummary;
+
+    public function __construct(Thresholds $thresholds, bool $showUncoveredFiles = false, bool $showOnlySummary = false)
+    {
+        $this->thresholds         = $thresholds;
+        $this->showUncoveredFiles = $showUncoveredFiles;
+        $this->showOnlySummary    = $showOnlySummary;
+    }
+
+    public function process(CodeCoverage $coverage, bool $showColors = false): string
+    {
+        $hasBranchCoverage = !empty($coverage->getData(true)->functionCoverage());
+
+        $output = PHP_EOL . PHP_EOL;
+        $report = $coverage->getReport();
+
+        $colors = [
+            'header'   => '',
+            'classes'  => '',
+            'methods'  => '',
+            'lines'    => '',
+            'branches' => '',
+            'paths'    => '',
+            'reset'    => '',
+        ];
+
+        if ($showColors) {
+            $colors['classes'] = $this->coverageColor(
+                $report->numberOfTestedClassesAndTraits(),
+                $report->numberOfClassesAndTraits(),
+            );
+
+            $colors['methods'] = $this->coverageColor(
+                $report->numberOfTestedMethods(),
+                $report->numberOfMethods(),
+            );
+
+            $colors['lines'] = $this->coverageColor(
+                $report->numberOfExecutedLines(),
+                $report->numberOfExecutableLines(),
+            );
+
+            $colors['branches'] = $this->coverageColor(
+                $report->numberOfExecutedBranches(),
+                $report->numberOfExecutableBranches(),
+            );
+
+            $colors['paths'] = $this->coverageColor(
+                $report->numberOfExecutedPaths(),
+                $report->numberOfExecutablePaths(),
+            );
+
+            $colors['reset']  = self::COLOR_RESET;
+            $colors['header'] = self::COLOR_HEADER;
+        }
+
+        $classes = sprintf(
+            '  Classes: %6s (%d/%d)',
+            Percentage::fromFractionAndTotal(
+                $report->numberOfTestedClassesAndTraits(),
+                $report->numberOfClassesAndTraits(),
+            )->asString(),
+            $report->numberOfTestedClassesAndTraits(),
+            $report->numberOfClassesAndTraits(),
+        );
+
+        $methods = sprintf(
+            '  Methods: %6s (%d/%d)',
+            Percentage::fromFractionAndTotal(
+                $report->numberOfTestedMethods(),
+                $report->numberOfMethods(),
+            )->asString(),
+            $report->numberOfTestedMethods(),
+            $report->numberOfMethods(),
+        );
+
+        $paths    = '';
+        $branches = '';
+
+        if ($hasBranchCoverage) {
+            $paths = sprintf(
+                '  Paths:   %6s (%d/%d)',
+                Percentage::fromFractionAndTotal(
+                    $report->numberOfExecutedPaths(),
+                    $report->numberOfExecutablePaths(),
+                )->asString(),
+                $report->numberOfExecutedPaths(),
+                $report->numberOfExecutablePaths(),
+            );
+
+            $branches = sprintf(
+                '  Branches:   %6s (%d/%d)',
+                Percentage::fromFractionAndTotal(
+                    $report->numberOfExecutedBranches(),
+                    $report->numberOfExecutableBranches(),
+                )->asString(),
+                $report->numberOfExecutedBranches(),
+                $report->numberOfExecutableBranches(),
+            );
+        }
+
+        $lines = sprintf(
+            '  Lines:   %6s (%d/%d)',
+            Percentage::fromFractionAndTotal(
+                $report->numberOfExecutedLines(),
+                $report->numberOfExecutableLines(),
+            )->asString(),
+            $report->numberOfExecutedLines(),
+            $report->numberOfExecutableLines(),
+        );
+
+        $padding = max(array_map('strlen', [$classes, $methods, $lines]));
+
+        if ($this->showOnlySummary) {
+            $title   = 'Code Coverage Report Summary:';
+            $padding = max($padding, strlen($title));
+
+            $output .= $this->format($colors['header'], $padding, $title);
+        } else {
+            $date  = date('  Y-m-d H:i:s');
+            $title = 'Code Coverage Report:';
+
+            $output .= $this->format($colors['header'], $padding, $title);
+            $output .= $this->format($colors['header'], $padding, $date);
+            $output .= $this->format($colors['header'], $padding, '');
+            $output .= $this->format($colors['header'], $padding, ' Summary:');
+        }
+
+        $output .= $this->format($colors['classes'], $padding, $classes);
+        $output .= $this->format($colors['methods'], $padding, $methods);
+
+        if ($hasBranchCoverage) {
+            $output .= $this->format($colors['paths'], $padding, $paths);
+            $output .= $this->format($colors['branches'], $padding, $branches);
+        }
+        $output .= $this->format($colors['lines'], $padding, $lines);
+
+        if ($this->showOnlySummary) {
+            return $output . PHP_EOL;
+        }
+
+        $classCoverage = [];
+
+        foreach ($report as $item) {
+            if (!$item instanceof File) {
+                continue;
+            }
+
+            $classes = $item->classesAndTraits();
+
+            foreach ($classes as $className => $class) {
+                $classExecutableLines    = 0;
+                $classExecutedLines      = 0;
+                $classExecutableBranches = 0;
+                $classExecutedBranches   = 0;
+                $classExecutablePaths    = 0;
+                $classExecutedPaths      = 0;
+                $coveredMethods          = 0;
+                $classMethods            = 0;
+
+                foreach ($class['methods'] as $method) {
+                    if ($method['executableLines'] == 0) {
+                        continue;
+                    }
+
+                    $classMethods++;
+                    $classExecutableLines    += $method['executableLines'];
+                    $classExecutedLines      += $method['executedLines'];
+                    $classExecutableBranches += $method['executableBranches'];
+                    $classExecutedBranches   += $method['executedBranches'];
+                    $classExecutablePaths    += $method['executablePaths'];
+                    $classExecutedPaths      += $method['executedPaths'];
+
+                    if ($method['coverage'] == 100) {
+                        $coveredMethods++;
+                    }
+                }
+
+                $classCoverage[$className] = [
+                    'namespace'         => $class['namespace'],
+                    'className'         => $className,
+                    'methodsCovered'    => $coveredMethods,
+                    'methodCount'       => $classMethods,
+                    'statementsCovered' => $classExecutedLines,
+                    'statementCount'    => $classExecutableLines,
+                    'branchesCovered'   => $classExecutedBranches,
+                    'branchesCount'     => $classExecutableBranches,
+                    'pathsCovered'      => $classExecutedPaths,
+                    'pathsCount'        => $classExecutablePaths,
+                ];
+            }
+        }
+
+        ksort($classCoverage);
+
+        $methodColor   = '';
+        $pathsColor    = '';
+        $branchesColor = '';
+        $linesColor    = '';
+        $resetColor    = '';
+
+        foreach ($classCoverage as $fullQualifiedPath => $classInfo) {
+            if ($this->showUncoveredFiles || $classInfo['statementsCovered'] != 0) {
+                if ($showColors) {
+                    $methodColor   = $this->coverageColor($classInfo['methodsCovered'], $classInfo['methodCount']);
+                    $pathsColor    = $this->coverageColor($classInfo['pathsCovered'], $classInfo['pathsCount']);
+                    $branchesColor = $this->coverageColor($classInfo['branchesCovered'], $classInfo['branchesCount']);
+                    $linesColor    = $this->coverageColor($classInfo['statementsCovered'], $classInfo['statementCount']);
+                    $resetColor    = $colors['reset'];
+                }
+
+                $output .= PHP_EOL . $fullQualifiedPath . PHP_EOL
+                    . '  ' . $methodColor . 'Methods: ' . $this->printCoverageCounts($classInfo['methodsCovered'], $classInfo['methodCount'], 2) . $resetColor . ' ';
+
+                if ($hasBranchCoverage) {
+                    $output .= '  ' . $pathsColor . 'Paths: ' . $this->printCoverageCounts($classInfo['pathsCovered'], $classInfo['pathsCount'], 3) . $resetColor . ' '
+                    . '  ' . $branchesColor . 'Branches: ' . $this->printCoverageCounts($classInfo['branchesCovered'], $classInfo['branchesCount'], 3) . $resetColor . ' ';
+                }
+                $output .= '  ' . $linesColor . 'Lines: ' . $this->printCoverageCounts($classInfo['statementsCovered'], $classInfo['statementCount'], 3) . $resetColor;
+            }
+        }
+
+        return $output . PHP_EOL;
+    }
+
+    private function coverageColor(int $numberOfCoveredElements, int $totalNumberOfElements): string
+    {
+        $coverage = Percentage::fromFractionAndTotal(
+            $numberOfCoveredElements,
+            $totalNumberOfElements,
+        );
+
+        if ($coverage->asFloat() >= $this->thresholds->highLowerBound()) {
+            return self::COLOR_GREEN;
+        }
+
+        if ($coverage->asFloat() > $this->thresholds->lowUpperBound()) {
+            return self::COLOR_YELLOW;
+        }
+
+        return self::COLOR_RED;
+    }
+
+    private function printCoverageCounts(int $numberOfCoveredElements, int $totalNumberOfElements, int $precision): string
+    {
+        $format = '%' . $precision . 's';
+
+        return Percentage::fromFractionAndTotal(
+            $numberOfCoveredElements,
+            $totalNumberOfElements,
+        )->asFixedWidthString() .
+            ' (' . sprintf($format, $numberOfCoveredElements) . '/' .
+        sprintf($format, $totalNumberOfElements) . ')';
+    }
+
+    private function format(string $color, int $padding, false|string $string): string
+    {
+        if ($color === '') {
+            return (string) $string . PHP_EOL;
+        }
+
+        return $color . str_pad((string) $string, $padding) . self::COLOR_RESET . PHP_EOL;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Thresholds.php

@@ -0,0 +1,56 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report;
+
+use SebastianBergmann\CodeCoverage\InvalidArgumentException;
+
+/**
+ * @immutable
+ */
+final class Thresholds
+{
+    private readonly int $lowUpperBound;
+    private readonly int $highLowerBound;
+
+    public static function default(): self
+    {
+        return new self(50, 90);
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public static function from(int $lowUpperBound, int $highLowerBound): self
+    {
+        if ($lowUpperBound > $highLowerBound) {
+            throw new InvalidArgumentException(
+                '$lowUpperBound must not be larger than $highLowerBound',
+            );
+        }
+
+        return new self($lowUpperBound, $highLowerBound);
+    }
+
+    private function __construct(int $lowUpperBound, int $highLowerBound)
+    {
+        $this->lowUpperBound  = $lowUpperBound;
+        $this->highLowerBound = $highLowerBound;
+    }
+
+    public function lowUpperBound(): int
+    {
+        return $this->lowUpperBound;
+    }
+
+    public function highLowerBound(): int
+    {
+        return $this->highLowerBound;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Xml/BuildInformation.php

@@ -0,0 +1,82 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Xml;
+
+use function assert;
+use function phpversion;
+use DateTimeImmutable;
+use DOMElement;
+use SebastianBergmann\Environment\Runtime;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+final class BuildInformation
+{
+    private readonly DOMElement $contextNode;
+
+    public function __construct(DOMElement $contextNode)
+    {
+        $this->contextNode = $contextNode;
+    }
+
+    public function setRuntimeInformation(Runtime $runtime): void
+    {
+        $runtimeNode = $this->nodeByName('runtime');
+
+        $runtimeNode->setAttribute('name', $runtime->getName());
+        $runtimeNode->setAttribute('version', $runtime->getVersion());
+        $runtimeNode->setAttribute('url', $runtime->getVendorUrl());
+
+        $driverNode = $this->nodeByName('driver');
+
+        if ($runtime->hasXdebug()) {
+            $driverNode->setAttribute('name', 'xdebug');
+            $driverNode->setAttribute('version', phpversion('xdebug'));
+        }
+
+        if ($runtime->hasPCOV()) {
+            $driverNode->setAttribute('name', 'pcov');
+            $driverNode->setAttribute('version', phpversion('pcov'));
+        }
+    }
+
+    public function setBuildTime(DateTimeImmutable $date): void
+    {
+        $this->contextNode->setAttribute('time', $date->format('D M j G:i:s T Y'));
+    }
+
+    public function setGeneratorVersions(string $phpUnitVersion, string $coverageVersion): void
+    {
+        $this->contextNode->setAttribute('phpunit', $phpUnitVersion);
+        $this->contextNode->setAttribute('coverage', $coverageVersion);
+    }
+
+    private function nodeByName(string $name): DOMElement
+    {
+        $node = $this->contextNode->getElementsByTagNameNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            $name,
+        )->item(0);
+
+        if (!$node) {
+            $node = $this->contextNode->appendChild(
+                $this->contextNode->ownerDocument->createElementNS(
+                    'https://schema.phpunit.de/coverage/1.0',
+                    $name,
+                ),
+            );
+        }
+
+        assert($node instanceof DOMElement);
+
+        return $node;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Xml/Coverage.php

@@ -0,0 +1,63 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Xml;
+
+use DOMElement;
+use SebastianBergmann\CodeCoverage\ReportAlreadyFinalizedException;
+use XMLWriter;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+final class Coverage
+{
+    private readonly XMLWriter $writer;
+    private readonly DOMElement $contextNode;
+    private bool $finalized = false;
+
+    public function __construct(DOMElement $context, string $line)
+    {
+        $this->contextNode = $context;
+
+        $this->writer = new XMLWriter;
+        $this->writer->openMemory();
+        $this->writer->startElementNS(null, $context->nodeName, 'https://schema.phpunit.de/coverage/1.0');
+        $this->writer->writeAttribute('nr', $line);
+    }
+
+    /**
+     * @throws ReportAlreadyFinalizedException
+     */
+    public function addTest(string $test): void
+    {
+        if ($this->finalized) {
+            throw new ReportAlreadyFinalizedException;
+        }
+
+        $this->writer->startElement('covered');
+        $this->writer->writeAttribute('by', $test);
+        $this->writer->endElement();
+    }
+
+    public function finalize(): void
+    {
+        $this->writer->endElement();
+
+        $fragment = $this->contextNode->ownerDocument->createDocumentFragment();
+        $fragment->appendXML($this->writer->outputMemory());
+
+        $this->contextNode->parentNode->replaceChild(
+            $fragment,
+            $this->contextNode,
+        );
+
+        $this->finalized = true;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Xml/Directory.php

@@ -0,0 +1,17 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Xml;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+final class Directory extends Node
+{
+}

vendor/phpunit/php-code-coverage/src/Report/Xml/Facade.php

@@ -0,0 +1,304 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Xml;
+
+use const DIRECTORY_SEPARATOR;
+use const PHP_EOL;
+use function count;
+use function dirname;
+use function file_get_contents;
+use function file_put_contents;
+use function is_array;
+use function is_dir;
+use function is_file;
+use function is_writable;
+use function libxml_clear_errors;
+use function libxml_get_errors;
+use function libxml_use_internal_errors;
+use function sprintf;
+use function strlen;
+use function substr;
+use DateTimeImmutable;
+use DOMDocument;
+use SebastianBergmann\CodeCoverage\CodeCoverage;
+use SebastianBergmann\CodeCoverage\Driver\PathExistsButIsNotDirectoryException;
+use SebastianBergmann\CodeCoverage\Driver\WriteOperationFailedException;
+use SebastianBergmann\CodeCoverage\Node\AbstractNode;
+use SebastianBergmann\CodeCoverage\Node\Directory as DirectoryNode;
+use SebastianBergmann\CodeCoverage\Node\File as FileNode;
+use SebastianBergmann\CodeCoverage\Util\Filesystem as DirectoryUtil;
+use SebastianBergmann\CodeCoverage\Version;
+use SebastianBergmann\CodeCoverage\XmlException;
+use SebastianBergmann\Environment\Runtime;
+
+final class Facade
+{
+    private string $target;
+    private Project $project;
+    private readonly string $phpUnitVersion;
+
+    public function __construct(string $version)
+    {
+        $this->phpUnitVersion = $version;
+    }
+
+    /**
+     * @throws XmlException
+     */
+    public function process(CodeCoverage $coverage, string $target): void
+    {
+        if (substr($target, -1, 1) !== DIRECTORY_SEPARATOR) {
+            $target .= DIRECTORY_SEPARATOR;
+        }
+
+        $this->target = $target;
+        $this->initTargetDirectory($target);
+
+        $report = $coverage->getReport();
+
+        $this->project = new Project(
+            $coverage->getReport()->name(),
+        );
+
+        $this->setBuildInformation();
+        $this->processTests($coverage->getTests());
+        $this->processDirectory($report, $this->project);
+
+        $this->saveDocument($this->project->asDom(), 'index');
+    }
+
+    private function setBuildInformation(): void
+    {
+        $buildNode = $this->project->buildInformation();
+        $buildNode->setRuntimeInformation(new Runtime);
+        $buildNode->setBuildTime(new DateTimeImmutable);
+        $buildNode->setGeneratorVersions($this->phpUnitVersion, Version::id());
+    }
+
+    /**
+     * @throws PathExistsButIsNotDirectoryException
+     * @throws WriteOperationFailedException
+     */
+    private function initTargetDirectory(string $directory): void
+    {
+        if (is_file($directory)) {
+            if (!is_dir($directory)) {
+                throw new PathExistsButIsNotDirectoryException($directory);
+            }
+
+            if (!is_writable($directory)) {
+                throw new WriteOperationFailedException($directory);
+            }
+        }
+
+        DirectoryUtil::createDirectory($directory);
+    }
+
+    /**
+     * @throws XmlException
+     */
+    private function processDirectory(DirectoryNode $directory, Node $context): void
+    {
+        $directoryName = $directory->name();
+
+        if ($this->project->projectSourceDirectory() === $directoryName) {
+            $directoryName = '/';
+        }
+
+        $directoryObject = $context->addDirectory($directoryName);
+
+        $this->setTotals($directory, $directoryObject->totals());
+
+        foreach ($directory->directories() as $node) {
+            $this->processDirectory($node, $directoryObject);
+        }
+
+        foreach ($directory->files() as $node) {
+            $this->processFile($node, $directoryObject);
+        }
+    }
+
+    /**
+     * @throws XmlException
+     */
+    private function processFile(FileNode $file, Directory $context): void
+    {
+        $fileObject = $context->addFile(
+            $file->name(),
+            $file->id() . '.xml',
+        );
+
+        $this->setTotals($file, $fileObject->totals());
+
+        $path = substr(
+            $file->pathAsString(),
+            strlen($this->project->projectSourceDirectory()),
+        );
+
+        $fileReport = new Report($path);
+
+        $this->setTotals($file, $fileReport->totals());
+
+        foreach ($file->classesAndTraits() as $unit) {
+            $this->processUnit($unit, $fileReport);
+        }
+
+        foreach ($file->functions() as $function) {
+            $this->processFunction($function, $fileReport);
+        }
+
+        foreach ($file->lineCoverageData() as $line => $tests) {
+            if (!is_array($tests) || count($tests) === 0) {
+                continue;
+            }
+
+            $coverage = $fileReport->lineCoverage((string) $line);
+
+            foreach ($tests as $test) {
+                $coverage->addTest($test);
+            }
+
+            $coverage->finalize();
+        }
+
+        $fileReport->source()->setSourceCode(
+            file_get_contents($file->pathAsString()),
+        );
+
+        $this->saveDocument($fileReport->asDom(), $file->id());
+    }
+
+    private function processUnit(array $unit, Report $report): void
+    {
+        if (isset($unit['className'])) {
+            $unitObject = $report->classObject($unit['className']);
+        } else {
+            $unitObject = $report->traitObject($unit['traitName']);
+        }
+
+        $unitObject->setLines(
+            $unit['startLine'],
+            $unit['executableLines'],
+            $unit['executedLines'],
+        );
+
+        $unitObject->setCrap((float) $unit['crap']);
+        $unitObject->setNamespace($unit['namespace']);
+
+        foreach ($unit['methods'] as $method) {
+            $methodObject = $unitObject->addMethod($method['methodName']);
+            $methodObject->setSignature($method['signature']);
+            $methodObject->setLines((string) $method['startLine'], (string) $method['endLine']);
+            $methodObject->setCrap($method['crap']);
+            $methodObject->setTotals(
+                (string) $method['executableLines'],
+                (string) $method['executedLines'],
+                (string) $method['coverage'],
+            );
+        }
+    }
+
+    private function processFunction(array $function, Report $report): void
+    {
+        $functionObject = $report->functionObject($function['functionName']);
+
+        $functionObject->setSignature($function['signature']);
+        $functionObject->setLines((string) $function['startLine']);
+        $functionObject->setCrap($function['crap']);
+        $functionObject->setTotals((string) $function['executableLines'], (string) $function['executedLines'], (string) $function['coverage']);
+    }
+
+    private function processTests(array $tests): void
+    {
+        $testsObject = $this->project->tests();
+
+        foreach ($tests as $test => $result) {
+            $testsObject->addTest($test, $result);
+        }
+    }
+
+    private function setTotals(AbstractNode $node, Totals $totals): void
+    {
+        $loc = $node->linesOfCode();
+
+        $totals->setNumLines(
+            $loc['linesOfCode'],
+            $loc['commentLinesOfCode'],
+            $loc['nonCommentLinesOfCode'],
+            $node->numberOfExecutableLines(),
+            $node->numberOfExecutedLines(),
+        );
+
+        $totals->setNumClasses(
+            $node->numberOfClasses(),
+            $node->numberOfTestedClasses(),
+        );
+
+        $totals->setNumTraits(
+            $node->numberOfTraits(),
+            $node->numberOfTestedTraits(),
+        );
+
+        $totals->setNumMethods(
+            $node->numberOfMethods(),
+            $node->numberOfTestedMethods(),
+        );
+
+        $totals->setNumFunctions(
+            $node->numberOfFunctions(),
+            $node->numberOfTestedFunctions(),
+        );
+    }
+
+    private function targetDirectory(): string
+    {
+        return $this->target;
+    }
+
+    /**
+     * @throws XmlException
+     */
+    private function saveDocument(DOMDocument $document, string $name): void
+    {
+        $filename = sprintf('%s/%s.xml', $this->targetDirectory(), $name);
+
+        $document->formatOutput       = true;
+        $document->preserveWhiteSpace = false;
+        $this->initTargetDirectory(dirname($filename));
+
+        file_put_contents($filename, $this->documentAsString($document));
+    }
+
+    /**
+     * @throws XmlException
+     *
+     * @see https://bugs.php.net/bug.php?id=79191
+     */
+    private function documentAsString(DOMDocument $document): string
+    {
+        $xmlErrorHandling = libxml_use_internal_errors(true);
+        $xml              = $document->saveXML();
+
+        if ($xml === false) {
+            $message = 'Unable to generate the XML';
+
+            foreach (libxml_get_errors() as $error) {
+                $message .= PHP_EOL . $error->message;
+            }
+
+            throw new XmlException($message);
+        }
+
+        libxml_clear_errors();
+        libxml_use_internal_errors($xmlErrorHandling);
+
+        return $xml;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Xml/File.php

@@ -0,0 +1,80 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Xml;
+
+use DOMDocument;
+use DOMElement;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+class File
+{
+    private readonly DOMDocument $dom;
+    private readonly DOMElement $contextNode;
+
+    public function __construct(DOMElement $context)
+    {
+        $this->dom         = $context->ownerDocument;
+        $this->contextNode = $context;
+    }
+
+    public function totals(): Totals
+    {
+        $totalsContainer = $this->contextNode->firstChild;
+
+        if (!$totalsContainer) {
+            $totalsContainer = $this->contextNode->appendChild(
+                $this->dom->createElementNS(
+                    'https://schema.phpunit.de/coverage/1.0',
+                    'totals',
+                ),
+            );
+        }
+
+        return new Totals($totalsContainer);
+    }
+
+    public function lineCoverage(string $line): Coverage
+    {
+        $coverage = $this->contextNode->getElementsByTagNameNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            'coverage',
+        )->item(0);
+
+        if (!$coverage) {
+            $coverage = $this->contextNode->appendChild(
+                $this->dom->createElementNS(
+                    'https://schema.phpunit.de/coverage/1.0',
+                    'coverage',
+                ),
+            );
+        }
+
+        $lineNode = $coverage->appendChild(
+            $this->dom->createElementNS(
+                'https://schema.phpunit.de/coverage/1.0',
+                'line',
+            ),
+        );
+
+        return new Coverage($lineNode, $line);
+    }
+
+    protected function contextNode(): DOMElement
+    {
+        return $this->contextNode;
+    }
+
+    protected function dom(): DOMDocument
+    {
+        return $this->dom;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Xml/Method.php

@@ -0,0 +1,58 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Xml;
+
+use DOMElement;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+final class Method
+{
+    private readonly DOMElement $contextNode;
+
+    public function __construct(DOMElement $context, string $name)
+    {
+        $this->contextNode = $context;
+
+        $this->setName($name);
+    }
+
+    public function setSignature(string $signature): void
+    {
+        $this->contextNode->setAttribute('signature', $signature);
+    }
+
+    public function setLines(string $start, ?string $end = null): void
+    {
+        $this->contextNode->setAttribute('start', $start);
+
+        if ($end !== null) {
+            $this->contextNode->setAttribute('end', $end);
+        }
+    }
+
+    public function setTotals(string $executable, string $executed, string $coverage): void
+    {
+        $this->contextNode->setAttribute('executable', $executable);
+        $this->contextNode->setAttribute('executed', $executed);
+        $this->contextNode->setAttribute('coverage', $coverage);
+    }
+
+    public function setCrap(string $crap): void
+    {
+        $this->contextNode->setAttribute('crap', $crap);
+    }
+
+    private function setName(string $name): void
+    {
+        $this->contextNode->setAttribute('name', $name);
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Xml/Node.php

@@ -0,0 +1,86 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Xml;
+
+use DOMDocument;
+use DOMElement;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+abstract class Node
+{
+    private DOMDocument $dom;
+    private DOMElement $contextNode;
+
+    public function __construct(DOMElement $context)
+    {
+        $this->setContextNode($context);
+    }
+
+    public function dom(): DOMDocument
+    {
+        return $this->dom;
+    }
+
+    public function totals(): Totals
+    {
+        $totalsContainer = $this->contextNode()->firstChild;
+
+        if (!$totalsContainer) {
+            $totalsContainer = $this->contextNode()->appendChild(
+                $this->dom->createElementNS(
+                    'https://schema.phpunit.de/coverage/1.0',
+                    'totals',
+                ),
+            );
+        }
+
+        return new Totals($totalsContainer);
+    }
+
+    public function addDirectory(string $name): Directory
+    {
+        $dirNode = $this->dom()->createElementNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            'directory',
+        );
+
+        $dirNode->setAttribute('name', $name);
+        $this->contextNode()->appendChild($dirNode);
+
+        return new Directory($dirNode);
+    }
+
+    public function addFile(string $name, string $href): File
+    {
+        $fileNode = $this->dom()->createElementNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            'file',
+        );
+
+        $fileNode->setAttribute('name', $name);
+        $fileNode->setAttribute('href', $href);
+        $this->contextNode()->appendChild($fileNode);
+
+        return new File($fileNode);
+    }
+
+    protected function setContextNode(DOMElement $context): void
+    {
+        $this->dom         = $context->ownerDocument;
+        $this->contextNode = $context;
+    }
+
+    protected function contextNode(): DOMElement
+    {
+        return $this->contextNode;
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Xml/Project.php

@@ -0,0 +1,90 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Xml;
+
+use DOMDocument;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+final class Project extends Node
+{
+    public function __construct(string $directory)
+    {
+        $this->init();
+        $this->setProjectSourceDirectory($directory);
+    }
+
+    public function projectSourceDirectory(): string
+    {
+        return $this->contextNode()->getAttribute('source');
+    }
+
+    public function buildInformation(): BuildInformation
+    {
+        $buildNode = $this->dom()->getElementsByTagNameNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            'build',
+        )->item(0);
+
+        if (!$buildNode) {
+            $buildNode = $this->dom()->documentElement->appendChild(
+                $this->dom()->createElementNS(
+                    'https://schema.phpunit.de/coverage/1.0',
+                    'build',
+                ),
+            );
+        }
+
+        return new BuildInformation($buildNode);
+    }
+
+    public function tests(): Tests
+    {
+        $testsNode = $this->contextNode()->getElementsByTagNameNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            'tests',
+        )->item(0);
+
+        if (!$testsNode) {
+            $testsNode = $this->contextNode()->appendChild(
+                $this->dom()->createElementNS(
+                    'https://schema.phpunit.de/coverage/1.0',
+                    'tests',
+                ),
+            );
+        }
+
+        return new Tests($testsNode);
+    }
+
+    public function asDom(): DOMDocument
+    {
+        return $this->dom();
+    }
+
+    private function init(): void
+    {
+        $dom = new DOMDocument;
+        $dom->loadXML('<?xml version="1.0" ?><phpunit xmlns="https://schema.phpunit.de/coverage/1.0"><build/><project/></phpunit>');
+
+        $this->setContextNode(
+            $dom->getElementsByTagNameNS(
+                'https://schema.phpunit.de/coverage/1.0',
+                'project',
+            )->item(0),
+        );
+    }
+
+    private function setProjectSourceDirectory(string $name): void
+    {
+        $this->contextNode()->setAttribute('source', $name);
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Xml/Report.php

@@ -0,0 +1,99 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Xml;
+
+use function basename;
+use function dirname;
+use DOMDocument;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+final class Report extends File
+{
+    public function __construct(string $name)
+    {
+        $dom = new DOMDocument;
+        $dom->loadXML('<?xml version="1.0" ?><phpunit xmlns="https://schema.phpunit.de/coverage/1.0"><file /></phpunit>');
+
+        $contextNode = $dom->getElementsByTagNameNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            'file',
+        )->item(0);
+
+        parent::__construct($contextNode);
+
+        $this->setName($name);
+    }
+
+    public function asDom(): DOMDocument
+    {
+        return $this->dom();
+    }
+
+    public function functionObject($name): Method
+    {
+        $node = $this->contextNode()->appendChild(
+            $this->dom()->createElementNS(
+                'https://schema.phpunit.de/coverage/1.0',
+                'function',
+            ),
+        );
+
+        return new Method($node, $name);
+    }
+
+    public function classObject($name): Unit
+    {
+        return $this->unitObject('class', $name);
+    }
+
+    public function traitObject($name): Unit
+    {
+        return $this->unitObject('trait', $name);
+    }
+
+    public function source(): Source
+    {
+        $source = $this->contextNode()->getElementsByTagNameNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            'source',
+        )->item(0);
+
+        if (!$source) {
+            $source = $this->contextNode()->appendChild(
+                $this->dom()->createElementNS(
+                    'https://schema.phpunit.de/coverage/1.0',
+                    'source',
+                ),
+            );
+        }
+
+        return new Source($source);
+    }
+
+    private function setName(string $name): void
+    {
+        $this->contextNode()->setAttribute('name', basename($name));
+        $this->contextNode()->setAttribute('path', dirname($name));
+    }
+
+    private function unitObject(string $tagName, $name): Unit
+    {
+        $node = $this->contextNode()->appendChild(
+            $this->dom()->createElementNS(
+                'https://schema.phpunit.de/coverage/1.0',
+                $tagName,
+            ),
+        );
+
+        return new Unit($node, $name);
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Xml/Source.php

@@ -0,0 +1,41 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Xml;
+
+use DOMElement;
+use TheSeer\Tokenizer\NamespaceUri;
+use TheSeer\Tokenizer\Tokenizer;
+use TheSeer\Tokenizer\XMLSerializer;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+final class Source
+{
+    private readonly DOMElement $context;
+
+    public function __construct(DOMElement $context)
+    {
+        $this->context = $context;
+    }
+
+    public function setSourceCode(string $source): void
+    {
+        $context = $this->context;
+
+        $tokens = (new Tokenizer)->parse($source);
+        $srcDom = (new XMLSerializer(new NamespaceUri($context->namespaceURI)))->toDom($tokens);
+
+        $context->parentNode->replaceChild(
+            $context->ownerDocument->importNode($srcDom->documentElement, true),
+            $context,
+        );
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Xml/Tests.php

@@ -0,0 +1,47 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Xml;
+
+use function assert;
+use DOMElement;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ *
+ * @phpstan-import-type TestType from \SebastianBergmann\CodeCoverage\CodeCoverage
+ */
+final class Tests
+{
+    private readonly DOMElement $contextNode;
+
+    public function __construct(DOMElement $context)
+    {
+        $this->contextNode = $context;
+    }
+
+    /**
+     * @param TestType $result
+     */
+    public function addTest(string $test, array $result): void
+    {
+        $node = $this->contextNode->appendChild(
+            $this->contextNode->ownerDocument->createElementNS(
+                'https://schema.phpunit.de/coverage/1.0',
+                'test',
+            ),
+        );
+
+        assert($node instanceof DOMElement);
+
+        $node->setAttribute('name', $test);
+        $node->setAttribute('size', $result['size']);
+        $node->setAttribute('status', $result['status']);
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Xml/Totals.php

@@ -0,0 +1,123 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Xml;
+
+use function sprintf;
+use DOMElement;
+use DOMNode;
+use SebastianBergmann\CodeCoverage\Util\Percentage;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+final class Totals
+{
+    private readonly DOMNode $container;
+    private readonly DOMElement $linesNode;
+    private readonly DOMElement $methodsNode;
+    private readonly DOMElement $functionsNode;
+    private readonly DOMElement $classesNode;
+    private readonly DOMElement $traitsNode;
+
+    public function __construct(DOMElement $container)
+    {
+        $this->container = $container;
+        $dom             = $container->ownerDocument;
+
+        $this->linesNode = $dom->createElementNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            'lines',
+        );
+
+        $this->methodsNode = $dom->createElementNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            'methods',
+        );
+
+        $this->functionsNode = $dom->createElementNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            'functions',
+        );
+
+        $this->classesNode = $dom->createElementNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            'classes',
+        );
+
+        $this->traitsNode = $dom->createElementNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            'traits',
+        );
+
+        $container->appendChild($this->linesNode);
+        $container->appendChild($this->methodsNode);
+        $container->appendChild($this->functionsNode);
+        $container->appendChild($this->classesNode);
+        $container->appendChild($this->traitsNode);
+    }
+
+    public function container(): DOMNode
+    {
+        return $this->container;
+    }
+
+    public function setNumLines(int $loc, int $cloc, int $ncloc, int $executable, int $executed): void
+    {
+        $this->linesNode->setAttribute('total', (string) $loc);
+        $this->linesNode->setAttribute('comments', (string) $cloc);
+        $this->linesNode->setAttribute('code', (string) $ncloc);
+        $this->linesNode->setAttribute('executable', (string) $executable);
+        $this->linesNode->setAttribute('executed', (string) $executed);
+        $this->linesNode->setAttribute(
+            'percent',
+            $executable === 0 ? '0' : sprintf('%01.2F', Percentage::fromFractionAndTotal($executed, $executable)->asFloat()),
+        );
+    }
+
+    public function setNumClasses(int $count, int $tested): void
+    {
+        $this->classesNode->setAttribute('count', (string) $count);
+        $this->classesNode->setAttribute('tested', (string) $tested);
+        $this->classesNode->setAttribute(
+            'percent',
+            $count === 0 ? '0' : sprintf('%01.2F', Percentage::fromFractionAndTotal($tested, $count)->asFloat()),
+        );
+    }
+
+    public function setNumTraits(int $count, int $tested): void
+    {
+        $this->traitsNode->setAttribute('count', (string) $count);
+        $this->traitsNode->setAttribute('tested', (string) $tested);
+        $this->traitsNode->setAttribute(
+            'percent',
+            $count === 0 ? '0' : sprintf('%01.2F', Percentage::fromFractionAndTotal($tested, $count)->asFloat()),
+        );
+    }
+
+    public function setNumMethods(int $count, int $tested): void
+    {
+        $this->methodsNode->setAttribute('count', (string) $count);
+        $this->methodsNode->setAttribute('tested', (string) $tested);
+        $this->methodsNode->setAttribute(
+            'percent',
+            $count === 0 ? '0' : sprintf('%01.2F', Percentage::fromFractionAndTotal($tested, $count)->asFloat()),
+        );
+    }
+
+    public function setNumFunctions(int $count, int $tested): void
+    {
+        $this->functionsNode->setAttribute('count', (string) $count);
+        $this->functionsNode->setAttribute('tested', (string) $tested);
+        $this->functionsNode->setAttribute(
+            'percent',
+            $count === 0 ? '0' : sprintf('%01.2F', Percentage::fromFractionAndTotal($tested, $count)->asFloat()),
+        );
+    }
+}

vendor/phpunit/php-code-coverage/src/Report/Xml/Unit.php

@@ -0,0 +1,78 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of phpunit/php-code-coverage.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace SebastianBergmann\CodeCoverage\Report\Xml;
+
+use function assert;
+use DOMElement;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
+ */
+final class Unit
+{
+    private readonly DOMElement $contextNode;
+
+    public function __construct(DOMElement $context, string $name)
+    {
+        $this->contextNode = $context;
+
+        $this->setName($name);
+    }
+
+    public function setLines(int $start, int $executable, int $executed): void
+    {
+        $this->contextNode->setAttribute('start', (string) $start);
+        $this->contextNode->setAttribute('executable', (string) $executable);
+        $this->contextNode->setAttribute('executed', (string) $executed);
+    }
+
+    public function setCrap(float $crap): void
+    {
+        $this->contextNode->setAttribute('crap', (string) $crap);
+    }
+
+    public function setNamespace(string $namespace): void
+    {
+        $node = $this->contextNode->getElementsByTagNameNS(
+            'https://schema.phpunit.de/coverage/1.0',
+            'namespace',
+        )->item(0);
+
+        if (!$node) {
+            $node = $this->contextNode->appendChild(
+                $this->contextNode->ownerDocument->createElementNS(
+                    'https://schema.phpunit.de/coverage/1.0',
+                    'namespace',
+                ),
+            );
+        }
+
+        assert($node instanceof DOMElement);
+
+        $node->setAttribute('name', $namespace);
+    }
+
+    public function addMethod(string $name): Method
+    {
+        $node = $this->contextNode->appendChild(
+            $this->contextNode->ownerDocument->createElementNS(
+                'https://schema.phpunit.de/coverage/1.0',
+                'method',
+            ),
+        );
+
+        return new Method($node, $name);
+    }
+
+    private function setName(string $name): void
+    {
+        $this->contextNode->setAttribute('name', $name);
+    }
+}