<form method="POST">
    <h3>Editing: MarkdownParser.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
 *
 * Additional code based on commonmark-java (https://github.com/commonmark/commonmark-java)
 *  - (c) Atlassian Pty Ltd
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace League\CommonMark\Parser;

use League\CommonMark\Environment\EnvironmentInterface;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Event\DocumentPreParsedEvent;
use League\CommonMark\Exception\CommonMarkException;
use League\CommonMark\Input\MarkdownInput;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Node\Block\Paragraph;
use League\CommonMark\Parser\Block\BlockContinueParserInterface;
use League\CommonMark\Parser\Block\BlockContinueParserWithInlinesInterface;
use League\CommonMark\Parser\Block\BlockStart;
use League\CommonMark\Parser\Block\BlockStartParserInterface;
use League\CommonMark\Parser\Block\DocumentBlockParser;
use League\CommonMark\Parser\Block\ParagraphParser;
use League\CommonMark\Reference\ReferenceInterface;
use League\CommonMark\Reference\ReferenceMap;

final class MarkdownParser implements MarkdownParserInterface
{
    /** @psalm-readonly */
    private EnvironmentInterface $environment;

    /** @psalm-readonly-allow-private-mutation */
    private int $maxNestingLevel;

    /** @psalm-readonly-allow-private-mutation */
    private ReferenceMap $referenceMap;

    /** @psalm-readonly-allow-private-mutation */
    private int $lineNumber = 0;

    /** @psalm-readonly-allow-private-mutation */
    private Cursor $cursor;

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

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

    public function __construct(EnvironmentInterface $environment)
    {
        $this-&gt;environment = $environment;
    }

    private function initialize(): void
    {
        $this-&gt;referenceMap       = new ReferenceMap();
        $this-&gt;lineNumber         = 0;
        $this-&gt;activeBlockParsers = [];
        $this-&gt;closedBlockParsers = [];

        $this-&gt;maxNestingLevel = $this-&gt;environment-&gt;getConfiguration()-&gt;get('max_nesting_level');
    }

    /**
     * @throws CommonMarkException
     */
    public function parse(string $input): Document
    {
        $this-&gt;initialize();

        $documentParser = new DocumentBlockParser($this-&gt;referenceMap);
        $this-&gt;activateBlockParser($documentParser);

        $preParsedEvent = new DocumentPreParsedEvent($documentParser-&gt;getBlock(), new MarkdownInput($input));
        $this-&gt;environment-&gt;dispatch($preParsedEvent);
        $markdownInput = $preParsedEvent-&gt;getMarkdown();

        foreach ($markdownInput-&gt;getLines() as $lineNumber =&gt; $line) {
            $this-&gt;lineNumber = $lineNumber;
            $this-&gt;parseLine($line);
        }

        // finalizeAndProcess
        $this-&gt;closeBlockParsers(\count($this-&gt;activeBlockParsers), $this-&gt;lineNumber);
        $this-&gt;processInlines();

        $this-&gt;environment-&gt;dispatch(new DocumentParsedEvent($documentParser-&gt;getBlock()));

        return $documentParser-&gt;getBlock();
    }

    /**
     * Analyze a line of text and update the document appropriately. We parse markdown text by calling this on each
     * line of input, then finalizing the document.
     */
    private function parseLine(string $line): void
    {
        $this-&gt;cursor = new Cursor($line);

        $matches = $this-&gt;parseBlockContinuation();
        if ($matches === null) {
            return;
        }

        $unmatchedBlocks = \count($this-&gt;activeBlockParsers) - $matches;
        $blockParser     = $this-&gt;activeBlockParsers[$matches - 1];
        $startedNewBlock = false;

        // Unless last matched container is a code block, try new container starts,
        // adding children to the last matched container:
        $tryBlockStarts = $blockParser-&gt;getBlock() instanceof Paragraph || $blockParser-&gt;isContainer();
        while ($tryBlockStarts) {
            // this is a little performance optimization
            if ($this-&gt;cursor-&gt;isBlank()) {
                $this-&gt;cursor-&gt;advanceToEnd();
                break;
            }

            if ($blockParser-&gt;getBlock()-&gt;getDepth() &gt;= $this-&gt;maxNestingLevel) {
                break;
            }

            $blockStart = $this-&gt;findBlockStart($blockParser);
            if ($blockStart === null || $blockStart-&gt;isAborting()) {
                $this-&gt;cursor-&gt;advanceToNextNonSpaceOrTab();
                break;
            }

            if (($state = $blockStart-&gt;getCursorState()) !== null) {
                $this-&gt;cursor-&gt;restoreState($state);
            }

            $startedNewBlock = true;

            // We're starting a new block. If we have any previous blocks that need to be closed, we need to do it now.
            if ($unmatchedBlocks &gt; 0) {
                $this-&gt;closeBlockParsers($unmatchedBlocks, $this-&gt;lineNumber - 1);
                $unmatchedBlocks = 0;
            }

            $oldBlockLineStart = null;
            if ($blockStart-&gt;isReplaceActiveBlockParser()) {
                $oldBlockLineStart = $this-&gt;prepareActiveBlockParserForReplacement();
            }

            foreach ($blockStart-&gt;getBlockParsers() as $newBlockParser) {
                $blockParser    = $this-&gt;addChild($newBlockParser, $oldBlockLineStart);
                $tryBlockStarts = $newBlockParser-&gt;isContainer();
            }
        }

        // What remains at the offset is a text line. Add the text to the appropriate block.

        // First check for a lazy paragraph continuation:
        if (! $startedNewBlock &amp;&amp; ! $this-&gt;cursor-&gt;isBlank() &amp;&amp; $this-&gt;getActiveBlockParser()-&gt;canHaveLazyContinuationLines()) {
            $this-&gt;getActiveBlockParser()-&gt;addLine($this-&gt;cursor-&gt;getRemainder());
        } else {
            // finalize any blocks not matched
            if ($unmatchedBlocks &gt; 0) {
                $this-&gt;closeBlockParsers($unmatchedBlocks, $this-&gt;lineNumber - 1);
            }

            if (! $blockParser-&gt;isContainer()) {
                $this-&gt;getActiveBlockParser()-&gt;addLine($this-&gt;cursor-&gt;getRemainder());
            } elseif (! $this-&gt;cursor-&gt;isBlank()) {
                $this-&gt;addChild(new ParagraphParser());
                $this-&gt;getActiveBlockParser()-&gt;addLine($this-&gt;cursor-&gt;getRemainder());
            }
        }
    }

    private function parseBlockContinuation(): ?int
    {
        // For each containing block, try to parse the associated line start.
        // The document will always match, so we can skip the first block parser and start at 1 matches
        $matches = 1;
        for ($i = 1; $i &lt; \count($this-&gt;activeBlockParsers); $i++) {
            $blockParser   = $this-&gt;activeBlockParsers[$i];
            $blockContinue = $blockParser-&gt;tryContinue(clone $this-&gt;cursor, $this-&gt;getActiveBlockParser());
            if ($blockContinue === null) {
                break;
            }

            if ($blockContinue-&gt;isFinalize()) {
                $this-&gt;closeBlockParsers(\count($this-&gt;activeBlockParsers) - $i, $this-&gt;lineNumber);

                return null;
            }

            if (($state = $blockContinue-&gt;getCursorState()) !== null) {
                $this-&gt;cursor-&gt;restoreState($state);
            }

            $matches++;
        }

        return $matches;
    }

    private function findBlockStart(BlockContinueParserInterface $lastMatchedBlockParser): ?BlockStart
    {
        $matchedBlockParser = new MarkdownParserState($this-&gt;getActiveBlockParser(), $lastMatchedBlockParser);

        foreach ($this-&gt;environment-&gt;getBlockStartParsers() as $blockStartParser) {
            \assert($blockStartParser instanceof BlockStartParserInterface);
            if (($result = $blockStartParser-&gt;tryStart(clone $this-&gt;cursor, $matchedBlockParser)) !== null) {
                return $result;
            }
        }

        return null;
    }

    private function closeBlockParsers(int $count, int $endLineNumber): void
    {
        for ($i = 0; $i &lt; $count; $i++) {
            $blockParser = $this-&gt;deactivateBlockParser();
            $this-&gt;finalize($blockParser, $endLineNumber);

            // phpcs:disable SlevomatCodingStandard.ControlStructures.EarlyExit.EarlyExitNotUsed
            if ($blockParser instanceof BlockContinueParserWithInlinesInterface) {
                // Remember for inline parsing
                $this-&gt;closedBlockParsers[] = $blockParser;
            }
        }
    }

    /**
     * Finalize a block. Close it and do any necessary postprocessing, e.g. creating string_content from strings,
     * setting the 'tight' or 'loose' status of a list, and parsing the beginnings of paragraphs for reference
     * definitions.
     */
    private function finalize(BlockContinueParserInterface $blockParser, int $endLineNumber): void
    {
        if ($blockParser instanceof ParagraphParser) {
            $this-&gt;updateReferenceMap($blockParser-&gt;getReferences());
        }

        $blockParser-&gt;getBlock()-&gt;setEndLine($endLineNumber);
        $blockParser-&gt;closeBlock();
    }

    /**
     * Walk through a block &amp; children recursively, parsing string content into inline content where appropriate.
     */
    private function processInlines(): void
    {
        $p = new InlineParserEngine($this-&gt;environment, $this-&gt;referenceMap);

        foreach ($this-&gt;closedBlockParsers as $blockParser) {
            $blockParser-&gt;parseInlines($p);
        }
    }

    /**
     * Add block of type tag as a child of the tip. If the tip can't accept children, close and finalize it and try
     * its parent, and so on til we find a block that can accept children.
     */
    private function addChild(BlockContinueParserInterface $blockParser, ?int $startLineNumber = null): BlockContinueParserInterface
    {
        $blockParser-&gt;getBlock()-&gt;setStartLine($startLineNumber ?? $this-&gt;lineNumber);

        while (! $this-&gt;getActiveBlockParser()-&gt;canContain($blockParser-&gt;getBlock())) {
            $this-&gt;closeBlockParsers(1, ($startLineNumber ?? $this-&gt;lineNumber) - 1);
        }

        $this-&gt;getActiveBlockParser()-&gt;getBlock()-&gt;appendChild($blockParser-&gt;getBlock());
        $this-&gt;activateBlockParser($blockParser);

        return $blockParser;
    }

    private function activateBlockParser(BlockContinueParserInterface $blockParser): void
    {
        $this-&gt;activeBlockParsers[] = $blockParser;
    }

    /**
     * @throws ParserLogicException
     */
    private function deactivateBlockParser(): BlockContinueParserInterface
    {
        $popped = \array_pop($this-&gt;activeBlockParsers);
        if ($popped === null) {
            throw new ParserLogicException('The last block parser should not be deactivated');
        }

        return $popped;
    }

    /**
     * @return int|null The line number where the old block started
     */
    private function prepareActiveBlockParserForReplacement(): ?int
    {
        // Note that we don't want to parse inlines or finalize this block, as it's getting replaced.
        $old = $this-&gt;deactivateBlockParser();

        if ($old instanceof ParagraphParser) {
            $this-&gt;updateReferenceMap($old-&gt;getReferences());
        }

        $old-&gt;getBlock()-&gt;detach();

        return $old-&gt;getBlock()-&gt;getStartLine();
    }

    /**
     * @param ReferenceInterface[] $references
     */
    private function updateReferenceMap(iterable $references): void
    {
        foreach ($references as $reference) {
            if (! $this-&gt;referenceMap-&gt;contains($reference-&gt;getLabel())) {
                $this-&gt;referenceMap-&gt;add($reference);
            }
        }
    }

    /**
     * @throws ParserLogicException
     */
    public function getActiveBlockParser(): BlockContinueParserInterface
    {
        $active = \end($this-&gt;activeBlockParsers);
        if ($active === false) {
            throw new ParserLogicException('No active block parsers are available');
        }

        return $active;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>