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

declare(strict_types=1);

/*
 * This file is part of the league/commonmark package.
 *
 * (c) Colin O'Dell &lt;colinodell@gmail.com&gt;
 *
 * Original code based on the CommonMark JS reference parser (https://bitly.com/commonmark-js)
 *  - (c) John MacFarlane
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace League\CommonMark\Reference;

use League\CommonMark\Parser\Cursor;
use League\CommonMark\Util\LinkParserHelper;

final class ReferenceParser
{
    // Looking for the start of a definition, i.e. `[`
    private const START_DEFINITION = 0;
    // Looking for and parsing the label, i.e. `[foo]` within `[foo]`
    private const LABEL = 1;
    // Parsing the destination, i.e. `/url` in `[foo]: /url`
    private const DESTINATION = 2;
    // Looking for the start of a title, i.e. the first `&quot;` in `[foo]: /url &quot;title&quot;`
    private const START_TITLE = 3;
    // Parsing the content of the title, i.e. `title` in `[foo]: /url &quot;title&quot;`
    private const TITLE = 4;
    // End state, no matter what kind of lines we add, they won't be references
    private const PARAGRAPH = 5;

    /** @psalm-readonly-allow-private-mutation */
    private string $paragraph = '';

    /**
     * @var array&lt;int, ReferenceInterface&gt;
     *
     * @psalm-readonly-allow-private-mutation
     */
    private array $references = [];

    /** @psalm-readonly-allow-private-mutation */
    private int $state = self::START_DEFINITION;

    /** @psalm-readonly-allow-private-mutation */
    private ?string $label = null;

    /** @psalm-readonly-allow-private-mutation */
    private ?string $destination = null;

    /**
     * @var string string
     *
     * @psalm-readonly-allow-private-mutation
     */
    private string $title = '';

    /** @psalm-readonly-allow-private-mutation */
    private ?string $titleDelimiter = null;

    /** @psalm-readonly-allow-private-mutation */
    private bool $referenceValid = false;

    public function getParagraphContent(): string
    {
        return $this-&gt;paragraph;
    }

    /**
     * @return ReferenceInterface[]
     */
    public function getReferences(): iterable
    {
        $this-&gt;finishReference();

        return $this-&gt;references;
    }

    public function hasReferences(): bool
    {
        return $this-&gt;references !== [];
    }

    public function parse(string $line): void
    {
        if ($this-&gt;paragraph !== '') {
            $this-&gt;paragraph .= &quot;\n&quot;;
        }

        $this-&gt;paragraph .= $line;

        $cursor = new Cursor($line);
        while (! $cursor-&gt;isAtEnd()) {
            $result = false;
            switch ($this-&gt;state) {
                case self::PARAGRAPH:
                    // We're in a paragraph now. Link reference definitions can only appear at the beginning, so once
                    // we're in a paragraph, there's no going back.
                    return;
                case self::START_DEFINITION:
                    $result = $this-&gt;parseStartDefinition($cursor);
                    break;
                case self::LABEL:
                    $result = $this-&gt;parseLabel($cursor);
                    break;
                case self::DESTINATION:
                    $result = $this-&gt;parseDestination($cursor);
                    break;
                case self::START_TITLE:
                    $result = $this-&gt;parseStartTitle($cursor);
                    break;
                case self::TITLE:
                    $result = $this-&gt;parseTitle($cursor);
                    break;
                default:
                    // this should never happen
                    break;
            }

            if (! $result) {
                $this-&gt;state = self::PARAGRAPH;

                return;
            }
        }
    }

    private function parseStartDefinition(Cursor $cursor): bool
    {
        $cursor-&gt;advanceToNextNonSpaceOrTab();
        if ($cursor-&gt;isAtEnd() || $cursor-&gt;getCurrentCharacter() !== '[') {
            return false;
        }

        $this-&gt;state = self::LABEL;
        $this-&gt;label = '';

        $cursor-&gt;advance();
        if ($cursor-&gt;isAtEnd()) {
            $this-&gt;label .= &quot;\n&quot;;
        }

        return true;
    }

    private function parseLabel(Cursor $cursor): bool
    {
        $cursor-&gt;advanceToNextNonSpaceOrTab();

        $partialLabel = LinkParserHelper::parsePartialLinkLabel($cursor);
        if ($partialLabel === null) {
            return false;
        }

        \assert($this-&gt;label !== null);
        $this-&gt;label .= $partialLabel;

        if ($cursor-&gt;isAtEnd()) {
            // label might continue on next line
            $this-&gt;label .= &quot;\n&quot;;

            return true;
        }

        if ($cursor-&gt;getCurrentCharacter() !== ']') {
            return false;
        }

        $cursor-&gt;advance();

        // end of label
        if ($cursor-&gt;getCurrentCharacter() !== ':') {
            return false;
        }

        $cursor-&gt;advance();

        // spec: A link label can have at most 999 characters inside the square brackets
        if (\mb_strlen($this-&gt;label, 'UTF-8') &gt; 999) {
            return false;
        }

        // spec: A link label must contain at least one non-whitespace character
        if (\trim($this-&gt;label) === '') {
            return false;
        }

        $cursor-&gt;advanceToNextNonSpaceOrTab();

        $this-&gt;state = self::DESTINATION;

        return true;
    }

    private function parseDestination(Cursor $cursor): bool
    {
        $cursor-&gt;advanceToNextNonSpaceOrTab();

        $destination = LinkParserHelper::parseLinkDestination($cursor);
        if ($destination === null) {
            return false;
        }

        $this-&gt;destination = $destination;

        $advanced = $cursor-&gt;advanceToNextNonSpaceOrTab();
        if ($cursor-&gt;isAtEnd()) {
            // Destination was at end of line, so this is a valid reference for sure (and maybe a title).
            // If not at end of line, wait for title to be valid first.
            $this-&gt;referenceValid = true;
            $this-&gt;paragraph      = '';
        } elseif ($advanced === 0) {
            // spec: The title must be separated from the link destination by whitespace
            return false;
        }

        $this-&gt;state = self::START_TITLE;

        return true;
    }

    private function parseStartTitle(Cursor $cursor): bool
    {
        $cursor-&gt;advanceToNextNonSpaceOrTab();
        if ($cursor-&gt;isAtEnd()) {
            $this-&gt;state = self::START_DEFINITION;

            return true;
        }

        $this-&gt;titleDelimiter = null;
        switch ($c = $cursor-&gt;getCurrentCharacter()) {
            case '&quot;':
            case &quot;'&quot;:
                $this-&gt;titleDelimiter = $c;
                break;
            case '(':
                $this-&gt;titleDelimiter = ')';
                break;
            default:
                // no title delimter found
                break;
        }

        if ($this-&gt;titleDelimiter !== null) {
            $this-&gt;state = self::TITLE;
            $cursor-&gt;advance();
            if ($cursor-&gt;isAtEnd()) {
                $this-&gt;title .= &quot;\n&quot;;
            }
        } else {
            $this-&gt;finishReference();
            // There might be another reference instead, try that for the same character.
            $this-&gt;state = self::START_DEFINITION;
        }

        return true;
    }

    private function parseTitle(Cursor $cursor): bool
    {
        \assert($this-&gt;titleDelimiter !== null);
        $title = LinkParserHelper::parsePartialLinkTitle($cursor, $this-&gt;titleDelimiter);

        if ($title === null) {
            // Invalid title, stop
            return false;
        }

        // Did we find the end delimiter?
        $endDelimiterFound = false;
        if (\substr($title, -1) === $this-&gt;titleDelimiter) {
            $endDelimiterFound = true;
            // Chop it off
            $title = \substr($title, 0, -1);
        }

        $this-&gt;title .= $title;

        if (! $endDelimiterFound &amp;&amp; $cursor-&gt;isAtEnd()) {
            // Title still going, continue on next line
            $this-&gt;title .= &quot;\n&quot;;

            return true;
        }

        // We either hit the end delimiter or some extra whitespace
        $cursor-&gt;advanceToNextNonSpaceOrTab();
        if (! $cursor-&gt;isAtEnd()) {
            // spec: No further non-whitespace characters may occur on the line.
            return false;
        }

        $this-&gt;referenceValid = true;
        $this-&gt;finishReference();
        $this-&gt;paragraph = '';

        // See if there's another definition
        $this-&gt;state = self::START_DEFINITION;

        return true;
    }

    private function finishReference(): void
    {
        if (! $this-&gt;referenceValid) {
            return;
        }

        /** @psalm-suppress PossiblyNullArgument -- these can't possibly be null if we're in this state */
        $this-&gt;references[] = new Reference($this-&gt;label, $this-&gt;destination, $this-&gt;title);

        $this-&gt;label          = null;
        $this-&gt;referenceValid = false;
        $this-&gt;destination    = null;
        $this-&gt;title          = '';
        $this-&gt;titleDelimiter = null;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>