<form method="POST">
    <h3>Editing: Highlighter.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

declare(strict_types=1);

namespace NunoMaduro\Collision;

use NunoMaduro\Collision\Contracts\Highlighter as HighlighterContract;

/**
 * @internal
 */
final class Highlighter implements HighlighterContract
{
    public const TOKEN_DEFAULT    = 'token_default';
    public const TOKEN_COMMENT    = 'token_comment';
    public const TOKEN_STRING     = 'token_string';
    public const TOKEN_HTML       = 'token_html';
    public const TOKEN_KEYWORD    = 'token_keyword';
    public const ACTUAL_LINE_MARK = 'actual_line_mark';
    public const LINE_NUMBER      = 'line_number';

    private const ARROW_SYMBOL        = '&gt;';
    private const DELIMITER           = '|';
    private const ARROW_SYMBOL_UTF8   = '➜';
    private const DELIMITER_UTF8      = '▕'; // '▶';
    private const LINE_NUMBER_DIVIDER = 'line_divider';
    private const MARKED_LINE_NUMBER  = 'marked_line';
    private const WIDTH               = 3;
    /**
     * Holds the theme.
     *
     * @var array
     */
    private const THEME = [
        self::TOKEN_STRING  =&gt; ['light_gray'],
        self::TOKEN_COMMENT =&gt; ['dark_gray', 'italic'],
        self::TOKEN_KEYWORD =&gt; ['magenta', 'bold'],
        self::TOKEN_DEFAULT =&gt; ['default', 'bold'],
        self::TOKEN_HTML    =&gt; ['blue', 'bold'],

        self::ACTUAL_LINE_MARK    =&gt; ['red', 'bold'],
        self::LINE_NUMBER         =&gt; ['dark_gray'],
        self::MARKED_LINE_NUMBER  =&gt; ['italic', 'bold'],
        self::LINE_NUMBER_DIVIDER =&gt; ['dark_gray'],
    ];
    /** @var ConsoleColor */
    private $color;

    /** @var array */
    private const DEFAULT_THEME = [
        self::TOKEN_STRING  =&gt; 'red',
        self::TOKEN_COMMENT =&gt; 'yellow',
        self::TOKEN_KEYWORD =&gt; 'green',
        self::TOKEN_DEFAULT =&gt; 'default',
        self::TOKEN_HTML    =&gt; 'cyan',

        self::ACTUAL_LINE_MARK    =&gt; 'dark_gray',
        self::LINE_NUMBER         =&gt; 'dark_gray',
        self::MARKED_LINE_NUMBER  =&gt; 'dark_gray',
        self::LINE_NUMBER_DIVIDER =&gt; 'dark_gray',
    ];
    /** @var string */
    private $delimiter = self::DELIMITER_UTF8;
    /** @var string */
    private $arrow = self::ARROW_SYMBOL_UTF8;
    /**
     * @var string
     */
    private const NO_MARK = '    ';

    /**
     * Creates an instance of the Highlighter.
     */
    public function __construct(ConsoleColor $color = null, bool $UTF8 = true)
    {
        $this-&gt;color = $color ?: new ConsoleColor();

        foreach (self::DEFAULT_THEME as $name =&gt; $styles) {
            if (!$this-&gt;color-&gt;hasTheme($name)) {
                $this-&gt;color-&gt;addTheme($name, $styles);
            }
        }

        foreach (self::THEME as $name =&gt; $styles) {
            $this-&gt;color-&gt;addTheme($name, $styles);
        }
        if (!$UTF8) {
            $this-&gt;delimiter = self::DELIMITER;
            $this-&gt;arrow     = self::ARROW_SYMBOL;
        }
        $this-&gt;delimiter .= ' ';
    }

    /**
     * {@inheritdoc}
     */
    public function highlight(string $content, int $line): string
    {
        return rtrim($this-&gt;getCodeSnippet($content, $line, 4, 4));
    }

    /**
     * @param string $source
     * @param int    $lineNumber
     * @param int    $linesBefore
     * @param int    $linesAfter
     */
    public function getCodeSnippet($source, $lineNumber, $linesBefore = 2, $linesAfter = 2): string
    {
        $tokenLines = $this-&gt;getHighlightedLines($source);

        $offset     = $lineNumber - $linesBefore - 1;
        $offset     = max($offset, 0);
        $length     = $linesAfter + $linesBefore + 1;
        $tokenLines = array_slice($tokenLines, $offset, $length, $preserveKeys = true);

        $lines = $this-&gt;colorLines($tokenLines);

        return $this-&gt;lineNumbers($lines, $lineNumber);
    }

    /**
     * @param string $source
     */
    private function getHighlightedLines($source): array
    {
        $source = str_replace([&quot;\r\n&quot;, &quot;\r&quot;], &quot;\n&quot;, $source);
        $tokens = $this-&gt;tokenize($source);

        return $this-&gt;splitToLines($tokens);
    }

    /**
     * @param string $source
     */
    private function tokenize($source): array
    {
        $tokens = token_get_all($source);

        $output      = [];
        $currentType = null;
        $buffer      = '';

        foreach ($tokens as $token) {
            if (is_array($token)) {
                switch ($token[0]) {
                    case T_WHITESPACE:
                        break;

                    case T_OPEN_TAG:
                    case T_OPEN_TAG_WITH_ECHO:
                    case T_CLOSE_TAG:
                    case T_STRING:
                    case T_VARIABLE:
                        // Constants
                    case T_DIR:
                    case T_FILE:
                    case T_METHOD_C:
                    case T_DNUMBER:
                    case T_LNUMBER:
                    case T_NS_C:
                    case T_LINE:
                    case T_CLASS_C:
                    case T_FUNC_C:
                    case T_TRAIT_C:
                        $newType = self::TOKEN_DEFAULT;
                        break;

                    case T_COMMENT:
                    case T_DOC_COMMENT:
                        $newType = self::TOKEN_COMMENT;
                        break;

                    case T_ENCAPSED_AND_WHITESPACE:
                    case T_CONSTANT_ENCAPSED_STRING:
                        $newType = self::TOKEN_STRING;
                        break;

                    case T_INLINE_HTML:
                        $newType = self::TOKEN_HTML;
                        break;

                    default:
                        $newType = self::TOKEN_KEYWORD;
                }
            } else {
                $newType = $token === '&quot;' ? self::TOKEN_STRING : self::TOKEN_KEYWORD;
            }

            if ($currentType === null) {
                $currentType = $newType;
            }

            if ($currentType !== $newType) {
                $output[]    = [$currentType, $buffer];
                $buffer      = '';
                $currentType = $newType;
            }

            $buffer .= is_array($token) ? $token[1] : $token;
        }

        if (isset($newType)) {
            $output[] = [$newType, $buffer];
        }

        return $output;
    }

    private function splitToLines(array $tokens): array
    {
        $lines = [];

        $line = [];
        foreach ($tokens as $token) {
            foreach (explode(&quot;\n&quot;, $token[1]) as $count =&gt; $tokenLine) {
                if ($count &gt; 0) {
                    $lines[] = $line;
                    $line    = [];
                }

                if ($tokenLine === '') {
                    continue;
                }

                $line[] = [$token[0], $tokenLine];
            }
        }

        $lines[] = $line;

        return $lines;
    }

    private function colorLines(array $tokenLines): array
    {
        $lines = [];
        foreach ($tokenLines as $lineCount =&gt; $tokenLine) {
            $line = '';
            foreach ($tokenLine as $token) {
                [$tokenType, $tokenValue] = $token;
                if ($this-&gt;color-&gt;hasTheme($tokenType)) {
                    $line .= $this-&gt;color-&gt;apply($tokenType, $tokenValue);
                } else {
                    $line .= $tokenValue;
                }
            }
            $lines[$lineCount] = $line;
        }

        return $lines;
    }

    /**
     * @param int|null $markLine
     */
    private function lineNumbers(array $lines, $markLine = null): string
    {
        $lineStrlen = strlen((string) (array_key_last($lines) + 1));
        $lineStrlen = $lineStrlen &lt; self::WIDTH ? self::WIDTH : $lineStrlen;
        $snippet    = '';
        $mark       = '  ' . $this-&gt;arrow . ' ';
        foreach ($lines as $i =&gt; $line) {
            $coloredLineNumber = $this-&gt;coloredLineNumber(self::LINE_NUMBER, $i, $lineStrlen);

            if (null !== $markLine) {
                $snippet .=
                    ($markLine === $i + 1
                        ? $this-&gt;color-&gt;apply(self::ACTUAL_LINE_MARK, $mark)
                        : self::NO_MARK
                    );

                $coloredLineNumber =
                    ($markLine === $i + 1 ?
                        $this-&gt;coloredLineNumber(self::MARKED_LINE_NUMBER, $i, $lineStrlen) :
                        $coloredLineNumber
                    );
            }
            $snippet .= $coloredLineNumber;

            $snippet .=
                $this-&gt;color-&gt;apply(self::LINE_NUMBER_DIVIDER, $this-&gt;delimiter);

            $snippet .= $line . PHP_EOL;
        }

        return $snippet;
    }

    /**
     * @param string $style
     * @param int    $i
     * @param int    $lineStrlen
     */
    private function coloredLineNumber($style, $i, $lineStrlen): string
    {
        return $this-&gt;color-&gt;apply($style, str_pad((string) ($i + 1), $lineStrlen, ' ', STR_PAD_LEFT));
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>