resolved conflicts

docker/streamline-src/vendor/league/commonmark/src/Extension/Attributes/Util/AttributesHelper.php

@@ -0,0 +1,142 @@
+<?php
+
+/*
+ * This file is part of the league/commonmark package.
+ *
+ * (c) Colin O'Dell <colinodell@gmail.com>
+ * (c) 2015 Martin Hasoň <martin.hason@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\Extension\Attributes\Util;
+
+use League\CommonMark\Node\Node;
+use League\CommonMark\Parser\Cursor;
+use League\CommonMark\Util\RegexHelper;
+
+/**
+ * @internal
+ */
+final class AttributesHelper
+{
+    private const SINGLE_ATTRIBUTE = '\s*([.]-?[_a-z][^\s}]*|[#][^\s}]+|' . RegexHelper::PARTIAL_ATTRIBUTENAME . RegexHelper::PARTIAL_ATTRIBUTEVALUESPEC . ')\s*';
+    private const ATTRIBUTE_LIST   = '/^{:?(' . self::SINGLE_ATTRIBUTE . ')+}/i';
+
+    /**
+     * @return array<string, mixed>
+     */
+    public static function parseAttributes(Cursor $cursor): array
+    {
+        $state = $cursor->saveState();
+        $cursor->advanceToNextNonSpaceOrNewline();
+
+        // Quick check to see if we might have attributes
+        if ($cursor->getCharacter() !== '{') {
+            $cursor->restoreState($state);
+
+            return [];
+        }
+
+        // Attempt to match the entire attribute list expression
+        // While this is less performant than checking for '{' now and '}' later, it simplifies
+        // matching individual attributes since they won't need to look ahead for the closing '}'
+        // while dealing with the fact that attributes can technically contain curly braces.
+        // So we'll just match the start and end braces up front.
+        $attributeExpression = $cursor->match(self::ATTRIBUTE_LIST);
+        if ($attributeExpression === null) {
+            $cursor->restoreState($state);
+
+            return [];
+        }
+
+        // Trim the leading '{' or '{:' and the trailing '}'
+        $attributeExpression = \ltrim(\substr($attributeExpression, 1, -1), ':');
+        $attributeCursor     = new Cursor($attributeExpression);
+
+        /** @var array<string, mixed> $attributes */
+        $attributes = [];
+        while ($attribute = \trim((string) $attributeCursor->match('/^' . self::SINGLE_ATTRIBUTE . '/i'))) {
+            if ($attribute[0] === '#') {
+                $attributes['id'] = \substr($attribute, 1);
+
+                continue;
+            }
+
+            if ($attribute[0] === '.') {
+                $attributes['class'][] = \substr($attribute, 1);
+
+                continue;
+            }
+
+            /** @psalm-suppress PossiblyUndefinedArrayOffset */
+            [$name, $value] = \explode('=', $attribute, 2);
+
+            if ($value === 'true') {
+                $attributes[$name] = true;
+                continue;
+            }
+
+            $first = $value[0];
+            $last  = \substr($value, -1);
+            if (($first === '"' && $last === '"') || ($first === "'" && $last === "'") && \strlen($value) > 1) {
+                $value = \substr($value, 1, -1);
+            }
+
+            if (\strtolower(\trim($name)) === 'class') {
+                foreach (\array_filter(\explode(' ', \trim($value))) as $class) {
+                    $attributes['class'][] = $class;
+                }
+            } else {
+                $attributes[\trim($name)] = \trim($value);
+            }
+        }
+
+        if (isset($attributes['class'])) {
+            $attributes['class'] = \implode(' ', (array) $attributes['class']);
+        }
+
+        return $attributes;
+    }
+
+    /**
+     * @param Node|array<string, mixed> $attributes1
+     * @param Node|array<string, mixed> $attributes2
+     *
+     * @return array<string, mixed>
+     */
+    public static function mergeAttributes($attributes1, $attributes2): array
+    {
+        $attributes = [];
+        foreach ([$attributes1, $attributes2] as $arg) {
+            if ($arg instanceof Node) {
+                $arg = $arg->data->get('attributes');
+            }
+
+            /** @var array<string, mixed> $arg */
+            $arg = (array) $arg;
+            if (isset($arg['class'])) {
+                if (\is_string($arg['class'])) {
+                    $arg['class'] = \array_filter(\explode(' ', \trim($arg['class'])));
+                }
+
+                foreach ($arg['class'] as $class) {
+                    $attributes['class'][] = $class;
+                }
+
+                unset($arg['class']);
+            }
+
+            $attributes = \array_merge($attributes, $arg);
+        }
+
+        if (isset($attributes['class'])) {
+            $attributes['class'] = \implode(' ', $attributes['class']);
+        }
+
+        return $attributes;
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/Autolink/AutolinkExtension.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * 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.
+ */
+
+namespace League\CommonMark\Extension\Autolink;
+
+use League\CommonMark\Environment\EnvironmentBuilderInterface;
+use League\CommonMark\Extension\ConfigurableExtensionInterface;
+use League\Config\ConfigurationBuilderInterface;
+use Nette\Schema\Expect;
+
+final class AutolinkExtension implements ConfigurableExtensionInterface
+{
+    public function configureSchema(ConfigurationBuilderInterface $builder): void
+    {
+        $builder->addSchema('autolink', Expect::structure([
+            'allowed_protocols' => Expect::listOf('string')->default(['http', 'https', 'ftp'])->mergeDefaults(false),
+            'default_protocol' => Expect::string()->default('http'),
+        ]));
+    }
+
+    public function register(EnvironmentBuilderInterface $environment): void
+    {
+        $environment->addInlineParser(new EmailAutolinkParser());
+        $environment->addInlineParser(new UrlAutolinkParser(
+            $environment->getConfiguration()->get('autolink.allowed_protocols'),
+            $environment->getConfiguration()->get('autolink.default_protocol'),
+        ));
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/Autolink/UrlAutolinkParser.php

@@ -0,0 +1,157 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * 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.
+ */
+
+namespace League\CommonMark\Extension\Autolink;
+
+use League\CommonMark\Extension\CommonMark\Node\Inline\Link;
+use League\CommonMark\Parser\Inline\InlineParserInterface;
+use League\CommonMark\Parser\Inline\InlineParserMatch;
+use League\CommonMark\Parser\InlineParserContext;
+
+final class UrlAutolinkParser implements InlineParserInterface
+{
+    private const ALLOWED_AFTER = [null, ' ', "\t", "\n", "\x0b", "\x0c", "\x0d", '*', '_', '~', '('];
+
+    // RegEx adapted from https://github.com/symfony/symfony/blob/6.3/src/Symfony/Component/Validator/Constraints/UrlValidator.php
+    private const REGEX = '~
+        (
+            # Must start with a supported scheme + auth, or "www"
+            (?:
+                (?:%s)://                                                                            # protocol
+                (?:(?:(?:[\_\.\pL\pN-]|%%[0-9A-Fa-f]{2})+:)?((?:[\_\.\pL\pN-]|%%[0-9A-Fa-f]{2})+)@)? # basic auth
+            |www\.)
+            (?:
+                (?:
+                    (?:xn--[a-z0-9-]++\.)*+xn--[a-z0-9-]++            # a domain name using punycode
+                        |
+                    (?:[\pL\pN\pS\pM\-\_]++\.){1,127}[\pL\pN\pM]++    # a multi-level domain name; total length must be 253 bytes or less
+                        |
+                    [a-z0-9\-\_]++                                    # a single-level domain name
+                )\.?
+                    |                                                 # or
+                \d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}                    # an IP address
+                    |                                                 # or
+                \[
+                    (?:(?:(?:(?:(?:(?:(?:[0-9a-f]{1,4})):){6})(?:(?:(?:(?:(?:[0-9a-f]{1,4})):(?:(?:[0-9a-f]{1,4})))|(?:(?:(?:(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9]))\.){3}(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9])))))))|(?:(?:::(?:(?:(?:[0-9a-f]{1,4})):){5})(?:(?:(?:(?:(?:[0-9a-f]{1,4})):(?:(?:[0-9a-f]{1,4})))|(?:(?:(?:(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9]))\.){3}(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9])))))))|(?:(?:(?:(?:(?:[0-9a-f]{1,4})))?::(?:(?:(?:[0-9a-f]{1,4})):){4})(?:(?:(?:(?:(?:[0-9a-f]{1,4})):(?:(?:[0-9a-f]{1,4})))|(?:(?:(?:(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9]))\.){3}(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9])))))))|(?:(?:(?:(?:(?:(?:[0-9a-f]{1,4})):){0,1}(?:(?:[0-9a-f]{1,4})))?::(?:(?:(?:[0-9a-f]{1,4})):){3})(?:(?:(?:(?:(?:[0-9a-f]{1,4})):(?:(?:[0-9a-f]{1,4})))|(?:(?:(?:(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9]))\.){3}(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9])))))))|(?:(?:(?:(?:(?:(?:[0-9a-f]{1,4})):){0,2}(?:(?:[0-9a-f]{1,4})))?::(?:(?:(?:[0-9a-f]{1,4})):){2})(?:(?:(?:(?:(?:[0-9a-f]{1,4})):(?:(?:[0-9a-f]{1,4})))|(?:(?:(?:(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9]))\.){3}(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9])))))))|(?:(?:(?:(?:(?:(?:[0-9a-f]{1,4})):){0,3}(?:(?:[0-9a-f]{1,4})))?::(?:(?:[0-9a-f]{1,4})):)(?:(?:(?:(?:(?:[0-9a-f]{1,4})):(?:(?:[0-9a-f]{1,4})))|(?:(?:(?:(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9]))\.){3}(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9])))))))|(?:(?:(?:(?:(?:(?:[0-9a-f]{1,4})):){0,4}(?:(?:[0-9a-f]{1,4})))?::)(?:(?:(?:(?:(?:[0-9a-f]{1,4})):(?:(?:[0-9a-f]{1,4})))|(?:(?:(?:(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9]))\.){3}(?:(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9])))))))|(?:(?:(?:(?:(?:(?:[0-9a-f]{1,4})):){0,5}(?:(?:[0-9a-f]{1,4})))?::)(?:(?:[0-9a-f]{1,4})))|(?:(?:(?:(?:(?:(?:[0-9a-f]{1,4})):){0,6}(?:(?:[0-9a-f]{1,4})))?::))))
+                \]  # an IPv6 address
+            )
+            (?::[0-9]+)?                              # a port (optional)
+            (?:/ (?:[\pL\pN\-._\~!$&\'()*+,;=:@]|%%[0-9A-Fa-f]{2})* )*        # a path
+            (?:\? (?:[\pL\pN\-._\~!$&\'\[\]()*+,;=:@/?]|%%[0-9A-Fa-f]{2})* )? # a query (optional)
+            (?:\# (?:[\pL\pN\-._\~!$&\'()*+,;=:@/?]|%%[0-9A-Fa-f]{2})* )?     # a fragment (optional)
+        )~ixu';
+
+    /**
+     * @var string[]
+     *
+     * @psalm-readonly
+     */
+    private array $prefixes = ['www.'];
+
+    /**
+     * @psalm-var non-empty-string
+     *
+     * @psalm-readonly
+     */
+    private string $finalRegex;
+
+    private string $defaultProtocol;
+
+    /**
+     * @param array<int, string> $allowedProtocols
+     */
+    public function __construct(array $allowedProtocols = ['http', 'https', 'ftp'], string $defaultProtocol = 'http')
+    {
+        /**
+         * @psalm-suppress PropertyTypeCoercion
+         */
+        $this->finalRegex = \sprintf(self::REGEX, \implode('|', $allowedProtocols));
+
+        foreach ($allowedProtocols as $protocol) {
+            $this->prefixes[] = $protocol . '://';
+        }
+
+        $this->defaultProtocol = $defaultProtocol;
+    }
+
+    public function getMatchDefinition(): InlineParserMatch
+    {
+        return InlineParserMatch::oneOf(...$this->prefixes);
+    }
+
+    public function parse(InlineParserContext $inlineContext): bool
+    {
+        $cursor = $inlineContext->getCursor();
+
+        // Autolinks can only come at the beginning of a line, after whitespace, or certain delimiting characters
+        $previousChar = $cursor->peek(-1);
+        if (! \in_array($previousChar, self::ALLOWED_AFTER, true)) {
+            return false;
+        }
+
+        // Check if we have a valid URL
+        if (! \preg_match($this->finalRegex, $cursor->getRemainder(), $matches)) {
+            return false;
+        }
+
+        $url = $matches[0];
+
+        // Does the URL end with punctuation that should be stripped?
+        if (\preg_match('/(.+?)([?!.,:*_~]+)$/', $url, $matches)) {
+            // Add the punctuation later
+            $url = $matches[1];
+        }
+
+        // Does the URL end with something that looks like an entity reference?
+        if (\preg_match('/(.+)(&[A-Za-z0-9]+;)$/', $url, $matches)) {
+            $url = $matches[1];
+        }
+
+        // Does the URL need unmatched parens chopped off?
+        if (\substr($url, -1) === ')' && ($diff = self::diffParens($url)) > 0) {
+            $url = \substr($url, 0, -$diff);
+        }
+
+        $cursor->advanceBy(\mb_strlen($url, 'UTF-8'));
+
+        // Auto-prefix 'http(s)://' onto 'www' URLs
+        if (\substr($url, 0, 4) === 'www.') {
+            $inlineContext->getContainer()->appendChild(new Link($this->defaultProtocol . '://' . $url, $url));
+
+            return true;
+        }
+
+        $inlineContext->getContainer()->appendChild(new Link($url, $url));
+
+        return true;
+    }
+
+    /**
+     * @psalm-pure
+     */
+    private static function diffParens(string $content): int
+    {
+        // Scan the entire autolink for the total number of parentheses.
+        // If there is a greater number of closing parentheses than opening ones,
+        // we don’t consider ANY of the last characters as part of the autolink,
+        // in order to facilitate including an autolink inside a parenthesis.
+        \preg_match_all('/[()]/', $content, $matches);
+
+        $charCount = ['(' => 0, ')' => 0];
+        foreach ($matches[0] as $char) {
+            $charCount[$char]++;
+        }
+
+        return $charCount[')'] - $charCount['('];
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/CommonMark/Delimiter/Processor/EmphasisDelimiterProcessor.php

@@ -0,0 +1,119 @@
+<?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
+ *
+ * Additional emphasis processing code based on commonmark-java (https://github.com/atlassian/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\Extension\CommonMark\Delimiter\Processor;
+
+use League\CommonMark\Delimiter\DelimiterInterface;
+use League\CommonMark\Delimiter\Processor\CacheableDelimiterProcessorInterface;
+use League\CommonMark\Extension\CommonMark\Node\Inline\Emphasis;
+use League\CommonMark\Extension\CommonMark\Node\Inline\Strong;
+use League\CommonMark\Node\Inline\AbstractStringContainer;
+use League\Config\ConfigurationAwareInterface;
+use League\Config\ConfigurationInterface;
+
+final class EmphasisDelimiterProcessor implements CacheableDelimiterProcessorInterface, ConfigurationAwareInterface
+{
+    /** @psalm-readonly */
+    private string $char;
+
+    /** @psalm-readonly-allow-private-mutation */
+    private ConfigurationInterface $config;
+
+    /**
+     * @param string $char The emphasis character to use (typically '*' or '_')
+     */
+    public function __construct(string $char)
+    {
+        $this->char = $char;
+    }
+
+    public function getOpeningCharacter(): string
+    {
+        return $this->char;
+    }
+
+    public function getClosingCharacter(): string
+    {
+        return $this->char;
+    }
+
+    public function getMinLength(): int
+    {
+        return 1;
+    }
+
+    public function getDelimiterUse(DelimiterInterface $opener, DelimiterInterface $closer): int
+    {
+        // "Multiple of 3" rule for internal delimiter runs
+        if (($opener->canClose() || $closer->canOpen()) && $closer->getOriginalLength() % 3 !== 0 && ($opener->getOriginalLength() + $closer->getOriginalLength()) % 3 === 0) {
+            return 0;
+        }
+
+        // Calculate actual number of delimiters used from this closer
+        if ($opener->getLength() >= 2 && $closer->getLength() >= 2) {
+            if ($this->config->get('commonmark/enable_strong')) {
+                return 2;
+            }
+
+            return 0;
+        }
+
+        if ($this->config->get('commonmark/enable_em')) {
+            return 1;
+        }
+
+        return 0;
+    }
+
+    public function process(AbstractStringContainer $opener, AbstractStringContainer $closer, int $delimiterUse): void
+    {
+        if ($delimiterUse === 1) {
+            $emphasis = new Emphasis($this->char);
+        } elseif ($delimiterUse === 2) {
+            $emphasis = new Strong($this->char . $this->char);
+        } else {
+            return;
+        }
+
+        $next = $opener->next();
+        while ($next !== null && $next !== $closer) {
+            $tmp = $next->next();
+            $emphasis->appendChild($next);
+            $next = $tmp;
+        }
+
+        $opener->insertAfter($emphasis);
+    }
+
+    public function setConfiguration(ConfigurationInterface $configuration): void
+    {
+        $this->config = $configuration;
+    }
+
+    public function getCacheKey(DelimiterInterface $closer): string
+    {
+        return \sprintf(
+            '%s-%s-%d-%d',
+            $this->char,
+            $closer->canOpen() ? 'canOpen' : 'cannotOpen',
+            $closer->getOriginalLength() % 3,
+            $closer->getLength(),
+        );
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/CommonMark/Node/Block/ListBlock.php

@@ -0,0 +1,56 @@
+<?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\Extension\CommonMark\Node\Block;
+
+use League\CommonMark\Node\Block\AbstractBlock;
+use League\CommonMark\Node\Block\TightBlockInterface;
+
+class ListBlock extends AbstractBlock implements TightBlockInterface
+{
+    public const TYPE_BULLET  = 'bullet';
+    public const TYPE_ORDERED = 'ordered';
+
+    public const DELIM_PERIOD = 'period';
+    public const DELIM_PAREN  = 'paren';
+
+    protected bool $tight = false; // TODO Make lists tight by default in v3
+
+    /** @psalm-readonly */
+    protected ListData $listData;
+
+    public function __construct(ListData $listData)
+    {
+        parent::__construct();
+
+        $this->listData = $listData;
+    }
+
+    public function getListData(): ListData
+    {
+        return $this->listData;
+    }
+
+    public function isTight(): bool
+    {
+        return $this->tight;
+    }
+
+    public function setTight(bool $tight): void
+    {
+        $this->tight = $tight;
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/CommonMark/Parser/Block/FencedCodeParser.php

@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * 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.
+ */
+
+namespace League\CommonMark\Extension\CommonMark\Parser\Block;
+
+use League\CommonMark\Extension\CommonMark\Node\Block\FencedCode;
+use League\CommonMark\Parser\Block\AbstractBlockContinueParser;
+use League\CommonMark\Parser\Block\BlockContinue;
+use League\CommonMark\Parser\Block\BlockContinueParserInterface;
+use League\CommonMark\Parser\Cursor;
+use League\CommonMark\Util\ArrayCollection;
+use League\CommonMark\Util\RegexHelper;
+
+final class FencedCodeParser extends AbstractBlockContinueParser
+{
+    /** @psalm-readonly */
+    private FencedCode $block;
+
+    /** @var ArrayCollection<string> */
+    private ArrayCollection $strings;
+
+    public function __construct(int $fenceLength, string $fenceChar, int $fenceOffset)
+    {
+        $this->block   = new FencedCode($fenceLength, $fenceChar, $fenceOffset);
+        $this->strings = new ArrayCollection();
+    }
+
+    public function getBlock(): FencedCode
+    {
+        return $this->block;
+    }
+
+    public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
+    {
+        // Check for closing code fence
+        if (! $cursor->isIndented() && $cursor->getNextNonSpaceCharacter() === $this->block->getChar()) {
+            $match = RegexHelper::matchFirst('/^(?:`{3,}|~{3,})(?=[ \t]*$)/', $cursor->getLine(), $cursor->getNextNonSpacePosition());
+            if ($match !== null && \strlen($match[0]) >= $this->block->getLength()) {
+                // closing fence - we're at end of line, so we can finalize now
+                return BlockContinue::finished();
+            }
+        }
+
+        // Skip optional spaces of fence offset
+        // Optimization: don't attempt to match if we're at a non-space position
+        if ($cursor->getNextNonSpacePosition() > $cursor->getPosition()) {
+            $cursor->match('/^ {0,' . $this->block->getOffset() . '}/');
+        }
+
+        return BlockContinue::at($cursor);
+    }
+
+    public function addLine(string $line): void
+    {
+        $this->strings[] = $line;
+    }
+
+    public function closeBlock(): void
+    {
+        // first line becomes info string
+        $firstLine = $this->strings->first();
+        if ($firstLine === false) {
+            $firstLine = '';
+        }
+
+        $this->block->setInfo(RegexHelper::unescape(\trim($firstLine)));
+
+        if ($this->strings->count() === 1) {
+            $this->block->setLiteral('');
+        } else {
+            $this->block->setLiteral(\implode("\n", $this->strings->slice(1)) . "\n");
+        }
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/CommonMark/Parser/Block/IndentedCodeParser.php

@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * 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.
+ */
+
+namespace League\CommonMark\Extension\CommonMark\Parser\Block;
+
+use League\CommonMark\Extension\CommonMark\Node\Block\IndentedCode;
+use League\CommonMark\Parser\Block\AbstractBlockContinueParser;
+use League\CommonMark\Parser\Block\BlockContinue;
+use League\CommonMark\Parser\Block\BlockContinueParserInterface;
+use League\CommonMark\Parser\Cursor;
+use League\CommonMark\Util\ArrayCollection;
+
+final class IndentedCodeParser extends AbstractBlockContinueParser
+{
+    /** @psalm-readonly */
+    private IndentedCode $block;
+
+    /** @var ArrayCollection<string> */
+    private ArrayCollection $strings;
+
+    public function __construct()
+    {
+        $this->block   = new IndentedCode();
+        $this->strings = new ArrayCollection();
+    }
+
+    public function getBlock(): IndentedCode
+    {
+        return $this->block;
+    }
+
+    public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
+    {
+        if ($cursor->isIndented()) {
+            $cursor->advanceBy(Cursor::INDENT_LEVEL, true);
+
+            return BlockContinue::at($cursor);
+        }
+
+        if ($cursor->isBlank()) {
+            $cursor->advanceToNextNonSpaceOrTab();
+
+            return BlockContinue::at($cursor);
+        }
+
+        return BlockContinue::none();
+    }
+
+    public function addLine(string $line): void
+    {
+        $this->strings[] = $line;
+    }
+
+    public function closeBlock(): void
+    {
+        $lines = $this->strings->toArray();
+
+        // Note that indented code block cannot be empty, so $lines will always have at least one non-empty element
+        while (\preg_match('/^[ \t]*$/', \end($lines))) { // @phpstan-ignore-line
+            \array_pop($lines);
+        }
+
+        $this->block->setLiteral(\implode("\n", $lines) . "\n");
+        $this->block->setEndLine($this->block->getStartLine() + \count($lines) - 1);
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/CommonMark/Parser/Block/ListBlockParser.php

@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * 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.
+ */
+
+namespace League\CommonMark\Extension\CommonMark\Parser\Block;
+
+use League\CommonMark\Extension\CommonMark\Node\Block\ListBlock;
+use League\CommonMark\Extension\CommonMark\Node\Block\ListData;
+use League\CommonMark\Extension\CommonMark\Node\Block\ListItem;
+use League\CommonMark\Node\Block\AbstractBlock;
+use League\CommonMark\Parser\Block\AbstractBlockContinueParser;
+use League\CommonMark\Parser\Block\BlockContinue;
+use League\CommonMark\Parser\Block\BlockContinueParserInterface;
+use League\CommonMark\Parser\Cursor;
+
+final class ListBlockParser extends AbstractBlockContinueParser
+{
+    /** @psalm-readonly */
+    private ListBlock $block;
+
+    public function __construct(ListData $listData)
+    {
+        $this->block = new ListBlock($listData);
+    }
+
+    public function getBlock(): ListBlock
+    {
+        return $this->block;
+    }
+
+    public function isContainer(): bool
+    {
+        return true;
+    }
+
+    public function canContain(AbstractBlock $childBlock): bool
+    {
+        return $childBlock instanceof ListItem;
+    }
+
+    public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
+    {
+        // List blocks themselves don't have any markers, only list items. So try to stay in the list.
+        // If there is a block start other than list item, canContain makes sure that this list is closed.
+        return BlockContinue::at($cursor);
+    }
+
+    public function closeBlock(): void
+    {
+        $item = $this->block->firstChild();
+        while ($item instanceof AbstractBlock) {
+            // check for non-final list item ending with blank line:
+            if ($item->next() !== null && self::endsWithBlankLine($item)) {
+                $this->block->setTight(false);
+                break;
+            }
+
+            // recurse into children of list item, to see if there are spaces between any of them
+            $subitem = $item->firstChild();
+            while ($subitem instanceof AbstractBlock) {
+                if ($subitem->next() && self::endsWithBlankLine($subitem)) {
+                    $this->block->setTight(false);
+                    break 2;
+                }
+
+                $subitem = $subitem->next();
+            }
+
+            $item = $item->next();
+        }
+
+        $lastChild = $this->block->lastChild();
+        if ($lastChild instanceof AbstractBlock) {
+            $this->block->setEndLine($lastChild->getEndLine());
+        }
+    }
+
+    private static function endsWithBlankLine(AbstractBlock $block): bool
+    {
+        $next = $block->next();
+
+        return $next instanceof AbstractBlock && $block->getEndLine() !== $next->getStartLine() - 1;
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/CommonMark/Parser/Block/ListBlockStartParser.php

@@ -0,0 +1,154 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * 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.
+ */
+
+namespace League\CommonMark\Extension\CommonMark\Parser\Block;
+
+use League\CommonMark\Extension\CommonMark\Node\Block\ListBlock;
+use League\CommonMark\Extension\CommonMark\Node\Block\ListData;
+use League\CommonMark\Parser\Block\BlockStart;
+use League\CommonMark\Parser\Block\BlockStartParserInterface;
+use League\CommonMark\Parser\Cursor;
+use League\CommonMark\Parser\MarkdownParserStateInterface;
+use League\CommonMark\Util\RegexHelper;
+use League\Config\ConfigurationAwareInterface;
+use League\Config\ConfigurationInterface;
+
+final class ListBlockStartParser implements BlockStartParserInterface, ConfigurationAwareInterface
+{
+    /** @psalm-readonly-allow-private-mutation */
+    private ?ConfigurationInterface $config = null;
+
+    /**
+     * @psalm-var non-empty-string|null
+     *
+     * @psalm-readonly-allow-private-mutation
+     */
+    private ?string $listMarkerRegex = null;
+
+    public function setConfiguration(ConfigurationInterface $configuration): void
+    {
+        $this->config = $configuration;
+    }
+
+    public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
+    {
+        if ($cursor->isIndented()) {
+            return BlockStart::none();
+        }
+
+        $listData = $this->parseList($cursor, $parserState->getParagraphContent() !== null);
+        if ($listData === null) {
+            return BlockStart::none();
+        }
+
+        $listItemParser = new ListItemParser($listData);
+
+        // prepend the list block if needed
+        $matched = $parserState->getLastMatchedBlockParser();
+        if (! ($matched instanceof ListBlockParser) || ! $listData->equals($matched->getBlock()->getListData())) {
+            $listBlockParser = new ListBlockParser($listData);
+            // We start out with assuming a list is tight. If we find a blank line, we set it to loose later.
+            // TODO for 3.0: Just make them tight by default in the block so we can remove this call
+            $listBlockParser->getBlock()->setTight(true);
+
+            return BlockStart::of($listBlockParser, $listItemParser)->at($cursor);
+        }
+
+        return BlockStart::of($listItemParser)->at($cursor);
+    }
+
+    private function parseList(Cursor $cursor, bool $inParagraph): ?ListData
+    {
+        $indent = $cursor->getIndent();
+
+        $tmpCursor = clone $cursor;
+        $tmpCursor->advanceToNextNonSpaceOrTab();
+        $rest = $tmpCursor->getRemainder();
+
+        if (\preg_match($this->listMarkerRegex ?? $this->generateListMarkerRegex(), $rest) === 1) {
+            $data               = new ListData();
+            $data->markerOffset = $indent;
+            $data->type         = ListBlock::TYPE_BULLET;
+            $data->delimiter    = null;
+            $data->bulletChar   = $rest[0];
+            $markerLength       = 1;
+        } elseif (($matches = RegexHelper::matchFirst('/^(\d{1,9})([.)])/', $rest)) && (! $inParagraph || $matches[1] === '1')) {
+            $data               = new ListData();
+            $data->markerOffset = $indent;
+            $data->type         = ListBlock::TYPE_ORDERED;
+            $data->start        = (int) $matches[1];
+            $data->delimiter    = $matches[2] === '.' ? ListBlock::DELIM_PERIOD : ListBlock::DELIM_PAREN;
+            $data->bulletChar   = null;
+            $markerLength       = \strlen($matches[0]);
+        } else {
+            return null;
+        }
+
+        // Make sure we have spaces after
+        $nextChar = $tmpCursor->peek($markerLength);
+        if (! ($nextChar === null || $nextChar === "\t" || $nextChar === ' ')) {
+            return null;
+        }
+
+        // If it interrupts paragraph, make sure first line isn't blank
+        if ($inParagraph && ! RegexHelper::matchAt(RegexHelper::REGEX_NON_SPACE, $rest, $markerLength)) {
+            return null;
+        }
+
+        $cursor->advanceToNextNonSpaceOrTab(); // to start of marker
+        $cursor->advanceBy($markerLength, true); // to end of marker
+        $data->padding = self::calculateListMarkerPadding($cursor, $markerLength);
+
+        return $data;
+    }
+
+    private static function calculateListMarkerPadding(Cursor $cursor, int $markerLength): int
+    {
+        $start          = $cursor->saveState();
+        $spacesStartCol = $cursor->getColumn();
+
+        while ($cursor->getColumn() - $spacesStartCol < 5) {
+            if (! $cursor->advanceBySpaceOrTab()) {
+                break;
+            }
+        }
+
+        $blankItem         = $cursor->peek() === null;
+        $spacesAfterMarker = $cursor->getColumn() - $spacesStartCol;
+
+        if ($spacesAfterMarker >= 5 || $spacesAfterMarker < 1 || $blankItem) {
+            $cursor->restoreState($start);
+            $cursor->advanceBySpaceOrTab();
+
+            return $markerLength + 1;
+        }
+
+        return $markerLength + $spacesAfterMarker;
+    }
+
+    /**
+     * @psalm-return non-empty-string
+     */
+    private function generateListMarkerRegex(): string
+    {
+        // No configuration given - use the defaults
+        if ($this->config === null) {
+            return $this->listMarkerRegex = '/^[*+-]/';
+        }
+
+        $markers = $this->config->get('commonmark/unordered_list_markers');
+        \assert(\is_array($markers));
+
+        return $this->listMarkerRegex = '/^[' . \preg_quote(\implode('', $markers), '/') . ']/';
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/CommonMark/Parser/Block/ListItemParser.php

@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * 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.
+ */
+
+namespace League\CommonMark\Extension\CommonMark\Parser\Block;
+
+use League\CommonMark\Extension\CommonMark\Node\Block\ListData;
+use League\CommonMark\Extension\CommonMark\Node\Block\ListItem;
+use League\CommonMark\Node\Block\AbstractBlock;
+use League\CommonMark\Parser\Block\AbstractBlockContinueParser;
+use League\CommonMark\Parser\Block\BlockContinue;
+use League\CommonMark\Parser\Block\BlockContinueParserInterface;
+use League\CommonMark\Parser\Cursor;
+
+final class ListItemParser extends AbstractBlockContinueParser
+{
+    /** @psalm-readonly */
+    private ListItem $block;
+
+    public function __construct(ListData $listData)
+    {
+        $this->block = new ListItem($listData);
+    }
+
+    public function getBlock(): ListItem
+    {
+        return $this->block;
+    }
+
+    public function isContainer(): bool
+    {
+        return true;
+    }
+
+    public function canContain(AbstractBlock $childBlock): bool
+    {
+        return ! $childBlock instanceof ListItem;
+    }
+
+    public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
+    {
+        if ($cursor->isBlank()) {
+            if ($this->block->firstChild() === null) {
+                // Blank line after empty list item
+                return BlockContinue::none();
+            }
+
+            $cursor->advanceToNextNonSpaceOrTab();
+
+            return BlockContinue::at($cursor);
+        }
+
+        $contentIndent = $this->block->getListData()->markerOffset + $this->getBlock()->getListData()->padding;
+        if ($cursor->getIndent() >= $contentIndent) {
+            $cursor->advanceBy($contentIndent, true);
+
+            return BlockContinue::at($cursor);
+        }
+
+        // Note: We'll hit this case for lazy continuation lines, they will get added later.
+        return BlockContinue::none();
+    }
+
+    public function closeBlock(): void
+    {
+        if (($lastChild = $this->block->lastChild()) instanceof AbstractBlock) {
+            $this->block->setEndLine($lastChild->getEndLine());
+        } else {
+            // Empty list item
+            $this->block->setEndLine($this->block->getStartLine());
+        }
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/CommonMark/Parser/Inline/BacktickParser.php

@@ -0,0 +1,132 @@
+<?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\Extension\CommonMark\Parser\Inline;
+
+use League\CommonMark\Extension\CommonMark\Node\Inline\Code;
+use League\CommonMark\Node\Inline\Text;
+use League\CommonMark\Parser\Cursor;
+use League\CommonMark\Parser\Inline\InlineParserInterface;
+use League\CommonMark\Parser\Inline\InlineParserMatch;
+use League\CommonMark\Parser\InlineParserContext;
+
+final class BacktickParser implements InlineParserInterface
+{
+    /**
+     * Max bound for backtick code span delimiters.
+     *
+     * @see https://github.com/commonmark/cmark/commit/8ed5c9d
+     */
+    private const MAX_BACKTICKS = 1000;
+
+    /** @var \WeakReference<Cursor>|null */
+    private ?\WeakReference $lastCursor = null;
+    private bool $lastCursorScanned     = false;
+
+    /** @var array<int, int> backtick count => position of known ender */
+    private array $seenBackticks = [];
+
+    public function getMatchDefinition(): InlineParserMatch
+    {
+        return InlineParserMatch::regex('`+');
+    }
+
+    public function parse(InlineParserContext $inlineContext): bool
+    {
+        $ticks  = $inlineContext->getFullMatch();
+        $cursor = $inlineContext->getCursor();
+        $cursor->advanceBy($inlineContext->getFullMatchLength());
+
+        $currentPosition = $cursor->getPosition();
+        $previousState   = $cursor->saveState();
+
+        if ($this->findMatchingTicks(\strlen($ticks), $cursor)) {
+            $code = $cursor->getSubstring($currentPosition, $cursor->getPosition() - $currentPosition - \strlen($ticks));
+
+            $c = \preg_replace('/\n/m', ' ', $code) ?? '';
+
+            if (
+                $c !== '' &&
+                $c[0] === ' ' &&
+                \substr($c, -1, 1) === ' ' &&
+                \preg_match('/[^ ]/', $c)
+            ) {
+                $c = \substr($c, 1, -1);
+            }
+
+            $inlineContext->getContainer()->appendChild(new Code($c));
+
+            return true;
+        }
+
+        // If we got here, we didn't match a closing backtick sequence
+        $cursor->restoreState($previousState);
+        $inlineContext->getContainer()->appendChild(new Text($ticks));
+
+        return true;
+    }
+
+    /**
+     * Locates the matching closer for a backtick code span.
+     *
+     * Leverages some caching to avoid traversing the same cursor multiple times when
+     * we've already seen all the potential backtick closers.
+     *
+     * @see https://github.com/commonmark/cmark/commit/8ed5c9d
+     *
+     * @param int    $openTickLength Number of backticks in the opening sequence
+     * @param Cursor $cursor         Cursor to scan
+     *
+     * @return bool True if a matching closer was found, false otherwise
+     */
+    private function findMatchingTicks(int $openTickLength, Cursor $cursor): bool
+    {
+        // Reset the seenBackticks cache if this is a new cursor
+        if ($this->lastCursor === null || $this->lastCursor->get() !== $cursor) {
+            $this->seenBackticks     = [];
+            $this->lastCursor        = \WeakReference::create($cursor);
+            $this->lastCursorScanned = false;
+        }
+
+        if ($openTickLength > self::MAX_BACKTICKS) {
+            return false;
+        }
+
+        // Return if we already know there's no closer
+        if ($this->lastCursorScanned && isset($this->seenBackticks[$openTickLength]) && $this->seenBackticks[$openTickLength] <= $cursor->getPosition()) {
+            return false;
+        }
+
+        while ($ticks = $cursor->match('/`{1,' . self::MAX_BACKTICKS . '}/m')) {
+            $numTicks = \strlen($ticks);
+
+            // Did we find the closer?
+            if ($numTicks === $openTickLength) {
+                return true;
+            }
+
+            // Store position of closer
+            if ($numTicks <= self::MAX_BACKTICKS) {
+                $this->seenBackticks[$numTicks] = $cursor->getPosition() - $numTicks;
+            }
+        }
+
+        // Got through whole input without finding closer
+        $this->lastCursorScanned = true;
+
+        return false;
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/CommonMark/Parser/Inline/BangParser.php

@@ -0,0 +1,44 @@
+<?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\Extension\CommonMark\Parser\Inline;
+
+use League\CommonMark\Node\Inline\Text;
+use League\CommonMark\Parser\Inline\InlineParserInterface;
+use League\CommonMark\Parser\Inline\InlineParserMatch;
+use League\CommonMark\Parser\InlineParserContext;
+
+final class BangParser implements InlineParserInterface
+{
+    public function getMatchDefinition(): InlineParserMatch
+    {
+        return InlineParserMatch::string('![');
+    }
+
+    public function parse(InlineParserContext $inlineContext): bool
+    {
+        $cursor = $inlineContext->getCursor();
+        $cursor->advanceBy(2);
+
+        $node = new Text('![', ['delim' => true]);
+        $inlineContext->getContainer()->appendChild($node);
+
+        // Add entry to stack for this opener
+        $inlineContext->getDelimiterStack()->addBracket($node, $cursor->getPosition(), true);
+
+        return true;
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/CommonMark/Parser/Inline/CloseBracketParser.php

@@ -0,0 +1,214 @@
+<?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\Extension\CommonMark\Parser\Inline;
+
+use League\CommonMark\Delimiter\Bracket;
+use League\CommonMark\Environment\EnvironmentAwareInterface;
+use League\CommonMark\Environment\EnvironmentInterface;
+use League\CommonMark\Extension\CommonMark\Node\Inline\AbstractWebResource;
+use League\CommonMark\Extension\CommonMark\Node\Inline\Image;
+use League\CommonMark\Extension\CommonMark\Node\Inline\Link;
+use League\CommonMark\Extension\Mention\Mention;
+use League\CommonMark\Node\Inline\AdjacentTextMerger;
+use League\CommonMark\Node\Inline\Text;
+use League\CommonMark\Parser\Cursor;
+use League\CommonMark\Parser\Inline\InlineParserInterface;
+use League\CommonMark\Parser\Inline\InlineParserMatch;
+use League\CommonMark\Parser\InlineParserContext;
+use League\CommonMark\Reference\ReferenceInterface;
+use League\CommonMark\Reference\ReferenceMapInterface;
+use League\CommonMark\Util\LinkParserHelper;
+use League\CommonMark\Util\RegexHelper;
+
+final class CloseBracketParser implements InlineParserInterface, EnvironmentAwareInterface
+{
+    /** @psalm-readonly-allow-private-mutation */
+    private EnvironmentInterface $environment;
+
+    public function getMatchDefinition(): InlineParserMatch
+    {
+        return InlineParserMatch::string(']');
+    }
+
+    public function parse(InlineParserContext $inlineContext): bool
+    {
+        // Look through stack of delimiters for a [ or !
+        $opener = $inlineContext->getDelimiterStack()->getLastBracket();
+        if ($opener === null) {
+            return false;
+        }
+
+        if (! $opener->isImage() && ! $opener->isActive()) {
+            // no matched opener; remove from stack
+            $inlineContext->getDelimiterStack()->removeBracket();
+
+            return false;
+        }
+
+        $cursor = $inlineContext->getCursor();
+
+        $startPos      = $cursor->getPosition();
+        $previousState = $cursor->saveState();
+
+        $cursor->advanceBy(1);
+
+        // Check to see if we have a link/image
+
+        // Inline link?
+        if ($result = $this->tryParseInlineLinkAndTitle($cursor)) {
+            $link = $result;
+        } elseif ($link = $this->tryParseReference($cursor, $inlineContext->getReferenceMap(), $opener, $startPos)) {
+            $reference = $link;
+            $link      = ['url' => $link->getDestination(), 'title' => $link->getTitle()];
+        } else {
+            // No match; remove this opener from stack
+            $inlineContext->getDelimiterStack()->removeBracket();
+            $cursor->restoreState($previousState);
+
+            return false;
+        }
+
+        $inline = $this->createInline($link['url'], $link['title'], $opener->isImage(), $reference ?? null);
+        $opener->getNode()->replaceWith($inline);
+        while (($label = $inline->next()) !== null) {
+            // Is there a Mention or Link contained within this link?
+            // CommonMark does not allow nested links, so we'll restore the original text.
+            if ($label instanceof Mention) {
+                $label->replaceWith($replacement = new Text($label->getPrefix() . $label->getIdentifier()));
+                $inline->appendChild($replacement);
+            } elseif ($label instanceof Link) {
+                foreach ($label->children() as $child) {
+                    $label->insertBefore($child);
+                }
+
+                $label->detach();
+            } else {
+                $inline->appendChild($label);
+            }
+        }
+
+        // Process delimiters such as emphasis inside link/image
+        $delimiterStack = $inlineContext->getDelimiterStack();
+        $stackBottom    = $opener->getPosition();
+        $delimiterStack->processDelimiters($stackBottom, $this->environment->getDelimiterProcessors());
+        $delimiterStack->removeBracket();
+        $delimiterStack->removeAll($stackBottom);
+
+        // Merge any adjacent Text nodes together
+        AdjacentTextMerger::mergeChildNodes($inline);
+
+        // processEmphasis will remove this and later delimiters.
+        // Now, for a link, we also remove earlier link openers (no links in links)
+        if (! $opener->isImage()) {
+            $inlineContext->getDelimiterStack()->deactivateLinkOpeners();
+        }
+
+        return true;
+    }
+
+    public function setEnvironment(EnvironmentInterface $environment): void
+    {
+        $this->environment = $environment;
+    }
+
+    /**
+     * @return array<string, string>|null
+     */
+    private function tryParseInlineLinkAndTitle(Cursor $cursor): ?array
+    {
+        if ($cursor->getCurrentCharacter() !== '(') {
+            return null;
+        }
+
+        $previousState = $cursor->saveState();
+
+        $cursor->advanceBy(1);
+        $cursor->advanceToNextNonSpaceOrNewline();
+        if (($dest = LinkParserHelper::parseLinkDestination($cursor)) === null) {
+            $cursor->restoreState($previousState);
+
+            return null;
+        }
+
+        $cursor->advanceToNextNonSpaceOrNewline();
+        $previousCharacter = $cursor->peek(-1);
+        // We know from previous lines that we've advanced at least one space so far, so this next call should never be null
+        \assert(\is_string($previousCharacter));
+
+        $title = '';
+        // make sure there's a space before the title:
+        if (\preg_match(RegexHelper::REGEX_WHITESPACE_CHAR, $previousCharacter)) {
+            $title = LinkParserHelper::parseLinkTitle($cursor) ?? '';
+        }
+
+        $cursor->advanceToNextNonSpaceOrNewline();
+
+        if ($cursor->getCurrentCharacter() !== ')') {
+            $cursor->restoreState($previousState);
+
+            return null;
+        }
+
+        $cursor->advanceBy(1);
+
+        return ['url' => $dest, 'title' => $title];
+    }
+
+    private function tryParseReference(Cursor $cursor, ReferenceMapInterface $referenceMap, Bracket $opener, int $startPos): ?ReferenceInterface
+    {
+        $savePos     = $cursor->saveState();
+        $beforeLabel = $cursor->getPosition();
+        $n           = LinkParserHelper::parseLinkLabel($cursor);
+        if ($n > 2) {
+            $start  = $beforeLabel + 1;
+            $length = $n - 2;
+        } elseif (! $opener->hasNext()) {
+            // Empty or missing second label means to use the first label as the reference.
+            // The reference must not contain a bracket. If we know there's a bracket, we don't even bother checking it.
+            $start  = $opener->getPosition();
+            $length = $startPos - $start;
+        } else {
+            $cursor->restoreState($savePos);
+
+            return null;
+        }
+
+        $referenceLabel = $cursor->getSubstring($start, $length);
+
+        if ($n === 0) {
+            // If shortcut reference link, rewind before spaces we skipped
+            $cursor->restoreState($savePos);
+        }
+
+        return $referenceMap->get($referenceLabel);
+    }
+
+    private function createInline(string $url, string $title, bool $isImage, ?ReferenceInterface $reference = null): AbstractWebResource
+    {
+        if ($isImage) {
+            $inline = new Image($url, null, $title);
+        } else {
+            $inline = new Link($url, null, $title);
+        }
+
+        if ($reference) {
+            $inline->data->set('reference', $reference);
+        }
+
+        return $inline;
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/CommonMark/Parser/Inline/OpenBracketParser.php

@@ -0,0 +1,42 @@
+<?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\Extension\CommonMark\Parser\Inline;
+
+use League\CommonMark\Node\Inline\Text;
+use League\CommonMark\Parser\Inline\InlineParserInterface;
+use League\CommonMark\Parser\Inline\InlineParserMatch;
+use League\CommonMark\Parser\InlineParserContext;
+
+final class OpenBracketParser implements InlineParserInterface
+{
+    public function getMatchDefinition(): InlineParserMatch
+    {
+        return InlineParserMatch::string('[');
+    }
+
+    public function parse(InlineParserContext $inlineContext): bool
+    {
+        $inlineContext->getCursor()->advanceBy(1);
+        $node = new Text('[', ['delim' => true]);
+        $inlineContext->getContainer()->appendChild($node);
+
+        // Add entry to stack for this opener
+        $inlineContext->getDelimiterStack()->addBracket($node, $inlineContext->getCursor()->getPosition(), false);
+
+        return true;
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/CommonMark/Renderer/Block/ListItemRenderer.php

@@ -0,0 +1,80 @@
+<?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\Extension\CommonMark\Renderer\Block;
+
+use League\CommonMark\Extension\CommonMark\Node\Block\ListItem;
+use League\CommonMark\Node\Block\AbstractBlock;
+use League\CommonMark\Node\Block\Paragraph;
+use League\CommonMark\Node\Block\TightBlockInterface;
+use League\CommonMark\Node\Node;
+use League\CommonMark\Renderer\ChildNodeRendererInterface;
+use League\CommonMark\Renderer\NodeRendererInterface;
+use League\CommonMark\Util\HtmlElement;
+use League\CommonMark\Xml\XmlNodeRendererInterface;
+
+final class ListItemRenderer implements NodeRendererInterface, XmlNodeRendererInterface
+{
+    /**
+     * @param ListItem $node
+     *
+     * {@inheritDoc}
+     *
+     * @psalm-suppress MoreSpecificImplementedParamType
+     */
+    public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
+    {
+        ListItem::assertInstanceOf($node);
+
+        $contents = $childRenderer->renderNodes($node->children());
+
+        $inTightList = ($parent = $node->parent()) && $parent instanceof TightBlockInterface && $parent->isTight();
+
+        if ($this->needsBlockSeparator($node->firstChild(), $inTightList)) {
+            $contents = "\n" . $contents;
+        }
+
+        if ($this->needsBlockSeparator($node->lastChild(), $inTightList)) {
+            $contents .= "\n";
+        }
+
+        $attrs = $node->data->get('attributes');
+
+        return new HtmlElement('li', $attrs, $contents);
+    }
+
+    public function getXmlTagName(Node $node): string
+    {
+        return 'item';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getXmlAttributes(Node $node): array
+    {
+        return [];
+    }
+
+    private function needsBlockSeparator(?Node $child, bool $inTightList): bool
+    {
+        if ($child instanceof Paragraph && $inTightList) {
+            return false;
+        }
+
+        return $child instanceof AbstractBlock;
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/SmartPunct/QuoteParser.php

@@ -0,0 +1,98 @@
+<?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 (http://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\Extension\SmartPunct;
+
+use League\CommonMark\Delimiter\Delimiter;
+use League\CommonMark\Parser\Inline\InlineParserInterface;
+use League\CommonMark\Parser\Inline\InlineParserMatch;
+use League\CommonMark\Parser\InlineParserContext;
+use League\CommonMark\Util\RegexHelper;
+
+final class QuoteParser implements InlineParserInterface
+{
+    /**
+     * @deprecated This constant is no longer used and will be removed in a future major release
+     */
+    public const DOUBLE_QUOTES = [Quote::DOUBLE_QUOTE, Quote::DOUBLE_QUOTE_OPENER, Quote::DOUBLE_QUOTE_CLOSER];
+
+    /**
+     * @deprecated This constant is no longer used and will be removed in a future major release
+     */
+    public const SINGLE_QUOTES = [Quote::SINGLE_QUOTE, Quote::SINGLE_QUOTE_OPENER, Quote::SINGLE_QUOTE_CLOSER];
+
+    public function getMatchDefinition(): InlineParserMatch
+    {
+        return InlineParserMatch::oneOf(Quote::SINGLE_QUOTE, Quote::DOUBLE_QUOTE);
+    }
+
+    /**
+     * Normalizes any quote characters found and manually adds them to the delimiter stack
+     */
+    public function parse(InlineParserContext $inlineContext): bool
+    {
+        $char   = $inlineContext->getFullMatch();
+        $cursor = $inlineContext->getCursor();
+        $index  = $cursor->getPosition();
+
+        $charBefore = $cursor->peek(-1);
+        if ($charBefore === null) {
+            $charBefore = "\n";
+        }
+
+        $cursor->advance();
+
+        $charAfter = $cursor->getCurrentCharacter();
+        if ($charAfter === null) {
+            $charAfter = "\n";
+        }
+
+        [$leftFlanking, $rightFlanking] = $this->determineFlanking($charBefore, $charAfter);
+        $canOpen                        = $leftFlanking && ! $rightFlanking;
+        $canClose                       = $rightFlanking;
+
+        $node = new Quote($char, ['delim' => true]);
+        $inlineContext->getContainer()->appendChild($node);
+
+        // Add entry to stack to this opener
+        $inlineContext->getDelimiterStack()->push(new Delimiter($char, 1, $node, $canOpen, $canClose, $index));
+
+        return true;
+    }
+
+    /**
+     * @return bool[]
+     */
+    private function determineFlanking(string $charBefore, string $charAfter): array
+    {
+        $afterIsWhitespace   = \preg_match('/\pZ|\s/u', $charAfter);
+        $afterIsPunctuation  = \preg_match(RegexHelper::REGEX_PUNCTUATION, $charAfter);
+        $beforeIsWhitespace  = \preg_match('/\pZ|\s/u', $charBefore);
+        $beforeIsPunctuation = \preg_match(RegexHelper::REGEX_PUNCTUATION, $charBefore);
+
+        $leftFlanking = ! $afterIsWhitespace &&
+            ! ($afterIsPunctuation &&
+                ! $beforeIsWhitespace &&
+                ! $beforeIsPunctuation);
+
+        $rightFlanking = ! $beforeIsWhitespace &&
+            ! ($beforeIsPunctuation &&
+                ! $afterIsWhitespace &&
+                ! $afterIsPunctuation);
+
+        return [$leftFlanking, $rightFlanking];
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/Strikethrough/StrikethroughDelimiterProcessor.php

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the league/commonmark package.
+ *
+ * (c) Colin O'Dell <colinodell@gmail.com> and uAfrica.com (http://uafrica.com)
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace League\CommonMark\Extension\Strikethrough;
+
+use League\CommonMark\Delimiter\DelimiterInterface;
+use League\CommonMark\Delimiter\Processor\CacheableDelimiterProcessorInterface;
+use League\CommonMark\Node\Inline\AbstractStringContainer;
+
+final class StrikethroughDelimiterProcessor implements CacheableDelimiterProcessorInterface
+{
+    public function getOpeningCharacter(): string
+    {
+        return '~';
+    }
+
+    public function getClosingCharacter(): string
+    {
+        return '~';
+    }
+
+    public function getMinLength(): int
+    {
+        return 1;
+    }
+
+    public function getDelimiterUse(DelimiterInterface $opener, DelimiterInterface $closer): int
+    {
+        if ($opener->getLength() > 2 && $closer->getLength() > 2) {
+            return 0;
+        }
+
+        if ($opener->getLength() !== $closer->getLength()) {
+            return 0;
+        }
+
+        // $opener and $closer are the same length so we just return one of them
+        return $opener->getLength();
+    }
+
+    public function process(AbstractStringContainer $opener, AbstractStringContainer $closer, int $delimiterUse): void
+    {
+        $strikethrough = new Strikethrough(\str_repeat('~', $delimiterUse));
+
+        $tmp = $opener->next();
+        while ($tmp !== null && $tmp !== $closer) {
+            $next = $tmp->next();
+            $strikethrough->appendChild($tmp);
+            $tmp = $next;
+        }
+
+        $opener->insertAfter($strikethrough);
+    }
+
+    public function getCacheKey(DelimiterInterface $closer): string
+    {
+        return '~' . $closer->getLength();
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/Table/TableExtension.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This is part of the league/commonmark package.
+ *
+ * (c) Martin Hasoň <martin.hason@gmail.com>
+ * (c) Webuni s.r.o. <info@webuni.cz>
+ * (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.
+ */
+
+namespace League\CommonMark\Extension\Table;
+
+use League\CommonMark\Environment\EnvironmentBuilderInterface;
+use League\CommonMark\Extension\ConfigurableExtensionInterface;
+use League\CommonMark\Renderer\HtmlDecorator;
+use League\Config\ConfigurationBuilderInterface;
+use Nette\Schema\Expect;
+
+final class TableExtension implements ConfigurableExtensionInterface
+{
+    public function configureSchema(ConfigurationBuilderInterface $builder): void
+    {
+        $attributeArraySchema = Expect::arrayOf(
+            Expect::type('string|string[]|bool'), // attribute value(s)
+            'string' // attribute name
+        )->mergeDefaults(false);
+
+        $builder->addSchema('table', Expect::structure([
+            'wrap' => Expect::structure([
+                'enabled' => Expect::bool()->default(false),
+                'tag' => Expect::string()->default('div'),
+                'attributes' => Expect::arrayOf(Expect::string()),
+            ]),
+            'alignment_attributes' => Expect::structure([
+                'left' => (clone $attributeArraySchema)->default(['align' => 'left']),
+                'center' => (clone $attributeArraySchema)->default(['align' => 'center']),
+                'right' => (clone $attributeArraySchema)->default(['align' => 'right']),
+            ]),
+            'max_autocompleted_cells' => Expect::int()->min(0)->default(TableParser::DEFAULT_MAX_AUTOCOMPLETED_CELLS),
+        ]));
+    }
+
+    public function register(EnvironmentBuilderInterface $environment): void
+    {
+        $tableRenderer = new TableRenderer();
+        if ($environment->getConfiguration()->get('table/wrap/enabled')) {
+            $tableRenderer = new HtmlDecorator($tableRenderer, $environment->getConfiguration()->get('table/wrap/tag'), $environment->getConfiguration()->get('table/wrap/attributes'));
+        }
+
+        $environment
+            ->addBlockStartParser(new TableStartParser($environment->getConfiguration()->get('table/max_autocompleted_cells')))
+
+            ->addRenderer(Table::class, $tableRenderer)
+            ->addRenderer(TableSection::class, new TableSectionRenderer())
+            ->addRenderer(TableRow::class, new TableRowRenderer())
+            ->addRenderer(TableCell::class, new TableCellRenderer($environment->getConfiguration()->get('table/alignment_attributes')));
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/Table/TableParser.php

@@ -0,0 +1,212 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This is part of the league/commonmark package.
+ *
+ * (c) Martin Hasoň <martin.hason@gmail.com>
+ * (c) Webuni s.r.o. <info@webuni.cz>
+ * (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.
+ */
+
+namespace League\CommonMark\Extension\Table;
+
+use League\CommonMark\Parser\Block\AbstractBlockContinueParser;
+use League\CommonMark\Parser\Block\BlockContinue;
+use League\CommonMark\Parser\Block\BlockContinueParserInterface;
+use League\CommonMark\Parser\Block\BlockContinueParserWithInlinesInterface;
+use League\CommonMark\Parser\Cursor;
+use League\CommonMark\Parser\InlineParserEngineInterface;
+use League\CommonMark\Util\ArrayCollection;
+
+final class TableParser extends AbstractBlockContinueParser implements BlockContinueParserWithInlinesInterface
+{
+    /**
+     * @internal
+     */
+    public const DEFAULT_MAX_AUTOCOMPLETED_CELLS = 10_000;
+
+    /** @psalm-readonly */
+    private Table $block;
+
+    /**
+     * @var ArrayCollection<string>
+     *
+     * @psalm-readonly-allow-private-mutation
+     */
+    private ArrayCollection $bodyLines;
+
+    /**
+     * @var array<int, string|null>
+     * @psalm-var array<int, TableCell::ALIGN_*|null>
+     * @phpstan-var array<int, TableCell::ALIGN_*|null>
+     *
+     * @psalm-readonly
+     */
+    private array $columns;
+
+    /**
+     * @var array<int, string>
+     *
+     * @psalm-readonly-allow-private-mutation
+     */
+    private array $headerCells;
+
+    /** @psalm-readonly-allow-private-mutation */
+    private bool $nextIsSeparatorLine = true;
+
+    private int $remainingAutocompletedCells;
+
+    /**
+     * @param array<int, string|null> $columns
+     * @param array<int, string>      $headerCells
+     *
+     * @psalm-param array<int, TableCell::ALIGN_*|null> $columns
+     *
+     * @phpstan-param array<int, TableCell::ALIGN_*|null> $columns
+     */
+    public function __construct(array $columns, array $headerCells, int $remainingAutocompletedCells = self::DEFAULT_MAX_AUTOCOMPLETED_CELLS)
+    {
+        $this->block                       = new Table();
+        $this->bodyLines                   = new ArrayCollection();
+        $this->columns                     = $columns;
+        $this->headerCells                 = $headerCells;
+        $this->remainingAutocompletedCells = $remainingAutocompletedCells;
+    }
+
+    public function canHaveLazyContinuationLines(): bool
+    {
+        return true;
+    }
+
+    public function getBlock(): Table
+    {
+        return $this->block;
+    }
+
+    public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
+    {
+        if (\strpos($cursor->getLine(), '|') === false) {
+            return BlockContinue::none();
+        }
+
+        return BlockContinue::at($cursor);
+    }
+
+    public function addLine(string $line): void
+    {
+        if ($this->nextIsSeparatorLine) {
+            $this->nextIsSeparatorLine = false;
+        } else {
+            $this->bodyLines[] = $line;
+        }
+    }
+
+    public function parseInlines(InlineParserEngineInterface $inlineParser): void
+    {
+        $headerColumns = \count($this->headerCells);
+
+        $head = new TableSection(TableSection::TYPE_HEAD);
+        $this->block->appendChild($head);
+
+        $headerRow = new TableRow();
+        $head->appendChild($headerRow);
+        for ($i = 0; $i < $headerColumns; $i++) {
+            $cell      = $this->headerCells[$i];
+            $tableCell = $this->parseCell($cell, $i, $inlineParser);
+            $tableCell->setType(TableCell::TYPE_HEADER);
+            $headerRow->appendChild($tableCell);
+        }
+
+        $body = null;
+        foreach ($this->bodyLines as $rowLine) {
+            $cells = self::split($rowLine);
+            $row   = new TableRow();
+
+            // Body can not have more columns than head
+            for ($i = 0; $i < $headerColumns; $i++) {
+                // It can have less columns though, in which case we'll autocomplete the empty ones (up to some limit)
+                if (! isset($cells[$i]) && $this->remainingAutocompletedCells-- <= 0) {
+                    // Too many cells were auto-completed, so we'll just stop here
+                    return;
+                }
+
+                $cell      = $cells[$i] ?? '';
+                $tableCell = $this->parseCell($cell, $i, $inlineParser);
+                $row->appendChild($tableCell);
+            }
+
+            if ($body === null) {
+                // It's valid to have a table without body. In that case, don't add an empty TableBody node.
+                $body = new TableSection();
+                $this->block->appendChild($body);
+            }
+
+            $body->appendChild($row);
+        }
+    }
+
+    private function parseCell(string $cell, int $column, InlineParserEngineInterface $inlineParser): TableCell
+    {
+        $tableCell = new TableCell(TableCell::TYPE_DATA, $this->columns[$column] ?? null);
+
+        if ($cell !== '') {
+            $inlineParser->parse(\trim($cell), $tableCell);
+        }
+
+        return $tableCell;
+    }
+
+    /**
+     * @internal
+     *
+     * @return array<int, string>
+     */
+    public static function split(string $line): array
+    {
+        $cursor = new Cursor(\trim($line));
+
+        if ($cursor->getCurrentCharacter() === '|') {
+            $cursor->advanceBy(1);
+        }
+
+        $cells = [];
+        $sb    = '';
+
+        while (! $cursor->isAtEnd()) {
+            switch ($c = $cursor->getCurrentCharacter()) {
+                case '\\':
+                    if ($cursor->peek() === '|') {
+                        // Pipe is special for table parsing. An escaped pipe doesn't result in a new cell, but is
+                        // passed down to inline parsing as an unescaped pipe. Note that that applies even for the `\|`
+                        // in an input like `\\|` - in other words, table parsing doesn't support escaping backslashes.
+                        $sb .= '|';
+                        $cursor->advanceBy(1);
+                    } else {
+                        // Preserve backslash before other characters or at end of line.
+                        $sb .= '\\';
+                    }
+
+                    break;
+                case '|':
+                    $cells[] = $sb;
+                    $sb      = '';
+                    break;
+                default:
+                    $sb .= $c;
+            }
+
+            $cursor->advanceBy(1);
+        }
+
+        if ($sb !== '') {
+            $cells[] = $sb;
+        }
+
+        return $cells;
+    }
+}

docker/streamline-src/vendor/league/commonmark/src/Extension/Table/TableStartParser.php

@@ -0,0 +1,165 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This is part of the league/commonmark package.
+ *
+ * (c) Martin Hasoň <martin.hason@gmail.com>
+ * (c) Webuni s.r.o. <info@webuni.cz>
+ * (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.
+ */
+
+namespace League\CommonMark\Extension\Table;
+
+use League\CommonMark\Parser\Block\BlockStart;
+use League\CommonMark\Parser\Block\BlockStartParserInterface;
+use League\CommonMark\Parser\Block\ParagraphParser;
+use League\CommonMark\Parser\Cursor;
+use League\CommonMark\Parser\MarkdownParserStateInterface;
+
+final class TableStartParser implements BlockStartParserInterface
+{
+    private int $maxAutocompletedCells;
+
+    public function __construct(int $maxAutocompletedCells = TableParser::DEFAULT_MAX_AUTOCOMPLETED_CELLS)
+    {
+        $this->maxAutocompletedCells = $maxAutocompletedCells;
+    }
+
+    public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
+    {
+        $paragraph = $parserState->getParagraphContent();
+        if ($paragraph === null || \strpos($paragraph, '|') === false) {
+            return BlockStart::none();
+        }
+
+        $columns = self::parseSeparator($cursor);
+        if (\count($columns) === 0) {
+            return BlockStart::none();
+        }
+
+        $lastLineBreak = \strrpos($paragraph, "\n");
+        $lastLine      = $lastLineBreak === false ? $paragraph : \substr($paragraph, $lastLineBreak + 1);
+
+        $headerCells = TableParser::split($lastLine);
+        if (\count($headerCells) > \count($columns)) {
+            return BlockStart::none();
+        }
+
+        $cursor->advanceToEnd();
+
+        $parsers = [];
+
+        if ($lastLineBreak !== false) {
+            $p = new ParagraphParser();
+            $p->addLine(\substr($paragraph, 0, $lastLineBreak));
+            $parsers[] = $p;
+        }
+
+        $parsers[] = new TableParser($columns, $headerCells, $this->maxAutocompletedCells);
+
+        return BlockStart::of(...$parsers)
+            ->at($cursor)
+            ->replaceActiveBlockParser();
+    }
+
+    /**
+     * @return array<int, string|null>
+     *
+     * @psalm-return array<int, TableCell::ALIGN_*|null>
+     *
+     * @phpstan-return array<int, TableCell::ALIGN_*|null>
+     */
+    private static function parseSeparator(Cursor $cursor): array
+    {
+        $columns = [];
+        $pipes   = 0;
+        $valid   = false;
+
+        while (! $cursor->isAtEnd()) {
+            switch ($c = $cursor->getCurrentCharacter()) {
+                case '|':
+                    $cursor->advanceBy(1);
+                    $pipes++;
+                    if ($pipes > 1) {
+                        // More than one adjacent pipe not allowed
+                        return [];
+                    }
+
+                    // Need at least one pipe, even for a one-column table
+                    $valid = true;
+                    break;
+                case '-':
+                case ':':
+                    if ($pipes === 0 && \count($columns) > 0) {
+                        // Need a pipe after the first column (first column doesn't need to start with one)
+                        return [];
+                    }
+
+                    $left  = false;
+                    $right = false;
+                    if ($c === ':') {
+                        $left = true;
+                        $cursor->advanceBy(1);
+                    }
+
+                    if ($cursor->match('/^-+/') === null) {
+                        // Need at least one dash
+                        return [];
+                    }
+
+                    if ($cursor->getCurrentCharacter() === ':') {
+                        $right = true;
+                        $cursor->advanceBy(1);
+                    }
+
+                    $columns[] = self::getAlignment($left, $right);
+                    // Next, need another pipe
+                    $pipes = 0;
+                    break;
+                case ' ':
+                case "\t":
+                    // White space is allowed between pipes and columns
+                    $cursor->advanceToNextNonSpaceOrTab();
+                    break;
+                default:
+                    // Any other character is invalid
+                    return [];
+            }
+        }
+
+        if (! $valid) {
+            return [];
+        }
+
+        return $columns;
+    }
+
+    /**
+     * @psalm-return TableCell::ALIGN_*|null
+     *
+     * @phpstan-return TableCell::ALIGN_*|null
+     *
+     * @psalm-pure
+     */
+    private static function getAlignment(bool $left, bool $right): ?string
+    {
+        if ($left && $right) {
+            return TableCell::ALIGN_CENTER;
+        }
+
+        if ($left) {
+            return TableCell::ALIGN_LEFT;
+        }
+
+        if ($right) {
+            return TableCell::ALIGN_RIGHT;
+        }
+
+        return null;
+    }
+}