<h2>File Contents: /home/planet5/public_html/wp-content/plugins/cloudflare/vendor/symfony/polyfill-intl-idn/Idn.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/wp-content/plugins/cloudflare/vendor/symfony/polyfill-intl-idn/Idn.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt; and Trevor Rowbotham &lt;trevor.rowbotham@pm.me&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace Cloudflare\APO\Vendor\Symfony\Polyfill\Intl\Idn;

use Cloudflare\APO\Vendor\Symfony\Polyfill\Intl\Idn\Resources\unidata\DisallowedRanges;
use Cloudflare\APO\Vendor\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 = &#039;-&#039;;
    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&lt;int, int&gt;
     */
    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&lt;int, int&gt;
     */
    private static $virama;
    /**
     * @var array&lt;int, string&gt;
     */
    private static $mapped;
    /**
     * @var array&lt;int, bool&gt;
     */
    private static $ignored;
    /**
     * @var array&lt;int, string&gt;
     */
    private static $deviation;
    /**
     * @var array&lt;int, bool&gt;
     */
    private static $disallowed;
    /**
     * @var array&lt;int, string&gt;
     */
    private static $disallowed_STD3_mapped;
    /**
     * @var array&lt;int, bool&gt;
     */
    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, &amp;$idna_info = [])
    {
        if (\PHP_VERSION_ID &gt; 80400 &amp;&amp; &#039;&#039; === $domainName) {
            throw new \ValueError(&#039;idn_to_ascii(): Argument #1 ($domain) cannot be empty&#039;);
        }
        if (self::INTL_IDNA_VARIANT_2003 === $variant) {
            @trigger_error(&#039;idn_to_ascii(): INTL_IDNA_VARIANT_2003 is deprecated&#039;, \E_USER_DEPRECATED);
        }
        $options = [&#039;CheckHyphens&#039; =&gt; \true, &#039;CheckBidi&#039; =&gt; self::INTL_IDNA_VARIANT_2003 === $variant || 0 !== ($options &amp; self::IDNA_CHECK_BIDI), &#039;CheckJoiners&#039; =&gt; self::INTL_IDNA_VARIANT_UTS46 === $variant &amp;&amp; 0 !== ($options &amp; self::IDNA_CHECK_CONTEXTJ), &#039;UseSTD3ASCIIRules&#039; =&gt; 0 !== ($options &amp; self::IDNA_USE_STD3_RULES), &#039;Transitional_Processing&#039; =&gt; self::INTL_IDNA_VARIANT_2003 === $variant || 0 === ($options &amp; self::IDNA_NONTRANSITIONAL_TO_ASCII), &#039;VerifyDnsLength&#039; =&gt; \true];
        $info = new Info();
        $labels = self::process((string) $domainName, $options, $info);
        foreach ($labels as $i =&gt; $label) {
            // Only convert labels to punycode that contain non-ASCII code points
            if (1 === preg_match(&#039;/[^\x00-\x7F]/&#039;, $label)) {
                try {
                    $label = &#039;xn--&#039; . self::punycodeEncode($label);
                } catch (\Exception $e) {
                    $info-&gt;errors |= self::ERROR_PUNYCODE;
                }
                $labels[$i] = $label;
            }
        }
        if ($options[&#039;VerifyDnsLength&#039;]) {
            self::validateDomainAndLabelLength($labels, $info);
        }
        $idna_info = [&#039;result&#039; =&gt; implode(&#039;.&#039;, $labels), &#039;isTransitionalDifferent&#039; =&gt; $info-&gt;transitionalDifferent, &#039;errors&#039; =&gt; $info-&gt;errors];
        return 0 === $info-&gt;errors ? $idna_info[&#039;result&#039;] : \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, &amp;$idna_info = [])
    {
        if (\PHP_VERSION_ID &gt; 80400 &amp;&amp; &#039;&#039; === $domainName) {
            throw new \ValueError(&#039;idn_to_utf8(): Argument #1 ($domain) cannot be empty&#039;);
        }
        if (self::INTL_IDNA_VARIANT_2003 === $variant) {
            @trigger_error(&#039;idn_to_utf8(): INTL_IDNA_VARIANT_2003 is deprecated&#039;, \E_USER_DEPRECATED);
        }
        $info = new Info();
        $labels = self::process((string) $domainName, [&#039;CheckHyphens&#039; =&gt; \true, &#039;CheckBidi&#039; =&gt; self::INTL_IDNA_VARIANT_2003 === $variant || 0 !== ($options &amp; self::IDNA_CHECK_BIDI), &#039;CheckJoiners&#039; =&gt; self::INTL_IDNA_VARIANT_UTS46 === $variant &amp;&amp; 0 !== ($options &amp; self::IDNA_CHECK_CONTEXTJ), &#039;UseSTD3ASCIIRules&#039; =&gt; 0 !== ($options &amp; self::IDNA_USE_STD3_RULES), &#039;Transitional_Processing&#039; =&gt; self::INTL_IDNA_VARIANT_2003 === $variant || 0 === ($options &amp; self::IDNA_NONTRANSITIONAL_TO_UNICODE)], $info);
        $idna_info = [&#039;result&#039; =&gt; implode(&#039;.&#039;, $labels), &#039;isTransitionalDifferent&#039; =&gt; $info-&gt;transitionalDifferent, &#039;errors&#039; =&gt; $info-&gt;errors];
        return 0 === $info-&gt;errors ? $idna_info[&#039;result&#039;] : \false;
    }
    /**
     * @param string $label
     *
     * @return bool
     */
    private static function isValidContextJ(array $codePoints, $label)
    {
        if (!isset(self::$virama)) {
            self::$virama = require __DIR__ . \DIRECTORY_SEPARATOR . &#039;Resources&#039; . \DIRECTORY_SEPARATOR . &#039;unidata&#039; . \DIRECTORY_SEPARATOR . &#039;virama.php&#039;;
        }
        $offset = 0;
        foreach ($codePoints as $i =&gt; $codePoint) {
            if (0x200c !== $codePoint &amp;&amp; 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 &amp;&amp; 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&lt;string, bool&gt; $options
     *
     * @return string
     */
    private static function mapCodePoints($input, array $options, Info $info)
    {
        $str = &#039;&#039;;
        $useSTD3ASCIIRules = $options[&#039;UseSTD3ASCIIRules&#039;];
        $transitional = $options[&#039;Transitional_Processing&#039;];
        foreach (self::utf8Decode($input) as $codePoint) {
            $data = self::lookupCodePointStatus($codePoint, $useSTD3ASCIIRules);
            switch ($data[&#039;status&#039;]) {
                case &#039;disallowed&#039;:
                case &#039;valid&#039;:
                    $str .= mb_chr($codePoint, &#039;utf-8&#039;);
                    break;
                case &#039;ignored&#039;:
                    // Do nothing.
                    break;
                case &#039;mapped&#039;:
                    $str .= $transitional &amp;&amp; 0x1e9e === $codePoint ? &#039;ss&#039; : $data[&#039;mapping&#039;];
                    break;
                case &#039;deviation&#039;:
                    $info-&gt;transitionalDifferent = \true;
                    $str .= $transitional ? $data[&#039;mapping&#039;] : mb_chr($codePoint, &#039;utf-8&#039;);
                    break;
            }
        }
        return $str;
    }
    /**
     * @see https://www.unicode.org/reports/tr46/#Processing
     *
     * @param string              $domain
     * @param array&lt;string, bool&gt; $options
     *
     * @return array&lt;int, string&gt;
     */
    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[&#039;VerifyDnsLength&#039;]) || $options[&#039;VerifyDnsLength&#039;];
        if ($checkForEmptyLabels &amp;&amp; &#039;&#039; === $domain) {
            $info-&gt;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 (!\Cloudflare\APO\Vendor\Symfony\Polyfill\Intl\Normalizer\Normalizer::isNormalized($domain, \Cloudflare\APO\Vendor\Symfony\Polyfill\Intl\Normalizer\Normalizer::FORM_C)) {
            $domain = \Cloudflare\APO\Vendor\Symfony\Polyfill\Intl\Normalizer\Normalizer::normalize($domain, \Cloudflare\APO\Vendor\Symfony\Polyfill\Intl\Normalizer\Normalizer::FORM_C);
        }
        // Step 3. Break the string into labels at U+002E (.) FULL STOP.
        $labels = explode(&#039;.&#039;, $domain);
        $lastLabelIndex = \count($labels) - 1;
        // Step 4. Convert and validate each label in the domain name string.
        foreach ($labels as $i =&gt; $label) {
            $validationOptions = $options;
            if (&#039;xn--&#039; === 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(&#039;/[^\x00-\x7F]/&#039;, $label)) {
                    $info-&gt;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. Per UTS #46 revision 33, if the conversion succeeds but the result is empty or
                // contains only ASCII code points, record that there was an error and continue with the next label.
                try {
                    $label = self::punycodeDecode(substr($label, 4));
                } catch (\Exception $e) {
                    $info-&gt;errors |= self::ERROR_PUNYCODE;
                    continue;
                }
                if (&#039;&#039; === $label || 1 !== preg_match(&#039;/[^\x00-\x7F]/&#039;, $label)) {
                    $info-&gt;errors |= self::ERROR_INVALID_ACE_LABEL;
                    continue;
                }
                $validationOptions[&#039;Transitional_Processing&#039;] = \false;
                $labels[$i] = $label;
            }
            self::validateLabel($label, $info, $validationOptions, $i &gt; 0 &amp;&amp; $i === $lastLabelIndex);
        }
        if ($info-&gt;bidiDomain &amp;&amp; !$info-&gt;validBidiDomain) {
            $info-&gt;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-&gt;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-&gt;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-&gt;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-&gt;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) &amp;&amp; 1 === preg_match(Regex::BIDI_STEP_4_EN, $label)) {
                $info-&gt;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-&gt;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-&gt;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-&gt;validBidiDomain = \false;
            return;
        }
    }
    /**
     * @param array&lt;int, string&gt; $labels
     */
    private static function validateDomainAndLabelLength(array $labels, Info $info)
    {
        $maxDomainSize = self::MAX_DOMAIN_SIZE;
        $length = \count($labels);
        // Number of &quot;.&quot; 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&#039;s &quot;.&quot;
        // delimiter. This also means we don&#039;t need to check the last label&#039;s length for being too
        // long.
        if ($length &gt; 1 &amp;&amp; &#039;&#039; === $labels[$length - 1]) {
            ++$maxDomainSize;
            --$length;
        }
        for ($i = 0; $i &lt; $length; ++$i) {
            $bytes = \strlen($labels[$i]);
            $domainLength += $bytes;
            if ($bytes &gt; self::MAX_LABEL_SIZE) {
                $info-&gt;errors |= self::ERROR_LABEL_TOO_LONG;
            }
        }
        if ($domainLength &gt; $maxDomainSize) {
            $info-&gt;errors |= self::ERROR_DOMAIN_NAME_TOO_LONG;
        }
    }
    /**
     * @see https://www.unicode.org/reports/tr46/#Validity_Criteria
     *
     * @param string              $label
     * @param array&lt;string, bool&gt; $options
     * @param bool                $canBeEmpty
     */
    private static function validateLabel($label, Info $info, array $options, $canBeEmpty)
    {
        if (&#039;&#039; === $label) {
            if (!$canBeEmpty &amp;&amp; (!isset($options[&#039;VerifyDnsLength&#039;]) || $options[&#039;VerifyDnsLength&#039;])) {
                $info-&gt;errors |= self::ERROR_EMPTY_LABEL;
            }
            return;
        }
        // Step 1. The label must be in Unicode Normalization Form C.
        if (!\Cloudflare\APO\Vendor\Symfony\Polyfill\Intl\Normalizer\Normalizer::isNormalized($label, \Cloudflare\APO\Vendor\Symfony\Polyfill\Intl\Normalizer\Normalizer::FORM_C)) {
            $info-&gt;errors |= self::ERROR_INVALID_ACE_LABEL;
        }
        $codePoints = self::utf8Decode($label);
        if ($options[&#039;CheckHyphens&#039;]) {
            // 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]) &amp;&amp; 0x2d === $codePoints[2] &amp;&amp; 0x2d === $codePoints[3]) {
                $info-&gt;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 (&#039;-&#039; === substr($label, 0, 1)) {
                $info-&gt;errors |= self::ERROR_LEADING_HYPHEN;
            }
            if (&#039;-&#039; === substr($label, -1, 1)) {
                $info-&gt;errors |= self::ERROR_TRAILING_HYPHEN;
            }
        } elseif (&#039;xn--&#039; === substr($label, 0, 4)) {
            $info-&gt;errors |= self::ERROR_PUNYCODE;
        }
        // Step 4. The label must not contain a U+002E (.) FULL STOP.
        if (\false !== strpos($label, &#039;.&#039;)) {
            $info-&gt;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-&gt;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[&#039;Transitional_Processing&#039;];
        $useSTD3ASCIIRules = $options[&#039;UseSTD3ASCIIRules&#039;];
        foreach ($codePoints as $codePoint) {
            $data = self::lookupCodePointStatus($codePoint, $useSTD3ASCIIRules);
            $status = $data[&#039;status&#039;];
            if (&#039;valid&#039; === $status || !$transitional &amp;&amp; &#039;deviation&#039; === $status) {
                continue;
            }
            $info-&gt;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[&#039;CheckJoiners&#039;] &amp;&amp; !self::isValidContextJ($codePoints, $label)) {
            $info-&gt;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[&#039;CheckBidi&#039;] &amp;&amp; (!$info-&gt;bidiDomain || $info-&gt;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(&#039;ord&#039;, str_split($input));
        for ($j = 0; $j &lt; $b; ++$j) {
            if ($bytes[$j] &gt; 0x7f) {
                throw new \Exception(&#039;Invalid input&#039;);
            }
            $output[$out++] = $input[$j];
        }
        if ($b &gt; 0) {
            ++$b;
        }
        for ($in = $b; $in &lt; $inputLength; ++$out) {
            $oldi = $i;
            $w = 1;
            for ($k = self::BASE;; $k += self::BASE) {
                if ($in &gt;= $inputLength) {
                    throw new \Exception(&#039;Invalid input&#039;);
                }
                $digit = self::$basicToDigit[$bytes[$in++] &amp; 0xff];
                if ($digit &lt; 0) {
                    throw new \Exception(&#039;Invalid input&#039;);
                }
                if ($digit &gt; intdiv(self::MAX_INT - $i, $w)) {
                    throw new \Exception(&#039;Integer overflow&#039;);
                }
                $i += $digit * $w;
                if ($k &lt;= $bias) {
                    $t = self::TMIN;
                } elseif ($k &gt;= $bias + self::TMAX) {
                    $t = self::TMAX;
                } else {
                    $t = $k - $bias;
                }
                if ($digit &lt; $t) {
                    break;
                }
                $baseMinusT = self::BASE - $t;
                if ($w &gt; intdiv(self::MAX_INT, $baseMinusT)) {
                    throw new \Exception(&#039;Integer overflow&#039;);
                }
                $w *= $baseMinusT;
            }
            $outPlusOne = $out + 1;
            $bias = self::adaptBias($i - $oldi, $outPlusOne, 0 === $oldi);
            if (intdiv($i, $outPlusOne) &gt; self::MAX_INT - $n) {
                throw new \Exception(&#039;Integer overflow&#039;);
            }
            $n += intdiv($i, $outPlusOne);
            $i %= $outPlusOne;
            array_splice($output, $i++, 0, [mb_chr($n, &#039;utf-8&#039;)]);
        }
        return implode(&#039;&#039;, $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 = &#039;&#039;;
        $iter = self::utf8Decode($input);
        foreach ($iter as $codePoint) {
            ++$inputLength;
            if ($codePoint &lt; 0x80) {
                $output .= \chr($codePoint);
                ++$out;
            }
        }
        $h = $out;
        $b = $out;
        if ($b &gt; 0) {
            $output .= self::DELIMITER;
            ++$out;
        }
        while ($h &lt; $inputLength) {
            $m = self::MAX_INT;
            foreach ($iter as $codePoint) {
                if ($codePoint &gt;= $n &amp;&amp; $codePoint &lt; $m) {
                    $m = $codePoint;
                }
            }
            if ($m - $n &gt; intdiv(self::MAX_INT - $delta, $h + 1)) {
                throw new \Exception(&#039;Integer overflow&#039;);
            }
            $delta += ($m - $n) * ($h + 1);
            $n = $m;
            foreach ($iter as $codePoint) {
                if ($codePoint &lt; $n &amp;&amp; 0 === ++$delta) {
                    throw new \Exception(&#039;Integer overflow&#039;);
                }
                if ($codePoint === $n) {
                    $q = $delta;
                    for ($k = self::BASE;; $k += self::BASE) {
                        if ($k &lt;= $bias) {
                            $t = self::TMIN;
                        } elseif ($k &gt;= $bias + self::TMAX) {
                            $t = self::TMAX;
                        } else {
                            $t = $k - $bias;
                        }
                        if ($q &lt; $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 &gt;&gt; 1 is a faster way of doing intdiv(xxx, 2)
        $delta = $firstTime ? intdiv($delta, self::DAMP) : $delta &gt;&gt; 1;
        $delta += intdiv($delta, $numPoints);
        $k = 0;
        while ($delta &gt; (self::BASE - self::TMIN) * self::TMAX &gt;&gt; 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 &lt; 26 ? 1 : 0) - (($flag ? 1 : 0) &lt;&lt; 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&lt;int, int&gt;
     */
    private static function utf8Decode($input)
    {
        $bytesSeen = 0;
        $bytesNeeded = 0;
        $lowerBoundary = 0x80;
        $upperBoundary = 0xbf;
        $codePoint = 0;
        $codePoints = [];
        $length = \strlen($input);
        for ($i = 0; $i &lt; $length; ++$i) {
            $byte = \ord($input[$i]);
            if (0 === $bytesNeeded) {
                if ($byte &gt;= 0x0 &amp;&amp; $byte &lt;= 0x7f) {
                    $codePoints[] = $byte;
                    continue;
                }
                if ($byte &gt;= 0xc2 &amp;&amp; $byte &lt;= 0xdf) {
                    $bytesNeeded = 1;
                    $codePoint = $byte &amp; 0x1f;
                } elseif ($byte &gt;= 0xe0 &amp;&amp; $byte &lt;= 0xef) {
                    if (0xe0 === $byte) {
                        $lowerBoundary = 0xa0;
                    } elseif (0xed === $byte) {
                        $upperBoundary = 0x9f;
                    }
                    $bytesNeeded = 2;
                    $codePoint = $byte &amp; 0xf;
                } elseif ($byte &gt;= 0xf0 &amp;&amp; $byte &lt;= 0xf4) {
                    if (0xf0 === $byte) {
                        $lowerBoundary = 0x90;
                    } elseif (0xf4 === $byte) {
                        $upperBoundary = 0x8f;
                    }
                    $bytesNeeded = 3;
                    $codePoint = $byte &amp; 0x7;
                } else {
                    $codePoints[] = 0xfffd;
                }
                continue;
            }
            if ($byte &lt; $lowerBoundary || $byte &gt; $upperBoundary) {
                $codePoint = 0;
                $bytesNeeded = 0;
                $bytesSeen = 0;
                $lowerBoundary = 0x80;
                $upperBoundary = 0xbf;
                --$i;
                $codePoints[] = 0xfffd;
                continue;
            }
            $lowerBoundary = 0x80;
            $upperBoundary = 0xbf;
            $codePoint = $codePoint &lt;&lt; 6 | $byte &amp; 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__ . &#039;/Resources/unidata/mapped.php&#039;;
            self::$ignored = require __DIR__ . &#039;/Resources/unidata/ignored.php&#039;;
            self::$deviation = require __DIR__ . &#039;/Resources/unidata/deviation.php&#039;;
            self::$disallowed = require __DIR__ . &#039;/Resources/unidata/disallowed.php&#039;;
            self::$disallowed_STD3_mapped = require __DIR__ . &#039;/Resources/unidata/disallowed_STD3_mapped.php&#039;;
            self::$disallowed_STD3_valid = require __DIR__ . &#039;/Resources/unidata/disallowed_STD3_valid.php&#039;;
        }
        if (isset(self::$mapped[$codePoint])) {
            return [&#039;status&#039; =&gt; &#039;mapped&#039;, &#039;mapping&#039; =&gt; self::$mapped[$codePoint]];
        }
        if (isset(self::$ignored[$codePoint])) {
            return [&#039;status&#039; =&gt; &#039;ignored&#039;];
        }
        if (isset(self::$deviation[$codePoint])) {
            return [&#039;status&#039; =&gt; &#039;deviation&#039;, &#039;mapping&#039; =&gt; self::$deviation[$codePoint]];
        }
        if (isset(self::$disallowed[$codePoint]) || DisallowedRanges::inRange($codePoint)) {
            return [&#039;status&#039; =&gt; &#039;disallowed&#039;];
        }
        $isDisallowedMapped = isset(self::$disallowed_STD3_mapped[$codePoint]);
        if ($isDisallowedMapped || isset(self::$disallowed_STD3_valid[$codePoint])) {
            $status = &#039;disallowed&#039;;
            if (!$useSTD3ASCIIRules) {
                $status = $isDisallowedMapped ? &#039;mapped&#039; : &#039;valid&#039;;
            }
            if ($isDisallowedMapped) {
                return [&#039;status&#039; =&gt; $status, &#039;mapping&#039; =&gt; self::$disallowed_STD3_mapped[$codePoint]];
            }
            return [&#039;status&#039; =&gt; $status];
        }
        return [&#039;status&#039; =&gt; &#039;valid&#039;];
    }
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fwp-content%2Fplugins%2Fcloudflare%2Fvendor%2Fsymfony%2Fpolyfill-intl-idn'>⬅ Back to Directory</a>