5���#��a`,>����������1T���W�����{X�ɘ�}G�4�"��ҕ4z�5F>e6*��[��\�;��%*U0LUUr2�
cp�n��ݢ�kɜ��Y��͌3��+bG�����0#el���۴�o�e,,�jO�*M���1X��/3�z�)W^�,p>��s{��İQs��:�ޝd|w ���:f�I��e$���~�+ajX�jnT8����0'���S��>KI�UP���&���kNϒ�T�=�Xl��Ȟ�N��ڞ]Y��z_K[Q������ׂގ�\g�q!nB@�I�o��G*
���l;�_뼳��\�R���Ueэ��km)qh傢5�K���Nz٘6b�a���:����671k�{����� $��N� ��vf�N�]��S7gxg=V����j�G�;���w����Bx��� ���t�~�l/��"�ʭ��l��=ԝ6�n[D��ٛ�]������@"x)# �E����)��:�\8B�vk�c�p��v4�O*;c�o�J�?�4ª�MC���A������'�.�\�z��Vð��'�w�1USݻ�Sl�T��yj/�������� �g��ʕ,��:S')�����ܴ�]�7�!A^��b�%�P�׶ٮ��հU3� ���o�\}XTp,�e 59���7�n}d���k�6UFrVǧ�3q�����a��R�:�BW�n�>Ѻ��}�ox��KӦ����K)�kܑ�KL�� tCs1��#�?�升�v�{r:����u)�?#�Zx�M=ڝYـ#e��}J�HB���G��T�G>���GsܞG��2�+��~R��̅H���ש)$[�*Hfx-���u�g�x�({��� I7λ��w�v����Ym�~ �|e'X#��db�@h��W,<��x�� ��t��}U�r�>�0H�8�*�J5�A�ъ���A`�;�jȊY�*���&s�h8Jn�]����"�M>l3z��%������Ր�s��y�=�����Um�'�����q�F��s���X����� �%,U�v|�0���W`G�zcy�*�V�0���'�3R`5ޓ�Hڙ>PWbw7;�)[U(���:k�rm>�/ QU+)�P��>�Hm����!r -e��v��Y�>w��T7�ԝe)�^�6���_SN���⚓ϫ�('�?����2Sj�5,�[پd����|+�_�P���v'�[�]t'm�Ν2�l���}z/dz�^��E|�����"'J��q�ED)R�2�Ƃ��������Sg`��9���Ո�u5��~� ���d!�G��%>M6%�p���d�cP-�P ���L���`ϼT�Q�����nA�_��,����2�4��G�
�� �G�n�eRn����,�X�n�ߕ���Sz���V�����$�R�e�B�fZu��E ,Z��(�y���i����?vO!c�lOYA���� ��[�; c�� I|�v�C��o���m���+�H�ꡤ�\ea�Ӵ���;X�S��|v4�%�FcϷA�Q���[yϢ_s+Ơ�����&p����t����}�=%^S���b"#g�Ā'�[� o��A�UPz���r;�Ȕ�Z�T�y��4t>f�種ً����>T�؟�GRgC�^���-WЖu�k�S����,�G��L���V$ܱ�O餰�%c���p�)[*X_v��$@DD���Ӣ���3�b�E�-���V��0�֍?zy�S��y���a��dd\���j5�"�: Bx���i����?��;���3a��]�1�]Z�FD���澙r�c����|8uz/� CȎ����3U��T�
qb4���'�ҥX��6�KʖY��T2�f�Pe$6� �lG�zSQ�TP}� OL�1��q��^*r���xջ�Q�_���K�?��'�?���=V<��d��}AshE����\4V���������J:�j���}~�Tܛ�Wd�
�ꘃ�������}��s�~��xe*���k�lG2y�Y# AQUB�r��2�鼶z)M(��WK��g��}�""""��

<?php declare(strict_types=1);

namespace PhpParser\Lexer;

use PhpParser\Error;
use PhpParser\ErrorHandler;
use PhpParser\Lexer;
use PhpParser\Lexer\TokenEmulator\CoaleseEqualTokenEmulator;
use PhpParser\Lexer\TokenEmulator\FnTokenEmulator;
use PhpParser\Lexer\TokenEmulator\TokenEmulatorInterface;

class Emulative extends Lexer
{
    const PHP_7_3 = '7.3.0dev';
    const PHP_7_4 = '7.4.0dev';

    const FLEXIBLE_DOC_STRING_REGEX = <<<'REGEX'
/<<<[ \t]*(['"]?)([a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)\1\r?\n
(?:.*\r?\n)*?
(?<indentation>\h*)\2(?![a-zA-Z_\x80-\xff])(?<separator>(?:;?[\r\n])?)/x
REGEX;

    /** @var mixed[] Patches used to reverse changes introduced in the code */
    private $patches = [];

    /** @var TokenEmulatorInterface[] */
    private $tokenEmulators = [];

    /**
     * @param mixed[] $options
     */
    public function __construct(array $options = [])
    {
        parent::__construct($options);

        // prepare token emulators
        $this->tokenEmulators[] = new FnTokenEmulator();
        $this->tokenEmulators[] = new CoaleseEqualTokenEmulator();

        // add emulated tokens here
        foreach ($this->tokenEmulators as $emulativeToken) {
            $this->tokenMap[$emulativeToken->getTokenId()] = $emulativeToken->getParserTokenId();
        }
    }

    public function startLexing(string $code, ErrorHandler $errorHandler = null) {
        $this->patches = [];

        if ($this->isEmulationNeeded($code) === false) {
            // Nothing to emulate, yay
            parent::startLexing($code, $errorHandler);
            return;
        }

        $collector = new ErrorHandler\Collecting();

        // 1. emulation of heredoc and nowdoc new syntax
        $preparedCode = $this->processHeredocNowdoc($code);
        parent::startLexing($preparedCode, $collector);

        // add token emulation
        foreach ($this->tokenEmulators as $emulativeToken) {
            if ($emulativeToken->isEmulationNeeded($code)) {
                $this->tokens = $emulativeToken->emulate($code, $this->tokens);
            }
        }

        $this->fixupTokens();

        $errors = $collector->getErrors();
        if (!empty($errors)) {
            $this->fixupErrors($errors);
            foreach ($errors as $error) {
                $errorHandler->handleError($error);
            }
        }
    }

    private function isHeredocNowdocEmulationNeeded(string $code): bool
    {
        // skip version where this works without emulation
        if (version_compare(\PHP_VERSION, self::PHP_7_3, '>=')) {
            return false;
        }

        return strpos($code, '<<<') !== false;
    }

    private function processHeredocNowdoc(string $code): string
    {
        if ($this->isHeredocNowdocEmulationNeeded($code) === false) {
            return $code;
        }

        if (!preg_match_all(self::FLEXIBLE_DOC_STRING_REGEX, $code, $matches, PREG_SET_ORDER|PREG_OFFSET_CAPTURE)) {
            // No heredoc/nowdoc found
            return $code;
        }

        // Keep track of how much we need to adjust string offsets due to the modifications we
        // already made
        $posDelta = 0;
        foreach ($matches as $match) {
            $indentation = $match['indentation'][0];
            $indentationStart = $match['indentation'][1];

            $separator = $match['separator'][0];
            $separatorStart = $match['separator'][1];

            if ($indentation === '' && $separator !== '') {
                // Ordinary heredoc/nowdoc
                continue;
            }

            if ($indentation !== '') {
                // Remove indentation
                $indentationLen = strlen($indentation);
                $code = substr_replace($code, '', $indentationStart + $posDelta, $indentationLen);
                $this->patches[] = [$indentationStart + $posDelta, 'add', $indentation];
                $posDelta -= $indentationLen;
            }

            if ($separator === '') {
                // Insert newline as separator
                $code = substr_replace($code, "\n", $separatorStart + $posDelta, 0);
                $this->patches[] = [$separatorStart + $posDelta, 'remove', "\n"];
                $posDelta += 1;
            }
        }

        return $code;
    }

    private function isEmulationNeeded(string $code): bool
    {
        foreach ($this->tokenEmulators as $emulativeToken) {
            if ($emulativeToken->isEmulationNeeded($code)) {
                return true;
            }
        }

        return $this->isHeredocNowdocEmulationNeeded($code);
    }

    private function fixupTokens()
    {
        if (\count($this->patches) === 0) {
            return;
        }

        // Load first patch
        $patchIdx = 0;

        list($patchPos, $patchType, $patchText) = $this->patches[$patchIdx];

        // We use a manual loop over the tokens, because we modify the array on the fly
        $pos = 0;
        for ($i = 0, $c = \count($this->tokens); $i < $c; $i++) {
            $token = $this->tokens[$i];
            if (\is_string($token)) {
                // We assume that patches don't apply to string tokens
                $pos += \strlen($token);
                continue;
            }

            $len = \strlen($token[1]);
            $posDelta = 0;
            while ($patchPos >= $pos && $patchPos < $pos + $len) {
                $patchTextLen = \strlen($patchText);
                if ($patchType === 'remove') {
                    if ($patchPos === $pos && $patchTextLen === $len) {
                        // Remove token entirely
                        array_splice($this->tokens, $i, 1, []);
                        $i--;
                        $c--;
                    } else {
                        // Remove from token string
                        $this->tokens[$i][1] = substr_replace(
                            $token[1], '', $patchPos - $pos + $posDelta, $patchTextLen
                        );
                        $posDelta -= $patchTextLen;
                    }
                } elseif ($patchType === 'add') {
                    // Insert into the token string
                    $this->tokens[$i][1] = substr_replace(
                        $token[1], $patchText, $patchPos - $pos + $posDelta, 0
                    );
                    $posDelta += $patchTextLen;
                } else {
                    assert(false);
                }

                // Fetch the next patch
                $patchIdx++;
                if ($patchIdx >= \count($this->patches)) {
                    // No more patches, we're done
                    return;
                }

                list($patchPos, $patchType, $patchText) = $this->patches[$patchIdx];

                // Multiple patches may apply to the same token. Reload the current one to check
                // If the new patch applies
                $token = $this->tokens[$i];
            }

            $pos += $len;
        }

        // A patch did not apply
        assert(false);
    }

    /**
     * Fixup line and position information in errors.
     *
     * @param Error[] $errors
     */
    private function fixupErrors(array $errors) {
        foreach ($errors as $error) {
            $attrs = $error->getAttributes();

            $posDelta = 0;
            $lineDelta = 0;
            foreach ($this->patches as $patch) {
                list($patchPos, $patchType, $patchText) = $patch;
                if ($patchPos >= $attrs['startFilePos']) {
                    // No longer relevant
                    break;
                }

                if ($patchType === 'add') {
                    $posDelta += strlen($patchText);
                    $lineDelta += substr_count($patchText, "\n");
                } else {
                    $posDelta -= strlen($patchText);
                    $lineDelta -= substr_count($patchText, "\n");
                }
            }

            $attrs['startFilePos'] += $posDelta;
            $attrs['endFilePos'] += $posDelta;
            $attrs['startLine'] += $lineDelta;
            $attrs['endLine'] += $lineDelta;
            $error->setAttributes($attrs);
        }
    }
}