first commit

vendor/symfony/deprecation-contracts/CHANGELOG.md

@@ -0,0 +1,5 @@
+CHANGELOG
+=========
+
+The changelog is maintained for all Symfony contracts at the following URL:
+https://github.com/symfony/contracts/blob/main/CHANGELOG.md

vendor/symfony/deprecation-contracts/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2020-present Fabien Potencier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/symfony/deprecation-contracts/README.md

@@ -0,0 +1,26 @@
+Symfony Deprecation Contracts
+=============================
+
+A generic function and convention to trigger deprecation notices.
+
+This package provides a single global function named `trigger_deprecation()` that triggers silenced deprecation notices.
+
+By using a custom PHP error handler such as the one provided by the Symfony ErrorHandler component,
+the triggered deprecations can be caught and logged for later discovery, both on dev and prod environments.
+
+The function requires at least 3 arguments:
+ - the name of the Composer package that is triggering the deprecation
+ - the version of the package that introduced the deprecation
+ - the message of the deprecation
+ - more arguments can be provided: they will be inserted in the message using `printf()` formatting
+
+Example:
+```php
+trigger_deprecation('symfony/blockchain', '8.9', 'Using "%s" is deprecated, use "%s" instead.', 'bitcoin', 'fabcoin');
+```
+
+This will generate the following message:
+`Since symfony/blockchain 8.9: Using "bitcoin" is deprecated, use "fabcoin" instead.`
+
+While not recommended, the deprecation notices can be completely ignored by declaring an empty
+`function trigger_deprecation() {}` in your application.

vendor/symfony/deprecation-contracts/composer.json

@@ -0,0 +1,35 @@
+{
+    "name": "symfony/deprecation-contracts",
+    "type": "library",
+    "description": "A generic function and convention to trigger deprecation notices",
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Nicolas Grekas",
+            "email": "p@tchwork.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=8.1"
+    },
+    "autoload": {
+        "files": [
+            "function.php"
+        ]
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "branch-alias": {
+            "dev-main": "3.6-dev"
+        },
+        "thanks": {
+            "name": "symfony/contracts",
+            "url": "https://github.com/symfony/contracts"
+        }
+    }
+}

vendor/symfony/deprecation-contracts/function.php

@@ -0,0 +1,27 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+if (!function_exists('trigger_deprecation')) {
+    /**
+     * Triggers a silenced deprecation notice.
+     *
+     * @param string $package The name of the Composer package that is triggering the deprecation
+     * @param string $version The version of the package that introduced the deprecation
+     * @param string $message The message of the deprecation
+     * @param mixed  ...$args Values to insert in the message using printf() formatting
+     *
+     * @author Nicolas Grekas <p@tchwork.com>
+     */
+    function trigger_deprecation(string $package, string $version, string $message, mixed ...$args): void
+    {
+        @trigger_error(($package || $version ? "Since $package $version: " : '').($args ? vsprintf($message, $args) : $message), \E_USER_DEPRECATED);
+    }
+}

vendor/symfony/polyfill-ctype/Ctype.php

@@ -0,0 +1,232 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Polyfill\Ctype;
+
+/**
+ * Ctype implementation through regex.
+ *
+ * @internal
+ *
+ * @author Gert de Pagter <BackEndTea@gmail.com>
+ */
+final class Ctype
+{
+    /**
+     * Returns TRUE if every character in text is either a letter or a digit, FALSE otherwise.
+     *
+     * @see https://php.net/ctype-alnum
+     *
+     * @param mixed $text
+     *
+     * @return bool
+     */
+    public static function ctype_alnum($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text, __FUNCTION__);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^A-Za-z0-9]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is a letter, FALSE otherwise.
+     *
+     * @see https://php.net/ctype-alpha
+     *
+     * @param mixed $text
+     *
+     * @return bool
+     */
+    public static function ctype_alpha($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text, __FUNCTION__);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^A-Za-z]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is a control character from the current locale, FALSE otherwise.
+     *
+     * @see https://php.net/ctype-cntrl
+     *
+     * @param mixed $text
+     *
+     * @return bool
+     */
+    public static function ctype_cntrl($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text, __FUNCTION__);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^\x00-\x1f\x7f]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in the string text is a decimal digit, FALSE otherwise.
+     *
+     * @see https://php.net/ctype-digit
+     *
+     * @param mixed $text
+     *
+     * @return bool
+     */
+    public static function ctype_digit($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text, __FUNCTION__);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^0-9]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is printable and actually creates visible output (no white space), FALSE otherwise.
+     *
+     * @see https://php.net/ctype-graph
+     *
+     * @param mixed $text
+     *
+     * @return bool
+     */
+    public static function ctype_graph($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text, __FUNCTION__);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^!-~]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is a lowercase letter.
+     *
+     * @see https://php.net/ctype-lower
+     *
+     * @param mixed $text
+     *
+     * @return bool
+     */
+    public static function ctype_lower($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text, __FUNCTION__);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^a-z]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text will actually create output (including blanks). Returns FALSE if text contains control characters or characters that do not have any output or control function at all.
+     *
+     * @see https://php.net/ctype-print
+     *
+     * @param mixed $text
+     *
+     * @return bool
+     */
+    public static function ctype_print($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text, __FUNCTION__);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^ -~]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is printable, but neither letter, digit or blank, FALSE otherwise.
+     *
+     * @see https://php.net/ctype-punct
+     *
+     * @param mixed $text
+     *
+     * @return bool
+     */
+    public static function ctype_punct($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text, __FUNCTION__);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^!-\/\:-@\[-`\{-~]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text creates some sort of white space, FALSE otherwise. Besides the blank character this also includes tab, vertical tab, line feed, carriage return and form feed characters.
+     *
+     * @see https://php.net/ctype-space
+     *
+     * @param mixed $text
+     *
+     * @return bool
+     */
+    public static function ctype_space($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text, __FUNCTION__);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^\s]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is an uppercase letter.
+     *
+     * @see https://php.net/ctype-upper
+     *
+     * @param mixed $text
+     *
+     * @return bool
+     */
+    public static function ctype_upper($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text, __FUNCTION__);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^A-Z]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is a hexadecimal 'digit', that is a decimal digit or a character from [A-Fa-f] , FALSE otherwise.
+     *
+     * @see https://php.net/ctype-xdigit
+     *
+     * @param mixed $text
+     *
+     * @return bool
+     */
+    public static function ctype_xdigit($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text, __FUNCTION__);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^A-Fa-f0-9]/', $text);
+    }
+
+    /**
+     * Converts integers to their char versions according to normal ctype behaviour, if needed.
+     *
+     * If an integer between -128 and 255 inclusive is provided,
+     * it is interpreted as the ASCII value of a single character
+     * (negative values have 256 added in order to allow characters in the Extended ASCII range).
+     * Any other integer is interpreted as a string containing the decimal digits of the integer.
+     *
+     * @param mixed  $int
+     * @param string $function
+     *
+     * @return mixed
+     */
+    private static function convert_int_to_char_for_ctype($int, $function)
+    {
+        if (!\is_int($int)) {
+            return $int;
+        }
+
+        if ($int < -128 || $int > 255) {
+            return (string) $int;
+        }
+
+        if (\PHP_VERSION_ID >= 80100) {
+            @trigger_error($function.'(): Argument of type int will be interpreted as string in the future', \E_USER_DEPRECATED);
+        }
+
+        if ($int < 0) {
+            $int += 256;
+        }
+
+        return \chr($int);
+    }
+}

vendor/symfony/polyfill-ctype/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018-present Fabien Potencier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/symfony/polyfill-ctype/README.md

@@ -0,0 +1,12 @@
+Symfony Polyfill / Ctype
+========================
+
+This component provides `ctype_*` functions to users who run php versions without the ctype extension.
+
+More information can be found in the
+[main Polyfill README](https://github.com/symfony/polyfill/blob/main/README.md).
+
+License
+=======
+
+This library is released under the [MIT license](LICENSE).

vendor/symfony/polyfill-ctype/bootstrap.php

@@ -0,0 +1,50 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Symfony\Polyfill\Ctype as p;
+
+if (\PHP_VERSION_ID >= 80000) {
+    return require __DIR__.'/bootstrap80.php';
+}
+
+if (!function_exists('ctype_alnum')) {
+    function ctype_alnum($text) { return p\Ctype::ctype_alnum($text); }
+}
+if (!function_exists('ctype_alpha')) {
+    function ctype_alpha($text) { return p\Ctype::ctype_alpha($text); }
+}
+if (!function_exists('ctype_cntrl')) {
+    function ctype_cntrl($text) { return p\Ctype::ctype_cntrl($text); }
+}
+if (!function_exists('ctype_digit')) {
+    function ctype_digit($text) { return p\Ctype::ctype_digit($text); }
+}
+if (!function_exists('ctype_graph')) {
+    function ctype_graph($text) { return p\Ctype::ctype_graph($text); }
+}
+if (!function_exists('ctype_lower')) {
+    function ctype_lower($text) { return p\Ctype::ctype_lower($text); }
+}
+if (!function_exists('ctype_print')) {
+    function ctype_print($text) { return p\Ctype::ctype_print($text); }
+}
+if (!function_exists('ctype_punct')) {
+    function ctype_punct($text) { return p\Ctype::ctype_punct($text); }
+}
+if (!function_exists('ctype_space')) {
+    function ctype_space($text) { return p\Ctype::ctype_space($text); }
+}
+if (!function_exists('ctype_upper')) {
+    function ctype_upper($text) { return p\Ctype::ctype_upper($text); }
+}
+if (!function_exists('ctype_xdigit')) {
+    function ctype_xdigit($text) { return p\Ctype::ctype_xdigit($text); }
+}

vendor/symfony/polyfill-ctype/bootstrap80.php

@@ -0,0 +1,46 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Symfony\Polyfill\Ctype as p;
+
+if (!function_exists('ctype_alnum')) {
+    function ctype_alnum(mixed $text): bool { return p\Ctype::ctype_alnum($text); }
+}
+if (!function_exists('ctype_alpha')) {
+    function ctype_alpha(mixed $text): bool { return p\Ctype::ctype_alpha($text); }
+}
+if (!function_exists('ctype_cntrl')) {
+    function ctype_cntrl(mixed $text): bool { return p\Ctype::ctype_cntrl($text); }
+}
+if (!function_exists('ctype_digit')) {
+    function ctype_digit(mixed $text): bool { return p\Ctype::ctype_digit($text); }
+}
+if (!function_exists('ctype_graph')) {
+    function ctype_graph(mixed $text): bool { return p\Ctype::ctype_graph($text); }
+}
+if (!function_exists('ctype_lower')) {
+    function ctype_lower(mixed $text): bool { return p\Ctype::ctype_lower($text); }
+}
+if (!function_exists('ctype_print')) {
+    function ctype_print(mixed $text): bool { return p\Ctype::ctype_print($text); }
+}
+if (!function_exists('ctype_punct')) {
+    function ctype_punct(mixed $text): bool { return p\Ctype::ctype_punct($text); }
+}
+if (!function_exists('ctype_space')) {
+    function ctype_space(mixed $text): bool { return p\Ctype::ctype_space($text); }
+}
+if (!function_exists('ctype_upper')) {
+    function ctype_upper(mixed $text): bool { return p\Ctype::ctype_upper($text); }
+}
+if (!function_exists('ctype_xdigit')) {
+    function ctype_xdigit(mixed $text): bool { return p\Ctype::ctype_xdigit($text); }
+}

vendor/symfony/polyfill-ctype/composer.json

@@ -0,0 +1,38 @@
+{
+    "name": "symfony/polyfill-ctype",
+    "type": "library",
+    "description": "Symfony polyfill for ctype functions",
+    "keywords": ["polyfill", "compatibility", "portable", "ctype"],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Gert de Pagter",
+            "email": "BackEndTea@gmail.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=7.2"
+    },
+    "provide": {
+        "ext-ctype": "*"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Polyfill\\Ctype\\": "" },
+        "files": [ "bootstrap.php" ]
+    },
+    "suggest": {
+        "ext-ctype": "For best performance"
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "thanks": {
+            "name": "symfony/polyfill",
+            "url": "https://github.com/symfony/polyfill"
+        }
+    }
+}

vendor/symfony/polyfill-intl-idn/Idn.php

@@ -0,0 +1,941 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com> and Trevor Rowbotham <trevor.rowbotham@pm.me>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Polyfill\Intl\Idn;
+
+use Symfony\Polyfill\Intl\Idn\Resources\unidata\DisallowedRanges;
+use Symfony\Polyfill\Intl\Idn\Resources\unidata\Regex;
+
+/**
+ * @see https://www.unicode.org/reports/tr46/
+ *
+ * @internal
+ */
+final class Idn
+{
+    public const ERROR_EMPTY_LABEL = 1;
+    public const ERROR_LABEL_TOO_LONG = 2;
+    public const ERROR_DOMAIN_NAME_TOO_LONG = 4;
+    public const ERROR_LEADING_HYPHEN = 8;
+    public const ERROR_TRAILING_HYPHEN = 0x10;
+    public const ERROR_HYPHEN_3_4 = 0x20;
+    public const ERROR_LEADING_COMBINING_MARK = 0x40;
+    public const ERROR_DISALLOWED = 0x80;
+    public const ERROR_PUNYCODE = 0x100;
+    public const ERROR_LABEL_HAS_DOT = 0x200;
+    public const ERROR_INVALID_ACE_LABEL = 0x400;
+    public const ERROR_BIDI = 0x800;
+    public const ERROR_CONTEXTJ = 0x1000;
+    public const ERROR_CONTEXTO_PUNCTUATION = 0x2000;
+    public const ERROR_CONTEXTO_DIGITS = 0x4000;
+
+    public const INTL_IDNA_VARIANT_2003 = 0;
+    public const INTL_IDNA_VARIANT_UTS46 = 1;
+
+    public const IDNA_DEFAULT = 0;
+    public const IDNA_ALLOW_UNASSIGNED = 1;
+    public const IDNA_USE_STD3_RULES = 2;
+    public const IDNA_CHECK_BIDI = 4;
+    public const IDNA_CHECK_CONTEXTJ = 8;
+    public const IDNA_NONTRANSITIONAL_TO_ASCII = 16;
+    public const IDNA_NONTRANSITIONAL_TO_UNICODE = 32;
+
+    public const MAX_DOMAIN_SIZE = 253;
+    public const MAX_LABEL_SIZE = 63;
+
+    public const BASE = 36;
+    public const TMIN = 1;
+    public const TMAX = 26;
+    public const SKEW = 38;
+    public const DAMP = 700;
+    public const INITIAL_BIAS = 72;
+    public const INITIAL_N = 128;
+    public const DELIMITER = '-';
+    public const MAX_INT = 2147483647;
+
+    /**
+     * Contains the numeric value of a basic code point (for use in representing integers) in the
+     * range 0 to BASE-1, or -1 if b is does not represent a value.
+     *
+     * @var array<int, int>
+     */
+    private static $basicToDigit = [
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1,
+
+        -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+
+        -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    ];
+
+    /**
+     * @var array<int, int>
+     */
+    private static $virama;
+
+    /**
+     * @var array<int, string>
+     */
+    private static $mapped;
+
+    /**
+     * @var array<int, bool>
+     */
+    private static $ignored;
+
+    /**
+     * @var array<int, string>
+     */
+    private static $deviation;
+
+    /**
+     * @var array<int, bool>
+     */
+    private static $disallowed;
+
+    /**
+     * @var array<int, string>
+     */
+    private static $disallowed_STD3_mapped;
+
+    /**
+     * @var array<int, bool>
+     */
+    private static $disallowed_STD3_valid;
+
+    /**
+     * @var bool
+     */
+    private static $mappingTableLoaded = false;
+
+    /**
+     * @see https://www.unicode.org/reports/tr46/#ToASCII
+     *
+     * @param string $domainName
+     * @param int    $options
+     * @param int    $variant
+     * @param array  $idna_info
+     *
+     * @return string|false
+     */
+    public static function idn_to_ascii($domainName, $options = self::IDNA_DEFAULT, $variant = self::INTL_IDNA_VARIANT_UTS46, &$idna_info = [])
+    {
+        if (\PHP_VERSION_ID > 80400 && '' === $domainName) {
+            throw new \ValueError('idn_to_ascii(): Argument #1 ($domain) cannot be empty');
+        }
+
+        if (self::INTL_IDNA_VARIANT_2003 === $variant) {
+            @trigger_error('idn_to_ascii(): INTL_IDNA_VARIANT_2003 is deprecated', \E_USER_DEPRECATED);
+        }
+
+        $options = [
+            'CheckHyphens' => true,
+            'CheckBidi' => self::INTL_IDNA_VARIANT_2003 === $variant || 0 !== ($options & self::IDNA_CHECK_BIDI),
+            'CheckJoiners' => self::INTL_IDNA_VARIANT_UTS46 === $variant && 0 !== ($options & self::IDNA_CHECK_CONTEXTJ),
+            'UseSTD3ASCIIRules' => 0 !== ($options & self::IDNA_USE_STD3_RULES),
+            'Transitional_Processing' => self::INTL_IDNA_VARIANT_2003 === $variant || 0 === ($options & self::IDNA_NONTRANSITIONAL_TO_ASCII),
+            'VerifyDnsLength' => true,
+        ];
+        $info = new Info();
+        $labels = self::process((string) $domainName, $options, $info);
+
+        foreach ($labels as $i => $label) {
+            // Only convert labels to punycode that contain non-ASCII code points
+            if (1 === preg_match('/[^\x00-\x7F]/', $label)) {
+                try {
+                    $label = 'xn--'.self::punycodeEncode($label);
+                } catch (\Exception $e) {
+                    $info->errors |= self::ERROR_PUNYCODE;
+                }
+
+                $labels[$i] = $label;
+            }
+        }
+
+        if ($options['VerifyDnsLength']) {
+            self::validateDomainAndLabelLength($labels, $info);
+        }
+
+        $idna_info = [
+            'result' => implode('.', $labels),
+            'isTransitionalDifferent' => $info->transitionalDifferent,
+            'errors' => $info->errors,
+        ];
+
+        return 0 === $info->errors ? $idna_info['result'] : false;
+    }
+
+    /**
+     * @see https://www.unicode.org/reports/tr46/#ToUnicode
+     *
+     * @param string $domainName
+     * @param int    $options
+     * @param int    $variant
+     * @param array  $idna_info
+     *
+     * @return string|false
+     */
+    public static function idn_to_utf8($domainName, $options = self::IDNA_DEFAULT, $variant = self::INTL_IDNA_VARIANT_UTS46, &$idna_info = [])
+    {
+        if (\PHP_VERSION_ID > 80400 && '' === $domainName) {
+            throw new \ValueError('idn_to_utf8(): Argument #1 ($domain) cannot be empty');
+        }
+
+        if (self::INTL_IDNA_VARIANT_2003 === $variant) {
+            @trigger_error('idn_to_utf8(): INTL_IDNA_VARIANT_2003 is deprecated', \E_USER_DEPRECATED);
+        }
+
+        $info = new Info();
+        $labels = self::process((string) $domainName, [
+            'CheckHyphens' => true,
+            'CheckBidi' => self::INTL_IDNA_VARIANT_2003 === $variant || 0 !== ($options & self::IDNA_CHECK_BIDI),
+            'CheckJoiners' => self::INTL_IDNA_VARIANT_UTS46 === $variant && 0 !== ($options & self::IDNA_CHECK_CONTEXTJ),
+            'UseSTD3ASCIIRules' => 0 !== ($options & self::IDNA_USE_STD3_RULES),
+            'Transitional_Processing' => self::INTL_IDNA_VARIANT_2003 === $variant || 0 === ($options & self::IDNA_NONTRANSITIONAL_TO_UNICODE),
+        ], $info);
+        $idna_info = [
+            'result' => implode('.', $labels),
+            'isTransitionalDifferent' => $info->transitionalDifferent,
+            'errors' => $info->errors,
+        ];
+
+        return 0 === $info->errors ? $idna_info['result'] : false;
+    }
+
+    /**
+     * @param string $label
+     *
+     * @return bool
+     */
+    private static function isValidContextJ(array $codePoints, $label)
+    {
+        if (!isset(self::$virama)) {
+            self::$virama = require __DIR__.\DIRECTORY_SEPARATOR.'Resources'.\DIRECTORY_SEPARATOR.'unidata'.\DIRECTORY_SEPARATOR.'virama.php';
+        }
+
+        $offset = 0;
+
+        foreach ($codePoints as $i => $codePoint) {
+            if (0x200C !== $codePoint && 0x200D !== $codePoint) {
+                continue;
+            }
+
+            if (!isset($codePoints[$i - 1])) {
+                return false;
+            }
+
+            // If Canonical_Combining_Class(Before(cp)) .eq. Virama Then True;
+            if (isset(self::$virama[$codePoints[$i - 1]])) {
+                continue;
+            }
+
+            // If RegExpMatch((Joining_Type:{L,D})(Joining_Type:T)*\u200C(Joining_Type:T)*(Joining_Type:{R,D})) Then
+            // True;
+            // Generated RegExp = ([Joining_Type:{L,D}][Joining_Type:T]*\u200C[Joining_Type:T]*)[Joining_Type:{R,D}]
+            if (0x200C === $codePoint && 1 === preg_match(Regex::ZWNJ, $label, $matches, \PREG_OFFSET_CAPTURE, $offset)) {
+                $offset += \strlen($matches[1][0]);
+
+                continue;
+            }
+
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @see https://www.unicode.org/reports/tr46/#ProcessingStepMap
+     *
+     * @param string              $input
+     * @param array<string, bool> $options
+     *
+     * @return string
+     */
+    private static function mapCodePoints($input, array $options, Info $info)
+    {
+        $str = '';
+        $useSTD3ASCIIRules = $options['UseSTD3ASCIIRules'];
+        $transitional = $options['Transitional_Processing'];
+
+        foreach (self::utf8Decode($input) as $codePoint) {
+            $data = self::lookupCodePointStatus($codePoint, $useSTD3ASCIIRules);
+
+            switch ($data['status']) {
+                case 'disallowed':
+                case 'valid':
+                    $str .= mb_chr($codePoint, 'utf-8');
+
+                    break;
+
+                case 'ignored':
+                    // Do nothing.
+                    break;
+
+                case 'mapped':
+                    $str .= $transitional && 0x1E9E === $codePoint ? 'ss' : $data['mapping'];
+
+                    break;
+
+                case 'deviation':
+                    $info->transitionalDifferent = true;
+                    $str .= ($transitional ? $data['mapping'] : mb_chr($codePoint, 'utf-8'));
+
+                    break;
+            }
+        }
+
+        return $str;
+    }
+
+    /**
+     * @see https://www.unicode.org/reports/tr46/#Processing
+     *
+     * @param string              $domain
+     * @param array<string, bool> $options
+     *
+     * @return array<int, string>
+     */
+    private static function process($domain, array $options, Info $info)
+    {
+        // If VerifyDnsLength is not set, we are doing ToUnicode otherwise we are doing ToASCII and
+        // we need to respect the VerifyDnsLength option.
+        $checkForEmptyLabels = !isset($options['VerifyDnsLength']) || $options['VerifyDnsLength'];
+
+        if ($checkForEmptyLabels && '' === $domain) {
+            $info->errors |= self::ERROR_EMPTY_LABEL;
+
+            return [$domain];
+        }
+
+        // Step 1. Map each code point in the domain name string
+        $domain = self::mapCodePoints($domain, $options, $info);
+
+        // Step 2. Normalize the domain name string to Unicode Normalization Form C.
+        if (!\Normalizer::isNormalized($domain, \Normalizer::FORM_C)) {
+            $domain = \Normalizer::normalize($domain, \Normalizer::FORM_C);
+        }
+
+        // Step 3. Break the string into labels at U+002E (.) FULL STOP.
+        $labels = explode('.', $domain);
+        $lastLabelIndex = \count($labels) - 1;
+
+        // Step 4. Convert and validate each label in the domain name string.
+        foreach ($labels as $i => $label) {
+            $validationOptions = $options;
+
+            if ('xn--' === substr($label, 0, 4)) {
+                // Step 4.1. If the label contains any non-ASCII code point (i.e., a code point greater than U+007F),
+                // record that there was an error, and continue with the next label.
+                if (preg_match('/[^\x00-\x7F]/', $label)) {
+                    $info->errors |= self::ERROR_PUNYCODE;
+
+                    continue;
+                }
+
+                // Step 4.2. Attempt to convert the rest of the label to Unicode according to Punycode [RFC3492]. If
+                // that conversion fails, record that there was an error, and continue
+                // with the next label. Otherwise replace the original label in the string by the results of the
+                // conversion.
+                try {
+                    $label = self::punycodeDecode(substr($label, 4));
+                } catch (\Exception $e) {
+                    $info->errors |= self::ERROR_PUNYCODE;
+
+                    continue;
+                }
+
+                $validationOptions['Transitional_Processing'] = false;
+                $labels[$i] = $label;
+            }
+
+            self::validateLabel($label, $info, $validationOptions, $i > 0 && $i === $lastLabelIndex);
+        }
+
+        if ($info->bidiDomain && !$info->validBidiDomain) {
+            $info->errors |= self::ERROR_BIDI;
+        }
+
+        // Any input domain name string that does not record an error has been successfully
+        // processed according to this specification. Conversely, if an input domain_name string
+        // causes an error, then the processing of the input domain_name string fails. Determining
+        // what to do with error input is up to the caller, and not in the scope of this document.
+        return $labels;
+    }
+
+    /**
+     * @see https://tools.ietf.org/html/rfc5893#section-2
+     *
+     * @param string $label
+     */
+    private static function validateBidiLabel($label, Info $info)
+    {
+        if (1 === preg_match(Regex::RTL_LABEL, $label)) {
+            $info->bidiDomain = true;
+
+            // Step 1. The first character must be a character with Bidi property L, R, or AL.
+            // If it has the R or AL property, it is an RTL label
+            if (1 !== preg_match(Regex::BIDI_STEP_1_RTL, $label)) {
+                $info->validBidiDomain = false;
+
+                return;
+            }
+
+            // Step 2. In an RTL label, only characters with the Bidi properties R, AL, AN, EN, ES,
+            // CS, ET, ON, BN, or NSM are allowed.
+            if (1 === preg_match(Regex::BIDI_STEP_2, $label)) {
+                $info->validBidiDomain = false;
+
+                return;
+            }
+
+            // Step 3. In an RTL label, the end of the label must be a character with Bidi property
+            // R, AL, EN, or AN, followed by zero or more characters with Bidi property NSM.
+            if (1 !== preg_match(Regex::BIDI_STEP_3, $label)) {
+                $info->validBidiDomain = false;
+
+                return;
+            }
+
+            // Step 4. In an RTL label, if an EN is present, no AN may be present, and vice versa.
+            if (1 === preg_match(Regex::BIDI_STEP_4_AN, $label) && 1 === preg_match(Regex::BIDI_STEP_4_EN, $label)) {
+                $info->validBidiDomain = false;
+
+                return;
+            }
+
+            return;
+        }
+
+        // We are a LTR label
+        // Step 1. The first character must be a character with Bidi property L, R, or AL.
+        // If it has the L property, it is an LTR label.
+        if (1 !== preg_match(Regex::BIDI_STEP_1_LTR, $label)) {
+            $info->validBidiDomain = false;
+
+            return;
+        }
+
+        // Step 5. In an LTR label, only characters with the Bidi properties L, EN,
+        // ES, CS, ET, ON, BN, or NSM are allowed.
+        if (1 === preg_match(Regex::BIDI_STEP_5, $label)) {
+            $info->validBidiDomain = false;
+
+            return;
+        }
+
+        // Step 6.In an LTR label, the end of the label must be a character with Bidi property L or
+        // EN, followed by zero or more characters with Bidi property NSM.
+        if (1 !== preg_match(Regex::BIDI_STEP_6, $label)) {
+            $info->validBidiDomain = false;
+
+            return;
+        }
+    }
+
+    /**
+     * @param array<int, string> $labels
+     */
+    private static function validateDomainAndLabelLength(array $labels, Info $info)
+    {
+        $maxDomainSize = self::MAX_DOMAIN_SIZE;
+        $length = \count($labels);
+
+        // Number of "." delimiters.
+        $domainLength = $length - 1;
+
+        // If the last label is empty and it is not the first label, then it is the root label.
+        // Increase the max size by 1, making it 254, to account for the root label's "."
+        // delimiter. This also means we don't need to check the last label's length for being too
+        // long.
+        if ($length > 1 && '' === $labels[$length - 1]) {
+            ++$maxDomainSize;
+            --$length;
+        }
+
+        for ($i = 0; $i < $length; ++$i) {
+            $bytes = \strlen($labels[$i]);
+            $domainLength += $bytes;
+
+            if ($bytes > self::MAX_LABEL_SIZE) {
+                $info->errors |= self::ERROR_LABEL_TOO_LONG;
+            }
+        }
+
+        if ($domainLength > $maxDomainSize) {
+            $info->errors |= self::ERROR_DOMAIN_NAME_TOO_LONG;
+        }
+    }
+
+    /**
+     * @see https://www.unicode.org/reports/tr46/#Validity_Criteria
+     *
+     * @param string              $label
+     * @param array<string, bool> $options
+     * @param bool                $canBeEmpty
+     */
+    private static function validateLabel($label, Info $info, array $options, $canBeEmpty)
+    {
+        if ('' === $label) {
+            if (!$canBeEmpty && (!isset($options['VerifyDnsLength']) || $options['VerifyDnsLength'])) {
+                $info->errors |= self::ERROR_EMPTY_LABEL;
+            }
+
+            return;
+        }
+
+        // Step 1. The label must be in Unicode Normalization Form C.
+        if (!\Normalizer::isNormalized($label, \Normalizer::FORM_C)) {
+            $info->errors |= self::ERROR_INVALID_ACE_LABEL;
+        }
+
+        $codePoints = self::utf8Decode($label);
+
+        if ($options['CheckHyphens']) {
+            // Step 2. If CheckHyphens, the label must not contain a U+002D HYPHEN-MINUS character
+            // in both the thrid and fourth positions.
+            if (isset($codePoints[2], $codePoints[3]) && 0x002D === $codePoints[2] && 0x002D === $codePoints[3]) {
+                $info->errors |= self::ERROR_HYPHEN_3_4;
+            }
+
+            // Step 3. If CheckHyphens, the label must neither begin nor end with a U+002D
+            // HYPHEN-MINUS character.
+            if ('-' === substr($label, 0, 1)) {
+                $info->errors |= self::ERROR_LEADING_HYPHEN;
+            }
+
+            if ('-' === substr($label, -1, 1)) {
+                $info->errors |= self::ERROR_TRAILING_HYPHEN;
+            }
+        } elseif ('xn--' === substr($label, 0, 4)) {
+            $info->errors |= self::ERROR_PUNYCODE;
+        }
+
+        // Step 4. The label must not contain a U+002E (.) FULL STOP.
+        if (false !== strpos($label, '.')) {
+            $info->errors |= self::ERROR_LABEL_HAS_DOT;
+        }
+
+        // Step 5. The label must not begin with a combining mark, that is: General_Category=Mark.
+        if (1 === preg_match(Regex::COMBINING_MARK, $label)) {
+            $info->errors |= self::ERROR_LEADING_COMBINING_MARK;
+        }
+
+        // Step 6. Each code point in the label must only have certain status values according to
+        // Section 5, IDNA Mapping Table:
+        $transitional = $options['Transitional_Processing'];
+        $useSTD3ASCIIRules = $options['UseSTD3ASCIIRules'];
+
+        foreach ($codePoints as $codePoint) {
+            $data = self::lookupCodePointStatus($codePoint, $useSTD3ASCIIRules);
+            $status = $data['status'];
+
+            if ('valid' === $status || (!$transitional && 'deviation' === $status)) {
+                continue;
+            }
+
+            $info->errors |= self::ERROR_DISALLOWED;
+
+            break;
+        }
+
+        // Step 7. If CheckJoiners, the label must satisify the ContextJ rules from Appendix A, in
+        // The Unicode Code Points and Internationalized Domain Names for Applications (IDNA)
+        // [IDNA2008].
+        if ($options['CheckJoiners'] && !self::isValidContextJ($codePoints, $label)) {
+            $info->errors |= self::ERROR_CONTEXTJ;
+        }
+
+        // Step 8. If CheckBidi, and if the domain name is a  Bidi domain name, then the label must
+        // satisfy all six of the numbered conditions in [IDNA2008] RFC 5893, Section 2.
+        if ($options['CheckBidi'] && (!$info->bidiDomain || $info->validBidiDomain)) {
+            self::validateBidiLabel($label, $info);
+        }
+    }
+
+    /**
+     * @see https://tools.ietf.org/html/rfc3492#section-6.2
+     *
+     * @param string $input
+     *
+     * @return string
+     */
+    private static function punycodeDecode($input)
+    {
+        $n = self::INITIAL_N;
+        $out = 0;
+        $i = 0;
+        $bias = self::INITIAL_BIAS;
+        $lastDelimIndex = strrpos($input, self::DELIMITER);
+        $b = false === $lastDelimIndex ? 0 : $lastDelimIndex;
+        $inputLength = \strlen($input);
+        $output = [];
+        $bytes = array_map('ord', str_split($input));
+
+        for ($j = 0; $j < $b; ++$j) {
+            if ($bytes[$j] > 0x7F) {
+                throw new \Exception('Invalid input');
+            }
+
+            $output[$out++] = $input[$j];
+        }
+
+        if ($b > 0) {
+            ++$b;
+        }
+
+        for ($in = $b; $in < $inputLength; ++$out) {
+            $oldi = $i;
+            $w = 1;
+
+            for ($k = self::BASE; /* no condition */; $k += self::BASE) {
+                if ($in >= $inputLength) {
+                    throw new \Exception('Invalid input');
+                }
+
+                $digit = self::$basicToDigit[$bytes[$in++] & 0xFF];
+
+                if ($digit < 0) {
+                    throw new \Exception('Invalid input');
+                }
+
+                if ($digit > intdiv(self::MAX_INT - $i, $w)) {
+                    throw new \Exception('Integer overflow');
+                }
+
+                $i += $digit * $w;
+
+                if ($k <= $bias) {
+                    $t = self::TMIN;
+                } elseif ($k >= $bias + self::TMAX) {
+                    $t = self::TMAX;
+                } else {
+                    $t = $k - $bias;
+                }
+
+                if ($digit < $t) {
+                    break;
+                }
+
+                $baseMinusT = self::BASE - $t;
+
+                if ($w > intdiv(self::MAX_INT, $baseMinusT)) {
+                    throw new \Exception('Integer overflow');
+                }
+
+                $w *= $baseMinusT;
+            }
+
+            $outPlusOne = $out + 1;
+            $bias = self::adaptBias($i - $oldi, $outPlusOne, 0 === $oldi);
+
+            if (intdiv($i, $outPlusOne) > self::MAX_INT - $n) {
+                throw new \Exception('Integer overflow');
+            }
+
+            $n += intdiv($i, $outPlusOne);
+            $i %= $outPlusOne;
+            array_splice($output, $i++, 0, [mb_chr($n, 'utf-8')]);
+        }
+
+        return implode('', $output);
+    }
+
+    /**
+     * @see https://tools.ietf.org/html/rfc3492#section-6.3
+     *
+     * @param string $input
+     *
+     * @return string
+     */
+    private static function punycodeEncode($input)
+    {
+        $n = self::INITIAL_N;
+        $delta = 0;
+        $out = 0;
+        $bias = self::INITIAL_BIAS;
+        $inputLength = 0;
+        $output = '';
+        $iter = self::utf8Decode($input);
+
+        foreach ($iter as $codePoint) {
+            ++$inputLength;
+
+            if ($codePoint < 0x80) {
+                $output .= \chr($codePoint);
+                ++$out;
+            }
+        }
+
+        $h = $out;
+        $b = $out;
+
+        if ($b > 0) {
+            $output .= self::DELIMITER;
+            ++$out;
+        }
+
+        while ($h < $inputLength) {
+            $m = self::MAX_INT;
+
+            foreach ($iter as $codePoint) {
+                if ($codePoint >= $n && $codePoint < $m) {
+                    $m = $codePoint;
+                }
+            }
+
+            if ($m - $n > intdiv(self::MAX_INT - $delta, $h + 1)) {
+                throw new \Exception('Integer overflow');
+            }
+
+            $delta += ($m - $n) * ($h + 1);
+            $n = $m;
+
+            foreach ($iter as $codePoint) {
+                if ($codePoint < $n && 0 === ++$delta) {
+                    throw new \Exception('Integer overflow');
+                }
+
+                if ($codePoint === $n) {
+                    $q = $delta;
+
+                    for ($k = self::BASE; /* no condition */; $k += self::BASE) {
+                        if ($k <= $bias) {
+                            $t = self::TMIN;
+                        } elseif ($k >= $bias + self::TMAX) {
+                            $t = self::TMAX;
+                        } else {
+                            $t = $k - $bias;
+                        }
+
+                        if ($q < $t) {
+                            break;
+                        }
+
+                        $qMinusT = $q - $t;
+                        $baseMinusT = self::BASE - $t;
+                        $output .= self::encodeDigit($t + $qMinusT % $baseMinusT, false);
+                        ++$out;
+                        $q = intdiv($qMinusT, $baseMinusT);
+                    }
+
+                    $output .= self::encodeDigit($q, false);
+                    ++$out;
+                    $bias = self::adaptBias($delta, $h + 1, $h === $b);
+                    $delta = 0;
+                    ++$h;
+                }
+            }
+
+            ++$delta;
+            ++$n;
+        }
+
+        return $output;
+    }
+
+    /**
+     * @see https://tools.ietf.org/html/rfc3492#section-6.1
+     *
+     * @param int  $delta
+     * @param int  $numPoints
+     * @param bool $firstTime
+     *
+     * @return int
+     */
+    private static function adaptBias($delta, $numPoints, $firstTime)
+    {
+        // xxx >> 1 is a faster way of doing intdiv(xxx, 2)
+        $delta = $firstTime ? intdiv($delta, self::DAMP) : $delta >> 1;
+        $delta += intdiv($delta, $numPoints);
+        $k = 0;
+
+        while ($delta > ((self::BASE - self::TMIN) * self::TMAX) >> 1) {
+            $delta = intdiv($delta, self::BASE - self::TMIN);
+            $k += self::BASE;
+        }
+
+        return $k + intdiv((self::BASE - self::TMIN + 1) * $delta, $delta + self::SKEW);
+    }
+
+    /**
+     * @param int  $d
+     * @param bool $flag
+     *
+     * @return string
+     */
+    private static function encodeDigit($d, $flag)
+    {
+        return \chr($d + 22 + 75 * ($d < 26 ? 1 : 0) - (($flag ? 1 : 0) << 5));
+    }
+
+    /**
+     * Takes a UTF-8 encoded string and converts it into a series of integer code points. Any
+     * invalid byte sequences will be replaced by a U+FFFD replacement code point.
+     *
+     * @see https://encoding.spec.whatwg.org/#utf-8-decoder
+     *
+     * @param string $input
+     *
+     * @return array<int, int>
+     */
+    private static function utf8Decode($input)
+    {
+        $bytesSeen = 0;
+        $bytesNeeded = 0;
+        $lowerBoundary = 0x80;
+        $upperBoundary = 0xBF;
+        $codePoint = 0;
+        $codePoints = [];
+        $length = \strlen($input);
+
+        for ($i = 0; $i < $length; ++$i) {
+            $byte = \ord($input[$i]);
+
+            if (0 === $bytesNeeded) {
+                if ($byte >= 0x00 && $byte <= 0x7F) {
+                    $codePoints[] = $byte;
+
+                    continue;
+                }
+
+                if ($byte >= 0xC2 && $byte <= 0xDF) {
+                    $bytesNeeded = 1;
+                    $codePoint = $byte & 0x1F;
+                } elseif ($byte >= 0xE0 && $byte <= 0xEF) {
+                    if (0xE0 === $byte) {
+                        $lowerBoundary = 0xA0;
+                    } elseif (0xED === $byte) {
+                        $upperBoundary = 0x9F;
+                    }
+
+                    $bytesNeeded = 2;
+                    $codePoint = $byte & 0xF;
+                } elseif ($byte >= 0xF0 && $byte <= 0xF4) {
+                    if (0xF0 === $byte) {
+                        $lowerBoundary = 0x90;
+                    } elseif (0xF4 === $byte) {
+                        $upperBoundary = 0x8F;
+                    }
+
+                    $bytesNeeded = 3;
+                    $codePoint = $byte & 0x7;
+                } else {
+                    $codePoints[] = 0xFFFD;
+                }
+
+                continue;
+            }
+
+            if ($byte < $lowerBoundary || $byte > $upperBoundary) {
+                $codePoint = 0;
+                $bytesNeeded = 0;
+                $bytesSeen = 0;
+                $lowerBoundary = 0x80;
+                $upperBoundary = 0xBF;
+                --$i;
+                $codePoints[] = 0xFFFD;
+
+                continue;
+            }
+
+            $lowerBoundary = 0x80;
+            $upperBoundary = 0xBF;
+            $codePoint = ($codePoint << 6) | ($byte & 0x3F);
+
+            if (++$bytesSeen !== $bytesNeeded) {
+                continue;
+            }
+
+            $codePoints[] = $codePoint;
+            $codePoint = 0;
+            $bytesNeeded = 0;
+            $bytesSeen = 0;
+        }
+
+        // String unexpectedly ended, so append a U+FFFD code point.
+        if (0 !== $bytesNeeded) {
+            $codePoints[] = 0xFFFD;
+        }
+
+        return $codePoints;
+    }
+
+    /**
+     * @param int  $codePoint
+     * @param bool $useSTD3ASCIIRules
+     *
+     * @return array{status: string, mapping?: string}
+     */
+    private static function lookupCodePointStatus($codePoint, $useSTD3ASCIIRules)
+    {
+        if (!self::$mappingTableLoaded) {
+            self::$mappingTableLoaded = true;
+            self::$mapped = require __DIR__.'/Resources/unidata/mapped.php';
+            self::$ignored = require __DIR__.'/Resources/unidata/ignored.php';
+            self::$deviation = require __DIR__.'/Resources/unidata/deviation.php';
+            self::$disallowed = require __DIR__.'/Resources/unidata/disallowed.php';
+            self::$disallowed_STD3_mapped = require __DIR__.'/Resources/unidata/disallowed_STD3_mapped.php';
+            self::$disallowed_STD3_valid = require __DIR__.'/Resources/unidata/disallowed_STD3_valid.php';
+        }
+
+        if (isset(self::$mapped[$codePoint])) {
+            return ['status' => 'mapped', 'mapping' => self::$mapped[$codePoint]];
+        }
+
+        if (isset(self::$ignored[$codePoint])) {
+            return ['status' => 'ignored'];
+        }
+
+        if (isset(self::$deviation[$codePoint])) {
+            return ['status' => 'deviation', 'mapping' => self::$deviation[$codePoint]];
+        }
+
+        if (isset(self::$disallowed[$codePoint]) || DisallowedRanges::inRange($codePoint)) {
+            return ['status' => 'disallowed'];
+        }
+
+        $isDisallowedMapped = isset(self::$disallowed_STD3_mapped[$codePoint]);
+
+        if ($isDisallowedMapped || isset(self::$disallowed_STD3_valid[$codePoint])) {
+            $status = 'disallowed';
+
+            if (!$useSTD3ASCIIRules) {
+                $status = $isDisallowedMapped ? 'mapped' : 'valid';
+            }
+
+            if ($isDisallowedMapped) {
+                return ['status' => $status, 'mapping' => self::$disallowed_STD3_mapped[$codePoint]];
+            }
+
+            return ['status' => $status];
+        }
+
+        return ['status' => 'valid'];
+    }
+}

vendor/symfony/polyfill-intl-idn/Info.php

@@ -0,0 +1,23 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com> and Trevor Rowbotham <trevor.rowbotham@pm.me>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Polyfill\Intl\Idn;
+
+/**
+ * @internal
+ */
+class Info
+{
+    public $bidiDomain = false;
+    public $errors = 0;
+    public $validBidiDomain = true;
+    public $transitionalDifferent = false;
+}

vendor/symfony/polyfill-intl-idn/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018-present Fabien Potencier and Trevor Rowbotham <trevor.rowbotham@pm.me>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/symfony/polyfill-intl-idn/README.md

@@ -0,0 +1,12 @@
+Symfony Polyfill / Intl: Idn
+============================
+
+This component provides [`idn_to_ascii`](https://php.net/idn-to-ascii) and [`idn_to_utf8`](https://php.net/idn-to-utf8) functions to users who run php versions without the [Intl](https://php.net/intl) extension.
+
+More information can be found in the
+[main Polyfill README](https://github.com/symfony/polyfill/blob/main/README.md).
+
+License
+=======
+
+This library is released under the [MIT license](LICENSE).

vendor/symfony/polyfill-intl-idn/Resources/unidata/DisallowedRanges.php

@@ -0,0 +1,384 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Polyfill\Intl\Idn\Resources\unidata;
+
+/**
+ * @internal
+ */
+final class DisallowedRanges
+{
+    /**
+     * @param int $codePoint
+     *
+     * @return bool
+     */
+    public static function inRange($codePoint)
+    {
+        if ($codePoint >= 128 && $codePoint <= 159) {
+            return true;
+        }
+
+        if ($codePoint >= 2155 && $codePoint <= 2207) {
+            return true;
+        }
+
+        if ($codePoint >= 3676 && $codePoint <= 3712) {
+            return true;
+        }
+
+        if ($codePoint >= 3808 && $codePoint <= 3839) {
+            return true;
+        }
+
+        if ($codePoint >= 4059 && $codePoint <= 4095) {
+            return true;
+        }
+
+        if ($codePoint >= 4256 && $codePoint <= 4293) {
+            return true;
+        }
+
+        if ($codePoint >= 6849 && $codePoint <= 6911) {
+            return true;
+        }
+
+        if ($codePoint >= 11859 && $codePoint <= 11903) {
+            return true;
+        }
+
+        if ($codePoint >= 42955 && $codePoint <= 42996) {
+            return true;
+        }
+
+        if ($codePoint >= 55296 && $codePoint <= 57343) {
+            return true;
+        }
+
+        if ($codePoint >= 57344 && $codePoint <= 63743) {
+            return true;
+        }
+
+        if ($codePoint >= 64218 && $codePoint <= 64255) {
+            return true;
+        }
+
+        if ($codePoint >= 64976 && $codePoint <= 65007) {
+            return true;
+        }
+
+        if ($codePoint >= 65630 && $codePoint <= 65663) {
+            return true;
+        }
+
+        if ($codePoint >= 65953 && $codePoint <= 65999) {
+            return true;
+        }
+
+        if ($codePoint >= 66046 && $codePoint <= 66175) {
+            return true;
+        }
+
+        if ($codePoint >= 66518 && $codePoint <= 66559) {
+            return true;
+        }
+
+        if ($codePoint >= 66928 && $codePoint <= 67071) {
+            return true;
+        }
+
+        if ($codePoint >= 67432 && $codePoint <= 67583) {
+            return true;
+        }
+
+        if ($codePoint >= 67760 && $codePoint <= 67807) {
+            return true;
+        }
+
+        if ($codePoint >= 67904 && $codePoint <= 67967) {
+            return true;
+        }
+
+        if ($codePoint >= 68256 && $codePoint <= 68287) {
+            return true;
+        }
+
+        if ($codePoint >= 68528 && $codePoint <= 68607) {
+            return true;
+        }
+
+        if ($codePoint >= 68681 && $codePoint <= 68735) {
+            return true;
+        }
+
+        if ($codePoint >= 68922 && $codePoint <= 69215) {
+            return true;
+        }
+
+        if ($codePoint >= 69298 && $codePoint <= 69375) {
+            return true;
+        }
+
+        if ($codePoint >= 69466 && $codePoint <= 69551) {
+            return true;
+        }
+
+        if ($codePoint >= 70207 && $codePoint <= 70271) {
+            return true;
+        }
+
+        if ($codePoint >= 70517 && $codePoint <= 70655) {
+            return true;
+        }
+
+        if ($codePoint >= 70874 && $codePoint <= 71039) {
+            return true;
+        }
+
+        if ($codePoint >= 71134 && $codePoint <= 71167) {
+            return true;
+        }
+
+        if ($codePoint >= 71370 && $codePoint <= 71423) {
+            return true;
+        }
+
+        if ($codePoint >= 71488 && $codePoint <= 71679) {
+            return true;
+        }
+
+        if ($codePoint >= 71740 && $codePoint <= 71839) {
+            return true;
+        }
+
+        if ($codePoint >= 72026 && $codePoint <= 72095) {
+            return true;
+        }
+
+        if ($codePoint >= 72441 && $codePoint <= 72703) {
+            return true;
+        }
+
+        if ($codePoint >= 72887 && $codePoint <= 72959) {
+            return true;
+        }
+
+        if ($codePoint >= 73130 && $codePoint <= 73439) {
+            return true;
+        }
+
+        if ($codePoint >= 73465 && $codePoint <= 73647) {
+            return true;
+        }
+
+        if ($codePoint >= 74650 && $codePoint <= 74751) {
+            return true;
+        }
+
+        if ($codePoint >= 75076 && $codePoint <= 77823) {
+            return true;
+        }
+
+        if ($codePoint >= 78905 && $codePoint <= 82943) {
+            return true;
+        }
+
+        if ($codePoint >= 83527 && $codePoint <= 92159) {
+            return true;
+        }
+
+        if ($codePoint >= 92784 && $codePoint <= 92879) {
+            return true;
+        }
+
+        if ($codePoint >= 93072 && $codePoint <= 93759) {
+            return true;
+        }
+
+        if ($codePoint >= 93851 && $codePoint <= 93951) {
+            return true;
+        }
+
+        if ($codePoint >= 94112 && $codePoint <= 94175) {
+            return true;
+        }
+
+        if ($codePoint >= 101590 && $codePoint <= 101631) {
+            return true;
+        }
+
+        if ($codePoint >= 101641 && $codePoint <= 110591) {
+            return true;
+        }
+
+        if ($codePoint >= 110879 && $codePoint <= 110927) {
+            return true;
+        }
+
+        if ($codePoint >= 111356 && $codePoint <= 113663) {
+            return true;
+        }
+
+        if ($codePoint >= 113828 && $codePoint <= 118783) {
+            return true;
+        }
+
+        if ($codePoint >= 119366 && $codePoint <= 119519) {
+            return true;
+        }
+
+        if ($codePoint >= 119673 && $codePoint <= 119807) {
+            return true;
+        }
+
+        if ($codePoint >= 121520 && $codePoint <= 122879) {
+            return true;
+        }
+
+        if ($codePoint >= 122923 && $codePoint <= 123135) {
+            return true;
+        }
+
+        if ($codePoint >= 123216 && $codePoint <= 123583) {
+            return true;
+        }
+
+        if ($codePoint >= 123648 && $codePoint <= 124927) {
+            return true;
+        }
+
+        if ($codePoint >= 125143 && $codePoint <= 125183) {
+            return true;
+        }
+
+        if ($codePoint >= 125280 && $codePoint <= 126064) {
+            return true;
+        }
+
+        if ($codePoint >= 126133 && $codePoint <= 126208) {
+            return true;
+        }
+
+        if ($codePoint >= 126270 && $codePoint <= 126463) {
+            return true;
+        }
+
+        if ($codePoint >= 126652 && $codePoint <= 126703) {
+            return true;
+        }
+
+        if ($codePoint >= 126706 && $codePoint <= 126975) {
+            return true;
+        }
+
+        if ($codePoint >= 127406 && $codePoint <= 127461) {
+            return true;
+        }
+
+        if ($codePoint >= 127590 && $codePoint <= 127743) {
+            return true;
+        }
+
+        if ($codePoint >= 129202 && $codePoint <= 129279) {
+            return true;
+        }
+
+        if ($codePoint >= 129751 && $codePoint <= 129791) {
+            return true;
+        }
+
+        if ($codePoint >= 129995 && $codePoint <= 130031) {
+            return true;
+        }
+
+        if ($codePoint >= 130042 && $codePoint <= 131069) {
+            return true;
+        }
+
+        if ($codePoint >= 173790 && $codePoint <= 173823) {
+            return true;
+        }
+
+        if ($codePoint >= 191457 && $codePoint <= 194559) {
+            return true;
+        }
+
+        if ($codePoint >= 195102 && $codePoint <= 196605) {
+            return true;
+        }
+
+        if ($codePoint >= 201547 && $codePoint <= 262141) {
+            return true;
+        }
+
+        if ($codePoint >= 262144 && $codePoint <= 327677) {
+            return true;
+        }
+
+        if ($codePoint >= 327680 && $codePoint <= 393213) {
+            return true;
+        }
+
+        if ($codePoint >= 393216 && $codePoint <= 458749) {
+            return true;
+        }
+
+        if ($codePoint >= 458752 && $codePoint <= 524285) {
+            return true;
+        }
+
+        if ($codePoint >= 524288 && $codePoint <= 589821) {
+            return true;
+        }
+
+        if ($codePoint >= 589824 && $codePoint <= 655357) {
+            return true;
+        }
+
+        if ($codePoint >= 655360 && $codePoint <= 720893) {
+            return true;
+        }
+
+        if ($codePoint >= 720896 && $codePoint <= 786429) {
+            return true;
+        }
+
+        if ($codePoint >= 786432 && $codePoint <= 851965) {
+            return true;
+        }
+
+        if ($codePoint >= 851968 && $codePoint <= 917501) {
+            return true;
+        }
+
+        if ($codePoint >= 917536 && $codePoint <= 917631) {
+            return true;
+        }
+
+        if ($codePoint >= 917632 && $codePoint <= 917759) {
+            return true;
+        }
+
+        if ($codePoint >= 918000 && $codePoint <= 983037) {
+            return true;
+        }
+
+        if ($codePoint >= 983040 && $codePoint <= 1048573) {
+            return true;
+        }
+
+        if ($codePoint >= 1048576 && $codePoint <= 1114109) {
+            return true;
+        }
+
+        return false;
+    }
+}

vendor/symfony/polyfill-intl-idn/Resources/unidata/deviation.php

@@ -0,0 +1,8 @@
+<?php
+
+return array (
+  223 => 'ss',
+  962 => 'σ',
+  8204 => '',
+  8205 => '',
+);

vendor/symfony/polyfill-intl-idn/Resources/unidata/disallowed_STD3_mapped.php

@@ -0,0 +1,308 @@
+<?php
+
+return array (
+  160 => ' ',
+  168 => ' ̈',
+  175 => ' ̄',
+  180 => ' ́',
+  184 => ' ̧',
+  728 => ' ̆',
+  729 => ' ̇',
+  730 => ' ̊',
+  731 => ' ̨',
+  732 => ' ̃',
+  733 => ' ̋',
+  890 => ' ι',
+  894 => ';',
+  900 => ' ́',
+  901 => ' ̈́',
+  8125 => ' ̓',
+  8127 => ' ̓',
+  8128 => ' ͂',
+  8129 => ' ̈͂',
+  8141 => ' ̓̀',
+  8142 => ' ̓́',
+  8143 => ' ̓͂',
+  8157 => ' ̔̀',
+  8158 => ' ̔́',
+  8159 => ' ̔͂',
+  8173 => ' ̈̀',
+  8174 => ' ̈́',
+  8175 => '`',
+  8189 => ' ́',
+  8190 => ' ̔',
+  8192 => ' ',
+  8193 => ' ',
+  8194 => ' ',
+  8195 => ' ',
+  8196 => ' ',
+  8197 => ' ',
+  8198 => ' ',
+  8199 => ' ',
+  8200 => ' ',
+  8201 => ' ',
+  8202 => ' ',
+  8215 => ' ̳',
+  8239 => ' ',
+  8252 => '!!',
+  8254 => ' ̅',
+  8263 => '??',
+  8264 => '?!',
+  8265 => '!?',
+  8287 => ' ',
+  8314 => '+',
+  8316 => '=',
+  8317 => '(',
+  8318 => ')',
+  8330 => '+',
+  8332 => '=',
+  8333 => '(',
+  8334 => ')',
+  8448 => 'a/c',
+  8449 => 'a/s',
+  8453 => 'c/o',
+  8454 => 'c/u',
+  9332 => '(1)',
+  9333 => '(2)',
+  9334 => '(3)',
+  9335 => '(4)',
+  9336 => '(5)',
+  9337 => '(6)',
+  9338 => '(7)',
+  9339 => '(8)',
+  9340 => '(9)',
+  9341 => '(10)',
+  9342 => '(11)',
+  9343 => '(12)',
+  9344 => '(13)',
+  9345 => '(14)',
+  9346 => '(15)',
+  9347 => '(16)',
+  9348 => '(17)',
+  9349 => '(18)',
+  9350 => '(19)',
+  9351 => '(20)',
+  9372 => '(a)',
+  9373 => '(b)',
+  9374 => '(c)',
+  9375 => '(d)',
+  9376 => '(e)',
+  9377 => '(f)',
+  9378 => '(g)',
+  9379 => '(h)',
+  9380 => '(i)',
+  9381 => '(j)',
+  9382 => '(k)',
+  9383 => '(l)',
+  9384 => '(m)',
+  9385 => '(n)',
+  9386 => '(o)',
+  9387 => '(p)',
+  9388 => '(q)',
+  9389 => '(r)',
+  9390 => '(s)',
+  9391 => '(t)',
+  9392 => '(u)',
+  9393 => '(v)',
+  9394 => '(w)',
+  9395 => '(x)',
+  9396 => '(y)',
+  9397 => '(z)',
+  10868 => '::=',
+  10869 => '==',
+  10870 => '===',
+  12288 => ' ',
+  12443 => ' ゙',
+  12444 => ' ゚',
+  12800 => '(ᄀ)',
+  12801 => '(ᄂ)',
+  12802 => '(ᄃ)',
+  12803 => '(ᄅ)',
+  12804 => '(ᄆ)',
+  12805 => '(ᄇ)',
+  12806 => '(ᄉ)',
+  12807 => '(ᄋ)',
+  12808 => '(ᄌ)',
+  12809 => '(ᄎ)',
+  12810 => '(ᄏ)',
+  12811 => '(ᄐ)',
+  12812 => '(ᄑ)',
+  12813 => '(ᄒ)',
+  12814 => '(가)',
+  12815 => '(나)',
+  12816 => '(다)',
+  12817 => '(라)',
+  12818 => '(마)',
+  12819 => '(바)',
+  12820 => '(사)',
+  12821 => '(아)',
+  12822 => '(자)',
+  12823 => '(차)',
+  12824 => '(카)',
+  12825 => '(타)',
+  12826 => '(파)',
+  12827 => '(하)',
+  12828 => '(주)',
+  12829 => '(오전)',
+  12830 => '(오후)',
+  12832 => '(一)',
+  12833 => '(二)',
+  12834 => '(三)',
+  12835 => '(四)',
+  12836 => '(五)',
+  12837 => '(六)',
+  12838 => '(七)',
+  12839 => '(八)',
+  12840 => '(九)',
+  12841 => '(十)',
+  12842 => '(月)',
+  12843 => '(火)',
+  12844 => '(水)',
+  12845 => '(木)',
+  12846 => '(金)',
+  12847 => '(土)',
+  12848 => '(日)',
+  12849 => '(株)',
+  12850 => '(有)',
+  12851 => '(社)',
+  12852 => '(名)',
+  12853 => '(特)',
+  12854 => '(財)',
+  12855 => '(祝)',
+  12856 => '(労)',
+  12857 => '(代)',
+  12858 => '(呼)',
+  12859 => '(学)',
+  12860 => '(監)',
+  12861 => '(企)',
+  12862 => '(資)',
+  12863 => '(協)',
+  12864 => '(祭)',
+  12865 => '(休)',
+  12866 => '(自)',
+  12867 => '(至)',
+  64297 => '+',
+  64606 => ' ٌّ',
+  64607 => ' ٍّ',
+  64608 => ' َّ',
+  64609 => ' ُّ',
+  64610 => ' ِّ',
+  64611 => ' ّٰ',
+  65018 => 'صلى الله عليه وسلم',
+  65019 => 'جل جلاله',
+  65040 => ',',
+  65043 => ':',
+  65044 => ';',
+  65045 => '!',
+  65046 => '?',
+  65075 => '_',
+  65076 => '_',
+  65077 => '(',
+  65078 => ')',
+  65079 => '{',
+  65080 => '}',
+  65095 => '[',
+  65096 => ']',
+  65097 => ' ̅',
+  65098 => ' ̅',
+  65099 => ' ̅',
+  65100 => ' ̅',
+  65101 => '_',
+  65102 => '_',
+  65103 => '_',
+  65104 => ',',
+  65108 => ';',
+  65109 => ':',
+  65110 => '?',
+  65111 => '!',
+  65113 => '(',
+  65114 => ')',
+  65115 => '{',
+  65116 => '}',
+  65119 => '#',
+  65120 => '&',
+  65121 => '*',
+  65122 => '+',
+  65124 => '<',
+  65125 => '>',
+  65126 => '=',
+  65128 => '\\',
+  65129 => '$',
+  65130 => '%',
+  65131 => '@',
+  65136 => ' ً',
+  65138 => ' ٌ',
+  65140 => ' ٍ',
+  65142 => ' َ',
+  65144 => ' ُ',
+  65146 => ' ِ',
+  65148 => ' ّ',
+  65150 => ' ْ',
+  65281 => '!',
+  65282 => '"',
+  65283 => '#',
+  65284 => '$',
+  65285 => '%',
+  65286 => '&',
+  65287 => '\'',
+  65288 => '(',
+  65289 => ')',
+  65290 => '*',
+  65291 => '+',
+  65292 => ',',
+  65295 => '/',
+  65306 => ':',
+  65307 => ';',
+  65308 => '<',
+  65309 => '=',
+  65310 => '>',
+  65311 => '?',
+  65312 => '@',
+  65339 => '[',
+  65340 => '\\',
+  65341 => ']',
+  65342 => '^',
+  65343 => '_',
+  65344 => '`',
+  65371 => '{',
+  65372 => '|',
+  65373 => '}',
+  65374 => '~',
+  65507 => ' ̄',
+  127233 => '0,',
+  127234 => '1,',
+  127235 => '2,',
+  127236 => '3,',
+  127237 => '4,',
+  127238 => '5,',
+  127239 => '6,',
+  127240 => '7,',
+  127241 => '8,',
+  127242 => '9,',
+  127248 => '(a)',
+  127249 => '(b)',
+  127250 => '(c)',
+  127251 => '(d)',
+  127252 => '(e)',
+  127253 => '(f)',
+  127254 => '(g)',
+  127255 => '(h)',
+  127256 => '(i)',
+  127257 => '(j)',
+  127258 => '(k)',
+  127259 => '(l)',
+  127260 => '(m)',
+  127261 => '(n)',
+  127262 => '(o)',
+  127263 => '(p)',
+  127264 => '(q)',
+  127265 => '(r)',
+  127266 => '(s)',
+  127267 => '(t)',
+  127268 => '(u)',
+  127269 => '(v)',
+  127270 => '(w)',
+  127271 => '(x)',
+  127272 => '(y)',
+  127273 => '(z)',
+);

vendor/symfony/polyfill-intl-idn/Resources/unidata/disallowed_STD3_valid.php

@@ -0,0 +1,71 @@
+<?php
+
+return array (
+  0 => true,
+  1 => true,
+  2 => true,
+  3 => true,
+  4 => true,
+  5 => true,
+  6 => true,
+  7 => true,
+  8 => true,
+  9 => true,
+  10 => true,
+  11 => true,
+  12 => true,
+  13 => true,
+  14 => true,
+  15 => true,
+  16 => true,
+  17 => true,
+  18 => true,
+  19 => true,
+  20 => true,
+  21 => true,
+  22 => true,
+  23 => true,
+  24 => true,
+  25 => true,
+  26 => true,
+  27 => true,
+  28 => true,
+  29 => true,
+  30 => true,
+  31 => true,
+  32 => true,
+  33 => true,
+  34 => true,
+  35 => true,
+  36 => true,
+  37 => true,
+  38 => true,
+  39 => true,
+  40 => true,
+  41 => true,
+  42 => true,
+  43 => true,
+  44 => true,
+  47 => true,
+  58 => true,
+  59 => true,
+  60 => true,
+  61 => true,
+  62 => true,
+  63 => true,
+  64 => true,
+  91 => true,
+  92 => true,
+  93 => true,
+  94 => true,
+  95 => true,
+  96 => true,
+  123 => true,
+  124 => true,
+  125 => true,
+  126 => true,
+  127 => true,
+  8800 => true,
+  8814 => true,
+  8815 => true,
+);

vendor/symfony/polyfill-intl-idn/Resources/unidata/ignored.php

@@ -0,0 +1,273 @@
+<?php
+
+return array (
+  173 => true,
+  847 => true,
+  6155 => true,
+  6156 => true,
+  6157 => true,
+  8203 => true,
+  8288 => true,
+  8292 => true,
+  65024 => true,
+  65025 => true,
+  65026 => true,
+  65027 => true,
+  65028 => true,
+  65029 => true,
+  65030 => true,
+  65031 => true,
+  65032 => true,
+  65033 => true,
+  65034 => true,
+  65035 => true,
+  65036 => true,
+  65037 => true,
+  65038 => true,
+  65039 => true,
+  65279 => true,
+  113824 => true,
+  113825 => true,
+  113826 => true,
+  113827 => true,
+  917760 => true,
+  917761 => true,
+  917762 => true,
+  917763 => true,
+  917764 => true,
+  917765 => true,
+  917766 => true,
+  917767 => true,
+  917768 => true,
+  917769 => true,
+  917770 => true,
+  917771 => true,
+  917772 => true,
+  917773 => true,
+  917774 => true,
+  917775 => true,
+  917776 => true,
+  917777 => true,
+  917778 => true,
+  917779 => true,
+  917780 => true,
+  917781 => true,
+  917782 => true,
+  917783 => true,
+  917784 => true,
+  917785 => true,
+  917786 => true,
+  917787 => true,
+  917788 => true,
+  917789 => true,
+  917790 => true,
+  917791 => true,
+  917792 => true,
+  917793 => true,
+  917794 => true,
+  917795 => true,
+  917796 => true,
+  917797 => true,
+  917798 => true,
+  917799 => true,
+  917800 => true,
+  917801 => true,
+  917802 => true,
+  917803 => true,
+  917804 => true,
+  917805 => true,
+  917806 => true,
+  917807 => true,
+  917808 => true,
+  917809 => true,
+  917810 => true,
+  917811 => true,
+  917812 => true,
+  917813 => true,
+  917814 => true,
+  917815 => true,
+  917816 => true,
+  917817 => true,
+  917818 => true,
+  917819 => true,
+  917820 => true,
+  917821 => true,
+  917822 => true,
+  917823 => true,
+  917824 => true,
+  917825 => true,
+  917826 => true,
+  917827 => true,
+  917828 => true,
+  917829 => true,
+  917830 => true,
+  917831 => true,
+  917832 => true,
+  917833 => true,
+  917834 => true,
+  917835 => true,
+  917836 => true,
+  917837 => true,
+  917838 => true,
+  917839 => true,
+  917840 => true,
+  917841 => true,
+  917842 => true,
+  917843 => true,
+  917844 => true,
+  917845 => true,
+  917846 => true,
+  917847 => true,
+  917848 => true,
+  917849 => true,
+  917850 => true,
+  917851 => true,
+  917852 => true,
+  917853 => true,
+  917854 => true,
+  917855 => true,
+  917856 => true,
+  917857 => true,
+  917858 => true,
+  917859 => true,
+  917860 => true,
+  917861 => true,
+  917862 => true,
+  917863 => true,
+  917864 => true,
+  917865 => true,
+  917866 => true,
+  917867 => true,
+  917868 => true,
+  917869 => true,
+  917870 => true,
+  917871 => true,
+  917872 => true,
+  917873 => true,
+  917874 => true,
+  917875 => true,
+  917876 => true,
+  917877 => true,
+  917878 => true,
+  917879 => true,
+  917880 => true,
+  917881 => true,
+  917882 => true,
+  917883 => true,
+  917884 => true,
+  917885 => true,
+  917886 => true,
+  917887 => true,
+  917888 => true,
+  917889 => true,
+  917890 => true,
+  917891 => true,
+  917892 => true,
+  917893 => true,
+  917894 => true,
+  917895 => true,
+  917896 => true,
+  917897 => true,
+  917898 => true,
+  917899 => true,
+  917900 => true,
+  917901 => true,
+  917902 => true,
+  917903 => true,
+  917904 => true,
+  917905 => true,
+  917906 => true,
+  917907 => true,
+  917908 => true,
+  917909 => true,
+  917910 => true,
+  917911 => true,
+  917912 => true,
+  917913 => true,
+  917914 => true,
+  917915 => true,
+  917916 => true,
+  917917 => true,
+  917918 => true,
+  917919 => true,
+  917920 => true,
+  917921 => true,
+  917922 => true,
+  917923 => true,
+  917924 => true,
+  917925 => true,
+  917926 => true,
+  917927 => true,
+  917928 => true,
+  917929 => true,
+  917930 => true,
+  917931 => true,
+  917932 => true,
+  917933 => true,
+  917934 => true,
+  917935 => true,
+  917936 => true,
+  917937 => true,
+  917938 => true,
+  917939 => true,
+  917940 => true,
+  917941 => true,
+  917942 => true,
+  917943 => true,
+  917944 => true,
+  917945 => true,
+  917946 => true,
+  917947 => true,
+  917948 => true,
+  917949 => true,
+  917950 => true,
+  917951 => true,
+  917952 => true,
+  917953 => true,
+  917954 => true,
+  917955 => true,
+  917956 => true,
+  917957 => true,
+  917958 => true,
+  917959 => true,
+  917960 => true,
+  917961 => true,
+  917962 => true,
+  917963 => true,
+  917964 => true,
+  917965 => true,
+  917966 => true,
+  917967 => true,
+  917968 => true,
+  917969 => true,
+  917970 => true,
+  917971 => true,
+  917972 => true,
+  917973 => true,
+  917974 => true,
+  917975 => true,
+  917976 => true,
+  917977 => true,
+  917978 => true,
+  917979 => true,
+  917980 => true,
+  917981 => true,
+  917982 => true,
+  917983 => true,
+  917984 => true,
+  917985 => true,
+  917986 => true,
+  917987 => true,
+  917988 => true,
+  917989 => true,
+  917990 => true,
+  917991 => true,
+  917992 => true,
+  917993 => true,
+  917994 => true,
+  917995 => true,
+  917996 => true,
+  917997 => true,
+  917998 => true,
+  917999 => true,
+);

vendor/symfony/polyfill-intl-idn/Resources/unidata/virama.php

@@ -0,0 +1,65 @@
+<?php
+
+return array (
+  2381 => 9,
+  2509 => 9,
+  2637 => 9,
+  2765 => 9,
+  2893 => 9,
+  3021 => 9,
+  3149 => 9,
+  3277 => 9,
+  3387 => 9,
+  3388 => 9,
+  3405 => 9,
+  3530 => 9,
+  3642 => 9,
+  3770 => 9,
+  3972 => 9,
+  4153 => 9,
+  4154 => 9,
+  5908 => 9,
+  5940 => 9,
+  6098 => 9,
+  6752 => 9,
+  6980 => 9,
+  7082 => 9,
+  7083 => 9,
+  7154 => 9,
+  7155 => 9,
+  11647 => 9,
+  43014 => 9,
+  43052 => 9,
+  43204 => 9,
+  43347 => 9,
+  43456 => 9,
+  43766 => 9,
+  44013 => 9,
+  68159 => 9,
+  69702 => 9,
+  69759 => 9,
+  69817 => 9,
+  69939 => 9,
+  69940 => 9,
+  70080 => 9,
+  70197 => 9,
+  70378 => 9,
+  70477 => 9,
+  70722 => 9,
+  70850 => 9,
+  71103 => 9,
+  71231 => 9,
+  71350 => 9,
+  71467 => 9,
+  71737 => 9,
+  71997 => 9,
+  71998 => 9,
+  72160 => 9,
+  72244 => 9,
+  72263 => 9,
+  72345 => 9,
+  72767 => 9,
+  73028 => 9,
+  73029 => 9,
+  73111 => 9,
+);

vendor/symfony/polyfill-intl-idn/bootstrap.php

@@ -0,0 +1,145 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Symfony\Polyfill\Intl\Idn as p;
+
+if (extension_loaded('intl')) {
+    return;
+}
+
+if (\PHP_VERSION_ID >= 80000) {
+    return require __DIR__.'/bootstrap80.php';
+}
+
+if (!defined('U_IDNA_PROHIBITED_ERROR')) {
+    define('U_IDNA_PROHIBITED_ERROR', 66560);
+}
+if (!defined('U_IDNA_ERROR_START')) {
+    define('U_IDNA_ERROR_START', 66560);
+}
+if (!defined('U_IDNA_UNASSIGNED_ERROR')) {
+    define('U_IDNA_UNASSIGNED_ERROR', 66561);
+}
+if (!defined('U_IDNA_CHECK_BIDI_ERROR')) {
+    define('U_IDNA_CHECK_BIDI_ERROR', 66562);
+}
+if (!defined('U_IDNA_STD3_ASCII_RULES_ERROR')) {
+    define('U_IDNA_STD3_ASCII_RULES_ERROR', 66563);
+}
+if (!defined('U_IDNA_ACE_PREFIX_ERROR')) {
+    define('U_IDNA_ACE_PREFIX_ERROR', 66564);
+}
+if (!defined('U_IDNA_VERIFICATION_ERROR')) {
+    define('U_IDNA_VERIFICATION_ERROR', 66565);
+}
+if (!defined('U_IDNA_LABEL_TOO_LONG_ERROR')) {
+    define('U_IDNA_LABEL_TOO_LONG_ERROR', 66566);
+}
+if (!defined('U_IDNA_ZERO_LENGTH_LABEL_ERROR')) {
+    define('U_IDNA_ZERO_LENGTH_LABEL_ERROR', 66567);
+}
+if (!defined('U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR')) {
+    define('U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR', 66568);
+}
+if (!defined('U_IDNA_ERROR_LIMIT')) {
+    define('U_IDNA_ERROR_LIMIT', 66569);
+}
+if (!defined('U_STRINGPREP_PROHIBITED_ERROR')) {
+    define('U_STRINGPREP_PROHIBITED_ERROR', 66560);
+}
+if (!defined('U_STRINGPREP_UNASSIGNED_ERROR')) {
+    define('U_STRINGPREP_UNASSIGNED_ERROR', 66561);
+}
+if (!defined('U_STRINGPREP_CHECK_BIDI_ERROR')) {
+    define('U_STRINGPREP_CHECK_BIDI_ERROR', 66562);
+}
+if (!defined('IDNA_DEFAULT')) {
+    define('IDNA_DEFAULT', 0);
+}
+if (!defined('IDNA_ALLOW_UNASSIGNED')) {
+    define('IDNA_ALLOW_UNASSIGNED', 1);
+}
+if (!defined('IDNA_USE_STD3_RULES')) {
+    define('IDNA_USE_STD3_RULES', 2);
+}
+if (!defined('IDNA_CHECK_BIDI')) {
+    define('IDNA_CHECK_BIDI', 4);
+}
+if (!defined('IDNA_CHECK_CONTEXTJ')) {
+    define('IDNA_CHECK_CONTEXTJ', 8);
+}
+if (!defined('IDNA_NONTRANSITIONAL_TO_ASCII')) {
+    define('IDNA_NONTRANSITIONAL_TO_ASCII', 16);
+}
+if (!defined('IDNA_NONTRANSITIONAL_TO_UNICODE')) {
+    define('IDNA_NONTRANSITIONAL_TO_UNICODE', 32);
+}
+if (!defined('INTL_IDNA_VARIANT_2003')) {
+    define('INTL_IDNA_VARIANT_2003', 0);
+}
+if (!defined('INTL_IDNA_VARIANT_UTS46')) {
+    define('INTL_IDNA_VARIANT_UTS46', 1);
+}
+if (!defined('IDNA_ERROR_EMPTY_LABEL')) {
+    define('IDNA_ERROR_EMPTY_LABEL', 1);
+}
+if (!defined('IDNA_ERROR_LABEL_TOO_LONG')) {
+    define('IDNA_ERROR_LABEL_TOO_LONG', 2);
+}
+if (!defined('IDNA_ERROR_DOMAIN_NAME_TOO_LONG')) {
+    define('IDNA_ERROR_DOMAIN_NAME_TOO_LONG', 4);
+}
+if (!defined('IDNA_ERROR_LEADING_HYPHEN')) {
+    define('IDNA_ERROR_LEADING_HYPHEN', 8);
+}
+if (!defined('IDNA_ERROR_TRAILING_HYPHEN')) {
+    define('IDNA_ERROR_TRAILING_HYPHEN', 16);
+}
+if (!defined('IDNA_ERROR_HYPHEN_3_4')) {
+    define('IDNA_ERROR_HYPHEN_3_4', 32);
+}
+if (!defined('IDNA_ERROR_LEADING_COMBINING_MARK')) {
+    define('IDNA_ERROR_LEADING_COMBINING_MARK', 64);
+}
+if (!defined('IDNA_ERROR_DISALLOWED')) {
+    define('IDNA_ERROR_DISALLOWED', 128);
+}
+if (!defined('IDNA_ERROR_PUNYCODE')) {
+    define('IDNA_ERROR_PUNYCODE', 256);
+}
+if (!defined('IDNA_ERROR_LABEL_HAS_DOT')) {
+    define('IDNA_ERROR_LABEL_HAS_DOT', 512);
+}
+if (!defined('IDNA_ERROR_INVALID_ACE_LABEL')) {
+    define('IDNA_ERROR_INVALID_ACE_LABEL', 1024);
+}
+if (!defined('IDNA_ERROR_BIDI')) {
+    define('IDNA_ERROR_BIDI', 2048);
+}
+if (!defined('IDNA_ERROR_CONTEXTJ')) {
+    define('IDNA_ERROR_CONTEXTJ', 4096);
+}
+
+if (\PHP_VERSION_ID < 70400) {
+    if (!function_exists('idn_to_ascii')) {
+        function idn_to_ascii($domain, $flags = 0, $variant = \INTL_IDNA_VARIANT_2003, &$idna_info = null) { return p\Idn::idn_to_ascii($domain, $flags, $variant, $idna_info); }
+    }
+    if (!function_exists('idn_to_utf8')) {
+        function idn_to_utf8($domain, $flags = 0, $variant = \INTL_IDNA_VARIANT_2003, &$idna_info = null) { return p\Idn::idn_to_utf8($domain, $flags, $variant, $idna_info); }
+    }
+} else {
+    if (!function_exists('idn_to_ascii')) {
+        function idn_to_ascii($domain, $flags = 0, $variant = \INTL_IDNA_VARIANT_UTS46, &$idna_info = null) { return p\Idn::idn_to_ascii($domain, $flags, $variant, $idna_info); }
+    }
+    if (!function_exists('idn_to_utf8')) {
+        function idn_to_utf8($domain, $flags = 0, $variant = \INTL_IDNA_VARIANT_UTS46, &$idna_info = null) { return p\Idn::idn_to_utf8($domain, $flags, $variant, $idna_info); }
+    }
+}

vendor/symfony/polyfill-intl-idn/bootstrap80.php

@@ -0,0 +1,125 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Symfony\Polyfill\Intl\Idn as p;
+
+if (!defined('U_IDNA_PROHIBITED_ERROR')) {
+    define('U_IDNA_PROHIBITED_ERROR', 66560);
+}
+if (!defined('U_IDNA_ERROR_START')) {
+    define('U_IDNA_ERROR_START', 66560);
+}
+if (!defined('U_IDNA_UNASSIGNED_ERROR')) {
+    define('U_IDNA_UNASSIGNED_ERROR', 66561);
+}
+if (!defined('U_IDNA_CHECK_BIDI_ERROR')) {
+    define('U_IDNA_CHECK_BIDI_ERROR', 66562);
+}
+if (!defined('U_IDNA_STD3_ASCII_RULES_ERROR')) {
+    define('U_IDNA_STD3_ASCII_RULES_ERROR', 66563);
+}
+if (!defined('U_IDNA_ACE_PREFIX_ERROR')) {
+    define('U_IDNA_ACE_PREFIX_ERROR', 66564);
+}
+if (!defined('U_IDNA_VERIFICATION_ERROR')) {
+    define('U_IDNA_VERIFICATION_ERROR', 66565);
+}
+if (!defined('U_IDNA_LABEL_TOO_LONG_ERROR')) {
+    define('U_IDNA_LABEL_TOO_LONG_ERROR', 66566);
+}
+if (!defined('U_IDNA_ZERO_LENGTH_LABEL_ERROR')) {
+    define('U_IDNA_ZERO_LENGTH_LABEL_ERROR', 66567);
+}
+if (!defined('U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR')) {
+    define('U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR', 66568);
+}
+if (!defined('U_IDNA_ERROR_LIMIT')) {
+    define('U_IDNA_ERROR_LIMIT', 66569);
+}
+if (!defined('U_STRINGPREP_PROHIBITED_ERROR')) {
+    define('U_STRINGPREP_PROHIBITED_ERROR', 66560);
+}
+if (!defined('U_STRINGPREP_UNASSIGNED_ERROR')) {
+    define('U_STRINGPREP_UNASSIGNED_ERROR', 66561);
+}
+if (!defined('U_STRINGPREP_CHECK_BIDI_ERROR')) {
+    define('U_STRINGPREP_CHECK_BIDI_ERROR', 66562);
+}
+if (!defined('IDNA_DEFAULT')) {
+    define('IDNA_DEFAULT', 0);
+}
+if (!defined('IDNA_ALLOW_UNASSIGNED')) {
+    define('IDNA_ALLOW_UNASSIGNED', 1);
+}
+if (!defined('IDNA_USE_STD3_RULES')) {
+    define('IDNA_USE_STD3_RULES', 2);
+}
+if (!defined('IDNA_CHECK_BIDI')) {
+    define('IDNA_CHECK_BIDI', 4);
+}
+if (!defined('IDNA_CHECK_CONTEXTJ')) {
+    define('IDNA_CHECK_CONTEXTJ', 8);
+}
+if (!defined('IDNA_NONTRANSITIONAL_TO_ASCII')) {
+    define('IDNA_NONTRANSITIONAL_TO_ASCII', 16);
+}
+if (!defined('IDNA_NONTRANSITIONAL_TO_UNICODE')) {
+    define('IDNA_NONTRANSITIONAL_TO_UNICODE', 32);
+}
+if (!defined('INTL_IDNA_VARIANT_UTS46')) {
+    define('INTL_IDNA_VARIANT_UTS46', 1);
+}
+if (!defined('IDNA_ERROR_EMPTY_LABEL')) {
+    define('IDNA_ERROR_EMPTY_LABEL', 1);
+}
+if (!defined('IDNA_ERROR_LABEL_TOO_LONG')) {
+    define('IDNA_ERROR_LABEL_TOO_LONG', 2);
+}
+if (!defined('IDNA_ERROR_DOMAIN_NAME_TOO_LONG')) {
+    define('IDNA_ERROR_DOMAIN_NAME_TOO_LONG', 4);
+}
+if (!defined('IDNA_ERROR_LEADING_HYPHEN')) {
+    define('IDNA_ERROR_LEADING_HYPHEN', 8);
+}
+if (!defined('IDNA_ERROR_TRAILING_HYPHEN')) {
+    define('IDNA_ERROR_TRAILING_HYPHEN', 16);
+}
+if (!defined('IDNA_ERROR_HYPHEN_3_4')) {
+    define('IDNA_ERROR_HYPHEN_3_4', 32);
+}
+if (!defined('IDNA_ERROR_LEADING_COMBINING_MARK')) {
+    define('IDNA_ERROR_LEADING_COMBINING_MARK', 64);
+}
+if (!defined('IDNA_ERROR_DISALLOWED')) {
+    define('IDNA_ERROR_DISALLOWED', 128);
+}
+if (!defined('IDNA_ERROR_PUNYCODE')) {
+    define('IDNA_ERROR_PUNYCODE', 256);
+}
+if (!defined('IDNA_ERROR_LABEL_HAS_DOT')) {
+    define('IDNA_ERROR_LABEL_HAS_DOT', 512);
+}
+if (!defined('IDNA_ERROR_INVALID_ACE_LABEL')) {
+    define('IDNA_ERROR_INVALID_ACE_LABEL', 1024);
+}
+if (!defined('IDNA_ERROR_BIDI')) {
+    define('IDNA_ERROR_BIDI', 2048);
+}
+if (!defined('IDNA_ERROR_CONTEXTJ')) {
+    define('IDNA_ERROR_CONTEXTJ', 4096);
+}
+
+if (!function_exists('idn_to_ascii')) {
+    function idn_to_ascii(?string $domain, ?int $flags = IDNA_DEFAULT, ?int $variant = INTL_IDNA_VARIANT_UTS46, &$idna_info = null): string|false { return p\Idn::idn_to_ascii((string) $domain, (int) $flags, (int) $variant, $idna_info); }
+}
+if (!function_exists('idn_to_utf8')) {
+    function idn_to_utf8(?string $domain, ?int $flags = IDNA_DEFAULT, ?int $variant = INTL_IDNA_VARIANT_UTS46, &$idna_info = null): string|false { return p\Idn::idn_to_utf8((string) $domain, (int) $flags, (int) $variant, $idna_info); }
+}

vendor/symfony/polyfill-intl-idn/composer.json

@@ -0,0 +1,40 @@
+{
+    "name": "symfony/polyfill-intl-idn",
+    "type": "library",
+    "description": "Symfony polyfill for intl's idn_to_ascii and idn_to_utf8 functions",
+    "keywords": ["polyfill", "shim", "compatibility", "portable", "intl", "idn"],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Laurent Bassin",
+            "email": "laurent@bassin.info"
+        },
+        {
+            "name": "Trevor Rowbotham",
+            "email": "trevor.rowbotham@pm.me"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=7.2",
+        "symfony/polyfill-intl-normalizer": "^1.10"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Polyfill\\Intl\\Idn\\": "" },
+        "files": [ "bootstrap.php" ]
+    },
+    "suggest": {
+        "ext-intl": "For best performance"
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "thanks": {
+            "name": "symfony/polyfill",
+            "url": "https://github.com/symfony/polyfill"
+        }
+    }
+}

vendor/symfony/polyfill-intl-normalizer/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2015-present Fabien Potencier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/symfony/polyfill-intl-normalizer/Normalizer.php

@@ -0,0 +1,310 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Polyfill\Intl\Normalizer;
+
+/**
+ * Normalizer is a PHP fallback implementation of the Normalizer class provided by the intl extension.
+ *
+ * It has been validated with Unicode 6.3 Normalization Conformance Test.
+ * See http://www.unicode.org/reports/tr15/ for detailed info about Unicode normalizations.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class Normalizer
+{
+    public const FORM_D = \Normalizer::FORM_D;
+    public const FORM_KD = \Normalizer::FORM_KD;
+    public const FORM_C = \Normalizer::FORM_C;
+    public const FORM_KC = \Normalizer::FORM_KC;
+    public const NFD = \Normalizer::NFD;
+    public const NFKD = \Normalizer::NFKD;
+    public const NFC = \Normalizer::NFC;
+    public const NFKC = \Normalizer::NFKC;
+
+    private static $C;
+    private static $D;
+    private static $KD;
+    private static $cC;
+    private static $ulenMask = ["\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4];
+    private static $ASCII = "\x20\x65\x69\x61\x73\x6E\x74\x72\x6F\x6C\x75\x64\x5D\x5B\x63\x6D\x70\x27\x0A\x67\x7C\x68\x76\x2E\x66\x62\x2C\x3A\x3D\x2D\x71\x31\x30\x43\x32\x2A\x79\x78\x29\x28\x4C\x39\x41\x53\x2F\x50\x22\x45\x6A\x4D\x49\x6B\x33\x3E\x35\x54\x3C\x44\x34\x7D\x42\x7B\x38\x46\x77\x52\x36\x37\x55\x47\x4E\x3B\x4A\x7A\x56\x23\x48\x4F\x57\x5F\x26\x21\x4B\x3F\x58\x51\x25\x59\x5C\x09\x5A\x2B\x7E\x5E\x24\x40\x60\x7F\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F";
+
+    public static function isNormalized(string $s, int $form = self::FORM_C)
+    {
+        if (!\in_array($form, [self::NFD, self::NFKD, self::NFC, self::NFKC])) {
+            return false;
+        }
+        if (!isset($s[strspn($s, self::$ASCII)])) {
+            return true;
+        }
+        if (self::NFC == $form && preg_match('//u', $s) && !preg_match('/[^\x00-\x{2FF}]/u', $s)) {
+            return true;
+        }
+
+        return self::normalize($s, $form) === $s;
+    }
+
+    public static function normalize(string $s, int $form = self::FORM_C)
+    {
+        if (!preg_match('//u', $s)) {
+            return false;
+        }
+
+        switch ($form) {
+            case self::NFC: $C = true; $K = false; break;
+            case self::NFD: $C = false; $K = false; break;
+            case self::NFKC: $C = true; $K = true; break;
+            case self::NFKD: $C = false; $K = true; break;
+            default:
+                if (\defined('Normalizer::NONE') && \Normalizer::NONE == $form) {
+                    return $s;
+                }
+
+                if (80000 > \PHP_VERSION_ID) {
+                    return false;
+                }
+
+                throw new \ValueError('normalizer_normalize(): Argument #2 ($form) must be a a valid normalization form');
+        }
+
+        if ('' === $s) {
+            return '';
+        }
+
+        if ($K && null === self::$KD) {
+            self::$KD = self::getData('compatibilityDecomposition');
+        }
+
+        if (null === self::$D) {
+            self::$D = self::getData('canonicalDecomposition');
+            self::$cC = self::getData('combiningClass');
+        }
+
+        if (null !== $mbEncoding = (2 /* MB_OVERLOAD_STRING */ & (int) \ini_get('mbstring.func_overload')) ? mb_internal_encoding() : null) {
+            mb_internal_encoding('8bit');
+        }
+
+        $r = self::decompose($s, $K);
+
+        if ($C) {
+            if (null === self::$C) {
+                self::$C = self::getData('canonicalComposition');
+            }
+
+            $r = self::recompose($r);
+        }
+        if (null !== $mbEncoding) {
+            mb_internal_encoding($mbEncoding);
+        }
+
+        return $r;
+    }
+
+    private static function recompose($s)
+    {
+        $ASCII = self::$ASCII;
+        $compMap = self::$C;
+        $combClass = self::$cC;
+        $ulenMask = self::$ulenMask;
+
+        $result = $tail = '';
+
+        $i = $s[0] < "\x80" ? 1 : $ulenMask[$s[0] & "\xF0"];
+        $len = \strlen($s);
+
+        $lastUchr = substr($s, 0, $i);
+        $lastUcls = isset($combClass[$lastUchr]) ? 256 : 0;
+
+        while ($i < $len) {
+            if ($s[$i] < "\x80") {
+                // ASCII chars
+
+                if ($tail) {
+                    $lastUchr .= $tail;
+                    $tail = '';
+                }
+
+                if ($j = strspn($s, $ASCII, $i + 1)) {
+                    $lastUchr .= substr($s, $i, $j);
+                    $i += $j;
+                }
+
+                $result .= $lastUchr;
+                $lastUchr = $s[$i];
+                $lastUcls = 0;
+                ++$i;
+                continue;
+            }
+
+            $ulen = $ulenMask[$s[$i] & "\xF0"];
+            $uchr = substr($s, $i, $ulen);
+
+            if ($lastUchr < "\xE1\x84\x80" || "\xE1\x84\x92" < $lastUchr
+                || $uchr < "\xE1\x85\xA1" || "\xE1\x85\xB5" < $uchr
+                || $lastUcls) {
+                // Table lookup and combining chars composition
+
+                $ucls = $combClass[$uchr] ?? 0;
+
+                if (isset($compMap[$lastUchr.$uchr]) && (!$lastUcls || $lastUcls < $ucls)) {
+                    $lastUchr = $compMap[$lastUchr.$uchr];
+                } elseif ($lastUcls = $ucls) {
+                    $tail .= $uchr;
+                } else {
+                    if ($tail) {
+                        $lastUchr .= $tail;
+                        $tail = '';
+                    }
+
+                    $result .= $lastUchr;
+                    $lastUchr = $uchr;
+                }
+            } else {
+                // Hangul chars
+
+                $L = \ord($lastUchr[2]) - 0x80;
+                $V = \ord($uchr[2]) - 0xA1;
+                $T = 0;
+
+                $uchr = substr($s, $i + $ulen, 3);
+
+                if ("\xE1\x86\xA7" <= $uchr && $uchr <= "\xE1\x87\x82") {
+                    $T = \ord($uchr[2]) - 0xA7;
+                    0 > $T && $T += 0x40;
+                    $ulen += 3;
+                }
+
+                $L = 0xAC00 + ($L * 21 + $V) * 28 + $T;
+                $lastUchr = \chr(0xE0 | $L >> 12).\chr(0x80 | $L >> 6 & 0x3F).\chr(0x80 | $L & 0x3F);
+            }
+
+            $i += $ulen;
+        }
+
+        return $result.$lastUchr.$tail;
+    }
+
+    private static function decompose($s, $c)
+    {
+        $result = '';
+
+        $ASCII = self::$ASCII;
+        $decompMap = self::$D;
+        $combClass = self::$cC;
+        $ulenMask = self::$ulenMask;
+        if ($c) {
+            $compatMap = self::$KD;
+        }
+
+        $c = [];
+        $i = 0;
+        $len = \strlen($s);
+
+        while ($i < $len) {
+            if ($s[$i] < "\x80") {
+                // ASCII chars
+
+                if ($c) {
+                    ksort($c);
+                    $result .= implode('', $c);
+                    $c = [];
+                }
+
+                $j = 1 + strspn($s, $ASCII, $i + 1);
+                $result .= substr($s, $i, $j);
+                $i += $j;
+                continue;
+            }
+
+            $ulen = $ulenMask[$s[$i] & "\xF0"];
+            $uchr = substr($s, $i, $ulen);
+            $i += $ulen;
+
+            if ($uchr < "\xEA\xB0\x80" || "\xED\x9E\xA3" < $uchr) {
+                // Table lookup
+
+                if ($uchr !== $j = $compatMap[$uchr] ?? ($decompMap[$uchr] ?? $uchr)) {
+                    $uchr = $j;
+
+                    $j = \strlen($uchr);
+                    $ulen = $uchr[0] < "\x80" ? 1 : $ulenMask[$uchr[0] & "\xF0"];
+
+                    if ($ulen != $j) {
+                        // Put trailing chars in $s
+
+                        $j -= $ulen;
+                        $i -= $j;
+
+                        if (0 > $i) {
+                            $s = str_repeat(' ', -$i).$s;
+                            $len -= $i;
+                            $i = 0;
+                        }
+
+                        while ($j--) {
+                            $s[$i + $j] = $uchr[$ulen + $j];
+                        }
+
+                        $uchr = substr($uchr, 0, $ulen);
+                    }
+                }
+                if (isset($combClass[$uchr])) {
+                    // Combining chars, for sorting
+
+                    if (!isset($c[$combClass[$uchr]])) {
+                        $c[$combClass[$uchr]] = '';
+                    }
+                    $c[$combClass[$uchr]] .= $uchr;
+                    continue;
+                }
+            } else {
+                // Hangul chars
+
+                $uchr = unpack('C*', $uchr);
+                $j = (($uchr[1] - 224) << 12) + (($uchr[2] - 128) << 6) + $uchr[3] - 0xAC80;
+
+                $uchr = "\xE1\x84".\chr(0x80 + (int) ($j / 588))
+                       ."\xE1\x85".\chr(0xA1 + (int) (($j % 588) / 28));
+
+                if ($j %= 28) {
+                    $uchr .= $j < 25
+                        ? ("\xE1\x86".\chr(0xA7 + $j))
+                        : ("\xE1\x87".\chr(0x67 + $j));
+                }
+            }
+            if ($c) {
+                ksort($c);
+                $result .= implode('', $c);
+                $c = [];
+            }
+
+            $result .= $uchr;
+        }
+
+        if ($c) {
+            ksort($c);
+            $result .= implode('', $c);
+        }
+
+        return $result;
+    }
+
+    private static function getData($file)
+    {
+        if (file_exists($file = __DIR__.'/Resources/unidata/'.$file.'.php')) {
+            return require $file;
+        }
+
+        return false;
+    }
+}

vendor/symfony/polyfill-intl-normalizer/README.md

@@ -0,0 +1,14 @@
+Symfony Polyfill / Intl: Normalizer
+===================================
+
+This component provides a fallback implementation for the
+[`Normalizer`](https://php.net/Normalizer) class provided
+by the [Intl](https://php.net/intl) extension.
+
+More information can be found in the
+[main Polyfill README](https://github.com/symfony/polyfill/blob/main/README.md).
+
+License
+=======
+
+This library is released under the [MIT license](LICENSE).

vendor/symfony/polyfill-intl-normalizer/Resources/stubs/Normalizer.php

@@ -0,0 +1,17 @@
+<?php
+
+class Normalizer extends Symfony\Polyfill\Intl\Normalizer\Normalizer
+{
+    /**
+     * @deprecated since ICU 56 and removed in PHP 8
+     */
+    public const NONE = 2;
+    public const FORM_D = 4;
+    public const FORM_KD = 8;
+    public const FORM_C = 16;
+    public const FORM_KC = 32;
+    public const NFD = 4;
+    public const NFKD = 8;
+    public const NFC = 16;
+    public const NFKC = 32;
+}

vendor/symfony/polyfill-intl-normalizer/Resources/unidata/canonicalComposition.php

@@ -0,0 +1,945 @@
+<?php
+
+return array (
+  'À' => 'À',
+  'Á' => 'Á',
+  'Â' => 'Â',
+  'Ã' => 'Ã',
+  'Ä' => 'Ä',
+  'Å' => 'Å',
+  'Ç' => 'Ç',
+  'È' => 'È',
+  'É' => 'É',
+  'Ê' => 'Ê',
+  'Ë' => 'Ë',
+  'Ì' => 'Ì',
+  'Í' => 'Í',
+  'Î' => 'Î',
+  'Ï' => 'Ï',
+  'Ñ' => 'Ñ',
+  'Ò' => 'Ò',
+  'Ó' => 'Ó',
+  'Ô' => 'Ô',
+  'Õ' => 'Õ',
+  'Ö' => 'Ö',
+  'Ù' => 'Ù',
+  'Ú' => 'Ú',
+  'Û' => 'Û',
+  'Ü' => 'Ü',
+  'Ý' => 'Ý',
+  'à' => 'à',
+  'á' => 'á',
+  'â' => 'â',
+  'ã' => 'ã',
+  'ä' => 'ä',
+  'å' => 'å',
+  'ç' => 'ç',
+  'è' => 'è',
+  'é' => 'é',
+  'ê' => 'ê',
+  'ë' => 'ë',
+  'ì' => 'ì',
+  'í' => 'í',
+  'î' => 'î',
+  'ï' => 'ï',
+  'ñ' => 'ñ',
+  'ò' => 'ò',
+  'ó' => 'ó',
+  'ô' => 'ô',
+  'õ' => 'õ',
+  'ö' => 'ö',
+  'ù' => 'ù',
+  'ú' => 'ú',
+  'û' => 'û',
+  'ü' => 'ü',
+  'ý' => 'ý',
+  'ÿ' => 'ÿ',
+  'Ā' => 'Ā',
+  'ā' => 'ā',
+  'Ă' => 'Ă',
+  'ă' => 'ă',
+  'Ą' => 'Ą',
+  'ą' => 'ą',
+  'Ć' => 'Ć',
+  'ć' => 'ć',
+  'Ĉ' => 'Ĉ',
+  'ĉ' => 'ĉ',
+  'Ċ' => 'Ċ',
+  'ċ' => 'ċ',
+  'Č' => 'Č',
+  'č' => 'č',
+  'Ď' => 'Ď',
+  'ď' => 'ď',
+  'Ē' => 'Ē',
+  'ē' => 'ē',
+  'Ĕ' => 'Ĕ',
+  'ĕ' => 'ĕ',
+  'Ė' => 'Ė',
+  'ė' => 'ė',
+  'Ę' => 'Ę',
+  'ę' => 'ę',
+  'Ě' => 'Ě',
+  'ě' => 'ě',
+  'Ĝ' => 'Ĝ',
+  'ĝ' => 'ĝ',
+  'Ğ' => 'Ğ',
+  'ğ' => 'ğ',
+  'Ġ' => 'Ġ',
+  'ġ' => 'ġ',
+  'Ģ' => 'Ģ',
+  'ģ' => 'ģ',
+  'Ĥ' => 'Ĥ',
+  'ĥ' => 'ĥ',
+  'Ĩ' => 'Ĩ',
+  'ĩ' => 'ĩ',
+  'Ī' => 'Ī',
+  'ī' => 'ī',
+  'Ĭ' => 'Ĭ',
+  'ĭ' => 'ĭ',
+  'Į' => 'Į',
+  'į' => 'į',
+  'İ' => 'İ',
+  'Ĵ' => 'Ĵ',
+  'ĵ' => 'ĵ',
+  'Ķ' => 'Ķ',
+  'ķ' => 'ķ',
+  'Ĺ' => 'Ĺ',
+  'ĺ' => 'ĺ',
+  'Ļ' => 'Ļ',
+  'ļ' => 'ļ',
+  'Ľ' => 'Ľ',
+  'ľ' => 'ľ',
+  'Ń' => 'Ń',
+  'ń' => 'ń',
+  'Ņ' => 'Ņ',
+  'ņ' => 'ņ',
+  'Ň' => 'Ň',
+  'ň' => 'ň',
+  'Ō' => 'Ō',
+  'ō' => 'ō',
+  'Ŏ' => 'Ŏ',
+  'ŏ' => 'ŏ',
+  'Ő' => 'Ő',
+  'ő' => 'ő',
+  'Ŕ' => 'Ŕ',
+  'ŕ' => 'ŕ',
+  'Ŗ' => 'Ŗ',
+  'ŗ' => 'ŗ',
+  'Ř' => 'Ř',
+  'ř' => 'ř',
+  'Ś' => 'Ś',
+  'ś' => 'ś',
+  'Ŝ' => 'Ŝ',
+  'ŝ' => 'ŝ',
+  'Ş' => 'Ş',
+  'ş' => 'ş',
+  'Š' => 'Š',
+  'š' => 'š',
+  'Ţ' => 'Ţ',
+  'ţ' => 'ţ',
+  'Ť' => 'Ť',
+  'ť' => 'ť',
+  'Ũ' => 'Ũ',
+  'ũ' => 'ũ',
+  'Ū' => 'Ū',
+  'ū' => 'ū',
+  'Ŭ' => 'Ŭ',
+  'ŭ' => 'ŭ',
+  'Ů' => 'Ů',
+  'ů' => 'ů',
+  'Ű' => 'Ű',
+  'ű' => 'ű',
+  'Ų' => 'Ų',
+  'ų' => 'ų',
+  'Ŵ' => 'Ŵ',
+  'ŵ' => 'ŵ',
+  'Ŷ' => 'Ŷ',
+  'ŷ' => 'ŷ',
+  'Ÿ' => 'Ÿ',
+  'Ź' => 'Ź',
+  'ź' => 'ź',
+  'Ż' => 'Ż',
+  'ż' => 'ż',
+  'Ž' => 'Ž',
+  'ž' => 'ž',
+  'Ơ' => 'Ơ',
+  'ơ' => 'ơ',
+  'Ư' => 'Ư',
+  'ư' => 'ư',
+  'Ǎ' => 'Ǎ',
+  'ǎ' => 'ǎ',
+  'Ǐ' => 'Ǐ',
+  'ǐ' => 'ǐ',
+  'Ǒ' => 'Ǒ',
+  'ǒ' => 'ǒ',
+  'Ǔ' => 'Ǔ',
+  'ǔ' => 'ǔ',
+  'Ǖ' => 'Ǖ',
+  'ǖ' => 'ǖ',
+  'Ǘ' => 'Ǘ',
+  'ǘ' => 'ǘ',
+  'Ǚ' => 'Ǚ',
+  'ǚ' => 'ǚ',
+  'Ǜ' => 'Ǜ',
+  'ǜ' => 'ǜ',
+  'Ǟ' => 'Ǟ',
+  'ǟ' => 'ǟ',
+  'Ǡ' => 'Ǡ',
+  'ǡ' => 'ǡ',
+  'Ǣ' => 'Ǣ',
+  'ǣ' => 'ǣ',
+  'Ǧ' => 'Ǧ',
+  'ǧ' => 'ǧ',
+  'Ǩ' => 'Ǩ',
+  'ǩ' => 'ǩ',
+  'Ǫ' => 'Ǫ',
+  'ǫ' => 'ǫ',
+  'Ǭ' => 'Ǭ',
+  'ǭ' => 'ǭ',
+  'Ǯ' => 'Ǯ',
+  'ǯ' => 'ǯ',
+  'ǰ' => 'ǰ',
+  'Ǵ' => 'Ǵ',
+  'ǵ' => 'ǵ',
+  'Ǹ' => 'Ǹ',
+  'ǹ' => 'ǹ',
+  'Ǻ' => 'Ǻ',
+  'ǻ' => 'ǻ',
+  'Ǽ' => 'Ǽ',
+  'ǽ' => 'ǽ',
+  'Ǿ' => 'Ǿ',
+  'ǿ' => 'ǿ',
+  'Ȁ' => 'Ȁ',
+  'ȁ' => 'ȁ',
+  'Ȃ' => 'Ȃ',
+  'ȃ' => 'ȃ',
+  'Ȅ' => 'Ȅ',
+  'ȅ' => 'ȅ',
+  'Ȇ' => 'Ȇ',
+  'ȇ' => 'ȇ',
+  'Ȉ' => 'Ȉ',
+  'ȉ' => 'ȉ',
+  'Ȋ' => 'Ȋ',
+  'ȋ' => 'ȋ',
+  'Ȍ' => 'Ȍ',
+  'ȍ' => 'ȍ',
+  'Ȏ' => 'Ȏ',
+  'ȏ' => 'ȏ',
+  'Ȑ' => 'Ȑ',
+  'ȑ' => 'ȑ',
+  'Ȓ' => 'Ȓ',
+  'ȓ' => 'ȓ',
+  'Ȕ' => 'Ȕ',
+  'ȕ' => 'ȕ',
+  'Ȗ' => 'Ȗ',
+  'ȗ' => 'ȗ',
+  'Ș' => 'Ș',
+  'ș' => 'ș',
+  'Ț' => 'Ț',
+  'ț' => 'ț',
+  'Ȟ' => 'Ȟ',
+  'ȟ' => 'ȟ',
+  'Ȧ' => 'Ȧ',
+  'ȧ' => 'ȧ',
+  'Ȩ' => 'Ȩ',
+  'ȩ' => 'ȩ',
+  'Ȫ' => 'Ȫ',
+  'ȫ' => 'ȫ',
+  'Ȭ' => 'Ȭ',
+  'ȭ' => 'ȭ',
+  'Ȯ' => 'Ȯ',
+  'ȯ' => 'ȯ',
+  'Ȱ' => 'Ȱ',
+  'ȱ' => 'ȱ',
+  'Ȳ' => 'Ȳ',
+  'ȳ' => 'ȳ',
+  '΅' => '΅',
+  'Ά' => 'Ά',
+  'Έ' => 'Έ',
+  'Ή' => 'Ή',
+  'Ί' => 'Ί',
+  'Ό' => 'Ό',
+  'Ύ' => 'Ύ',
+  'Ώ' => 'Ώ',
+  'ΐ' => 'ΐ',
+  'Ϊ' => 'Ϊ',
+  'Ϋ' => 'Ϋ',
+  'ά' => 'ά',
+  'έ' => 'έ',
+  'ή' => 'ή',
+  'ί' => 'ί',
+  'ΰ' => 'ΰ',
+  'ϊ' => 'ϊ',
+  'ϋ' => 'ϋ',
+  'ό' => 'ό',
+  'ύ' => 'ύ',
+  'ώ' => 'ώ',
+  'ϓ' => 'ϓ',
+  'ϔ' => 'ϔ',
+  'Ѐ' => 'Ѐ',
+  'Ё' => 'Ё',
+  'Ѓ' => 'Ѓ',
+  'Ї' => 'Ї',
+  'Ќ' => 'Ќ',
+  'Ѝ' => 'Ѝ',
+  'Ў' => 'Ў',
+  'Й' => 'Й',
+  'й' => 'й',
+  'ѐ' => 'ѐ',
+  'ё' => 'ё',
+  'ѓ' => 'ѓ',
+  'ї' => 'ї',
+  'ќ' => 'ќ',
+  'ѝ' => 'ѝ',
+  'ў' => 'ў',
+  'Ѷ' => 'Ѷ',
+  'ѷ' => 'ѷ',
+  'Ӂ' => 'Ӂ',
+  'ӂ' => 'ӂ',
+  'Ӑ' => 'Ӑ',
+  'ӑ' => 'ӑ',
+  'Ӓ' => 'Ӓ',
+  'ӓ' => 'ӓ',
+  'Ӗ' => 'Ӗ',
+  'ӗ' => 'ӗ',
+  'Ӛ' => 'Ӛ',
+  'ӛ' => 'ӛ',
+  'Ӝ' => 'Ӝ',
+  'ӝ' => 'ӝ',
+  'Ӟ' => 'Ӟ',
+  'ӟ' => 'ӟ',
+  'Ӣ' => 'Ӣ',
+  'ӣ' => 'ӣ',
+  'Ӥ' => 'Ӥ',
+  'ӥ' => 'ӥ',
+  'Ӧ' => 'Ӧ',
+  'ӧ' => 'ӧ',
+  'Ӫ' => 'Ӫ',
+  'ӫ' => 'ӫ',
+  'Ӭ' => 'Ӭ',
+  'ӭ' => 'ӭ',
+  'Ӯ' => 'Ӯ',
+  'ӯ' => 'ӯ',
+  'Ӱ' => 'Ӱ',
+  'ӱ' => 'ӱ',
+  'Ӳ' => 'Ӳ',
+  'ӳ' => 'ӳ',
+  'Ӵ' => 'Ӵ',
+  'ӵ' => 'ӵ',
+  'Ӹ' => 'Ӹ',
+  'ӹ' => 'ӹ',
+  'آ' => 'آ',
+  'أ' => 'أ',
+  'ؤ' => 'ؤ',
+  'إ' => 'إ',
+  'ئ' => 'ئ',
+  'ۀ' => 'ۀ',
+  'ۂ' => 'ۂ',
+  'ۓ' => 'ۓ',
+  'ऩ' => 'ऩ',
+  'ऱ' => 'ऱ',
+  'ऴ' => 'ऴ',
+  'ো' => 'ো',
+  'ৌ' => 'ৌ',
+  'ୈ' => 'ୈ',
+  'ୋ' => 'ୋ',
+  'ୌ' => 'ୌ',
+  'ஔ' => 'ஔ',
+  'ொ' => 'ொ',
+  'ோ' => 'ோ',
+  'ௌ' => 'ௌ',
+  'ై' => 'ై',
+  'ೀ' => 'ೀ',
+  'ೇ' => 'ೇ',
+  'ೈ' => 'ೈ',
+  'ೊ' => 'ೊ',
+  'ೋ' => 'ೋ',
+  'ൊ' => 'ൊ',
+  'ോ' => 'ോ',
+  'ൌ' => 'ൌ',
+  'ේ' => 'ේ',
+  'ො' => 'ො',
+  'ෝ' => 'ෝ',
+  'ෞ' => 'ෞ',
+  'ဦ' => 'ဦ',
+  'ᬆ' => 'ᬆ',
+  'ᬈ' => 'ᬈ',
+  'ᬊ' => 'ᬊ',
+  'ᬌ' => 'ᬌ',
+  'ᬎ' => 'ᬎ',
+  'ᬒ' => 'ᬒ',
+  'ᬻ' => 'ᬻ',
+  'ᬽ' => 'ᬽ',
+  'ᭀ' => 'ᭀ',
+  'ᭁ' => 'ᭁ',
+  'ᭃ' => 'ᭃ',
+  'Ḁ' => 'Ḁ',
+  'ḁ' => 'ḁ',
+  'Ḃ' => 'Ḃ',
+  'ḃ' => 'ḃ',
+  'Ḅ' => 'Ḅ',
+  'ḅ' => 'ḅ',
+  'Ḇ' => 'Ḇ',
+  'ḇ' => 'ḇ',
+  'Ḉ' => 'Ḉ',
+  'ḉ' => 'ḉ',
+  'Ḋ' => 'Ḋ',
+  'ḋ' => 'ḋ',
+  'Ḍ' => 'Ḍ',
+  'ḍ' => 'ḍ',
+  'Ḏ' => 'Ḏ',
+  'ḏ' => 'ḏ',
+  'Ḑ' => 'Ḑ',
+  'ḑ' => 'ḑ',
+  'Ḓ' => 'Ḓ',
+  'ḓ' => 'ḓ',
+  'Ḕ' => 'Ḕ',
+  'ḕ' => 'ḕ',
+  'Ḗ' => 'Ḗ',
+  'ḗ' => 'ḗ',
+  'Ḙ' => 'Ḙ',
+  'ḙ' => 'ḙ',
+  'Ḛ' => 'Ḛ',
+  'ḛ' => 'ḛ',
+  'Ḝ' => 'Ḝ',
+  'ḝ' => 'ḝ',
+  'Ḟ' => 'Ḟ',
+  'ḟ' => 'ḟ',
+  'Ḡ' => 'Ḡ',
+  'ḡ' => 'ḡ',
+  'Ḣ' => 'Ḣ',
+  'ḣ' => 'ḣ',
+  'Ḥ' => 'Ḥ',
+  'ḥ' => 'ḥ',
+  'Ḧ' => 'Ḧ',
+  'ḧ' => 'ḧ',
+  'Ḩ' => 'Ḩ',
+  'ḩ' => 'ḩ',
+  'Ḫ' => 'Ḫ',
+  'ḫ' => 'ḫ',
+  'Ḭ' => 'Ḭ',
+  'ḭ' => 'ḭ',
+  'Ḯ' => 'Ḯ',
+  'ḯ' => 'ḯ',
+  'Ḱ' => 'Ḱ',
+  'ḱ' => 'ḱ',
+  'Ḳ' => 'Ḳ',
+  'ḳ' => 'ḳ',
+  'Ḵ' => 'Ḵ',
+  'ḵ' => 'ḵ',
+  'Ḷ' => 'Ḷ',
+  'ḷ' => 'ḷ',
+  'Ḹ' => 'Ḹ',
+  'ḹ' => 'ḹ',
+  'Ḻ' => 'Ḻ',
+  'ḻ' => 'ḻ',
+  'Ḽ' => 'Ḽ',
+  'ḽ' => 'ḽ',
+  'Ḿ' => 'Ḿ',
+  'ḿ' => 'ḿ',
+  'Ṁ' => 'Ṁ',
+  'ṁ' => 'ṁ',
+  'Ṃ' => 'Ṃ',
+  'ṃ' => 'ṃ',
+  'Ṅ' => 'Ṅ',
+  'ṅ' => 'ṅ',
+  'Ṇ' => 'Ṇ',
+  'ṇ' => 'ṇ',
+  'Ṉ' => 'Ṉ',
+  'ṉ' => 'ṉ',
+  'Ṋ' => 'Ṋ',
+  'ṋ' => 'ṋ',
+  'Ṍ' => 'Ṍ',
+  'ṍ' => 'ṍ',
+  'Ṏ' => 'Ṏ',
+  'ṏ' => 'ṏ',
+  'Ṑ' => 'Ṑ',
+  'ṑ' => 'ṑ',
+  'Ṓ' => 'Ṓ',
+  'ṓ' => 'ṓ',
+  'Ṕ' => 'Ṕ',
+  'ṕ' => 'ṕ',
+  'Ṗ' => 'Ṗ',
+  'ṗ' => 'ṗ',
+  'Ṙ' => 'Ṙ',
+  'ṙ' => 'ṙ',
+  'Ṛ' => 'Ṛ',
+  'ṛ' => 'ṛ',
+  'Ṝ' => 'Ṝ',
+  'ṝ' => 'ṝ',
+  'Ṟ' => 'Ṟ',
+  'ṟ' => 'ṟ',
+  'Ṡ' => 'Ṡ',
+  'ṡ' => 'ṡ',
+  'Ṣ' => 'Ṣ',
+  'ṣ' => 'ṣ',
+  'Ṥ' => 'Ṥ',
+  'ṥ' => 'ṥ',
+  'Ṧ' => 'Ṧ',
+  'ṧ' => 'ṧ',
+  'Ṩ' => 'Ṩ',
+  'ṩ' => 'ṩ',
+  'Ṫ' => 'Ṫ',
+  'ṫ' => 'ṫ',
+  'Ṭ' => 'Ṭ',
+  'ṭ' => 'ṭ',
+  'Ṯ' => 'Ṯ',
+  'ṯ' => 'ṯ',
+  'Ṱ' => 'Ṱ',
+  'ṱ' => 'ṱ',
+  'Ṳ' => 'Ṳ',
+  'ṳ' => 'ṳ',
+  'Ṵ' => 'Ṵ',
+  'ṵ' => 'ṵ',
+  'Ṷ' => 'Ṷ',
+  'ṷ' => 'ṷ',
+  'Ṹ' => 'Ṹ',
+  'ṹ' => 'ṹ',
+  'Ṻ' => 'Ṻ',
+  'ṻ' => 'ṻ',
+  'Ṽ' => 'Ṽ',
+  'ṽ' => 'ṽ',
+  'Ṿ' => 'Ṿ',
+  'ṿ' => 'ṿ',
+  'Ẁ' => 'Ẁ',
+  'ẁ' => 'ẁ',
+  'Ẃ' => 'Ẃ',
+  'ẃ' => 'ẃ',
+  'Ẅ' => 'Ẅ',
+  'ẅ' => 'ẅ',
+  'Ẇ' => 'Ẇ',
+  'ẇ' => 'ẇ',
+  'Ẉ' => 'Ẉ',
+  'ẉ' => 'ẉ',
+  'Ẋ' => 'Ẋ',
+  'ẋ' => 'ẋ',
+  'Ẍ' => 'Ẍ',
+  'ẍ' => 'ẍ',
+  'Ẏ' => 'Ẏ',
+  'ẏ' => 'ẏ',
+  'Ẑ' => 'Ẑ',
+  'ẑ' => 'ẑ',
+  'Ẓ' => 'Ẓ',
+  'ẓ' => 'ẓ',
+  'Ẕ' => 'Ẕ',
+  'ẕ' => 'ẕ',
+  'ẖ' => 'ẖ',
+  'ẗ' => 'ẗ',
+  'ẘ' => 'ẘ',
+  'ẙ' => 'ẙ',
+  'ẛ' => 'ẛ',
+  'Ạ' => 'Ạ',
+  'ạ' => 'ạ',
+  'Ả' => 'Ả',
+  'ả' => 'ả',
+  'Ấ' => 'Ấ',
+  'ấ' => 'ấ',
+  'Ầ' => 'Ầ',
+  'ầ' => 'ầ',
+  'Ẩ' => 'Ẩ',
+  'ẩ' => 'ẩ',
+  'Ẫ' => 'Ẫ',
+  'ẫ' => 'ẫ',
+  'Ậ' => 'Ậ',
+  'ậ' => 'ậ',
+  'Ắ' => 'Ắ',
+  'ắ' => 'ắ',
+  'Ằ' => 'Ằ',
+  'ằ' => 'ằ',
+  'Ẳ' => 'Ẳ',
+  'ẳ' => 'ẳ',
+  'Ẵ' => 'Ẵ',
+  'ẵ' => 'ẵ',
+  'Ặ' => 'Ặ',
+  'ặ' => 'ặ',
+  'Ẹ' => 'Ẹ',
+  'ẹ' => 'ẹ',
+  'Ẻ' => 'Ẻ',
+  'ẻ' => 'ẻ',
+  'Ẽ' => 'Ẽ',
+  'ẽ' => 'ẽ',
+  'Ế' => 'Ế',
+  'ế' => 'ế',
+  'Ề' => 'Ề',
+  'ề' => 'ề',
+  'Ể' => 'Ể',
+  'ể' => 'ể',
+  'Ễ' => 'Ễ',
+  'ễ' => 'ễ',
+  'Ệ' => 'Ệ',
+  'ệ' => 'ệ',
+  'Ỉ' => 'Ỉ',
+  'ỉ' => 'ỉ',
+  'Ị' => 'Ị',
+  'ị' => 'ị',
+  'Ọ' => 'Ọ',
+  'ọ' => 'ọ',
+  'Ỏ' => 'Ỏ',
+  'ỏ' => 'ỏ',
+  'Ố' => 'Ố',
+  'ố' => 'ố',
+  'Ồ' => 'Ồ',
+  'ồ' => 'ồ',
+  'Ổ' => 'Ổ',
+  'ổ' => 'ổ',
+  'Ỗ' => 'Ỗ',
+  'ỗ' => 'ỗ',
+  'Ộ' => 'Ộ',
+  'ộ' => 'ộ',
+  'Ớ' => 'Ớ',
+  'ớ' => 'ớ',
+  'Ờ' => 'Ờ',
+  'ờ' => 'ờ',
+  'Ở' => 'Ở',
+  'ở' => 'ở',
+  'Ỡ' => 'Ỡ',
+  'ỡ' => 'ỡ',
+  'Ợ' => 'Ợ',
+  'ợ' => 'ợ',
+  'Ụ' => 'Ụ',
+  'ụ' => 'ụ',
+  'Ủ' => 'Ủ',
+  'ủ' => 'ủ',
+  'Ứ' => 'Ứ',
+  'ứ' => 'ứ',
+  'Ừ' => 'Ừ',
+  'ừ' => 'ừ',
+  'Ử' => 'Ử',
+  'ử' => 'ử',
+  'Ữ' => 'Ữ',
+  'ữ' => 'ữ',
+  'Ự' => 'Ự',
+  'ự' => 'ự',
+  'Ỳ' => 'Ỳ',
+  'ỳ' => 'ỳ',
+  'Ỵ' => 'Ỵ',
+  'ỵ' => 'ỵ',
+  'Ỷ' => 'Ỷ',
+  'ỷ' => 'ỷ',
+  'Ỹ' => 'Ỹ',
+  'ỹ' => 'ỹ',
+  'ἀ' => 'ἀ',
+  'ἁ' => 'ἁ',
+  'ἂ' => 'ἂ',
+  'ἃ' => 'ἃ',
+  'ἄ' => 'ἄ',
+  'ἅ' => 'ἅ',
+  'ἆ' => 'ἆ',
+  'ἇ' => 'ἇ',
+  'Ἀ' => 'Ἀ',
+  'Ἁ' => 'Ἁ',
+  'Ἂ' => 'Ἂ',
+  'Ἃ' => 'Ἃ',
+  'Ἄ' => 'Ἄ',
+  'Ἅ' => 'Ἅ',
+  'Ἆ' => 'Ἆ',
+  'Ἇ' => 'Ἇ',
+  'ἐ' => 'ἐ',
+  'ἑ' => 'ἑ',
+  'ἒ' => 'ἒ',
+  'ἓ' => 'ἓ',
+  'ἔ' => 'ἔ',
+  'ἕ' => 'ἕ',
+  'Ἐ' => 'Ἐ',
+  'Ἑ' => 'Ἑ',
+  'Ἒ' => 'Ἒ',
+  'Ἓ' => 'Ἓ',
+  'Ἔ' => 'Ἔ',
+  'Ἕ' => 'Ἕ',
+  'ἠ' => 'ἠ',
+  'ἡ' => 'ἡ',
+  'ἢ' => 'ἢ',
+  'ἣ' => 'ἣ',
+  'ἤ' => 'ἤ',
+  'ἥ' => 'ἥ',
+  'ἦ' => 'ἦ',
+  'ἧ' => 'ἧ',
+  'Ἠ' => 'Ἠ',
+  'Ἡ' => 'Ἡ',
+  'Ἢ' => 'Ἢ',
+  'Ἣ' => 'Ἣ',
+  'Ἤ' => 'Ἤ',
+  'Ἥ' => 'Ἥ',
+  'Ἦ' => 'Ἦ',
+  'Ἧ' => 'Ἧ',
+  'ἰ' => 'ἰ',
+  'ἱ' => 'ἱ',
+  'ἲ' => 'ἲ',
+  'ἳ' => 'ἳ',
+  'ἴ' => 'ἴ',
+  'ἵ' => 'ἵ',
+  'ἶ' => 'ἶ',
+  'ἷ' => 'ἷ',
+  'Ἰ' => 'Ἰ',
+  'Ἱ' => 'Ἱ',
+  'Ἲ' => 'Ἲ',
+  'Ἳ' => 'Ἳ',
+  'Ἴ' => 'Ἴ',
+  'Ἵ' => 'Ἵ',
+  'Ἶ' => 'Ἶ',
+  'Ἷ' => 'Ἷ',
+  'ὀ' => 'ὀ',
+  'ὁ' => 'ὁ',
+  'ὂ' => 'ὂ',
+  'ὃ' => 'ὃ',
+  'ὄ' => 'ὄ',
+  'ὅ' => 'ὅ',
+  'Ὀ' => 'Ὀ',
+  'Ὁ' => 'Ὁ',
+  'Ὂ' => 'Ὂ',
+  'Ὃ' => 'Ὃ',
+  'Ὄ' => 'Ὄ',
+  'Ὅ' => 'Ὅ',
+  'ὐ' => 'ὐ',
+  'ὑ' => 'ὑ',
+  'ὒ' => 'ὒ',
+  'ὓ' => 'ὓ',
+  'ὔ' => 'ὔ',
+  'ὕ' => 'ὕ',
+  'ὖ' => 'ὖ',
+  'ὗ' => 'ὗ',
+  'Ὑ' => 'Ὑ',
+  'Ὓ' => 'Ὓ',
+  'Ὕ' => 'Ὕ',
+  'Ὗ' => 'Ὗ',
+  'ὠ' => 'ὠ',
+  'ὡ' => 'ὡ',
+  'ὢ' => 'ὢ',
+  'ὣ' => 'ὣ',
+  'ὤ' => 'ὤ',
+  'ὥ' => 'ὥ',
+  'ὦ' => 'ὦ',
+  'ὧ' => 'ὧ',
+  'Ὠ' => 'Ὠ',
+  'Ὡ' => 'Ὡ',
+  'Ὢ' => 'Ὢ',
+  'Ὣ' => 'Ὣ',
+  'Ὤ' => 'Ὤ',
+  'Ὥ' => 'Ὥ',
+  'Ὦ' => 'Ὦ',
+  'Ὧ' => 'Ὧ',
+  'ὰ' => 'ὰ',
+  'ὲ' => 'ὲ',
+  'ὴ' => 'ὴ',
+  'ὶ' => 'ὶ',
+  'ὸ' => 'ὸ',
+  'ὺ' => 'ὺ',
+  'ὼ' => 'ὼ',
+  'ᾀ' => 'ᾀ',
+  'ᾁ' => 'ᾁ',
+  'ᾂ' => 'ᾂ',
+  'ᾃ' => 'ᾃ',
+  'ᾄ' => 'ᾄ',
+  'ᾅ' => 'ᾅ',
+  'ᾆ' => 'ᾆ',
+  'ᾇ' => 'ᾇ',
+  'ᾈ' => 'ᾈ',
+  'ᾉ' => 'ᾉ',
+  'ᾊ' => 'ᾊ',
+  'ᾋ' => 'ᾋ',
+  'ᾌ' => 'ᾌ',
+  'ᾍ' => 'ᾍ',
+  'ᾎ' => 'ᾎ',
+  'ᾏ' => 'ᾏ',
+  'ᾐ' => 'ᾐ',
+  'ᾑ' => 'ᾑ',
+  'ᾒ' => 'ᾒ',
+  'ᾓ' => 'ᾓ',
+  'ᾔ' => 'ᾔ',
+  'ᾕ' => 'ᾕ',
+  'ᾖ' => 'ᾖ',
+  'ᾗ' => 'ᾗ',
+  'ᾘ' => 'ᾘ',
+  'ᾙ' => 'ᾙ',
+  'ᾚ' => 'ᾚ',
+  'ᾛ' => 'ᾛ',
+  'ᾜ' => 'ᾜ',
+  'ᾝ' => 'ᾝ',
+  'ᾞ' => 'ᾞ',
+  'ᾟ' => 'ᾟ',
+  'ᾠ' => 'ᾠ',
+  'ᾡ' => 'ᾡ',
+  'ᾢ' => 'ᾢ',
+  'ᾣ' => 'ᾣ',
+  'ᾤ' => 'ᾤ',
+  'ᾥ' => 'ᾥ',
+  'ᾦ' => 'ᾦ',
+  'ᾧ' => 'ᾧ',
+  'ᾨ' => 'ᾨ',
+  'ᾩ' => 'ᾩ',
+  'ᾪ' => 'ᾪ',
+  'ᾫ' => 'ᾫ',
+  'ᾬ' => 'ᾬ',
+  'ᾭ' => 'ᾭ',
+  'ᾮ' => 'ᾮ',
+  'ᾯ' => 'ᾯ',
+  'ᾰ' => 'ᾰ',
+  'ᾱ' => 'ᾱ',
+  'ᾲ' => 'ᾲ',
+  'ᾳ' => 'ᾳ',
+  'ᾴ' => 'ᾴ',
+  'ᾶ' => 'ᾶ',
+  'ᾷ' => 'ᾷ',
+  'Ᾰ' => 'Ᾰ',
+  'Ᾱ' => 'Ᾱ',
+  'Ὰ' => 'Ὰ',
+  'ᾼ' => 'ᾼ',
+  '῁' => '῁',
+  'ῂ' => 'ῂ',
+  'ῃ' => 'ῃ',
+  'ῄ' => 'ῄ',
+  'ῆ' => 'ῆ',
+  'ῇ' => 'ῇ',
+  'Ὲ' => 'Ὲ',
+  'Ὴ' => 'Ὴ',
+  'ῌ' => 'ῌ',
+  '῍' => '῍',
+  '῎' => '῎',
+  '῏' => '῏',
+  'ῐ' => 'ῐ',
+  'ῑ' => 'ῑ',
+  'ῒ' => 'ῒ',
+  'ῖ' => 'ῖ',
+  'ῗ' => 'ῗ',
+  'Ῐ' => 'Ῐ',
+  'Ῑ' => 'Ῑ',
+  'Ὶ' => 'Ὶ',
+  '῝' => '῝',
+  '῞' => '῞',
+  '῟' => '῟',
+  'ῠ' => 'ῠ',
+  'ῡ' => 'ῡ',
+  'ῢ' => 'ῢ',
+  'ῤ' => 'ῤ',
+  'ῥ' => 'ῥ',
+  'ῦ' => 'ῦ',
+  'ῧ' => 'ῧ',
+  'Ῠ' => 'Ῠ',
+  'Ῡ' => 'Ῡ',
+  'Ὺ' => 'Ὺ',
+  'Ῥ' => 'Ῥ',
+  '῭' => '῭',
+  'ῲ' => 'ῲ',
+  'ῳ' => 'ῳ',
+  'ῴ' => 'ῴ',
+  'ῶ' => 'ῶ',
+  'ῷ' => 'ῷ',
+  'Ὸ' => 'Ὸ',
+  'Ὼ' => 'Ὼ',
+  'ῼ' => 'ῼ',
+  '↚' => '↚',
+  '↛' => '↛',
+  '↮' => '↮',
+  '⇍' => '⇍',
+  '⇎' => '⇎',
+  '⇏' => '⇏',
+  '∄' => '∄',
+  '∉' => '∉',
+  '∌' => '∌',
+  '∤' => '∤',
+  '∦' => '∦',
+  '≁' => '≁',
+  '≄' => '≄',
+  '≇' => '≇',
+  '≉' => '≉',
+  '≠' => '≠',
+  '≢' => '≢',
+  '≭' => '≭',
+  '≮' => '≮',
+  '≯' => '≯',
+  '≰' => '≰',
+  '≱' => '≱',
+  '≴' => '≴',
+  '≵' => '≵',
+  '≸' => '≸',
+  '≹' => '≹',
+  '⊀' => '⊀',
+  '⊁' => '⊁',
+  '⊄' => '⊄',
+  '⊅' => '⊅',
+  '⊈' => '⊈',
+  '⊉' => '⊉',
+  '⊬' => '⊬',
+  '⊭' => '⊭',
+  '⊮' => '⊮',
+  '⊯' => '⊯',
+  '⋠' => '⋠',
+  '⋡' => '⋡',
+  '⋢' => '⋢',
+  '⋣' => '⋣',
+  '⋪' => '⋪',
+  '⋫' => '⋫',
+  '⋬' => '⋬',
+  '⋭' => '⋭',
+  'が' => 'が',
+  'ぎ' => 'ぎ',
+  'ぐ' => 'ぐ',
+  'げ' => 'げ',
+  'ご' => 'ご',
+  'ざ' => 'ざ',
+  'じ' => 'じ',
+  'ず' => 'ず',
+  'ぜ' => 'ぜ',
+  'ぞ' => 'ぞ',
+  'だ' => 'だ',
+  'ぢ' => 'ぢ',
+  'づ' => 'づ',
+  'で' => 'で',
+  'ど' => 'ど',
+  'ば' => 'ば',
+  'ぱ' => 'ぱ',
+  'び' => 'び',
+  'ぴ' => 'ぴ',
+  'ぶ' => 'ぶ',
+  'ぷ' => 'ぷ',
+  'べ' => 'べ',
+  'ぺ' => 'ぺ',
+  'ぼ' => 'ぼ',
+  'ぽ' => 'ぽ',
+  'ゔ' => 'ゔ',
+  'ゞ' => 'ゞ',
+  'ガ' => 'ガ',
+  'ギ' => 'ギ',
+  'グ' => 'グ',
+  'ゲ' => 'ゲ',
+  'ゴ' => 'ゴ',
+  'ザ' => 'ザ',
+  'ジ' => 'ジ',
+  'ズ' => 'ズ',
+  'ゼ' => 'ゼ',
+  'ゾ' => 'ゾ',
+  'ダ' => 'ダ',
+  'ヂ' => 'ヂ',
+  'ヅ' => 'ヅ',
+  'デ' => 'デ',
+  'ド' => 'ド',
+  'バ' => 'バ',
+  'パ' => 'パ',
+  'ビ' => 'ビ',
+  'ピ' => 'ピ',
+  'ブ' => 'ブ',
+  'プ' => 'プ',
+  'ベ' => 'ベ',
+  'ペ' => 'ペ',
+  'ボ' => 'ボ',
+  'ポ' => 'ポ',
+  'ヴ' => 'ヴ',
+  'ヷ' => 'ヷ',
+  'ヸ' => 'ヸ',
+  'ヹ' => 'ヹ',
+  'ヺ' => 'ヺ',
+  'ヾ' => 'ヾ',
+  '𑂚' => '𑂚',
+  '𑂜' => '𑂜',
+  '𑂫' => '𑂫',
+  '𑄮' => '𑄮',
+  '𑄯' => '𑄯',
+  '𑍋' => '𑍋',
+  '𑍌' => '𑍌',
+  '𑒻' => '𑒻',
+  '𑒼' => '𑒼',
+  '𑒾' => '𑒾',
+  '𑖺' => '𑖺',
+  '𑖻' => '𑖻',
+  '𑤸' => '𑤸',
+);

vendor/symfony/polyfill-intl-normalizer/Resources/unidata/combiningClass.php

@@ -0,0 +1,876 @@
+<?php
+
+return array (
+  '̀' => 230,
+  '́' => 230,
+  '̂' => 230,
+  '̃' => 230,
+  '̄' => 230,
+  '̅' => 230,
+  '̆' => 230,
+  '̇' => 230,
+  '̈' => 230,
+  '̉' => 230,
+  '̊' => 230,
+  '̋' => 230,
+  '̌' => 230,
+  '̍' => 230,
+  '̎' => 230,
+  '̏' => 230,
+  '̐' => 230,
+  '̑' => 230,
+  '̒' => 230,
+  '̓' => 230,
+  '̔' => 230,
+  '̕' => 232,
+  '̖' => 220,
+  '̗' => 220,
+  '̘' => 220,
+  '̙' => 220,
+  '̚' => 232,
+  '̛' => 216,
+  '̜' => 220,
+  '̝' => 220,
+  '̞' => 220,
+  '̟' => 220,
+  '̠' => 220,
+  '̡' => 202,
+  '̢' => 202,
+  '̣' => 220,
+  '̤' => 220,
+  '̥' => 220,
+  '̦' => 220,
+  '̧' => 202,
+  '̨' => 202,
+  '̩' => 220,
+  '̪' => 220,
+  '̫' => 220,
+  '̬' => 220,
+  '̭' => 220,
+  '̮' => 220,
+  '̯' => 220,
+  '̰' => 220,
+  '̱' => 220,
+  '̲' => 220,
+  '̳' => 220,
+  '̴' => 1,
+  '̵' => 1,
+  '̶' => 1,
+  '̷' => 1,
+  '̸' => 1,
+  '̹' => 220,
+  '̺' => 220,
+  '̻' => 220,
+  '̼' => 220,
+  '̽' => 230,
+  '̾' => 230,
+  '̿' => 230,
+  '̀' => 230,
+  '́' => 230,
+  '͂' => 230,
+  '̓' => 230,
+  '̈́' => 230,
+  'ͅ' => 240,
+  '͆' => 230,
+  '͇' => 220,
+  '͈' => 220,
+  '͉' => 220,
+  '͊' => 230,
+  '͋' => 230,
+  '͌' => 230,
+  '͍' => 220,
+  '͎' => 220,
+  '͐' => 230,
+  '͑' => 230,
+  '͒' => 230,
+  '͓' => 220,
+  '͔' => 220,
+  '͕' => 220,
+  '͖' => 220,
+  '͗' => 230,
+  '͘' => 232,
+  '͙' => 220,
+  '͚' => 220,
+  '͛' => 230,
+  '͜' => 233,
+  '͝' => 234,
+  '͞' => 234,
+  '͟' => 233,
+  '͠' => 234,
+  '͡' => 234,
+  '͢' => 233,
+  'ͣ' => 230,
+  'ͤ' => 230,
+  'ͥ' => 230,
+  'ͦ' => 230,
+  'ͧ' => 230,
+  'ͨ' => 230,
+  'ͩ' => 230,
+  'ͪ' => 230,
+  'ͫ' => 230,
+  'ͬ' => 230,
+  'ͭ' => 230,
+  'ͮ' => 230,
+  'ͯ' => 230,
+  '҃' => 230,
+  '҄' => 230,
+  '҅' => 230,
+  '҆' => 230,
+  '҇' => 230,
+  '֑' => 220,
+  '֒' => 230,
+  '֓' => 230,
+  '֔' => 230,
+  '֕' => 230,
+  '֖' => 220,
+  '֗' => 230,
+  '֘' => 230,
+  '֙' => 230,
+  '֚' => 222,
+  '֛' => 220,
+  '֜' => 230,
+  '֝' => 230,
+  '֞' => 230,
+  '֟' => 230,
+  '֠' => 230,
+  '֡' => 230,
+  '֢' => 220,
+  '֣' => 220,
+  '֤' => 220,
+  '֥' => 220,
+  '֦' => 220,
+  '֧' => 220,
+  '֨' => 230,
+  '֩' => 230,
+  '֪' => 220,
+  '֫' => 230,
+  '֬' => 230,
+  '֭' => 222,
+  '֮' => 228,
+  '֯' => 230,
+  'ְ' => 10,
+  'ֱ' => 11,
+  'ֲ' => 12,
+  'ֳ' => 13,
+  'ִ' => 14,
+  'ֵ' => 15,
+  'ֶ' => 16,
+  'ַ' => 17,
+  'ָ' => 18,
+  'ֹ' => 19,
+  'ֺ' => 19,
+  'ֻ' => 20,
+  'ּ' => 21,
+  'ֽ' => 22,
+  'ֿ' => 23,
+  'ׁ' => 24,
+  'ׂ' => 25,
+  'ׄ' => 230,
+  'ׅ' => 220,
+  'ׇ' => 18,
+  'ؐ' => 230,
+  'ؑ' => 230,
+  'ؒ' => 230,
+  'ؓ' => 230,
+  'ؔ' => 230,
+  'ؕ' => 230,
+  'ؖ' => 230,
+  'ؗ' => 230,
+  'ؘ' => 30,
+  'ؙ' => 31,
+  'ؚ' => 32,
+  'ً' => 27,
+  'ٌ' => 28,
+  'ٍ' => 29,
+  'َ' => 30,
+  'ُ' => 31,
+  'ِ' => 32,
+  'ّ' => 33,
+  'ْ' => 34,
+  'ٓ' => 230,
+  'ٔ' => 230,
+  'ٕ' => 220,
+  'ٖ' => 220,
+  'ٗ' => 230,
+  '٘' => 230,
+  'ٙ' => 230,
+  'ٚ' => 230,
+  'ٛ' => 230,
+  'ٜ' => 220,
+  'ٝ' => 230,
+  'ٞ' => 230,
+  'ٟ' => 220,
+  'ٰ' => 35,
+  'ۖ' => 230,
+  'ۗ' => 230,
+  'ۘ' => 230,
+  'ۙ' => 230,
+  'ۚ' => 230,
+  'ۛ' => 230,
+  'ۜ' => 230,
+  '۟' => 230,
+  '۠' => 230,
+  'ۡ' => 230,
+  'ۢ' => 230,
+  'ۣ' => 220,
+  'ۤ' => 230,
+  'ۧ' => 230,
+  'ۨ' => 230,
+  '۪' => 220,
+  '۫' => 230,
+  '۬' => 230,
+  'ۭ' => 220,
+  'ܑ' => 36,
+  'ܰ' => 230,
+  'ܱ' => 220,
+  'ܲ' => 230,
+  'ܳ' => 230,
+  'ܴ' => 220,
+  'ܵ' => 230,
+  'ܶ' => 230,
+  'ܷ' => 220,
+  'ܸ' => 220,
+  'ܹ' => 220,
+  'ܺ' => 230,
+  'ܻ' => 220,
+  'ܼ' => 220,
+  'ܽ' => 230,
+  'ܾ' => 220,
+  'ܿ' => 230,
+  '݀' => 230,
+  '݁' => 230,
+  '݂' => 220,
+  '݃' => 230,
+  '݄' => 220,
+  '݅' => 230,
+  '݆' => 220,
+  '݇' => 230,
+  '݈' => 220,
+  '݉' => 230,
+  '݊' => 230,
+  '߫' => 230,
+  '߬' => 230,
+  '߭' => 230,
+  '߮' => 230,
+  '߯' => 230,
+  '߰' => 230,
+  '߱' => 230,
+  '߲' => 220,
+  '߳' => 230,
+  '߽' => 220,
+  'ࠖ' => 230,
+  'ࠗ' => 230,
+  '࠘' => 230,
+  '࠙' => 230,
+  'ࠛ' => 230,
+  'ࠜ' => 230,
+  'ࠝ' => 230,
+  'ࠞ' => 230,
+  'ࠟ' => 230,
+  'ࠠ' => 230,
+  'ࠡ' => 230,
+  'ࠢ' => 230,
+  'ࠣ' => 230,
+  'ࠥ' => 230,
+  'ࠦ' => 230,
+  'ࠧ' => 230,
+  'ࠩ' => 230,
+  'ࠪ' => 230,
+  'ࠫ' => 230,
+  'ࠬ' => 230,
+  '࠭' => 230,
+  '࡙' => 220,
+  '࡚' => 220,
+  '࡛' => 220,
+  '࣓' => 220,
+  'ࣔ' => 230,
+  'ࣕ' => 230,
+  'ࣖ' => 230,
+  'ࣗ' => 230,
+  'ࣘ' => 230,
+  'ࣙ' => 230,
+  'ࣚ' => 230,
+  'ࣛ' => 230,
+  'ࣜ' => 230,
+  'ࣝ' => 230,
+  'ࣞ' => 230,
+  'ࣟ' => 230,
+  '࣠' => 230,
+  '࣡' => 230,
+  'ࣣ' => 220,
+  'ࣤ' => 230,
+  'ࣥ' => 230,
+  'ࣦ' => 220,
+  'ࣧ' => 230,
+  'ࣨ' => 230,
+  'ࣩ' => 220,
+  '࣪' => 230,
+  '࣫' => 230,
+  '࣬' => 230,
+  '࣭' => 220,
+  '࣮' => 220,
+  '࣯' => 220,
+  'ࣰ' => 27,
+  'ࣱ' => 28,
+  'ࣲ' => 29,
+  'ࣳ' => 230,
+  'ࣴ' => 230,
+  'ࣵ' => 230,
+  'ࣶ' => 220,
+  'ࣷ' => 230,
+  'ࣸ' => 230,
+  'ࣹ' => 220,
+  'ࣺ' => 220,
+  'ࣻ' => 230,
+  'ࣼ' => 230,
+  'ࣽ' => 230,
+  'ࣾ' => 230,
+  'ࣿ' => 230,
+  '़' => 7,
+  '्' => 9,
+  '॑' => 230,
+  '॒' => 220,
+  '॓' => 230,
+  '॔' => 230,
+  '়' => 7,
+  '্' => 9,
+  '৾' => 230,
+  '਼' => 7,
+  '੍' => 9,
+  '઼' => 7,
+  '્' => 9,
+  '଼' => 7,
+  '୍' => 9,
+  '்' => 9,
+  '్' => 9,
+  'ౕ' => 84,
+  'ౖ' => 91,
+  '಼' => 7,
+  '್' => 9,
+  '഻' => 9,
+  '഼' => 9,
+  '്' => 9,
+  '්' => 9,
+  'ุ' => 103,
+  'ู' => 103,
+  'ฺ' => 9,
+  '่' => 107,
+  '้' => 107,
+  '๊' => 107,
+  '๋' => 107,
+  'ຸ' => 118,
+  'ູ' => 118,
+  '຺' => 9,
+  '່' => 122,
+  '້' => 122,
+  '໊' => 122,
+  '໋' => 122,
+  '༘' => 220,
+  '༙' => 220,
+  '༵' => 220,
+  '༷' => 220,
+  '༹' => 216,
+  'ཱ' => 129,
+  'ི' => 130,
+  'ུ' => 132,
+  'ེ' => 130,
+  'ཻ' => 130,
+  'ོ' => 130,
+  'ཽ' => 130,
+  'ྀ' => 130,
+  'ྂ' => 230,
+  'ྃ' => 230,
+  '྄' => 9,
+  '྆' => 230,
+  '྇' => 230,
+  '࿆' => 220,
+  '့' => 7,
+  '္' => 9,
+  '်' => 9,
+  'ႍ' => 220,
+  '፝' => 230,
+  '፞' => 230,
+  '፟' => 230,
+  '᜔' => 9,
+  '᜴' => 9,
+  '្' => 9,
+  '៝' => 230,
+  'ᢩ' => 228,
+  '᤹' => 222,
+  '᤺' => 230,
+  '᤻' => 220,
+  'ᨗ' => 230,
+  'ᨘ' => 220,
+  '᩠' => 9,
+  '᩵' => 230,
+  '᩶' => 230,
+  '᩷' => 230,
+  '᩸' => 230,
+  '᩹' => 230,
+  '᩺' => 230,
+  '᩻' => 230,
+  '᩼' => 230,
+  '᩿' => 220,
+  '᪰' => 230,
+  '᪱' => 230,
+  '᪲' => 230,
+  '᪳' => 230,
+  '᪴' => 230,
+  '᪵' => 220,
+  '᪶' => 220,
+  '᪷' => 220,
+  '᪸' => 220,
+  '᪹' => 220,
+  '᪺' => 220,
+  '᪻' => 230,
+  '᪼' => 230,
+  '᪽' => 220,
+  'ᪿ' => 220,
+  'ᫀ' => 220,
+  '᬴' => 7,
+  '᭄' => 9,
+  '᭫' => 230,
+  '᭬' => 220,
+  '᭭' => 230,
+  '᭮' => 230,
+  '᭯' => 230,
+  '᭰' => 230,
+  '᭱' => 230,
+  '᭲' => 230,
+  '᭳' => 230,
+  '᮪' => 9,
+  '᮫' => 9,
+  '᯦' => 7,
+  '᯲' => 9,
+  '᯳' => 9,
+  '᰷' => 7,
+  '᳐' => 230,
+  '᳑' => 230,
+  '᳒' => 230,
+  '᳔' => 1,
+  '᳕' => 220,
+  '᳖' => 220,
+  '᳗' => 220,
+  '᳘' => 220,
+  '᳙' => 220,
+  '᳚' => 230,
+  '᳛' => 230,
+  '᳜' => 220,
+  '᳝' => 220,
+  '᳞' => 220,
+  '᳟' => 220,
+  '᳠' => 230,
+  '᳢' => 1,
+  '᳣' => 1,
+  '᳤' => 1,
+  '᳥' => 1,
+  '᳦' => 1,
+  '᳧' => 1,
+  '᳨' => 1,
+  '᳭' => 220,
+  '᳴' => 230,
+  '᳸' => 230,
+  '᳹' => 230,
+  '᷀' => 230,
+  '᷁' => 230,
+  '᷂' => 220,
+  '᷃' => 230,
+  '᷄' => 230,
+  '᷅' => 230,
+  '᷆' => 230,
+  '᷇' => 230,
+  '᷈' => 230,
+  '᷉' => 230,
+  '᷊' => 220,
+  '᷋' => 230,
+  '᷌' => 230,
+  '᷍' => 234,
+  '᷎' => 214,
+  '᷏' => 220,
+  '᷐' => 202,
+  '᷑' => 230,
+  '᷒' => 230,
+  'ᷓ' => 230,
+  'ᷔ' => 230,
+  'ᷕ' => 230,
+  'ᷖ' => 230,
+  'ᷗ' => 230,
+  'ᷘ' => 230,
+  'ᷙ' => 230,
+  'ᷚ' => 230,
+  'ᷛ' => 230,
+  'ᷜ' => 230,
+  'ᷝ' => 230,
+  'ᷞ' => 230,
+  'ᷟ' => 230,
+  'ᷠ' => 230,
+  'ᷡ' => 230,
+  'ᷢ' => 230,
+  'ᷣ' => 230,
+  'ᷤ' => 230,
+  'ᷥ' => 230,
+  'ᷦ' => 230,
+  'ᷧ' => 230,
+  'ᷨ' => 230,
+  'ᷩ' => 230,
+  'ᷪ' => 230,
+  'ᷫ' => 230,
+  'ᷬ' => 230,
+  'ᷭ' => 230,
+  'ᷮ' => 230,
+  'ᷯ' => 230,
+  'ᷰ' => 230,
+  'ᷱ' => 230,
+  'ᷲ' => 230,
+  'ᷳ' => 230,
+  'ᷴ' => 230,
+  '᷵' => 230,
+  '᷶' => 232,
+  '᷷' => 228,
+  '᷸' => 228,
+  '᷹' => 220,
+  '᷻' => 230,
+  '᷼' => 233,
+  '᷽' => 220,
+  '᷾' => 230,
+  '᷿' => 220,
+  '⃐' => 230,
+  '⃑' => 230,
+  '⃒' => 1,
+  '⃓' => 1,
+  '⃔' => 230,
+  '⃕' => 230,
+  '⃖' => 230,
+  '⃗' => 230,
+  '⃘' => 1,
+  '⃙' => 1,
+  '⃚' => 1,
+  '⃛' => 230,
+  '⃜' => 230,
+  '⃡' => 230,
+  '⃥' => 1,
+  '⃦' => 1,
+  '⃧' => 230,
+  '⃨' => 220,
+  '⃩' => 230,
+  '⃪' => 1,
+  '⃫' => 1,
+  '⃬' => 220,
+  '⃭' => 220,
+  '⃮' => 220,
+  '⃯' => 220,
+  '⃰' => 230,
+  '⳯' => 230,
+  '⳰' => 230,
+  '⳱' => 230,
+  '⵿' => 9,
+  'ⷠ' => 230,
+  'ⷡ' => 230,
+  'ⷢ' => 230,
+  'ⷣ' => 230,
+  'ⷤ' => 230,
+  'ⷥ' => 230,
+  'ⷦ' => 230,
+  'ⷧ' => 230,
+  'ⷨ' => 230,
+  'ⷩ' => 230,
+  'ⷪ' => 230,
+  'ⷫ' => 230,
+  'ⷬ' => 230,
+  'ⷭ' => 230,
+  'ⷮ' => 230,
+  'ⷯ' => 230,
+  'ⷰ' => 230,
+  'ⷱ' => 230,
+  'ⷲ' => 230,
+  'ⷳ' => 230,
+  'ⷴ' => 230,
+  'ⷵ' => 230,
+  'ⷶ' => 230,
+  'ⷷ' => 230,
+  'ⷸ' => 230,
+  'ⷹ' => 230,
+  'ⷺ' => 230,
+  'ⷻ' => 230,
+  'ⷼ' => 230,
+  'ⷽ' => 230,
+  'ⷾ' => 230,
+  'ⷿ' => 230,
+  '〪' => 218,
+  '〫' => 228,
+  '〬' => 232,
+  '〭' => 222,
+  '〮' => 224,
+  '〯' => 224,
+  '゙' => 8,
+  '゚' => 8,
+  '꙯' => 230,
+  'ꙴ' => 230,
+  'ꙵ' => 230,
+  'ꙶ' => 230,
+  'ꙷ' => 230,
+  'ꙸ' => 230,
+  'ꙹ' => 230,
+  'ꙺ' => 230,
+  'ꙻ' => 230,
+  '꙼' => 230,
+  '꙽' => 230,
+  'ꚞ' => 230,
+  'ꚟ' => 230,
+  '꛰' => 230,
+  '꛱' => 230,
+  '꠆' => 9,
+  '꠬' => 9,
+  '꣄' => 9,
+  '꣠' => 230,
+  '꣡' => 230,
+  '꣢' => 230,
+  '꣣' => 230,
+  '꣤' => 230,
+  '꣥' => 230,
+  '꣦' => 230,
+  '꣧' => 230,
+  '꣨' => 230,
+  '꣩' => 230,
+  '꣪' => 230,
+  '꣫' => 230,
+  '꣬' => 230,
+  '꣭' => 230,
+  '꣮' => 230,
+  '꣯' => 230,
+  '꣰' => 230,
+  '꣱' => 230,
+  '꤫' => 220,
+  '꤬' => 220,
+  '꤭' => 220,
+  '꥓' => 9,
+  '꦳' => 7,
+  '꧀' => 9,
+  'ꪰ' => 230,
+  'ꪲ' => 230,
+  'ꪳ' => 230,
+  'ꪴ' => 220,
+  'ꪷ' => 230,
+  'ꪸ' => 230,
+  'ꪾ' => 230,
+  '꪿' => 230,
+  '꫁' => 230,
+  '꫶' => 9,
+  '꯭' => 9,
+  'ﬞ' => 26,
+  '︠' => 230,
+  '︡' => 230,
+  '︢' => 230,
+  '︣' => 230,
+  '︤' => 230,
+  '︥' => 230,
+  '︦' => 230,
+  '︧' => 220,
+  '︨' => 220,
+  '︩' => 220,
+  '︪' => 220,
+  '︫' => 220,
+  '︬' => 220,
+  '︭' => 220,
+  '︮' => 230,
+  '︯' => 230,
+  '𐇽' => 220,
+  '𐋠' => 220,
+  '𐍶' => 230,
+  '𐍷' => 230,
+  '𐍸' => 230,
+  '𐍹' => 230,
+  '𐍺' => 230,
+  '𐨍' => 220,
+  '𐨏' => 230,
+  '𐨸' => 230,
+  '𐨹' => 1,
+  '𐨺' => 220,
+  '𐨿' => 9,
+  '𐫥' => 230,
+  '𐫦' => 220,
+  '𐴤' => 230,
+  '𐴥' => 230,
+  '𐴦' => 230,
+  '𐴧' => 230,
+  '𐺫' => 230,
+  '𐺬' => 230,
+  '𐽆' => 220,
+  '𐽇' => 220,
+  '𐽈' => 230,
+  '𐽉' => 230,
+  '𐽊' => 230,
+  '𐽋' => 220,
+  '𐽌' => 230,
+  '𐽍' => 220,
+  '𐽎' => 220,
+  '𐽏' => 220,
+  '𐽐' => 220,
+  '𑁆' => 9,
+  '𑁿' => 9,
+  '𑂹' => 9,
+  '𑂺' => 7,
+  '𑄀' => 230,
+  '𑄁' => 230,
+  '𑄂' => 230,
+  '𑄳' => 9,
+  '𑄴' => 9,
+  '𑅳' => 7,
+  '𑇀' => 9,
+  '𑇊' => 7,
+  '𑈵' => 9,
+  '𑈶' => 7,
+  '𑋩' => 7,
+  '𑋪' => 9,
+  '𑌻' => 7,
+  '𑌼' => 7,
+  '𑍍' => 9,
+  '𑍦' => 230,
+  '𑍧' => 230,
+  '𑍨' => 230,
+  '𑍩' => 230,
+  '𑍪' => 230,
+  '𑍫' => 230,
+  '𑍬' => 230,
+  '𑍰' => 230,
+  '𑍱' => 230,
+  '𑍲' => 230,
+  '𑍳' => 230,
+  '𑍴' => 230,
+  '𑑂' => 9,
+  '𑑆' => 7,
+  '𑑞' => 230,
+  '𑓂' => 9,
+  '𑓃' => 7,
+  '𑖿' => 9,
+  '𑗀' => 7,
+  '𑘿' => 9,
+  '𑚶' => 9,
+  '𑚷' => 7,
+  '𑜫' => 9,
+  '𑠹' => 9,
+  '𑠺' => 7,
+  '𑤽' => 9,
+  '𑤾' => 9,
+  '𑥃' => 7,
+  '𑧠' => 9,
+  '𑨴' => 9,
+  '𑩇' => 9,
+  '𑪙' => 9,
+  '𑰿' => 9,
+  '𑵂' => 7,
+  '𑵄' => 9,
+  '𑵅' => 9,
+  '𑶗' => 9,
+  '𖫰' => 1,
+  '𖫱' => 1,
+  '𖫲' => 1,
+  '𖫳' => 1,
+  '𖫴' => 1,
+  '𖬰' => 230,
+  '𖬱' => 230,
+  '𖬲' => 230,
+  '𖬳' => 230,
+  '𖬴' => 230,
+  '𖬵' => 230,
+  '𖬶' => 230,
+  '𖿰' => 6,
+  '𖿱' => 6,
+  '𛲞' => 1,
+  '𝅥' => 216,
+  '𝅦' => 216,
+  '𝅧' => 1,
+  '𝅨' => 1,
+  '𝅩' => 1,
+  '𝅭' => 226,
+  '𝅮' => 216,
+  '𝅯' => 216,
+  '𝅰' => 216,
+  '𝅱' => 216,
+  '𝅲' => 216,
+  '𝅻' => 220,
+  '𝅼' => 220,
+  '𝅽' => 220,
+  '𝅾' => 220,
+  '𝅿' => 220,
+  '𝆀' => 220,
+  '𝆁' => 220,
+  '𝆂' => 220,
+  '𝆅' => 230,
+  '𝆆' => 230,
+  '𝆇' => 230,
+  '𝆈' => 230,
+  '𝆉' => 230,
+  '𝆊' => 220,
+  '𝆋' => 220,
+  '𝆪' => 230,
+  '𝆫' => 230,
+  '𝆬' => 230,
+  '𝆭' => 230,
+  '𝉂' => 230,
+  '𝉃' => 230,
+  '𝉄' => 230,
+  '𞀀' => 230,
+  '𞀁' => 230,
+  '𞀂' => 230,
+  '𞀃' => 230,
+  '𞀄' => 230,
+  '𞀅' => 230,
+  '𞀆' => 230,
+  '𞀈' => 230,
+  '𞀉' => 230,
+  '𞀊' => 230,
+  '𞀋' => 230,
+  '𞀌' => 230,
+  '𞀍' => 230,
+  '𞀎' => 230,
+  '𞀏' => 230,
+  '𞀐' => 230,
+  '𞀑' => 230,
+  '𞀒' => 230,
+  '𞀓' => 230,
+  '𞀔' => 230,
+  '𞀕' => 230,
+  '𞀖' => 230,
+  '𞀗' => 230,
+  '𞀘' => 230,
+  '𞀛' => 230,
+  '𞀜' => 230,
+  '𞀝' => 230,
+  '𞀞' => 230,
+  '𞀟' => 230,
+  '𞀠' => 230,
+  '𞀡' => 230,
+  '𞀣' => 230,
+  '𞀤' => 230,
+  '𞀦' => 230,
+  '𞀧' => 230,
+  '𞀨' => 230,
+  '𞀩' => 230,
+  '𞀪' => 230,
+  '𞄰' => 230,
+  '𞄱' => 230,
+  '𞄲' => 230,
+  '𞄳' => 230,
+  '𞄴' => 230,
+  '𞄵' => 230,
+  '𞄶' => 230,
+  '𞋬' => 230,
+  '𞋭' => 230,
+  '𞋮' => 230,
+  '𞋯' => 230,
+  '𞣐' => 220,
+  '𞣑' => 220,
+  '𞣒' => 220,
+  '𞣓' => 220,
+  '𞣔' => 220,
+  '𞣕' => 220,
+  '𞣖' => 220,
+  '𞥄' => 230,
+  '𞥅' => 230,
+  '𞥆' => 230,
+  '𞥇' => 230,
+  '𞥈' => 230,
+  '𞥉' => 230,
+  '𞥊' => 7,
+);

vendor/symfony/polyfill-intl-normalizer/bootstrap.php

@@ -0,0 +1,23 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Symfony\Polyfill\Intl\Normalizer as p;
+
+if (\PHP_VERSION_ID >= 80000) {
+    return require __DIR__.'/bootstrap80.php';
+}
+
+if (!function_exists('normalizer_is_normalized')) {
+    function normalizer_is_normalized($string, $form = p\Normalizer::FORM_C) { return p\Normalizer::isNormalized($string, $form); }
+}
+if (!function_exists('normalizer_normalize')) {
+    function normalizer_normalize($string, $form = p\Normalizer::FORM_C) { return p\Normalizer::normalize($string, $form); }
+}

vendor/symfony/polyfill-intl-normalizer/bootstrap80.php

@@ -0,0 +1,19 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Symfony\Polyfill\Intl\Normalizer as p;
+
+if (!function_exists('normalizer_is_normalized')) {
+    function normalizer_is_normalized(?string $string, ?int $form = p\Normalizer::FORM_C): bool { return p\Normalizer::isNormalized((string) $string, (int) $form); }
+}
+if (!function_exists('normalizer_normalize')) {
+    function normalizer_normalize(?string $string, ?int $form = p\Normalizer::FORM_C): string|false { return p\Normalizer::normalize((string) $string, (int) $form); }
+}

vendor/symfony/polyfill-intl-normalizer/composer.json

@@ -0,0 +1,36 @@
+{
+    "name": "symfony/polyfill-intl-normalizer",
+    "type": "library",
+    "description": "Symfony polyfill for intl's Normalizer class and related functions",
+    "keywords": ["polyfill", "shim", "compatibility", "portable", "intl", "normalizer"],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Nicolas Grekas",
+            "email": "p@tchwork.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=7.2"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Polyfill\\Intl\\Normalizer\\": "" },
+        "files": [ "bootstrap.php" ],
+        "classmap": [ "Resources/stubs" ]
+    },
+    "suggest": {
+        "ext-intl": "For best performance"
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "thanks": {
+            "name": "symfony/polyfill",
+            "url": "https://github.com/symfony/polyfill"
+        }
+    }
+}

vendor/symfony/polyfill-mbstring/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2015-present Fabien Potencier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/symfony/polyfill-mbstring/README.md

@@ -0,0 +1,13 @@
+Symfony Polyfill / Mbstring
+===========================
+
+This component provides a partial, native PHP implementation for the
+[Mbstring](https://php.net/mbstring) extension.
+
+More information can be found in the
+[main Polyfill README](https://github.com/symfony/polyfill/blob/main/README.md).
+
+License
+=======
+
+This library is released under the [MIT license](LICENSE).

vendor/symfony/polyfill-mbstring/Resources/unidata/caseFolding.php

@@ -0,0 +1,119 @@
+<?php
+
+return [
+    'İ' => 'i̇',
+    'µ' => 'μ',
+    'ſ' => 's',
+    'ͅ' => 'ι',
+    'ς' => 'σ',
+    'ϐ' => 'β',
+    'ϑ' => 'θ',
+    'ϕ' => 'φ',
+    'ϖ' => 'π',
+    'ϰ' => 'κ',
+    'ϱ' => 'ρ',
+    'ϵ' => 'ε',
+    'ẛ' => 'ṡ',
+    'ι' => 'ι',
+    'ß' => 'ss',
+    'ʼn' => 'ʼn',
+    'ǰ' => 'ǰ',
+    'ΐ' => 'ΐ',
+    'ΰ' => 'ΰ',
+    'և' => 'եւ',
+    'ẖ' => 'ẖ',
+    'ẗ' => 'ẗ',
+    'ẘ' => 'ẘ',
+    'ẙ' => 'ẙ',
+    'ẚ' => 'aʾ',
+    'ẞ' => 'ss',
+    'ὐ' => 'ὐ',
+    'ὒ' => 'ὒ',
+    'ὔ' => 'ὔ',
+    'ὖ' => 'ὖ',
+    'ᾀ' => 'ἀι',
+    'ᾁ' => 'ἁι',
+    'ᾂ' => 'ἂι',
+    'ᾃ' => 'ἃι',
+    'ᾄ' => 'ἄι',
+    'ᾅ' => 'ἅι',
+    'ᾆ' => 'ἆι',
+    'ᾇ' => 'ἇι',
+    'ᾈ' => 'ἀι',
+    'ᾉ' => 'ἁι',
+    'ᾊ' => 'ἂι',
+    'ᾋ' => 'ἃι',
+    'ᾌ' => 'ἄι',
+    'ᾍ' => 'ἅι',
+    'ᾎ' => 'ἆι',
+    'ᾏ' => 'ἇι',
+    'ᾐ' => 'ἠι',
+    'ᾑ' => 'ἡι',
+    'ᾒ' => 'ἢι',
+    'ᾓ' => 'ἣι',
+    'ᾔ' => 'ἤι',
+    'ᾕ' => 'ἥι',
+    'ᾖ' => 'ἦι',
+    'ᾗ' => 'ἧι',
+    'ᾘ' => 'ἠι',
+    'ᾙ' => 'ἡι',
+    'ᾚ' => 'ἢι',
+    'ᾛ' => 'ἣι',
+    'ᾜ' => 'ἤι',
+    'ᾝ' => 'ἥι',
+    'ᾞ' => 'ἦι',
+    'ᾟ' => 'ἧι',
+    'ᾠ' => 'ὠι',
+    'ᾡ' => 'ὡι',
+    'ᾢ' => 'ὢι',
+    'ᾣ' => 'ὣι',
+    'ᾤ' => 'ὤι',
+    'ᾥ' => 'ὥι',
+    'ᾦ' => 'ὦι',
+    'ᾧ' => 'ὧι',
+    'ᾨ' => 'ὠι',
+    'ᾩ' => 'ὡι',
+    'ᾪ' => 'ὢι',
+    'ᾫ' => 'ὣι',
+    'ᾬ' => 'ὤι',
+    'ᾭ' => 'ὥι',
+    'ᾮ' => 'ὦι',
+    'ᾯ' => 'ὧι',
+    'ᾲ' => 'ὰι',
+    'ᾳ' => 'αι',
+    'ᾴ' => 'άι',
+    'ᾶ' => 'ᾶ',
+    'ᾷ' => 'ᾶι',
+    'ᾼ' => 'αι',
+    'ῂ' => 'ὴι',
+    'ῃ' => 'ηι',
+    'ῄ' => 'ήι',
+    'ῆ' => 'ῆ',
+    'ῇ' => 'ῆι',
+    'ῌ' => 'ηι',
+    'ῒ' => 'ῒ',
+    'ῖ' => 'ῖ',
+    'ῗ' => 'ῗ',
+    'ῢ' => 'ῢ',
+    'ῤ' => 'ῤ',
+    'ῦ' => 'ῦ',
+    'ῧ' => 'ῧ',
+    'ῲ' => 'ὼι',
+    'ῳ' => 'ωι',
+    'ῴ' => 'ώι',
+    'ῶ' => 'ῶ',
+    'ῷ' => 'ῶι',
+    'ῼ' => 'ωι',
+    'ff' => 'ff',
+    'fi' => 'fi',
+    'fl' => 'fl',
+    'ffi' => 'ffi',
+    'ffl' => 'ffl',
+    'ſt' => 'st',
+    'st' => 'st',
+    'ﬓ' => 'մն',
+    'ﬔ' => 'մե',
+    'ﬕ' => 'մի',
+    'ﬖ' => 'վն',
+    'ﬗ' => 'մխ',
+];

vendor/symfony/polyfill-mbstring/bootstrap.php

@@ -0,0 +1,172 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Symfony\Polyfill\Mbstring as p;
+
+if (\PHP_VERSION_ID >= 80000) {
+    return require __DIR__.'/bootstrap80.php';
+}
+
+if (!function_exists('mb_convert_encoding')) {
+    function mb_convert_encoding($string, $to_encoding, $from_encoding = null) { return p\Mbstring::mb_convert_encoding($string, $to_encoding, $from_encoding); }
+}
+if (!function_exists('mb_decode_mimeheader')) {
+    function mb_decode_mimeheader($string) { return p\Mbstring::mb_decode_mimeheader($string); }
+}
+if (!function_exists('mb_encode_mimeheader')) {
+    function mb_encode_mimeheader($string, $charset = null, $transfer_encoding = null, $newline = "\r\n", $indent = 0) { return p\Mbstring::mb_encode_mimeheader($string, $charset, $transfer_encoding, $newline, $indent); }
+}
+if (!function_exists('mb_decode_numericentity')) {
+    function mb_decode_numericentity($string, $map, $encoding = null) { return p\Mbstring::mb_decode_numericentity($string, $map, $encoding); }
+}
+if (!function_exists('mb_encode_numericentity')) {
+    function mb_encode_numericentity($string, $map, $encoding = null, $hex = false) { return p\Mbstring::mb_encode_numericentity($string, $map, $encoding, $hex); }
+}
+if (!function_exists('mb_convert_case')) {
+    function mb_convert_case($string, $mode, $encoding = null) { return p\Mbstring::mb_convert_case($string, $mode, $encoding); }
+}
+if (!function_exists('mb_internal_encoding')) {
+    function mb_internal_encoding($encoding = null) { return p\Mbstring::mb_internal_encoding($encoding); }
+}
+if (!function_exists('mb_language')) {
+    function mb_language($language = null) { return p\Mbstring::mb_language($language); }
+}
+if (!function_exists('mb_list_encodings')) {
+    function mb_list_encodings() { return p\Mbstring::mb_list_encodings(); }
+}
+if (!function_exists('mb_encoding_aliases')) {
+    function mb_encoding_aliases($encoding) { return p\Mbstring::mb_encoding_aliases($encoding); }
+}
+if (!function_exists('mb_check_encoding')) {
+    function mb_check_encoding($value = null, $encoding = null) { return p\Mbstring::mb_check_encoding($value, $encoding); }
+}
+if (!function_exists('mb_detect_encoding')) {
+    function mb_detect_encoding($string, $encodings = null, $strict = false) { return p\Mbstring::mb_detect_encoding($string, $encodings, $strict); }
+}
+if (!function_exists('mb_detect_order')) {
+    function mb_detect_order($encoding = null) { return p\Mbstring::mb_detect_order($encoding); }
+}
+if (!function_exists('mb_parse_str')) {
+    function mb_parse_str($string, &$result = []) { parse_str($string, $result); return (bool) $result; }
+}
+if (!function_exists('mb_strlen')) {
+    function mb_strlen($string, $encoding = null) { return p\Mbstring::mb_strlen($string, $encoding); }
+}
+if (!function_exists('mb_strpos')) {
+    function mb_strpos($haystack, $needle, $offset = 0, $encoding = null) { return p\Mbstring::mb_strpos($haystack, $needle, $offset, $encoding); }
+}
+if (!function_exists('mb_strtolower')) {
+    function mb_strtolower($string, $encoding = null) { return p\Mbstring::mb_strtolower($string, $encoding); }
+}
+if (!function_exists('mb_strtoupper')) {
+    function mb_strtoupper($string, $encoding = null) { return p\Mbstring::mb_strtoupper($string, $encoding); }
+}
+if (!function_exists('mb_substitute_character')) {
+    function mb_substitute_character($substitute_character = null) { return p\Mbstring::mb_substitute_character($substitute_character); }
+}
+if (!function_exists('mb_substr')) {
+    function mb_substr($string, $start, $length = 2147483647, $encoding = null) { return p\Mbstring::mb_substr($string, $start, $length, $encoding); }
+}
+if (!function_exists('mb_stripos')) {
+    function mb_stripos($haystack, $needle, $offset = 0, $encoding = null) { return p\Mbstring::mb_stripos($haystack, $needle, $offset, $encoding); }
+}
+if (!function_exists('mb_stristr')) {
+    function mb_stristr($haystack, $needle, $before_needle = false, $encoding = null) { return p\Mbstring::mb_stristr($haystack, $needle, $before_needle, $encoding); }
+}
+if (!function_exists('mb_strrchr')) {
+    function mb_strrchr($haystack, $needle, $before_needle = false, $encoding = null) { return p\Mbstring::mb_strrchr($haystack, $needle, $before_needle, $encoding); }
+}
+if (!function_exists('mb_strrichr')) {
+    function mb_strrichr($haystack, $needle, $before_needle = false, $encoding = null) { return p\Mbstring::mb_strrichr($haystack, $needle, $before_needle, $encoding); }
+}
+if (!function_exists('mb_strripos')) {
+    function mb_strripos($haystack, $needle, $offset = 0, $encoding = null) { return p\Mbstring::mb_strripos($haystack, $needle, $offset, $encoding); }
+}
+if (!function_exists('mb_strrpos')) {
+    function mb_strrpos($haystack, $needle, $offset = 0, $encoding = null) { return p\Mbstring::mb_strrpos($haystack, $needle, $offset, $encoding); }
+}
+if (!function_exists('mb_strstr')) {
+    function mb_strstr($haystack, $needle, $before_needle = false, $encoding = null) { return p\Mbstring::mb_strstr($haystack, $needle, $before_needle, $encoding); }
+}
+if (!function_exists('mb_get_info')) {
+    function mb_get_info($type = 'all') { return p\Mbstring::mb_get_info($type); }
+}
+if (!function_exists('mb_http_output')) {
+    function mb_http_output($encoding = null) { return p\Mbstring::mb_http_output($encoding); }
+}
+if (!function_exists('mb_strwidth')) {
+    function mb_strwidth($string, $encoding = null) { return p\Mbstring::mb_strwidth($string, $encoding); }
+}
+if (!function_exists('mb_substr_count')) {
+    function mb_substr_count($haystack, $needle, $encoding = null) { return p\Mbstring::mb_substr_count($haystack, $needle, $encoding); }
+}
+if (!function_exists('mb_output_handler')) {
+    function mb_output_handler($string, $status) { return p\Mbstring::mb_output_handler($string, $status); }
+}
+if (!function_exists('mb_http_input')) {
+    function mb_http_input($type = null) { return p\Mbstring::mb_http_input($type); }
+}
+
+if (!function_exists('mb_convert_variables')) {
+    function mb_convert_variables($to_encoding, $from_encoding, &...$vars) { return p\Mbstring::mb_convert_variables($to_encoding, $from_encoding, ...$vars); }
+}
+
+if (!function_exists('mb_ord')) {
+    function mb_ord($string, $encoding = null) { return p\Mbstring::mb_ord($string, $encoding); }
+}
+if (!function_exists('mb_chr')) {
+    function mb_chr($codepoint, $encoding = null) { return p\Mbstring::mb_chr($codepoint, $encoding); }
+}
+if (!function_exists('mb_scrub')) {
+    function mb_scrub($string, $encoding = null) { $encoding = null === $encoding ? mb_internal_encoding() : $encoding; return mb_convert_encoding($string, $encoding, $encoding); }
+}
+if (!function_exists('mb_str_split')) {
+    function mb_str_split($string, $length = 1, $encoding = null) { return p\Mbstring::mb_str_split($string, $length, $encoding); }
+}
+
+if (!function_exists('mb_str_pad')) {
+    function mb_str_pad(string $string, int $length, string $pad_string = ' ', int $pad_type = STR_PAD_RIGHT, ?string $encoding = null): string { return p\Mbstring::mb_str_pad($string, $length, $pad_string, $pad_type, $encoding); }
+}
+
+if (!function_exists('mb_ucfirst')) {
+    function mb_ucfirst(string $string, ?string $encoding = null): string { return p\Mbstring::mb_ucfirst($string, $encoding); }
+}
+
+if (!function_exists('mb_lcfirst')) {
+    function mb_lcfirst(string $string, ?string $encoding = null): string { return p\Mbstring::mb_lcfirst($string, $encoding); }
+}
+
+if (!function_exists('mb_trim')) {
+    function mb_trim(string $string, ?string $characters = null, ?string $encoding = null): string { return p\Mbstring::mb_trim($string, $characters, $encoding); }
+}
+
+if (!function_exists('mb_ltrim')) {
+    function mb_ltrim(string $string, ?string $characters = null, ?string $encoding = null): string { return p\Mbstring::mb_ltrim($string, $characters, $encoding); }
+}
+
+if (!function_exists('mb_rtrim')) {
+    function mb_rtrim(string $string, ?string $characters = null, ?string $encoding = null): string { return p\Mbstring::mb_rtrim($string, $characters, $encoding); }
+}
+
+
+if (extension_loaded('mbstring')) {
+    return;
+}
+
+if (!defined('MB_CASE_UPPER')) {
+    define('MB_CASE_UPPER', 0);
+}
+if (!defined('MB_CASE_LOWER')) {
+    define('MB_CASE_LOWER', 1);
+}
+if (!defined('MB_CASE_TITLE')) {
+    define('MB_CASE_TITLE', 2);
+}

vendor/symfony/polyfill-mbstring/bootstrap80.php

@@ -0,0 +1,167 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Symfony\Polyfill\Mbstring as p;
+
+if (!function_exists('mb_convert_encoding')) {
+    function mb_convert_encoding(array|string|null $string, ?string $to_encoding, array|string|null $from_encoding = null): array|string|false { return p\Mbstring::mb_convert_encoding($string ?? '', (string) $to_encoding, $from_encoding); }
+}
+if (!function_exists('mb_decode_mimeheader')) {
+    function mb_decode_mimeheader(?string $string): string { return p\Mbstring::mb_decode_mimeheader((string) $string); }
+}
+if (!function_exists('mb_encode_mimeheader')) {
+    function mb_encode_mimeheader(?string $string, ?string $charset = null, ?string $transfer_encoding = null, ?string $newline = "\r\n", ?int $indent = 0): string { return p\Mbstring::mb_encode_mimeheader((string) $string, $charset, $transfer_encoding, (string) $newline, (int) $indent); }
+}
+if (!function_exists('mb_decode_numericentity')) {
+    function mb_decode_numericentity(?string $string, array $map, ?string $encoding = null): string { return p\Mbstring::mb_decode_numericentity((string) $string, $map, $encoding); }
+}
+if (!function_exists('mb_encode_numericentity')) {
+    function mb_encode_numericentity(?string $string, array $map, ?string $encoding = null, ?bool $hex = false): string { return p\Mbstring::mb_encode_numericentity((string) $string, $map, $encoding, (bool) $hex); }
+}
+if (!function_exists('mb_convert_case')) {
+    function mb_convert_case(?string $string, ?int $mode, ?string $encoding = null): string { return p\Mbstring::mb_convert_case((string) $string, (int) $mode, $encoding); }
+}
+if (!function_exists('mb_internal_encoding')) {
+    function mb_internal_encoding(?string $encoding = null): string|bool { return p\Mbstring::mb_internal_encoding($encoding); }
+}
+if (!function_exists('mb_language')) {
+    function mb_language(?string $language = null): string|bool { return p\Mbstring::mb_language($language); }
+}
+if (!function_exists('mb_list_encodings')) {
+    function mb_list_encodings(): array { return p\Mbstring::mb_list_encodings(); }
+}
+if (!function_exists('mb_encoding_aliases')) {
+    function mb_encoding_aliases(?string $encoding): array { return p\Mbstring::mb_encoding_aliases((string) $encoding); }
+}
+if (!function_exists('mb_check_encoding')) {
+    function mb_check_encoding(array|string|null $value = null, ?string $encoding = null): bool { return p\Mbstring::mb_check_encoding($value, $encoding); }
+}
+if (!function_exists('mb_detect_encoding')) {
+    function mb_detect_encoding(?string $string, array|string|null $encodings = null, ?bool $strict = false): string|false { return p\Mbstring::mb_detect_encoding((string) $string, $encodings, (bool) $strict); }
+}
+if (!function_exists('mb_detect_order')) {
+    function mb_detect_order(array|string|null $encoding = null): array|bool { return p\Mbstring::mb_detect_order($encoding); }
+}
+if (!function_exists('mb_parse_str')) {
+    function mb_parse_str(?string $string, &$result = []): bool { parse_str((string) $string, $result); return (bool) $result; }
+}
+if (!function_exists('mb_strlen')) {
+    function mb_strlen(?string $string, ?string $encoding = null): int { return p\Mbstring::mb_strlen((string) $string, $encoding); }
+}
+if (!function_exists('mb_strpos')) {
+    function mb_strpos(?string $haystack, ?string $needle, ?int $offset = 0, ?string $encoding = null): int|false { return p\Mbstring::mb_strpos((string) $haystack, (string) $needle, (int) $offset, $encoding); }
+}
+if (!function_exists('mb_strtolower')) {
+    function mb_strtolower(?string $string, ?string $encoding = null): string { return p\Mbstring::mb_strtolower((string) $string, $encoding); }
+}
+if (!function_exists('mb_strtoupper')) {
+    function mb_strtoupper(?string $string, ?string $encoding = null): string { return p\Mbstring::mb_strtoupper((string) $string, $encoding); }
+}
+if (!function_exists('mb_substitute_character')) {
+    function mb_substitute_character(string|int|null $substitute_character = null): string|int|bool { return p\Mbstring::mb_substitute_character($substitute_character); }
+}
+if (!function_exists('mb_substr')) {
+    function mb_substr(?string $string, ?int $start, ?int $length = null, ?string $encoding = null): string { return p\Mbstring::mb_substr((string) $string, (int) $start, $length, $encoding); }
+}
+if (!function_exists('mb_stripos')) {
+    function mb_stripos(?string $haystack, ?string $needle, ?int $offset = 0, ?string $encoding = null): int|false { return p\Mbstring::mb_stripos((string) $haystack, (string) $needle, (int) $offset, $encoding); }
+}
+if (!function_exists('mb_stristr')) {
+    function mb_stristr(?string $haystack, ?string $needle, ?bool $before_needle = false, ?string $encoding = null): string|false { return p\Mbstring::mb_stristr((string) $haystack, (string) $needle, (bool) $before_needle, $encoding); }
+}
+if (!function_exists('mb_strrchr')) {
+    function mb_strrchr(?string $haystack, ?string $needle, ?bool $before_needle = false, ?string $encoding = null): string|false { return p\Mbstring::mb_strrchr((string) $haystack, (string) $needle, (bool) $before_needle, $encoding); }
+}
+if (!function_exists('mb_strrichr')) {
+    function mb_strrichr(?string $haystack, ?string $needle, ?bool $before_needle = false, ?string $encoding = null): string|false { return p\Mbstring::mb_strrichr((string) $haystack, (string) $needle, (bool) $before_needle, $encoding); }
+}
+if (!function_exists('mb_strripos')) {
+    function mb_strripos(?string $haystack, ?string $needle, ?int $offset = 0, ?string $encoding = null): int|false { return p\Mbstring::mb_strripos((string) $haystack, (string) $needle, (int) $offset, $encoding); }
+}
+if (!function_exists('mb_strrpos')) {
+    function mb_strrpos(?string $haystack, ?string $needle, ?int $offset = 0, ?string $encoding = null): int|false { return p\Mbstring::mb_strrpos((string) $haystack, (string) $needle, (int) $offset, $encoding); }
+}
+if (!function_exists('mb_strstr')) {
+    function mb_strstr(?string $haystack, ?string $needle, ?bool $before_needle = false, ?string $encoding = null): string|false { return p\Mbstring::mb_strstr((string) $haystack, (string) $needle, (bool) $before_needle, $encoding); }
+}
+if (!function_exists('mb_get_info')) {
+    function mb_get_info(?string $type = 'all'): array|string|int|false|null { return p\Mbstring::mb_get_info((string) $type); }
+}
+if (!function_exists('mb_http_output')) {
+    function mb_http_output(?string $encoding = null): string|bool { return p\Mbstring::mb_http_output($encoding); }
+}
+if (!function_exists('mb_strwidth')) {
+    function mb_strwidth(?string $string, ?string $encoding = null): int { return p\Mbstring::mb_strwidth((string) $string, $encoding); }
+}
+if (!function_exists('mb_substr_count')) {
+    function mb_substr_count(?string $haystack, ?string $needle, ?string $encoding = null): int { return p\Mbstring::mb_substr_count((string) $haystack, (string) $needle, $encoding); }
+}
+if (!function_exists('mb_output_handler')) {
+    function mb_output_handler(?string $string, ?int $status): string { return p\Mbstring::mb_output_handler((string) $string, (int) $status); }
+}
+if (!function_exists('mb_http_input')) {
+    function mb_http_input(?string $type = null): array|string|false { return p\Mbstring::mb_http_input($type); }
+}
+
+if (!function_exists('mb_convert_variables')) {
+    function mb_convert_variables(?string $to_encoding, array|string|null $from_encoding, mixed &$var, mixed &...$vars): string|false { return p\Mbstring::mb_convert_variables((string) $to_encoding, $from_encoding ?? '', $var, ...$vars); }
+}
+
+if (!function_exists('mb_ord')) {
+    function mb_ord(?string $string, ?string $encoding = null): int|false { return p\Mbstring::mb_ord((string) $string, $encoding); }
+}
+if (!function_exists('mb_chr')) {
+    function mb_chr(?int $codepoint, ?string $encoding = null): string|false { return p\Mbstring::mb_chr((int) $codepoint, $encoding); }
+}
+if (!function_exists('mb_scrub')) {
+    function mb_scrub(?string $string, ?string $encoding = null): string { $encoding ??= mb_internal_encoding(); return mb_convert_encoding((string) $string, $encoding, $encoding); }
+}
+if (!function_exists('mb_str_split')) {
+    function mb_str_split(?string $string, ?int $length = 1, ?string $encoding = null): array { return p\Mbstring::mb_str_split((string) $string, (int) $length, $encoding); }
+}
+
+if (!function_exists('mb_str_pad')) {
+    function mb_str_pad(string $string, int $length, string $pad_string = ' ', int $pad_type = STR_PAD_RIGHT, ?string $encoding = null): string { return p\Mbstring::mb_str_pad($string, $length, $pad_string, $pad_type, $encoding); }
+}
+
+if (!function_exists('mb_ucfirst')) {
+    function mb_ucfirst(string $string, ?string $encoding = null): string { return p\Mbstring::mb_ucfirst($string, $encoding); }
+}
+
+if (!function_exists('mb_lcfirst')) {
+    function mb_lcfirst(string $string, ?string $encoding = null): string { return p\Mbstring::mb_lcfirst($string, $encoding); }
+}
+
+if (!function_exists('mb_trim')) {
+    function mb_trim(string $string, ?string $characters = null, ?string $encoding = null): string { return p\Mbstring::mb_trim($string, $characters, $encoding); }
+}
+
+if (!function_exists('mb_ltrim')) {
+    function mb_ltrim(string $string, ?string $characters = null, ?string $encoding = null): string { return p\Mbstring::mb_ltrim($string, $characters, $encoding); }
+}
+
+if (!function_exists('mb_rtrim')) {
+    function mb_rtrim(string $string, ?string $characters = null, ?string $encoding = null): string { return p\Mbstring::mb_rtrim($string, $characters, $encoding); }
+}
+
+if (extension_loaded('mbstring')) {
+    return;
+}
+
+if (!defined('MB_CASE_UPPER')) {
+    define('MB_CASE_UPPER', 0);
+}
+if (!defined('MB_CASE_LOWER')) {
+    define('MB_CASE_LOWER', 1);
+}
+if (!defined('MB_CASE_TITLE')) {
+    define('MB_CASE_TITLE', 2);
+}

vendor/symfony/polyfill-mbstring/composer.json

@@ -0,0 +1,39 @@
+{
+    "name": "symfony/polyfill-mbstring",
+    "type": "library",
+    "description": "Symfony polyfill for the Mbstring extension",
+    "keywords": ["polyfill", "shim", "compatibility", "portable", "mbstring"],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Nicolas Grekas",
+            "email": "p@tchwork.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=7.2",
+        "ext-iconv": "*"
+    },
+    "provide": {
+        "ext-mbstring": "*"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Polyfill\\Mbstring\\": "" },
+        "files": [ "bootstrap.php" ]
+    },
+    "suggest": {
+        "ext-mbstring": "For best performance"
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "thanks": {
+            "name": "symfony/polyfill",
+            "url": "https://github.com/symfony/polyfill"
+        }
+    }
+}

vendor/symfony/yaml/CHANGELOG.md

@@ -0,0 +1,275 @@
+CHANGELOG
+=========
+
+7.3
+---
+
+ * Add compact nested mapping support by using the `Yaml::DUMP_COMPACT_NESTED_MAPPING` flag
+ * Add the `Yaml::DUMP_FORCE_DOUBLE_QUOTES_ON_VALUES` flag to enforce double quotes around string values
+
+7.2
+---
+
+ * Deprecate parsing duplicate mapping keys whose value is `null`
+ * Add support for dumping `null` as an empty value by using the `Yaml::DUMP_NULL_AS_EMPTY` flag
+
+7.1
+---
+
+ * Add support for getting all the enum cases with `!php/enum Foo`
+
+7.0
+---
+
+ * Remove the `!php/const:` tag, use `!php/const` instead (without the colon)
+
+6.3
+---
+
+ * Add support to dump int keys as strings by using the `Yaml::DUMP_NUMERIC_KEY_AS_STRING` flag
+
+6.2
+---
+
+ * Add support for `!php/enum` and `!php/enum *->value`
+ * Deprecate the `!php/const:` tag in key which will be replaced by the `!php/const` tag (without the colon) since 3.4
+
+6.1
+---
+
+ * In cases where it will likely improve readability, strings containing single quotes will be double-quoted
+
+5.4
+---
+
+ * Add new `lint:yaml dirname --exclude=/dirname/foo.yaml --exclude=/dirname/bar.yaml`
+   option to exclude one or more specific files from multiple file list
+ * Allow negatable for the parse tags option with `--no-parse-tags`
+
+5.3
+---
+
+ * Added `github` format support & autodetection to render errors as annotations
+   when running the YAML linter command in a Github Action environment.
+
+5.1.0
+-----
+
+ * Added support for parsing numbers prefixed with `0o` as octal numbers.
+ * Deprecated support for parsing numbers starting with `0` as octal numbers. They will be parsed as strings as of Symfony 6.0. Prefix numbers with `0o`
+   so that they are parsed as octal numbers.
+
+   Before:
+
+   ```yaml
+   Yaml::parse('072');
+   ```
+
+   After:
+
+   ```yaml
+   Yaml::parse('0o72');
+   ```
+
+ * Added `yaml-lint` binary.
+ * Deprecated using the `!php/object` and `!php/const` tags without a value.
+
+5.0.0
+-----
+
+ * Removed support for mappings inside multi-line strings.
+ * removed support for implicit STDIN usage in the `lint:yaml` command, use `lint:yaml -` (append a dash) instead to make it explicit.
+
+4.4.0
+-----
+
+ * Added support for parsing the inline notation spanning multiple lines.
+ * Added support to dump `null` as `~` by using the `Yaml::DUMP_NULL_AS_TILDE` flag.
+ * deprecated accepting STDIN implicitly when using the `lint:yaml` command, use `lint:yaml -` (append a dash) instead to make it explicit.
+
+4.3.0
+-----
+
+ * Using a mapping inside a multi-line string is deprecated and will throw a `ParseException` in 5.0.
+
+4.2.0
+-----
+
+ * added support for multiple files or directories in `LintCommand`
+
+4.0.0
+-----
+
+ * The behavior of the non-specific tag `!` is changed and now forces
+   non-evaluating your values.
+ * complex mappings will throw a `ParseException`
+ * support for the comma as a group separator for floats has been dropped, use
+   the underscore instead
+ * support for the `!!php/object` tag has been dropped, use the `!php/object`
+   tag instead
+ * duplicate mapping keys throw a `ParseException`
+ * non-string mapping keys throw a `ParseException`, use the `Yaml::PARSE_KEYS_AS_STRINGS`
+   flag to cast them to strings
+ * `%` at the beginning of an unquoted string throw a `ParseException`
+ * mappings with a colon (`:`) that is not followed by a whitespace throw a
+   `ParseException`
+ * the `Dumper::setIndentation()` method has been removed
+ * being able to pass boolean options to the `Yaml::parse()`, `Yaml::dump()`,
+   `Parser::parse()`, and `Dumper::dump()` methods to configure the behavior of
+   the parser and dumper is no longer supported, pass bitmask flags instead
+ * the constructor arguments of the `Parser` class have been removed
+ * the `Inline` class is internal and no longer part of the BC promise
+ * removed support for the `!str` tag, use the `!!str` tag instead
+ * added support for tagged scalars.
+
+   ```yml
+   Yaml::parse('!foo bar', Yaml::PARSE_CUSTOM_TAGS);
+   // returns TaggedValue('foo', 'bar');
+   ```
+
+3.4.0
+-----
+
+ * added support for parsing YAML files using the `Yaml::parseFile()` or `Parser::parseFile()` method
+
+ * the `Dumper`, `Parser`, and `Yaml` classes are marked as final
+
+ * Deprecated the `!php/object:` tag which will be replaced by the
+   `!php/object` tag (without the colon) in 4.0.
+
+ * Deprecated the `!php/const:` tag which will be replaced by the
+   `!php/const` tag (without the colon) in 4.0.
+
+ * Support for the `!str` tag is deprecated, use the `!!str` tag instead.
+
+ * Deprecated using the non-specific tag `!` as its behavior will change in 4.0.
+   It will force non-evaluating your values in 4.0. Use plain integers or `!!float` instead.
+
+3.3.0
+-----
+
+ * Starting an unquoted string with a question mark followed by a space is
+   deprecated and will throw a `ParseException` in Symfony 4.0.
+
+ * Deprecated support for implicitly parsing non-string mapping keys as strings.
+   Mapping keys that are no strings will lead to a `ParseException` in Symfony
+   4.0. Use quotes to opt-in for keys to be parsed as strings.
+
+   Before:
+
+   ```php
+   $yaml = <<<YAML
+   null: null key
+   true: boolean true
+   2.0: float key
+   YAML;
+
+   Yaml::parse($yaml);
+   ```
+
+   After:
+
+   ```php
+
+   $yaml = <<<YAML
+   "null": null key
+   "true": boolean true
+   "2.0": float key
+   YAML;
+
+   Yaml::parse($yaml);
+   ```
+
+ * Omitted mapping values will be parsed as `null`.
+
+ * Omitting the key of a mapping is deprecated and will throw a `ParseException` in Symfony 4.0.
+
+ * Added support for dumping empty PHP arrays as YAML sequences:
+
+   ```php
+   Yaml::dump([], 0, 0, Yaml::DUMP_EMPTY_ARRAY_AS_SEQUENCE);
+   ```
+
+3.2.0
+-----
+
+ * Mappings with a colon (`:`) that is not followed by a whitespace are deprecated
+   when the mapping key is not quoted and will lead to a `ParseException` in
+   Symfony 4.0 (e.g. `foo:bar` must be `foo: bar`).
+
+ * Added support for parsing PHP constants:
+
+   ```php
+   Yaml::parse('!php/const:PHP_INT_MAX', Yaml::PARSE_CONSTANT);
+   ```
+
+ * Support for silently ignoring duplicate mapping keys in YAML has been
+   deprecated and will lead to a `ParseException` in Symfony 4.0.
+
+3.1.0
+-----
+
+ * Added support to dump `stdClass` and `ArrayAccess` objects as YAML mappings
+   through the `Yaml::DUMP_OBJECT_AS_MAP` flag.
+
+ * Strings that are not UTF-8 encoded will be dumped as base64 encoded binary
+   data.
+
+ * Added support for dumping multi line strings as literal blocks.
+
+ * Added support for parsing base64 encoded binary data when they are tagged
+   with the `!!binary` tag.
+
+ * Added support for parsing timestamps as `\DateTime` objects:
+
+   ```php
+   Yaml::parse('2001-12-15 21:59:43.10 -5', Yaml::PARSE_DATETIME);
+   ```
+
+ * `\DateTime` and `\DateTimeImmutable` objects are dumped as YAML timestamps.
+
+ * Deprecated usage of `%` at the beginning of an unquoted string.
+
+ * Added support for customizing the YAML parser behavior through an optional bit field:
+
+   ```php
+   Yaml::parse('{ "foo": "bar", "fiz": "cat" }', Yaml::PARSE_EXCEPTION_ON_INVALID_TYPE | Yaml::PARSE_OBJECT | Yaml::PARSE_OBJECT_FOR_MAP);
+   ```
+
+ * Added support for customizing the dumped YAML string through an optional bit field:
+
+   ```php
+   Yaml::dump(['foo' => new A(), 'bar' => 1], 0, 0, Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE | Yaml::DUMP_OBJECT);
+   ```
+
+3.0.0
+-----
+
+ * Yaml::parse() now throws an exception when a blackslash is not escaped
+   in double-quoted strings
+
+2.8.0
+-----
+
+ * Deprecated usage of a colon in an unquoted mapping value
+ * Deprecated usage of @, \`, | and > at the beginning of an unquoted string
+ * When surrounding strings with double-quotes, you must now escape `\` characters. Not
+   escaping those characters (when surrounded by double-quotes) is deprecated.
+
+   Before:
+
+   ```yml
+   class: "Foo\Var"
+   ```
+
+   After:
+
+   ```yml
+   class: "Foo\\Var"
+   ```
+
+2.1.0
+-----
+
+ * Yaml::parse() does not evaluate loaded files as PHP files by default
+   anymore (call Yaml::enablePhpParsing() to get back the old behavior)

vendor/symfony/yaml/Command/LintCommand.php

@@ -0,0 +1,277 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Command;
+
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\CI\GithubActionReporter;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Completion\CompletionInput;
+use Symfony\Component\Console\Completion\CompletionSuggestions;
+use Symfony\Component\Console\Exception\InvalidArgumentException;
+use Symfony\Component\Console\Exception\RuntimeException;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+use Symfony\Component\Yaml\Exception\ParseException;
+use Symfony\Component\Yaml\Parser;
+use Symfony\Component\Yaml\Yaml;
+
+/**
+ * Validates YAML files syntax and outputs encountered errors.
+ *
+ * @author Grégoire Pineau <lyrixx@lyrixx.info>
+ * @author Robin Chalas <robin.chalas@gmail.com>
+ */
+#[AsCommand(name: 'lint:yaml', description: 'Lint a YAML file and outputs encountered errors')]
+class LintCommand extends Command
+{
+    private Parser $parser;
+    private ?string $format = null;
+    private bool $displayCorrectFiles;
+    private ?\Closure $directoryIteratorProvider;
+    private ?\Closure $isReadableProvider;
+
+    public function __construct(?string $name = null, ?callable $directoryIteratorProvider = null, ?callable $isReadableProvider = null)
+    {
+        parent::__construct($name);
+
+        $this->directoryIteratorProvider = null === $directoryIteratorProvider ? null : $directoryIteratorProvider(...);
+        $this->isReadableProvider = null === $isReadableProvider ? null : $isReadableProvider(...);
+    }
+
+    protected function configure(): void
+    {
+        $this
+            ->addArgument('filename', InputArgument::IS_ARRAY, 'A file, a directory or "-" for reading from STDIN')
+            ->addOption('format', null, InputOption::VALUE_REQUIRED, \sprintf('The output format ("%s")', implode('", "', $this->getAvailableFormatOptions())))
+            ->addOption('exclude', null, InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY, 'Path(s) to exclude')
+            ->addOption('parse-tags', null, InputOption::VALUE_NEGATABLE, 'Parse custom tags', null)
+            ->setHelp(<<<EOF
+The <info>%command.name%</info> command lints a YAML file and outputs to STDOUT
+the first encountered syntax error.
+
+You can validates YAML contents passed from STDIN:
+
+  <info>cat filename | php %command.full_name% -</info>
+
+You can also validate the syntax of a file:
+
+  <info>php %command.full_name% filename</info>
+
+Or of a whole directory:
+
+  <info>php %command.full_name% dirname</info>
+
+The <info>--format</info> option specifies the format of the command output:
+
+  <info>php %command.full_name% dirname --format=json</info>
+
+You can also exclude one or more specific files:
+
+  <info>php %command.full_name% dirname --exclude="dirname/foo.yaml" --exclude="dirname/bar.yaml"</info>
+
+EOF
+            )
+        ;
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $io = new SymfonyStyle($input, $output);
+        $filenames = (array) $input->getArgument('filename');
+        $excludes = $input->getOption('exclude');
+        $this->format = $input->getOption('format');
+        $flags = $input->getOption('parse-tags');
+
+        if (null === $this->format) {
+            // Autodetect format according to CI environment
+            $this->format = class_exists(GithubActionReporter::class) && GithubActionReporter::isGithubActionEnvironment() ? 'github' : 'txt';
+        }
+
+        $flags = $flags ? Yaml::PARSE_CUSTOM_TAGS : 0;
+
+        $this->displayCorrectFiles = $output->isVerbose();
+
+        if (['-'] === $filenames) {
+            return $this->display($io, [$this->validate(file_get_contents('php://stdin'), $flags)]);
+        }
+
+        if (!$filenames) {
+            throw new RuntimeException('Please provide a filename or pipe file content to STDIN.');
+        }
+
+        $filesInfo = [];
+        foreach ($filenames as $filename) {
+            if (!$this->isReadable($filename)) {
+                throw new RuntimeException(\sprintf('File or directory "%s" is not readable.', $filename));
+            }
+
+            foreach ($this->getFiles($filename) as $file) {
+                if (!\in_array($file->getPathname(), $excludes, true)) {
+                    $filesInfo[] = $this->validate(file_get_contents($file), $flags, $file);
+                }
+            }
+        }
+
+        return $this->display($io, $filesInfo);
+    }
+
+    private function validate(string $content, int $flags, ?string $file = null): array
+    {
+        $prevErrorHandler = set_error_handler(function ($level, $message, $file, $line) use (&$prevErrorHandler) {
+            if (\E_USER_DEPRECATED === $level) {
+                throw new ParseException($message, $this->getParser()->getRealCurrentLineNb() + 1);
+            }
+
+            return $prevErrorHandler ? $prevErrorHandler($level, $message, $file, $line) : false;
+        });
+
+        try {
+            $this->getParser()->parse($content, Yaml::PARSE_CONSTANT | $flags);
+        } catch (ParseException $e) {
+            return ['file' => $file, 'line' => $e->getParsedLine(), 'valid' => false, 'message' => $e->getMessage()];
+        } finally {
+            restore_error_handler();
+        }
+
+        return ['file' => $file, 'valid' => true];
+    }
+
+    private function display(SymfonyStyle $io, array $files): int
+    {
+        return match ($this->format) {
+            'txt' => $this->displayTxt($io, $files),
+            'json' => $this->displayJson($io, $files),
+            'github' => $this->displayTxt($io, $files, true),
+            default => throw new InvalidArgumentException(\sprintf('Supported formats are "%s".', implode('", "', $this->getAvailableFormatOptions()))),
+        };
+    }
+
+    private function displayTxt(SymfonyStyle $io, array $filesInfo, bool $errorAsGithubAnnotations = false): int
+    {
+        $countFiles = \count($filesInfo);
+        $erroredFiles = 0;
+        $suggestTagOption = false;
+
+        if ($errorAsGithubAnnotations) {
+            $githubReporter = new GithubActionReporter($io);
+        }
+
+        foreach ($filesInfo as $info) {
+            if ($info['valid'] && $this->displayCorrectFiles) {
+                $io->comment('<info>OK</info>'.($info['file'] ? \sprintf(' in %s', $info['file']) : ''));
+            } elseif (!$info['valid']) {
+                ++$erroredFiles;
+                $io->text('<error> ERROR </error>'.($info['file'] ? \sprintf(' in %s', $info['file']) : ''));
+                $io->text(\sprintf('<error> >> %s</error>', $info['message']));
+
+                if (str_contains($info['message'], 'PARSE_CUSTOM_TAGS')) {
+                    $suggestTagOption = true;
+                }
+
+                if ($errorAsGithubAnnotations) {
+                    $githubReporter->error($info['message'], $info['file'] ?? 'php://stdin', $info['line']);
+                }
+            }
+        }
+
+        if (0 === $erroredFiles) {
+            $io->success(\sprintf('All %d YAML files contain valid syntax.', $countFiles));
+        } else {
+            $io->warning(\sprintf('%d YAML files have valid syntax and %d contain errors.%s', $countFiles - $erroredFiles, $erroredFiles, $suggestTagOption ? ' Use the --parse-tags option if you want parse custom tags.' : ''));
+        }
+
+        return min($erroredFiles, 1);
+    }
+
+    private function displayJson(SymfonyStyle $io, array $filesInfo): int
+    {
+        $errors = 0;
+
+        array_walk($filesInfo, function (&$v) use (&$errors) {
+            $v['file'] = (string) $v['file'];
+            if (!$v['valid']) {
+                ++$errors;
+            }
+
+            if (isset($v['message']) && str_contains($v['message'], 'PARSE_CUSTOM_TAGS')) {
+                $v['message'] .= ' Use the --parse-tags option if you want parse custom tags.';
+            }
+        });
+
+        $io->writeln(json_encode($filesInfo, \JSON_PRETTY_PRINT | \JSON_UNESCAPED_SLASHES));
+
+        return min($errors, 1);
+    }
+
+    private function getFiles(string $fileOrDirectory): iterable
+    {
+        if (is_file($fileOrDirectory)) {
+            yield new \SplFileInfo($fileOrDirectory);
+
+            return;
+        }
+
+        foreach ($this->getDirectoryIterator($fileOrDirectory) as $file) {
+            if (!\in_array($file->getExtension(), ['yml', 'yaml'])) {
+                continue;
+            }
+
+            yield $file;
+        }
+    }
+
+    private function getParser(): Parser
+    {
+        return $this->parser ??= new Parser();
+    }
+
+    private function getDirectoryIterator(string $directory): iterable
+    {
+        $default = fn ($directory) => new \RecursiveIteratorIterator(
+            new \RecursiveDirectoryIterator($directory, \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::FOLLOW_SYMLINKS),
+            \RecursiveIteratorIterator::LEAVES_ONLY
+        );
+
+        if (null !== $this->directoryIteratorProvider) {
+            return ($this->directoryIteratorProvider)($directory, $default);
+        }
+
+        return $default($directory);
+    }
+
+    private function isReadable(string $fileOrDirectory): bool
+    {
+        $default = is_readable(...);
+
+        if (null !== $this->isReadableProvider) {
+            return ($this->isReadableProvider)($fileOrDirectory, $default);
+        }
+
+        return $default($fileOrDirectory);
+    }
+
+    public function complete(CompletionInput $input, CompletionSuggestions $suggestions): void
+    {
+        if ($input->mustSuggestOptionValuesFor('format')) {
+            $suggestions->suggestValues($this->getAvailableFormatOptions());
+        }
+    }
+
+    /** @return string[] */
+    private function getAvailableFormatOptions(): array
+    {
+        return ['txt', 'json', 'github'];
+    }
+}

vendor/symfony/yaml/Dumper.php

@@ -0,0 +1,184 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml;
+
+use Symfony\Component\Yaml\Tag\TaggedValue;
+
+/**
+ * Dumper dumps PHP variables to YAML strings.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @final
+ */
+class Dumper
+{
+    /**
+     * @param int $indentation The amount of spaces to use for indentation of nested nodes
+     */
+    public function __construct(private int $indentation = 4)
+    {
+        if ($indentation < 1) {
+            throw new \InvalidArgumentException('The indentation must be greater than zero.');
+        }
+    }
+
+    /**
+     * Dumps a PHP value to YAML.
+     *
+     * @param mixed                     $input  The PHP value
+     * @param int                       $inline The level where you switch to inline YAML
+     * @param int                       $indent The level of indentation (used internally)
+     * @param int-mask-of<Yaml::DUMP_*> $flags  A bit field of Yaml::DUMP_* constants to customize the dumped YAML string
+     */
+    public function dump(mixed $input, int $inline = 0, int $indent = 0, int $flags = 0): string
+    {
+        if ($flags & Yaml::DUMP_NULL_AS_EMPTY && $flags & Yaml::DUMP_NULL_AS_TILDE) {
+            throw new \InvalidArgumentException('The Yaml::DUMP_NULL_AS_EMPTY and Yaml::DUMP_NULL_AS_TILDE flags cannot be used together.');
+        }
+
+        return $this->doDump($input, $inline, $indent, $flags);
+    }
+
+    private function doDump(mixed $input, int $inline = 0, int $indent = 0, int $flags = 0, int $nestingLevel = 0): string
+    {
+        $output = '';
+        $prefix = $indent ? str_repeat(' ', $indent) : '';
+        $dumpObjectAsInlineMap = true;
+
+        if (Yaml::DUMP_OBJECT_AS_MAP & $flags && ($input instanceof \ArrayObject || $input instanceof \stdClass)) {
+            $dumpObjectAsInlineMap = !(array) $input;
+        }
+
+        if ($inline <= 0 || (!\is_array($input) && !$input instanceof TaggedValue && $dumpObjectAsInlineMap) || !$input) {
+            $output .= $prefix.Inline::dump($input, $flags, 0 === $nestingLevel);
+        } elseif ($input instanceof TaggedValue) {
+            $output .= $this->dumpTaggedValue($input, $inline, $indent, $flags, $prefix, $nestingLevel);
+        } else {
+            $dumpAsMap = Inline::isHash($input);
+            $compactNestedMapping = Yaml::DUMP_COMPACT_NESTED_MAPPING & $flags && !$dumpAsMap;
+
+            foreach ($input as $key => $value) {
+                if ('' !== $output && "\n" !== $output[-1]) {
+                    $output .= "\n";
+                }
+
+                if (\is_int($key) && Yaml::DUMP_NUMERIC_KEY_AS_STRING & $flags) {
+                    $key = (string) $key;
+                }
+
+                if (Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK & $flags && \is_string($value) && str_contains($value, "\n") && !str_contains($value, "\r")) {
+                    $blockIndentationIndicator = $this->getBlockIndentationIndicator($value);
+
+                    if (isset($value[-2]) && "\n" === $value[-2] && "\n" === $value[-1]) {
+                        $blockChompingIndicator = '+';
+                    } elseif ("\n" === $value[-1]) {
+                        $blockChompingIndicator = '';
+                    } else {
+                        $blockChompingIndicator = '-';
+                    }
+
+                    $output .= \sprintf('%s%s%s |%s%s', $prefix, $dumpAsMap ? Inline::dump($key, $flags).':' : '-', '', $blockIndentationIndicator, $blockChompingIndicator);
+
+                    foreach (explode("\n", $value) as $row) {
+                        if ('' === $row) {
+                            $output .= "\n";
+                        } else {
+                            $output .= \sprintf("\n%s%s%s", $prefix, str_repeat(' ', $this->indentation), $row);
+                        }
+                    }
+
+                    continue;
+                }
+
+                if ($value instanceof TaggedValue) {
+                    $output .= \sprintf('%s%s !%s', $prefix, $dumpAsMap ? Inline::dump($key, $flags).':' : '-', $value->getTag());
+
+                    if (Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK & $flags && \is_string($value->getValue()) && str_contains($value->getValue(), "\n") && !str_contains($value->getValue(), "\r\n")) {
+                        $blockIndentationIndicator = $this->getBlockIndentationIndicator($value->getValue());
+                        $output .= \sprintf(' |%s', $blockIndentationIndicator);
+
+                        foreach (explode("\n", $value->getValue()) as $row) {
+                            $output .= \sprintf("\n%s%s%s", $prefix, str_repeat(' ', $this->indentation), $row);
+                        }
+
+                        continue;
+                    }
+
+                    if ($inline - 1 <= 0 || null === $value->getValue() || \is_scalar($value->getValue())) {
+                        $output .= ' '.$this->doDump($value->getValue(), $inline - 1, 0, $flags, $nestingLevel + 1)."\n";
+                    } else {
+                        $output .= "\n";
+                        $output .= $this->doDump($value->getValue(), $inline - 1, $dumpAsMap ? $indent + $this->indentation : $indent + 2, $flags, $nestingLevel + 1);
+                    }
+
+                    continue;
+                }
+
+                $dumpObjectAsInlineMap = true;
+
+                if (Yaml::DUMP_OBJECT_AS_MAP & $flags && ($value instanceof \ArrayObject || $value instanceof \stdClass)) {
+                    $dumpObjectAsInlineMap = !(array) $value;
+                }
+
+                $willBeInlined = $inline - 1 <= 0 || !\is_array($value) && $dumpObjectAsInlineMap || !$value;
+
+                $output .= \sprintf('%s%s%s%s',
+                    $prefix,
+                    $dumpAsMap ? Inline::dump($key, $flags).':' : '-',
+                    $willBeInlined || ($compactNestedMapping && \is_array($value) && Inline::isHash($value)) ? ' ' : "\n",
+                    $compactNestedMapping && \is_array($value) && Inline::isHash($value) ? substr($this->doDump($value, $inline - 1, $indent + 2, $flags, $nestingLevel + 1), $indent + 2) : $this->doDump($value, $inline - 1, $willBeInlined ? 0 : $indent + $this->indentation, $flags, $nestingLevel + 1)
+                ).($willBeInlined ? "\n" : '');
+            }
+        }
+
+        return $output;
+    }
+
+    private function dumpTaggedValue(TaggedValue $value, int $inline, int $indent, int $flags, string $prefix, int $nestingLevel): string
+    {
+        $output = \sprintf('%s!%s', $prefix ? $prefix.' ' : '', $value->getTag());
+
+        if (Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK & $flags && \is_string($value->getValue()) && str_contains($value->getValue(), "\n") && !str_contains($value->getValue(), "\r\n")) {
+            $blockIndentationIndicator = $this->getBlockIndentationIndicator($value->getValue());
+            $output .= \sprintf(' |%s', $blockIndentationIndicator);
+
+            foreach (explode("\n", $value->getValue()) as $row) {
+                $output .= \sprintf("\n%s%s%s", $prefix, str_repeat(' ', $this->indentation), $row);
+            }
+
+            return $output;
+        }
+
+        if ($inline - 1 <= 0 || null === $value->getValue() || \is_scalar($value->getValue())) {
+            return $output.' '.$this->doDump($value->getValue(), $inline - 1, 0, $flags, $nestingLevel + 1)."\n";
+        }
+
+        return $output."\n".$this->doDump($value->getValue(), $inline - 1, $indent, $flags, $nestingLevel + 1);
+    }
+
+    private function getBlockIndentationIndicator(string $value): string
+    {
+        $lines = explode("\n", $value);
+
+        // If the first line (that is neither empty nor contains only spaces)
+        // starts with a space character, the spec requires a block indentation indicator
+        // http://www.yaml.org/spec/1.2/spec.html#id2793979
+        foreach ($lines as $line) {
+            if ('' !== trim($line, ' ')) {
+                return str_starts_with($line, ' ') ? (string) $this->indentation : '';
+            }
+        }
+
+        return '';
+    }
+}

vendor/symfony/yaml/Escaper.php

@@ -0,0 +1,97 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml;
+
+/**
+ * Escaper encapsulates escaping rules for single and double-quoted
+ * YAML strings.
+ *
+ * @author Matthew Lewinski <matthew@lewinski.org>
+ *
+ * @internal
+ */
+class Escaper
+{
+    // Characters that would cause a dumped string to require double quoting.
+    public const REGEX_CHARACTER_TO_ESCAPE = "[\\x00-\\x1f]|\x7f|\xc2\x85|\xc2\xa0|\xe2\x80\xa8|\xe2\x80\xa9";
+
+    // Mapping arrays for escaping a double quoted string. The backslash is
+    // first to ensure proper escaping because str_replace operates iteratively
+    // on the input arrays. This ordering of the characters avoids the use of strtr,
+    // which performs more slowly.
+    private const ESCAPEES = [
+        '\\', '\\\\', '\\"', '"',
+        "\x00",  "\x01",  "\x02",  "\x03",  "\x04",  "\x05",  "\x06",  "\x07",
+        "\x08",  "\x09",  "\x0a",  "\x0b",  "\x0c",  "\x0d",  "\x0e",  "\x0f",
+        "\x10",  "\x11",  "\x12",  "\x13",  "\x14",  "\x15",  "\x16",  "\x17",
+        "\x18",  "\x19",  "\x1a",  "\x1b",  "\x1c",  "\x1d",  "\x1e",  "\x1f",
+        "\x7f",
+        "\xc2\x85", "\xc2\xa0", "\xe2\x80\xa8", "\xe2\x80\xa9",
+    ];
+    private const ESCAPED = [
+        '\\\\', '\\"', '\\\\', '\\"',
+        '\\0',   '\\x01', '\\x02', '\\x03', '\\x04', '\\x05', '\\x06', '\\a',
+        '\\b',   '\\t',   '\\n',   '\\v',   '\\f',   '\\r',   '\\x0e', '\\x0f',
+        '\\x10', '\\x11', '\\x12', '\\x13', '\\x14', '\\x15', '\\x16', '\\x17',
+        '\\x18', '\\x19', '\\x1a', '\\e',   '\\x1c', '\\x1d', '\\x1e', '\\x1f',
+        '\\x7f',
+        '\\N', '\\_', '\\L', '\\P',
+    ];
+
+    /**
+     * Determines if a PHP value would require double quoting in YAML.
+     *
+     * @param string $value A PHP value
+     */
+    public static function requiresDoubleQuoting(string $value): bool
+    {
+        return 0 < preg_match('/'.self::REGEX_CHARACTER_TO_ESCAPE.'/u', $value);
+    }
+
+    /**
+     * Escapes and surrounds a PHP value with double quotes.
+     *
+     * @param string $value A PHP value
+     */
+    public static function escapeWithDoubleQuotes(string $value): string
+    {
+        return \sprintf('"%s"', str_replace(self::ESCAPEES, self::ESCAPED, $value));
+    }
+
+    /**
+     * Determines if a PHP value would require single quoting in YAML.
+     *
+     * @param string $value A PHP value
+     */
+    public static function requiresSingleQuoting(string $value): bool
+    {
+        // Determines if a PHP value is entirely composed of a value that would
+        // require single quoting in YAML.
+        if (\in_array(strtolower($value), ['null', '~', 'true', 'false', 'y', 'n', 'yes', 'no', 'on', 'off'])) {
+            return true;
+        }
+
+        // Determines if the PHP value contains any single characters that would
+        // cause it to require single quoting in YAML.
+        return 0 < preg_match('/[\s\'"\:\{\}\[\],&\*\#\?] | \A[\-?|<>=!%@`\p{Zs}]/xu', $value);
+    }
+
+    /**
+     * Escapes and surrounds a PHP value with single quotes.
+     *
+     * @param string $value A PHP value
+     */
+    public static function escapeWithSingleQuotes(string $value): string
+    {
+        return \sprintf("'%s'", str_replace('\'', '\'\'', $value));
+    }
+}

vendor/symfony/yaml/Exception/DumpException.php

@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Exception;
+
+/**
+ * Exception class thrown when an error occurs during dumping.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class DumpException extends RuntimeException
+{
+}

vendor/symfony/yaml/Exception/ExceptionInterface.php

@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Exception;
+
+/**
+ * Exception interface for all exceptions thrown by the component.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+interface ExceptionInterface extends \Throwable
+{
+}

vendor/symfony/yaml/Exception/ParseException.php

@@ -0,0 +1,121 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Exception;
+
+/**
+ * Exception class thrown when an error occurs during parsing.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ParseException extends RuntimeException
+{
+    /**
+     * @param string      $rawMessage The error message
+     * @param int         $parsedLine The line where the error occurred
+     * @param string|null $snippet    The snippet of code near the problem
+     * @param string|null $parsedFile The file name where the error occurred
+     */
+    public function __construct(
+        private string $rawMessage,
+        private int $parsedLine = -1,
+        private ?string $snippet = null,
+        private ?string $parsedFile = null,
+        ?\Throwable $previous = null,
+    ) {
+        $this->updateRepr();
+
+        parent::__construct($this->message, 0, $previous);
+    }
+
+    /**
+     * Gets the snippet of code near the error.
+     */
+    public function getSnippet(): string
+    {
+        return $this->snippet;
+    }
+
+    /**
+     * Sets the snippet of code near the error.
+     */
+    public function setSnippet(string $snippet): void
+    {
+        $this->snippet = $snippet;
+
+        $this->updateRepr();
+    }
+
+    /**
+     * Gets the filename where the error occurred.
+     *
+     * This method returns null if a string is parsed.
+     */
+    public function getParsedFile(): string
+    {
+        return $this->parsedFile;
+    }
+
+    /**
+     * Sets the filename where the error occurred.
+     */
+    public function setParsedFile(string $parsedFile): void
+    {
+        $this->parsedFile = $parsedFile;
+
+        $this->updateRepr();
+    }
+
+    /**
+     * Gets the line where the error occurred.
+     */
+    public function getParsedLine(): int
+    {
+        return $this->parsedLine;
+    }
+
+    /**
+     * Sets the line where the error occurred.
+     */
+    public function setParsedLine(int $parsedLine): void
+    {
+        $this->parsedLine = $parsedLine;
+
+        $this->updateRepr();
+    }
+
+    private function updateRepr(): void
+    {
+        $this->message = $this->rawMessage;
+
+        $dot = false;
+        if (str_ends_with($this->message, '.')) {
+            $this->message = substr($this->message, 0, -1);
+            $dot = true;
+        }
+
+        if (null !== $this->parsedFile) {
+            $this->message .= \sprintf(' in %s', json_encode($this->parsedFile, \JSON_UNESCAPED_SLASHES | \JSON_UNESCAPED_UNICODE));
+        }
+
+        if ($this->parsedLine >= 0) {
+            $this->message .= \sprintf(' at line %d', $this->parsedLine);
+        }
+
+        if ($this->snippet) {
+            $this->message .= \sprintf(' (near "%s")', $this->snippet);
+        }
+
+        if ($dot) {
+            $this->message .= '.';
+        }
+    }
+}

vendor/symfony/yaml/Exception/RuntimeException.php

@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Exception;
+
+/**
+ * Exception class thrown when an error occurs during parsing.
+ *
+ * @author Romain Neutron <imprec@gmail.com>
+ */
+class RuntimeException extends \RuntimeException implements ExceptionInterface
+{
+}

vendor/symfony/yaml/Inline.php

@@ -0,0 +1,858 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml;
+
+use Symfony\Component\Yaml\Exception\DumpException;
+use Symfony\Component\Yaml\Exception\ParseException;
+use Symfony\Component\Yaml\Tag\TaggedValue;
+
+/**
+ * Inline implements a YAML parser/dumper for the YAML inline syntax.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class Inline
+{
+    public const REGEX_QUOTED_STRING = '(?:"([^"\\\\]*+(?:\\\\.[^"\\\\]*+)*+)"|\'([^\']*+(?:\'\'[^\']*+)*+)\')';
+
+    public static int $parsedLineNumber = -1;
+    public static ?string $parsedFilename = null;
+
+    private static bool $exceptionOnInvalidType = false;
+    private static bool $objectSupport = false;
+    private static bool $objectForMap = false;
+    private static bool $constantSupport = false;
+
+    public static function initialize(int $flags, ?int $parsedLineNumber = null, ?string $parsedFilename = null): void
+    {
+        self::$exceptionOnInvalidType = (bool) (Yaml::PARSE_EXCEPTION_ON_INVALID_TYPE & $flags);
+        self::$objectSupport = (bool) (Yaml::PARSE_OBJECT & $flags);
+        self::$objectForMap = (bool) (Yaml::PARSE_OBJECT_FOR_MAP & $flags);
+        self::$constantSupport = (bool) (Yaml::PARSE_CONSTANT & $flags);
+        self::$parsedFilename = $parsedFilename;
+
+        if (null !== $parsedLineNumber) {
+            self::$parsedLineNumber = $parsedLineNumber;
+        }
+    }
+
+    /**
+     * Converts a YAML string to a PHP value.
+     *
+     * @param int   $flags      A bit field of Yaml::PARSE_* constants to customize the YAML parser behavior
+     * @param array $references Mapping of variable names to values
+     *
+     * @throws ParseException
+     */
+    public static function parse(string $value, int $flags = 0, array &$references = []): mixed
+    {
+        self::initialize($flags);
+
+        $value = trim($value);
+
+        if ('' === $value) {
+            return '';
+        }
+
+        $i = 0;
+        $tag = self::parseTag($value, $i, $flags);
+        switch ($value[$i]) {
+            case '[':
+                $result = self::parseSequence($value, $flags, $i, $references);
+                ++$i;
+                break;
+            case '{':
+                $result = self::parseMapping($value, $flags, $i, $references);
+                ++$i;
+                break;
+            default:
+                $result = self::parseScalar($value, $flags, null, $i, true, $references);
+        }
+
+        // some comments are allowed at the end
+        if (preg_replace('/\s*#.*$/A', '', substr($value, $i))) {
+            throw new ParseException(\sprintf('Unexpected characters near "%s".', substr($value, $i)), self::$parsedLineNumber + 1, $value, self::$parsedFilename);
+        }
+
+        if (null !== $tag && '' !== $tag) {
+            return new TaggedValue($tag, $result);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Dumps a given PHP variable to a YAML string.
+     *
+     * @param mixed $value The PHP variable to convert
+     * @param int   $flags A bit field of Yaml::DUMP_* constants to customize the dumped YAML string
+     *
+     * @throws DumpException When trying to dump PHP resource
+     */
+    public static function dump(mixed $value, int $flags = 0, bool $rootLevel = false): string
+    {
+        switch (true) {
+            case \is_resource($value):
+                if (Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE & $flags) {
+                    throw new DumpException(\sprintf('Unable to dump PHP resources in a YAML file ("%s").', get_resource_type($value)));
+                }
+
+                return self::dumpNull($flags);
+            case $value instanceof \DateTimeInterface:
+                return $value->format(match (true) {
+                    !$length = \strlen(rtrim($value->format('u'), '0')) => 'c',
+                    $length < 4 => 'Y-m-d\TH:i:s.vP',
+                    default => 'Y-m-d\TH:i:s.uP',
+                });
+            case $value instanceof \UnitEnum:
+                return \sprintf('!php/enum %s::%s', $value::class, $value->name);
+            case \is_object($value):
+                if ($value instanceof TaggedValue) {
+                    return '!'.$value->getTag().' '.self::dump($value->getValue(), $flags);
+                }
+
+                if (Yaml::DUMP_OBJECT & $flags) {
+                    return '!php/object '.self::dump(serialize($value));
+                }
+
+                if (Yaml::DUMP_OBJECT_AS_MAP & $flags && ($value instanceof \stdClass || $value instanceof \ArrayObject)) {
+                    return self::dumpHashArray($value, $flags);
+                }
+
+                if (Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE & $flags) {
+                    throw new DumpException('Object support when dumping a YAML file has been disabled.');
+                }
+
+                return self::dumpNull($flags);
+            case \is_array($value):
+                return self::dumpArray($value, $flags);
+            case null === $value:
+                return self::dumpNull($flags, $rootLevel);
+            case true === $value:
+                return 'true';
+            case false === $value:
+                return 'false';
+            case \is_int($value):
+                return $value;
+            case is_numeric($value) && false === strpbrk($value, "\f\n\r\t\v"):
+                $locale = setlocale(\LC_NUMERIC, 0);
+                if (false !== $locale) {
+                    setlocale(\LC_NUMERIC, 'C');
+                }
+                if (\is_float($value)) {
+                    $repr = (string) $value;
+                    if (is_infinite($value)) {
+                        $repr = str_ireplace('INF', '.Inf', $repr);
+                    } elseif (floor($value) == $value && $repr == $value) {
+                        // Preserve float data type since storing a whole number will result in integer value.
+                        if (!str_contains($repr, 'E')) {
+                            $repr .= '.0';
+                        }
+                    }
+                } else {
+                    $repr = \is_string($value) ? "'$value'" : (string) $value;
+                }
+                if (false !== $locale) {
+                    setlocale(\LC_NUMERIC, $locale);
+                }
+
+                return $repr;
+            case '' == $value:
+                return "''";
+            case self::isBinaryString($value):
+                return '!!binary '.base64_encode($value);
+            case Escaper::requiresDoubleQuoting($value):
+            case Yaml::DUMP_FORCE_DOUBLE_QUOTES_ON_VALUES & $flags:
+                return Escaper::escapeWithDoubleQuotes($value);
+            case Escaper::requiresSingleQuoting($value):
+                $singleQuoted = Escaper::escapeWithSingleQuotes($value);
+                if (!str_contains($value, "'")) {
+                    return $singleQuoted;
+                }
+                // Attempt double-quoting the string instead to see if it's more efficient.
+                $doubleQuoted = Escaper::escapeWithDoubleQuotes($value);
+
+                return \strlen($doubleQuoted) < \strlen($singleQuoted) ? $doubleQuoted : $singleQuoted;
+            case Parser::preg_match('{^[0-9]+[_0-9]*$}', $value):
+            case Parser::preg_match(self::getHexRegex(), $value):
+            case Parser::preg_match(self::getTimestampRegex(), $value):
+                return Escaper::escapeWithSingleQuotes($value);
+            default:
+                return $value;
+        }
+    }
+
+    /**
+     * Check if given array is hash or just normal indexed array.
+     */
+    public static function isHash(array|\ArrayObject|\stdClass $value): bool
+    {
+        if ($value instanceof \stdClass || $value instanceof \ArrayObject) {
+            return true;
+        }
+
+        $expectedKey = 0;
+
+        foreach ($value as $key => $val) {
+            if ($key !== $expectedKey++) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Dumps a PHP array to a YAML string.
+     *
+     * @param array $value The PHP array to dump
+     * @param int   $flags A bit field of Yaml::DUMP_* constants to customize the dumped YAML string
+     */
+    private static function dumpArray(array $value, int $flags): string
+    {
+        // array
+        if (($value || Yaml::DUMP_EMPTY_ARRAY_AS_SEQUENCE & $flags) && !self::isHash($value)) {
+            $output = [];
+            foreach ($value as $val) {
+                $output[] = self::dump($val, $flags);
+            }
+
+            return \sprintf('[%s]', implode(', ', $output));
+        }
+
+        return self::dumpHashArray($value, $flags);
+    }
+
+    /**
+     * Dumps hash array to a YAML string.
+     *
+     * @param array|\ArrayObject|\stdClass $value The hash array to dump
+     * @param int                          $flags A bit field of Yaml::DUMP_* constants to customize the dumped YAML string
+     */
+    private static function dumpHashArray(array|\ArrayObject|\stdClass $value, int $flags): string
+    {
+        $output = [];
+        $keyFlags = $flags & ~Yaml::DUMP_FORCE_DOUBLE_QUOTES_ON_VALUES;
+        foreach ($value as $key => $val) {
+            if (\is_int($key) && Yaml::DUMP_NUMERIC_KEY_AS_STRING & $flags) {
+                $key = (string) $key;
+            }
+
+            $output[] = \sprintf('%s: %s', self::dump($key, $keyFlags), self::dump($val, $flags));
+        }
+
+        return \sprintf('{ %s }', implode(', ', $output));
+    }
+
+    private static function dumpNull(int $flags, bool $rootLevel = false): string
+    {
+        if (Yaml::DUMP_NULL_AS_TILDE & $flags) {
+            return '~';
+        }
+
+        if (Yaml::DUMP_NULL_AS_EMPTY & $flags && !$rootLevel) {
+            return '';
+        }
+
+        return 'null';
+    }
+
+    /**
+     * Parses a YAML scalar.
+     *
+     * @throws ParseException When malformed inline YAML string is parsed
+     */
+    public static function parseScalar(string $scalar, int $flags = 0, ?array $delimiters = null, int &$i = 0, bool $evaluate = true, array &$references = [], ?bool &$isQuoted = null): mixed
+    {
+        if (\in_array($scalar[$i], ['"', "'"], true)) {
+            // quoted scalar
+            $isQuoted = true;
+            $output = self::parseQuotedScalar($scalar, $i);
+
+            if (null !== $delimiters) {
+                $tmp = ltrim(substr($scalar, $i), " \n");
+                if ('' === $tmp) {
+                    throw new ParseException(\sprintf('Unexpected end of line, expected one of "%s".', implode('', $delimiters)), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+                }
+                if (!\in_array($tmp[0], $delimiters)) {
+                    throw new ParseException(\sprintf('Unexpected characters (%s).', substr($scalar, $i)), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+                }
+            }
+        } else {
+            // "normal" string
+            $isQuoted = false;
+
+            if (!$delimiters) {
+                $output = substr($scalar, $i);
+                $i += \strlen($output);
+
+                // remove comments
+                if (Parser::preg_match('/[ \t]+#/', $output, $match, \PREG_OFFSET_CAPTURE)) {
+                    $output = substr($output, 0, $match[0][1]);
+                }
+            } elseif (Parser::preg_match('/^(.*?)('.implode('|', $delimiters).')/', substr($scalar, $i), $match)) {
+                $output = $match[1];
+                $i += \strlen($output);
+                $output = trim($output);
+            } else {
+                throw new ParseException(\sprintf('Malformed inline YAML string: "%s".', $scalar), self::$parsedLineNumber + 1, null, self::$parsedFilename);
+            }
+
+            // a non-quoted string cannot start with @ or ` (reserved) nor with a scalar indicator (| or >)
+            if ($output && ('@' === $output[0] || '`' === $output[0] || '|' === $output[0] || '>' === $output[0] || '%' === $output[0])) {
+                throw new ParseException(\sprintf('The reserved indicator "%s" cannot start a plain scalar; you need to quote the scalar.', $output[0]), self::$parsedLineNumber + 1, $output, self::$parsedFilename);
+            }
+
+            if ($evaluate) {
+                $output = self::evaluateScalar($output, $flags, $references, $isQuoted);
+            }
+        }
+
+        return $output;
+    }
+
+    /**
+     * Parses a YAML quoted scalar.
+     *
+     * @throws ParseException When malformed inline YAML string is parsed
+     */
+    private static function parseQuotedScalar(string $scalar, int &$i = 0): string
+    {
+        if (!Parser::preg_match('/'.self::REGEX_QUOTED_STRING.'/Au', substr($scalar, $i), $match)) {
+            throw new ParseException(\sprintf('Malformed inline YAML string: "%s".', substr($scalar, $i)), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+        }
+
+        $output = substr($match[0], 1, -1);
+
+        $unescaper = new Unescaper();
+        if ('"' == $scalar[$i]) {
+            $output = $unescaper->unescapeDoubleQuotedString($output);
+        } else {
+            $output = $unescaper->unescapeSingleQuotedString($output);
+        }
+
+        $i += \strlen($match[0]);
+
+        return $output;
+    }
+
+    /**
+     * Parses a YAML sequence.
+     *
+     * @throws ParseException When malformed inline YAML string is parsed
+     */
+    private static function parseSequence(string $sequence, int $flags, int &$i = 0, array &$references = []): array
+    {
+        $output = [];
+        $len = \strlen($sequence);
+        ++$i;
+
+        // [foo, bar, ...]
+        $lastToken = null;
+        while ($i < $len) {
+            if (']' === $sequence[$i]) {
+                return $output;
+            }
+            if (',' === $sequence[$i] || ' ' === $sequence[$i]) {
+                if (',' === $sequence[$i] && (null === $lastToken || 'separator' === $lastToken)) {
+                    $output[] = null;
+                } elseif (',' === $sequence[$i]) {
+                    $lastToken = 'separator';
+                }
+
+                ++$i;
+
+                continue;
+            }
+
+            $tag = self::parseTag($sequence, $i, $flags);
+            switch ($sequence[$i]) {
+                case '[':
+                    // nested sequence
+                    $value = self::parseSequence($sequence, $flags, $i, $references);
+                    break;
+                case '{':
+                    // nested mapping
+                    $value = self::parseMapping($sequence, $flags, $i, $references);
+                    break;
+                default:
+                    $value = self::parseScalar($sequence, $flags, [',', ']'], $i, null === $tag, $references, $isQuoted);
+
+                    // the value can be an array if a reference has been resolved to an array var
+                    if (\is_string($value) && !$isQuoted && str_contains($value, ': ')) {
+                        // embedded mapping?
+                        try {
+                            $pos = 0;
+                            $value = self::parseMapping('{'.$value.'}', $flags, $pos, $references);
+                        } catch (\InvalidArgumentException) {
+                            // no, it's not
+                        }
+                    }
+
+                    if (!$isQuoted && \is_string($value) && '' !== $value && '&' === $value[0] && Parser::preg_match(Parser::REFERENCE_PATTERN, $value, $matches)) {
+                        $references[$matches['ref']] = $matches['value'];
+                        $value = $matches['value'];
+                    }
+
+                    --$i;
+            }
+
+            if (null !== $tag && '' !== $tag) {
+                $value = new TaggedValue($tag, $value);
+            }
+
+            $output[] = $value;
+
+            $lastToken = 'value';
+            ++$i;
+        }
+
+        throw new ParseException(\sprintf('Malformed inline YAML string: "%s".', $sequence), self::$parsedLineNumber + 1, null, self::$parsedFilename);
+    }
+
+    /**
+     * Parses a YAML mapping.
+     *
+     * @throws ParseException When malformed inline YAML string is parsed
+     */
+    private static function parseMapping(string $mapping, int $flags, int &$i = 0, array &$references = []): array|\stdClass
+    {
+        $output = [];
+        $len = \strlen($mapping);
+        ++$i;
+        $allowOverwrite = false;
+
+        // {foo: bar, bar:foo, ...}
+        while ($i < $len) {
+            switch ($mapping[$i]) {
+                case ' ':
+                case ',':
+                case "\n":
+                    ++$i;
+                    continue 2;
+                case '}':
+                    if (self::$objectForMap) {
+                        return (object) $output;
+                    }
+
+                    return $output;
+            }
+
+            // key
+            $offsetBeforeKeyParsing = $i;
+            $isKeyQuoted = \in_array($mapping[$i], ['"', "'"], true);
+            $key = self::parseScalar($mapping, $flags, [':', ' '], $i, false);
+
+            if ($offsetBeforeKeyParsing === $i) {
+                throw new ParseException('Missing mapping key.', self::$parsedLineNumber + 1, $mapping);
+            }
+
+            if ('!php/const' === $key || '!php/enum' === $key) {
+                $key .= ' '.self::parseScalar($mapping, $flags, ['(?<!:):(?!:)'], $i, false);
+                $key = self::evaluateScalar($key, $flags);
+            }
+
+            if (false === $i = strpos($mapping, ':', $i)) {
+                break;
+            }
+
+            if (!$isKeyQuoted) {
+                $evaluatedKey = self::evaluateScalar($key, $flags, $references);
+
+                if ('' !== $key && $evaluatedKey !== $key && !\is_string($evaluatedKey) && !\is_int($evaluatedKey)) {
+                    throw new ParseException('Implicit casting of incompatible mapping keys to strings is not supported. Quote your evaluable mapping keys instead.', self::$parsedLineNumber + 1, $mapping);
+                }
+            }
+
+            if (!$isKeyQuoted && (!isset($mapping[$i + 1]) || !\in_array($mapping[$i + 1], [' ', ',', '[', ']', '{', '}', "\n"], true))) {
+                throw new ParseException('Colons must be followed by a space or an indication character (i.e. " ", ",", "[", "]", "{", "}").', self::$parsedLineNumber + 1, $mapping);
+            }
+
+            if ('<<' === $key) {
+                $allowOverwrite = true;
+            }
+
+            while ($i < $len) {
+                if (':' === $mapping[$i] || ' ' === $mapping[$i] || "\n" === $mapping[$i]) {
+                    ++$i;
+
+                    continue;
+                }
+
+                $tag = self::parseTag($mapping, $i, $flags);
+                switch ($mapping[$i]) {
+                    case '[':
+                        // nested sequence
+                        $value = self::parseSequence($mapping, $flags, $i, $references);
+                        // Spec: Keys MUST be unique; first one wins.
+                        // Parser cannot abort this mapping earlier, since lines
+                        // are processed sequentially.
+                        // But overwriting is allowed when a merge node is used in current block.
+                        if ('<<' === $key) {
+                            foreach ($value as $parsedValue) {
+                                $output += $parsedValue;
+                            }
+                        } elseif ($allowOverwrite || !isset($output[$key])) {
+                            if (null !== $tag) {
+                                $output[$key] = new TaggedValue($tag, $value);
+                            } else {
+                                $output[$key] = $value;
+                            }
+                        } elseif (isset($output[$key])) {
+                            throw new ParseException(\sprintf('Duplicate key "%s" detected.', $key), self::$parsedLineNumber + 1, $mapping);
+                        }
+                        break;
+                    case '{':
+                        // nested mapping
+                        $value = self::parseMapping($mapping, $flags, $i, $references);
+                        // Spec: Keys MUST be unique; first one wins.
+                        // Parser cannot abort this mapping earlier, since lines
+                        // are processed sequentially.
+                        // But overwriting is allowed when a merge node is used in current block.
+                        if ('<<' === $key) {
+                            $output += $value;
+                        } elseif ($allowOverwrite || !isset($output[$key])) {
+                            if (null !== $tag) {
+                                $output[$key] = new TaggedValue($tag, $value);
+                            } else {
+                                $output[$key] = $value;
+                            }
+                        } elseif (isset($output[$key])) {
+                            throw new ParseException(\sprintf('Duplicate key "%s" detected.', $key), self::$parsedLineNumber + 1, $mapping);
+                        }
+                        break;
+                    default:
+                        $value = self::parseScalar($mapping, $flags, [',', '}', "\n"], $i, null === $tag, $references, $isValueQuoted);
+                        // Spec: Keys MUST be unique; first one wins.
+                        // Parser cannot abort this mapping earlier, since lines
+                        // are processed sequentially.
+                        // But overwriting is allowed when a merge node is used in current block.
+                        if ('<<' === $key) {
+                            $output += $value;
+                        } elseif ($allowOverwrite || !isset($output[$key])) {
+                            if (!$isValueQuoted && \is_string($value) && '' !== $value && '&' === $value[0] && !self::isBinaryString($value) && Parser::preg_match(Parser::REFERENCE_PATTERN, $value, $matches)) {
+                                $references[$matches['ref']] = $matches['value'];
+                                $value = $matches['value'];
+                            }
+
+                            if (null !== $tag) {
+                                $output[$key] = new TaggedValue($tag, $value);
+                            } else {
+                                $output[$key] = $value;
+                            }
+                        } elseif (isset($output[$key])) {
+                            throw new ParseException(\sprintf('Duplicate key "%s" detected.', $key), self::$parsedLineNumber + 1, $mapping);
+                        }
+                        --$i;
+                }
+                ++$i;
+
+                continue 2;
+            }
+        }
+
+        throw new ParseException(\sprintf('Malformed inline YAML string: "%s".', $mapping), self::$parsedLineNumber + 1, null, self::$parsedFilename);
+    }
+
+    /**
+     * Evaluates scalars and replaces magic values.
+     *
+     * @throws ParseException when object parsing support was disabled and the parser detected a PHP object or when a reference could not be resolved
+     */
+    private static function evaluateScalar(string $scalar, int $flags, array &$references = [], ?bool &$isQuotedString = null): mixed
+    {
+        $isQuotedString = false;
+        $scalar = trim($scalar);
+
+        if (str_starts_with($scalar, '*')) {
+            if (false !== $pos = strpos($scalar, '#')) {
+                $value = substr($scalar, 1, $pos - 2);
+            } else {
+                $value = substr($scalar, 1);
+            }
+
+            // an unquoted *
+            if ('' === $value) {
+                throw new ParseException('A reference must contain at least one character.', self::$parsedLineNumber + 1, $value, self::$parsedFilename);
+            }
+
+            if (!\array_key_exists($value, $references)) {
+                throw new ParseException(\sprintf('Reference "%s" does not exist.', $value), self::$parsedLineNumber + 1, $value, self::$parsedFilename);
+            }
+
+            return $references[$value];
+        }
+
+        $scalarLower = strtolower($scalar);
+
+        switch (true) {
+            case 'null' === $scalarLower:
+            case '' === $scalar:
+            case '~' === $scalar:
+                return null;
+            case 'true' === $scalarLower:
+                return true;
+            case 'false' === $scalarLower:
+                return false;
+            case '!' === $scalar[0]:
+                switch (true) {
+                    case str_starts_with($scalar, '!!str '):
+                        $s = substr($scalar, 6);
+
+                        if (\in_array($s[0] ?? '', ['"', "'"], true)) {
+                            $isQuotedString = true;
+                            $s = self::parseQuotedScalar($s);
+                        }
+
+                        return $s;
+                    case str_starts_with($scalar, '! '):
+                        return substr($scalar, 2);
+                    case str_starts_with($scalar, '!php/object'):
+                        if (self::$objectSupport) {
+                            if (!isset($scalar[12])) {
+                                throw new ParseException('Missing value for tag "!php/object".', self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+                            }
+
+                            return unserialize(self::parseScalar(substr($scalar, 12)));
+                        }
+
+                        if (self::$exceptionOnInvalidType) {
+                            throw new ParseException('Object support when parsing a YAML file has been disabled.', self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+                        }
+
+                        return null;
+                    case str_starts_with($scalar, '!php/const'):
+                        if (self::$constantSupport) {
+                            if (!isset($scalar[11])) {
+                                throw new ParseException('Missing value for tag "!php/const".', self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+                            }
+
+                            $i = 0;
+                            if (\defined($const = self::parseScalar(substr($scalar, 11), 0, null, $i, false))) {
+                                return \constant($const);
+                            }
+
+                            throw new ParseException(\sprintf('The constant "%s" is not defined.', $const), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+                        }
+                        if (self::$exceptionOnInvalidType) {
+                            throw new ParseException(\sprintf('The string "%s" could not be parsed as a constant. Did you forget to pass the "Yaml::PARSE_CONSTANT" flag to the parser?', $scalar), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+                        }
+
+                        return null;
+                    case str_starts_with($scalar, '!php/enum'):
+                        if (self::$constantSupport) {
+                            if (!isset($scalar[11])) {
+                                throw new ParseException('Missing value for tag "!php/enum".', self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+                            }
+
+                            $i = 0;
+                            $enumName = self::parseScalar(substr($scalar, 10), 0, null, $i, false);
+                            $useName = str_contains($enumName, '::');
+                            $enum = $useName ? strstr($enumName, '::', true) : $enumName;
+
+                            if (!enum_exists($enum)) {
+                                throw new ParseException(\sprintf('The enum "%s" is not defined.', $enum), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+                            }
+                            if (!$useName) {
+                                return $enum::cases();
+                            }
+                            if ($useValue = str_ends_with($enumName, '->value')) {
+                                $enumName = substr($enumName, 0, -7);
+                            }
+
+                            if (!\defined($enumName)) {
+                                throw new ParseException(\sprintf('The string "%s" is not the name of a valid enum.', $enumName), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+                            }
+
+                            $value = \constant($enumName);
+
+                            if (!$useValue) {
+                                return $value;
+                            }
+                            if (!$value instanceof \BackedEnum) {
+                                throw new ParseException(\sprintf('The enum "%s" defines no value next to its name.', $enumName), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+                            }
+
+                            return $value->value;
+                        }
+                        if (self::$exceptionOnInvalidType) {
+                            throw new ParseException(\sprintf('The string "%s" could not be parsed as an enum. Did you forget to pass the "Yaml::PARSE_CONSTANT" flag to the parser?', $scalar), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+                        }
+
+                        return null;
+                    case str_starts_with($scalar, '!!float '):
+                        return (float) substr($scalar, 8);
+                    case str_starts_with($scalar, '!!binary '):
+                        return self::evaluateBinaryScalar(substr($scalar, 9));
+                }
+
+                throw new ParseException(\sprintf('The string "%s" could not be parsed as it uses an unsupported built-in tag.', $scalar), self::$parsedLineNumber, $scalar, self::$parsedFilename);
+            case preg_match('/^(?:\+|-)?0o(?P<value>[0-7_]++)$/', $scalar, $matches):
+                $value = str_replace('_', '', $matches['value']);
+
+                if ('-' === $scalar[0]) {
+                    return -octdec($value);
+                }
+
+                return octdec($value);
+            case \in_array($scalar[0], ['+', '-', '.'], true) || is_numeric($scalar[0]):
+                if (Parser::preg_match('{^[+-]?[0-9][0-9_]*$}', $scalar)) {
+                    $scalar = str_replace('_', '', $scalar);
+                }
+
+                switch (true) {
+                    case ctype_digit($scalar):
+                    case '-' === $scalar[0] && ctype_digit(substr($scalar, 1)):
+                        if ($scalar < \PHP_INT_MIN || \PHP_INT_MAX < $scalar) {
+                            return $scalar;
+                        }
+
+                        $cast = (int) $scalar;
+
+                        return ($scalar === (string) $cast) ? $cast : $scalar;
+                    case is_numeric($scalar):
+                    case Parser::preg_match(self::getHexRegex(), $scalar):
+                        $scalar = str_replace('_', '', $scalar);
+
+                        return '0x' === $scalar[0].$scalar[1] ? hexdec($scalar) : (float) $scalar;
+                    case '.inf' === $scalarLower:
+                    case '.nan' === $scalarLower:
+                        return -log(0);
+                    case '-.inf' === $scalarLower:
+                        return log(0);
+                    case Parser::preg_match('/^(-|\+)?[0-9][0-9_]*(\.[0-9_]+)?$/', $scalar):
+                        return (float) str_replace('_', '', $scalar);
+                    case Parser::preg_match(self::getTimestampRegex(), $scalar):
+                        try {
+                            // When no timezone is provided in the parsed date, YAML spec says we must assume UTC.
+                            $time = new \DateTimeImmutable($scalar, new \DateTimeZone('UTC'));
+                        } catch (\Exception $e) {
+                            // Some dates accepted by the regex are not valid dates.
+                            throw new ParseException(\sprintf('The date "%s" could not be parsed as it is an invalid date.', $scalar), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename, $e);
+                        }
+
+                        if (Yaml::PARSE_DATETIME & $flags) {
+                            return $time;
+                        }
+
+                        if ('' !== rtrim($time->format('u'), '0')) {
+                            return (float) $time->format('U.u');
+                        }
+
+                        try {
+                            if (false !== $scalar = $time->getTimestamp()) {
+                                return $scalar;
+                            }
+                        } catch (\DateRangeError|\ValueError) {
+                            // no-op
+                        }
+
+                        return $time->format('U');
+                }
+        }
+
+        return (string) $scalar;
+    }
+
+    private static function parseTag(string $value, int &$i, int $flags): ?string
+    {
+        if ('!' !== $value[$i]) {
+            return null;
+        }
+
+        $tagLength = strcspn($value, " \t\n[]{},", $i + 1);
+        $tag = substr($value, $i + 1, $tagLength);
+
+        $nextOffset = $i + $tagLength + 1;
+        $nextOffset += strspn($value, ' ', $nextOffset);
+
+        if ('' === $tag && (!isset($value[$nextOffset]) || \in_array($value[$nextOffset], [']', '}', ','], true))) {
+            throw new ParseException('Using the unquoted scalar value "!" is not supported. You must quote it.', self::$parsedLineNumber + 1, $value, self::$parsedFilename);
+        }
+
+        // Is followed by a scalar and is a built-in tag
+        if ('' !== $tag && (!isset($value[$nextOffset]) || !\in_array($value[$nextOffset], ['[', '{'], true)) && ('!' === $tag[0] || \in_array($tag, ['str', 'php/const', 'php/enum', 'php/object'], true))) {
+            // Manage in {@link self::evaluateScalar()}
+            return null;
+        }
+
+        $i = $nextOffset;
+
+        // Built-in tags
+        if ('' !== $tag && '!' === $tag[0]) {
+            throw new ParseException(\sprintf('The built-in tag "!%s" is not implemented.', $tag), self::$parsedLineNumber + 1, $value, self::$parsedFilename);
+        }
+
+        if ('' !== $tag && !isset($value[$i])) {
+            throw new ParseException(\sprintf('Missing value for tag "%s".', $tag), self::$parsedLineNumber + 1, $value, self::$parsedFilename);
+        }
+
+        if ('' === $tag || Yaml::PARSE_CUSTOM_TAGS & $flags) {
+            return $tag;
+        }
+
+        throw new ParseException(\sprintf('Tags support is not enabled. Enable the "Yaml::PARSE_CUSTOM_TAGS" flag to use "!%s".', $tag), self::$parsedLineNumber + 1, $value, self::$parsedFilename);
+    }
+
+    public static function evaluateBinaryScalar(string $scalar): string
+    {
+        $parsedBinaryData = self::parseScalar(preg_replace('/\s/', '', $scalar));
+
+        if (0 !== (\strlen($parsedBinaryData) % 4)) {
+            throw new ParseException(\sprintf('The normalized base64 encoded data (data without whitespace characters) length must be a multiple of four (%d bytes given).', \strlen($parsedBinaryData)), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+        }
+
+        if (!Parser::preg_match('#^[A-Z0-9+/]+={0,2}$#i', $parsedBinaryData)) {
+            throw new ParseException(\sprintf('The base64 encoded data (%s) contains invalid characters.', $parsedBinaryData), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
+        }
+
+        return base64_decode($parsedBinaryData, true);
+    }
+
+    private static function isBinaryString(string $value): bool
+    {
+        return !preg_match('//u', $value) || preg_match('/[^\x00\x07-\x0d\x1B\x20-\xff]/', $value);
+    }
+
+    /**
+     * Gets a regex that matches a YAML date.
+     *
+     * @see http://www.yaml.org/spec/1.2/spec.html#id2761573
+     */
+    private static function getTimestampRegex(): string
+    {
+        return <<<EOF
+        ~^
+        (?P<year>[0-9][0-9][0-9][0-9])
+        -(?P<month>[0-9][0-9]?)
+        -(?P<day>[0-9][0-9]?)
+        (?:(?:[Tt]|[ \t]+)
+        (?P<hour>[0-9][0-9]?)
+        :(?P<minute>[0-9][0-9])
+        :(?P<second>[0-9][0-9])
+        (?:\.(?P<fraction>[0-9]*))?
+        (?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?)
+        (?::(?P<tz_minute>[0-9][0-9]))?))?)?
+        $~x
+EOF;
+    }
+
+    /**
+     * Gets a regex that matches a YAML number in hexadecimal notation.
+     */
+    private static function getHexRegex(): string
+    {
+        return '~^0x[0-9a-f_]++$~i';
+    }
+}

vendor/symfony/yaml/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2004-present Fabien Potencier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/symfony/yaml/README.md

@@ -0,0 +1,13 @@
+Yaml Component
+==============
+
+The Yaml component loads and dumps YAML files.
+
+Resources
+---------
+
+ * [Documentation](https://symfony.com/doc/current/components/yaml.html)
+ * [Contributing](https://symfony.com/doc/current/contributing/index.html)
+ * [Report issues](https://github.com/symfony/symfony/issues) and
+   [send Pull Requests](https://github.com/symfony/symfony/pulls)
+   in the [main Symfony repository](https://github.com/symfony/symfony)

vendor/symfony/yaml/Resources/bin/yaml-lint

@@ -0,0 +1,49 @@
+#!/usr/bin/env php
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+if ('cli' !== \PHP_SAPI) {
+    throw new Exception('This script must be run from the command line.');
+}
+
+/**
+ * Runs the Yaml lint command.
+ *
+ * @author Jan Schädlich <jan.schaedlich@sensiolabs.de>
+ */
+
+use Symfony\Component\Console\Application;
+use Symfony\Component\Yaml\Command\LintCommand;
+
+function includeIfExists(string $file): bool
+{
+    return file_exists($file) && include $file;
+}
+
+if (
+    !includeIfExists(__DIR__ . '/../../../../autoload.php') &&
+    !includeIfExists(__DIR__ . '/../../vendor/autoload.php') &&
+    !includeIfExists(__DIR__ . '/../../../../../../vendor/autoload.php')
+) {
+    fwrite(STDERR, 'Install dependencies using Composer.'.PHP_EOL);
+    exit(1);
+}
+
+if (!class_exists(Application::class)) {
+    fwrite(STDERR, 'You need the "symfony/console" component in order to run the Yaml linter.'.PHP_EOL);
+    exit(1);
+}
+
+(new Application())->add($command = new LintCommand())
+    ->getApplication()
+    ->setDefaultCommand($command->getName(), true)
+    ->run()
+;

vendor/symfony/yaml/Tag/TaggedValue.php

@@ -0,0 +1,35 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Tag;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ * @author Guilhem N. <egetick@gmail.com>
+ */
+final class TaggedValue
+{
+    public function __construct(
+        private string $tag,
+        private mixed $value,
+    ) {
+    }
+
+    public function getTag(): string
+    {
+        return $this->tag;
+    }
+
+    public function getValue(): mixed
+    {
+        return $this->value;
+    }
+}

vendor/symfony/yaml/Unescaper.php

@@ -0,0 +1,108 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml;
+
+use Symfony\Component\Yaml\Exception\ParseException;
+
+/**
+ * Unescaper encapsulates unescaping rules for single and double-quoted
+ * YAML strings.
+ *
+ * @author Matthew Lewinski <matthew@lewinski.org>
+ *
+ * @internal
+ */
+class Unescaper
+{
+    /**
+     * Regex fragment that matches an escaped character in a double quoted string.
+     */
+    public const REGEX_ESCAPED_CHARACTER = '\\\\(x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|.)';
+
+    /**
+     * Unescapes a single quoted string.
+     *
+     * @param string $value A single quoted string
+     */
+    public function unescapeSingleQuotedString(string $value): string
+    {
+        return str_replace('\'\'', '\'', $value);
+    }
+
+    /**
+     * Unescapes a double quoted string.
+     *
+     * @param string $value A double quoted string
+     */
+    public function unescapeDoubleQuotedString(string $value): string
+    {
+        $callback = fn ($match) => $this->unescapeCharacter($match[0]);
+
+        // evaluate the string
+        return preg_replace_callback('/'.self::REGEX_ESCAPED_CHARACTER.'/u', $callback, $value);
+    }
+
+    /**
+     * Unescapes a character that was found in a double-quoted string.
+     *
+     * @param string $value An escaped character
+     */
+    private function unescapeCharacter(string $value): string
+    {
+        return match ($value[1]) {
+            '0' => "\x0",
+            'a' => "\x7",
+            'b' => "\x8",
+            't' => "\t",
+            "\t" => "\t",
+            'n' => "\n",
+            'v' => "\xB",
+            'f' => "\xC",
+            'r' => "\r",
+            'e' => "\x1B",
+            ' ' => ' ',
+            '"' => '"',
+            '/' => '/',
+            '\\' => '\\',
+            // U+0085 NEXT LINE
+            'N' => "\xC2\x85",
+            // U+00A0 NO-BREAK SPACE
+            '_' => "\xC2\xA0",
+            // U+2028 LINE SEPARATOR
+            'L' => "\xE2\x80\xA8",
+            // U+2029 PARAGRAPH SEPARATOR
+            'P' => "\xE2\x80\xA9",
+            'x' => self::utf8chr(hexdec(substr($value, 2, 2))),
+            'u' => self::utf8chr(hexdec(substr($value, 2, 4))),
+            'U' => self::utf8chr(hexdec(substr($value, 2, 8))),
+            default => throw new ParseException(\sprintf('Found unknown escape character "%s".', $value)),
+        };
+    }
+
+    /**
+     * Get the UTF-8 character for the given code point.
+     */
+    private static function utf8chr(int $c): string
+    {
+        if (0x80 > $c %= 0x200000) {
+            return \chr($c);
+        }
+        if (0x800 > $c) {
+            return \chr(0xC0 | $c >> 6).\chr(0x80 | $c & 0x3F);
+        }
+        if (0x10000 > $c) {
+            return \chr(0xE0 | $c >> 12).\chr(0x80 | $c >> 6 & 0x3F).\chr(0x80 | $c & 0x3F);
+        }
+
+        return \chr(0xF0 | $c >> 18).\chr(0x80 | $c >> 12 & 0x3F).\chr(0x80 | $c >> 6 & 0x3F).\chr(0x80 | $c & 0x3F);
+    }
+}

vendor/symfony/yaml/Yaml.php

@@ -0,0 +1,100 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml;
+
+use Symfony\Component\Yaml\Exception\ParseException;
+
+/**
+ * Yaml offers convenience methods to load and dump YAML.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @final
+ */
+class Yaml
+{
+    public const DUMP_OBJECT = 1;
+    public const PARSE_EXCEPTION_ON_INVALID_TYPE = 2;
+    public const PARSE_OBJECT = 4;
+    public const PARSE_OBJECT_FOR_MAP = 8;
+    public const DUMP_EXCEPTION_ON_INVALID_TYPE = 16;
+    public const PARSE_DATETIME = 32;
+    public const DUMP_OBJECT_AS_MAP = 64;
+    public const DUMP_MULTI_LINE_LITERAL_BLOCK = 128;
+    public const PARSE_CONSTANT = 256;
+    public const PARSE_CUSTOM_TAGS = 512;
+    public const DUMP_EMPTY_ARRAY_AS_SEQUENCE = 1024;
+    public const DUMP_NULL_AS_TILDE = 2048;
+    public const DUMP_NUMERIC_KEY_AS_STRING = 4096;
+    public const DUMP_NULL_AS_EMPTY = 8192;
+    public const DUMP_COMPACT_NESTED_MAPPING = 16384;
+    public const DUMP_FORCE_DOUBLE_QUOTES_ON_VALUES = 32768;
+
+    /**
+     * Parses a YAML file into a PHP value.
+     *
+     * Usage:
+     *
+     *     $array = Yaml::parseFile('config.yml');
+     *     print_r($array);
+     *
+     * @param string                     $filename The path to the YAML file to be parsed
+     * @param int-mask-of<self::PARSE_*> $flags    A bit field of PARSE_* constants to customize the YAML parser behavior
+     *
+     * @throws ParseException If the file could not be read or the YAML is not valid
+     */
+    public static function parseFile(string $filename, int $flags = 0): mixed
+    {
+        $yaml = new Parser();
+
+        return $yaml->parseFile($filename, $flags);
+    }
+
+    /**
+     * Parses YAML into a PHP value.
+     *
+     *  Usage:
+     *  <code>
+     *   $array = Yaml::parse(file_get_contents('config.yml'));
+     *   print_r($array);
+     *  </code>
+     *
+     * @param string                     $input A string containing YAML
+     * @param int-mask-of<self::PARSE_*> $flags A bit field of PARSE_* constants to customize the YAML parser behavior
+     *
+     * @throws ParseException If the YAML is not valid
+     */
+    public static function parse(string $input, int $flags = 0): mixed
+    {
+        $yaml = new Parser();
+
+        return $yaml->parse($input, $flags);
+    }
+
+    /**
+     * Dumps a PHP value to a YAML string.
+     *
+     * The dump method, when supplied with an array, will do its best
+     * to convert the array into friendly YAML.
+     *
+     * @param mixed                     $input  The PHP value
+     * @param int                       $inline The level where you switch to inline YAML
+     * @param int                       $indent The amount of spaces to use for indentation of nested nodes
+     * @param int-mask-of<self::DUMP_*> $flags  A bit field of DUMP_* constants to customize the dumped YAML string
+     */
+    public static function dump(mixed $input, int $inline = 2, int $indent = 4, int $flags = 0): string
+    {
+        $yaml = new Dumper($indent);
+
+        return $yaml->dump($input, $inline, 0, $flags);
+    }
+}

vendor/symfony/yaml/composer.json

@@ -0,0 +1,39 @@
+{
+    "name": "symfony/yaml",
+    "type": "library",
+    "description": "Loads and dumps YAML files",
+    "keywords": [],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Fabien Potencier",
+            "email": "fabien@symfony.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=8.2",
+        "symfony/deprecation-contracts": "^2.5|^3.0",
+        "symfony/polyfill-ctype": "^1.8"
+    },
+    "require-dev": {
+        "symfony/console": "^6.4|^7.0"
+    },
+    "conflict": {
+        "symfony/console": "<6.4"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Component\\Yaml\\": "" },
+        "exclude-from-classmap": [
+            "/Tests/"
+        ]
+    },
+    "bin": [
+        "Resources/bin/yaml-lint"
+    ],
+    "minimum-stability": "dev"
+}