Initial commit，修正

vendor/codeception/lib-web/src/Constraint/Page.php

@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Codeception\Constraint;
+
+use PHPUnit\Framework\Constraint\Constraint;
+
+use function mb_stripos;
+use function mb_strlen;
+use function mb_substr;
+use function preg_replace;
+use function sprintf;
+use function strtr;
+use function trim;
+
+class Page extends Constraint
+{
+    protected string $uri;
+
+    protected string $string;
+
+    public function __construct(string $string, string $uri = '')
+    {
+        $this->string = $this->normalizeText($string);
+        $this->uri = $uri;
+    }
+
+    /**
+     * Evaluates the constraint for parameter $other. Returns true if the
+     * constraint is met, false otherwise.
+     *
+     * @param string $other Value or object to evaluate.
+     * @return bool
+     */
+    protected function matches($other): bool
+    {
+        $other = $this->normalizeText($other);
+        return mb_stripos($other, $this->string, 0, 'UTF-8') !== false;
+    }
+
+    private function normalizeText(string $text): string
+    {
+        $text = strtr($text, "\r\n", "  ");
+        return trim(preg_replace('/\\s{2,}/', ' ', $text));
+    }
+
+    /**
+     * Returns a string representation of the constraint.
+     */
+    public function toString(): string
+    {
+        return sprintf(
+            'contains "%s"',
+            $this->string
+        );
+    }
+
+    /**
+     * @param string $pageContent
+     */
+    protected function failureDescription($pageContent): string
+    {
+        $message = $this->uriMessage('on page');
+        $message .= "\n--> ";
+        $message .= mb_substr($pageContent, 0, 300, 'utf-8');
+        if (mb_strlen($pageContent, 'utf-8') > 300 && function_exists('codecept_output_dir')) {
+            $message .= "\n[Content too long to display. See complete response in '"
+                . codecept_output_dir() . "' directory]";
+        }
+
+        return $message . "\n--> " . $this->toString();
+    }
+
+    protected function uriMessage(string $onPage = ''): string
+    {
+        if (!$this->uri) {
+            return '';
+        }
+        return "{$onPage} {$this->uri}";
+    }
+}

vendor/codeception/lib-web/src/Exception/ElementNotFound.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Codeception\Exception;
+
+use Codeception\Util\Locator;
+use PHPUnit\Framework\AssertionFailedError;
+
+use function is_string;
+
+class ElementNotFound extends AssertionFailedError
+{
+    public function __construct($selector, string $message = '')
+    {
+        if (!is_string($selector) || !str_contains($selector, "'")) {
+            $selector = Locator::humanReadableString($selector);
+        }
+        parent::__construct("{$message} element with {$selector} was not found.");
+    }
+}

vendor/codeception/lib-web/src/Exception/MalformedLocatorException.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Codeception\Exception;
+
+use function ucfirst;
+
+class MalformedLocatorException extends \RuntimeException
+{
+    public function __construct(string $locator, string $type = 'CSS or XPath')
+    {
+        parent::__construct(ucfirst($type) . " locator is malformed: {$locator}");
+    }
+}

vendor/codeception/lib-web/src/Lib/Interfaces/ElementLocator.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Codeception\Lib\Interfaces;
+
+interface ElementLocator
+{
+    /**
+     * Locates element using available Codeception locator types:
+     *
+     * * XPath
+     * * CSS
+     * * Strict Locator
+     *
+     * Use it in Helpers or GroupObject or Extension classes:
+     *
+     * ```php
+     * <?php
+     * $els = $this->getModule('{{MODULE_NAME}}')->_findElements('.items');
+     * $els = $this->getModule('{{MODULE_NAME}}')->_findElements(['name' => 'username']);
+     *
+     * $editLinks = $this->getModule('{{MODULE_NAME}}')->_findElements(['link' => 'Edit']);
+     * // now you can iterate over $editLinks and check that all them have valid hrefs
+     * ```
+     *
+     * WebDriver module returns `Facebook\WebDriver\Remote\RemoteWebElement` instances
+     * PhpBrowser and Framework modules return `Symfony\Component\DomCrawler\Crawler` instances
+     *
+     * @api
+     */
+    public function _findElements(mixed $locator): iterable;
+}

vendor/codeception/lib-web/src/Lib/Interfaces/MultiSession.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Codeception\Lib\Interfaces;
+
+interface MultiSession
+{
+    public function _initializeSession(): void;
+
+    public function _loadSession($session): void;
+
+    public function _backupSession();
+
+    public function _closeSession($session = null): void;
+
+    public function _getName(): string;
+}

vendor/codeception/lib-web/src/Lib/Interfaces/PageSourceSaver.php

@@ -0,0 +1,31 @@
+<?php
+
+// phpcs:disable Generic.Files.LineLength.TooLong
+
+namespace Codeception\Lib\Interfaces;
+
+interface PageSourceSaver
+{
+    /**
+     * Saves page source of to a file
+     *
+     * ```php
+     * $this->getModule('{{MODULE_NAME}}')->_savePageSource(codecept_output_dir().'page.html');
+     * ```
+     * @api
+     */
+    public function _savePageSource(string $filename): void;
+
+    /**
+     * Use this method within an [interactive pause](https://codeception.com/docs/02-GettingStarted#Interactive-Pause) to save the HTML source code of the current page.
+     *
+     * ```php
+     * <?php
+     * $I->makeHtmlSnapshot('edit_page');
+     * // saved to: tests/_output/debug/edit_page.html
+     * $I->makeHtmlSnapshot();
+     * // saved to: tests/_output/debug/2017-05-26_14-24-11_4b3403665fea6.html
+     * ```
+     */
+    public function makeHtmlSnapshot(string $name = null): void;
+}

vendor/codeception/lib-web/src/Lib/Interfaces/Remote.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Codeception\Lib\Interfaces;
+
+interface Remote
+{
+    /**
+     * Changes the subdomain for the 'url' configuration parameter.
+     * Does not open a page; use `amOnPage` for that.
+     *
+     * ``` php
+     * <?php
+     * // If config is: 'https://mysite.com'
+     * // or config is: 'https://www.mysite.com'
+     * // or config is: 'https://company.mysite.com'
+     *
+     * $I->amOnSubdomain('user');
+     * $I->amOnPage('/');
+     * // moves to https://user.mysite.com/
+     * ```
+     *
+     */
+    public function amOnSubdomain(string $subdomain): void;
+
+    /**
+     * Open web page at the given absolute URL and sets its hostname as the base host.
+     *
+     * ``` php
+     * <?php
+     * $I->amOnUrl('https://codeception.com');
+     * $I->amOnPage('/quickstart'); // moves to https://codeception.com/quickstart
+     * ```
+     */
+    public function amOnUrl(string $url): void;
+
+    public function _getUrl();
+}

vendor/codeception/lib-web/src/Lib/Interfaces/ScreenshotSaver.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Codeception\Lib\Interfaces;
+
+interface ScreenshotSaver
+{
+    /**
+     * Saves screenshot of current page to a file
+     *
+     * ```php
+     * $this->getModule('{{MODULE_NAME}}')->_saveScreenshot(codecept_output_dir().'screenshot_1.png');
+     * ```
+     * @api
+     */
+    public function _saveScreenshot(string $filename);
+}

vendor/codeception/lib-web/src/Lib/Interfaces/SessionSnapshot.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Codeception\Lib\Interfaces;
+
+interface SessionSnapshot
+{
+    /**
+     * Saves current cookies into named snapshot in order to restore them in other tests
+     * This is useful to save session state between tests.
+     * For example, if user needs log in to site for each test this scenario can be executed once
+     * while other tests can just restore saved cookies.
+     *
+     * ``` php
+     * <?php
+     * // inside AcceptanceTester class:
+     *
+     * public function login()
+     * {
+     *      // if snapshot exists - skipping login
+     *      if ($I->loadSessionSnapshot('login')) return;
+     *
+     *      // logging in
+     *      $I->amOnPage('/login');
+     *      $I->fillField('name', 'jon');
+     *      $I->fillField('password', '123345');
+     *      $I->click('Login');
+     *
+     *      // saving snapshot
+     *      $I->saveSessionSnapshot('login');
+     * }
+     * ```
+     *
+     * @return mixed
+     */
+    public function saveSessionSnapshot(string $name);
+
+    /**
+     * Loads cookies from a saved snapshot.
+     * Allows to reuse same session across tests without additional login.
+     *
+     * See [saveSessionSnapshot](#saveSessionSnapshot)
+     *
+     * @return mixed
+     */
+    public function loadSessionSnapshot(string $name);
+
+    /**
+     * Deletes session snapshot.
+     *
+     * See [saveSessionSnapshot](#saveSessionSnapshot)
+     *
+     * @return mixed
+     */
+    public function deleteSessionSnapshot(string $name);
+}

vendor/codeception/lib-web/src/Lib/Interfaces/Web.php

@@ -0,0 +1,840 @@
+<?php
+
+// phpcs:disable Generic.Files.LineLength.TooLong
+
+namespace Codeception\Lib\Interfaces;
+
+interface Web
+{
+    /**
+     * Opens the page for the given relative URI.
+     *
+     * ```php
+     * <?php
+     * // opens front page
+     * $I->amOnPage('/');
+     * // opens /register page
+     * $I->amOnPage('/register');
+     * ```
+     */
+    public function amOnPage(string $page): void;
+
+    /**
+     * Checks that the current page contains the given string (case insensitive).
+     *
+     * You can specify a specific HTML element (via CSS or XPath) as the second
+     * parameter to only search within that element.
+     *
+     * ```php
+     * <?php
+     * $I->see('Logout');                        // I can suppose user is logged in
+     * $I->see('Sign Up', 'h1');                 // I can suppose it's a signup page
+     * $I->see('Sign Up', '//body/h1');          // with XPath
+     * $I->see('Sign Up', ['css' => 'body h1']); // with strict CSS locator
+     * ```
+     *
+     * Note that the search is done after stripping all HTML tags from the body,
+     * so `$I->see('strong')` will return true for strings like:
+     *
+     *   - `<p>I am Stronger than thou</p>`
+     *   - `<script>document.createElement('strong');</script>`
+     *
+     * But will *not* be true for strings like:
+     *
+     *   - `<strong>Home</strong>`
+     *   - `<div class="strong">Home</strong>`
+     *   - `<!-- strong -->`
+     *
+     * For checking the raw source code, use `seeInSource()`.
+     *
+     * @param array|string $selector optional
+     */
+    public function see(string $text, $selector = null): void;
+
+    /**
+     * Checks that the current page doesn't contain the text specified (case insensitive).
+     * Give a locator as the second parameter to match a specific region.
+     *
+     * ```php
+     * <?php
+     * $I->dontSee('Login');                         // I can suppose user is already logged in
+     * $I->dontSee('Sign Up','h1');                  // I can suppose it's not a signup page
+     * $I->dontSee('Sign Up','//body/h1');           // with XPath
+     * $I->dontSee('Sign Up', ['css' => 'body h1']); // with strict CSS locator
+     * ```
+     *
+     * Note that the search is done after stripping all HTML tags from the body,
+     * so `$I->dontSee('strong')` will fail on strings like:
+     *
+     *   - `<p>I am Stronger than thou</p>`
+     *   - `<script>document.createElement('strong');</script>`
+     *
+     * But will ignore strings like:
+     *
+     *   - `<strong>Home</strong>`
+     *   - `<div class="strong">Home</strong>`
+     *   - `<!-- strong -->`
+     *
+     * For checking the raw source code, use `seeInSource()`.
+     *
+     * @param array|string $selector optional
+     */
+    public function dontSee(string $text, $selector = null): void;
+
+    /**
+     * Checks that the current page contains the given string in its
+     * raw source code.
+     *
+     * ```php
+     * <?php
+     * $I->seeInSource('<h1>Green eggs &amp; ham</h1>');
+     * ```
+     */
+    public function seeInSource(string $raw): void;
+
+    /**
+     * Checks that the current page contains the given string in its
+     * raw source code.
+     *
+     * ```php
+     * <?php
+     * $I->dontSeeInSource('<h1>Green eggs &amp; ham</h1>');
+     * ```
+     */
+    public function dontSeeInSource(string $raw): void;
+
+    /**
+     * Submits the given form on the page, with the given form
+     * values.  Pass the form field's values as an array in the second
+     * parameter.
+     *
+     * Although this function can be used as a short-hand version of
+     * `fillField()`, `selectOption()`, `click()` etc. it has some important
+     * differences:
+     *
+     *  * Only field *names* may be used, not CSS/XPath selectors nor field labels
+     *  * If a field is sent to this function that does *not* exist on the page,
+     *    it will silently be added to the HTTP request.  This is helpful for testing
+     *    some types of forms, but be aware that you will *not* get an exception
+     *    like you would if you called `fillField()` or `selectOption()` with
+     *    a missing field.
+     *
+     * Fields that are not provided will be filled by their values from the page,
+     * or from any previous calls to `fillField()`, `selectOption()` etc.
+     * You don't need to click the 'Submit' button afterwards.
+     * This command itself triggers the request to form's action.
+     *
+     * You can optionally specify which button's value to include
+     * in the request with the last parameter (as an alternative to
+     * explicitly setting its value in the second parameter), as
+     * button values are not otherwise included in the request.
+     *
+     * Examples:
+     *
+     * ```php
+     * <?php
+     * $I->submitForm('#login', [
+     *     'login' => 'davert',
+     *     'password' => '123456'
+     * ]);
+     * // or
+     * $I->submitForm('#login', [
+     *     'login' => 'davert',
+     *     'password' => '123456'
+     * ], 'submitButtonName');
+     *
+     * ```
+     *
+     * For example, given this sample "Sign Up" form:
+     *
+     * ``` html
+     * <form id="userForm">
+     *     Login:
+     *     <input type="text" name="user[login]" /><br/>
+     *     Password:
+     *     <input type="password" name="user[password]" /><br/>
+     *     Do you agree to our terms?
+     *     <input type="checkbox" name="user[agree]" /><br/>
+     *     Subscribe to our newsletter?
+     *     <input type="checkbox" name="user[newsletter]" value="1" checked="checked" /><br/>
+     *     Select pricing plan:
+     *     <select name="plan">
+     *         <option value="1">Free</option>
+     *         <option value="2" selected="selected">Paid</option>
+     *     </select>
+     *     <input type="submit" name="submitButton" value="Submit" />
+     * </form>
+     * ```
+     *
+     * You could write the following to submit it:
+     *
+     * ```php
+     * <?php
+     * $I->submitForm(
+     *     '#userForm',
+     *     [
+     *         'user' => [
+     *             'login' => 'Davert',
+     *             'password' => '123456',
+     *             'agree' => true
+     *         ]
+     *     ],
+     *     'submitButton'
+     * );
+     * ```
+     * Note that "2" will be the submitted value for the "plan" field, as it is
+     * the selected option.
+     *
+     * To uncheck the pre-checked checkbox "newsletter", call `$I->uncheckOption(['name' => 'user[newsletter]']);` *before*,
+     * then submit the form as shown here (i.e. without the "newsletter" field in the `$params` array).
+     *
+     * You can also emulate a JavaScript submission by not specifying any
+     * buttons in the third parameter to submitForm.
+     *
+     * ```php
+     * <?php
+     * $I->submitForm(
+     *     '#userForm',
+     *     [
+     *         'user' => [
+     *             'login' => 'Davert',
+     *             'password' => '123456',
+     *             'agree' => true
+     *         ]
+     *     ]
+     * );
+     * ```
+     *
+     * This function works well when paired with `seeInFormFields()`
+     * for quickly testing CRUD interfaces and form validation logic.
+     *
+     * ```php
+     * <?php
+     * $form = [
+     *      'field1' => 'value',
+     *      'field2' => 'another value',
+     *      'checkbox1' => true,
+     *      // ...
+     * ];
+     * $I->submitForm('#my-form', $form, 'submitButton');
+     * // $I->amOnPage('/path/to/form-page') may be needed
+     * $I->seeInFormFields('#my-form', $form);
+     * ```
+     *
+     * Parameter values can be set to arrays for multiple input fields
+     * of the same name, or multi-select combo boxes.  For checkboxes,
+     * you can use either the string value or boolean `true`/`false` which will
+     * be replaced by the checkbox's value in the DOM.
+     *
+     * ```php
+     * <?php
+     * $I->submitForm('#my-form', [
+     *      'field1' => 'value',
+     *      'checkbox' => [
+     *          'value of first checkbox',
+     *          'value of second checkbox',
+     *      ],
+     *      'otherCheckboxes' => [
+     *          true,
+     *          false,
+     *          false
+     *      ],
+     *      'multiselect' => [
+     *          'first option value',
+     *          'second option value'
+     *      ]
+     * ]);
+     * ```
+     *
+     * Mixing string and boolean values for a checkbox's value is not supported
+     * and may produce unexpected results.
+     *
+     * Field names ending in `[]` must be passed without the trailing square
+     * bracket characters, and must contain an array for its value.  This allows
+     * submitting multiple values with the same name, consider:
+     *
+     * ```php
+     * <?php
+     * // This will NOT work correctly
+     * $I->submitForm('#my-form', [
+     *     'field[]' => 'value',
+     *     'field[]' => 'another value',  // 'field[]' is already a defined key
+     * ]);
+     * ```
+     *
+     * The solution is to pass an array value:
+     *
+     * ```php
+     * <?php
+     * // This way both values are submitted
+     * $I->submitForm('#my-form', [
+     *     'field' => [
+     *         'value',
+     *         'another value',
+     *     ]
+     * ]);
+     * ```
+     */
+    public function submitForm($selector, array $params, string $button = null): void;
+
+    /**
+     * Perform a click on a link or a button, given by a locator.
+     * If a fuzzy locator is given, the page will be searched for a button, link, or image matching the locator string.
+     * For buttons, the "value" attribute, "name" attribute, and inner text are searched.
+     * For links, the link text is searched.
+     * For images, the "alt" attribute and inner text of any parent links are searched.
+     *
+     * The second parameter is a context (CSS or XPath locator) to narrow the search.
+     *
+     * Note that if the locator matches a button of type `submit`, the form will be submitted.
+     *
+     * ```php
+     * <?php
+     * // simple link
+     * $I->click('Logout');
+     * // button of form
+     * $I->click('Submit');
+     * // CSS button
+     * $I->click('#form input[type=submit]');
+     * // XPath
+     * $I->click('//form/*[@type="submit"]');
+     * // link in context
+     * $I->click('Logout', '#nav');
+     * // using strict locator
+     * $I->click(['link' => 'Login']);
+     * ```
+     * @param string|array $link
+     */
+    public function click($link, $context = null): void;
+
+    /**
+     * Checks that there's a link with the specified text.
+     * Give a full URL as the second parameter to match links with that exact URL.
+     *
+     * ```php
+     * <?php
+     * $I->seeLink('Logout'); // matches <a href="#">Logout</a>
+     * $I->seeLink('Logout','/logout'); // matches <a href="/logout">Logout</a>
+     * ```
+     */
+    public function seeLink(string $text, string $url = null): void;
+
+    /**
+     * Checks that the page doesn't contain a link with the given string.
+     * If the second parameter is given, only links with a matching "href" attribute will be checked.
+     *
+     * ```php
+     * <?php
+     * $I->dontSeeLink('Logout'); // I suppose user is not logged in
+     * $I->dontSeeLink('Checkout now', '/store/cart.php');
+     * ```
+     */
+    public function dontSeeLink(string $text, string $url = ''): void;
+
+    /**
+     * Checks that current URI contains the given string.
+     *
+     * ```php
+     * <?php
+     * // to match: /home/dashboard
+     * $I->seeInCurrentUrl('home');
+     * // to match: /users/1
+     * $I->seeInCurrentUrl('/users/');
+     * ```
+     */
+    public function seeInCurrentUrl(string $uri): void;
+
+    /**
+     * Checks that the current URL is equal to the given string.
+     * Unlike `seeInCurrentUrl`, this only matches the full URL.
+     *
+     * ```php
+     * <?php
+     * // to match root url
+     * $I->seeCurrentUrlEquals('/');
+     * ```
+     */
+    public function seeCurrentUrlEquals(string $uri): void;
+
+    /**
+     * Checks that the current URL matches the given regular expression.
+     *
+     * ```php
+     * <?php
+     * // to match root url
+     * $I->seeCurrentUrlMatches('~^/users/(\d+)~');
+     * ```
+     */
+    public function seeCurrentUrlMatches(string $uri): void;
+
+    /**
+     * Checks that the current URI doesn't contain the given string.
+     *
+     * ```php
+     * <?php
+     * $I->dontSeeInCurrentUrl('/users/');
+     * ```
+     */
+    public function dontSeeInCurrentUrl(string $uri): void;
+
+    /**
+     * Checks that the current URL doesn't equal the given string.
+     * Unlike `dontSeeInCurrentUrl`, this only matches the full URL.
+     *
+     * ```php
+     * <?php
+     * // current url is not root
+     * $I->dontSeeCurrentUrlEquals('/');
+     * ```
+     */
+    public function dontSeeCurrentUrlEquals(string $uri): void;
+
+    /**
+     * Checks that current url doesn't match the given regular expression.
+     *
+     * ```php
+     * <?php
+     * // to match root url
+     * $I->dontSeeCurrentUrlMatches('~^/users/(\d+)~');
+     * ```
+     */
+    public function dontSeeCurrentUrlMatches(string $uri): void;
+
+    /**
+     * Executes the given regular expression against the current URI and returns the first capturing group.
+     * If no parameters are provided, the full URI is returned.
+     *
+     * ```php
+     * <?php
+     * $user_id = $I->grabFromCurrentUrl('~^/user/(\d+)/~');
+     * $uri = $I->grabFromCurrentUrl();
+     * ```
+     */
+    public function grabFromCurrentUrl(string $uri = null): mixed;
+
+    /**
+     * Checks that the specified checkbox is checked.
+     *
+     * ```php
+     * <?php
+     * $I->seeCheckboxIsChecked('#agree'); // I suppose user agreed to terms
+     * $I->seeCheckboxIsChecked('#signup_form input[type=checkbox]'); // I suppose user agreed to terms, If there is only one checkbox in form.
+     * $I->seeCheckboxIsChecked('//form/input[@type=checkbox and @name=agree]');
+     * ```
+     */
+    public function seeCheckboxIsChecked($checkbox): void;
+
+    /**
+     * Check that the specified checkbox is unchecked.
+     *
+     * ```php
+     * <?php
+     * $I->dontSeeCheckboxIsChecked('#agree'); // I suppose user didn't agree to terms
+     * $I->seeCheckboxIsChecked('#signup_form input[type=checkbox]'); // I suppose user didn't check the first checkbox in form.
+     * ```
+     */
+    public function dontSeeCheckboxIsChecked($checkbox): void;
+
+    /**
+     * Checks that the given input field or textarea *equals* (i.e. not just contains) the given value.
+     * Fields are matched by label text, the "name" attribute, CSS, or XPath.
+     *
+     * ```php
+     * <?php
+     * $I->seeInField('Body','Type your comment here');
+     * $I->seeInField('form textarea[name=body]','Type your comment here');
+     * $I->seeInField('form input[type=hidden]','hidden_value');
+     * $I->seeInField('#searchform input','Search');
+     * $I->seeInField('//form/*[@name=search]','Search');
+     * $I->seeInField(['name' => 'search'], 'Search');
+     * ```
+     *
+     * @param string|array $field
+     */
+    public function seeInField($field, $value): void;
+
+    /**
+     * Checks that an input field or textarea doesn't contain the given value.
+     * For fuzzy locators, the field is matched by label text, CSS and XPath.
+     *
+     * ```php
+     * <?php
+     * $I->dontSeeInField('Body','Type your comment here');
+     * $I->dontSeeInField('form textarea[name=body]','Type your comment here');
+     * $I->dontSeeInField('form input[type=hidden]','hidden_value');
+     * $I->dontSeeInField('#searchform input','Search');
+     * $I->dontSeeInField('//form/*[@name=search]','Search');
+     * $I->dontSeeInField(['name' => 'search'], 'Search');
+     * ```
+     * @param string|array $field
+     */
+    public function dontSeeInField($field, $value): void;
+
+    /**
+     * Checks if the array of form parameters (name => value) are set on the form matched with the
+     * passed selector.
+     *
+     * ```php
+     * <?php
+     * $I->seeInFormFields('form[name=myform]', [
+     *      'input1' => 'value',
+     *      'input2' => 'other value',
+     * ]);
+     * ```
+     *
+     * For multi-select elements, or to check values of multiple elements with the same name, an
+     * array may be passed:
+     *
+     * ```php
+     * <?php
+     * $I->seeInFormFields('.form-class', [
+     *      'multiselect' => [
+     *          'value1',
+     *          'value2',
+     *      ],
+     *      'checkbox[]' => [
+     *          'a checked value',
+     *          'another checked value',
+     *      ],
+     * ]);
+     * ```
+     *
+     * Additionally, checkbox values can be checked with a boolean.
+     *
+     * ```php
+     * <?php
+     * $I->seeInFormFields('#form-id', [
+     *      'checkbox1' => true,        // passes if checked
+     *      'checkbox2' => false,       // passes if unchecked
+     * ]);
+     * ```
+     *
+     * Pair this with submitForm for quick testing magic.
+     *
+     * ```php
+     * <?php
+     * $form = [
+     *      'field1' => 'value',
+     *      'field2' => 'another value',
+     *      'checkbox1' => true,
+     *      // ...
+     * ];
+     * $I->submitForm('//form[@id=my-form]', string $form, 'submitButton');
+     * // $I->amOnPage('/path/to/form-page') may be needed
+     * $I->seeInFormFields('//form[@id=my-form]', string $form);
+     * ```
+     */
+    public function seeInFormFields($formSelector, array $params): void;
+
+    /**
+     * Checks if the array of form parameters (name => value) are not set on the form matched with
+     * the passed selector.
+     *
+     * ```php
+     * <?php
+     * $I->dontSeeInFormFields('form[name=myform]', [
+     *      'input1' => 'non-existent value',
+     *      'input2' => 'other non-existent value',
+     * ]);
+     * ```
+     *
+     * To check that an element hasn't been assigned any one of many values, an array can be passed
+     * as the value:
+     *
+     * ```php
+     * <?php
+     * $I->dontSeeInFormFields('.form-class', [
+     *      'fieldName' => [
+     *          'This value shouldn\'t be set',
+     *          'And this value shouldn\'t be set',
+     *      ],
+     * ]);
+     * ```
+     *
+     * Additionally, checkbox values can be checked with a boolean.
+     *
+     * ```php
+     * <?php
+     * $I->dontSeeInFormFields('#form-id', [
+     *      'checkbox1' => true,        // fails if checked
+     *      'checkbox2' => false,       // fails if unchecked
+     * ]);
+     * ```
+     */
+    public function dontSeeInFormFields($formSelector, array $params): void;
+
+    /**
+     * Selects an option in a select tag or in radio button group.
+     *
+     * ```php
+     * <?php
+     * $I->selectOption('form select[name=account]', 'Premium');
+     * $I->selectOption('form input[name=payment]', 'Monthly');
+     * $I->selectOption('//form/select[@name=account]', 'Monthly');
+     * ```
+     *
+     * Provide an array for the second argument to select multiple options:
+     *
+     * ```php
+     * <?php
+     * $I->selectOption('Which OS do you use?', ['Windows', 'Linux']);
+     * ```
+     *
+     * Or provide an associative array for the second argument to specifically define which selection method should be used:
+     *
+     * ```php
+     * <?php
+     * $I->selectOption('Which OS do you use?', ['text' => 'Windows']); // Only search by text 'Windows'
+     * $I->selectOption('Which OS do you use?', ['value' => 'windows']); // Only search by value 'windows'
+     * ```
+     */
+    public function selectOption($select, $option): void;
+
+    /**
+     * Ticks a checkbox. For radio buttons, use the `selectOption` method instead.
+     *
+     * ```php
+     * <?php
+     * $I->checkOption('#agree');
+     * ```
+     */
+    public function checkOption($option): void;
+
+    /**
+     * Unticks a checkbox.
+     *
+     * ```php
+     * <?php
+     * $I->uncheckOption('#notify');
+     * ```
+     */
+    public function uncheckOption($option): void;
+
+    /**
+     * Fills a text field or textarea with the given string.
+     *
+     * ```php
+     * <?php
+     * $I->fillField("//input[@type='text']", "Hello World!");
+     * $I->fillField(['name' => 'email'], 'jon@example.com');
+     * ```
+     */
+    public function fillField($field, $value): void;
+
+    /**
+     * Attaches a file relative to the Codeception `_data` directory to the given file upload field.
+     *
+     * ```php
+     * <?php
+     * // file is stored in 'tests/_data/prices.xls'
+     * $I->attachFile('input[@type="file"]', 'prices.xls');
+     * ```
+     */
+    public function attachFile($field, string $filename): void;
+
+    /**
+     * Finds and returns the text contents of the given element.
+     * If a fuzzy locator is used, the element is found using CSS, XPath,
+     * and by matching the full page source by regular expression.
+     *
+     * ```php
+     * <?php
+     * $heading = $I->grabTextFrom('h1');
+     * $heading = $I->grabTextFrom('descendant-or-self::h1');
+     * $value = $I->grabTextFrom('~<input value=(.*?)]~sgi'); // match with a regex
+     * ```
+     */
+    public function grabTextFrom($cssOrXPathOrRegex): mixed;
+
+    /**
+     * Finds the value for the given form field.
+     * If a fuzzy locator is used, the field is found by field name, CSS, and XPath.
+     *
+     * ```php
+     * <?php
+     * $name = $I->grabValueFrom('Name');
+     * $name = $I->grabValueFrom('input[name=username]');
+     * $name = $I->grabValueFrom('descendant-or-self::form/descendant::input[@name = 'username']');
+     * $name = $I->grabValueFrom(['name' => 'username']);
+     * ```
+     */
+    public function grabValueFrom($field): mixed;
+
+    /**
+     * Grabs the value of the given attribute value from the given element.
+     * Fails if element is not found.
+     *
+     * ```php
+     * <?php
+     * $I->grabAttributeFrom('#tooltip', 'title');
+     * ```
+     */
+    public function grabAttributeFrom($cssOrXpath, string $attribute): mixed;
+
+    /**
+     * Grabs either the text content, or attribute values, of nodes
+     * matched by $cssOrXpath and returns them as an array.
+     *
+     * ```html
+     * <a href="#first">First</a>
+     * <a href="#second">Second</a>
+     * <a href="#third">Third</a>
+     * ```
+     *
+     * ```php
+     * <?php
+     * // would return ['First', 'Second', 'Third']
+     * $aLinkText = $I->grabMultiple('a');
+     *
+     * // would return ['#first', '#second', '#third']
+     * $aLinks = $I->grabMultiple('a', 'href');
+     * ```
+     *
+     * @return string[]
+     */
+    public function grabMultiple($cssOrXpath, string $attribute = null): array;
+
+    /**
+     * Checks that the given element exists on the page and is visible.
+     * You can also specify expected attributes of this element.
+     * Only works if `<html>` tag is present.
+     *
+     * ```php
+     * <?php
+     * $I->seeElement('.error');
+     * $I->seeElement('//form/input[1]');
+     * $I->seeElement('input', ['name' => 'login']);
+     * $I->seeElement('input', ['value' => '123456']);
+     *
+     * // strict locator in first arg, attributes in second
+     * $I->seeElement(['css' => 'form input'], ['name' => 'login']);
+     * ```
+     */
+    public function seeElement($selector, array $attributes = []): void;
+
+    /**
+     * Checks that the given element is invisible or not present on the page.
+     * You can also specify expected attributes of this element.
+     *
+     * ```php
+     * <?php
+     * $I->dontSeeElement('.error');
+     * $I->dontSeeElement('//form/input[1]');
+     * $I->dontSeeElement('input', ['name' => 'login']);
+     * $I->dontSeeElement('input', ['value' => '123456']);
+     * ```
+     */
+    public function dontSeeElement($selector, array $attributes = []): void;
+
+    /**
+     * Checks that there are a certain number of elements matched by the given locator on the page.
+     *
+     * ```php
+     * <?php
+     * $I->seeNumberOfElements('tr', 10);
+     * $I->seeNumberOfElements('tr', [0,10]); // between 0 and 10 elements
+     * ```
+     *
+     * @param int|int[] $expected
+     */
+    public function seeNumberOfElements($selector, array|int $expected): void;
+
+    /**
+     * Checks that the given option is selected.
+     *
+     * ```php
+     * <?php
+     * $I->seeOptionIsSelected('#form input[name=payment]', 'Visa');
+     * ```
+     *
+     * @return mixed|void
+     */
+    public function seeOptionIsSelected($selector, string $optionText);
+
+    /**
+     * Checks that the given option is not selected.
+     *
+     * ```php
+     * <?php
+     * $I->dontSeeOptionIsSelected('#form input[name=payment]', 'Visa');
+     * ```
+     *
+     * @return mixed|void
+     */
+    public function dontSeeOptionIsSelected($selector, string $optionText);
+
+    /**
+     * Checks that the page title contains the given string.
+     *
+     * ```php
+     * <?php
+     * $I->seeInTitle('Blog - Post #1');
+     * ```
+     *
+     * @return mixed|void
+     */
+    public function seeInTitle(string $title);
+
+    /**
+     * Checks that the page title does not contain the given string.
+     *
+     * @return mixed|void
+     */
+    public function dontSeeInTitle(string $title);
+
+    /**
+     * Checks that a cookie with the given name is set.
+     * You can set additional cookie params like `domain`, `path` as array passed in last argument.
+     *
+     * ```php
+     * <?php
+     * $I->seeCookie('PHPSESSID');
+     * ```
+     *
+     * @return mixed|void
+     */
+    public function seeCookie(string $cookie, array $params = []);
+
+    /**
+     * Checks that there isn't a cookie with the given name.
+     * You can set additional cookie params like `domain`, `path` as array passed in last argument.
+     *
+     * @return mixed|void
+     */
+    public function dontSeeCookie(string $cookie, array $params = []);
+
+    /**
+     * Sets a cookie with the given name and value.
+     * You can set additional cookie params like `domain`, `path`, `expires`, `secure` in array passed as last argument.
+     *
+     * ```php
+     * <?php
+     * $I->setCookie('PHPSESSID', 'el4ukv0kqbvoirg7nkp4dncpk3');
+     * ```
+     *
+     * @return mixed|void
+     */
+    public function setCookie(string $name, ?string $val, array $params = []);
+
+    /**
+     * Unsets cookie with the given name.
+     * You can set additional cookie params like `domain`, `path` in array passed as last argument.
+     *
+     * @return mixed|void
+     */
+    public function resetCookie(string $cookie, array $params = []);
+
+    /**
+     * Grabs a cookie value.
+     * You can set additional cookie params like `domain`, `path` in array passed as last argument.
+     * If the cookie is set by an ajax request (XMLHttpRequest), there might be some delay caused by the browser, so try `$I->wait(0.1)`.
+     */
+    public function grabCookie(string $cookie, array $params = []): mixed;
+
+    /**
+     * Grabs current page source code.
+     *
+     * @return string Current page source code.
+     */
+    public function grabPageSource(): string;
+}

vendor/codeception/lib-web/src/Util/Locator.php

@@ -0,0 +1,348 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Codeception\Util;
+
+use DOMDocument;
+use DOMXPath;
+use Exception;
+use Facebook\WebDriver\WebDriverBy;
+use InvalidArgumentException;
+use Symfony\Component\CssSelector\CssSelectorConverter;
+use Symfony\Component\CssSelector\Exception\ParseException;
+use Symfony\Component\CssSelector\XPath\Translator;
+
+use function abs;
+use function class_exists;
+use function func_get_args;
+use function implode;
+use function is_array;
+use function is_int;
+use function is_string;
+use function key;
+use function preg_match;
+use function sprintf;
+use function strtolower;
+
+/**
+ * Set of useful functions for using CSS and XPath locators.
+ * Please check them before writing complex functional or acceptance tests.
+ *
+ */
+class Locator
+{
+    /**
+     * Applies OR operator to any number of CSS or XPath selectors.
+     * You can mix up CSS and XPath selectors here.
+     *
+     * ```php
+     * <?php
+     * use \Codeception\Util\Locator;
+     *
+     * $I->see('Title', Locator::combine('h1','h2','h3'));
+     * ```
+     *
+     * This will search for `Title` text in either `h1`, `h2`, or `h3` tag.
+     * You can also combine CSS selector with XPath locator:
+     *
+     * ```php
+     * <?php
+     * use \Codeception\Util\Locator;
+     *
+     * $I->fillField(Locator::combine('form input[type=text]','//form/textarea[2]'), 'qwerty');
+     * ```
+     *
+     * As a result the Locator will produce a mixed XPath value that will be used in fillField action.
+     *
+     * @static
+     * @throws Exception
+     */
+    public static function combine(string $selector1, string $selector2): string
+    {
+        $selectors = func_get_args();
+        foreach ($selectors as $k => $v) {
+            $selectors[$k] = self::toXPath($v);
+            if (!$selectors[$k]) {
+                throw new Exception("{$v} is invalid CSS or XPath");
+            }
+        }
+        return implode(' | ', $selectors);
+    }
+
+    /**
+     * Matches the *a* element with given URL
+     *
+     * ```php
+     * <?php
+     * use \Codeception\Util\Locator;
+     *
+     * $I->see('Log In', Locator::href('/login.php'));
+     * ```
+     * @static
+     */
+    public static function href(string $url): string
+    {
+        return sprintf('//a[@href=normalize-space(%s)]', Translator::getXpathLiteral($url));
+    }
+
+    /**
+     * Matches the element with given tab index
+     *
+     * Do you often use the `TAB` key to navigate through the web page? How do your site respond to this navigation?
+     * You could try to match elements by their tab position using `tabIndex` method of `Locator` class.
+     * ```php
+     * <?php
+     * use \Codeception\Util\Locator;
+     *
+     * $I->fillField(Locator::tabIndex(1), 'davert');
+     * $I->fillField(Locator::tabIndex(2) , 'qwerty');
+     * $I->click('Login');
+     * ```
+     * @static
+     */
+    public static function tabIndex(int $index): string
+    {
+        return sprintf('//*[@tabindex = normalize-space(%d)]', $index);
+    }
+
+    /**
+     * Matches option by text:
+     *
+     * ```php
+     * <?php
+     * use Codeception\Util\Locator;
+     *
+     * $I->seeElement(Locator::option('Male'), '#select-gender');
+     * ```
+     */
+    public static function option(string $value): string
+    {
+        return sprintf('//option[.=normalize-space("%s")]', $value);
+    }
+
+    protected static function toXPath(string $selector): ?string
+    {
+        try {
+            return (new CssSelectorConverter())->toXPath($selector);
+        } catch (ParseException $parseException) {
+            if (self::isXPath($selector)) {
+                return $selector;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Finds element by it's attribute(s)
+     *
+     * ```php
+     * <?php
+     * use \Codeception\Util\Locator;
+     *
+     * $I->seeElement(Locator::find('img', ['title' => 'diagram']));
+     * ```
+     * @static
+     */
+    public static function find(string $element, array $attributes): string
+    {
+        $operands = [];
+        foreach ($attributes as $attribute => $value) {
+            if (is_int($attribute)) {
+                $operands[] = '@' . $value;
+            } else {
+                $operands[] = '@' . $attribute . ' = ' . Translator::getXpathLiteral($value);
+            }
+        }
+        return sprintf('//%s[%s]', $element, implode(' and ', $operands));
+    }
+
+    /**
+     * Checks that provided string is CSS selector
+     *
+     * ```php
+     * <?php
+     * Locator::isCSS('#user .hello') => true
+     * Locator::isCSS('body') => true
+     * Locator::isCSS('//body/p/user') => false
+     * ```
+     */
+    public static function isCSS(string $selector): bool
+    {
+        try {
+            (new CssSelectorConverter())->toXPath($selector);
+        } catch (ParseException $e) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Checks that locator is an XPath
+     *
+     * ```php
+     * <?php
+     * Locator::isXPath('#user .hello') => false
+     * Locator::isXPath('body') => false
+     * Locator::isXPath('//body/p/user') => true
+     * ```
+     */
+    public static function isXPath(string $locator): bool
+    {
+        $domDocument = new DOMDocument('1.0', 'UTF-8');
+        $domxPath = new DOMXPath($domDocument);
+        return @$domxPath->evaluate($locator, $domDocument) !== false;
+    }
+
+    public static function isPrecise(WebDriverBy|array|string $locator): bool
+    {
+        if (is_array($locator)) {
+            return true;
+        }
+        if ($locator instanceof WebDriverBy) {
+            return true;
+        }
+        if (Locator::isID($locator)) {
+            return true;
+        }
+        if (str_starts_with($locator, '//')) {
+            return true; // simple xpath check
+        }
+        return false;
+    }
+
+    /**
+     * Checks that a string is valid CSS ID
+     *
+     * ```php
+     * <?php
+     * Locator::isID('#user') => true
+     * Locator::isID('body') => false
+     * Locator::isID('//body/p/user') => false
+     * ```
+     */
+    public static function isID(string $id): bool
+    {
+        return (bool)preg_match('~^#[\w.\-\[\]=^\~:]+$~', $id);
+    }
+
+    /**
+     * Checks that a string is valid CSS class
+     *
+     * ```php
+     * <?php
+     * Locator::isClass('.hello') => true
+     * Locator::isClass('body') => false
+     * Locator::isClass('//body/p/user') => false
+     * ```
+     */
+    public static function isClass(string $class): bool
+    {
+        return (bool)preg_match('#^\.[\w.\-\[\]=^~:]+$#', $class);
+    }
+
+    /**
+     * Locates an element containing a text inside.
+     * Either CSS or XPath locator can be passed, however they will be converted to XPath.
+     *
+     * ```php
+     * <?php
+     * use Codeception\Util\Locator;
+     *
+     * Locator::contains('label', 'Name'); // label containing name
+     * Locator::contains('div[@contenteditable=true]', 'hello world');
+     * ```
+     */
+    public static function contains(string $element, string $text): string
+    {
+        $text = Translator::getXpathLiteral($text);
+        return sprintf('%s[%s]', self::toXPath($element), "contains(., {$text})");
+    }
+
+    /**
+     * Locates element at position.
+     * Either CSS or XPath locator can be passed as locator,
+     * position is an integer. If a negative value is provided, counting starts from the last element.
+     * First element has index 1
+     *
+     * ```php
+     * <?php
+     * use Codeception\Util\Locator;
+     *
+     * Locator::elementAt('//table/tr', 2); // second row
+     * Locator::elementAt('//table/tr', -1); // last row
+     * Locator::elementAt('table#grind>tr', -2); // previous than last row
+     * ```
+     *
+     * @param string $element CSS or XPath locator
+     * @param int|string $position xPath index
+     */
+    public static function elementAt(string $element, int|string $position): string
+    {
+        if (is_int($position) && $position < 0) {
+            ++$position; // -1 points to the last element
+            $position = 'last()-' . abs($position);
+        }
+        if ($position === 0) {
+            throw new InvalidArgumentException(
+                '0 is not valid element position. XPath expects first element to have index 1'
+            );
+        }
+        return sprintf('(%s)[position()=%s]', self::toXPath($element), $position);
+    }
+
+    /**
+     * Locates first element of group elements.
+     * Either CSS or XPath locator can be passed as locator,
+     * Equal to `Locator::elementAt($locator, 1)`
+     *
+     * ```php
+     * <?php
+     * use Codeception\Util\Locator;
+     *
+     * Locator::firstElement('//table/tr');
+     * ```
+     */
+    public static function firstElement(string $element): string
+    {
+        return self::elementAt($element, 1);
+    }
+
+    /**
+     * Locates last element of group elements.
+     * Either CSS or XPath locator can be passed as locator,
+     * Equal to `Locator::elementAt($locator, -1)`
+     *
+     * ```php
+     * <?php
+     * use Codeception\Util\Locator;
+     *
+     * Locator::lastElement('//table/tr');
+     * ```
+     */
+    public static function lastElement(string $element): string
+    {
+        return self::elementAt($element, 'last()');
+    }
+
+    /**
+     * Transforms strict locator, \Facebook\WebDriver\WebDriverBy into a string representation
+     */
+    public static function humanReadableString(WebDriverBy|array|string $selector): string
+    {
+        if (is_string($selector)) {
+            return "'{$selector}'";
+        }
+        if (is_array($selector)) {
+            $type = strtolower(key($selector));
+            $locator = $selector[$type];
+            return "{$type} '{$locator}'";
+        }
+        if (class_exists('\Facebook\WebDriver\WebDriverBy') && $selector instanceof WebDriverBy) {
+            $type = $selector->getMechanism();
+            $locator = $selector->getValue();
+            return "{$type} '{$locator}'";
+        }
+        throw new InvalidArgumentException("Unrecognized selector");
+    }
+}

vendor/codeception/lib-web/src/Util/Uri.php

@@ -0,0 +1,123 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Codeception\Util;
+
+use GuzzleHttp\Psr7\Uri as Psr7Uri;
+use InvalidArgumentException;
+
+use function dirname;
+use function ltrim;
+use function parse_url;
+use function preg_match;
+use function rtrim;
+
+class Uri
+{
+    /**
+     * Merges the passed $add argument onto $base.
+     *
+     * If a relative URL is passed as the 'path' part of the $add url
+     * array, the relative URL is mapped using the base 'path' part as
+     * its base.
+     *
+     * @param string $baseUri the base URL
+     * @param string $uri the URL to merge
+     * @return string the merged array
+     */
+    public static function mergeUrls(string $baseUri, string $uri): string
+    {
+        $base = new Psr7Uri($baseUri);
+        $parts = parse_url($uri);
+
+        //If the relative URL does not parse, attempt to parse the entire URL.
+        //PHP Known bug ( https://bugs.php.net/bug.php?id=70942 )
+        if ($parts === false) {
+            $parts = parse_url($base . $uri);
+        }
+
+        if ($parts === false) {
+            throw new InvalidArgumentException("Invalid URI {$uri}");
+        }
+
+        if (isset($parts['host']) && isset($parts['scheme'])) {
+            // if this is an absolute url, replace with it
+            return $uri;
+        }
+
+        if (isset($parts['host'])) {
+            $base = $base->withHost($parts['host']);
+            $base = $base->withPath('');
+            $base = $base->withQuery('');
+            $base = $base->withFragment('');
+        }
+        if (isset($parts['path'])) {
+            $path = $parts['path'];
+            $basePath = $base->getPath();
+            if ((!str_starts_with($path, '/')) && !empty($path)) {
+                if ($basePath !== '') {
+                    // if it ends with a slash, relative paths are below it
+                    if (preg_match('#/$#', $basePath)) {
+                        $path = $basePath . $path;
+                    } else {
+                        // remove double slashes
+                        $dir = rtrim(dirname($basePath), '\\/');
+                        $path = $dir . '/' . $path;
+                    }
+                } else {
+                    $path = '/' . ltrim($path, '/');
+                }
+            }
+            $base = $base->withPath($path);
+            $base = $base->withQuery('');
+            $base = $base->withFragment('');
+        }
+        if (isset($parts['query'])) {
+            $base = $base->withQuery($parts['query']);
+            $base = $base->withFragment('');
+        }
+        if (isset($parts['fragment'])) {
+            $base = $base->withFragment($parts['fragment']);
+        }
+
+        return (string)$base;
+    }
+
+    /**
+     * Retrieve /path?query#fragment part of URL
+     */
+    public static function retrieveUri(string $url): string
+    {
+        $uri = new Psr7Uri($url);
+        return (string)(new Psr7Uri())
+            ->withPath($uri->getPath())
+            ->withQuery($uri->getQuery())
+            ->withFragment($uri->getFragment());
+    }
+
+    public static function retrieveHost(string $url): string
+    {
+        $urlParts = parse_url($url);
+        if (!isset($urlParts['host']) || !isset($urlParts['scheme'])) {
+            throw new InvalidArgumentException("Wrong URL passes, host and scheme not set");
+        }
+        $host = $urlParts['scheme'] . '://' . $urlParts['host'];
+        if (isset($urlParts['port'])) {
+            $host .= ':' . $urlParts['port'];
+        }
+        return $host;
+    }
+
+    public static function appendPath(string $url, string $path): string
+    {
+        $uri = new Psr7Uri($url);
+        $cutUrl = (string)$uri->withQuery('')->withFragment('');
+
+        if ($path === '' || $path[0] === '#') {
+            return $cutUrl . $path;
+        }
+
+        return rtrim($cutUrl, '/') . '/' . ltrim($path, '/');
+    }
+}