upgraded dependencies

vendor/sebastian/cli-parser/ChangeLog.md

@@ -0,0 +1,15 @@
+# ChangeLog
+
+All notable changes are documented in this file using the [Keep a CHANGELOG](https://keepachangelog.com/) principles.
+
+## [1.0.1] - 2020-09-28
+
+### Changed
+
+* Changed PHP version constraint in `composer.json` from `^7.3 || ^8.0` to `>=7.3`
+
+## [1.0.0] - 2020-08-12
+
+* Initial release
+
+[1.0.0]: https://github.com/sebastianbergmann/cli-parser/compare/bb7bb3297957927962b0a3335befe7b66f7462e9...1.0.0

vendor/sebastian/cli-parser/LICENSE

@@ -0,0 +1,33 @@
+sebastian/cli-parser
+
+Copyright (c) 2020, Sebastian Bergmann <sebastian@phpunit.de>.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in
+   the documentation and/or other materials provided with the
+   distribution.
+
+ * Neither the name of Sebastian Bergmann nor the names of his
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

vendor/sebastian/cli-parser/README.md

@@ -0,0 +1,17 @@
+# sebastian/cli-parser
+
+Library for parsing `$_SERVER['argv']`, extracted from `phpunit/phpunit`.
+
+## Installation
+
+You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/):
+
+```
+composer require sebastian/cli-parser
+```
+
+If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency:
+
+```
+composer require --dev sebastian/cli-parser
+```

vendor/sebastian/cli-parser/composer.json

@@ -0,0 +1,41 @@
+{
+    "name": "sebastian/cli-parser",
+    "description": "Library for parsing CLI options",
+    "type": "library",
+    "homepage": "https://github.com/sebastianbergmann/cli-parser",
+    "license": "BSD-3-Clause",
+    "authors": [
+        {
+            "name": "Sebastian Bergmann",
+            "email": "sebastian@phpunit.de",
+            "role": "lead"
+        }
+    ],
+    "support": {
+        "issues": "https://github.com/sebastianbergmann/cli-parser/issues"
+    },
+    "prefer-stable": true,
+    "require": {
+        "php": ">=7.3"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "^9.3"
+    },
+    "config": {
+        "platform": {
+            "php": "7.3.0"
+        },
+        "optimize-autoloader": true,
+        "sort-packages": true
+    },
+    "autoload": {
+        "classmap": [
+            "src/"
+        ]
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "1.0-dev"
+        }
+    }
+}

vendor/sebastian/cli-parser/infection.json

@@ -0,0 +1,12 @@
+{
+    "source": {
+        "directories": [
+            "src"
+        ]
+    },
+    "mutators": {
+        "@default": true
+    },
+    "minMsi": 100,
+    "minCoveredMsi": 100
+}

vendor/sebastian/cli-parser/src/Parser.php

@@ -0,0 +1,204 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/cli-parser.
+ *
+ * (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\CliParser;
+
+use function array_map;
+use function array_merge;
+use function array_shift;
+use function array_slice;
+use function assert;
+use function count;
+use function current;
+use function explode;
+use function is_array;
+use function is_int;
+use function is_string;
+use function key;
+use function next;
+use function preg_replace;
+use function reset;
+use function sort;
+use function strlen;
+use function strpos;
+use function strstr;
+use function substr;
+
+final class Parser
+{
+    /**
+     * @psalm-param list<string> $argv
+     * @psalm-param list<string> $longOptions
+     *
+     * @throws AmbiguousOptionException
+     * @throws RequiredOptionArgumentMissingException
+     * @throws OptionDoesNotAllowArgumentException
+     * @throws UnknownOptionException
+     */
+    public function parse(array $argv, string $shortOptions, array $longOptions = null): array
+    {
+        if (empty($argv)) {
+            return [[], []];
+        }
+
+        $options     = [];
+        $nonOptions  = [];
+
+        if ($longOptions) {
+            sort($longOptions);
+        }
+
+        if (isset($argv[0][0]) && $argv[0][0] !== '-') {
+            array_shift($argv);
+        }
+
+        reset($argv);
+
+        $argv = array_map('trim', $argv);
+
+        while (false !== $arg = current($argv)) {
+            $i = key($argv);
+
+            assert(is_int($i));
+
+            next($argv);
+
+            if ($arg === '') {
+                continue;
+            }
+
+            if ($arg === '--') {
+                $nonOptions = array_merge($nonOptions, array_slice($argv, $i + 1));
+
+                break;
+            }
+
+            if ($arg[0] !== '-' || (strlen($arg) > 1 && $arg[1] === '-' && !$longOptions)) {
+                $nonOptions[] = $arg;
+
+                continue;
+            }
+
+            if (strlen($arg) > 1 && $arg[1] === '-' && is_array($longOptions)) {
+                $this->parseLongOption(
+                    substr($arg, 2),
+                    $longOptions,
+                    $options,
+                    $argv
+                );
+            } else {
+                $this->parseShortOption(
+                    substr($arg, 1),
+                    $shortOptions,
+                    $options,
+                    $argv
+                );
+            }
+        }
+
+        return [$options, $nonOptions];
+    }
+
+    /**
+     * @throws RequiredOptionArgumentMissingException
+     */
+    private function parseShortOption(string $arg, string $shortOptions, array &$opts, array &$args): void
+    {
+        $argLength = strlen($arg);
+
+        for ($i = 0; $i < $argLength; $i++) {
+            $option         = $arg[$i];
+            $optionArgument = null;
+
+            if ($arg[$i] === ':' || ($spec = strstr($shortOptions, $option)) === false) {
+                throw new UnknownOptionException('-' . $option);
+            }
+
+            assert(is_string($spec));
+
+            if (strlen($spec) > 1 && $spec[1] === ':') {
+                if ($i + 1 < $argLength) {
+                    $opts[] = [$option, substr($arg, $i + 1)];
+
+                    break;
+                }
+
+                if (!(strlen($spec) > 2 && $spec[2] === ':')) {
+                    $optionArgument = current($args);
+
+                    if (!$optionArgument) {
+                        throw new RequiredOptionArgumentMissingException('-' . $option);
+                    }
+
+                    assert(is_string($optionArgument));
+
+                    next($args);
+                }
+            }
+
+            $opts[] = [$option, $optionArgument];
+        }
+    }
+
+    /**
+     * @psalm-param list<string> $longOptions
+     *
+     * @throws AmbiguousOptionException
+     * @throws RequiredOptionArgumentMissingException
+     * @throws OptionDoesNotAllowArgumentException
+     * @throws UnknownOptionException
+     */
+    private function parseLongOption(string $arg, array $longOptions, array &$opts, array &$args): void
+    {
+        $count          = count($longOptions);
+        $list           = explode('=', $arg);
+        $option         = $list[0];
+        $optionArgument = null;
+
+        if (count($list) > 1) {
+            $optionArgument = $list[1];
+        }
+
+        $optionLength = strlen($option);
+
+        foreach ($longOptions as $i => $longOption) {
+            $opt_start = substr($longOption, 0, $optionLength);
+
+            if ($opt_start !== $option) {
+                continue;
+            }
+
+            $opt_rest = substr($longOption, $optionLength);
+
+            if ($opt_rest !== '' && $i + 1 < $count && $option[0] !== '=' && strpos($longOptions[$i + 1], $option) === 0) {
+                throw new AmbiguousOptionException('--' . $option);
+            }
+
+            if (substr($longOption, -1) === '=') {
+                /* @noinspection StrlenInEmptyStringCheckContextInspection */
+                if (substr($longOption, -2) !== '==' && !strlen((string) $optionArgument)) {
+                    if (false === $optionArgument = current($args)) {
+                        throw new RequiredOptionArgumentMissingException('--' . $option);
+                    }
+
+                    next($args);
+                }
+            } elseif ($optionArgument) {
+                throw new OptionDoesNotAllowArgumentException('--' . $option);
+            }
+
+            $fullOption = '--' . preg_replace('/={1,2}$/', '', $longOption);
+            $opts[]     = [$fullOption, $optionArgument];
+
+            return;
+        }
+
+        throw new UnknownOptionException('--' . $option);
+    }
+}

vendor/sebastian/cli-parser/src/exceptions/AmbiguousOptionException.php

@@ -0,0 +1,26 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/cli-parser.
+ *
+ * (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\CliParser;
+
+use function sprintf;
+use RuntimeException;
+
+final class AmbiguousOptionException extends RuntimeException implements Exception
+{
+    public function __construct(string $option)
+    {
+        parent::__construct(
+            sprintf(
+                'Option "%s" is ambiguous',
+                $option
+            )
+        );
+    }
+}

vendor/sebastian/cli-parser/src/exceptions/Exception.php

@@ -1,14 +1,16 @@
 <?php declare(strict_types=1);
 /*
- * This file is part of sebastian/global-state.
+ * This file is part of sebastian/cli-parser.
  *
  * (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\GlobalState\TestFixture;
+namespace SebastianBergmann\CliParser;
 
-function snapshotFunction(): void
+use Throwable;
+
+interface Exception extends Throwable
 {
 }

vendor/sebastian/cli-parser/src/exceptions/OptionDoesNotAllowArgumentException.php

@@ -0,0 +1,26 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/cli-parser.
+ *
+ * (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\CliParser;
+
+use function sprintf;
+use RuntimeException;
+
+final class OptionDoesNotAllowArgumentException extends RuntimeException implements Exception
+{
+    public function __construct(string $option)
+    {
+        parent::__construct(
+            sprintf(
+                'Option "%s" does not allow an argument',
+                $option
+            )
+        );
+    }
+}

vendor/sebastian/cli-parser/src/exceptions/RequiredOptionArgumentMissingException.php

@@ -0,0 +1,26 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/cli-parser.
+ *
+ * (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\CliParser;
+
+use function sprintf;
+use RuntimeException;
+
+final class RequiredOptionArgumentMissingException extends RuntimeException implements Exception
+{
+    public function __construct(string $option)
+    {
+        parent::__construct(
+            sprintf(
+                'Required argument for option "%s" is missing',
+                $option
+            )
+        );
+    }
+}

vendor/sebastian/cli-parser/src/exceptions/UnknownOptionException.php

@@ -0,0 +1,26 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/cli-parser.
+ *
+ * (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\CliParser;
+
+use function sprintf;
+use RuntimeException;
+
+final class UnknownOptionException extends RuntimeException implements Exception
+{
+    public function __construct(string $option)
+    {
+        parent::__construct(
+            sprintf(
+                'Unknown option "%s"',
+                $option
+            )
+        );
+    }
+}

vendor/sebastian/code-unit-reverse-lookup/.gitignore

@@ -1,4 +0,0 @@
-/.idea
-/composer.lock
-/vendor
-

vendor/sebastian/code-unit-reverse-lookup/.php_cs

@@ -1,67 +0,0 @@
-<?php
-$finder = Symfony\CS\Finder\DefaultFinder::create()
-    ->files()
-    ->in('src')
-    ->in('tests')
-    ->name('*.php');
-
-return Symfony\CS\Config\Config::create()
-    ->level(\Symfony\CS\FixerInterface::NONE_LEVEL)
-    ->fixers(
-        array(
-            'align_double_arrow',
-            'align_equals',
-            'braces',
-            'concat_with_spaces',
-            'duplicate_semicolon',
-            'elseif',
-            'empty_return',
-            'encoding',
-            'eof_ending',
-            'extra_empty_lines',
-            'function_call_space',
-            'function_declaration',
-            'indentation',
-            'join_function',
-            'line_after_namespace',
-            'linefeed',
-            'list_commas',
-            'lowercase_constants',
-            'lowercase_keywords',
-            'method_argument_space',
-            'multiple_use',
-            'namespace_no_leading_whitespace',
-            'no_blank_lines_after_class_opening',
-            'no_empty_lines_after_phpdocs',
-            'parenthesis',
-            'php_closing_tag',
-            'phpdoc_indent',
-            'phpdoc_no_access',
-            'phpdoc_no_empty_return',
-            'phpdoc_no_package',
-            'phpdoc_params',
-            'phpdoc_scalar',
-            'phpdoc_separation',
-            'phpdoc_to_comment',
-            'phpdoc_trim',
-            'phpdoc_types',
-            'phpdoc_var_without_name',
-            'remove_lines_between_uses',
-            'return',
-            'self_accessor',
-            'short_array_syntax',
-            'short_tag',
-            'single_line_after_imports',
-            'single_quote',
-            'spaces_before_semicolon',
-            'spaces_cast',
-            'ternary_spaces',
-            'trailing_spaces',
-            'trim_array_spaces',
-            'unused_use',
-            'visibility',
-            'whitespacy_lines'
-        )
-    )
-    ->finder($finder);
-

vendor/sebastian/code-unit-reverse-lookup/.travis.yml

@@ -1,25 +0,0 @@
-language: php
-
-php:
-  - 5.6
-  - 7.0
-  - 7.0snapshot
-  - 7.1
-  - 7.1snapshot
-  - master
-
-sudo: false
-
-before_install:
-  - composer self-update
-  - composer clear-cache
-
-install:
-  - travis_retry composer update --no-interaction --no-ansi --no-progress --no-suggest --optimize-autoloader --prefer-stable
-
-script:
-  - ./vendor/bin/phpunit
-
-notifications:
-  email: false
-

vendor/sebastian/code-unit-reverse-lookup/ChangeLog.md

@@ -2,14 +2,37 @@
 
 All notable changes to `sebastianbergmann/code-unit-reverse-lookup` are documented in this file using the [Keep a CHANGELOG](http://keepachangelog.com/) principles.
 
-## [1.0.2] - 2020-11-30
+## [2.0.3] - 2020-09-28
 
 ### Changed
 
-* Changed PHP version constraint in `composer.json` from `^5.6 || ^7.0` to `>=5.6`
+* Changed PHP version constraint in `composer.json` from `^7.3 || ^8.0` to `>=7.3`
+
+## [2.0.2] - 2020-06-26
+
+### Added
+
+* This component is now supported on PHP 8
+
+## [2.0.1] - 2020-06-15
+
+### Changed
+
+* Tests etc. are now ignored for archive exports
+
+## 2.0.0 - 2020-02-07
+
+### Removed
+
+* This component is no longer supported on PHP 5.6, PHP 7.0, PHP 7.1, and PHP 7.2
 
 ## 1.0.0 - 2016-02-13
 
+### Added
+
 * Initial release
 
-[1.0.2]: https://github.com/sebastianbergmann/code-unit-reverse-lookup/compare/1.0.1...1.0.2
+[2.0.3]: https://github.com/sebastianbergmann/code-unit-reverse-lookup/compare/2.0.2...2.0.3
+[2.0.2]: https://github.com/sebastianbergmann/code-unit-reverse-lookup/compare/2.0.1...2.0.2
+[2.0.1]: https://github.com/sebastianbergmann/code-unit-reverse-lookup/compare/2.0.0...2.0.1
+[2.0.0]: https://github.com/sebastianbergmann/code-unit-reverse-lookup/compare/1.0.0...2.0.0

vendor/sebastian/code-unit-reverse-lookup/LICENSE

@@ -1,6 +1,6 @@
 code-unit-reverse-lookup
 
-Copyright (c) 2016-2017, Sebastian Bergmann <sebastian@phpunit.de>.
+Copyright (c) 2016-2020, Sebastian Bergmann <sebastian@phpunit.de>.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

vendor/sebastian/code-unit-reverse-lookup/README.md

@@ -1,4 +1,7 @@
-# code-unit-reverse-lookup
+# sebastian/code-unit-reverse-lookup
+
+[![CI Status](https://github.com/sebastianbergmann/code-unit-reverse-lookup/workflows/CI/badge.svg)](https://github.com/sebastianbergmann/code-unit-reverse-lookup/actions)
+[![Type Coverage](https://shepherd.dev/github/sebastianbergmann/code-unit-reverse-lookup/coverage.svg)](https://shepherd.dev/github/sebastianbergmann/code-unit-reverse-lookup)
 
 Looks up which function or method a line of code belongs to.
 
@@ -6,9 +9,12 @@ Looks up which function or method a line of code belongs to.
 
 You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/):
 
-    composer require sebastian/code-unit-reverse-lookup
+```
+composer require sebastian/code-unit-reverse-lookup
+```
 
 If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency:
 
-    composer require --dev sebastian/code-unit-reverse-lookup
-
+```
+composer require --dev sebastian/code-unit-reverse-lookup
+```

vendor/sebastian/code-unit-reverse-lookup/build.xml

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="code-unit-reverse-lookup" default="setup">
-    <target name="setup" depends="clean,composer"/>
-
-    <target name="clean" description="Cleanup build artifacts">
-        <delete dir="${basedir}/vendor"/>
-        <delete file="${basedir}/composer.lock"/>
-    </target>
-
-    <target name="composer" depends="clean" description="Install dependencies with Composer">
-        <exec executable="composer" taskname="composer">
-            <arg value="update"/>
-            <arg value="--no-interaction"/>
-            <arg value="--no-progress"/>
-            <arg value="--no-ansi"/>
-            <arg value="--no-suggest"/>
-            <arg value="--optimize-autoloader"/>
-            <arg value="--prefer-stable"/>
-        </exec>
-    </target>
-</project>
-

vendor/sebastian/code-unit-reverse-lookup/composer.json

@@ -9,11 +9,19 @@
             "email": "sebastian@phpunit.de"
         }
     ],
+    "prefer-stable": true,
+    "config": {
+        "platform": {
+            "php": "7.3.0"
+        },
+        "optimize-autoloader": true,
+        "sort-packages": true
+    },
     "require": {
-        "php": ">=5.6"
+        "php": ">=7.3"
     },
     "require-dev": {
-        "phpunit/phpunit": "^8.5"
+        "phpunit/phpunit": "^9.3"
     },
     "autoload": {
         "classmap": [
@@ -22,7 +30,7 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "1.0.x-dev"
+            "dev-master": "2.0-dev"
         }
     }
 }

vendor/sebastian/code-unit-reverse-lookup/phpunit.xml

@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/5.4/phpunit.xsd"
-         bootstrap="vendor/autoload.php"
-         backupGlobals="false"
-         backupStaticAttributes="false"
-         beStrictAboutCoversAnnotation="true"
-         beStrictAboutOutputDuringTests="true"
-         beStrictAboutTestsThatDoNotTestAnything="true"
-         beStrictAboutTodoAnnotatedTests="true"
-         verbose="true">
-    <testsuite>
-        <directory suffix="Test.php">tests</directory>
-    </testsuite>
-
-    <filter>
-        <whitelist processUncoveredFilesFromWhitelist="true">
-            <directory suffix=".php">src</directory>
-        </whitelist>
-    </filter>
-</phpunit>

vendor/sebastian/code-unit-reverse-lookup/src/Wizard.php

@@ -1,15 +1,26 @@
-<?php
+<?php declare(strict_types=1);
 /*
- * This file is part of code-unit-reverse-lookup.
+ * This file is part of sebastian/code-unit-reverse-lookup.
  *
  * (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\CodeUnitReverseLookup;
 
+use function array_merge;
+use function assert;
+use function get_declared_classes;
+use function get_declared_traits;
+use function get_defined_functions;
+use function is_array;
+use function range;
+use ReflectionClass;
+use ReflectionFunction;
+use ReflectionFunctionAbstract;
+use ReflectionMethod;
+
 /**
  * @since Class available since Release 1.0.0
  */
@@ -44,25 +55,31 @@ class Wizard
 
         if (isset($this->lookupTable[$filename][$lineNumber])) {
             return $this->lookupTable[$filename][$lineNumber];
-        } else {
-            return $filename . ':' . $lineNumber;
         }
+
+        return $filename . ':' . $lineNumber;
     }
 
-    private function updateLookupTable()
+    private function updateLookupTable(): void
     {
         $this->processClassesAndTraits();
         $this->processFunctions();
     }
 
-    private function processClassesAndTraits()
+    private function processClassesAndTraits(): void
     {
-        foreach (array_merge(get_declared_classes(), get_declared_traits()) as $classOrTrait) {
+        $classes = get_declared_classes();
+        $traits  = get_declared_traits();
+
+        assert(is_array($classes));
+        assert(is_array($traits));
+
+        foreach (array_merge($classes, $traits) as $classOrTrait) {
             if (isset($this->processedClasses[$classOrTrait])) {
                 continue;
             }
 
-            $reflector = new \ReflectionClass($classOrTrait);
+            $reflector = new ReflectionClass($classOrTrait);
 
             foreach ($reflector->getMethods() as $method) {
                 $this->processFunctionOrMethod($method);
@@ -72,23 +89,20 @@ class Wizard
         }
     }
 
-    private function processFunctions()
+    private function processFunctions(): void
     {
         foreach (get_defined_functions()['user'] as $function) {
             if (isset($this->processedFunctions[$function])) {
                 continue;
             }
 
-            $this->processFunctionOrMethod(new \ReflectionFunction($function));
+            $this->processFunctionOrMethod(new ReflectionFunction($function));
 
             $this->processedFunctions[$function] = true;
         }
     }
 
-    /**
-     * @param \ReflectionFunctionAbstract $functionOrMethod
-     */
-    private function processFunctionOrMethod(\ReflectionFunctionAbstract $functionOrMethod)
+    private function processFunctionOrMethod(ReflectionFunctionAbstract $functionOrMethod): void
     {
         if ($functionOrMethod->isInternal()) {
             return;
@@ -96,7 +110,7 @@ class Wizard
 
         $name = $functionOrMethod->getName();
 
-        if ($functionOrMethod instanceof \ReflectionMethod) {
+        if ($functionOrMethod instanceof ReflectionMethod) {
             $name = $functionOrMethod->getDeclaringClass()->getName() . '::' . $name;
         }
 

vendor/sebastian/code-unit-reverse-lookup/tests/WizardTest.php

@@ -1,45 +0,0 @@
-<?php
-/*
- * This file is part of code-unit-reverse-lookup.
- *
- * (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\CodeUnitReverseLookup;
-
-use PHPUnit\Framework\TestCase;
-
-/**
- * @covers SebastianBergmann\CodeUnitReverseLookup\Wizard
- */
-class WizardTest extends TestCase
-{
-    /**
-     * @var Wizard
-     */
-    private $wizard;
-
-    protected function setUp(): void
-    {
-        $this->wizard = new Wizard;
-    }
-
-    public function testMethodCanBeLookedUp()
-    {
-        $this->assertEquals(
-            __METHOD__,
-            $this->wizard->lookup(__FILE__, __LINE__)
-        );
-    }
-
-    public function testReturnsFilenameAndLineNumberAsStringWhenNotInCodeUnit()
-    {
-        $this->assertEquals(
-            'file.php:1',
-            $this->wizard->lookup('file.php', 1)
-        );
-    }
-}

vendor/sebastian/code-unit/.psalm/baseline.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<files psalm-version="4.0.1@b1e2e30026936ef8d5bf6a354d1c3959b6231f44">
+  <file src="src/Mapper.php">
+    <ArgumentTypeCoercion occurrences="16">
+      <code>$firstPart</code>
+      <code>$firstPart</code>
+      <code>$firstPart</code>
+      <code>$firstPart</code>
+      <code>$firstPart</code>
+      <code>$firstPart</code>
+      <code>$firstPart</code>
+      <code>$firstPart</code>
+      <code>$firstPart</code>
+      <code>$secondPart</code>
+      <code>$unit</code>
+      <code>$unit</code>
+      <code>$unit</code>
+      <code>$unit</code>
+      <code>$unit</code>
+      <code>$unit</code>
+    </ArgumentTypeCoercion>
+  </file>
+</files>

vendor/sebastian/code-unit/.psalm/config.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<psalm
+    totallyTyped="true"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns="https://getpsalm.org/schema/config"
+    xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
+    resolveFromConfigFile="false"
+    errorBaseline=".psalm/baseline.xml"
+>
+    <projectFiles>
+        <directory name="src" />
+        <ignoreFiles>
+            <directory name="vendor" />
+        </ignoreFiles>
+    </projectFiles>
+</psalm>

vendor/sebastian/code-unit/ChangeLog.md

@@ -0,0 +1,65 @@
+# ChangeLog
+
+All notable changes are documented in this file using the [Keep a CHANGELOG](http://keepachangelog.com/) principles.
+
+## [1.0.8] - 2020-10-26
+
+### Fixed
+
+* `SebastianBergmann\CodeUnit\Exception` now correctly extends `\Throwable`
+
+## [1.0.7] - 2020-10-02
+
+### Fixed
+
+* `SebastianBergmann\CodeUnit\Mapper::stringToCodeUnits()` no longer attempts to create `CodeUnit` objects for code units that are not declared in userland
+
+## [1.0.6] - 2020-09-28
+
+### Changed
+
+* Changed PHP version constraint in `composer.json` from `^7.3 || ^8.0` to `>=7.3`
+
+## [1.0.5] - 2020-06-26
+
+### Fixed
+
+* [#3](https://github.com/sebastianbergmann/code-unit/issues/3): Regression in 1.0.4
+
+## [1.0.4] - 2020-06-26
+
+### Added
+
+* This component is now supported on PHP 8
+
+## [1.0.3] - 2020-06-15
+
+### Changed
+
+* Tests etc. are now ignored for archive exports
+
+## [1.0.2] - 2020-04-30
+
+### Fixed
+
+* `Mapper::stringToCodeUnits()` raised the wrong exception for `Class::method` when a class named `Class` exists but does not have a method named `method`
+
+## [1.0.1] - 2020-04-27
+
+### Fixed
+
+* [#2](https://github.com/sebastianbergmann/code-unit/issues/2): `Mapper::stringToCodeUnits()` breaks when `ClassName<extended>` is used for class that extends built-in class
+
+## [1.0.0] - 2020-03-30
+
+* Initial release
+
+[1.0.8]: https://github.com/sebastianbergmann/code-unit/compare/1.0.7...1.0.8
+[1.0.7]: https://github.com/sebastianbergmann/code-unit/compare/1.0.6...1.0.7
+[1.0.6]: https://github.com/sebastianbergmann/code-unit/compare/1.0.5...1.0.6
+[1.0.5]: https://github.com/sebastianbergmann/code-unit/compare/1.0.4...1.0.5
+[1.0.4]: https://github.com/sebastianbergmann/code-unit/compare/1.0.3...1.0.4
+[1.0.3]: https://github.com/sebastianbergmann/code-unit/compare/1.0.2...1.0.3
+[1.0.2]: https://github.com/sebastianbergmann/code-unit/compare/1.0.1...1.0.2
+[1.0.1]: https://github.com/sebastianbergmann/code-unit/compare/1.0.0...1.0.1
+[1.0.0]: https://github.com/sebastianbergmann/code-unit/compare/530c3900e5db9bcb8516da545bef0d62536cedaa...1.0.0

vendor/sebastian/code-unit/LICENSE

@@ -0,0 +1,33 @@
+sebastian/code-unit
+
+Copyright (c) 2020, Sebastian Bergmann <sebastian@phpunit.de>.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in
+   the documentation and/or other materials provided with the
+   distribution.
+
+ * Neither the name of Sebastian Bergmann nor the names of his
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

vendor/sebastian/code-unit/README.md

@@ -0,0 +1,17 @@
+# sebastian/code-unit
+
+Collection of value objects that represent the PHP code units.
+
+## Installation
+
+You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/):
+
+```
+composer require sebastian/code-unit
+```
+
+If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency:
+
+```
+composer require --dev sebastian/code-unit
+```

vendor/sebastian/code-unit/composer.json

@@ -0,0 +1,50 @@
+{
+    "name": "sebastian/code-unit",
+    "description": "Collection of value objects that represent the PHP code units",
+    "type": "library",
+    "homepage": "https://github.com/sebastianbergmann/code-unit",
+    "license": "BSD-3-Clause",
+    "authors": [
+        {
+            "name": "Sebastian Bergmann",
+            "email": "sebastian@phpunit.de",
+            "role": "lead"
+        }
+    ],
+    "support": {
+        "issues": "https://github.com/sebastianbergmann/code-unit/issues"
+    },
+    "prefer-stable": true,
+    "require": {
+        "php": ">=7.3"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "^9.3"
+    },
+    "config": {
+        "platform": {
+            "php": "7.3.0"
+        },
+        "optimize-autoloader": true,
+        "sort-packages": true
+    },
+    "autoload": {
+        "classmap": [
+            "src/"
+        ]
+    },
+    "autoload-dev": {
+        "classmap": [
+            "tests/_fixture"
+        ],
+        "files": [
+            "tests/_fixture/file_with_multiple_code_units.php",
+            "tests/_fixture/function.php"
+        ]
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "1.0-dev"
+        }
+    }
+}

vendor/sebastian/code-unit/src/ClassMethodUnit.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+/**
+ * @psalm-immutable
+ */
+final class ClassMethodUnit extends CodeUnit
+{
+    /**
+     * @psalm-assert-if-true ClassMethodUnit $this
+     */
+    public function isClassMethod(): bool
+    {
+        return true;
+    }
+}

vendor/sebastian/code-unit/src/ClassUnit.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+/**
+ * @psalm-immutable
+ */
+final class ClassUnit extends CodeUnit
+{
+    /**
+     * @psalm-assert-if-true ClassUnit $this
+     */
+    public function isClass(): bool
+    {
+        return true;
+    }
+}

vendor/sebastian/code-unit/src/CodeUnit.php

@@ -0,0 +1,445 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+use function range;
+use function sprintf;
+use ReflectionClass;
+use ReflectionFunction;
+use ReflectionMethod;
+
+/**
+ * @psalm-immutable
+ */
+abstract class CodeUnit
+{
+    /**
+     * @var string
+     */
+    private $name;
+
+    /**
+     * @var string
+     */
+    private $sourceFileName;
+
+    /**
+     * @var array
+     * @psalm-var list<int>
+     */
+    private $sourceLines;
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws InvalidCodeUnitException
+     * @throws ReflectionException
+     */
+    public static function forClass(string $className): ClassUnit
+    {
+        self::ensureUserDefinedClass($className);
+
+        $reflector = self::reflectorForClass($className);
+
+        return new ClassUnit(
+            $className,
+            $reflector->getFileName(),
+            range(
+                $reflector->getStartLine(),
+                $reflector->getEndLine()
+            )
+        );
+    }
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws InvalidCodeUnitException
+     * @throws ReflectionException
+     */
+    public static function forClassMethod(string $className, string $methodName): ClassMethodUnit
+    {
+        self::ensureUserDefinedClass($className);
+
+        $reflector = self::reflectorForClassMethod($className, $methodName);
+
+        return new ClassMethodUnit(
+            $className . '::' . $methodName,
+            $reflector->getFileName(),
+            range(
+                $reflector->getStartLine(),
+                $reflector->getEndLine()
+            )
+        );
+    }
+
+    /**
+     * @psalm-param class-string $interfaceName
+     *
+     * @throws InvalidCodeUnitException
+     * @throws ReflectionException
+     */
+    public static function forInterface(string $interfaceName): InterfaceUnit
+    {
+        self::ensureUserDefinedInterface($interfaceName);
+
+        $reflector = self::reflectorForClass($interfaceName);
+
+        return new InterfaceUnit(
+            $interfaceName,
+            $reflector->getFileName(),
+            range(
+                $reflector->getStartLine(),
+                $reflector->getEndLine()
+            )
+        );
+    }
+
+    /**
+     * @psalm-param class-string $interfaceName
+     *
+     * @throws InvalidCodeUnitException
+     * @throws ReflectionException
+     */
+    public static function forInterfaceMethod(string $interfaceName, string $methodName): InterfaceMethodUnit
+    {
+        self::ensureUserDefinedInterface($interfaceName);
+
+        $reflector = self::reflectorForClassMethod($interfaceName, $methodName);
+
+        return new InterfaceMethodUnit(
+            $interfaceName . '::' . $methodName,
+            $reflector->getFileName(),
+            range(
+                $reflector->getStartLine(),
+                $reflector->getEndLine()
+            )
+        );
+    }
+
+    /**
+     * @psalm-param class-string $traitName
+     *
+     * @throws InvalidCodeUnitException
+     * @throws ReflectionException
+     */
+    public static function forTrait(string $traitName): TraitUnit
+    {
+        self::ensureUserDefinedTrait($traitName);
+
+        $reflector = self::reflectorForClass($traitName);
+
+        return new TraitUnit(
+            $traitName,
+            $reflector->getFileName(),
+            range(
+                $reflector->getStartLine(),
+                $reflector->getEndLine()
+            )
+        );
+    }
+
+    /**
+     * @psalm-param class-string $traitName
+     *
+     * @throws InvalidCodeUnitException
+     * @throws ReflectionException
+     */
+    public static function forTraitMethod(string $traitName, string $methodName): TraitMethodUnit
+    {
+        self::ensureUserDefinedTrait($traitName);
+
+        $reflector = self::reflectorForClassMethod($traitName, $methodName);
+
+        return new TraitMethodUnit(
+            $traitName . '::' . $methodName,
+            $reflector->getFileName(),
+            range(
+                $reflector->getStartLine(),
+                $reflector->getEndLine()
+            )
+        );
+    }
+
+    /**
+     * @psalm-param callable-string $functionName
+     *
+     * @throws InvalidCodeUnitException
+     * @throws ReflectionException
+     */
+    public static function forFunction(string $functionName): FunctionUnit
+    {
+        $reflector = self::reflectorForFunction($functionName);
+
+        if (!$reflector->isUserDefined()) {
+            throw new InvalidCodeUnitException(
+                sprintf(
+                    '"%s" is not a user-defined function',
+                    $functionName
+                )
+            );
+        }
+
+        return new FunctionUnit(
+            $functionName,
+            $reflector->getFileName(),
+            range(
+                $reflector->getStartLine(),
+                $reflector->getEndLine()
+            )
+        );
+    }
+
+    /**
+     * @psalm-param list<int> $sourceLines
+     */
+    private function __construct(string $name, string $sourceFileName, array $sourceLines)
+    {
+        $this->name           = $name;
+        $this->sourceFileName = $sourceFileName;
+        $this->sourceLines    = $sourceLines;
+    }
+
+    public function name(): string
+    {
+        return $this->name;
+    }
+
+    public function sourceFileName(): string
+    {
+        return $this->sourceFileName;
+    }
+
+    /**
+     * @psalm-return list<int>
+     */
+    public function sourceLines(): array
+    {
+        return $this->sourceLines;
+    }
+
+    public function isClass(): bool
+    {
+        return false;
+    }
+
+    public function isClassMethod(): bool
+    {
+        return false;
+    }
+
+    public function isInterface(): bool
+    {
+        return false;
+    }
+
+    public function isInterfaceMethod(): bool
+    {
+        return false;
+    }
+
+    public function isTrait(): bool
+    {
+        return false;
+    }
+
+    public function isTraitMethod(): bool
+    {
+        return false;
+    }
+
+    public function isFunction(): bool
+    {
+        return false;
+    }
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws InvalidCodeUnitException
+     */
+    private static function ensureUserDefinedClass(string $className): void
+    {
+        try {
+            $reflector = new ReflectionClass($className);
+
+            if ($reflector->isInterface()) {
+                throw new InvalidCodeUnitException(
+                    sprintf(
+                        '"%s" is an interface and not a class',
+                        $className
+                    )
+                );
+            }
+
+            if ($reflector->isTrait()) {
+                throw new InvalidCodeUnitException(
+                    sprintf(
+                        '"%s" is a trait and not a class',
+                        $className
+                    )
+                );
+            }
+
+            if (!$reflector->isUserDefined()) {
+                throw new InvalidCodeUnitException(
+                    sprintf(
+                        '"%s" is not a user-defined class',
+                        $className
+                    )
+                );
+            }
+            // @codeCoverageIgnoreStart
+        } catch (\ReflectionException $e) {
+            throw new ReflectionException(
+                $e->getMessage(),
+                (int) $e->getCode(),
+                $e
+            );
+        }
+        // @codeCoverageIgnoreEnd
+    }
+
+    /**
+     * @psalm-param class-string $interfaceName
+     *
+     * @throws InvalidCodeUnitException
+     */
+    private static function ensureUserDefinedInterface(string $interfaceName): void
+    {
+        try {
+            $reflector = new ReflectionClass($interfaceName);
+
+            if (!$reflector->isInterface()) {
+                throw new InvalidCodeUnitException(
+                    sprintf(
+                        '"%s" is not an interface',
+                        $interfaceName
+                    )
+                );
+            }
+
+            if (!$reflector->isUserDefined()) {
+                throw new InvalidCodeUnitException(
+                    sprintf(
+                        '"%s" is not a user-defined interface',
+                        $interfaceName
+                    )
+                );
+            }
+            // @codeCoverageIgnoreStart
+        } catch (\ReflectionException $e) {
+            throw new ReflectionException(
+                $e->getMessage(),
+                (int) $e->getCode(),
+                $e
+            );
+        }
+        // @codeCoverageIgnoreEnd
+    }
+
+    /**
+     * @psalm-param class-string $traitName
+     *
+     * @throws InvalidCodeUnitException
+     */
+    private static function ensureUserDefinedTrait(string $traitName): void
+    {
+        try {
+            $reflector = new ReflectionClass($traitName);
+
+            if (!$reflector->isTrait()) {
+                throw new InvalidCodeUnitException(
+                    sprintf(
+                        '"%s" is not a trait',
+                        $traitName
+                    )
+                );
+            }
+
+            // @codeCoverageIgnoreStart
+            if (!$reflector->isUserDefined()) {
+                throw new InvalidCodeUnitException(
+                    sprintf(
+                        '"%s" is not a user-defined trait',
+                        $traitName
+                    )
+                );
+            }
+        } catch (\ReflectionException $e) {
+            throw new ReflectionException(
+                $e->getMessage(),
+                (int) $e->getCode(),
+                $e
+            );
+        }
+        // @codeCoverageIgnoreEnd
+    }
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws ReflectionException
+     */
+    private static function reflectorForClass(string $className): ReflectionClass
+    {
+        try {
+            return new ReflectionClass($className);
+            // @codeCoverageIgnoreStart
+        } catch (\ReflectionException $e) {
+            throw new ReflectionException(
+                $e->getMessage(),
+                (int) $e->getCode(),
+                $e
+            );
+        }
+        // @codeCoverageIgnoreEnd
+    }
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws ReflectionException
+     */
+    private static function reflectorForClassMethod(string $className, string $methodName): ReflectionMethod
+    {
+        try {
+            return new ReflectionMethod($className, $methodName);
+            // @codeCoverageIgnoreStart
+        } catch (\ReflectionException $e) {
+            throw new ReflectionException(
+                $e->getMessage(),
+                (int) $e->getCode(),
+                $e
+            );
+        }
+        // @codeCoverageIgnoreEnd
+    }
+
+    /**
+     * @psalm-param callable-string $functionName
+     *
+     * @throws ReflectionException
+     */
+    private static function reflectorForFunction(string $functionName): ReflectionFunction
+    {
+        try {
+            return new ReflectionFunction($functionName);
+            // @codeCoverageIgnoreStart
+        } catch (\ReflectionException $e) {
+            throw new ReflectionException(
+                $e->getMessage(),
+                (int) $e->getCode(),
+                $e
+            );
+        }
+        // @codeCoverageIgnoreEnd
+    }
+}

vendor/sebastian/code-unit/src/CodeUnitCollection.php

@@ -0,0 +1,84 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+use function array_merge;
+use function count;
+use Countable;
+use IteratorAggregate;
+
+final class CodeUnitCollection implements Countable, IteratorAggregate
+{
+    /**
+     * @psalm-var list<CodeUnit>
+     */
+    private $codeUnits = [];
+
+    /**
+     * @psalm-param list<CodeUnit> $items
+     */
+    public static function fromArray(array $items): self
+    {
+        $collection = new self;
+
+        foreach ($items as $item) {
+            $collection->add($item);
+        }
+
+        return $collection;
+    }
+
+    public static function fromList(CodeUnit ...$items): self
+    {
+        return self::fromArray($items);
+    }
+
+    private function __construct()
+    {
+    }
+
+    /**
+     * @psalm-return list<CodeUnit>
+     */
+    public function asArray(): array
+    {
+        return $this->codeUnits;
+    }
+
+    public function getIterator(): CodeUnitCollectionIterator
+    {
+        return new CodeUnitCollectionIterator($this);
+    }
+
+    public function count(): int
+    {
+        return count($this->codeUnits);
+    }
+
+    public function isEmpty(): bool
+    {
+        return empty($this->codeUnits);
+    }
+
+    public function mergeWith(self $other): self
+    {
+        return self::fromArray(
+            array_merge(
+                $this->asArray(),
+                $other->asArray()
+            )
+        );
+    }
+
+    private function add(CodeUnit $item): void
+    {
+        $this->codeUnits[] = $item;
+    }
+}

vendor/sebastian/code-unit/src/CodeUnitCollectionIterator.php

@@ -0,0 +1,55 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+use Iterator;
+
+final class CodeUnitCollectionIterator implements Iterator
+{
+    /**
+     * @psalm-var list<CodeUnit>
+     */
+    private $codeUnits;
+
+    /**
+     * @var int
+     */
+    private $position = 0;
+
+    public function __construct(CodeUnitCollection $collection)
+    {
+        $this->codeUnits = $collection->asArray();
+    }
+
+    public function rewind(): void
+    {
+        $this->position = 0;
+    }
+
+    public function valid(): bool
+    {
+        return isset($this->codeUnits[$this->position]);
+    }
+
+    public function key(): int
+    {
+        return $this->position;
+    }
+
+    public function current(): CodeUnit
+    {
+        return $this->codeUnits[$this->position];
+    }
+
+    public function next(): void
+    {
+        $this->position++;
+    }
+}

vendor/sebastian/code-unit/src/FunctionUnit.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+/**
+ * @psalm-immutable
+ */
+final class FunctionUnit extends CodeUnit
+{
+    /**
+     * @psalm-assert-if-true FunctionUnit $this
+     */
+    public function isFunction(): bool
+    {
+        return true;
+    }
+}

vendor/sebastian/code-unit/src/InterfaceMethodUnit.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+/**
+ * @psalm-immutable
+ */
+final class InterfaceMethodUnit extends CodeUnit
+{
+    /**
+     * @psalm-assert-if-true InterfaceMethod $this
+     */
+    public function isInterfaceMethod(): bool
+    {
+        return true;
+    }
+}

vendor/sebastian/code-unit/src/InterfaceUnit.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+/**
+ * @psalm-immutable
+ */
+final class InterfaceUnit extends CodeUnit
+{
+    /**
+     * @psalm-assert-if-true InterfaceUnit $this
+     */
+    public function isInterface(): bool
+    {
+        return true;
+    }
+}

vendor/sebastian/code-unit/src/Mapper.php

@@ -0,0 +1,414 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+use function array_keys;
+use function array_merge;
+use function array_unique;
+use function array_values;
+use function class_exists;
+use function explode;
+use function function_exists;
+use function interface_exists;
+use function ksort;
+use function method_exists;
+use function sort;
+use function sprintf;
+use function str_replace;
+use function strpos;
+use function trait_exists;
+use ReflectionClass;
+use ReflectionFunction;
+use ReflectionMethod;
+
+final class Mapper
+{
+    /**
+     * @psalm-return array<string,list<int>>
+     */
+    public function codeUnitsToSourceLines(CodeUnitCollection $codeUnits): array
+    {
+        $result = [];
+
+        foreach ($codeUnits as $codeUnit) {
+            $sourceFileName = $codeUnit->sourceFileName();
+
+            if (!isset($result[$sourceFileName])) {
+                $result[$sourceFileName] = [];
+            }
+
+            $result[$sourceFileName] = array_merge($result[$sourceFileName], $codeUnit->sourceLines());
+        }
+
+        foreach (array_keys($result) as $sourceFileName) {
+            $result[$sourceFileName] = array_values(array_unique($result[$sourceFileName]));
+
+            sort($result[$sourceFileName]);
+        }
+
+        ksort($result);
+
+        return $result;
+    }
+
+    /**
+     * @throws InvalidCodeUnitException
+     * @throws ReflectionException
+     */
+    public function stringToCodeUnits(string $unit): CodeUnitCollection
+    {
+        if (strpos($unit, '::') !== false) {
+            [$firstPart, $secondPart] = explode('::', $unit);
+
+            if (empty($firstPart) && $this->isUserDefinedFunction($secondPart)) {
+                return CodeUnitCollection::fromList(CodeUnit::forFunction($secondPart));
+            }
+
+            if ($this->isUserDefinedClass($firstPart)) {
+                if ($secondPart === '<public>') {
+                    return $this->publicMethodsOfClass($firstPart);
+                }
+
+                if ($secondPart === '<!public>') {
+                    return $this->protectedAndPrivateMethodsOfClass($firstPart);
+                }
+
+                if ($secondPart === '<protected>') {
+                    return $this->protectedMethodsOfClass($firstPart);
+                }
+
+                if ($secondPart === '<!protected>') {
+                    return $this->publicAndPrivateMethodsOfClass($firstPart);
+                }
+
+                if ($secondPart === '<private>') {
+                    return $this->privateMethodsOfClass($firstPart);
+                }
+
+                if ($secondPart === '<!private>') {
+                    return $this->publicAndProtectedMethodsOfClass($firstPart);
+                }
+
+                if ($this->isUserDefinedMethod($firstPart, $secondPart)) {
+                    return CodeUnitCollection::fromList(CodeUnit::forClassMethod($firstPart, $secondPart));
+                }
+            }
+
+            if ($this->isUserDefinedInterface($firstPart)) {
+                return CodeUnitCollection::fromList(CodeUnit::forInterfaceMethod($firstPart, $secondPart));
+            }
+
+            if ($this->isUserDefinedTrait($firstPart)) {
+                return CodeUnitCollection::fromList(CodeUnit::forTraitMethod($firstPart, $secondPart));
+            }
+        } else {
+            if ($this->isUserDefinedClass($unit)) {
+                $units = [CodeUnit::forClass($unit)];
+
+                foreach ($this->reflectorForClass($unit)->getTraits() as $trait) {
+                    if (!$trait->isUserDefined()) {
+                        // @codeCoverageIgnoreStart
+                        continue;
+                        // @codeCoverageIgnoreEnd
+                    }
+
+                    $units[] = CodeUnit::forTrait($trait->getName());
+                }
+
+                return CodeUnitCollection::fromArray($units);
+            }
+
+            if ($this->isUserDefinedInterface($unit)) {
+                return CodeUnitCollection::fromList(CodeUnit::forInterface($unit));
+            }
+
+            if ($this->isUserDefinedTrait($unit)) {
+                return CodeUnitCollection::fromList(CodeUnit::forTrait($unit));
+            }
+
+            if ($this->isUserDefinedFunction($unit)) {
+                return CodeUnitCollection::fromList(CodeUnit::forFunction($unit));
+            }
+
+            $unit = str_replace('<extended>', '', $unit);
+
+            if ($this->isUserDefinedClass($unit)) {
+                return $this->classAndParentClassesAndTraits($unit);
+            }
+        }
+
+        throw new InvalidCodeUnitException(
+            sprintf(
+                '"%s" is not a valid code unit',
+                $unit
+            )
+        );
+    }
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws ReflectionException
+     */
+    private function publicMethodsOfClass(string $className): CodeUnitCollection
+    {
+        return $this->methodsOfClass($className, ReflectionMethod::IS_PUBLIC);
+    }
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws ReflectionException
+     */
+    private function publicAndProtectedMethodsOfClass(string $className): CodeUnitCollection
+    {
+        return $this->methodsOfClass($className, ReflectionMethod::IS_PUBLIC | ReflectionMethod::IS_PROTECTED);
+    }
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws ReflectionException
+     */
+    private function publicAndPrivateMethodsOfClass(string $className): CodeUnitCollection
+    {
+        return $this->methodsOfClass($className, ReflectionMethod::IS_PUBLIC | ReflectionMethod::IS_PRIVATE);
+    }
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws ReflectionException
+     */
+    private function protectedMethodsOfClass(string $className): CodeUnitCollection
+    {
+        return $this->methodsOfClass($className, ReflectionMethod::IS_PROTECTED);
+    }
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws ReflectionException
+     */
+    private function protectedAndPrivateMethodsOfClass(string $className): CodeUnitCollection
+    {
+        return $this->methodsOfClass($className, ReflectionMethod::IS_PROTECTED | ReflectionMethod::IS_PRIVATE);
+    }
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws ReflectionException
+     */
+    private function privateMethodsOfClass(string $className): CodeUnitCollection
+    {
+        return $this->methodsOfClass($className, ReflectionMethod::IS_PRIVATE);
+    }
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws ReflectionException
+     */
+    private function methodsOfClass(string $className, int $filter): CodeUnitCollection
+    {
+        $units = [];
+
+        foreach ($this->reflectorForClass($className)->getMethods($filter) as $method) {
+            if (!$method->isUserDefined()) {
+                continue;
+            }
+
+            $units[] = CodeUnit::forClassMethod($className, $method->getName());
+        }
+
+        return CodeUnitCollection::fromArray($units);
+    }
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws ReflectionException
+     */
+    private function classAndParentClassesAndTraits(string $className): CodeUnitCollection
+    {
+        $units = [CodeUnit::forClass($className)];
+
+        $reflector = $this->reflectorForClass($className);
+
+        foreach ($this->reflectorForClass($className)->getTraits() as $trait) {
+            if (!$trait->isUserDefined()) {
+                // @codeCoverageIgnoreStart
+                continue;
+                // @codeCoverageIgnoreEnd
+            }
+
+            $units[] = CodeUnit::forTrait($trait->getName());
+        }
+
+        while ($reflector = $reflector->getParentClass()) {
+            if (!$reflector->isUserDefined()) {
+                break;
+            }
+
+            $units[] = CodeUnit::forClass($reflector->getName());
+
+            foreach ($reflector->getTraits() as $trait) {
+                if (!$trait->isUserDefined()) {
+                    // @codeCoverageIgnoreStart
+                    continue;
+                    // @codeCoverageIgnoreEnd
+                }
+
+                $units[] = CodeUnit::forTrait($trait->getName());
+            }
+        }
+
+        return CodeUnitCollection::fromArray($units);
+    }
+
+    /**
+     * @psalm-param class-string $className
+     *
+     * @throws ReflectionException
+     */
+    private function reflectorForClass(string $className): ReflectionClass
+    {
+        try {
+            return new ReflectionClass($className);
+            // @codeCoverageIgnoreStart
+        } catch (\ReflectionException $e) {
+            throw new ReflectionException(
+                $e->getMessage(),
+                (int) $e->getCode(),
+                $e
+            );
+        }
+        // @codeCoverageIgnoreEnd
+    }
+
+    /**
+     * @throws ReflectionException
+     */
+    private function isUserDefinedFunction(string $functionName): bool
+    {
+        if (!function_exists($functionName)) {
+            return false;
+        }
+
+        try {
+            return (new ReflectionFunction($functionName))->isUserDefined();
+            // @codeCoverageIgnoreStart
+        } catch (\ReflectionException $e) {
+            throw new ReflectionException(
+                $e->getMessage(),
+                (int) $e->getCode(),
+                $e
+            );
+        }
+        // @codeCoverageIgnoreEnd
+    }
+
+    /**
+     * @throws ReflectionException
+     */
+    private function isUserDefinedClass(string $className): bool
+    {
+        if (!class_exists($className)) {
+            return false;
+        }
+
+        try {
+            return (new ReflectionClass($className))->isUserDefined();
+            // @codeCoverageIgnoreStart
+        } catch (\ReflectionException $e) {
+            throw new ReflectionException(
+                $e->getMessage(),
+                (int) $e->getCode(),
+                $e
+            );
+        }
+        // @codeCoverageIgnoreEnd
+    }
+
+    /**
+     * @throws ReflectionException
+     */
+    private function isUserDefinedInterface(string $interfaceName): bool
+    {
+        if (!interface_exists($interfaceName)) {
+            return false;
+        }
+
+        try {
+            return (new ReflectionClass($interfaceName))->isUserDefined();
+            // @codeCoverageIgnoreStart
+        } catch (\ReflectionException $e) {
+            throw new ReflectionException(
+                $e->getMessage(),
+                (int) $e->getCode(),
+                $e
+            );
+        }
+        // @codeCoverageIgnoreEnd
+    }
+
+    /**
+     * @throws ReflectionException
+     */
+    private function isUserDefinedTrait(string $traitName): bool
+    {
+        if (!trait_exists($traitName)) {
+            return false;
+        }
+
+        try {
+            return (new ReflectionClass($traitName))->isUserDefined();
+            // @codeCoverageIgnoreStart
+        } catch (\ReflectionException $e) {
+            throw new ReflectionException(
+                $e->getMessage(),
+                (int) $e->getCode(),
+                $e
+            );
+        }
+        // @codeCoverageIgnoreEnd
+    }
+
+    /**
+     * @throws ReflectionException
+     */
+    private function isUserDefinedMethod(string $className, string $methodName): bool
+    {
+        if (!class_exists($className)) {
+            // @codeCoverageIgnoreStart
+            return false;
+            // @codeCoverageIgnoreEnd
+        }
+
+        if (!method_exists($className, $methodName)) {
+            // @codeCoverageIgnoreStart
+            return false;
+            // @codeCoverageIgnoreEnd
+        }
+
+        try {
+            return (new ReflectionMethod($className, $methodName))->isUserDefined();
+            // @codeCoverageIgnoreStart
+        } catch (\ReflectionException $e) {
+            throw new ReflectionException(
+                $e->getMessage(),
+                (int) $e->getCode(),
+                $e
+            );
+        }
+        // @codeCoverageIgnoreEnd
+    }
+}

vendor/sebastian/code-unit/src/TraitMethodUnit.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+/**
+ * @psalm-immutable
+ */
+final class TraitMethodUnit extends CodeUnit
+{
+    /**
+     * @psalm-assert-if-true TraitMethodUnit $this
+     */
+    public function isTraitMethod(): bool
+    {
+        return true;
+    }
+}

vendor/sebastian/code-unit/src/TraitUnit.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+/**
+ * @psalm-immutable
+ */
+final class TraitUnit extends CodeUnit
+{
+    /**
+     * @psalm-assert-if-true TraitUnit $this
+     */
+    public function isTrait(): bool
+    {
+        return true;
+    }
+}

vendor/sebastian/code-unit/src/exceptions/Exception.php

@@ -1,14 +1,16 @@
 <?php declare(strict_types=1);
 /*
- * This file is part of sebastian/type.
+ * This file is part of sebastian/code-unit.
  *
  * (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\Type\TestFixture;
+namespace SebastianBergmann\CodeUnit;
 
-class ChildClass extends ParentClass
+use Throwable;
+
+interface Exception extends Throwable
 {
 }

vendor/sebastian/code-unit/src/exceptions/InvalidCodeUnitException.php

@@ -0,0 +1,16 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+use RuntimeException;
+
+final class InvalidCodeUnitException extends RuntimeException implements Exception
+{
+}

vendor/sebastian/code-unit/src/exceptions/NoTraitException.php

@@ -0,0 +1,16 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+use RuntimeException;
+
+final class NoTraitException extends RuntimeException implements Exception
+{
+}

vendor/sebastian/code-unit/src/exceptions/ReflectionException.php

@@ -0,0 +1,16 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/code-unit.
+ *
+ * (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\CodeUnit;
+
+use RuntimeException;
+
+final class ReflectionException extends RuntimeException implements Exception
+{
+}

vendor/sebastian/comparator/ChangeLog.md

@@ -2,6 +2,60 @@
 
 All notable changes are documented in this file using the [Keep a CHANGELOG](http://keepachangelog.com/) principles.
 
+## [4.0.8] - 2022-09-14
+
+### Fixed
+
+* [#102](https://github.com/sebastianbergmann/comparator/pull/102): Fix `float` comparison precision
+
+## [4.0.7] - 2022-09-14
+
+### Fixed
+
+* [#99](https://github.com/sebastianbergmann/comparator/pull/99): Fix weak comparison between `'0'` and `false`
+
+## [4.0.6] - 2020-10-26
+
+### Fixed
+
+* `SebastianBergmann\Comparator\Exception` now correctly extends `\Throwable`
+
+## [4.0.5] - 2020-09-30
+
+### Fixed
+
+* [#89](https://github.com/sebastianbergmann/comparator/pull/89): Handle PHP 8 `ValueError`
+
+## [4.0.4] - 2020-09-28
+
+### Changed
+
+* Changed PHP version constraint in `composer.json` from `^7.3 || ^8.0` to `>=7.3`
+
+## [4.0.3] - 2020-06-26
+
+### Added
+
+* This component is now supported on PHP 8
+
+## [4.0.2] - 2020-06-15
+
+### Fixed
+
+* [#85](https://github.com/sebastianbergmann/comparator/issues/85): Version 4.0.1 breaks backward compatibility
+
+## [4.0.1] - 2020-06-15
+
+### Changed
+
+* Tests etc. are now ignored for archive exports
+
+## [4.0.0] - 2020-02-07
+
+### Removed
+
+* Removed support for PHP 7.1 and PHP 7.2
+
 ## [3.0.5] - 2022-09-14
 
 ### Fixed
@@ -68,6 +122,15 @@ All notable changes are documented in this file using the [Keep a CHANGELOG](htt
 * Added `SebastianBergmann\Comparator\Factory::reset()` to unregister all non-default comparators
 * Added support for `phpunit/phpunit-mock-objects` version `^5.0`
 
+[4.0.8]: https://github.com/sebastianbergmann/comparator/compare/4.0.7...4.0.8
+[4.0.7]: https://github.com/sebastianbergmann/comparator/compare/4.0.6...4.0.7
+[4.0.6]: https://github.com/sebastianbergmann/comparator/compare/4.0.5...4.0.6
+[4.0.5]: https://github.com/sebastianbergmann/comparator/compare/4.0.4...4.0.5
+[4.0.4]: https://github.com/sebastianbergmann/comparator/compare/4.0.3...4.0.4
+[4.0.3]: https://github.com/sebastianbergmann/comparator/compare/4.0.2...4.0.3
+[4.0.2]: https://github.com/sebastianbergmann/comparator/compare/4.0.1...4.0.2
+[4.0.1]: https://github.com/sebastianbergmann/comparator/compare/4.0.0...4.0.1
+[4.0.0]: https://github.com/sebastianbergmann/comparator/compare/3.0.5...4.0.0
 [3.0.5]: https://github.com/sebastianbergmann/comparator/compare/3.0.4...3.0.5
 [3.0.4]: https://github.com/sebastianbergmann/comparator/compare/3.0.3...3.0.4
 [3.0.3]: https://github.com/sebastianbergmann/comparator/compare/3.0.2...3.0.3

vendor/sebastian/comparator/LICENSE

@@ -1,6 +1,6 @@
 Comparator
 
-Copyright (c) 2002-2018, Sebastian Bergmann <sebastian@phpunit.de>.
+Copyright (c) 2002-2020, Sebastian Bergmann <sebastian@phpunit.de>.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

vendor/sebastian/comparator/README.md

@@ -1,6 +1,7 @@
-[![Build Status](https://travis-ci.org/sebastianbergmann/comparator.svg?branch=master)](https://travis-ci.org/sebastianbergmann/comparator)
+# sebastian/comparator
 
-# Comparator
+[![CI Status](https://github.com/sebastianbergmann/comparator/workflows/CI/badge.svg)](https://github.com/sebastianbergmann/comparator/actions)
+[![Type Coverage](https://shepherd.dev/github/sebastianbergmann/comparator/coverage.svg)](https://shepherd.dev/github/sebastianbergmann/comparator)
 
 This component provides the functionality to compare PHP values for equality.
 
@@ -8,11 +9,15 @@ This component provides the functionality to compare PHP values for equality.
 
 You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/):
 
-    composer require sebastian/comparator
+```
+composer require sebastian/comparator
+```
 
 If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency:
 
-    composer require --dev sebastian/comparator
+```
+composer require --dev sebastian/comparator
+```
 
 ## Usage
 
@@ -34,4 +39,3 @@ try {
     print "Dates don't match";
 }
 ```
-

vendor/sebastian/comparator/composer.json

@@ -24,14 +24,17 @@
     ],
     "prefer-stable": true,
     "require": {
-        "php": ">=7.1",
-        "sebastian/diff": "^3.0",
-        "sebastian/exporter": "^3.1"
+        "php": ">=7.3",
+        "sebastian/diff": "^4.0",
+        "sebastian/exporter": "^4.0"
     },
     "require-dev": {
-        "phpunit/phpunit": "^8.5"
+        "phpunit/phpunit": "^9.3"
     },
     "config": {
+        "platform": {
+            "php": "7.3.0"
+        },
         "optimize-autoloader": true,
         "sort-packages": true
     },
@@ -47,7 +50,7 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "3.0-dev"
+            "dev-master": "4.0-dev"
         }
     }
 }

vendor/sebastian/comparator/src/ArrayComparator.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,8 +9,19 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use function array_key_exists;
+use function is_array;
+use function sort;
+use function sprintf;
+use function str_replace;
+use function trim;
+
 /**
  * Compares arrays for equality.
+ *
+ * Arrays are equal if they contain the same key-value pairs.
+ * The order of the keys does not matter.
+ * The types of key-value pairs do not matter.
  */
 class ArrayComparator extends Comparator
 {
@@ -24,11 +35,11 @@ class ArrayComparator extends Comparator
      */
     public function accepts($expected, $actual)
     {
-        return \is_array($expected) && \is_array($actual);
+        return is_array($expected) && is_array($actual);
     }
 
     /**
-     * Asserts that two values are equal.
+     * Asserts that two arrays are equal.
      *
      * @param mixed $expected     First value to compare
      * @param mixed $actual       Second value to compare
@@ -39,11 +50,11 @@ class ArrayComparator extends Comparator
      *
      * @throws ComparisonFailure
      */
-    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = [])
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = [])/*: void*/
     {
         if ($canonicalize) {
-            \sort($expected);
-            \sort($actual);
+            sort($expected);
+            sort($actual);
         }
 
         $remaining        = $actual;
@@ -54,8 +65,8 @@ class ArrayComparator extends Comparator
         foreach ($expected as $key => $value) {
             unset($remaining[$key]);
 
-            if (!\array_key_exists($key, $actual)) {
-                $expectedAsString .= \sprintf(
+            if (!array_key_exists($key, $actual)) {
+                $expectedAsString .= sprintf(
                     "    %s => %s\n",
                     $this->exporter->export($key),
                     $this->exporter->shortenedExport($value)
@@ -70,25 +81,25 @@ class ArrayComparator extends Comparator
                 $comparator = $this->factory->getComparatorFor($value, $actual[$key]);
                 $comparator->assertEquals($value, $actual[$key], $delta, $canonicalize, $ignoreCase, $processed);
 
-                $expectedAsString .= \sprintf(
+                $expectedAsString .= sprintf(
                     "    %s => %s\n",
                     $this->exporter->export($key),
                     $this->exporter->shortenedExport($value)
                 );
 
-                $actualAsString .= \sprintf(
+                $actualAsString .= sprintf(
                     "    %s => %s\n",
                     $this->exporter->export($key),
                     $this->exporter->shortenedExport($actual[$key])
                 );
             } catch (ComparisonFailure $e) {
-                $expectedAsString .= \sprintf(
+                $expectedAsString .= sprintf(
                     "    %s => %s\n",
                     $this->exporter->export($key),
                     $e->getExpectedAsString() ? $this->indent($e->getExpectedAsString()) : $this->exporter->shortenedExport($e->getExpected())
                 );
 
-                $actualAsString .= \sprintf(
+                $actualAsString .= sprintf(
                     "    %s => %s\n",
                     $this->exporter->export($key),
                     $e->getActualAsString() ? $this->indent($e->getActualAsString()) : $this->exporter->shortenedExport($e->getActual())
@@ -99,7 +110,7 @@ class ArrayComparator extends Comparator
         }
 
         foreach ($remaining as $key => $value) {
-            $actualAsString .= \sprintf(
+            $actualAsString .= sprintf(
                 "    %s => %s\n",
                 $this->exporter->export($key),
                 $this->exporter->shortenedExport($value)
@@ -125,6 +136,6 @@ class ArrayComparator extends Comparator
 
     protected function indent($lines)
     {
-        return \trim(\str_replace("\n", "\n    ", $lines));
+        return trim(str_replace("\n", "\n    ", $lines));
     }
 }

vendor/sebastian/comparator/src/Comparator.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -31,7 +31,7 @@ abstract class Comparator
         $this->exporter = new Exporter;
     }
 
-    public function setFactory(Factory $factory)
+    public function setFactory(Factory $factory)/*: void*/
     {
         $this->factory = $factory;
     }

vendor/sebastian/comparator/src/ComparisonFailure.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,13 +9,14 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use RuntimeException;
 use SebastianBergmann\Diff\Differ;
 use SebastianBergmann\Diff\Output\UnifiedDiffOutputBuilder;
 
 /**
  * Thrown when an assertion for string equality failed.
  */
-class ComparisonFailure extends \RuntimeException
+class ComparisonFailure extends RuntimeException
 {
     /**
      * Expected value of the retrieval which does not match $actual.
@@ -32,14 +33,14 @@ class ComparisonFailure extends \RuntimeException
     protected $actual;
 
     /**
-     * The string representation of the expected value
+     * The string representation of the expected value.
      *
      * @var string
      */
     protected $expectedAsString;
 
     /**
-     * The string representation of the actual value
+     * The string representation of the actual value.
      *
      * @var string
      */

vendor/sebastian/comparator/src/DOMNodeComparator.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,8 +9,11 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use function sprintf;
+use function strtolower;
 use DOMDocument;
 use DOMNode;
+use ValueError;
 
 /**
  * Compares DOMNode instances for equality.
@@ -42,7 +45,7 @@ class DOMNodeComparator extends ObjectComparator
      *
      * @throws ComparisonFailure
      */
-    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = [])
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = [])/*: void*/
     {
         $expectedAsString = $this->nodeToText($expected, true, $ignoreCase);
         $actualAsString   = $this->nodeToText($actual, true, $ignoreCase);
@@ -56,7 +59,7 @@ class DOMNodeComparator extends ObjectComparator
                 $expectedAsString,
                 $actualAsString,
                 false,
-                \sprintf("Failed asserting that two DOM %s are equal.\n", $type)
+                sprintf("Failed asserting that two DOM %s are equal.\n", $type)
             );
         }
     }
@@ -69,7 +72,11 @@ class DOMNodeComparator extends ObjectComparator
     {
         if ($canonicalize) {
             $document = new DOMDocument;
-            @$document->loadXML($node->C14N());
+
+            try {
+                @$document->loadXML($node->C14N());
+            } catch (ValueError $e) {
+            }
 
             $node = $document;
         }
@@ -81,6 +88,6 @@ class DOMNodeComparator extends ObjectComparator
 
         $text = $node instanceof DOMDocument ? $node->saveXML() : $document->saveXML($node);
 
-        return $ignoreCase ? \strtolower($text) : $text;
+        return $ignoreCase ? strtolower($text) : $text;
     }
 }

vendor/sebastian/comparator/src/DateTimeComparator.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,6 +9,15 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use function abs;
+use function floor;
+use function sprintf;
+use DateInterval;
+use DateTime;
+use DateTimeInterface;
+use DateTimeZone;
+use Exception;
+
 /**
  * Compares DateTimeInterface instances for equality.
  */
@@ -24,8 +33,8 @@ class DateTimeComparator extends ObjectComparator
      */
     public function accepts($expected, $actual)
     {
-        return ($expected instanceof \DateTime || $expected instanceof \DateTimeInterface) &&
-               ($actual instanceof \DateTime || $actual instanceof \DateTimeInterface);
+        return ($expected instanceof DateTime || $expected instanceof DateTimeInterface) &&
+               ($actual instanceof DateTime || $actual instanceof DateTimeInterface);
     }
 
     /**
@@ -38,26 +47,26 @@ class DateTimeComparator extends ObjectComparator
      * @param bool  $ignoreCase   Case is ignored when set to true
      * @param array $processed    List of already processed elements (used to prevent infinite recursion)
      *
-     * @throws \Exception
+     * @throws Exception
      * @throws ComparisonFailure
      */
-    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = [])
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = [])/*: void*/
     {
-        /** @var \DateTimeInterface $expected */
-        /** @var \DateTimeInterface $actual */
-        $absDelta = \abs($delta);
-        $delta    = new \DateInterval(\sprintf('PT%dS', $absDelta));
-        $delta->f = $absDelta - \floor($absDelta);
+        /** @var DateTimeInterface $expected */
+        /** @var DateTimeInterface $actual */
+        $absDelta = abs($delta);
+        $delta    = new DateInterval(sprintf('PT%dS', $absDelta));
+        $delta->f = $absDelta - floor($absDelta);
 
         $actualClone = (clone $actual)
-            ->setTimezone(new \DateTimeZone('UTC'));
+            ->setTimezone(new DateTimeZone('UTC'));
 
         $expectedLower = (clone $expected)
-            ->setTimezone(new \DateTimeZone('UTC'))
+            ->setTimezone(new DateTimeZone('UTC'))
             ->sub($delta);
 
         $expectedUpper = (clone $expected)
-            ->setTimezone(new \DateTimeZone('UTC'))
+            ->setTimezone(new DateTimeZone('UTC'))
             ->add($delta);
 
         if ($actualClone < $expectedLower || $actualClone > $expectedUpper) {
@@ -77,7 +86,7 @@ class DateTimeComparator extends ObjectComparator
      * 'Invalid DateTimeInterface object' if the provided DateTimeInterface was not properly
      * initialized.
      */
-    private function dateTimeToString(\DateTimeInterface $datetime): string
+    private function dateTimeToString(DateTimeInterface $datetime): string
     {
         $string = $datetime->format('Y-m-d\TH:i:s.uO');
 

vendor/sebastian/comparator/src/DoubleComparator.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,6 +9,9 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use function is_float;
+use function is_numeric;
+
 /**
  * Compares doubles for equality.
  *
@@ -21,7 +24,7 @@ class DoubleComparator extends NumericComparator
      *
      * @var float
      */
-    const EPSILON = 0.0000000001;
+    public const EPSILON = 0.0000000001;
 
     /**
      * Returns whether the comparator can compare two values.
@@ -33,7 +36,7 @@ class DoubleComparator extends NumericComparator
      */
     public function accepts($expected, $actual)
     {
-        return (\is_float($expected) || \is_float($actual)) && \is_numeric($expected) && \is_numeric($actual);
+        return (is_float($expected) || is_float($actual)) && is_numeric($expected) && is_numeric($actual);
     }
 
     /**
@@ -47,7 +50,7 @@ class DoubleComparator extends NumericComparator
      *
      * @throws ComparisonFailure
      */
-    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)/*: void*/
     {
         if ($delta == 0) {
             $delta = self::EPSILON;

vendor/sebastian/comparator/src/ExceptionComparator.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,6 +9,8 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use Exception;
+
 /**
  * Compares Exception instances for equality.
  */
@@ -24,7 +26,7 @@ class ExceptionComparator extends ObjectComparator
      */
     public function accepts($expected, $actual)
     {
-        return $expected instanceof \Exception && $actual instanceof \Exception;
+        return $expected instanceof Exception && $actual instanceof Exception;
     }
 
     /**

vendor/sebastian/comparator/src/Factory.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,6 +9,8 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use function array_unshift;
+
 /**
  * Factory for comparators which compare values for equality.
  */
@@ -35,7 +37,7 @@ class Factory
     public static function getInstance()
     {
         if (self::$instance === null) {
-            self::$instance = new self;
+            self::$instance = new self; // @codeCoverageIgnore
         }
 
         return self::$instance;
@@ -70,6 +72,8 @@ class Factory
                 return $comparator;
             }
         }
+
+        throw new RuntimeException('No suitable Comparator implementation found');
     }
 
     /**
@@ -82,9 +86,9 @@ class Factory
      *
      * @param Comparator $comparator The comparator to be registered
      */
-    public function register(Comparator $comparator)
+    public function register(Comparator $comparator)/*: void*/
     {
-        \array_unshift($this->customComparators, $comparator);
+        array_unshift($this->customComparators, $comparator);
 
         $comparator->setFactory($this);
     }
@@ -96,7 +100,7 @@ class Factory
      *
      * @param Comparator $comparator The comparator to be unregistered
      */
-    public function unregister(Comparator $comparator)
+    public function unregister(Comparator $comparator)/*: void*/
     {
         foreach ($this->customComparators as $key => $_comparator) {
             if ($comparator === $_comparator) {
@@ -108,12 +112,12 @@ class Factory
     /**
      * Unregisters all non-default comparators.
      */
-    public function reset()
+    public function reset()/*: void*/
     {
         $this->customComparators = [];
     }
 
-    private function registerDefaultComparators()
+    private function registerDefaultComparators(): void
     {
         $this->registerDefaultComparator(new MockObjectComparator);
         $this->registerDefaultComparator(new DateTimeComparator);
@@ -128,7 +132,7 @@ class Factory
         $this->registerDefaultComparator(new TypeComparator);
     }
 
-    private function registerDefaultComparator(Comparator $comparator)
+    private function registerDefaultComparator(Comparator $comparator): void
     {
         $this->defaultComparators[] = $comparator;
 

vendor/sebastian/comparator/src/MockObjectComparator.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,8 +9,10 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use PHPUnit\Framework\MockObject\MockObject;
+
 /**
- * Compares PHPUnit_Framework_MockObject_MockObject instances for equality.
+ * Compares PHPUnit\Framework\MockObject\MockObject instances for equality.
  */
 class MockObjectComparator extends ObjectComparator
 {
@@ -24,8 +26,7 @@ class MockObjectComparator extends ObjectComparator
      */
     public function accepts($expected, $actual)
     {
-        return ($expected instanceof \PHPUnit_Framework_MockObject_MockObject || $expected instanceof \PHPUnit\Framework\MockObject\MockObject) &&
-               ($actual instanceof \PHPUnit_Framework_MockObject_MockObject || $actual instanceof \PHPUnit\Framework\MockObject\MockObject);
+        return $expected instanceof MockObject && $actual instanceof MockObject;
     }
 
     /**

vendor/sebastian/comparator/src/NumericComparator.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,6 +9,14 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use function abs;
+use function is_float;
+use function is_infinite;
+use function is_nan;
+use function is_numeric;
+use function is_string;
+use function sprintf;
+
 /**
  * Compares numerical values for equality.
  */
@@ -25,8 +33,8 @@ class NumericComparator extends ScalarComparator
     public function accepts($expected, $actual)
     {
         // all numerical values, but not if both of them are strings
-        return \is_numeric($expected) && \is_numeric($actual) &&
-               !(\is_string($expected) && \is_string($actual));
+        return is_numeric($expected) && is_numeric($actual) &&
+               !(is_string($expected) && is_string($actual));
     }
 
     /**
@@ -40,22 +48,22 @@ class NumericComparator extends ScalarComparator
      *
      * @throws ComparisonFailure
      */
-    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)/*: void*/
     {
-        if (\is_infinite($actual) && \is_infinite($expected)) {
-            return; // @codeCoverageIgnore
+        if ($this->isInfinite($actual) && $this->isInfinite($expected)) {
+            return;
         }
 
-        if ((\is_infinite($actual) xor \is_infinite($expected)) ||
-            (\is_nan($actual) || \is_nan($expected)) ||
-            \abs($actual - $expected) > $delta) {
+        if (($this->isInfinite($actual) xor $this->isInfinite($expected)) ||
+            ($this->isNan($actual) || $this->isNan($expected)) ||
+            abs($actual - $expected) > $delta) {
             throw new ComparisonFailure(
                 $expected,
                 $actual,
                 '',
                 '',
                 false,
-                \sprintf(
+                sprintf(
                     'Failed asserting that %s matches expected %s.',
                     $this->exporter->export($actual),
                     $this->exporter->export($expected)
@@ -63,4 +71,14 @@ class NumericComparator extends ScalarComparator
             );
         }
     }
+
+    private function isInfinite($value): bool
+    {
+        return is_float($value) && is_infinite($value);
+    }
+
+    private function isNan($value): bool
+    {
+        return is_float($value) && is_nan($value);
+    }
 }

vendor/sebastian/comparator/src/ObjectComparator.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,6 +9,12 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use function get_class;
+use function in_array;
+use function is_object;
+use function sprintf;
+use function substr_replace;
+
 /**
  * Compares objects for equality.
  */
@@ -24,7 +30,7 @@ class ObjectComparator extends ArrayComparator
      */
     public function accepts($expected, $actual)
     {
-        return \is_object($expected) && \is_object($actual);
+        return is_object($expected) && is_object($actual);
     }
 
     /**
@@ -39,26 +45,26 @@ class ObjectComparator extends ArrayComparator
      *
      * @throws ComparisonFailure
      */
-    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = [])
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false, array &$processed = [])/*: void*/
     {
-        if (\get_class($actual) !== \get_class($expected)) {
+        if (get_class($actual) !== get_class($expected)) {
             throw new ComparisonFailure(
                 $expected,
                 $actual,
                 $this->exporter->export($expected),
                 $this->exporter->export($actual),
                 false,
-                \sprintf(
+                sprintf(
                     '%s is not instance of expected class "%s".',
                     $this->exporter->export($actual),
-                    \get_class($expected)
+                    get_class($expected)
                 )
             );
         }
 
         // don't compare twice to allow for cyclic dependencies
-        if (\in_array([$actual, $expected], $processed, true) ||
-            \in_array([$expected, $actual], $processed, true)) {
+        if (in_array([$actual, $expected], $processed, true) ||
+            in_array([$expected, $actual], $processed, true)) {
             return;
         }
 
@@ -82,8 +88,8 @@ class ObjectComparator extends ArrayComparator
                     $expected,
                     $actual,
                     // replace "Array" with "MyClass object"
-                    \substr_replace($e->getExpectedAsString(), \get_class($expected) . ' Object', 0, 5),
-                    \substr_replace($e->getActualAsString(), \get_class($actual) . ' Object', 0, 5),
+                    substr_replace($e->getExpectedAsString(), get_class($expected) . ' Object', 0, 5),
+                    substr_replace($e->getActualAsString(), get_class($actual) . ' Object', 0, 5),
                     false,
                     'Failed asserting that two objects are equal.'
                 );

vendor/sebastian/comparator/src/ResourceComparator.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,6 +9,8 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use function is_resource;
+
 /**
  * Compares resources for equality.
  */
@@ -24,7 +26,7 @@ class ResourceComparator extends Comparator
      */
     public function accepts($expected, $actual)
     {
-        return \is_resource($expected) && \is_resource($actual);
+        return is_resource($expected) && is_resource($actual);
     }
 
     /**
@@ -38,7 +40,7 @@ class ResourceComparator extends Comparator
      *
      * @throws ComparisonFailure
      */
-    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)/*: void*/
     {
         if ($actual != $expected) {
             throw new ComparisonFailure(

vendor/sebastian/comparator/src/ScalarComparator.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,6 +9,14 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use function is_bool;
+use function is_object;
+use function is_scalar;
+use function is_string;
+use function method_exists;
+use function sprintf;
+use function strtolower;
+
 /**
  * Compares scalar or NULL values for equality.
  */
@@ -26,11 +34,11 @@ class ScalarComparator extends Comparator
      */
     public function accepts($expected, $actual)
     {
-        return ((\is_scalar($expected) xor null === $expected) &&
-               (\is_scalar($actual) xor null === $actual))
+        return ((is_scalar($expected) xor null === $expected) &&
+               (is_scalar($actual) xor null === $actual))
                // allow comparison between strings and objects featuring __toString()
-               || (\is_string($expected) && \is_object($actual) && \method_exists($actual, '__toString'))
-               || (\is_object($expected) && \method_exists($expected, '__toString') && \is_string($actual));
+               || (is_string($expected) && is_object($actual) && method_exists($actual, '__toString'))
+               || (is_object($expected) && method_exists($expected, '__toString') && is_string($actual));
     }
 
     /**
@@ -44,24 +52,24 @@ class ScalarComparator extends Comparator
      *
      * @throws ComparisonFailure
      */
-    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)/*: void*/
     {
         $expectedToCompare = $expected;
         $actualToCompare   = $actual;
 
         // always compare as strings to avoid strange behaviour
         // otherwise 0 == 'Foobar'
-        if ((\is_string($expected) && !\is_bool($actual)) || (\is_string($actual) && !\is_bool($expected))) {
+        if ((is_string($expected) && !is_bool($actual)) || (is_string($actual) && !is_bool($expected))) {
             $expectedToCompare = (string) $expectedToCompare;
             $actualToCompare   = (string) $actualToCompare;
 
             if ($ignoreCase) {
-                $expectedToCompare = \strtolower($expectedToCompare);
-                $actualToCompare   = \strtolower($actualToCompare);
+                $expectedToCompare = strtolower($expectedToCompare);
+                $actualToCompare   = strtolower($actualToCompare);
             }
         }
 
-        if ($expectedToCompare !== $actualToCompare && \is_string($expected) && \is_string($actual)) {
+        if ($expectedToCompare !== $actualToCompare && is_string($expected) && is_string($actual)) {
             throw new ComparisonFailure(
                 $expected,
                 $actual,
@@ -80,7 +88,7 @@ class ScalarComparator extends Comparator
                 '',
                 '',
                 false,
-                \sprintf(
+                sprintf(
                     'Failed asserting that %s matches expected %s.',
                     $this->exporter->export($actual),
                     $this->exporter->export($expected)

vendor/sebastian/comparator/src/SplObjectStorageComparator.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,6 +9,8 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use SplObjectStorage;
+
 /**
  * Compares \SplObjectStorage instances for equality.
  */
@@ -24,7 +26,7 @@ class SplObjectStorageComparator extends Comparator
      */
     public function accepts($expected, $actual)
     {
-        return $expected instanceof \SplObjectStorage && $actual instanceof \SplObjectStorage;
+        return $expected instanceof SplObjectStorage && $actual instanceof SplObjectStorage;
     }
 
     /**
@@ -38,7 +40,7 @@ class SplObjectStorageComparator extends Comparator
      *
      * @throws ComparisonFailure
      */
-    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)/*: void*/
     {
         foreach ($actual as $object) {
             if (!$expected->contains($object)) {

vendor/sebastian/comparator/src/TypeComparator.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 /*
  * This file is part of sebastian/comparator.
  *
@@ -9,6 +9,9 @@
  */
 namespace SebastianBergmann\Comparator;
 
+use function gettype;
+use function sprintf;
+
 /**
  * Compares values for type equality.
  */
@@ -38,9 +41,9 @@ class TypeComparator extends Comparator
      *
      * @throws ComparisonFailure
      */
-    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
+    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)/*: void*/
     {
-        if (\gettype($expected) != \gettype($actual)) {
+        if (gettype($expected) != gettype($actual)) {
             throw new ComparisonFailure(
                 $expected,
                 $actual,
@@ -48,10 +51,10 @@ class TypeComparator extends Comparator
                 '',
                 '',
                 false,
-                \sprintf(
+                sprintf(
                     '%s does not match expected type "%s".',
                     $this->exporter->shortenedExport($actual),
-                    \gettype($expected)
+                    gettype($expected)
                 )
             );
         }

vendor/sebastian/comparator/src/exceptions/Exception.php

@@ -1,14 +1,16 @@
 <?php declare(strict_types=1);
 /*
- * This file is part of sebastian/global-state.
+ * This file is part of sebastian/comparator.
  *
  * (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\GlobalState\TestFixture;
+namespace SebastianBergmann\Comparator;
 
-trait SnapshotTrait
+use Throwable;
+
+interface Exception extends Throwable
 {
 }

vendor/sebastian/comparator/src/exceptions/RuntimeException.php

@@ -1,15 +1,14 @@
 <?php declare(strict_types=1);
 /*
- * This file is part of sebastian/global-state.
+ * This file is part of sebastian/comparator.
  *
  * (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\GlobalState\TestFixture;
+namespace SebastianBergmann\Comparator;
 
-class BlacklistedClass
+final class RuntimeException extends \RuntimeException implements Exception
 {
-    private static $attribute;
 }

vendor/sebastian/complexity/.psalm/baseline.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<files psalm-version="4.0.1@b1e2e30026936ef8d5bf6a354d1c3959b6231f44"/>

vendor/sebastian/complexity/.psalm/config.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<psalm
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns="https://getpsalm.org/schema/config"
+    xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
+    resolveFromConfigFile="false"
+    errorBaseline=".psalm/baseline.xml"
+    totallyTyped="true"
+>
+    <projectFiles>
+        <directory name="src" />
+        <ignoreFiles>
+            <directory name="vendor" />
+        </ignoreFiles>
+    </projectFiles>
+</psalm>

vendor/sebastian/complexity/ChangeLog.md

@@ -0,0 +1,30 @@
+# ChangeLog
+
+All notable changes are documented in this file using the [Keep a CHANGELOG](https://keepachangelog.com/) principles.
+
+## [2.0.2] - 2020-10-26
+
+### Fixed
+
+* `SebastianBergmann\Complexity\Exception` now correctly extends `\Throwable`
+
+## [2.0.1] - 2020-09-28
+
+### Changed
+
+* Changed PHP version constraint in `composer.json` from `^7.3 || ^8.0` to `>=7.3`
+
+## [2.0.0] - 2020-07-25
+
+### Removed
+
+* The `ParentConnectingVisitor` has been removed (it should have been marked as `@internal`)
+
+## [1.0.0] - 2020-07-22
+
+* Initial release
+
+[2.0.2]: https://github.com/sebastianbergmann/complexity/compare/2.0.1...2.0.2
+[2.0.1]: https://github.com/sebastianbergmann/complexity/compare/2.0.0...2.0.1
+[2.0.0]: https://github.com/sebastianbergmann/complexity/compare/1.0.0...2.0.0
+[1.0.0]: https://github.com/sebastianbergmann/complexity/compare/70ee0ad32d9e2be3f85beffa3e2eb474193f2487...1.0.0

vendor/sebastian/complexity/LICENSE

@@ -0,0 +1,33 @@
+sebastian/complexity
+
+Copyright (c) 2020, Sebastian Bergmann <sebastian@phpunit.de>.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in
+   the documentation and/or other materials provided with the
+   distribution.
+
+ * Neither the name of Sebastian Bergmann nor the names of his
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

vendor/sebastian/complexity/README.md

@@ -0,0 +1,22 @@
+# sebastian/complexity
+
+Library for calculating the complexity of PHP code units.
+
+[![Latest Stable Version](https://img.shields.io/packagist/v/sebastian/complexity.svg?style=flat-square)](https://packagist.org/packages/sebastian/complexity)
+[![Minimum PHP Version](https://img.shields.io/badge/php-%3E%3D%207.3-8892BF.svg?style=flat-square)](https://php.net/)
+[![CI Status](https://github.com/sebastianbergmann/complexity/workflows/CI/badge.svg?branch=master&event=push)](https://phpunit.de/build-status.html)
+[![Type Coverage](https://shepherd.dev/github/sebastianbergmann/complexity/coverage.svg)](https://shepherd.dev/github/sebastianbergmann/complexity)
+
+## Installation
+
+You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/):
+
+```
+composer require sebastian/complexity
+```
+
+If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency:
+
+```
+composer require --dev sebastian/complexity
+```

vendor/sebastian/complexity/composer.json

@@ -0,0 +1,41 @@
+{
+    "name": "sebastian/complexity",
+    "description": "Library for calculating the complexity of PHP code units",
+    "type": "library",
+    "homepage": "https://github.com/sebastianbergmann/complexity",
+    "license": "BSD-3-Clause",
+    "authors": [
+        {
+            "name": "Sebastian Bergmann",
+            "email": "sebastian@phpunit.de",
+            "role": "lead"
+        }
+    ],
+    "support": {
+        "issues": "https://github.com/sebastianbergmann/complexity/issues"
+    },
+    "require": {
+        "php": ">=7.3",
+        "nikic/php-parser": "^4.7"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "^9.3"
+    },
+    "config": {
+        "platform": {
+            "php": "7.3.0"
+        },
+        "optimize-autoloader": true,
+        "sort-packages": true
+    },
+    "autoload": {
+        "classmap": [
+            "src/"
+        ]
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "2.0-dev"
+        }
+    }
+}

vendor/sebastian/complexity/src/Calculator.php

@@ -0,0 +1,88 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/complexity.
+ *
+ * (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\Complexity;
+
+use PhpParser\Error;
+use PhpParser\Lexer;
+use PhpParser\Node;
+use PhpParser\NodeTraverser;
+use PhpParser\NodeVisitor\NameResolver;
+use PhpParser\NodeVisitor\ParentConnectingVisitor;
+use PhpParser\Parser;
+use PhpParser\ParserFactory;
+
+final class Calculator
+{
+    /**
+     * @throws RuntimeException
+     */
+    public function calculateForSourceFile(string $sourceFile): ComplexityCollection
+    {
+        return $this->calculateForSourceString(file_get_contents($sourceFile));
+    }
+
+    /**
+     * @throws RuntimeException
+     */
+    public function calculateForSourceString(string $source): ComplexityCollection
+    {
+        try {
+            $nodes = $this->parser()->parse($source);
+
+            assert($nodes !== null);
+
+            return $this->calculateForAbstractSyntaxTree($nodes);
+
+            // @codeCoverageIgnoreStart
+        } catch (Error $error) {
+            throw new RuntimeException(
+                $error->getMessage(),
+                (int) $error->getCode(),
+                $error
+            );
+        }
+        // @codeCoverageIgnoreEnd
+    }
+
+    /**
+     * @param Node[] $nodes
+     *
+     * @throws RuntimeException
+     */
+    public function calculateForAbstractSyntaxTree(array $nodes): ComplexityCollection
+    {
+        $traverser                    = new NodeTraverser;
+        $complexityCalculatingVisitor = new ComplexityCalculatingVisitor(true);
+
+        $traverser->addVisitor(new NameResolver);
+        $traverser->addVisitor(new ParentConnectingVisitor);
+        $traverser->addVisitor($complexityCalculatingVisitor);
+
+        try {
+            /* @noinspection UnusedFunctionResultInspection */
+            $traverser->traverse($nodes);
+            // @codeCoverageIgnoreStart
+        } catch (Error $error) {
+            throw new RuntimeException(
+                $error->getMessage(),
+                (int) $error->getCode(),
+                $error
+            );
+        }
+        // @codeCoverageIgnoreEnd
+
+        return $complexityCalculatingVisitor->result();
+    }
+
+    private function parser(): Parser
+    {
+        return (new ParserFactory)->create(ParserFactory::PREFER_PHP7, new Lexer);
+    }
+}

vendor/sebastian/complexity/src/Complexity/Complexity.php

@@ -0,0 +1,42 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/complexity.
+ *
+ * (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\Complexity;
+
+/**
+ * @psalm-immutable
+ */
+final class Complexity
+{
+    /**
+     * @var string
+     */
+    private $name;
+
+    /**
+     * @var int
+     */
+    private $cyclomaticComplexity;
+
+    public function __construct(string $name, int $cyclomaticComplexity)
+    {
+        $this->name                 = $name;
+        $this->cyclomaticComplexity = $cyclomaticComplexity;
+    }
+
+    public function name(): string
+    {
+        return $this->name;
+    }
+
+    public function cyclomaticComplexity(): int
+    {
+        return $this->cyclomaticComplexity;
+    }
+}

vendor/sebastian/complexity/src/Complexity/ComplexityCollection.php

@@ -0,0 +1,72 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/complexity.
+ *
+ * (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\Complexity;
+
+use function count;
+use Countable;
+use IteratorAggregate;
+
+/**
+ * @psalm-immutable
+ */
+final class ComplexityCollection implements Countable, IteratorAggregate
+{
+    /**
+     * @psalm-var list<Complexity>
+     */
+    private $items = [];
+
+    public static function fromList(Complexity ...$items): self
+    {
+        return new self($items);
+    }
+
+    /**
+     * @psalm-param list<Complexity> $items
+     */
+    private function __construct(array $items)
+    {
+        $this->items = $items;
+    }
+
+    /**
+     * @psalm-return list<Complexity>
+     */
+    public function asArray(): array
+    {
+        return $this->items;
+    }
+
+    public function getIterator(): ComplexityCollectionIterator
+    {
+        return new ComplexityCollectionIterator($this);
+    }
+
+    public function count(): int
+    {
+        return count($this->items);
+    }
+
+    public function isEmpty(): bool
+    {
+        return empty($this->items);
+    }
+
+    public function cyclomaticComplexity(): int
+    {
+        $cyclomaticComplexity = 0;
+
+        foreach ($this as $item) {
+            $cyclomaticComplexity += $item->cyclomaticComplexity();
+        }
+
+        return $cyclomaticComplexity;
+    }
+}

vendor/sebastian/complexity/src/Complexity/ComplexityCollectionIterator.php

@@ -0,0 +1,55 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/complexity.
+ *
+ * (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\Complexity;
+
+use Iterator;
+
+final class ComplexityCollectionIterator implements Iterator
+{
+    /**
+     * @psalm-var list<Complexity>
+     */
+    private $items;
+
+    /**
+     * @var int
+     */
+    private $position = 0;
+
+    public function __construct(ComplexityCollection $items)
+    {
+        $this->items = $items->asArray();
+    }
+
+    public function rewind(): void
+    {
+        $this->position = 0;
+    }
+
+    public function valid(): bool
+    {
+        return isset($this->items[$this->position]);
+    }
+
+    public function key(): int
+    {
+        return $this->position;
+    }
+
+    public function current(): Complexity
+    {
+        return $this->items[$this->position];
+    }
+
+    public function next(): void
+    {
+        $this->position++;
+    }
+}

vendor/sebastian/complexity/src/Exception/Exception.php

@@ -1,14 +1,16 @@
 <?php declare(strict_types=1);
 /*
- * This file is part of sebastian/global-state.
+ * This file is part of sebastian/complexity.
  *
  * (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\GlobalState\TestFixture;
+namespace SebastianBergmann\Complexity;
 
-interface BlacklistedInterface
+use Throwable;
+
+interface Exception extends Throwable
 {
 }

vendor/sebastian/complexity/src/Exception/RuntimeException.php

@@ -1,14 +1,14 @@
 <?php declare(strict_types=1);
 /*
- * This file is part of sebastian/global-state.
+ * This file is part of sebastian/complexity.
  *
  * (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\GlobalState\TestFixture;
+namespace SebastianBergmann\Complexity;
 
-class BlacklistedChildClass extends BlacklistedClass
+final class RuntimeException extends \RuntimeException implements Exception
 {
 }

vendor/sebastian/complexity/src/Visitor/ComplexityCalculatingVisitor.php

@@ -0,0 +1,109 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/complexity.
+ *
+ * (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\Complexity;
+
+use function assert;
+use function is_array;
+use PhpParser\Node;
+use PhpParser\Node\Name;
+use PhpParser\Node\Stmt;
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\ClassMethod;
+use PhpParser\Node\Stmt\Function_;
+use PhpParser\Node\Stmt\Trait_;
+use PhpParser\NodeTraverser;
+use PhpParser\NodeVisitorAbstract;
+
+final class ComplexityCalculatingVisitor extends NodeVisitorAbstract
+{
+    /**
+     * @psalm-var list<Complexity>
+     */
+    private $result = [];
+
+    /**
+     * @var bool
+     */
+    private $shortCircuitTraversal;
+
+    public function __construct(bool $shortCircuitTraversal)
+    {
+        $this->shortCircuitTraversal = $shortCircuitTraversal;
+    }
+
+    public function enterNode(Node $node): ?int
+    {
+        if (!$node instanceof ClassMethod && !$node instanceof Function_) {
+            return null;
+        }
+
+        if ($node instanceof ClassMethod) {
+            $name = $this->classMethodName($node);
+        } else {
+            $name = $this->functionName($node);
+        }
+
+        $statements = $node->getStmts();
+
+        assert(is_array($statements));
+
+        $this->result[] = new Complexity(
+            $name,
+            $this->cyclomaticComplexity($statements)
+        );
+
+        if ($this->shortCircuitTraversal) {
+            return NodeTraverser::DONT_TRAVERSE_CHILDREN;
+        }
+
+        return null;
+    }
+
+    public function result(): ComplexityCollection
+    {
+        return ComplexityCollection::fromList(...$this->result);
+    }
+
+    /**
+     * @param Stmt[] $statements
+     */
+    private function cyclomaticComplexity(array $statements): int
+    {
+        $traverser = new NodeTraverser;
+
+        $cyclomaticComplexityCalculatingVisitor = new CyclomaticComplexityCalculatingVisitor;
+
+        $traverser->addVisitor($cyclomaticComplexityCalculatingVisitor);
+
+        /* @noinspection UnusedFunctionResultInspection */
+        $traverser->traverse($statements);
+
+        return $cyclomaticComplexityCalculatingVisitor->cyclomaticComplexity();
+    }
+
+    private function classMethodName(ClassMethod $node): string
+    {
+        $parent = $node->getAttribute('parent');
+
+        assert($parent instanceof Class_ || $parent instanceof Trait_);
+        assert(isset($parent->namespacedName));
+        assert($parent->namespacedName instanceof Name);
+
+        return $parent->namespacedName->toString() . '::' . $node->name->toString();
+    }
+
+    private function functionName(Function_ $node): string
+    {
+        assert(isset($node->namespacedName));
+        assert($node->namespacedName instanceof Name);
+
+        return $node->namespacedName->toString();
+    }
+}

vendor/sebastian/complexity/src/Visitor/CyclomaticComplexityCalculatingVisitor.php

@@ -0,0 +1,59 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of sebastian/complexity.
+ *
+ * (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\Complexity;
+
+use function get_class;
+use PhpParser\Node;
+use PhpParser\Node\Expr\BinaryOp\BooleanAnd;
+use PhpParser\Node\Expr\BinaryOp\BooleanOr;
+use PhpParser\Node\Expr\BinaryOp\LogicalAnd;
+use PhpParser\Node\Expr\BinaryOp\LogicalOr;
+use PhpParser\Node\Expr\Ternary;
+use PhpParser\Node\Stmt\Case_;
+use PhpParser\Node\Stmt\Catch_;
+use PhpParser\Node\Stmt\ElseIf_;
+use PhpParser\Node\Stmt\For_;
+use PhpParser\Node\Stmt\Foreach_;
+use PhpParser\Node\Stmt\If_;
+use PhpParser\Node\Stmt\While_;
+use PhpParser\NodeVisitorAbstract;
+
+final class CyclomaticComplexityCalculatingVisitor extends NodeVisitorAbstract
+{
+    /**
+     * @var int
+     */
+    private $cyclomaticComplexity = 1;
+
+    public function enterNode(Node $node): void
+    {
+        /* @noinspection GetClassMissUseInspection */
+        switch (get_class($node)) {
+            case BooleanAnd::class:
+            case BooleanOr::class:
+            case Case_::class:
+            case Catch_::class:
+            case ElseIf_::class:
+            case For_::class:
+            case Foreach_::class:
+            case If_::class:
+            case LogicalAnd::class:
+            case LogicalOr::class:
+            case Ternary::class:
+            case While_::class:
+                $this->cyclomaticComplexity++;
+        }
+    }
+
+    public function cyclomaticComplexity(): int
+    {
+        return $this->cyclomaticComplexity;
+    }
+}

vendor/sebastian/diff/.github/stale.yml

@@ -1,40 +0,0 @@
-# Configuration for probot-stale - https://github.com/probot/stale
-
-# Number of days of inactivity before an Issue or Pull Request becomes stale
-daysUntilStale: 60
-
-# Number of days of inactivity before a stale Issue or Pull Request is closed.
-# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
-daysUntilClose: 7
-
-# Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
-exemptLabels:
-  - enhancement
-
-# Set to true to ignore issues in a project (defaults to false)
-exemptProjects: false
-
-# Set to true to ignore issues in a milestone (defaults to false)
-exemptMilestones: false
-
-# Label to use when marking as stale
-staleLabel: wontfix
-
-# Comment to post when marking as stale. Set to `false` to disable
-markComment: >
-  This issue has been automatically marked as stale because it has not had activity within the last 60 days. It will be closed after 7 days if no further activity occurs. Thank you for your contributions.
-
-# Comment to post when removing the stale label.
-# unmarkComment: >
-#   Your comment here.
-
-# Comment to post when closing a stale Issue or Pull Request.
-closeComment: >
-  This issue has been automatically closed because it has not had activity since it was marked as stale. Thank you for your contributions.
-
-# Limit the number of actions per hour, from 1-30. Default is 30
-limitPerRun: 30
-
-# Limit to only `issues` or `pulls`
-only: issues
-

vendor/sebastian/diff/.gitignore

@@ -1,6 +0,0 @@
-/.idea
-/composer.lock
-/vendor
-/.php_cs.cache
-/.phpunit.result.cache
-/from.txt.orig

vendor/sebastian/diff/.php_cs.dist

@@ -1,168 +0,0 @@
-<?php declare(strict_types=1);
-$header = <<<'EOF'
-This file is part of sebastian/diff.
-
-(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.
-EOF;
-
-return PhpCsFixer\Config::create()
-    ->setRiskyAllowed(true)
-    ->setRules(
-        [
-            'array_syntax' => ['syntax' => 'short'],
-            'binary_operator_spaces' => [
-                'operators' => [
-                    '=' => 'align',
-                    '=>' => 'align',
-                ],
-            ],
-            'blank_line_after_namespace' => true,
-            'blank_line_before_statement' => [
-                'statements' => [
-                    'break',
-                    'continue',
-                    'declare',
-                    'do',
-                    'for',
-                    'foreach',
-                    'if',
-                    'include',
-                    'include_once',
-                    'require',
-                    'require_once',
-                    'return',
-                    'switch',
-                    'throw',
-                    'try',
-                    'while',
-                    'yield',
-                ],
-            ],
-            'braces' => true,
-            'cast_spaces' => true,
-            'class_attributes_separation' => ['elements' => ['method']],
-            'compact_nullable_typehint' => true,
-            'concat_space' => ['spacing' => 'one'],
-            'declare_equal_normalize' => ['space' => 'none'],
-            'declare_strict_types' => true,
-            'dir_constant' => true,
-            'elseif' => true,
-            'encoding' => true,
-            'full_opening_tag' => true,
-            'function_declaration' => true,
-            'header_comment' => ['header' => $header, 'separate' => 'none'],
-            'indentation_type' => true,
-            'line_ending' => true,
-            'list_syntax' => ['syntax' => 'short'],
-            'lowercase_cast' => true,
-            'lowercase_constants' => true,
-            'lowercase_keywords' => true,
-            'magic_constant_casing' => true,
-            'method_argument_space' => ['ensure_fully_multiline' => true],
-            'modernize_types_casting' => true,
-            'native_function_casing' => true,
-            'native_function_invocation' => true,
-            'no_alias_functions' => true,
-            'no_blank_lines_after_class_opening' => true,
-            'no_blank_lines_after_phpdoc' => true,
-            'no_closing_tag' => true,
-            'no_empty_comment' => true,
-            'no_empty_phpdoc' => true,
-            'no_empty_statement' => true,
-            'no_extra_blank_lines' => true,
-            'no_homoglyph_names' => true,
-            'no_leading_import_slash' => true,
-            'no_leading_namespace_whitespace' => true,
-            'no_mixed_echo_print' => ['use' => 'print'],
-            'no_null_property_initialization' => true,
-            'no_short_bool_cast' => true,
-            'no_short_echo_tag' => true,
-            'no_singleline_whitespace_before_semicolons' => true,
-            'no_spaces_after_function_name' => true,
-            'no_spaces_inside_parenthesis' => true,
-            'no_superfluous_elseif' => true,
-            'no_trailing_comma_in_list_call' => true,
-            'no_trailing_comma_in_singleline_array' => true,
-            'no_trailing_whitespace' => true,
-            'no_trailing_whitespace_in_comment' => true,
-            'no_unneeded_control_parentheses' => true,
-            'no_unneeded_curly_braces' => true,
-            'no_unneeded_final_method' => true,
-            'no_unreachable_default_argument_value' => true,
-            'no_unused_imports' => true,
-            'no_useless_else' => true,
-            'no_whitespace_before_comma_in_array' => true,
-            'no_whitespace_in_blank_line' => true,
-            'non_printable_character' => true,
-            'normalize_index_brace' => true,
-            'object_operator_without_whitespace' => true,
-            'ordered_class_elements' => [
-                'order' => [
-                    'use_trait',
-                    'constant_public',
-                    'constant_protected',
-                    'constant_private',
-                    'property_public_static',
-                    'property_protected_static',
-                    'property_private_static',
-                    'property_public',
-                    'property_protected',
-                    'property_private',
-                    'method_public_static',
-                    'construct',
-                    'destruct',
-                    'magic',
-                    'phpunit',
-                    'method_public',
-                    'method_protected',
-                    'method_private',
-                    'method_protected_static',
-                    'method_private_static',
-                ],
-            ],
-            'ordered_imports' => true,
-            'phpdoc_add_missing_param_annotation' => true,
-            'phpdoc_align' => true,
-            'phpdoc_annotation_without_dot' => true,
-            'phpdoc_indent' => true,
-            'phpdoc_no_access' => true,
-            'phpdoc_no_empty_return' => true,
-            'phpdoc_no_package' => true,
-            'phpdoc_order' => true,
-            'phpdoc_return_self_reference' => true,
-            'phpdoc_scalar' => true,
-            'phpdoc_separation' => true,
-            'phpdoc_single_line_var_spacing' => true,
-            'phpdoc_to_comment' => true,
-            'phpdoc_trim' => true,
-            'phpdoc_types' => true,
-            'phpdoc_types_order' => true,
-            'phpdoc_var_without_name' => true,
-            'pow_to_exponentiation' => true,
-            'protected_to_private' => true,
-            'return_type_declaration' => ['space_before' => 'none'],
-            'self_accessor' => true,
-            'short_scalar_cast' => true,
-            'simplified_null_return' => true,
-            'single_blank_line_at_eof' => true,
-            'single_import_per_statement' => true,
-            'single_line_after_imports' => true,
-            'single_quote' => true,
-            'standardize_not_equals' => true,
-            'ternary_to_null_coalescing' => true,
-            'trim_array_spaces' => true,
-            'unary_operator_spaces' => true,
-            'visibility_required' => true,
-            'void_return' => true,
-            'whitespace_after_comma_in_array' => true,
-        ]
-    )
-    ->setFinder(
-        PhpCsFixer\Finder::create()
-        ->files()
-        ->in(__DIR__ . '/src')
-        ->in(__DIR__ . '/tests')
-    );

vendor/sebastian/diff/.travis.yml

@@ -1,26 +0,0 @@
-language: php
-
-php:
-  - 7.1
-  - 7.2
-  - 7.3
-  - master
-
-sudo: false
-
-before_install:
-  - composer self-update
-  - composer clear-cache
-
-install:
-  - travis_retry composer update --no-interaction --no-ansi --no-progress --no-suggest --optimize-autoloader --prefer-stable
-
-script:
-  - ./vendor/bin/phpunit --coverage-clover=coverage.xml
-
-after_success:
-  - bash <(curl -s https://codecov.io/bash)
-
-notifications:
-  email: false
-

vendor/sebastian/diff/ChangeLog.md

@@ -2,11 +2,35 @@
 
 All notable changes are documented in this file using the [Keep a CHANGELOG](http://keepachangelog.com/) principles.
 
-## [3.0.3] - 2020-11-30
+## [4.0.4] - 2020-10-26
+
+### Fixed
+
+* `SebastianBergmann\Diff\Exception` now correctly extends `\Throwable`
+
+## [4.0.3] - 2020-09-28
 
 ### Changed
 
-* Changed PHP version constraint in `composer.json` from `^7.1` to `>=7.1`
+* Changed PHP version constraint in `composer.json` from `^7.3 || ^8.0` to `>=7.3`
+
+## [4.0.2] - 2020-06-30
+
+### Added
+
+* This component is now supported on PHP 8
+
+## [4.0.1] - 2020-05-08
+
+### Fixed
+
+* [#99](https://github.com/sebastianbergmann/diff/pull/99): Regression in unified diff output of identical strings
+
+## [4.0.0] - 2020-02-07
+
+### Removed
+
+* Removed support for PHP 7.1 and PHP 7.2
 
 ## [3.0.2] - 2019-02-04
 
@@ -34,25 +58,29 @@ All notable changes are documented in this file using the [Keep a CHANGELOG](htt
 
 ### Fixed
 
-* Fixed [#70](https://github.com/sebastianbergmann/diff/issues/70): Diffing of arrays no longer works
+* [#70](https://github.com/sebastianbergmann/diff/issues/70): Diffing of arrays no longer works
 
 ## [2.0.1] - 2017-08-03
 
 ### Fixed
 
-* Fixed [#66](https://github.com/sebastianbergmann/diff/pull/66): Restored backwards compatibility for PHPUnit 6.1.4, 6.2.0, 6.2.1, 6.2.2, and 6.2.3
+* [#66](https://github.com/sebastianbergmann/diff/pull/66): Restored backwards compatibility for PHPUnit 6.1.4, 6.2.0, 6.2.1, 6.2.2, and 6.2.3
 
 ## [2.0.0] - 2017-07-11 [YANKED]
 
 ### Added
 
-* Implemented [#64](https://github.com/sebastianbergmann/diff/pull/64): Show line numbers for chunks of a diff
+* [#64](https://github.com/sebastianbergmann/diff/pull/64): Show line numbers for chunks of a diff
 
 ### Removed
 
 * This component is no longer supported on PHP 5.6
 
-[3.0.3]: https://github.com/sebastianbergmann/diff/compare/3.0.2...3.0.3
+[4.0.4]: https://github.com/sebastianbergmann/diff/compare/4.0.3...4.0.4
+[4.0.3]: https://github.com/sebastianbergmann/diff/compare/4.0.2...4.0.3
+[4.0.2]: https://github.com/sebastianbergmann/diff/compare/4.0.1...4.0.2
+[4.0.1]: https://github.com/sebastianbergmann/diff/compare/4.0.0...4.0.1
+[4.0.0]: https://github.com/sebastianbergmann/diff/compare/3.0.2...4.0.0
 [3.0.2]: https://github.com/sebastianbergmann/diff/compare/3.0.1...3.0.2
 [3.0.1]: https://github.com/sebastianbergmann/diff/compare/3.0.0...3.0.1
 [3.0.0]: https://github.com/sebastianbergmann/diff/compare/2.0...3.0.0

vendor/sebastian/diff/LICENSE

@@ -1,6 +1,6 @@
 sebastian/diff
 
-Copyright (c) 2002-2019, Sebastian Bergmann <sebastian@phpunit.de>.
+Copyright (c) 2002-2020, Sebastian Bergmann <sebastian@phpunit.de>.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

vendor/sebastian/diff/README.md

@@ -1,16 +1,23 @@
 # sebastian/diff
 
+[![CI Status](https://github.com/sebastianbergmann/diff/workflows/CI/badge.svg)](https://github.com/sebastianbergmann/diff/actions)
+[![Type Coverage](https://shepherd.dev/github/sebastianbergmann/diff/coverage.svg)](https://shepherd.dev/github/sebastianbergmann/diff)
+
 Diff implementation for PHP, factored out of PHPUnit into a stand-alone component.
 
 ## Installation
 
 You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/):
 
-    composer require sebastian/diff
+```
+composer require sebastian/diff
+```
 
 If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency:
 
-    composer require --dev sebastian/diff
+```
+composer require --dev sebastian/diff
+```
 
 ### Usage
 
@@ -37,7 +44,7 @@ The code above yields the output below:
 
 There are three output builders available in this package:
 
-#### UnifiedDiffOutputBuilder 
+#### UnifiedDiffOutputBuilder
 
 This is default builder, which generates the output close to udiff and is used by PHPUnit.
 
@@ -101,7 +108,7 @@ print $differ->diff('foo', 'bar');
 
 #### DiffOutputBuilderInterface
 
-You can pass any output builder to the `Differ` class as longs as it implements the `DiffOutputBuilderInterface`. 
+You can pass any output builder to the `Differ` class as longs as it implements the `DiffOutputBuilderInterface`.
 
 #### Parsing diff
 

vendor/sebastian/diff/build.xml

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="diff" default="setup">
-    <target name="setup" depends="clean,composer"/>
-
-    <target name="clean" description="Cleanup build artifacts">
-        <delete dir="${basedir}/vendor"/>
-        <delete file="${basedir}/composer.lock"/>
-    </target>
-
-    <target name="composer" depends="clean" description="Install dependencies with Composer">
-        <exec executable="composer" taskname="composer">
-            <arg value="update"/>
-            <arg value="--no-interaction"/>
-            <arg value="--no-progress"/>
-            <arg value="--no-ansi"/>
-            <arg value="--no-suggest"/>
-            <arg value="--optimize-autoloader"/>
-            <arg value="--prefer-stable"/>
-        </exec>
-    </target>
-</project>
-

vendor/sebastian/diff/composer.json

@@ -14,12 +14,20 @@
             "email": "mail@kore-nordmann.de"
         }
     ],
+    "prefer-stable": true,
+    "config": {
+        "platform": {
+            "php": "7.3.0"
+        },
+        "optimize-autoloader": true,
+        "sort-packages": true
+    },
     "require": {
-        "php": ">=7.1"
+        "php": ">=7.3"
     },
     "require-dev": {
-        "phpunit/phpunit": "^7.5 || ^8.0",
-        "symfony/process": "^2 || ^3.3 || ^4"
+        "phpunit/phpunit": "^9.3",
+        "symfony/process": "^4.2 || ^5"
     },
     "autoload": {
         "classmap": [
@@ -33,7 +41,7 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "3.0-dev"
+            "dev-master": "4.0-dev"
         }
     }
 }

vendor/sebastian/diff/phpunit.xml

@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/7.2/phpunit.xsd"
-         bootstrap="vendor/autoload.php"
-         forceCoversAnnotation="true"
-         beStrictAboutCoversAnnotation="true"
-         beStrictAboutOutputDuringTests="true"
-         beStrictAboutTodoAnnotatedTests="true"
-         verbose="true">
-    <testsuites>
-        <testsuite name="default">
-            <directory suffix="Test.php">tests</directory>
-        </testsuite>
-    </testsuites>
-
-    <filter>
-        <whitelist processUncoveredFilesFromWhitelist="true">
-            <directory suffix=".php">src</directory>
-        </whitelist>
-    </filter>
-</phpunit>

vendor/sebastian/diff/src/Chunk.php

@@ -7,7 +7,6 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
 namespace SebastianBergmann\Diff;
 
 final class Chunk

vendor/sebastian/diff/src/Diff.php

@@ -7,7 +7,6 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
 namespace SebastianBergmann\Diff;
 
 final class Diff
@@ -28,8 +27,6 @@ final class Diff
     private $chunks;
 
     /**
-     * @param string  $from
-     * @param string  $to
      * @param Chunk[] $chunks
      */
     public function __construct(string $from, string $to, array $chunks = [])

vendor/sebastian/diff/src/Differ.php

@@ -7,21 +7,42 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
 namespace SebastianBergmann\Diff;
 
+use const PHP_INT_SIZE;
+use const PREG_SPLIT_DELIM_CAPTURE;
+use const PREG_SPLIT_NO_EMPTY;
+use function array_shift;
+use function array_unshift;
+use function array_values;
+use function count;
+use function current;
+use function end;
+use function get_class;
+use function gettype;
+use function is_array;
+use function is_object;
+use function is_string;
+use function key;
+use function min;
+use function preg_split;
+use function prev;
+use function reset;
+use function sprintf;
+use function substr;
 use SebastianBergmann\Diff\Output\DiffOutputBuilderInterface;
 use SebastianBergmann\Diff\Output\UnifiedDiffOutputBuilder;
 
-/**
- * Diff implementation.
- */
 final class Differ
 {
     public const OLD                     = 0;
+
     public const ADDED                   = 1;
+
     public const REMOVED                 = 2;
+
     public const DIFF_LINE_END_WARNING   = 3;
+
     public const NO_LINE_END_EOF_WARNING = 4;
 
     /**
@@ -40,16 +61,16 @@ final class Differ
             $this->outputBuilder = $outputBuilder;
         } elseif (null === $outputBuilder) {
             $this->outputBuilder = new UnifiedDiffOutputBuilder;
-        } elseif (\is_string($outputBuilder)) {
+        } elseif (is_string($outputBuilder)) {
             // PHPUnit 6.1.4, 6.2.0, 6.2.1, 6.2.2, and 6.2.3 support
             // @see https://github.com/sebastianbergmann/phpunit/issues/2734#issuecomment-314514056
             // @deprecated
             $this->outputBuilder = new UnifiedDiffOutputBuilder($outputBuilder);
         } else {
             throw new InvalidArgumentException(
-                \sprintf(
+                sprintf(
                     'Expected builder to be an instance of DiffOutputBuilderInterface, <null> or a string, got %s.',
-                    \is_object($outputBuilder) ? 'instance of "' . \get_class($outputBuilder) . '"' : \gettype($outputBuilder) . ' "' . $outputBuilder . '"'
+                    is_object($outputBuilder) ? 'instance of "' . get_class($outputBuilder) . '"' : gettype($outputBuilder) . ' "' . $outputBuilder . '"'
                 )
             );
         }
@@ -58,11 +79,8 @@ final class Differ
     /**
      * Returns the diff between two arrays or strings as string.
      *
-     * @param array|string                            $from
-     * @param array|string                            $to
-     * @param null|LongestCommonSubsequenceCalculator $lcs
-     *
-     * @return string
+     * @param array|string $from
+     * @param array|string $to
      */
     public function diff($from, $to, LongestCommonSubsequenceCalculator $lcs = null): string
     {
@@ -89,20 +107,18 @@ final class Differ
      * @param array|string                       $from
      * @param array|string                       $to
      * @param LongestCommonSubsequenceCalculator $lcs
-     *
-     * @return array
      */
     public function diffToArray($from, $to, LongestCommonSubsequenceCalculator $lcs = null): array
     {
-        if (\is_string($from)) {
+        if (is_string($from)) {
             $from = $this->splitStringByLines($from);
-        } elseif (!\is_array($from)) {
+        } elseif (!is_array($from)) {
             throw new InvalidArgumentException('"from" must be an array or string.');
         }
 
-        if (\is_string($to)) {
+        if (is_string($to)) {
             $to = $this->splitStringByLines($to);
-        } elseif (!\is_array($to)) {
+        } elseif (!is_array($to)) {
             throw new InvalidArgumentException('"to" must be an array or string.');
         }
 
@@ -112,36 +128,36 @@ final class Differ
             $lcs = $this->selectLcsImplementation($from, $to);
         }
 
-        $common = $lcs->calculate(\array_values($from), \array_values($to));
+        $common = $lcs->calculate(array_values($from), array_values($to));
         $diff   = [];
 
         foreach ($start as $token) {
             $diff[] = [$token, self::OLD];
         }
 
-        \reset($from);
-        \reset($to);
+        reset($from);
+        reset($to);
 
         foreach ($common as $token) {
-            while (($fromToken = \reset($from)) !== $token) {
-                $diff[] = [\array_shift($from), self::REMOVED];
+            while (($fromToken = reset($from)) !== $token) {
+                $diff[] = [array_shift($from), self::REMOVED];
             }
 
-            while (($toToken = \reset($to)) !== $token) {
-                $diff[] = [\array_shift($to), self::ADDED];
+            while (($toToken = reset($to)) !== $token) {
+                $diff[] = [array_shift($to), self::ADDED];
             }
 
             $diff[] = [$token, self::OLD];
 
-            \array_shift($from);
-            \array_shift($to);
+            array_shift($from);
+            array_shift($to);
         }
 
-        while (($token = \array_shift($from)) !== null) {
+        while (($token = array_shift($from)) !== null) {
             $diff[] = [$token, self::REMOVED];
         }
 
-        while (($token = \array_shift($to)) !== null) {
+        while (($token = array_shift($to)) !== null) {
             $diff[] = [$token, self::ADDED];
         }
 
@@ -150,7 +166,7 @@ final class Differ
         }
 
         if ($this->detectUnmatchedLineEndings($diff)) {
-            \array_unshift($diff, ["#Warning: Strings contain different line endings!\n", self::DIFF_LINE_END_WARNING]);
+            array_unshift($diff, ["#Warning: Strings contain different line endings!\n", self::DIFF_LINE_END_WARNING]);
         }
 
         return $diff;
@@ -159,13 +175,11 @@ final class Differ
     /**
      * Casts variable to string if it is not a string or array.
      *
-     * @param mixed $input
-     *
      * @return array|string
      */
     private function normalizeDiffInput($input)
     {
-        if (!\is_array($input) && !\is_string($input)) {
+        if (!is_array($input) && !is_string($input)) {
             return (string) $input;
         }
 
@@ -174,22 +188,12 @@ final class Differ
 
     /**
      * Checks if input is string, if so it will split it line-by-line.
-     *
-     * @param string $input
-     *
-     * @return array
      */
     private function splitStringByLines(string $input): array
     {
-        return \preg_split('/(.*\R)/', $input, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
+        return preg_split('/(.*\R)/', $input, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
     }
 
-    /**
-     * @param array $from
-     * @param array $to
-     *
-     * @return LongestCommonSubsequenceCalculator
-     */
     private function selectLcsImplementation(array $from, array $to): LongestCommonSubsequenceCalculator
     {
         // We do not want to use the time-efficient implementation if its memory
@@ -208,24 +212,17 @@ final class Differ
     /**
      * Calculates the estimated memory footprint for the DP-based method.
      *
-     * @param array $from
-     * @param array $to
-     *
      * @return float|int
      */
     private function calculateEstimatedFootprint(array $from, array $to)
     {
         $itemSize = PHP_INT_SIZE === 4 ? 76 : 144;
 
-        return $itemSize * \min(\count($from), \count($to)) ** 2;
+        return $itemSize * min(count($from), count($to)) ** 2;
     }
 
     /**
      * Returns true if line ends don't match in a diff.
-     *
-     * @param array $diff
-     *
-     * @return bool
      */
     private function detectUnmatchedLineEndings(array $diff): bool
     {
@@ -267,11 +264,11 @@ final class Differ
 
     private function getLinebreak($line): string
     {
-        if (!\is_string($line)) {
+        if (!is_string($line)) {
             return '';
         }
 
-        $lc = \substr($line, -1);
+        $lc = substr($line, -1);
 
         if ("\r" === $lc) {
             return "\r";
@@ -281,7 +278,7 @@ final class Differ
             return '';
         }
 
-        if ("\r\n" === \substr($line, -2)) {
+        if ("\r\n" === substr($line, -2)) {
             return "\r\n";
         }
 
@@ -293,10 +290,10 @@ final class Differ
         $start = [];
         $end   = [];
 
-        \reset($to);
+        reset($to);
 
         foreach ($from as $k => $v) {
-            $toK = \key($to);
+            $toK = key($to);
 
             if ($toK === $k && $v === $to[$k]) {
                 $start[$k] = $v;
@@ -307,19 +304,19 @@ final class Differ
             }
         }
 
-        \end($from);
-        \end($to);
+        end($from);
+        end($to);
 
         do {
-            $fromK = \key($from);
-            $toK   = \key($to);
+            $fromK = key($from);
+            $toK   = key($to);
 
-            if (null === $fromK || null === $toK || \current($from) !== \current($to)) {
+            if (null === $fromK || null === $toK || current($from) !== current($to)) {
                 break;
             }
 
-            \prev($from);
-            \prev($to);
+            prev($from);
+            prev($to);
 
             $end = [$fromK => $from[$fromK]] + $end;
             unset($from[$fromK], $to[$toK]);

vendor/sebastian/diff/src/Exception/ConfigurationException.php

@@ -7,31 +7,29 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
 namespace SebastianBergmann\Diff;
 
+use function get_class;
+use function gettype;
+use function is_object;
+use function sprintf;
+use Exception;
+
 final class ConfigurationException extends InvalidArgumentException
 {
-    /**
-     * @param string          $option
-     * @param string          $expected
-     * @param mixed           $value
-     * @param int             $code
-     * @param null|\Exception $previous
-     */
     public function __construct(
         string $option,
         string $expected,
         $value,
         int $code = 0,
-        \Exception $previous = null
+        Exception $previous = null
     ) {
         parent::__construct(
-            \sprintf(
+            sprintf(
                 'Option "%s" must be %s, got "%s".',
                 $option,
                 $expected,
-                \is_object($value) ? \get_class($value) : (null === $value ? '<null>' : \gettype($value) . '#' . $value)
+                is_object($value) ? get_class($value) : (null === $value ? '<null>' : gettype($value) . '#' . $value)
             ),
             $code,
             $previous

vendor/sebastian/diff/src/Exception/Exception.php

@@ -7,9 +7,10 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
 namespace SebastianBergmann\Diff;
 
-interface Exception
+use Throwable;
+
+interface Exception extends Throwable
 {
 }

vendor/sebastian/diff/src/Exception/InvalidArgumentException.php

@@ -7,7 +7,6 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
 namespace SebastianBergmann\Diff;
 
 class InvalidArgumentException extends \InvalidArgumentException implements Exception

vendor/sebastian/diff/src/Line.php

@@ -7,13 +7,14 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
 namespace SebastianBergmann\Diff;
 
 final class Line
 {
     public const ADDED     = 1;
+
     public const REMOVED   = 2;
+
     public const UNCHANGED = 3;
 
     /**

vendor/sebastian/diff/src/LongestCommonSubsequenceCalculator.php

@@ -7,18 +7,12 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
 namespace SebastianBergmann\Diff;
 
 interface LongestCommonSubsequenceCalculator
 {
     /**
      * Calculates the longest common subsequence of two arrays.
-     *
-     * @param array $from
-     * @param array $to
-     *
-     * @return array
      */
     public function calculate(array $from, array $to): array;
 }

vendor/sebastian/diff/src/MemoryEfficientLongestCommonSubsequenceCalculator.php

@@ -7,9 +7,16 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
 namespace SebastianBergmann\Diff;
 
+use function array_fill;
+use function array_merge;
+use function array_reverse;
+use function array_slice;
+use function count;
+use function in_array;
+use function max;
+
 final class MemoryEfficientLongestCommonSubsequenceCalculator implements LongestCommonSubsequenceCalculator
 {
     /**
@@ -17,15 +24,15 @@ final class MemoryEfficientLongestCommonSubsequenceCalculator implements Longest
      */
     public function calculate(array $from, array $to): array
     {
-        $cFrom = \count($from);
-        $cTo   = \count($to);
+        $cFrom = count($from);
+        $cTo   = count($to);
 
         if ($cFrom === 0) {
             return [];
         }
 
         if ($cFrom === 1) {
-            if (\in_array($from[0], $to, true)) {
+            if (in_array($from[0], $to, true)) {
                 return [$from[0]];
             }
 
@@ -33,10 +40,10 @@ final class MemoryEfficientLongestCommonSubsequenceCalculator implements Longest
         }
 
         $i         = (int) ($cFrom / 2);
-        $fromStart = \array_slice($from, 0, $i);
-        $fromEnd   = \array_slice($from, $i);
+        $fromStart = array_slice($from, 0, $i);
+        $fromEnd   = array_slice($from, $i);
         $llB       = $this->length($fromStart, $to);
-        $llE       = $this->length(\array_reverse($fromEnd), \array_reverse($to));
+        $llE       = $this->length(array_reverse($fromEnd), array_reverse($to));
         $jMax      = 0;
         $max       = 0;
 
@@ -49,10 +56,10 @@ final class MemoryEfficientLongestCommonSubsequenceCalculator implements Longest
             }
         }
 
-        $toStart = \array_slice($to, 0, $jMax);
-        $toEnd   = \array_slice($to, $jMax);
+        $toStart = array_slice($to, 0, $jMax);
+        $toEnd   = array_slice($to, $jMax);
 
-        return \array_merge(
+        return array_merge(
             $this->calculate($fromStart, $toStart),
             $this->calculate($fromEnd, $toEnd)
         );
@@ -60,9 +67,9 @@ final class MemoryEfficientLongestCommonSubsequenceCalculator implements Longest
 
     private function length(array $from, array $to): array
     {
-        $current = \array_fill(0, \count($to) + 1, 0);
-        $cFrom   = \count($from);
-        $cTo     = \count($to);
+        $current = array_fill(0, count($to) + 1, 0);
+        $cFrom   = count($from);
+        $cTo     = count($to);
 
         for ($i = 0; $i < $cFrom; $i++) {
             $prev = $current;
@@ -71,7 +78,7 @@ final class MemoryEfficientLongestCommonSubsequenceCalculator implements Longest
                 if ($from[$i] === $to[$j]) {
                     $current[$j + 1] = $prev[$j] + 1;
                 } else {
-                    $current[$j + 1] = \max($current[$j], $prev[$j + 1]);
+                    $current[$j + 1] = max($current[$j], $prev[$j + 1]);
                 }
             }
         }

vendor/sebastian/diff/src/Output/AbstractChunkOutputBuilder.php

@@ -7,23 +7,19 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
 namespace SebastianBergmann\Diff\Output;
 
+use function count;
+
 abstract class AbstractChunkOutputBuilder implements DiffOutputBuilderInterface
 {
     /**
      * Takes input of the diff array and returns the common parts.
      * Iterates through diff line by line.
-     *
-     * @param array $diff
-     * @param int   $lineThreshold
-     *
-     * @return array
      */
     protected function getCommonChunks(array $diff, int $lineThreshold = 5): array
     {
-        $diffSize     = \count($diff);
+        $diffSize     = count($diff);
         $capturing    = false;
         $chunkStart   = 0;
         $chunkSize    = 0;

vendor/sebastian/diff/src/Output/DiffOnlyOutputBuilder.php

@@ -7,9 +7,13 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
 namespace SebastianBergmann\Diff\Output;
 
+use function fclose;
+use function fopen;
+use function fwrite;
+use function stream_get_contents;
+use function substr;
 use SebastianBergmann\Diff\Differ;
 
 /**
@@ -30,38 +34,38 @@ final class DiffOnlyOutputBuilder implements DiffOutputBuilderInterface
 
     public function getDiff(array $diff): string
     {
-        $buffer = \fopen('php://memory', 'r+b');
+        $buffer = fopen('php://memory', 'r+b');
 
         if ('' !== $this->header) {
-            \fwrite($buffer, $this->header);
+            fwrite($buffer, $this->header);
 
-            if ("\n" !== \substr($this->header, -1, 1)) {
-                \fwrite($buffer, "\n");
+            if ("\n" !== substr($this->header, -1, 1)) {
+                fwrite($buffer, "\n");
             }
         }
 
         foreach ($diff as $diffEntry) {
             if ($diffEntry[1] === Differ::ADDED) {
-                \fwrite($buffer, '+' . $diffEntry[0]);
+                fwrite($buffer, '+' . $diffEntry[0]);
             } elseif ($diffEntry[1] === Differ::REMOVED) {
-                \fwrite($buffer, '-' . $diffEntry[0]);
+                fwrite($buffer, '-' . $diffEntry[0]);
             } elseif ($diffEntry[1] === Differ::DIFF_LINE_END_WARNING) {
-                \fwrite($buffer, ' ' . $diffEntry[0]);
+                fwrite($buffer, ' ' . $diffEntry[0]);
 
                 continue; // Warnings should not be tested for line break, it will always be there
             } else { /* Not changed (old) 0 */
                 continue; // we didn't write the non changs line, so do not add a line break either
             }
 
-            $lc = \substr($diffEntry[0], -1);
+            $lc = substr($diffEntry[0], -1);
 
             if ($lc !== "\n" && $lc !== "\r") {
-                \fwrite($buffer, "\n"); // \No newline at end of file
+                fwrite($buffer, "\n"); // \No newline at end of file
             }
         }
 
-        $diff = \stream_get_contents($buffer, -1, 0);
-        \fclose($buffer);
+        $diff = stream_get_contents($buffer, -1, 0);
+        fclose($buffer);
 
         return $diff;
     }

vendor/sebastian/diff/src/Output/DiffOutputBuilderInterface.php

@@ -7,7 +7,6 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
 namespace SebastianBergmann\Diff\Output;
 
 /**