🎉

vendor/league/commonmark/src/Reference/Reference.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the league/commonmark package.
+ *
+ * (c) Colin O'Dell <colinodell@gmail.com>
+ *
+ * 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;
+
+/**
+ * @psalm-immutable
+ */
+final class Reference implements ReferenceInterface
+{
+    /** @psalm-readonly */
+    private string $label;
+
+    /** @psalm-readonly */
+    private string $destination;
+
+    /** @psalm-readonly */
+    private string $title;
+
+    public function __construct(string $label, string $destination, string $title)
+    {
+        $this->label       = $label;
+        $this->destination = $destination;
+        $this->title       = $title;
+    }
+
+    public function getLabel(): string
+    {
+        return $this->label;
+    }
+
+    public function getDestination(): string
+    {
+        return $this->destination;
+    }
+
+    public function getTitle(): string
+    {
+        return $this->title;
+    }
+}

vendor/league/commonmark/src/Reference/ReferenceInterface.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the league/commonmark package.
+ *
+ * (c) Colin O'Dell <colinodell@gmail.com>
+ *
+ * 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;
+
+/**
+ * Link reference
+ */
+interface ReferenceInterface
+{
+    public function getLabel(): string;
+
+    public function getDestination(): string;
+
+    public function getTitle(): string;
+}

vendor/league/commonmark/src/Reference/ReferenceMap.php

@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the league/commonmark package.
+ *
+ * (c) Colin O'Dell <colinodell@gmail.com>
+ *
+ * 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\Normalizer\TextNormalizer;
+
+/**
+ * A collection of references, indexed by label
+ */
+final class ReferenceMap implements ReferenceMapInterface
+{
+    /** @psalm-readonly */
+    private TextNormalizer $normalizer;
+
+    /**
+     * @var array<string, ReferenceInterface>
+     *
+     * @psalm-readonly-allow-private-mutation
+     */
+    private array $references = [];
+
+    public function __construct()
+    {
+        $this->normalizer = new TextNormalizer();
+    }
+
+    public function add(ReferenceInterface $reference): void
+    {
+        // Normalize the key
+        $key = $this->normalizer->normalize($reference->getLabel());
+        // Store the reference
+        $this->references[$key] = $reference;
+    }
+
+    public function contains(string $label): bool
+    {
+        $label = $this->normalizer->normalize($label);
+
+        return isset($this->references[$label]);
+    }
+
+    public function get(string $label): ?ReferenceInterface
+    {
+        $label = $this->normalizer->normalize($label);
+
+        return $this->references[$label] ?? null;
+    }
+
+    /**
+     * @return \Traversable<string, ReferenceInterface>
+     */
+    public function getIterator(): \Traversable
+    {
+        foreach ($this->references as $normalizedLabel => $reference) {
+            yield $normalizedLabel => $reference;
+        }
+    }
+
+    public function count(): int
+    {
+        return \count($this->references);
+    }
+}

vendor/league/commonmark/src/Reference/ReferenceMapInterface.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the league/commonmark package.
+ *
+ * (c) Colin O'Dell <colinodell@gmail.com>
+ *
+ * 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;
+
+/**
+ * A collection of references
+ *
+ * @phpstan-extends \IteratorAggregate<ReferenceInterface>
+ */
+interface ReferenceMapInterface extends \IteratorAggregate, \Countable
+{
+    public function add(ReferenceInterface $reference): void;
+
+    public function contains(string $label): bool;
+
+    public function get(string $label): ?ReferenceInterface;
+}

vendor/league/commonmark/src/Reference/ReferenceParser.php

@@ -0,0 +1,324 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the league/commonmark package.
+ *
+ * (c) Colin O'Dell <colinodell@gmail.com>
+ *
+ * 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 `"` in `[foo]: /url "title"`
+    private const START_TITLE = 3;
+    // Parsing the content of the title, i.e. `title` in `[foo]: /url "title"`
+    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<int, ReferenceInterface>
+     *
+     * @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->paragraph;
+    }
+
+    /**
+     * @return ReferenceInterface[]
+     */
+    public function getReferences(): iterable
+    {
+        $this->finishReference();
+
+        return $this->references;
+    }
+
+    public function hasReferences(): bool
+    {
+        return $this->references !== [];
+    }
+
+    public function parse(string $line): void
+    {
+        if ($this->paragraph !== '') {
+            $this->paragraph .= "\n";
+        }
+
+        $this->paragraph .= $line;
+
+        $cursor = new Cursor($line);
+        while (! $cursor->isAtEnd()) {
+            $result = false;
+            switch ($this->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->parseStartDefinition($cursor);
+                    break;
+                case self::LABEL:
+                    $result = $this->parseLabel($cursor);
+                    break;
+                case self::DESTINATION:
+                    $result = $this->parseDestination($cursor);
+                    break;
+                case self::START_TITLE:
+                    $result = $this->parseStartTitle($cursor);
+                    break;
+                case self::TITLE:
+                    $result = $this->parseTitle($cursor);
+                    break;
+                default:
+                    // this should never happen
+                    break;
+            }
+
+            if (! $result) {
+                $this->state = self::PARAGRAPH;
+
+                return;
+            }
+        }
+    }
+
+    private function parseStartDefinition(Cursor $cursor): bool
+    {
+        $cursor->advanceToNextNonSpaceOrTab();
+        if ($cursor->isAtEnd() || $cursor->getCurrentCharacter() !== '[') {
+            return false;
+        }
+
+        $this->state = self::LABEL;
+        $this->label = '';
+
+        $cursor->advance();
+        if ($cursor->isAtEnd()) {
+            $this->label .= "\n";
+        }
+
+        return true;
+    }
+
+    private function parseLabel(Cursor $cursor): bool
+    {
+        $cursor->advanceToNextNonSpaceOrTab();
+
+        $partialLabel = LinkParserHelper::parsePartialLinkLabel($cursor);
+        if ($partialLabel === null) {
+            return false;
+        }
+
+        \assert($this->label !== null);
+        $this->label .= $partialLabel;
+
+        if ($cursor->isAtEnd()) {
+            // label might continue on next line
+            $this->label .= "\n";
+
+            return true;
+        }
+
+        if ($cursor->getCurrentCharacter() !== ']') {
+            return false;
+        }
+
+        $cursor->advance();
+
+        // end of label
+        if ($cursor->getCurrentCharacter() !== ':') {
+            return false;
+        }
+
+        $cursor->advance();
+
+        // spec: A link label can have at most 999 characters inside the square brackets
+        if (\mb_strlen($this->label, 'UTF-8') > 999) {
+            return false;
+        }
+
+        // spec: A link label must contain at least one non-whitespace character
+        if (\trim($this->label) === '') {
+            return false;
+        }
+
+        $cursor->advanceToNextNonSpaceOrTab();
+
+        $this->state = self::DESTINATION;
+
+        return true;
+    }
+
+    private function parseDestination(Cursor $cursor): bool
+    {
+        $cursor->advanceToNextNonSpaceOrTab();
+
+        $destination = LinkParserHelper::parseLinkDestination($cursor);
+        if ($destination === null) {
+            return false;
+        }
+
+        $this->destination = $destination;
+
+        $advanced = $cursor->advanceToNextNonSpaceOrTab();
+        if ($cursor->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->referenceValid = true;
+            $this->paragraph      = '';
+        } elseif ($advanced === 0) {
+            // spec: The title must be separated from the link destination by whitespace
+            return false;
+        }
+
+        $this->state = self::START_TITLE;
+
+        return true;
+    }
+
+    private function parseStartTitle(Cursor $cursor): bool
+    {
+        $cursor->advanceToNextNonSpaceOrTab();
+        if ($cursor->isAtEnd()) {
+            $this->state = self::START_DEFINITION;
+
+            return true;
+        }
+
+        $this->titleDelimiter = null;
+        switch ($c = $cursor->getCurrentCharacter()) {
+            case '"':
+            case "'":
+                $this->titleDelimiter = $c;
+                break;
+            case '(':
+                $this->titleDelimiter = ')';
+                break;
+            default:
+                // no title delimter found
+                break;
+        }
+
+        if ($this->titleDelimiter !== null) {
+            $this->state = self::TITLE;
+            $cursor->advance();
+            if ($cursor->isAtEnd()) {
+                $this->title .= "\n";
+            }
+        } else {
+            $this->finishReference();
+            // There might be another reference instead, try that for the same character.
+            $this->state = self::START_DEFINITION;
+        }
+
+        return true;
+    }
+
+    private function parseTitle(Cursor $cursor): bool
+    {
+        \assert($this->titleDelimiter !== null);
+        $title = LinkParserHelper::parsePartialLinkTitle($cursor, $this->titleDelimiter);
+
+        if ($title === null) {
+            // Invalid title, stop
+            return false;
+        }
+
+        // Did we find the end delimiter?
+        $endDelimiterFound = false;
+        if (\substr($title, -1) === $this->titleDelimiter) {
+            $endDelimiterFound = true;
+            // Chop it off
+            $title = \substr($title, 0, -1);
+        }
+
+        $this->title .= $title;
+
+        if (! $endDelimiterFound && $cursor->isAtEnd()) {
+            // Title still going, continue on next line
+            $this->title .= "\n";
+
+            return true;
+        }
+
+        // We either hit the end delimiter or some extra whitespace
+        $cursor->advanceToNextNonSpaceOrTab();
+        if (! $cursor->isAtEnd()) {
+            // spec: No further non-whitespace characters may occur on the line.
+            return false;
+        }
+
+        $this->referenceValid = true;
+        $this->finishReference();
+        $this->paragraph = '';
+
+        // See if there's another definition
+        $this->state = self::START_DEFINITION;
+
+        return true;
+    }
+
+    private function finishReference(): void
+    {
+        if (! $this->referenceValid) {
+            return;
+        }
+
+        /** @psalm-suppress PossiblyNullArgument -- these can't possibly be null if we're in this state */
+        $this->references[] = new Reference($this->label, $this->destination, $this->title);
+
+        $this->label          = null;
+        $this->referenceValid = false;
+        $this->destination    = null;
+        $this->title          = '';
+        $this->titleDelimiter = null;
+    }
+}

vendor/league/commonmark/src/Reference/ReferenceableInterface.php

@@ -0,0 +1,19 @@
+<?php
+
+/*
+ * This file is part of the league/commonmark package.
+ *
+ * (c) Colin O'Dell <colinodell@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\CommonMark\Reference;
+
+interface ReferenceableInterface
+{
+    public function getReference(): ReferenceInterface;
+}