/home/mip/mip/public/vendor/laravel-filemanager/files/folder-1/821668/commonmark.zip
PK �@]����s s LICENSEnu �[��� BSD 3-Clause License
Copyright (c) 2014-2022, Colin O'Dell. All rights reserved. Some code based on commonmark.js (copyright 2014-2018, John MacFarlane) and commonmark-java (copyright 2015-2016, Atlassian Pty Ltd)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
PK �@]D2Ix
src/Input/MarkdownInput.phpnu �[��� <?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\Input;
use League\CommonMark\Exception\UnexpectedEncodingException;
class MarkdownInput implements MarkdownInputInterface
{
/**
* @var array<int, string>|null
*
* @psalm-readonly-allow-private-mutation
*/
private ?array $lines = null;
/** @psalm-readonly-allow-private-mutation */
private string $content;
/** @psalm-readonly-allow-private-mutation */
private ?int $lineCount = null;
/** @psalm-readonly */
private int $lineOffset;
public function __construct(string $content, int $lineOffset = 0)
{
if (! \mb_check_encoding($content, 'UTF-8')) {
throw new UnexpectedEncodingException('Unexpected encoding - UTF-8 or ASCII was expected');
}
// Strip any leading UTF-8 BOM
if (\substr($content, 0, 3) === "\xEF\xBB\xBF") {
$content = \substr($content, 3);
}
$this->content = $content;
$this->lineOffset = $lineOffset;
}
public function getContent(): string
{
return $this->content;
}
/**
* {@inheritDoc}
*/
public function getLines(): iterable
{
$this->splitLinesIfNeeded();
\assert($this->lines !== null);
/** @psalm-suppress PossiblyNullIterator */
foreach ($this->lines as $i => $line) {
yield $this->lineOffset + $i + 1 => $line;
}
}
public function getLineCount(): int
{
$this->splitLinesIfNeeded();
\assert($this->lineCount !== null);
return $this->lineCount;
}
private function splitLinesIfNeeded(): void
{
if ($this->lines !== null) {
return;
}
$lines = \preg_split('/\r\n|\n|\r/', $this->content);
if ($lines === false) {
throw new UnexpectedEncodingException('Failed to split Markdown content by line');
}
$this->lines = $lines;
// Remove any newline which appears at the very end of the string.
// We've already split the document by newlines, so we can simply drop
// any empty element which appears on the end.
if (\end($this->lines) === '') {
\array_pop($this->lines);
}
$this->lineCount = \count($this->lines);
}
}
PK �@]#W�
$ src/Input/MarkdownInputInterface.phpnu �[��� <?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\Input;
interface MarkdownInputInterface
{
public function getContent(): string;
/**
* @return iterable<int, string>
*/
public function getLines(): iterable;
public function getLineCount(): int;
}
PK �@]���%� � - src/Environment/EnvironmentAwareInterface.phpnu �[��� <?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\Environment;
interface EnvironmentAwareInterface
{
public function setEnvironment(EnvironmentInterface $environment): void;
}
PK �@] T1�T T ( src/Environment/EnvironmentInterface.phpnu �[��� <?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\Environment;
use League\CommonMark\Delimiter\Processor\DelimiterProcessorCollection;
use League\CommonMark\Extension\ExtensionInterface;
use League\CommonMark\Node\Node;
use League\CommonMark\Normalizer\TextNormalizerInterface;
use League\CommonMark\Parser\Block\BlockStartParserInterface;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\Config\ConfigurationProviderInterface;
use Psr\EventDispatcher\EventDispatcherInterface;
interface EnvironmentInterface extends ConfigurationProviderInterface, EventDispatcherInterface
{
/**
* Get all registered extensions
*
* @return ExtensionInterface[]
*/
public function getExtensions(): iterable;
/**
* @return iterable<BlockStartParserInterface>
*/
public function getBlockStartParsers(): iterable;
/**
* @return iterable<InlineParserInterface>
*/
public function getInlineParsers(): iterable;
public function getDelimiterProcessors(): DelimiterProcessorCollection;
/**
* @psalm-param class-string<Node> $nodeClass
*
* @return iterable<NodeRendererInterface>
*/
public function getRenderersForClass(string $nodeClass): iterable;
public function getSlugNormalizer(): TextNormalizerInterface;
}
PK �@]���b b / src/Environment/EnvironmentBuilderInterface.phpnu �[��� <?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\Environment;
use League\CommonMark\Delimiter\Processor\DelimiterProcessorInterface;
use League\CommonMark\Exception\AlreadyInitializedException;
use League\CommonMark\Extension\ExtensionInterface;
use League\CommonMark\Node\Node;
use League\CommonMark\Parser\Block\BlockStartParserInterface;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\Config\ConfigurationProviderInterface;
/**
* Interface for building the Environment with any extensions, parsers, listeners, etc. that it may need
*/
interface EnvironmentBuilderInterface extends ConfigurationProviderInterface
{
/**
* Registers the given extension with the Environment
*
* @throws AlreadyInitializedException if the Environment has already been initialized
*/
public function addExtension(ExtensionInterface $extension): EnvironmentBuilderInterface;
/**
* Registers the given block start parser with the Environment
*
* @param BlockStartParserInterface $parser Block parser instance
* @param int $priority Priority (a higher number will be executed earlier)
*
* @return $this
*
* @throws AlreadyInitializedException if the Environment has already been initialized
*/
public function addBlockStartParser(BlockStartParserInterface $parser, int $priority = 0): EnvironmentBuilderInterface;
/**
* Registers the given inline parser with the Environment
*
* @param InlineParserInterface $parser Inline parser instance
* @param int $priority Priority (a higher number will be executed earlier)
*
* @return $this
*
* @throws AlreadyInitializedException if the Environment has already been initialized
*/
public function addInlineParser(InlineParserInterface $parser, int $priority = 0): EnvironmentBuilderInterface;
/**
* Registers the given delimiter processor with the Environment
*
* @param DelimiterProcessorInterface $processor Delimiter processors instance
*
* @throws AlreadyInitializedException if the Environment has already been initialized
*/
public function addDelimiterProcessor(DelimiterProcessorInterface $processor): EnvironmentBuilderInterface;
/**
* Registers the given node renderer with the Environment
*
* @param string $nodeClass The fully-qualified node element class name the renderer below should handle
* @param NodeRendererInterface $renderer The renderer responsible for rendering the type of element given above
* @param int $priority Priority (a higher number will be executed earlier)
*
* @psalm-param class-string<Node> $nodeClass
*
* @return $this
*
* @throws AlreadyInitializedException if the Environment has already been initialized
*/
public function addRenderer(string $nodeClass, NodeRendererInterface $renderer, int $priority = 0): EnvironmentBuilderInterface;
/**
* Registers the given event listener
*
* @param class-string $eventClass Fully-qualified class name of the event this listener should respond to
* @param callable $listener Listener to be executed
* @param int $priority Priority (a higher number will be executed earlier)
*
* @return $this
*
* @throws AlreadyInitializedException if the Environment has already been initialized
*/
public function addEventListener(string $eventClass, callable $listener, int $priority = 0): EnvironmentBuilderInterface;
}
PK �@]�R�M�: �: src/Environment/Environment.phpnu �[��� <?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\Environment;
use League\CommonMark\Delimiter\DelimiterParser;
use League\CommonMark\Delimiter\Processor\DelimiterProcessorCollection;
use League\CommonMark\Delimiter\Processor\DelimiterProcessorInterface;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Event\ListenerData;
use League\CommonMark\Exception\AlreadyInitializedException;
use League\CommonMark\Extension\CommonMark\CommonMarkCoreExtension;
use League\CommonMark\Extension\ConfigurableExtensionInterface;
use League\CommonMark\Extension\ExtensionInterface;
use League\CommonMark\Extension\GithubFlavoredMarkdownExtension;
use League\CommonMark\Normalizer\SlugNormalizer;
use League\CommonMark\Normalizer\TextNormalizerInterface;
use League\CommonMark\Normalizer\UniqueSlugNormalizer;
use League\CommonMark\Normalizer\UniqueSlugNormalizerInterface;
use League\CommonMark\Parser\Block\BlockStartParserInterface;
use League\CommonMark\Parser\Block\SkipLinesStartingWithLettersParser;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlFilter;
use League\CommonMark\Util\PrioritizedList;
use League\Config\Configuration;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
use Nette\Schema\Expect;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\EventDispatcher\ListenerProviderInterface;
use Psr\EventDispatcher\StoppableEventInterface;
final class Environment implements EnvironmentInterface, EnvironmentBuilderInterface, ListenerProviderInterface
{
/**
* @var ExtensionInterface[]
*
* @psalm-readonly-allow-private-mutation
*/
private array $extensions = [];
/**
* @var ExtensionInterface[]
*
* @psalm-readonly-allow-private-mutation
*/
private array $uninitializedExtensions = [];
/** @psalm-readonly-allow-private-mutation */
private bool $extensionsInitialized = false;
/**
* @var PrioritizedList<BlockStartParserInterface>
*
* @psalm-readonly
*/
private PrioritizedList $blockStartParsers;
/**
* @var PrioritizedList<InlineParserInterface>
*
* @psalm-readonly
*/
private PrioritizedList $inlineParsers;
/** @psalm-readonly */
private DelimiterProcessorCollection $delimiterProcessors;
/**
* @var array<string, PrioritizedList<NodeRendererInterface>>
*
* @psalm-readonly-allow-private-mutation
*/
private array $renderersByClass = [];
/**
* @var PrioritizedList<ListenerData>
*
* @psalm-readonly-allow-private-mutation
*/
private PrioritizedList $listenerData;
private ?EventDispatcherInterface $eventDispatcher = null;
/** @psalm-readonly */
private Configuration $config;
private ?TextNormalizerInterface $slugNormalizer = null;
/**
* @param array<string, mixed> $config
*/
public function __construct(array $config = [])
{
$this->config = self::createDefaultConfiguration();
$this->config->merge($config);
$this->blockStartParsers = new PrioritizedList();
$this->inlineParsers = new PrioritizedList();
$this->listenerData = new PrioritizedList();
$this->delimiterProcessors = new DelimiterProcessorCollection();
// Performance optimization: always include a block "parser" that aborts parsing if a line starts with a letter
// and is therefore unlikely to match any lines as a block start.
$this->addBlockStartParser(new SkipLinesStartingWithLettersParser(), 249);
}
public function getConfiguration(): ConfigurationInterface
{
return $this->config->reader();
}
/**
* @deprecated Environment::mergeConfig() is deprecated since league/commonmark v2.0 and will be removed in v3.0. Configuration should be set when instantiating the environment instead.
*
* @param array<string, mixed> $config
*/
public function mergeConfig(array $config): void
{
@\trigger_error('Environment::mergeConfig() is deprecated since league/commonmark v2.0 and will be removed in v3.0. Configuration should be set when instantiating the environment instead.', \E_USER_DEPRECATED);
$this->assertUninitialized('Failed to modify configuration.');
$this->config->merge($config);
}
public function addBlockStartParser(BlockStartParserInterface $parser, int $priority = 0): EnvironmentBuilderInterface
{
$this->assertUninitialized('Failed to add block start parser.');
$this->blockStartParsers->add($parser, $priority);
$this->injectEnvironmentAndConfigurationIfNeeded($parser);
return $this;
}
public function addInlineParser(InlineParserInterface $parser, int $priority = 0): EnvironmentBuilderInterface
{
$this->assertUninitialized('Failed to add inline parser.');
$this->inlineParsers->add($parser, $priority);
$this->injectEnvironmentAndConfigurationIfNeeded($parser);
return $this;
}
public function addDelimiterProcessor(DelimiterProcessorInterface $processor): EnvironmentBuilderInterface
{
$this->assertUninitialized('Failed to add delimiter processor.');
$this->delimiterProcessors->add($processor);
$this->injectEnvironmentAndConfigurationIfNeeded($processor);
return $this;
}
public function addRenderer(string $nodeClass, NodeRendererInterface $renderer, int $priority = 0): EnvironmentBuilderInterface
{
$this->assertUninitialized('Failed to add renderer.');
if (! isset($this->renderersByClass[$nodeClass])) {
$this->renderersByClass[$nodeClass] = new PrioritizedList();
}
$this->renderersByClass[$nodeClass]->add($renderer, $priority);
$this->injectEnvironmentAndConfigurationIfNeeded($renderer);
return $this;
}
/**
* {@inheritDoc}
*/
public function getBlockStartParsers(): iterable
{
if (! $this->extensionsInitialized) {
$this->initializeExtensions();
}
return $this->blockStartParsers->getIterator();
}
public function getDelimiterProcessors(): DelimiterProcessorCollection
{
if (! $this->extensionsInitialized) {
$this->initializeExtensions();
}
return $this->delimiterProcessors;
}
/**
* {@inheritDoc}
*/
public function getRenderersForClass(string $nodeClass): iterable
{
if (! $this->extensionsInitialized) {
$this->initializeExtensions();
}
// If renderers are defined for this specific class, return them immediately
if (isset($this->renderersByClass[$nodeClass])) {
return $this->renderersByClass[$nodeClass];
}
/** @psalm-suppress TypeDoesNotContainType -- Bug: https://github.com/vimeo/psalm/issues/3332 */
while (\class_exists($parent ??= $nodeClass) && $parent = \get_parent_class($parent)) {
if (! isset($this->renderersByClass[$parent])) {
continue;
}
// "Cache" this result to avoid future loops
return $this->renderersByClass[$nodeClass] = $this->renderersByClass[$parent];
}
return [];
}
/**
* {@inheritDoc}
*/
public function getExtensions(): iterable
{
return $this->extensions;
}
/**
* Add a single extension
*
* @return $this
*/
public function addExtension(ExtensionInterface $extension): EnvironmentBuilderInterface
{
$this->assertUninitialized('Failed to add extension.');
$this->extensions[] = $extension;
$this->uninitializedExtensions[] = $extension;
if ($extension instanceof ConfigurableExtensionInterface) {
$extension->configureSchema($this->config);
}
return $this;
}
private function initializeExtensions(): void
{
// Initialize the slug normalizer
$this->getSlugNormalizer();
// Ask all extensions to register their components
while (\count($this->uninitializedExtensions) > 0) {
foreach ($this->uninitializedExtensions as $i => $extension) {
$extension->register($this);
unset($this->uninitializedExtensions[$i]);
}
}
$this->extensionsInitialized = true;
// Create the special delimiter parser if any processors were registered
if ($this->delimiterProcessors->count() > 0) {
$this->inlineParsers->add(new DelimiterParser($this->delimiterProcessors), PHP_INT_MIN);
}
}
private function injectEnvironmentAndConfigurationIfNeeded(object $object): void
{
if ($object instanceof EnvironmentAwareInterface) {
$object->setEnvironment($this);
}
if ($object instanceof ConfigurationAwareInterface) {
$object->setConfiguration($this->config->reader());
}
}
/**
* @deprecated Instantiate the environment and add the extension yourself
*
* @param array<string, mixed> $config
*/
public static function createCommonMarkEnvironment(array $config = []): Environment
{
$environment = new self($config);
$environment->addExtension(new CommonMarkCoreExtension());
return $environment;
}
/**
* @deprecated Instantiate the environment and add the extension yourself
*
* @param array<string, mixed> $config
*/
public static function createGFMEnvironment(array $config = []): Environment
{
$environment = new self($config);
$environment->addExtension(new CommonMarkCoreExtension());
$environment->addExtension(new GithubFlavoredMarkdownExtension());
return $environment;
}
public function addEventListener(string $eventClass, callable $listener, int $priority = 0): EnvironmentBuilderInterface
{
$this->assertUninitialized('Failed to add event listener.');
$this->listenerData->add(new ListenerData($eventClass, $listener), $priority);
if (\is_object($listener)) {
$this->injectEnvironmentAndConfigurationIfNeeded($listener);
} elseif (\is_array($listener) && \is_object($listener[0])) {
$this->injectEnvironmentAndConfigurationIfNeeded($listener[0]);
}
return $this;
}
public function dispatch(object $event): object
{
if (! $this->extensionsInitialized) {
$this->initializeExtensions();
}
if ($this->eventDispatcher !== null) {
return $this->eventDispatcher->dispatch($event);
}
foreach ($this->getListenersForEvent($event) as $listener) {
if ($event instanceof StoppableEventInterface && $event->isPropagationStopped()) {
return $event;
}
$listener($event);
}
return $event;
}
public function setEventDispatcher(EventDispatcherInterface $dispatcher): void
{
$this->eventDispatcher = $dispatcher;
}
/**
* {@inheritDoc}
*
* @return iterable<callable>
*/
public function getListenersForEvent(object $event): iterable
{
foreach ($this->listenerData as $listenerData) {
\assert($listenerData instanceof ListenerData);
/** @psalm-suppress ArgumentTypeCoercion */
if (! \is_a($event, $listenerData->getEvent())) {
continue;
}
yield function (object $event) use ($listenerData) {
if (! $this->extensionsInitialized) {
$this->initializeExtensions();
}
return \call_user_func($listenerData->getListener(), $event);
};
}
}
/**
* @return iterable<InlineParserInterface>
*/
public function getInlineParsers(): iterable
{
if (! $this->extensionsInitialized) {
$this->initializeExtensions();
}
return $this->inlineParsers->getIterator();
}
public function getSlugNormalizer(): TextNormalizerInterface
{
if ($this->slugNormalizer === null) {
$normalizer = $this->config->get('slug_normalizer/instance');
\assert($normalizer instanceof TextNormalizerInterface);
$this->injectEnvironmentAndConfigurationIfNeeded($normalizer);
if ($this->config->get('slug_normalizer/unique') !== UniqueSlugNormalizerInterface::DISABLED && ! $normalizer instanceof UniqueSlugNormalizer) {
$normalizer = new UniqueSlugNormalizer($normalizer);
}
if ($normalizer instanceof UniqueSlugNormalizer) {
if ($this->config->get('slug_normalizer/unique') === UniqueSlugNormalizerInterface::PER_DOCUMENT) {
$this->addEventListener(DocumentParsedEvent::class, [$normalizer, 'clearHistory'], -1000);
}
}
$this->slugNormalizer = $normalizer;
}
return $this->slugNormalizer;
}
/**
* @throws AlreadyInitializedException
*/
private function assertUninitialized(string $message): void
{
if ($this->extensionsInitialized) {
throw new AlreadyInitializedException($message . ' Extensions have already been initialized.');
}
}
public static function createDefaultConfiguration(): Configuration
{
return new Configuration([
'html_input' => Expect::anyOf(HtmlFilter::STRIP, HtmlFilter::ALLOW, HtmlFilter::ESCAPE)->default(HtmlFilter::ALLOW),
'allow_unsafe_links' => Expect::bool(true),
'max_nesting_level' => Expect::type('int')->default(PHP_INT_MAX),
'renderer' => Expect::structure([
'block_separator' => Expect::string("\n"),
'inner_separator' => Expect::string("\n"),
'soft_break' => Expect::string("\n"),
]),
'slug_normalizer' => Expect::structure([
'instance' => Expect::type(TextNormalizerInterface::class)->default(new SlugNormalizer()),
'max_length' => Expect::int()->min(0)->default(255),
'unique' => Expect::anyOf(UniqueSlugNormalizerInterface::DISABLED, UniqueSlugNormalizerInterface::PER_ENVIRONMENT, UniqueSlugNormalizerInterface::PER_DOCUMENT)->default(UniqueSlugNormalizerInterface::PER_DOCUMENT),
]),
]);
}
}
PK �@]�:�U>
>
src/MarkdownConverter.phpnu �[��� <?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;
use League\CommonMark\Environment\EnvironmentInterface;
use League\CommonMark\Exception\CommonMarkException;
use League\CommonMark\Output\RenderedContentInterface;
use League\CommonMark\Parser\MarkdownParser;
use League\CommonMark\Parser\MarkdownParserInterface;
use League\CommonMark\Renderer\HtmlRenderer;
use League\CommonMark\Renderer\MarkdownRendererInterface;
class MarkdownConverter implements ConverterInterface, MarkdownConverterInterface
{
/** @psalm-readonly */
protected EnvironmentInterface $environment;
/** @psalm-readonly */
protected MarkdownParserInterface $markdownParser;
/** @psalm-readonly */
protected MarkdownRendererInterface $htmlRenderer;
public function __construct(EnvironmentInterface $environment)
{
$this->environment = $environment;
$this->markdownParser = new MarkdownParser($environment);
$this->htmlRenderer = new HtmlRenderer($environment);
}
public function getEnvironment(): EnvironmentInterface
{
return $this->environment;
}
/**
* Converts Markdown to HTML.
*
* @param string $input The Markdown to convert
*
* @return RenderedContentInterface Rendered HTML
*
* @throws CommonMarkException
*/
public function convert(string $input): RenderedContentInterface
{
$documentAST = $this->markdownParser->parse($input);
return $this->htmlRenderer->renderDocument($documentAST);
}
/**
* Converts Markdown to HTML.
*
* @deprecated since 2.2; use {@link convert()} instead
*
* @param string $markdown The Markdown to convert
*
* @return RenderedContentInterface Rendered HTML
*
* @throws CommonMarkException
*/
public function convertToHtml(string $markdown): RenderedContentInterface
{
\trigger_deprecation('league/commonmark', '2.2.0', 'Calling "convertToHtml()" on a %s class is deprecated, use "convert()" instead.', self::class);
return $this->convert($markdown);
}
/**
* Converts CommonMark to HTML.
*
* @see MarkdownConverter::convert()
*
* @throws CommonMarkException
*/
public function __invoke(string $markdown): RenderedContentInterface
{
return $this->convert($markdown);
}
}
PK �@]� ��� � % src/Node/StringContainerInterface.phpnu �[��� <?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\Node;
/**
* Interface for a node which directly contains line(s) of text
*/
interface StringContainerInterface
{
public function setLiteral(string $literal): void;
public function getLiteral(): string;
}
PK �@] ��0b b src/Node/NodeIterator.phpnu �[��� <?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\Node;
use League\CommonMark\Node\Block\AbstractBlock;
/**
* @implements \IteratorAggregate<int, Node>
*/
final class NodeIterator implements \IteratorAggregate
{
public const FLAG_BLOCKS_ONLY = 1;
private Node $node;
private bool $blocksOnly;
public function __construct(Node $node, int $flags = 0)
{
$this->node = $node;
$this->blocksOnly = ($flags & self::FLAG_BLOCKS_ONLY) === self::FLAG_BLOCKS_ONLY;
}
/**
* @return \Generator<int, Node>
*/
public function getIterator(): \Generator
{
$stack = [$this->node];
$index = 0;
while ($stack) {
$node = \array_pop($stack);
yield $index++ => $node;
// Push all children onto the stack in reverse order
$child = $node->lastChild();
while ($child !== null) {
if (! $this->blocksOnly || $child instanceof AbstractBlock) {
$stack[] = $child;
}
$child = $child->previous();
}
}
}
}
PK �@]K��s} } src/Node/NodeWalkerEvent.phpnu �[��� <?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\Node;
final class NodeWalkerEvent
{
/** @psalm-readonly */
private Node $node;
/** @psalm-readonly */
private bool $isEntering;
public function __construct(Node $node, bool $isEntering = true)
{
$this->node = $node;
$this->isEntering = $isEntering;
}
public function getNode(): Node
{
return $this->node;
}
public function isEntering(): bool
{
return $this->isEntering;
}
}
PK �@]w�
]� � & src/Node/Query/ExpressionInterface.phpnu �[��� <?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\Node\Query;
use League\CommonMark\Node\Node;
interface ExpressionInterface
{
public function __invoke(Node $node): bool;
}
PK �@]sW�k k src/Node/Query/OrExpr.phpnu �[��� <?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\Node\Query;
use League\CommonMark\Node\Node;
/**
* @internal
*/
final class OrExpr implements ExpressionInterface
{
/**
* @var callable[]
* @psalm-var list<callable(Node): bool>
*/
private array $conditions;
/**
* @psalm-param callable(Node): bool $expressions
*/
public function __construct(callable ...$expressions)
{
$this->conditions = \array_values($expressions);
}
/**
* @param callable(Node): bool $expression
*/
public function add(callable $expression): void
{
$this->conditions[] = $expression;
}
public function __invoke(Node $node): bool
{
foreach ($this->conditions as $condition) {
if ($condition($node)) {
return true;
}
}
return false;
}
}
PK �@]h��Wn n src/Node/Query/AndExpr.phpnu �[��� <?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\Node\Query;
use League\CommonMark\Node\Node;
/**
* @internal
*/
final class AndExpr implements ExpressionInterface
{
/**
* @var callable[]
* @psalm-var list<callable(Node): bool>
*/
private array $conditions;
/**
* @psalm-param callable(Node): bool $expressions
*/
public function __construct(callable ...$expressions)
{
$this->conditions = \array_values($expressions);
}
/**
* @param callable(Node): bool $expression
*/
public function add(callable $expression): void
{
$this->conditions[] = $expression;
}
public function __invoke(Node $node): bool
{
foreach ($this->conditions as $condition) {
if (! $condition($node)) {
return false;
}
}
return true;
}
}
PK �@]
2ސ� � ( src/Node/RawMarkupContainerInterface.phpnu �[��� <?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\Node;
/**
* Interface for a node which contains raw, unprocessed markup (like HTML)
*/
interface RawMarkupContainerInterface extends StringContainerInterface
{
}
PK �@]���B B src/Node/Node.phpnu �[��� <?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\Node;
use Dflydev\DotAccessData\Data;
use League\CommonMark\Exception\InvalidArgumentException;
abstract class Node
{
/** @psalm-readonly */
public Data $data;
/** @psalm-readonly-allow-private-mutation */
protected int $depth = 0;
/** @psalm-readonly-allow-private-mutation */
protected ?Node $parent = null;
/** @psalm-readonly-allow-private-mutation */
protected ?Node $previous = null;
/** @psalm-readonly-allow-private-mutation */
protected ?Node $next = null;
/** @psalm-readonly-allow-private-mutation */
protected ?Node $firstChild = null;
/** @psalm-readonly-allow-private-mutation */
protected ?Node $lastChild = null;
public function __construct()
{
$this->data = new Data([
'attributes' => [],
]);
}
public function previous(): ?Node
{
return $this->previous;
}
public function next(): ?Node
{
return $this->next;
}
public function parent(): ?Node
{
return $this->parent;
}
protected function setParent(?Node $node = null): void
{
$this->parent = $node;
$this->depth = $node === null ? 0 : $node->depth + 1;
}
/**
* Inserts the $sibling node after $this
*/
public function insertAfter(Node $sibling): void
{
$sibling->detach();
$sibling->next = $this->next;
if ($sibling->next) {
$sibling->next->previous = $sibling;
}
$sibling->previous = $this;
$this->next = $sibling;
$sibling->setParent($this->parent);
if (! $sibling->next && $sibling->parent) {
$sibling->parent->lastChild = $sibling;
}
}
/**
* Inserts the $sibling node before $this
*/
public function insertBefore(Node $sibling): void
{
$sibling->detach();
$sibling->previous = $this->previous;
if ($sibling->previous) {
$sibling->previous->next = $sibling;
}
$sibling->next = $this;
$this->previous = $sibling;
$sibling->setParent($this->parent);
if (! $sibling->previous && $sibling->parent) {
$sibling->parent->firstChild = $sibling;
}
}
public function replaceWith(Node $replacement): void
{
$replacement->detach();
$this->insertAfter($replacement);
$this->detach();
}
public function detach(): void
{
if ($this->previous) {
$this->previous->next = $this->next;
} elseif ($this->parent) {
$this->parent->firstChild = $this->next;
}
if ($this->next) {
$this->next->previous = $this->previous;
} elseif ($this->parent) {
$this->parent->lastChild = $this->previous;
}
$this->parent = null;
$this->next = null;
$this->previous = null;
$this->depth = 0;
}
public function hasChildren(): bool
{
return $this->firstChild !== null;
}
public function firstChild(): ?Node
{
return $this->firstChild;
}
public function lastChild(): ?Node
{
return $this->lastChild;
}
/**
* @return Node[]
*/
public function children(): iterable
{
$children = [];
for ($current = $this->firstChild; $current !== null; $current = $current->next) {
$children[] = $current;
}
return $children;
}
public function appendChild(Node $child): void
{
if ($this->lastChild) {
$this->lastChild->insertAfter($child);
} else {
$child->detach();
$child->setParent($this);
$this->lastChild = $this->firstChild = $child;
}
}
/**
* Adds $child as the very first child of $this
*/
public function prependChild(Node $child): void
{
if ($this->firstChild) {
$this->firstChild->insertBefore($child);
} else {
$child->detach();
$child->setParent($this);
$this->lastChild = $this->firstChild = $child;
}
}
/**
* Detaches all child nodes of given node
*/
public function detachChildren(): void
{
foreach ($this->children() as $children) {
$children->setParent(null);
}
$this->firstChild = $this->lastChild = null;
}
/**
* Replace all children of given node with collection of another
*
* @param iterable<Node> $children
*/
public function replaceChildren(iterable $children): void
{
$this->detachChildren();
foreach ($children as $item) {
$this->appendChild($item);
}
}
public function getDepth(): int
{
return $this->depth;
}
public function walker(): NodeWalker
{
return new NodeWalker($this);
}
public function iterator(int $flags = 0): NodeIterator
{
return new NodeIterator($this, $flags);
}
/**
* Clone the current node and its children
*
* WARNING: This is a recursive function and should not be called on deeply-nested node trees!
*/
public function __clone()
{
// Cloned nodes are detached from their parents, siblings, and children
$this->parent = null;
$this->previous = null;
$this->next = null;
// But save a copy of the children since we'll need that in a moment
$children = $this->children();
$this->detachChildren();
// The original children get cloned and re-added
foreach ($children as $child) {
$this->appendChild(clone $child);
}
}
public static function assertInstanceOf(Node $node): void
{
if (! $node instanceof static) {
throw new InvalidArgumentException(\sprintf('Incompatible node type: expected %s, got %s', static::class, \get_class($node)));
}
}
}
PK �@]j� �W W + src/Node/Inline/AbstractStringContainer.phpnu �[��� <?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\Node\Inline;
use League\CommonMark\Node\StringContainerInterface;
abstract class AbstractStringContainer extends AbstractInline implements StringContainerInterface
{
protected string $literal = '';
/**
* @param array<string, mixed> $data
*/
public function __construct(string $contents = '', array $data = [])
{
parent::__construct();
$this->literal = $contents;
if (\count($data) > 0) {
$this->data->import($data);
}
}
public function getLiteral(): string
{
return $this->literal;
}
public function setLiteral(string $literal): void
{
$this->literal = $literal;
}
}
PK �@]C�N�� � src/Node/Inline/Newline.phpnu �[��� <?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\Node\Inline;
final class Newline extends AbstractInline
{
// Any changes to these constants should be reflected in .phpstorm.meta.php
public const HARDBREAK = 0;
public const SOFTBREAK = 1;
/** @psalm-readonly */
private int $type;
public function __construct(int $breakType = self::HARDBREAK)
{
parent::__construct();
$this->type = $breakType;
}
/** @psalm-immutable */
public function getType(): int
{
return $this->type;
}
}
PK �@]i�� � & src/Node/Inline/DelimitedInterface.phpnu �[��� <?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\Node\Inline;
interface DelimitedInterface
{
public function getOpeningDelimiter(): string;
public function getClosingDelimiter(): string;
}
PK �@]P3�0 " src/Node/Inline/AbstractInline.phpnu �[��� <?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\Node\Inline;
use League\CommonMark\Node\Node;
abstract class AbstractInline extends Node
{
}
PK �@]j}RM M src/Node/Inline/Text.phpnu �[��� <?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\Node\Inline;
final class Text extends AbstractStringContainer
{
public function append(string $literal): void
{
$this->literal .= $literal;
}
}
PK �@]���~� � & src/Node/Inline/AdjacentTextMerger.phpnu �[��� <?php
declare(strict_types=1);
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
*
* 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\Node\Inline;
use League\CommonMark\Node\Node;
/**
* @internal
*/
final class AdjacentTextMerger
{
public static function mergeChildNodes(Node $node): void
{
// No children or just one child node, no need for merging
if ($node->firstChild() === $node->lastChild() || $node->firstChild() === null || $node->lastChild() === null) {
return;
}
/** @psalm-suppress PossiblyNullArgument */
self::mergeTextNodesInclusive($node->firstChild(), $node->lastChild());
}
public static function mergeTextNodesBetweenExclusive(Node $fromNode, Node $toNode): void
{
// No nodes between them
if ($fromNode === $toNode || $fromNode->next() === $toNode || $fromNode->next() === null || $toNode->previous() === null) {
return;
}
/** @psalm-suppress PossiblyNullArgument */
self::mergeTextNodesInclusive($fromNode->next(), $toNode->previous());
}
public static function mergeWithDirectlyAdjacentNodes(Text $node): void
{
$start = ($previous = $node->previous()) instanceof Text ? $previous : $node;
$end = ($next = $node->next()) instanceof Text ? $next : $node;
self::mergeIfNeeded($start, $end);
}
private static function mergeTextNodesInclusive(Node $fromNode, Node $toNode): void
{
$first = null;
$last = null;
$node = $fromNode;
while ($node !== null) {
if ($node instanceof Text) {
if ($first === null) {
$first = $node;
}
$last = $node;
} else {
self::mergeIfNeeded($first, $last);
$first = null;
$last = null;
}
if ($node === $toNode) {
break;
}
$node = $node->next();
}
self::mergeIfNeeded($first, $last);
}
private static function mergeIfNeeded(?Text $first, ?Text $last): void
{
if ($first === null || $last === null || $first === $last) {
// No merging needed
return;
}
$s = $first->getLiteral();
$node = $first->next();
$stop = $last->next();
while ($node !== $stop && $node instanceof Text) {
$s .= $node->getLiteral();
$unlink = $node;
$node = $node->next();
$unlink->detach();
}
$first->setLiteral($s);
}
}
PK �@],�� � src/Node/NodeWalker.phpnu �[��� <?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\Node;
use League\CommonMark\Node\Block\AbstractBlock;
final class NodeWalker
{
/** @psalm-readonly */
private Node $root;
/** @psalm-readonly-allow-private-mutation */
private ?Node $current = null;
/** @psalm-readonly-allow-private-mutation */
private bool $entering;
public function __construct(Node $root)
{
$this->root = $root;
$this->current = $this->root;
$this->entering = true;
}
/**
* Returns an event which contains node and entering flag
* (entering is true when we enter a Node from a parent or sibling,
* and false when we reenter it from child)
*/
public function next(): ?NodeWalkerEvent
{
$current = $this->current;
$entering = $this->entering;
if ($current === null) {
return null;
}
if ($entering && ($current instanceof AbstractBlock || $current->hasChildren())) {
if ($current->firstChild()) {
$this->current = $current->firstChild();
$this->entering = true;
} else {
$this->entering = false;
}
} elseif ($current === $this->root) {
$this->current = null;
} elseif ($current->next() === null) {
$this->current = $current->parent();
$this->entering = false;
} else {
$this->current = $current->next();
$this->entering = true;
}
return new NodeWalkerEvent($current, $entering);
}
/**
* Resets the iterator to resume at the specified node
*/
public function resumeAt(Node $node, bool $entering = true): void
{
$this->current = $node;
$this->entering = $entering;
}
}
PK �@]�w�Q� � & src/Node/Block/TightBlockInterface.phpnu �[��� <?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\Node\Block;
interface TightBlockInterface
{
public function isTight(): bool;
public function setTight(bool $tight): void;
}
PK �@]Ҽƨ src/Node/Block/Document.phpnu �[��� <?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\Node\Block;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Reference\ReferenceMap;
use League\CommonMark\Reference\ReferenceMapInterface;
class Document extends AbstractBlock
{
/** @psalm-readonly */
protected ReferenceMapInterface $referenceMap;
public function __construct(?ReferenceMapInterface $referenceMap = null)
{
parent::__construct();
$this->setStartLine(1);
$this->referenceMap = $referenceMap ?? new ReferenceMap();
}
public function getReferenceMap(): ReferenceMapInterface
{
return $this->referenceMap;
}
public function canContain(AbstractBlock $block): bool
{
return true;
}
public function isCode(): bool
{
return false;
}
public function matchesNextLine(Cursor $cursor): bool
{
return true;
}
}
PK �@]v�
� � src/Node/Block/Paragraph.phpnu �[��� <?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\Node\Block;
class Paragraph extends AbstractBlock
{
}
PK �@]�t� � src/Node/Block/AbstractBlock.phpnu �[��� <?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\Node\Block;
use League\CommonMark\Exception\InvalidArgumentException;
use League\CommonMark\Node\Node;
/**
* Block-level element
*
* @method parent() ?AbstractBlock
*/
abstract class AbstractBlock extends Node
{
protected ?int $startLine = null;
protected ?int $endLine = null;
protected function setParent(?Node $node = null): void
{
if ($node && ! $node instanceof self) {
throw new InvalidArgumentException('Parent of block must also be block (cannot be inline)');
}
parent::setParent($node);
}
public function setStartLine(?int $startLine): void
{
$this->startLine = $startLine;
if ($this->endLine === null) {
$this->endLine = $startLine;
}
}
public function getStartLine(): ?int
{
return $this->startLine;
}
public function setEndLine(?int $endLine): void
{
$this->endLine = $endLine;
}
public function getEndLine(): ?int
{
return $this->endLine;
}
}
PK �@]5��� � src/Node/Query.phpnu �[��� <?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\Node;
use League\CommonMark\Node\Query\AndExpr;
use League\CommonMark\Node\Query\OrExpr;
final class Query
{
/** @var callable(Node): bool $condition */
private $condition;
public function __construct()
{
$this->condition = new AndExpr();
}
public function where(callable ...$conditions): self
{
return $this->andWhere(...$conditions);
}
public function andWhere(callable ...$conditions): self
{
if ($this->condition instanceof AndExpr) {
foreach ($conditions as $condition) {
$this->condition->add($condition);
}
} else {
$this->condition = new AndExpr($this->condition, ...$conditions);
}
return $this;
}
public function orWhere(callable ...$conditions): self
{
if ($this->condition instanceof OrExpr) {
foreach ($conditions as $condition) {
$this->condition->add($condition);
}
} else {
$this->condition = new OrExpr($this->condition, ...$conditions);
}
return $this;
}
public function findOne(Node $node): ?Node
{
foreach ($node->iterator() as $n) {
if (\call_user_func($this->condition, $n)) {
return $n;
}
}
return null;
}
/**
* @return iterable<Node>
*/
public function findAll(Node $node, ?int $limit = PHP_INT_MAX): iterable
{
$resultCount = 0;
foreach ($node->iterator() as $n) {
if ($resultCount >= $limit) {
break;
}
if (! \call_user_func($this->condition, $n)) {
continue;
}
++$resultCount;
yield $n;
}
}
/**
* @return callable(Node): bool
*/
public static function type(string $class): callable
{
return static fn (Node $node): bool => $node instanceof $class;
}
/**
* @psalm-param ?callable(Node): bool $condition
*
* @return callable(Node): bool
*/
public static function hasChild(?callable $condition = null): callable
{
return static function (Node $node) use ($condition): bool {
foreach ($node->children() as $child) {
if ($condition === null || $condition($child)) {
return true;
}
}
return false;
};
}
/**
* @psalm-param ?callable(Node): bool $condition
*
* @return callable(Node): bool
*/
public static function hasParent(?callable $condition = null): callable
{
return static function (Node $node) use ($condition): bool {
$parent = $node->parent();
if ($parent === null) {
return false;
}
if ($condition === null) {
return true;
}
return $condition($parent);
};
}
}
PK �@]�j4L L " src/Node/StringContainerHelper.phpnu �[��� <?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\Node;
final class StringContainerHelper
{
/**
* Extract text literals from all descendant nodes
*
* @param Node $node Parent node
* @param array<string> $excludeTypes Optional list of node class types to exclude
*
* @return string Concatenated literals
*/
public static function getChildText(Node $node, array $excludeTypes = []): string
{
$text = '';
foreach ($node->iterator() as $child) {
if ($child instanceof StringContainerInterface && ! self::isOneOf($child, $excludeTypes)) {
$text .= $child->getLiteral();
}
}
return $text;
}
/**
* @param string[] $classesOrInterfacesToCheck
*
* @psalm-pure
*/
private static function isOneOf(object $object, array $classesOrInterfacesToCheck): bool
{
foreach ($classesOrInterfacesToCheck as $type) {
if ($object instanceof $type) {
return true;
}
}
return false;
}
}
PK �@]�!�� � src/Util/SpecReader.phpnu �[��� <?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\Util;
use League\CommonMark\Exception\IOException;
/**
* Reads in a CommonMark spec document and extracts the input/output examples for testing against them
*/
final class SpecReader
{
private function __construct()
{
}
/**
* @return iterable<string, array{input: string, output: string, type: string, section: string, number: int}>
*/
public static function read(string $data): iterable
{
// Normalize newlines for platform independence
$data = \preg_replace('/\r\n?/', "\n", $data);
\assert($data !== null);
$data = \preg_replace('/<!-- END TESTS -->.*$/', '', $data);
\assert($data !== null);
\preg_match_all('/^`{32} (example ?\w*)\n([\s\S]*?)^\.\n([\s\S]*?)^`{32}$|^#{1,6} *(.*)$/m', $data, $matches, PREG_SET_ORDER);
$currentSection = 'Example';
$exampleNumber = 0;
foreach ($matches as $match) {
if (isset($match[4])) {
$currentSection = $match[4];
continue;
}
yield \trim($currentSection . ' #' . $exampleNumber) => [
'input' => \str_replace('→', "\t", $match[2]),
'output' => \str_replace('→', "\t", $match[3]),
'type' => $match[1],
'section' => $currentSection,
'number' => $exampleNumber++,
];
}
}
/**
* @return iterable<string, array{input: string, output: string, type: string, section: string, number: int}>
*
* @throws IOException if the file cannot be loaded
*/
public static function readFile(string $filename): iterable
{
if (($data = \file_get_contents($filename)) === false) {
throw new IOException(\sprintf('Failed to load spec from %s', $filename));
}
return self::read($data);
}
}
PK �@]BR�(;
;
src/Util/UrlEncoder.phpnu �[��� <?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\Util;
use League\CommonMark\Exception\UnexpectedEncodingException;
/**
* @psalm-immutable
*/
final class UrlEncoder
{
private const ENCODE_CACHE = ['%00', '%01', '%02', '%03', '%04', '%05', '%06', '%07', '%08', '%09', '%0A', '%0B', '%0C', '%0D', '%0E', '%0F', '%10', '%11', '%12', '%13', '%14', '%15', '%16', '%17', '%18', '%19', '%1A', '%1B', '%1C', '%1D', '%1E', '%1F', '%20', '!', '%22', '#', '$', '%25', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '%3C', '=', '%3E', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '%5B', '%5C', '%5D', '%5E', '_', '%60', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '%7B', '%7C', '%7D', '~', '%7F'];
/**
* @throws UnexpectedEncodingException if a non-UTF-8-compatible encoding is used
*
* @psalm-pure
*/
public static function unescapeAndEncode(string $uri): string
{
// Optimization: if the URL only includes characters we know will be kept as-is, then just return the URL as-is.
if (\preg_match('/^[A-Za-z0-9~!@#$&*()\-_=+;:,.\/?]+$/', $uri)) {
return $uri;
}
if (! \mb_check_encoding($uri, 'UTF-8')) {
throw new UnexpectedEncodingException('Unexpected encoding - UTF-8 or ASCII was expected');
}
$result = '';
$chars = \mb_str_split($uri, 1, 'UTF-8');
$l = \count($chars);
for ($i = 0; $i < $l; $i++) {
$code = $chars[$i];
if ($code === '%' && $i + 2 < $l) {
if (\preg_match('/^[0-9a-f]{2}$/i', $chars[$i + 1] . $chars[$i + 2]) === 1) {
$result .= '%' . $chars[$i + 1] . $chars[$i + 2];
$i += 2;
continue;
}
}
if (\ord($code) < 128) {
$result .= self::ENCODE_CACHE[\ord($code)];
continue;
}
$result .= \rawurlencode($code);
}
return $result;
}
}
PK �@])Q�i i src/Util/PrioritizedList.phpnu �[��� <?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\Util;
/**
* @internal
*
* @phpstan-template T
* @phpstan-implements \IteratorAggregate<T>
*/
final class PrioritizedList implements \IteratorAggregate
{
/**
* @var array<int, array<mixed>>
* @phpstan-var array<int, array<T>>
*/
private array $list = [];
/**
* @var \Traversable<mixed>|null
* @phpstan-var \Traversable<T>|null
*/
private ?\Traversable $optimized = null;
/**
* @param mixed $item
*
* @phpstan-param T $item
*/
public function add($item, int $priority): void
{
$this->list[$priority][] = $item;
$this->optimized = null;
}
/**
* @return \Traversable<int, mixed>
*
* @phpstan-return \Traversable<int, T>
*/
#[\ReturnTypeWillChange]
public function getIterator(): \Traversable
{
if ($this->optimized === null) {
\krsort($this->list);
$sorted = [];
foreach ($this->list as $group) {
foreach ($group as $item) {
$sorted[] = $item;
}
}
$this->optimized = new \ArrayIterator($sorted);
}
return $this->optimized;
}
}
PK �@] �sX� � src/Util/LinkParserHelper.phpnu �[��� <?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\Util;
use League\CommonMark\Parser\Cursor;
/**
* @psalm-immutable
*/
final class LinkParserHelper
{
/**
* Attempt to parse link destination
*
* @return string|null The string, or null if no match
*/
public static function parseLinkDestination(Cursor $cursor): ?string
{
if ($res = $cursor->match(RegexHelper::REGEX_LINK_DESTINATION_BRACES)) {
// Chop off surrounding <..>:
return UrlEncoder::unescapeAndEncode(
RegexHelper::unescape(\substr($res, 1, -1))
);
}
if ($cursor->getCurrentCharacter() === '<') {
return null;
}
$destination = self::manuallyParseLinkDestination($cursor);
if ($destination === null) {
return null;
}
return UrlEncoder::unescapeAndEncode(
RegexHelper::unescape($destination)
);
}
public static function parseLinkLabel(Cursor $cursor): int
{
$match = $cursor->match('/^\[(?:[^\\\\\[\]]|\\\\.){0,1000}\]/');
if ($match === null) {
return 0;
}
$length = \mb_strlen($match, 'UTF-8');
if ($length > 1001) {
return 0;
}
return $length;
}
public static function parsePartialLinkLabel(Cursor $cursor): ?string
{
return $cursor->match('/^(?:[^\\\\\[\]]+|\\\\.?)*/');
}
/**
* Attempt to parse link title (sans quotes)
*
* @return string|null The string, or null if no match
*/
public static function parseLinkTitle(Cursor $cursor): ?string
{
if ($title = $cursor->match('/' . RegexHelper::PARTIAL_LINK_TITLE . '/')) {
// Chop off quotes from title and unescape
return RegexHelper::unescape(\substr($title, 1, -1));
}
return null;
}
public static function parsePartialLinkTitle(Cursor $cursor, string $endDelimiter): ?string
{
$endDelimiter = \preg_quote($endDelimiter, '/');
$regex = \sprintf('/(%s|[^%s\x00])*(?:%s)?/', RegexHelper::PARTIAL_ESCAPED_CHAR, $endDelimiter, $endDelimiter);
if (($partialTitle = $cursor->match($regex)) === null) {
return null;
}
return RegexHelper::unescape($partialTitle);
}
private static function manuallyParseLinkDestination(Cursor $cursor): ?string
{
$oldPosition = $cursor->getPosition();
$oldState = $cursor->saveState();
$openParens = 0;
while (($c = $cursor->getCurrentCharacter()) !== null) {
if ($c === '\\' && ($peek = $cursor->peek()) !== null && RegexHelper::isEscapable($peek)) {
$cursor->advanceBy(2);
} elseif ($c === '(') {
$cursor->advanceBy(1);
$openParens++;
} elseif ($c === ')') {
if ($openParens < 1) {
break;
}
$cursor->advanceBy(1);
$openParens--;
} elseif (\preg_match(RegexHelper::REGEX_WHITESPACE_CHAR, $c)) {
break;
} else {
$cursor->advanceBy(1);
}
}
if ($openParens !== 0) {
return null;
}
if ($cursor->getPosition() === $oldPosition && (! isset($c) || $c !== ')')) {
return null;
}
$newPos = $cursor->getPosition();
$cursor->restoreState($oldState);
$cursor->advanceBy($newPos - $cursor->getPosition());
return $cursor->getPreviousText();
}
}
PK �@] �A�( ( src/Util/RegexHelper.phpnu �[��� <?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\Util;
use League\CommonMark\Exception\InvalidArgumentException;
use League\CommonMark\Extension\CommonMark\Node\Block\HtmlBlock;
/**
* Provides regular expressions and utilities for parsing Markdown
*
* All of the PARTIAL_ regex constants assume that they'll be used in case-insensitive searches
* All other complete regexes provided by this class (either via constants or methods) will have case-insensitivity enabled.
*
* @phpcs:disable Generic.Strings.UnnecessaryStringConcat.Found
*
* @psalm-immutable
*/
final class RegexHelper
{
// Partial regular expressions (wrap with `/` on each side and add the case-insensitive `i` flag before use)
public const PARTIAL_ENTITY = '&(?:#x[a-f0-9]{1,6}|#[0-9]{1,7}|[a-z][a-z0-9]{1,31});';
public const PARTIAL_ESCAPABLE = '[!"#$%&\'()*+,.\/:;<=>?@[\\\\\]^_`{|}~-]';
public const PARTIAL_ESCAPED_CHAR = '\\\\' . self::PARTIAL_ESCAPABLE;
public const PARTIAL_IN_DOUBLE_QUOTES = '"(' . self::PARTIAL_ESCAPED_CHAR . '|[^"\x00])*"';
public const PARTIAL_IN_SINGLE_QUOTES = '\'(' . self::PARTIAL_ESCAPED_CHAR . '|[^\'\x00])*\'';
public const PARTIAL_IN_PARENS = '\\((' . self::PARTIAL_ESCAPED_CHAR . '|[^)\x00])*\\)';
public const PARTIAL_REG_CHAR = '[^\\\\()\x00-\x20]';
public const PARTIAL_IN_PARENS_NOSP = '\((' . self::PARTIAL_REG_CHAR . '|' . self::PARTIAL_ESCAPED_CHAR . '|\\\\)*\)';
public const PARTIAL_TAGNAME = '[a-z][a-z0-9-]*';
public const PARTIAL_BLOCKTAGNAME = '(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h1|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)';
public const PARTIAL_ATTRIBUTENAME = '[a-z_:][a-z0-9:._-]*';
public const PARTIAL_UNQUOTEDVALUE = '[^"\'=<>`\x00-\x20]+';
public const PARTIAL_SINGLEQUOTEDVALUE = '\'[^\']*\'';
public const PARTIAL_DOUBLEQUOTEDVALUE = '"[^"]*"';
public const PARTIAL_ATTRIBUTEVALUE = '(?:' . self::PARTIAL_UNQUOTEDVALUE . '|' . self::PARTIAL_SINGLEQUOTEDVALUE . '|' . self::PARTIAL_DOUBLEQUOTEDVALUE . ')';
public const PARTIAL_ATTRIBUTEVALUESPEC = '(?:' . '\s*=' . '\s*' . self::PARTIAL_ATTRIBUTEVALUE . ')';
public const PARTIAL_ATTRIBUTE = '(?:' . '\s+' . self::PARTIAL_ATTRIBUTENAME . self::PARTIAL_ATTRIBUTEVALUESPEC . '?)';
public const PARTIAL_OPENTAG = '<' . self::PARTIAL_TAGNAME . self::PARTIAL_ATTRIBUTE . '*' . '\s*\/?>';
public const PARTIAL_CLOSETAG = '<\/' . self::PARTIAL_TAGNAME . '\s*[>]';
public const PARTIAL_OPENBLOCKTAG = '<' . self::PARTIAL_BLOCKTAGNAME . self::PARTIAL_ATTRIBUTE . '*' . '\s*\/?>';
public const PARTIAL_CLOSEBLOCKTAG = '<\/' . self::PARTIAL_BLOCKTAGNAME . '\s*[>]';
public const PARTIAL_HTMLCOMMENT = '<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->';
public const PARTIAL_PROCESSINGINSTRUCTION = '[<][?][\s\S]*?[?][>]';
public const PARTIAL_DECLARATION = '<![A-Z]+' . '[^>]*>';
public const PARTIAL_CDATA = '<!\[CDATA\[[\s\S]*?]\]>';
public const PARTIAL_HTMLTAG = '(?:' . self::PARTIAL_OPENTAG . '|' . self::PARTIAL_CLOSETAG . '|' . self::PARTIAL_HTMLCOMMENT . '|' .
self::PARTIAL_PROCESSINGINSTRUCTION . '|' . self::PARTIAL_DECLARATION . '|' . self::PARTIAL_CDATA . ')';
public const PARTIAL_HTMLBLOCKOPEN = '<(?:' . self::PARTIAL_BLOCKTAGNAME . '(?:[\s\/>]|$)' . '|' .
'\/' . self::PARTIAL_BLOCKTAGNAME . '(?:[\s>]|$)' . '|' . '[?!])';
public const PARTIAL_LINK_TITLE = '^(?:"(' . self::PARTIAL_ESCAPED_CHAR . '|[^"\x00])*"' .
'|' . '\'(' . self::PARTIAL_ESCAPED_CHAR . '|[^\'\x00])*\'' .
'|' . '\((' . self::PARTIAL_ESCAPED_CHAR . '|[^()\x00])*\))';
public const REGEX_PUNCTUATION = '/^[\x{2000}-\x{206F}\x{2E00}-\x{2E7F}\p{Pc}\p{Pd}\p{Pe}\p{Pf}\p{Pi}\p{Po}\p{Ps}\\\\\'!"#\$%&\(\)\*\+,\-\.\\/:;<=>\?@\[\]\^_`\{\|\}~]/u';
public const REGEX_UNSAFE_PROTOCOL = '/^javascript:|vbscript:|file:|data:/i';
public const REGEX_SAFE_DATA_PROTOCOL = '/^data:image\/(?:png|gif|jpeg|webp)/i';
public const REGEX_NON_SPACE = '/[^ \t\f\v\r\n]/';
public const REGEX_WHITESPACE_CHAR = '/^[ \t\n\x0b\x0c\x0d]/';
public const REGEX_UNICODE_WHITESPACE_CHAR = '/^\pZ|\s/u';
public const REGEX_THEMATIC_BREAK = '/^(?:\*[ \t]*){3,}$|^(?:_[ \t]*){3,}$|^(?:-[ \t]*){3,}$/';
public const REGEX_LINK_DESTINATION_BRACES = '/^(?:<(?:[^<>\\n\\\\\\x00]|\\\\.)*>)/';
/**
* @psalm-pure
*/
public static function isEscapable(string $character): bool
{
return \preg_match('/' . self::PARTIAL_ESCAPABLE . '/', $character) === 1;
}
/**
* @psalm-pure
*/
public static function isLetter(?string $character): bool
{
if ($character === null) {
return false;
}
return \preg_match('/[\pL]/u', $character) === 1;
}
/**
* Attempt to match a regex in string s at offset offset
*
* @psalm-param non-empty-string $regex
*
* @return int|null Index of match, or null
*
* @psalm-pure
*/
public static function matchAt(string $regex, string $string, int $offset = 0): ?int
{
$matches = [];
$string = \mb_substr($string, $offset, null, 'UTF-8');
if (! \preg_match($regex, $string, $matches, \PREG_OFFSET_CAPTURE)) {
return null;
}
// PREG_OFFSET_CAPTURE always returns the byte offset, not the char offset, which is annoying
$charPos = \mb_strlen(\mb_strcut($string, 0, $matches[0][1], 'UTF-8'), 'UTF-8');
return $offset + $charPos;
}
/**
* Functional wrapper around preg_match_all which only returns the first set of matches
*
* @psalm-param non-empty-string $pattern
*
* @return string[]|null
*
* @psalm-pure
*/
public static function matchFirst(string $pattern, string $subject, int $offset = 0): ?array
{
if ($offset !== 0) {
$subject = \substr($subject, $offset);
}
\preg_match_all($pattern, $subject, $matches, \PREG_SET_ORDER);
if ($matches === []) {
return null;
}
return $matches[0] ?: null;
}
/**
* Replace backslash escapes with literal characters
*
* @psalm-pure
*/
public static function unescape(string $string): string
{
$allEscapedChar = '/\\\\(' . self::PARTIAL_ESCAPABLE . ')/';
$escaped = \preg_replace($allEscapedChar, '$1', $string);
\assert(\is_string($escaped));
return \preg_replace_callback('/' . self::PARTIAL_ENTITY . '/i', static fn ($e) => Html5EntityDecoder::decode($e[0]), $escaped);
}
/**
* @internal
*
* @param int $type HTML block type
*
* @psalm-param HtmlBlock::TYPE_* $type
*
* @phpstan-param HtmlBlock::TYPE_* $type
*
* @psalm-return non-empty-string
*
* @throws InvalidArgumentException if an invalid type is given
*
* @psalm-pure
*/
public static function getHtmlBlockOpenRegex(int $type): string
{
switch ($type) {
case HtmlBlock::TYPE_1_CODE_CONTAINER:
return '/^<(?:script|pre|textarea|style)(?:\s|>|$)/i';
case HtmlBlock::TYPE_2_COMMENT:
return '/^<!--/';
case HtmlBlock::TYPE_3:
return '/^<[?]/';
case HtmlBlock::TYPE_4:
return '/^<![A-Z]/i';
case HtmlBlock::TYPE_5_CDATA:
return '/^<!\[CDATA\[/i';
case HtmlBlock::TYPE_6_BLOCK_ELEMENT:
return '%^<[/]?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[123456]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?:\s|[/]?[>]|$)%i';
case HtmlBlock::TYPE_7_MISC_ELEMENT:
return '/^(?:' . self::PARTIAL_OPENTAG . '|' . self::PARTIAL_CLOSETAG . ')\\s*$/i';
default:
throw new InvalidArgumentException('Invalid HTML block type');
}
}
/**
* @internal
*
* @param int $type HTML block type
*
* @psalm-param HtmlBlock::TYPE_* $type
*
* @phpstan-param HtmlBlock::TYPE_* $type
*
* @psalm-return non-empty-string
*
* @throws InvalidArgumentException if an invalid type is given
*
* @psalm-pure
*/
public static function getHtmlBlockCloseRegex(int $type): string
{
switch ($type) {
case HtmlBlock::TYPE_1_CODE_CONTAINER:
return '%<\/(?:script|pre|textarea|style)>%i';
case HtmlBlock::TYPE_2_COMMENT:
return '/-->/';
case HtmlBlock::TYPE_3:
return '/\?>/';
case HtmlBlock::TYPE_4:
return '/>/';
case HtmlBlock::TYPE_5_CDATA:
return '/\]\]>/';
default:
throw new InvalidArgumentException('Invalid HTML block type');
}
}
/**
* @psalm-pure
*/
public static function isLinkPotentiallyUnsafe(string $url): bool
{
return \preg_match(self::REGEX_UNSAFE_PROTOCOL, $url) !== 0 && \preg_match(self::REGEX_SAFE_DATA_PROTOCOL, $url) === 0;
}
}
PK �@]�My src/Util/Html5EntityDecoder.phpnu �[��� <?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\Util;
/**
* @psalm-immutable
*/
final class Html5EntityDecoder
{
/**
* @psalm-pure
*/
public static function decode(string $entity): string
{
if (\substr($entity, -1) !== ';') {
return $entity;
}
if (\substr($entity, 0, 2) === '&#') {
if (\strtolower(\substr($entity, 2, 1)) === 'x') {
return self::fromHex(\substr($entity, 3, -1));
}
return self::fromDecimal(\substr($entity, 2, -1));
}
return \html_entity_decode($entity, \ENT_QUOTES | \ENT_HTML5, 'UTF-8');
}
/**
* @param mixed $number
*
* @psalm-pure
*/
private static function fromDecimal($number): string
{
// Only convert code points within planes 0-2, excluding NULL
// phpcs:ignore Generic.PHP.ForbiddenFunctions.Found
if (empty($number) || $number > 0x2FFFF) {
return self::fromHex('fffd');
}
$entity = '&#' . $number . ';';
$converted = \mb_decode_numericentity($entity, [0x0, 0x2FFFF, 0, 0xFFFF], 'UTF-8');
if ($converted === $entity) {
return self::fromHex('fffd');
}
return $converted;
}
/**
* @psalm-pure
*/
private static function fromHex(string $hexChars): string
{
return self::fromDecimal(\hexdec($hexChars));
}
}
PK �@]�ؼ � src/Util/HtmlFilter.phpnu �[��� <?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\Util;
use League\CommonMark\Exception\InvalidArgumentException;
/**
* @psalm-immutable
*/
final class HtmlFilter
{
// Return the entire string as-is
public const ALLOW = 'allow';
// Escape the entire string so any HTML/JS won't be interpreted as such
public const ESCAPE = 'escape';
// Return an empty string
public const STRIP = 'strip';
/**
* Runs the given HTML through the given filter
*
* @param string $html HTML input to be filtered
* @param string $filter One of the HtmlFilter constants
*
* @return string Filtered HTML
*
* @throws InvalidArgumentException when an invalid $filter is given
*
* @psalm-pure
*/
public static function filter(string $html, string $filter): string
{
switch ($filter) {
case self::STRIP:
return '';
case self::ESCAPE:
return \htmlspecialchars($html, \ENT_NOQUOTES);
case self::ALLOW:
return $html;
default:
throw new InvalidArgumentException(\sprintf('Invalid filter provided: "%s"', $filter));
}
}
}
PK �@]�X���
�
src/Util/ArrayCollection.phpnu �[��� <?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\Util;
/**
* Array collection
*
* Provides a wrapper around a standard PHP array.
*
* @internal
*
* @phpstan-template T
* @phpstan-implements \IteratorAggregate<int, T>
* @phpstan-implements \ArrayAccess<int, T>
*/
final class ArrayCollection implements \IteratorAggregate, \Countable, \ArrayAccess
{
/**
* @var array<int, mixed>
* @phpstan-var array<int, T>
*/
private array $elements;
/**
* Constructor
*
* @param array<int|string, mixed> $elements
*
* @phpstan-param array<int, T> $elements
*/
public function __construct(array $elements = [])
{
$this->elements = $elements;
}
/**
* @return mixed|false
*
* @phpstan-return T|false
*/
public function first()
{
return \reset($this->elements);
}
/**
* @return mixed|false
*
* @phpstan-return T|false
*/
public function last()
{
return \end($this->elements);
}
/**
* Retrieve an external iterator
*
* @return \ArrayIterator<int, mixed>
*
* @phpstan-return \ArrayIterator<int, T>
*/
#[\ReturnTypeWillChange]
public function getIterator(): \ArrayIterator
{
return new \ArrayIterator($this->elements);
}
/**
* Count elements of an object
*
* @return int The count as an integer.
*/
public function count(): int
{
return \count($this->elements);
}
/**
* Whether an offset exists
*
* {@inheritDoc}
*
* @phpstan-param int $offset
*/
public function offsetExists($offset): bool
{
return \array_key_exists($offset, $this->elements);
}
/**
* Offset to retrieve
*
* {@inheritDoc}
*
* @phpstan-param int $offset
*
* @phpstan-return T|null
*/
#[\ReturnTypeWillChange]
public function offsetGet($offset)
{
return $this->elements[$offset] ?? null;
}
/**
* Offset to set
*
* {@inheritDoc}
*
* @phpstan-param int|null $offset
* @phpstan-param T $value
*/
#[\ReturnTypeWillChange]
public function offsetSet($offset, $value): void
{
if ($offset === null) {
$this->elements[] = $value;
} else {
$this->elements[$offset] = $value;
}
}
/**
* Offset to unset
*
* {@inheritDoc}
*
* @phpstan-param int $offset
*/
#[\ReturnTypeWillChange]
public function offsetUnset($offset): void
{
if (! \array_key_exists($offset, $this->elements)) {
return;
}
unset($this->elements[$offset]);
}
/**
* Returns a subset of the array
*
* @return array<int, mixed>
*
* @phpstan-return array<int, T>
*/
public function slice(int $offset, ?int $length = null): array
{
return \array_slice($this->elements, $offset, $length, true);
}
/**
* @return array<int, mixed>
*
* @phpstan-return array<int, T>
*/
public function toArray(): array
{
return $this->elements;
}
}
PK �@] w�?� � src/Util/Xml.phpnu �[��� <?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\Util;
/**
* Utility class for handling/generating XML and HTML
*
* @psalm-immutable
*/
final class Xml
{
/**
* @psalm-pure
*/
public static function escape(string $string): string
{
return \str_replace(['&', '<', '>', '"'], ['&', '<', '>', '"'], $string);
}
}
PK �@]y0@, , src/Util/HtmlElement.phpnu �[��� <?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\Util;
final class HtmlElement implements \Stringable
{
/** @psalm-readonly */
private string $tagName;
/** @var array<string, string|bool> */
private array $attributes = [];
/** @var \Stringable|\Stringable[]|string */
private $contents;
/** @psalm-readonly */
private bool $selfClosing;
/**
* @param string $tagName Name of the HTML tag
* @param array<string, string|string[]|bool> $attributes Array of attributes (values should be unescaped)
* @param \Stringable|\Stringable[]|string|null $contents Inner contents, pre-escaped if needed
* @param bool $selfClosing Whether the tag is self-closing
*/
public function __construct(string $tagName, array $attributes = [], $contents = '', bool $selfClosing = false)
{
$this->tagName = $tagName;
$this->selfClosing = $selfClosing;
foreach ($attributes as $name => $value) {
$this->setAttribute($name, $value);
}
$this->setContents($contents ?? '');
}
/** @psalm-immutable */
public function getTagName(): string
{
return $this->tagName;
}
/**
* @return array<string, string|bool>
*
* @psalm-immutable
*/
public function getAllAttributes(): array
{
return $this->attributes;
}
/**
* @return string|bool|null
*
* @psalm-immutable
*/
public function getAttribute(string $key)
{
return $this->attributes[$key] ?? null;
}
/**
* @param string|string[]|bool $value
*/
public function setAttribute(string $key, $value = true): self
{
if (\is_array($value)) {
$this->attributes[$key] = \implode(' ', \array_unique($value));
} else {
$this->attributes[$key] = $value;
}
return $this;
}
/**
* @return \Stringable|\Stringable[]|string
*
* @psalm-immutable
*/
public function getContents(bool $asString = true)
{
if (! $asString) {
return $this->contents;
}
return $this->getContentsAsString();
}
/**
* Sets the inner contents of the tag (must be pre-escaped if needed)
*
* @param \Stringable|\Stringable[]|string $contents
*
* @return $this
*/
public function setContents($contents): self
{
$this->contents = $contents ?? ''; // @phpstan-ignore-line
return $this;
}
/** @psalm-immutable */
public function __toString(): string
{
$result = '<' . $this->tagName;
foreach ($this->attributes as $key => $value) {
if ($value === true) {
$result .= ' ' . $key;
} elseif ($value === false) {
continue;
} else {
$result .= ' ' . $key . '="' . Xml::escape($value) . '"';
}
}
if ($this->contents !== '') {
$result .= '>' . $this->getContentsAsString() . '</' . $this->tagName . '>';
} elseif ($this->selfClosing && $this->tagName === 'input') {
$result .= '>';
} elseif ($this->selfClosing) {
$result .= ' />';
} else {
$result .= '></' . $this->tagName . '>';
}
return $result;
}
/** @psalm-immutable */
private function getContentsAsString(): string
{
if (\is_string($this->contents)) {
return $this->contents;
}
if (\is_array($this->contents)) {
return \implode('', $this->contents);
}
return (string) $this->contents;
}
}
PK �@]��
�� � ' src/GithubFlavoredMarkdownConverter.phpnu �[��� <?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;
use League\CommonMark\Environment\Environment;
use League\CommonMark\Extension\CommonMark\CommonMarkCoreExtension;
use League\CommonMark\Extension\GithubFlavoredMarkdownExtension;
/**
* Converts GitHub Flavored Markdown to HTML.
*/
final class GithubFlavoredMarkdownConverter extends MarkdownConverter
{
/**
* Create a new Markdown converter pre-configured for GFM
*
* @param array<string, mixed> $config
*/
public function __construct(array $config = [])
{
$environment = new Environment($config);
$environment->addExtension(new CommonMarkCoreExtension());
$environment->addExtension(new GithubFlavoredMarkdownExtension());
parent::__construct($environment);
}
public function getEnvironment(): Environment
{
\assert($this->environment instanceof Environment);
return $this->environment;
}
}
PK �@]�oF/� � # src/Event/DocumentRenderedEvent.phpnu �[��� <?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\Event;
use League\CommonMark\Output\RenderedContentInterface;
final class DocumentRenderedEvent extends AbstractEvent
{
private RenderedContentInterface $output;
public function __construct(RenderedContentInterface $output)
{
$this->output = $output;
}
/**
* @psalm-mutation-free
*/
public function getOutput(): RenderedContentInterface
{
return $this->output;
}
/**
* @psalm-external-mutation-free
*/
public function replaceOutput(RenderedContentInterface $output): void
{
$this->output = $output;
}
}
PK �@]A2hێ � $ src/Event/DocumentPreRenderEvent.phpnu �[��� <?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\Event;
use League\CommonMark\Node\Block\Document;
/**
* Event dispatched just before rendering begins
*/
final class DocumentPreRenderEvent extends AbstractEvent
{
/** @psalm-readonly */
private Document $document;
/** @psalm-readonly */
private string $format;
public function __construct(Document $document, string $format)
{
$this->document = $document;
$this->format = $format;
}
public function getDocument(): Document
{
return $this->document;
}
public function getFormat(): string
{
return $this->format;
}
}
PK �@]
�V2� � ! src/Event/DocumentParsedEvent.phpnu �[��� <?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\Event;
use League\CommonMark\Node\Block\Document;
/**
* Event dispatched when the document has been fully parsed
*/
final class DocumentParsedEvent extends AbstractEvent
{
/** @psalm-readonly */
private Document $document;
public function __construct(Document $document)
{
$this->document = $document;
}
public function getDocument(): Document
{
return $this->document;
}
}
PK �@]0�!�� � src/Event/AbstractEvent.phpnu �[��� <?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 Symfony EventDispatcher "Event" contract
* - (c) 2018-2019 Fabien Potencier
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace League\CommonMark\Event;
use Psr\EventDispatcher\StoppableEventInterface;
/**
* Base class for classes containing event data.
*
* This class contains no event data. It is used by events that do not pass
* state information to an event handler when an event is raised.
*
* You can call the method stopPropagation() to abort the execution of
* further listeners in your event listener.
*/
abstract class AbstractEvent implements StoppableEventInterface
{
/** @psalm-readonly-allow-private-mutation */
private bool $propagationStopped = false;
/**
* Returns whether further event listeners should be triggered.
*/
final public function isPropagationStopped(): bool
{
return $this->propagationStopped;
}
/**
* Stops the propagation of the event to further event listeners.
*
* If multiple event listeners are connected to the same event, no
* further event listener will be triggered once any trigger calls
* stopPropagation().
*/
final public function stopPropagation(): void
{
$this->propagationStopped = true;
}
}
PK �@] �/E� � src/Event/ListenerData.phpnu �[��� <?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\Event;
/**
* @internal
*
* @psalm-immutable
*/
final class ListenerData
{
/** @var class-string */
private string $event;
/** @var callable */
private $listener;
/**
* @param class-string $event
*/
public function __construct(string $event, callable $listener)
{
$this->event = $event;
$this->listener = $listener;
}
/**
* @return class-string
*/
public function getEvent(): string
{
return $this->event;
}
public function getListener(): callable
{
return $this->listener;
}
}
PK �@]��t t $ src/Event/DocumentPreParsedEvent.phpnu �[��� <?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\Event;
use League\CommonMark\Input\MarkdownInputInterface;
use League\CommonMark\Node\Block\Document;
/**
* Event dispatched when the document is about to be parsed
*/
final class DocumentPreParsedEvent extends AbstractEvent
{
/** @psalm-readonly */
private Document $document;
private MarkdownInputInterface $markdown;
public function __construct(Document $document, MarkdownInputInterface $markdown)
{
$this->document = $document;
$this->markdown = $markdown;
}
public function getDocument(): Document
{
return $this->document;
}
public function getMarkdown(): MarkdownInputInterface
{
return $this->markdown;
}
public function replaceMarkdown(MarkdownInputInterface $markdownInput): void
{
$this->markdown = $markdownInput;
}
}
PK �@]G
0 src/Extension/ConfigurableExtensionInterface.phpnu �[��� <?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;
use League\Config\ConfigurationBuilderInterface;
interface ConfigurableExtensionInterface extends ExtensionInterface
{
public function configureSchema(ConfigurationBuilderInterface $builder): void;
}
PK �@]�F� ! src/Extension/Mention/Mention.phpnu �[��� <?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\Mention;
use League\CommonMark\Extension\CommonMark\Node\Inline\Link;
use League\CommonMark\Node\Inline\Text;
class Mention extends Link
{
private string $name;
private string $prefix;
private string $identifier;
public function __construct(string $name, string $prefix, string $identifier, ?string $label = null)
{
$this->name = $name;
$this->prefix = $prefix;
$this->identifier = $identifier;
parent::__construct('', $label ?? \sprintf('%s%s', $prefix, $identifier));
}
public function getLabel(): ?string
{
if (($labelNode = $this->findLabelNode()) === null) {
return null;
}
return $labelNode->getLiteral();
}
public function getIdentifier(): string
{
return $this->identifier;
}
public function getName(): ?string
{
return $this->name;
}
public function getPrefix(): string
{
return $this->prefix;
}
public function hasUrl(): bool
{
return $this->url !== '';
}
/**
* @return $this
*/
public function setLabel(string $label): self
{
if (($labelNode = $this->findLabelNode()) === null) {
$labelNode = new Text();
$this->prependChild($labelNode);
}
$labelNode->setLiteral($label);
return $this;
}
private function findLabelNode(): ?Text
{
foreach ($this->children() as $child) {
if ($child instanceof Text) {
return $child;
}
}
return null;
}
}
PK �@]<@�(�
�
* src/Extension/Mention/MentionExtension.phpnu �[��� <?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\Mention;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Extension\ConfigurableExtensionInterface;
use League\CommonMark\Extension\Mention\Generator\MentionGeneratorInterface;
use League\Config\ConfigurationBuilderInterface;
use League\Config\Exception\InvalidConfigurationException;
use Nette\Schema\Expect;
final class MentionExtension implements ConfigurableExtensionInterface
{
public function configureSchema(ConfigurationBuilderInterface $builder): void
{
$isAValidPartialRegex = static function (string $regex): bool {
$regex = '/' . $regex . '/i';
return @\preg_match($regex, '') !== false;
};
$builder->addSchema('mentions', Expect::arrayOf(
Expect::structure([
'prefix' => Expect::string()->required(),
'pattern' => Expect::string()->assert($isAValidPartialRegex, 'Pattern must not include starting/ending delimiters (like "/")')->required(),
'generator' => Expect::anyOf(
Expect::type(MentionGeneratorInterface::class),
Expect::string(),
Expect::type('callable')
)->required(),
])
));
}
public function register(EnvironmentBuilderInterface $environment): void
{
$mentions = $environment->getConfiguration()->get('mentions');
foreach ($mentions as $name => $mention) {
if ($mention['generator'] instanceof MentionGeneratorInterface) {
$environment->addInlineParser(new MentionParser($name, $mention['prefix'], $mention['pattern'], $mention['generator']));
} elseif (\is_string($mention['generator'])) {
$environment->addInlineParser(MentionParser::createWithStringTemplate($name, $mention['prefix'], $mention['pattern'], $mention['generator']));
} elseif (\is_callable($mention['generator'])) {
$environment->addInlineParser(MentionParser::createWithCallback($name, $mention['prefix'], $mention['pattern'], $mention['generator']));
} else {
throw new InvalidConfigurationException(\sprintf('The "generator" provided for the "%s" MentionParser configuration must be a string template, callable, or an object that implements %s.', $name, MentionGeneratorInterface::class));
}
}
}
}
PK �@]��T/� � ' src/Extension/Mention/MentionParser.phpnu �[��� <?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\Mention;
use League\CommonMark\Extension\Mention\Generator\CallbackGenerator;
use League\CommonMark\Extension\Mention\Generator\MentionGeneratorInterface;
use League\CommonMark\Extension\Mention\Generator\StringTemplateLinkGenerator;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Parser\Inline\InlineParserMatch;
use League\CommonMark\Parser\InlineParserContext;
final class MentionParser implements InlineParserInterface
{
/** @psalm-readonly */
private string $name;
/** @psalm-readonly */
private string $prefix;
/** @psalm-readonly */
private string $identifierPattern;
/** @psalm-readonly */
private MentionGeneratorInterface $mentionGenerator;
public function __construct(string $name, string $prefix, string $identifierPattern, MentionGeneratorInterface $mentionGenerator)
{
$this->name = $name;
$this->prefix = $prefix;
$this->identifierPattern = $identifierPattern;
$this->mentionGenerator = $mentionGenerator;
}
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::join(
InlineParserMatch::string($this->prefix),
InlineParserMatch::regex($this->identifierPattern)
);
}
public function parse(InlineParserContext $inlineContext): bool
{
$cursor = $inlineContext->getCursor();
// The prefix must not have any other characters immediately prior
$previousChar = $cursor->peek(-1);
if ($previousChar !== null && \preg_match('/\w/', $previousChar)) {
// peek() doesn't modify the cursor, so no need to restore state first
return false;
}
[$prefix, $identifier] = $inlineContext->getSubMatches();
$mention = $this->mentionGenerator->generateMention(new Mention($this->name, $prefix, $identifier));
if ($mention === null) {
return false;
}
$cursor->advanceBy($inlineContext->getFullMatchLength());
$inlineContext->getContainer()->appendChild($mention);
return true;
}
public static function createWithStringTemplate(string $name, string $prefix, string $mentionRegex, string $urlTemplate): MentionParser
{
return new self($name, $prefix, $mentionRegex, new StringTemplateLinkGenerator($urlTemplate));
}
public static function createWithCallback(string $name, string $prefix, string $mentionRegex, callable $callback): MentionParser
{
return new self($name, $prefix, $mentionRegex, new CallbackGenerator($callback));
}
}
PK �@]�U|� = src/Extension/Mention/Generator/MentionGeneratorInterface.phpnu �[��� <?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\Mention\Generator;
use League\CommonMark\Extension\Mention\Mention;
use League\CommonMark\Node\Inline\AbstractInline;
interface MentionGeneratorInterface
{
public function generateMention(Mention $mention): ?AbstractInline;
}
PK �@] �ݖN N ? src/Extension/Mention/Generator/StringTemplateLinkGenerator.phpnu �[��� <?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\Mention\Generator;
use League\CommonMark\Extension\Mention\Mention;
use League\CommonMark\Node\Inline\AbstractInline;
final class StringTemplateLinkGenerator implements MentionGeneratorInterface
{
private string $urlTemplate;
public function __construct(string $urlTemplate)
{
$this->urlTemplate = $urlTemplate;
}
public function generateMention(Mention $mention): ?AbstractInline
{
$mention->setUrl(\sprintf($this->urlTemplate, $mention->getIdentifier()));
return $mention;
}
}
PK �@]�G��G G 5 src/Extension/Mention/Generator/CallbackGenerator.phpnu �[��� <?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\Mention\Generator;
use League\CommonMark\Exception\LogicException;
use League\CommonMark\Extension\Mention\Mention;
use League\CommonMark\Node\Inline\AbstractInline;
final class CallbackGenerator implements MentionGeneratorInterface
{
/**
* A callback function which sets the URL on the passed mention and returns the mention, return a new AbstractInline based object or null if the mention is not a match
*
* @var callable(Mention): ?AbstractInline
*/
private $callback;
public function __construct(callable $callback)
{
$this->callback = $callback;
}
/**
* @throws LogicException
*/
public function generateMention(Mention $mention): ?AbstractInline
{
$result = \call_user_func($this->callback, $mention);
if ($result === null) {
return null;
}
if ($result instanceof AbstractInline && ! ($result instanceof Mention)) {
return $result;
}
if ($result instanceof Mention && $result->hasUrl()) {
return $mention;
}
throw new LogicException('CallbackGenerator callable must set the URL on the passed mention and return the mention, return a new AbstractInline based object or null if the mention is not a match');
}
}
PK �@]�C@� � ; src/Extension/HeadingPermalink/HeadingPermalinkRenderer.phpnu �[��� <?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\HeadingPermalink;
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;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
/**
* Renders the HeadingPermalink elements
*/
final class HeadingPermalinkRenderer implements NodeRendererInterface, XmlNodeRendererInterface, ConfigurationAwareInterface
{
public const DEFAULT_SYMBOL = '¶';
/** @psalm-readonly-allow-private-mutation */
private ConfigurationInterface $config;
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
/**
* @param HeadingPermalink $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
HeadingPermalink::assertInstanceOf($node);
$slug = $node->getSlug();
$fragmentPrefix = (string) $this->config->get('heading_permalink/fragment_prefix');
if ($fragmentPrefix !== '') {
$fragmentPrefix .= '-';
}
$attrs = $node->data->getData('attributes');
$appendId = ! $this->config->get('heading_permalink/apply_id_to_heading');
if ($appendId) {
$idPrefix = (string) $this->config->get('heading_permalink/id_prefix');
if ($idPrefix !== '') {
$idPrefix .= '-';
}
$attrs->set('id', $idPrefix . $slug);
}
$attrs->set('href', '#' . $fragmentPrefix . $slug);
$attrs->append('class', $this->config->get('heading_permalink/html_class'));
$hidden = $this->config->get('heading_permalink/aria_hidden');
if ($hidden) {
$attrs->set('aria-hidden', 'true');
}
$attrs->set('title', $this->config->get('heading_permalink/title'));
$symbol = $this->config->get('heading_permalink/symbol');
\assert(\is_string($symbol));
return new HtmlElement('a', $attrs->export(), \htmlspecialchars($symbol), false);
}
public function getXmlTagName(Node $node): string
{
return 'heading_permalink';
}
/**
* @param HeadingPermalink $node
*
* @return array<string, scalar>
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlAttributes(Node $node): array
{
HeadingPermalink::assertInstanceOf($node);
return [
'slug' => $node->getSlug(),
];
}
}
PK �@]��� � < src/Extension/HeadingPermalink/HeadingPermalinkProcessor.phpnu �[��� <?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\HeadingPermalink;
use League\CommonMark\Environment\EnvironmentAwareInterface;
use League\CommonMark\Environment\EnvironmentInterface;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\CommonMark\Node\Block\Heading;
use League\CommonMark\Node\NodeIterator;
use League\CommonMark\Node\RawMarkupContainerInterface;
use League\CommonMark\Node\StringContainerHelper;
use League\CommonMark\Normalizer\TextNormalizerInterface;
use League\Config\ConfigurationInterface;
use League\Config\Exception\InvalidConfigurationException;
/**
* Searches the Document for Heading elements and adds HeadingPermalinks to each one
*/
final class HeadingPermalinkProcessor implements EnvironmentAwareInterface
{
public const INSERT_BEFORE = 'before';
public const INSERT_AFTER = 'after';
public const INSERT_NONE = 'none';
/** @psalm-readonly-allow-private-mutation */
private TextNormalizerInterface $slugNormalizer;
/** @psalm-readonly-allow-private-mutation */
private ConfigurationInterface $config;
public function setEnvironment(EnvironmentInterface $environment): void
{
$this->config = $environment->getConfiguration();
$this->slugNormalizer = $environment->getSlugNormalizer();
}
public function __invoke(DocumentParsedEvent $e): void
{
$min = (int) $this->config->get('heading_permalink/min_heading_level');
$max = (int) $this->config->get('heading_permalink/max_heading_level');
$applyToHeading = (bool) $this->config->get('heading_permalink/apply_id_to_heading');
$idPrefix = (string) $this->config->get('heading_permalink/id_prefix');
$slugLength = (int) $this->config->get('slug_normalizer/max_length');
$headingClass = (string) $this->config->get('heading_permalink/heading_class');
if ($idPrefix !== '') {
$idPrefix .= '-';
}
foreach ($e->getDocument()->iterator(NodeIterator::FLAG_BLOCKS_ONLY) as $node) {
if ($node instanceof Heading && $node->getLevel() >= $min && $node->getLevel() <= $max) {
$this->addHeadingLink($node, $slugLength, $idPrefix, $applyToHeading, $headingClass);
}
}
}
private function addHeadingLink(Heading $heading, int $slugLength, string $idPrefix, bool $applyToHeading, string $headingClass): void
{
$text = StringContainerHelper::getChildText($heading, [RawMarkupContainerInterface::class]);
$slug = $this->slugNormalizer->normalize($text, [
'node' => $heading,
'length' => $slugLength,
]);
if ($applyToHeading) {
$heading->data->set('attributes/id', $idPrefix . $slug);
}
if ($headingClass !== '') {
$heading->data->append('attributes/class', $headingClass);
}
$headingLinkAnchor = new HeadingPermalink($slug);
switch ($this->config->get('heading_permalink/insert')) {
case self::INSERT_BEFORE:
$heading->prependChild($headingLinkAnchor);
return;
case self::INSERT_AFTER:
$heading->appendChild($headingLinkAnchor);
return;
case self::INSERT_NONE:
return;
default:
throw new InvalidConfigurationException("Invalid configuration value for heading_permalink/insert; expected 'before', 'after', or 'none'");
}
}
}
PK �@]rE{�� � 3 src/Extension/HeadingPermalink/HeadingPermalink.phpnu �[��� <?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\HeadingPermalink;
use League\CommonMark\Node\Inline\AbstractInline;
/**
* Represents an anchor link within a heading
*/
final class HeadingPermalink extends AbstractInline
{
/** @psalm-readonly */
private string $slug;
public function __construct(string $slug)
{
parent::__construct();
$this->slug = $slug;
}
public function getSlug(): string
{
return $this->slug;
}
}
PK �@]�CO�S S < src/Extension/HeadingPermalink/HeadingPermalinkExtension.phpnu �[��� <?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\HeadingPermalink;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\ConfigurableExtensionInterface;
use League\Config\ConfigurationBuilderInterface;
use Nette\Schema\Expect;
/**
* Extension which automatically anchor links to heading elements
*/
final class HeadingPermalinkExtension implements ConfigurableExtensionInterface
{
public function configureSchema(ConfigurationBuilderInterface $builder): void
{
$builder->addSchema('heading_permalink', Expect::structure([
'min_heading_level' => Expect::int()->min(1)->max(6)->default(1),
'max_heading_level' => Expect::int()->min(1)->max(6)->default(6),
'insert' => Expect::anyOf(HeadingPermalinkProcessor::INSERT_BEFORE, HeadingPermalinkProcessor::INSERT_AFTER, HeadingPermalinkProcessor::INSERT_NONE)->default(HeadingPermalinkProcessor::INSERT_BEFORE),
'id_prefix' => Expect::string()->default('content'),
'apply_id_to_heading' => Expect::bool()->default(false),
'heading_class' => Expect::string()->default(''),
'fragment_prefix' => Expect::string()->default('content'),
'html_class' => Expect::string()->default('heading-permalink'),
'title' => Expect::string()->default('Permalink'),
'symbol' => Expect::string()->default(HeadingPermalinkRenderer::DEFAULT_SYMBOL),
'aria_hidden' => Expect::bool()->default(true),
]));
}
public function register(EnvironmentBuilderInterface $environment): void
{
$environment->addEventListener(DocumentParsedEvent::class, new HeadingPermalinkProcessor(), -100);
$environment->addRenderer(HeadingPermalink::class, new HeadingPermalinkRenderer());
}
}
PK �@] ��� � 1 src/Extension/GithubFlavoredMarkdownExtension.phpnu �[��� <?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;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Extension\Autolink\AutolinkExtension;
use League\CommonMark\Extension\DisallowedRawHtml\DisallowedRawHtmlExtension;
use League\CommonMark\Extension\Strikethrough\StrikethroughExtension;
use League\CommonMark\Extension\Table\TableExtension;
use League\CommonMark\Extension\TaskList\TaskListExtension;
final class GithubFlavoredMarkdownExtension implements ExtensionInterface
{
public function register(EnvironmentBuilderInterface $environment): void
{
$environment->addExtension(new AutolinkExtension());
$environment->addExtension(new DisallowedRawHtmlExtension());
$environment->addExtension(new StrikethroughExtension());
$environment->addExtension(new TableExtension());
$environment->addExtension(new TaskListExtension());
}
}
PK �@]5��a� � 8 src/Extension/TableOfContents/TableOfContentsBuilder.phpnu �[��� <?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\TableOfContents;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\CommonMark\Node\Block\Heading;
use League\CommonMark\Extension\HeadingPermalink\HeadingPermalink;
use League\CommonMark\Extension\TableOfContents\Node\TableOfContents;
use League\CommonMark\Extension\TableOfContents\Node\TableOfContentsPlaceholder;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Node\NodeIterator;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
use League\Config\Exception\InvalidConfigurationException;
final class TableOfContentsBuilder implements ConfigurationAwareInterface
{
public const POSITION_TOP = 'top';
public const POSITION_BEFORE_HEADINGS = 'before-headings';
public const POSITION_PLACEHOLDER = 'placeholder';
/** @psalm-readonly-allow-private-mutation */
private ConfigurationInterface $config;
public function onDocumentParsed(DocumentParsedEvent $event): void
{
$document = $event->getDocument();
$generator = new TableOfContentsGenerator(
(string) $this->config->get('table_of_contents/style'),
(string) $this->config->get('table_of_contents/normalize'),
(int) $this->config->get('table_of_contents/min_heading_level'),
(int) $this->config->get('table_of_contents/max_heading_level'),
(string) $this->config->get('heading_permalink/fragment_prefix'),
);
$toc = $generator->generate($document);
if ($toc === null) {
// No linkable headers exist, so no TOC could be generated
return;
}
// Add custom CSS class(es), if defined
$class = $this->config->get('table_of_contents/html_class');
if ($class !== null) {
$toc->data->append('attributes/class', $class);
}
// Add the TOC to the Document
$position = $this->config->get('table_of_contents/position');
if ($position === self::POSITION_TOP) {
$document->prependChild($toc);
} elseif ($position === self::POSITION_BEFORE_HEADINGS) {
$this->insertBeforeFirstLinkedHeading($document, $toc);
} elseif ($position === self::POSITION_PLACEHOLDER) {
$this->replacePlaceholders($document, $toc);
} else {
throw InvalidConfigurationException::forConfigOption('table_of_contents/position', $position);
}
}
private function insertBeforeFirstLinkedHeading(Document $document, TableOfContents $toc): void
{
foreach ($document->iterator(NodeIterator::FLAG_BLOCKS_ONLY) as $node) {
if (! $node instanceof Heading) {
continue;
}
foreach ($node->children() as $child) {
if ($child instanceof HeadingPermalink) {
$node->insertBefore($toc);
return;
}
}
}
}
private function replacePlaceholders(Document $document, TableOfContents $toc): void
{
foreach ($document->iterator(NodeIterator::FLAG_BLOCKS_ONLY) as $node) {
// Add the block once we find a placeholder
if (! $node instanceof TableOfContentsPlaceholder) {
continue;
}
$node->replaceWith(clone $toc);
}
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
}
PK �@]�_��� � 6 src/Extension/TableOfContents/Node/TableOfContents.phpnu �[��� <?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\TableOfContents\Node;
use League\CommonMark\Extension\CommonMark\Node\Block\ListBlock;
final class TableOfContents extends ListBlock
{
}
PK �@]� � A src/Extension/TableOfContents/Node/TableOfContentsPlaceholder.phpnu �[��� <?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\TableOfContents\Node;
use League\CommonMark\Node\Block\AbstractBlock;
final class TableOfContentsPlaceholder extends AbstractBlock
{
}
PK �@]�8�)� � : src/Extension/TableOfContents/TableOfContentsGenerator.phpnu �[��� <?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\TableOfContents;
use League\CommonMark\Extension\CommonMark\Node\Block\Heading;
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\Extension\CommonMark\Node\Inline\Link;
use League\CommonMark\Extension\HeadingPermalink\HeadingPermalink;
use League\CommonMark\Extension\TableOfContents\Node\TableOfContents;
use League\CommonMark\Extension\TableOfContents\Normalizer\AsIsNormalizerStrategy;
use League\CommonMark\Extension\TableOfContents\Normalizer\FlatNormalizerStrategy;
use League\CommonMark\Extension\TableOfContents\Normalizer\NormalizerStrategyInterface;
use League\CommonMark\Extension\TableOfContents\Normalizer\RelativeNormalizerStrategy;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Node\NodeIterator;
use League\CommonMark\Node\RawMarkupContainerInterface;
use League\CommonMark\Node\StringContainerHelper;
use League\Config\Exception\InvalidConfigurationException;
final class TableOfContentsGenerator implements TableOfContentsGeneratorInterface
{
public const STYLE_BULLET = ListBlock::TYPE_BULLET;
public const STYLE_ORDERED = ListBlock::TYPE_ORDERED;
public const NORMALIZE_DISABLED = 'as-is';
public const NORMALIZE_RELATIVE = 'relative';
public const NORMALIZE_FLAT = 'flat';
/** @psalm-readonly */
private string $style;
/** @psalm-readonly */
private string $normalizationStrategy;
/** @psalm-readonly */
private int $minHeadingLevel;
/** @psalm-readonly */
private int $maxHeadingLevel;
/** @psalm-readonly */
private string $fragmentPrefix;
public function __construct(string $style, string $normalizationStrategy, int $minHeadingLevel, int $maxHeadingLevel, string $fragmentPrefix)
{
$this->style = $style;
$this->normalizationStrategy = $normalizationStrategy;
$this->minHeadingLevel = $minHeadingLevel;
$this->maxHeadingLevel = $maxHeadingLevel;
$this->fragmentPrefix = $fragmentPrefix;
if ($fragmentPrefix !== '') {
$this->fragmentPrefix .= '-';
}
}
public function generate(Document $document): ?TableOfContents
{
$toc = $this->createToc($document);
$normalizer = $this->getNormalizer($toc);
$firstHeading = null;
foreach ($this->getHeadingLinks($document) as $headingLink) {
$heading = $headingLink->parent();
// Make sure this is actually tied to a heading
if (! $heading instanceof Heading) {
continue;
}
// Skip any headings outside the configured min/max levels
if ($heading->getLevel() < $this->minHeadingLevel || $heading->getLevel() > $this->maxHeadingLevel) {
continue;
}
// Keep track of the first heading we see - we might need this later
$firstHeading ??= $heading;
// Keep track of the start and end lines
$toc->setStartLine($firstHeading->getStartLine());
$toc->setEndLine($heading->getEndLine());
// Create the new link
$link = new Link('#' . $this->fragmentPrefix . $headingLink->getSlug(), StringContainerHelper::getChildText($heading, [RawMarkupContainerInterface::class]));
$listItem = new ListItem($toc->getListData());
$listItem->setStartLine($heading->getStartLine());
$listItem->setEndLine($heading->getEndLine());
$listItem->appendChild($link);
// Add it to the correct place
$normalizer->addItem($heading->getLevel(), $listItem);
}
// Don't add the TOC if no headings were present
if (! $toc->hasChildren() || $firstHeading === null) {
return null;
}
return $toc;
}
private function createToc(Document $document): TableOfContents
{
$listData = new ListData();
if ($this->style === self::STYLE_BULLET) {
$listData->type = ListBlock::TYPE_BULLET;
} elseif ($this->style === self::STYLE_ORDERED) {
$listData->type = ListBlock::TYPE_ORDERED;
} else {
throw new InvalidConfigurationException(\sprintf('Invalid table of contents list style: "%s"', $this->style));
}
$toc = new TableOfContents($listData);
$toc->setStartLine($document->getStartLine());
$toc->setEndLine($document->getEndLine());
return $toc;
}
/**
* @return iterable<HeadingPermalink>
*/
private function getHeadingLinks(Document $document): iterable
{
foreach ($document->iterator(NodeIterator::FLAG_BLOCKS_ONLY) as $node) {
if (! $node instanceof Heading) {
continue;
}
foreach ($node->children() as $child) {
if ($child instanceof HeadingPermalink) {
yield $child;
}
}
}
}
private function getNormalizer(TableOfContents $toc): NormalizerStrategyInterface
{
switch ($this->normalizationStrategy) {
case self::NORMALIZE_DISABLED:
return new AsIsNormalizerStrategy($toc);
case self::NORMALIZE_RELATIVE:
return new RelativeNormalizerStrategy($toc);
case self::NORMALIZE_FLAT:
return new FlatNormalizerStrategy($toc);
default:
throw new InvalidConfigurationException(\sprintf('Invalid table of contents normalization strategy: "%s"', $this->normalizationStrategy));
}
}
}
PK �@] �DM. . C src/Extension/TableOfContents/TableOfContentsGeneratorInterface.phpnu �[��� <?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\TableOfContents;
use League\CommonMark\Extension\TableOfContents\Node\TableOfContents;
use League\CommonMark\Node\Block\Document;
interface TableOfContentsGeneratorInterface
{
public function generate(Document $document): ?TableOfContents;
}
PK �@]v��h� � 9 src/Extension/TableOfContents/TableOfContentsRenderer.phpnu �[��� <?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\TableOfContents;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Xml\XmlNodeRendererInterface;
final class TableOfContentsRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/** @var NodeRendererInterface&XmlNodeRendererInterface */
private $innerRenderer;
/**
* @psalm-param NodeRendererInterface&XmlNodeRendererInterface $innerRenderer
*
* @phpstan-param NodeRendererInterface&XmlNodeRendererInterface $innerRenderer
*/
public function __construct(NodeRendererInterface $innerRenderer)
{
$this->innerRenderer = $innerRenderer;
}
/**
* {@inheritDoc}
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer)
{
return $this->innerRenderer->render($node, $childRenderer);
}
public function getXmlTagName(Node $node): string
{
return 'table_of_contents';
}
/**
* @return array<string, scalar>
*/
public function getXmlAttributes(Node $node): array
{
return $this->innerRenderer->getXmlAttributes($node);
}
}
PK �@]�;ۿ D src/Extension/TableOfContents/TableOfContentsPlaceholderRenderer.phpnu �[��� <?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\TableOfContents;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Xml\XmlNodeRendererInterface;
final class TableOfContentsPlaceholderRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
public function render(Node $node, ChildNodeRendererInterface $childRenderer): string
{
return '<!-- table of contents -->';
}
public function getXmlTagName(Node $node): string
{
return 'table_of_contents_placeholder';
}
/**
* @return array<string, scalar>
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@]��[� � B src/Extension/TableOfContents/TableOfContentsPlaceholderParser.phpnu �[��� <?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\TableOfContents;
use League\CommonMark\Extension\TableOfContents\Node\TableOfContentsPlaceholder;
use League\CommonMark\Parser\Block\AbstractBlockContinueParser;
use League\CommonMark\Parser\Block\BlockContinue;
use League\CommonMark\Parser\Block\BlockContinueParserInterface;
use League\CommonMark\Parser\Block\BlockStart;
use League\CommonMark\Parser\Block\BlockStartParserInterface;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Parser\MarkdownParserStateInterface;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class TableOfContentsPlaceholderParser extends AbstractBlockContinueParser
{
/** @psalm-readonly */
private TableOfContentsPlaceholder $block;
public function __construct()
{
$this->block = new TableOfContentsPlaceholder();
}
public function getBlock(): TableOfContentsPlaceholder
{
return $this->block;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
return BlockContinue::none();
}
public static function blockStartParser(): BlockStartParserInterface
{
return new class () implements BlockStartParserInterface, ConfigurationAwareInterface {
/** @psalm-readonly-allow-private-mutation */
private ConfigurationInterface $config;
public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
{
$placeholder = $this->config->get('table_of_contents/placeholder');
if ($placeholder === null) {
return BlockStart::none();
}
// The placeholder must be the only thing on the line
if ($cursor->match('/^' . \preg_quote($placeholder, '/') . '$/') === null) {
return BlockStart::none();
}
return BlockStart::of(new TableOfContentsPlaceholderParser())->at($cursor);
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
};
}
}
PK �@]U�Ti� � G src/Extension/TableOfContents/Normalizer/RelativeNormalizerStrategy.phpnu �[��� <?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\TableOfContents\Normalizer;
use League\CommonMark\Extension\CommonMark\Node\Block\ListBlock;
use League\CommonMark\Extension\CommonMark\Node\Block\ListItem;
use League\CommonMark\Extension\TableOfContents\Node\TableOfContents;
final class RelativeNormalizerStrategy implements NormalizerStrategyInterface
{
/** @psalm-readonly */
private TableOfContents $toc;
/**
* @var array<int, ListItem>
*
* @psalm-readonly-allow-private-mutation
*/
private array $listItemStack = [];
public function __construct(TableOfContents $toc)
{
$this->toc = $toc;
}
public function addItem(int $level, ListItem $listItemToAdd): void
{
$previousLevel = \array_key_last($this->listItemStack);
// Pop the stack if we're too deep
while ($previousLevel !== null && $level < $previousLevel) {
\array_pop($this->listItemStack);
$previousLevel = \array_key_last($this->listItemStack);
}
$lastListItem = \end($this->listItemStack);
// Need to go one level deeper? Add that level
if ($lastListItem !== false && $level > $previousLevel) {
$targetListBlock = new ListBlock($lastListItem->getListData());
$targetListBlock->setStartLine($listItemToAdd->getStartLine());
$targetListBlock->setEndLine($listItemToAdd->getEndLine());
$lastListItem->appendChild($targetListBlock);
// Otherwise we're at the right level
// If there's no stack we're adding this item directly to the TOC element
} elseif ($lastListItem === false) {
$targetListBlock = $this->toc;
// Otherwise add it to the last list item
} else {
$targetListBlock = $lastListItem->parent();
}
$targetListBlock->appendChild($listItemToAdd);
$this->listItemStack[$level] = $listItemToAdd;
}
}
PK �@]SH� H src/Extension/TableOfContents/Normalizer/NormalizerStrategyInterface.phpnu �[��� <?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\TableOfContents\Normalizer;
use League\CommonMark\Extension\CommonMark\Node\Block\ListItem;
interface NormalizerStrategyInterface
{
public function addItem(int $level, ListItem $listItemToAdd): void;
}
PK �@]I���e e C src/Extension/TableOfContents/Normalizer/AsIsNormalizerStrategy.phpnu �[��� <?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\TableOfContents\Normalizer;
use League\CommonMark\Extension\CommonMark\Node\Block\ListBlock;
use League\CommonMark\Extension\CommonMark\Node\Block\ListItem;
use League\CommonMark\Extension\TableOfContents\Node\TableOfContents;
final class AsIsNormalizerStrategy implements NormalizerStrategyInterface
{
/** @psalm-readonly-allow-private-mutation */
private ListBlock $parentListBlock;
/** @psalm-readonly-allow-private-mutation */
private int $parentLevel = 1;
/** @psalm-readonly-allow-private-mutation */
private ?ListItem $lastListItem = null;
public function __construct(TableOfContents $toc)
{
$this->parentListBlock = $toc;
}
public function addItem(int $level, ListItem $listItemToAdd): void
{
while ($level > $this->parentLevel) {
// Descend downwards, creating new ListBlocks if needed, until we reach the correct depth
if ($this->lastListItem === null) {
$this->lastListItem = new ListItem($this->parentListBlock->getListData());
$this->parentListBlock->appendChild($this->lastListItem);
}
$newListBlock = new ListBlock($this->parentListBlock->getListData());
$newListBlock->setStartLine($listItemToAdd->getStartLine());
$newListBlock->setEndLine($listItemToAdd->getEndLine());
$this->lastListItem->appendChild($newListBlock);
$this->parentListBlock = $newListBlock;
$this->lastListItem = null;
$this->parentLevel++;
}
while ($level < $this->parentLevel) {
// Search upwards for the previous parent list block
$search = $this->parentListBlock;
while ($search = $search->parent()) {
if ($search instanceof ListBlock) {
$this->parentListBlock = $search;
break;
}
}
$this->parentLevel--;
}
$this->parentListBlock->appendChild($listItemToAdd);
$this->lastListItem = $listItemToAdd;
}
}
PK �@] @H H C src/Extension/TableOfContents/Normalizer/FlatNormalizerStrategy.phpnu �[��� <?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\TableOfContents\Normalizer;
use League\CommonMark\Extension\CommonMark\Node\Block\ListItem;
use League\CommonMark\Extension\TableOfContents\Node\TableOfContents;
final class FlatNormalizerStrategy implements NormalizerStrategyInterface
{
/** @psalm-readonly */
private TableOfContents $toc;
public function __construct(TableOfContents $toc)
{
$this->toc = $toc;
}
public function addItem(int $level, ListItem $listItemToAdd): void
{
$this->toc->appendChild($listItemToAdd);
}
}
PK �@]��{z z : src/Extension/TableOfContents/TableOfContentsExtension.phpnu �[��� <?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\TableOfContents;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\CommonMark\Node\Block\ListBlock;
use League\CommonMark\Extension\CommonMark\Renderer\Block\ListBlockRenderer;
use League\CommonMark\Extension\ConfigurableExtensionInterface;
use League\CommonMark\Extension\TableOfContents\Node\TableOfContents;
use League\CommonMark\Extension\TableOfContents\Node\TableOfContentsPlaceholder;
use League\Config\ConfigurationBuilderInterface;
use Nette\Schema\Expect;
final class TableOfContentsExtension implements ConfigurableExtensionInterface
{
public function configureSchema(ConfigurationBuilderInterface $builder): void
{
$builder->addSchema('table_of_contents', Expect::structure([
'position' => Expect::anyOf(TableOfContentsBuilder::POSITION_BEFORE_HEADINGS, TableOfContentsBuilder::POSITION_PLACEHOLDER, TableOfContentsBuilder::POSITION_TOP)->default(TableOfContentsBuilder::POSITION_TOP),
'style' => Expect::anyOf(ListBlock::TYPE_BULLET, ListBlock::TYPE_ORDERED)->default(ListBlock::TYPE_BULLET),
'normalize' => Expect::anyOf(TableOfContentsGenerator::NORMALIZE_RELATIVE, TableOfContentsGenerator::NORMALIZE_FLAT, TableOfContentsGenerator::NORMALIZE_DISABLED)->default(TableOfContentsGenerator::NORMALIZE_RELATIVE),
'min_heading_level' => Expect::int()->min(1)->max(6)->default(1),
'max_heading_level' => Expect::int()->min(1)->max(6)->default(6),
'html_class' => Expect::string()->default('table-of-contents'),
'placeholder' => Expect::anyOf(Expect::string(), Expect::null())->default(null),
]));
}
public function register(EnvironmentBuilderInterface $environment): void
{
$environment->addRenderer(TableOfContents::class, new TableOfContentsRenderer(new ListBlockRenderer()));
$environment->addEventListener(DocumentParsedEvent::class, [new TableOfContentsBuilder(), 'onDocumentParsed'], -150);
// phpcs:ignore SlevomatCodingStandard.ControlStructures.EarlyExit.EarlyExitNotUsed
if ($environment->getConfiguration()->get('table_of_contents/position') === TableOfContentsBuilder::POSITION_PLACEHOLDER) {
$environment->addBlockStartParser(TableOfContentsPlaceholderParser::blockStartParser(), 200);
// If a placeholder cannot be replaced with a TOC element this renderer will ensure the parser won't error out
$environment->addRenderer(TableOfContentsPlaceholder::class, new TableOfContentsPlaceholderRenderer());
}
}
}
PK �@]t�~�� � 2 src/Extension/InlinesOnly/InlinesOnlyExtension.phpnu �[��� <?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\InlinesOnly;
use League\CommonMark as Core;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Extension\CommonMark;
use League\CommonMark\Extension\CommonMark\Delimiter\Processor\EmphasisDelimiterProcessor;
use League\CommonMark\Extension\ConfigurableExtensionInterface;
use League\Config\ConfigurationBuilderInterface;
use Nette\Schema\Expect;
final class InlinesOnlyExtension implements ConfigurableExtensionInterface
{
public function configureSchema(ConfigurationBuilderInterface $builder): void
{
$builder->addSchema('commonmark', Expect::structure([
'use_asterisk' => Expect::bool(true),
'use_underscore' => Expect::bool(true),
'enable_strong' => Expect::bool(true),
'enable_em' => Expect::bool(true),
]));
}
// phpcs:disable Generic.Functions.FunctionCallArgumentSpacing.TooMuchSpaceAfterComma,Squiz.WhiteSpace.SemicolonSpacing.Incorrect
public function register(EnvironmentBuilderInterface $environment): void
{
$childRenderer = new ChildRenderer();
$environment
->addInlineParser(new Core\Parser\Inline\NewlineParser(), 200)
->addInlineParser(new CommonMark\Parser\Inline\BacktickParser(), 150)
->addInlineParser(new CommonMark\Parser\Inline\EscapableParser(), 80)
->addInlineParser(new CommonMark\Parser\Inline\EntityParser(), 70)
->addInlineParser(new CommonMark\Parser\Inline\AutolinkParser(), 50)
->addInlineParser(new CommonMark\Parser\Inline\HtmlInlineParser(), 40)
->addInlineParser(new CommonMark\Parser\Inline\CloseBracketParser(), 30)
->addInlineParser(new CommonMark\Parser\Inline\OpenBracketParser(), 20)
->addInlineParser(new CommonMark\Parser\Inline\BangParser(), 10)
->addRenderer(Core\Node\Block\Document::class, $childRenderer, 0)
->addRenderer(Core\Node\Block\Paragraph::class, $childRenderer, 0)
->addRenderer(CommonMark\Node\Inline\Code::class, new CommonMark\Renderer\Inline\CodeRenderer(), 0)
->addRenderer(CommonMark\Node\Inline\Emphasis::class, new CommonMark\Renderer\Inline\EmphasisRenderer(), 0)
->addRenderer(CommonMark\Node\Inline\HtmlInline::class, new CommonMark\Renderer\Inline\HtmlInlineRenderer(), 0)
->addRenderer(CommonMark\Node\Inline\Image::class, new CommonMark\Renderer\Inline\ImageRenderer(), 0)
->addRenderer(CommonMark\Node\Inline\Link::class, new CommonMark\Renderer\Inline\LinkRenderer(), 0)
->addRenderer(Core\Node\Inline\Newline::class, new Core\Renderer\Inline\NewlineRenderer(), 0)
->addRenderer(CommonMark\Node\Inline\Strong::class, new CommonMark\Renderer\Inline\StrongRenderer(), 0)
->addRenderer(Core\Node\Inline\Text::class, new Core\Renderer\Inline\TextRenderer(), 0)
;
if ($environment->getConfiguration()->get('commonmark/use_asterisk')) {
$environment->addDelimiterProcessor(new EmphasisDelimiterProcessor('*'));
}
if ($environment->getConfiguration()->get('commonmark/use_underscore')) {
$environment->addDelimiterProcessor(new EmphasisDelimiterProcessor('_'));
}
}
}
PK �@]�1'� � + src/Extension/InlinesOnly/ChildRenderer.phpnu �[��� <?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\InlinesOnly;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
/**
* Simply renders child elements as-is, adding newlines as needed.
*/
final class ChildRenderer implements NodeRendererInterface
{
public function render(Node $node, ChildNodeRendererInterface $childRenderer): string
{
$out = $childRenderer->renderNodes($node->children());
if (! $node instanceof Document) {
$out .= $childRenderer->getBlockSeparator();
}
return $out;
}
}
PK �@]��� � @ src/Extension/FrontMatter/Input/MarkdownInputWithFrontMatter.phpnu �[��� <?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\Extension\FrontMatter\Input;
use League\CommonMark\Extension\FrontMatter\FrontMatterProviderInterface;
use League\CommonMark\Input\MarkdownInput;
final class MarkdownInputWithFrontMatter extends MarkdownInput implements FrontMatterProviderInterface
{
/** @var mixed|null */
private $frontMatter;
/**
* @param string $content Markdown content without the raw front matter
* @param int $lineOffset Line offset (based on number of front matter lines removed)
* @param mixed|null $frontMatter Parsed front matter
*/
public function __construct(string $content, int $lineOffset = 0, $frontMatter = null)
{
parent::__construct($content, $lineOffset);
$this->frontMatter = $frontMatter;
}
/**
* {@inheritDoc}
*/
public function getFrontMatter()
{
return $this->frontMatter;
}
}
PK �@]�d�s� � D src/Extension/FrontMatter/Listener/FrontMatterPostRenderListener.phpnu �[��� <?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\Extension\FrontMatter\Listener;
use League\CommonMark\Event\DocumentRenderedEvent;
use League\CommonMark\Extension\FrontMatter\Output\RenderedContentWithFrontMatter;
final class FrontMatterPostRenderListener
{
public function __invoke(DocumentRenderedEvent $event): void
{
if ($event->getOutput()->getDocument()->data->get('front_matter', null) === null) {
return;
}
$frontMatter = $event->getOutput()->getDocument()->data->get('front_matter');
$event->replaceOutput(new RenderedContentWithFrontMatter(
$event->getOutput()->getDocument(),
$event->getOutput()->getContent(),
$frontMatter
));
}
}
PK �@]6��E� � ; src/Extension/FrontMatter/Listener/FrontMatterPreParser.phpnu �[��� <?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\Extension\FrontMatter\Listener;
use League\CommonMark\Event\DocumentPreParsedEvent;
use League\CommonMark\Extension\FrontMatter\FrontMatterParserInterface;
final class FrontMatterPreParser
{
private FrontMatterParserInterface $parser;
public function __construct(FrontMatterParserInterface $parser)
{
$this->parser = $parser;
}
public function __invoke(DocumentPreParsedEvent $event): void
{
$content = $event->getMarkdown()->getContent();
$parsed = $this->parser->parse($content);
$event->getDocument()->data->set('front_matter', $parsed->getFrontMatter());
$event->replaceMarkdown($parsed);
}
}
PK �@]�cֿ � : src/Extension/FrontMatter/FrontMatterProviderInterface.phpnu �[��� <?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\Extension\FrontMatter;
interface FrontMatterProviderInterface
{
/**
* @return mixed|null
*/
public function getFrontMatter();
}
PK �@]NY �� � C src/Extension/FrontMatter/Output/RenderedContentWithFrontMatter.phpnu �[��� <?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\Extension\FrontMatter\Output;
use League\CommonMark\Extension\FrontMatter\FrontMatterProviderInterface;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Output\RenderedContent;
/**
* @psalm-immutable
*/
final class RenderedContentWithFrontMatter extends RenderedContent implements FrontMatterProviderInterface
{
/**
* @var mixed
*
* @psalm-readonly
*/
private $frontMatter;
/**
* @param Document $document The parsed Document object
* @param string $content The final HTML
* @param mixed|null $frontMatter Any parsed front matter
*/
public function __construct(Document $document, string $content, $frontMatter)
{
parent::__construct($document, $content);
$this->frontMatter = $frontMatter;
}
/**
* {@inheritDoc}
*/
public function getFrontMatter()
{
return $this->frontMatter;
}
}
PK �@]�Oj� � 2 src/Extension/FrontMatter/FrontMatterExtension.phpnu �[��� <?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\FrontMatter;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Event\DocumentPreParsedEvent;
use League\CommonMark\Event\DocumentRenderedEvent;
use League\CommonMark\Extension\ExtensionInterface;
use League\CommonMark\Extension\FrontMatter\Data\FrontMatterDataParserInterface;
use League\CommonMark\Extension\FrontMatter\Data\LibYamlFrontMatterParser;
use League\CommonMark\Extension\FrontMatter\Data\SymfonyYamlFrontMatterParser;
use League\CommonMark\Extension\FrontMatter\Listener\FrontMatterPostRenderListener;
use League\CommonMark\Extension\FrontMatter\Listener\FrontMatterPreParser;
final class FrontMatterExtension implements ExtensionInterface
{
/** @psalm-readonly */
private FrontMatterParserInterface $frontMatterParser;
public function __construct(?FrontMatterDataParserInterface $dataParser = null)
{
$this->frontMatterParser = new FrontMatterParser($dataParser ?? LibYamlFrontMatterParser::capable() ?? new SymfonyYamlFrontMatterParser());
}
public function getFrontMatterParser(): FrontMatterParserInterface
{
return $this->frontMatterParser;
}
public function register(EnvironmentBuilderInterface $environment): void
{
$environment->addEventListener(DocumentPreParsedEvent::class, new FrontMatterPreParser($this->frontMatterParser));
$environment->addEventListener(DocumentRenderedEvent::class, new FrontMatterPostRenderListener(), -500);
}
}
PK �@]R)n 8 src/Extension/FrontMatter/FrontMatterParserInterface.phpnu �[��� <?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\Extension\FrontMatter;
use League\CommonMark\Extension\FrontMatter\Input\MarkdownInputWithFrontMatter;
interface FrontMatterParserInterface
{
public function parse(string $markdownContent): MarkdownInputWithFrontMatter;
}
PK �@]5$ � � C src/Extension/FrontMatter/Exception/InvalidFrontMatterException.phpnu �[��� <?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\Extension\FrontMatter\Exception;
use League\CommonMark\Exception\CommonMarkException;
class InvalidFrontMatterException extends \RuntimeException implements CommonMarkException
{
public static function wrap(\Throwable $t): self
{
return new InvalidFrontMatterException('Failed to parse front matter: ' . $t->getMessage(), 0, $t);
}
}
PK �@]�iҍ' ' / src/Extension/FrontMatter/FrontMatterParser.phpnu �[��� <?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\FrontMatter;
use League\CommonMark\Extension\FrontMatter\Data\FrontMatterDataParserInterface;
use League\CommonMark\Extension\FrontMatter\Exception\InvalidFrontMatterException;
use League\CommonMark\Extension\FrontMatter\Input\MarkdownInputWithFrontMatter;
use League\CommonMark\Parser\Cursor;
final class FrontMatterParser implements FrontMatterParserInterface
{
/** @psalm-readonly */
private FrontMatterDataParserInterface $frontMatterParser;
private const REGEX_FRONT_MATTER = '/^---\\R.*?\\R---\\R/s';
public function __construct(FrontMatterDataParserInterface $frontMatterParser)
{
$this->frontMatterParser = $frontMatterParser;
}
/**
* @throws InvalidFrontMatterException if the front matter cannot be parsed
*/
public function parse(string $markdownContent): MarkdownInputWithFrontMatter
{
$cursor = new Cursor($markdownContent);
// Locate the front matter
$frontMatter = $cursor->match(self::REGEX_FRONT_MATTER);
if ($frontMatter === null) {
return new MarkdownInputWithFrontMatter($markdownContent);
}
// Trim the last line (ending ---s and newline)
$frontMatter = \preg_replace('/---\R$/', '', $frontMatter);
if ($frontMatter === null) {
return new MarkdownInputWithFrontMatter($markdownContent);
}
// Parse the resulting YAML data
$data = $this->frontMatterParser->parse($frontMatter);
// Advance through any remaining newlines which separated the front matter from the Markdown text
$trailingNewlines = $cursor->match('/^\R+/');
// Calculate how many lines the Markdown is offset from the front matter by counting the number of newlines
// Don't forget to add 1 because we stripped one out when trimming the trailing delims
$lineOffset = \preg_match_all('/\R/', $frontMatter . $trailingNewlines) + 1;
return new MarkdownInputWithFrontMatter($cursor->getRemainder(), $lineOffset, $data);
}
}
PK �@]j�@� � ; src/Extension/FrontMatter/Data/LibYamlFrontMatterParser.phpnu �[��� <?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\FrontMatter\Data;
use League\CommonMark\Exception\MissingDependencyException;
use League\CommonMark\Extension\FrontMatter\Exception\InvalidFrontMatterException;
final class LibYamlFrontMatterParser implements FrontMatterDataParserInterface
{
public static function capable(): ?LibYamlFrontMatterParser
{
if (! \extension_loaded('yaml')) {
return null;
}
return new LibYamlFrontMatterParser();
}
/**
* {@inheritDoc}
*/
public function parse(string $frontMatter)
{
if (! \extension_loaded('yaml')) {
throw new MissingDependencyException('Failed to parse yaml: "ext-yaml" extension is missing');
}
$result = @\yaml_parse($frontMatter);
if ($result === false) {
throw new InvalidFrontMatterException('Failed to parse front matter');
}
return $result;
}
}
PK �@]��a a ? src/Extension/FrontMatter/Data/SymfonyYamlFrontMatterParser.phpnu �[��� <?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\FrontMatter\Data;
use League\CommonMark\Exception\MissingDependencyException;
use League\CommonMark\Extension\FrontMatter\Exception\InvalidFrontMatterException;
use Symfony\Component\Yaml\Exception\ParseException;
use Symfony\Component\Yaml\Yaml;
final class SymfonyYamlFrontMatterParser implements FrontMatterDataParserInterface
{
/**
* {@inheritDoc}
*/
public function parse(string $frontMatter)
{
if (! \class_exists(Yaml::class)) {
throw new MissingDependencyException('Failed to parse yaml: "symfony/yaml" library is missing');
}
try {
/** @psalm-suppress ReservedWord */
return Yaml::parse($frontMatter);
} catch (ParseException $ex) {
throw InvalidFrontMatterException::wrap($ex);
}
}
}
PK �@]C���� � A src/Extension/FrontMatter/Data/FrontMatterDataParserInterface.phpnu �[��� <?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\FrontMatter\Data;
use League\CommonMark\Extension\FrontMatter\Exception\InvalidFrontMatterException;
interface FrontMatterDataParserInterface
{
/**
* @return mixed|null The parsed data (which may be null, if the input represents a null value)
*
* @throws InvalidFrontMatterException if parsing fails
*/
public function parse(string $frontMatter);
}
PK �@]�2n�� � ( src/Extension/Table/TableRowRenderer.phpnu �[��� <?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\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlElement;
use League\CommonMark\Xml\XmlNodeRendererInterface;
final class TableRowRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param TableRow $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
TableRow::assertInstanceOf($node);
$attrs = $node->data->get('attributes');
$separator = $childRenderer->getInnerSeparator();
return new HtmlElement('tr', $attrs, $separator . $childRenderer->renderNodes($node->children()) . $separator);
}
public function getXmlTagName(Node $node): string
{
return 'table_row';
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@] �P�8 8 # src/Extension/Table/TableParser.phpnu �[��� <?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
{
/** @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;
/**
* @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)
{
$this->block = new Table();
$this->bodyLines = new ArrayCollection();
$this->columns = $columns;
$this->headerCells = $headerCells;
}
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++) {
$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();
if ($column < \count($this->columns)) {
$tableCell->setAlign($this->columns[$column]);
}
$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;
}
}
PK �@]�Y� � src/Extension/Table/Table.phpnu �[��� <?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\Node\Block\AbstractBlock;
final class Table extends AbstractBlock
{
}
PK �@]�2�� � src/Extension/Table/TableRow.phpnu �[��� <?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\Node\Block\AbstractBlock;
final class TableRow extends AbstractBlock
{
}
PK �@]��� � & src/Extension/Table/TableExtension.phpnu �[��� <?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']),
]),
]));
}
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())
->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')));
}
}
PK �@]_ �%� � ! src/Extension/Table/TableCell.phpnu �[��� <?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\Node\Block\AbstractBlock;
final class TableCell extends AbstractBlock
{
public const TYPE_HEADER = 'header';
public const TYPE_DATA = 'data';
public const ALIGN_LEFT = 'left';
public const ALIGN_RIGHT = 'right';
public const ALIGN_CENTER = 'center';
/**
* @psalm-var self::TYPE_*
* @phpstan-var self::TYPE_*
*
* @psalm-readonly-allow-private-mutation
*/
private string $type = self::TYPE_DATA;
/**
* @psalm-var self::ALIGN_*|null
* @phpstan-var self::ALIGN_*|null
*
* @psalm-readonly-allow-private-mutation
*/
private ?string $align = null;
/**
* @psalm-param self::TYPE_* $type
* @psalm-param self::ALIGN_*|null $align
*
* @phpstan-param self::TYPE_* $type
* @phpstan-param self::ALIGN_*|null $align
*/
public function __construct(string $type = self::TYPE_DATA, ?string $align = null)
{
parent::__construct();
$this->type = $type;
$this->align = $align;
}
/**
* @psalm-return self::TYPE_*
*
* @phpstan-return self::TYPE_*
*/
public function getType(): string
{
return $this->type;
}
/**
* @psalm-param self::TYPE_* $type
*
* @phpstan-param self::TYPE_* $type
*/
public function setType(string $type): void
{
$this->type = $type;
}
/**
* @psalm-return self::ALIGN_*|null
*
* @phpstan-return self::ALIGN_*|null
*/
public function getAlign(): ?string
{
return $this->align;
}
/**
* @psalm-param self::ALIGN_*|null $align
*
* @phpstan-param self::ALIGN_*|null $align
*/
public function setAlign(?string $align): void
{
$this->align = $align;
}
}
PK �@]�k߫� � % src/Extension/Table/TableRenderer.phpnu �[��� <?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\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlElement;
use League\CommonMark\Xml\XmlNodeRendererInterface;
final class TableRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param Table $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
Table::assertInstanceOf($node);
$attrs = $node->data->get('attributes');
$separator = $childRenderer->getInnerSeparator();
$children = $childRenderer->renderNodes($node->children());
return new HtmlElement('table', $attrs, $separator . \trim($children) . $separator);
}
public function getXmlTagName(Node $node): string
{
return 'table';
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@]_I��� � ( src/Extension/Table/TableStartParser.phpnu �[��� <?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
{
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();
}
$lines = \explode("\n", $paragraph);
$lastLine = \array_pop($lines);
$headerCells = TableParser::split($lastLine);
if (\count($headerCells) > \count($columns)) {
return BlockStart::none();
}
$cursor->advanceToEnd();
$parsers = [];
if (\count($lines) > 0) {
$p = new ParagraphParser();
$p->addLine(\implode("\n", $lines));
$parsers[] = $p;
}
$parsers[] = new TableParser($columns, $headerCells);
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;
}
}
PK �@]�A�9
9
) src/Extension/Table/TableCellRenderer.phpnu �[��� <?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\Extension\Attributes\Util\AttributesHelper;
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 TableCellRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
private const DEFAULT_ATTRIBUTES = [
TableCell::ALIGN_LEFT => ['align' => 'left'],
TableCell::ALIGN_CENTER => ['align' => 'center'],
TableCell::ALIGN_RIGHT => ['align' => 'right'],
];
/** @var array<TableCell::ALIGN_*, array<string, string|string[]|bool>> */
private array $alignmentAttributes;
/**
* @param array<TableCell::ALIGN_*, array<string, string|string[]|bool>> $alignmentAttributes
*/
public function __construct(array $alignmentAttributes = self::DEFAULT_ATTRIBUTES)
{
$this->alignmentAttributes = $alignmentAttributes;
}
/**
* @param TableCell $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
TableCell::assertInstanceOf($node);
$attrs = $node->data->get('attributes');
if (($alignment = $node->getAlign()) !== null) {
$attrs = AttributesHelper::mergeAttributes($attrs, $this->alignmentAttributes[$alignment]);
}
$tag = $node->getType() === TableCell::TYPE_HEADER ? 'th' : 'td';
return new HtmlElement($tag, $attrs, $childRenderer->renderNodes($node->children()));
}
public function getXmlTagName(Node $node): string
{
return 'table_cell';
}
/**
* @param TableCell $node
*
* @return array<string, scalar>
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlAttributes(Node $node): array
{
TableCell::assertInstanceOf($node);
$ret = ['type' => $node->getType()];
if (($align = $node->getAlign()) !== null) {
$ret['align'] = $align;
}
return $ret;
}
}
PK �@]� �- - , src/Extension/Table/TableSectionRenderer.phpnu �[��� <?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\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlElement;
use League\CommonMark\Xml\XmlNodeRendererInterface;
final class TableSectionRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param TableSection $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer)
{
TableSection::assertInstanceOf($node);
if (! $node->hasChildren()) {
return '';
}
$attrs = $node->data->get('attributes');
$separator = $childRenderer->getInnerSeparator();
$tag = $node->getType() === TableSection::TYPE_HEAD ? 'thead' : 'tbody';
return new HtmlElement($tag, $attrs, $separator . $childRenderer->renderNodes($node->children()) . $separator);
}
public function getXmlTagName(Node $node): string
{
return 'table_section';
}
/**
* @param TableSection $node
*
* @return array<string, scalar>
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlAttributes(Node $node): array
{
TableSection::assertInstanceOf($node);
return [
'type' => $node->getType(),
];
}
}
PK �@]��+j! ! $ src/Extension/Table/TableSection.phpnu �[��� <?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\Node\Block\AbstractBlock;
final class TableSection extends AbstractBlock
{
public const TYPE_HEAD = 'head';
public const TYPE_BODY = 'body';
/**
* @psalm-var self::TYPE_*
* @phpstan-var self::TYPE_*
*
* @psalm-readonly
*/
private string $type;
/**
* @psalm-param self::TYPE_* $type
*
* @phpstan-param self::TYPE_* $type
*/
public function __construct(string $type = self::TYPE_BODY)
{
parent::__construct();
$this->type = $type;
}
/**
* @psalm-return self::TYPE_*
*
* @phpstan-return self::TYPE_*
*/
public function getType(): string
{
return $this->type;
}
public function isHead(): bool
{
return $this->type === self::TYPE_HEAD;
}
public function isBody(): bool
{
return $this->type === self::TYPE_BODY;
}
}
PK �@]0֝�T T - src/Extension/CommonMark/Node/Inline/Link.phpnu �[��� <?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\Inline;
use League\CommonMark\Node\Inline\Text;
class Link extends AbstractWebResource
{
protected ?string $title = null;
public function __construct(string $url, ?string $label = null, ?string $title = null)
{
parent::__construct($url);
if ($label !== null && $label !== '') {
$this->appendChild(new Text($label));
}
$this->title = $title;
}
public function getTitle(): ?string
{
if ($this->title === '') {
return null;
}
return $this->title;
}
public function setTitle(?string $title): void
{
$this->title = $title;
}
}
PK �@]P�2U U . src/Extension/CommonMark/Node/Inline/Image.phpnu �[��� <?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\Inline;
use League\CommonMark\Node\Inline\Text;
class Image extends AbstractWebResource
{
protected ?string $title = null;
public function __construct(string $url, ?string $label = null, ?string $title = null)
{
parent::__construct($url);
if ($label !== null && $label !== '') {
$this->appendChild(new Text($label));
}
$this->title = $title;
}
public function getTitle(): ?string
{
if ($this->title === '') {
return null;
}
return $this->title;
}
public function setTitle(?string $title): void
{
$this->title = $title;
}
}
PK �@] <̋� � 1 src/Extension/CommonMark/Node/Inline/Emphasis.phpnu �[��� <?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\Inline;
use League\CommonMark\Node\Inline\AbstractInline;
use League\CommonMark\Node\Inline\DelimitedInterface;
final class Emphasis extends AbstractInline implements DelimitedInterface
{
private string $delimiter;
public function __construct(string $delimiter = '_')
{
parent::__construct();
$this->delimiter = $delimiter;
}
public function getOpeningDelimiter(): string
{
return $this->delimiter;
}
public function getClosingDelimiter(): string
{
return $this->delimiter;
}
}
PK �@]��h�6 6 - src/Extension/CommonMark/Node/Inline/Code.phpnu �[��� <?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\Inline;
use League\CommonMark\Node\Inline\AbstractStringContainer;
class Code extends AbstractStringContainer
{
}
PK �@]�x�� � 3 src/Extension/CommonMark/Node/Inline/HtmlInline.phpnu �[��� <?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\Inline;
use League\CommonMark\Node\Inline\AbstractStringContainer;
use League\CommonMark\Node\RawMarkupContainerInterface;
final class HtmlInline extends AbstractStringContainer implements RawMarkupContainerInterface
{
}
PK �@]놘�o o < src/Extension/CommonMark/Node/Inline/AbstractWebResource.phpnu �[��� <?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\Inline;
use League\CommonMark\Node\Inline\AbstractInline;
abstract class AbstractWebResource extends AbstractInline
{
protected string $url;
public function __construct(string $url)
{
parent::__construct();
$this->url = $url;
}
public function getUrl(): string
{
return $this->url;
}
public function setUrl(string $url): void
{
$this->url = $url;
}
}
PK �@]��� � / src/Extension/CommonMark/Node/Inline/Strong.phpnu �[��� <?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\Inline;
use League\CommonMark\Node\Inline\AbstractInline;
use League\CommonMark\Node\Inline\DelimitedInterface;
final class Strong extends AbstractInline implements DelimitedInterface
{
private string $delimiter;
public function __construct(string $delimiter = '**')
{
parent::__construct();
$this->delimiter = $delimiter;
}
public function getOpeningDelimiter(): string
{
return $this->delimiter;
}
public function getClosingDelimiter(): string
{
return $this->delimiter;
}
}
PK �@]�5�i@ @ 0 src/Extension/CommonMark/Node/Block/ListItem.phpnu �[��� <?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;
class ListItem extends AbstractBlock
{
/** @psalm-readonly */
protected ListData $listData;
public function __construct(ListData $listData)
{
parent::__construct();
$this->listData = $listData;
}
public function getListData(): ListData
{
return $this->listData;
}
}
PK �@]�`I�� � 2 src/Extension/CommonMark/Node/Block/BlockQuote.phpnu �[��� <?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\Node\Block;
use League\CommonMark\Node\Block\AbstractBlock;
class BlockQuote extends AbstractBlock
{
}
PK �@]щ8� 1 src/Extension/CommonMark/Node/Block/ListBlock.phpnu �[��� <?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;
/** @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;
}
}
PK �@] t>Pb b / src/Extension/CommonMark/Node/Block/Heading.phpnu �[��� <?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;
final class Heading extends AbstractBlock
{
private int $level;
public function __construct(int $level)
{
parent::__construct();
$this->level = $level;
}
public function getLevel(): int
{
return $this->level;
}
public function setLevel(int $level): void
{
$this->level = $level;
}
}
PK �@]�>l>� � 2 src/Extension/CommonMark/Node/Block/FencedCode.phpnu �[��� <?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\StringContainerInterface;
final class FencedCode extends AbstractBlock implements StringContainerInterface
{
private ?string $info = null;
private string $literal = '';
private int $length;
private string $char;
private int $offset;
public function __construct(int $length, string $char, int $offset)
{
parent::__construct();
$this->length = $length;
$this->char = $char;
$this->offset = $offset;
}
public function getInfo(): ?string
{
return $this->info;
}
/**
* @return string[]
*/
public function getInfoWords(): array
{
return \preg_split('/\s+/', $this->info ?? '') ?: [];
}
public function setInfo(string $info): void
{
$this->info = $info;
}
public function getLiteral(): string
{
return $this->literal;
}
public function setLiteral(string $literal): void
{
$this->literal = $literal;
}
public function getChar(): string
{
return $this->char;
}
public function setChar(string $char): void
{
$this->char = $char;
}
public function getLength(): int
{
return $this->length;
}
public function setLength(int $length): void
{
$this->length = $length;
}
public function getOffset(): int
{
return $this->offset;
}
public function setOffset(int $offset): void
{
$this->offset = $offset;
}
}
PK �@]��_�8 8 0 src/Extension/CommonMark/Node/Block/ListData.phpnu �[��� <?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;
class ListData
{
public ?int $start = null;
public int $padding = 0;
/**
* @psalm-var ListBlock::TYPE_*
* @phpstan-var ListBlock::TYPE_*
*/
public string $type;
/**
* @psalm-var ListBlock::DELIM_*|null
* @phpstan-var ListBlock::DELIM_*|null
*/
public ?string $delimiter = null;
public ?string $bulletChar = null;
public int $markerOffset;
public function equals(ListData $data): bool
{
return $this->type === $data->type &&
$this->delimiter === $data->delimiter &&
$this->bulletChar === $data->bulletChar;
}
}
PK �@]��>�� � 5 src/Extension/CommonMark/Node/Block/ThematicBreak.phpnu �[��� <?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\Node\Block;
use League\CommonMark\Node\Block\AbstractBlock;
class ThematicBreak extends AbstractBlock
{
}
PK �@]�[�� � 4 src/Extension/CommonMark/Node/Block/IndentedCode.phpnu �[��� <?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\Node\Block;
use League\CommonMark\Node\Block\AbstractBlock;
use League\CommonMark\Node\StringContainerInterface;
final class IndentedCode extends AbstractBlock implements StringContainerInterface
{
private string $literal = '';
public function getLiteral(): string
{
return $this->literal;
}
public function setLiteral(string $literal): void
{
$this->literal = $literal;
}
}
PK �@]��0' ' 1 src/Extension/CommonMark/Node/Block/HtmlBlock.phpnu �[��� <?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\Node\Block;
use League\CommonMark\Node\Block\AbstractBlock;
use League\CommonMark\Node\RawMarkupContainerInterface;
final class HtmlBlock extends AbstractBlock implements RawMarkupContainerInterface
{
// Any changes to these constants should be reflected in .phpstorm.meta.php
public const TYPE_1_CODE_CONTAINER = 1;
public const TYPE_2_COMMENT = 2;
public const TYPE_3 = 3;
public const TYPE_4 = 4;
public const TYPE_5_CDATA = 5;
public const TYPE_6_BLOCK_ELEMENT = 6;
public const TYPE_7_MISC_ELEMENT = 7;
/**
* @psalm-var self::TYPE_* $type
* @phpstan-var self::TYPE_* $type
*/
private int $type;
private string $literal = '';
/**
* @psalm-param self::TYPE_* $type
*
* @phpstan-param self::TYPE_* $type
*/
public function __construct(int $type)
{
parent::__construct();
$this->type = $type;
}
/**
* @psalm-return self::TYPE_*
*
* @phpstan-return self::TYPE_*
*/
public function getType(): int
{
return $this->type;
}
/**
* @psalm-param self::TYPE_* $type
*
* @phpstan-param self::TYPE_* $type
*/
public function setType(int $type): void
{
$this->type = $type;
}
public function getLiteral(): string
{
return $this->literal;
}
public function setLiteral(string $literal): void
{
$this->literal = $literal;
}
}
PK �@]h�{U U 4 src/Extension/CommonMark/CommonMarkCoreExtension.phpnu �[��� <?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;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Extension\CommonMark\Delimiter\Processor\EmphasisDelimiterProcessor;
use League\CommonMark\Extension\ConfigurableExtensionInterface;
use League\CommonMark\Node as CoreNode;
use League\CommonMark\Parser as CoreParser;
use League\CommonMark\Renderer as CoreRenderer;
use League\Config\ConfigurationBuilderInterface;
use Nette\Schema\Expect;
final class CommonMarkCoreExtension implements ConfigurableExtensionInterface
{
public function configureSchema(ConfigurationBuilderInterface $builder): void
{
$builder->addSchema('commonmark', Expect::structure([
'use_asterisk' => Expect::bool(true),
'use_underscore' => Expect::bool(true),
'enable_strong' => Expect::bool(true),
'enable_em' => Expect::bool(true),
'unordered_list_markers' => Expect::listOf('string')->min(1)->default(['*', '+', '-'])->mergeDefaults(false),
]));
}
// phpcs:disable Generic.Functions.FunctionCallArgumentSpacing.TooMuchSpaceAfterComma,Squiz.WhiteSpace.SemicolonSpacing.Incorrect
public function register(EnvironmentBuilderInterface $environment): void
{
$environment
->addBlockStartParser(new Parser\Block\BlockQuoteStartParser(), 70)
->addBlockStartParser(new Parser\Block\HeadingStartParser(), 60)
->addBlockStartParser(new Parser\Block\FencedCodeStartParser(), 50)
->addBlockStartParser(new Parser\Block\HtmlBlockStartParser(), 40)
->addBlockStartParser(new Parser\Block\ThematicBreakStartParser(), 20)
->addBlockStartParser(new Parser\Block\ListBlockStartParser(), 10)
->addBlockStartParser(new Parser\Block\IndentedCodeStartParser(), -100)
->addInlineParser(new CoreParser\Inline\NewlineParser(), 200)
->addInlineParser(new Parser\Inline\BacktickParser(), 150)
->addInlineParser(new Parser\Inline\EscapableParser(), 80)
->addInlineParser(new Parser\Inline\EntityParser(), 70)
->addInlineParser(new Parser\Inline\AutolinkParser(), 50)
->addInlineParser(new Parser\Inline\HtmlInlineParser(), 40)
->addInlineParser(new Parser\Inline\CloseBracketParser(), 30)
->addInlineParser(new Parser\Inline\OpenBracketParser(), 20)
->addInlineParser(new Parser\Inline\BangParser(), 10)
->addRenderer(Node\Block\BlockQuote::class, new Renderer\Block\BlockQuoteRenderer(), 0)
->addRenderer(CoreNode\Block\Document::class, new CoreRenderer\Block\DocumentRenderer(), 0)
->addRenderer(Node\Block\FencedCode::class, new Renderer\Block\FencedCodeRenderer(), 0)
->addRenderer(Node\Block\Heading::class, new Renderer\Block\HeadingRenderer(), 0)
->addRenderer(Node\Block\HtmlBlock::class, new Renderer\Block\HtmlBlockRenderer(), 0)
->addRenderer(Node\Block\IndentedCode::class, new Renderer\Block\IndentedCodeRenderer(), 0)
->addRenderer(Node\Block\ListBlock::class, new Renderer\Block\ListBlockRenderer(), 0)
->addRenderer(Node\Block\ListItem::class, new Renderer\Block\ListItemRenderer(), 0)
->addRenderer(CoreNode\Block\Paragraph::class, new CoreRenderer\Block\ParagraphRenderer(), 0)
->addRenderer(Node\Block\ThematicBreak::class, new Renderer\Block\ThematicBreakRenderer(), 0)
->addRenderer(Node\Inline\Code::class, new Renderer\Inline\CodeRenderer(), 0)
->addRenderer(Node\Inline\Emphasis::class, new Renderer\Inline\EmphasisRenderer(), 0)
->addRenderer(Node\Inline\HtmlInline::class, new Renderer\Inline\HtmlInlineRenderer(), 0)
->addRenderer(Node\Inline\Image::class, new Renderer\Inline\ImageRenderer(), 0)
->addRenderer(Node\Inline\Link::class, new Renderer\Inline\LinkRenderer(), 0)
->addRenderer(CoreNode\Inline\Newline::class, new CoreRenderer\Inline\NewlineRenderer(), 0)
->addRenderer(Node\Inline\Strong::class, new Renderer\Inline\StrongRenderer(), 0)
->addRenderer(CoreNode\Inline\Text::class, new CoreRenderer\Inline\TextRenderer(), 0)
;
if ($environment->getConfiguration()->get('commonmark/use_asterisk')) {
$environment->addDelimiterProcessor(new EmphasisDelimiterProcessor('*'));
}
if ($environment->getConfiguration()->get('commonmark/use_underscore')) {
$environment->addDelimiterProcessor(new EmphasisDelimiterProcessor('_'));
}
}
}
PK �@]� ]�� � : src/Extension/CommonMark/Renderer/Inline/ImageRenderer.phpnu �[��� <?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\Inline;
use League\CommonMark\Extension\CommonMark\Node\Inline\Image;
use League\CommonMark\Node\Inline\Newline;
use League\CommonMark\Node\Node;
use League\CommonMark\Node\NodeIterator;
use League\CommonMark\Node\StringContainerInterface;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlElement;
use League\CommonMark\Util\RegexHelper;
use League\CommonMark\Xml\XmlNodeRendererInterface;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class ImageRenderer implements NodeRendererInterface, XmlNodeRendererInterface, ConfigurationAwareInterface
{
/** @psalm-readonly-allow-private-mutation */
private ConfigurationInterface $config;
/**
* @param Image $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
Image::assertInstanceOf($node);
$attrs = $node->data->get('attributes');
$forbidUnsafeLinks = ! $this->config->get('allow_unsafe_links');
if ($forbidUnsafeLinks && RegexHelper::isLinkPotentiallyUnsafe($node->getUrl())) {
$attrs['src'] = '';
} else {
$attrs['src'] = $node->getUrl();
}
$attrs['alt'] = $this->getAltText($node);
if (($title = $node->getTitle()) !== null) {
$attrs['title'] = $title;
}
return new HtmlElement('img', $attrs, '', true);
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
public function getXmlTagName(Node $node): string
{
return 'image';
}
/**
* @param Image $node
*
* @return array<string, scalar>
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlAttributes(Node $node): array
{
Image::assertInstanceOf($node);
return [
'destination' => $node->getUrl(),
'title' => $node->getTitle() ?? '',
];
}
private function getAltText(Image $node): string
{
$altText = '';
foreach ((new NodeIterator($node)) as $n) {
if ($n instanceof StringContainerInterface) {
$altText .= $n->getLiteral();
} elseif ($n instanceof Newline) {
$altText .= "\n";
}
}
return $altText;
}
}
PK �@]S>qL9
9
9 src/Extension/CommonMark/Renderer/Inline/LinkRenderer.phpnu �[��� <?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\Inline;
use League\CommonMark\Extension\CommonMark\Node\Inline\Link;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlElement;
use League\CommonMark\Util\RegexHelper;
use League\CommonMark\Xml\XmlNodeRendererInterface;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class LinkRenderer implements NodeRendererInterface, XmlNodeRendererInterface, ConfigurationAwareInterface
{
/** @psalm-readonly-allow-private-mutation */
private ConfigurationInterface $config;
/**
* @param Link $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
Link::assertInstanceOf($node);
$attrs = $node->data->get('attributes');
$forbidUnsafeLinks = ! $this->config->get('allow_unsafe_links');
if (! ($forbidUnsafeLinks && RegexHelper::isLinkPotentiallyUnsafe($node->getUrl()))) {
$attrs['href'] = $node->getUrl();
}
if (($title = $node->getTitle()) !== null) {
$attrs['title'] = $title;
}
if (isset($attrs['target']) && $attrs['target'] === '_blank' && ! isset($attrs['rel'])) {
$attrs['rel'] = 'noopener noreferrer';
}
return new HtmlElement('a', $attrs, $childRenderer->renderNodes($node->children()));
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
public function getXmlTagName(Node $node): string
{
return 'link';
}
/**
* @param Link $node
*
* @return array<string, scalar>
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlAttributes(Node $node): array
{
Link::assertInstanceOf($node);
return [
'destination' => $node->getUrl(),
'title' => $node->getTitle() ?? '',
];
}
}
PK �@] ?��� � = src/Extension/CommonMark/Renderer/Inline/EmphasisRenderer.phpnu �[��� <?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\Inline;
use League\CommonMark\Extension\CommonMark\Node\Inline\Emphasis;
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 EmphasisRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param Emphasis $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
Emphasis::assertInstanceOf($node);
$attrs = $node->data->get('attributes');
return new HtmlElement('em', $attrs, $childRenderer->renderNodes($node->children()));
}
public function getXmlTagName(Node $node): string
{
return 'emph';
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@](� � � 9 src/Extension/CommonMark/Renderer/Inline/CodeRenderer.phpnu �[��� <?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\Inline;
use League\CommonMark\Extension\CommonMark\Node\Inline\Code;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlElement;
use League\CommonMark\Util\Xml;
use League\CommonMark\Xml\XmlNodeRendererInterface;
final class CodeRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param Code $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
Code::assertInstanceOf($node);
$attrs = $node->data->get('attributes');
return new HtmlElement('code', $attrs, Xml::escape($node->getLiteral()));
}
public function getXmlTagName(Node $node): string
{
return 'code';
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@]�� �2 2 ? src/Extension/CommonMark/Renderer/Inline/HtmlInlineRenderer.phpnu �[��� <?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\Inline;
use League\CommonMark\Extension\CommonMark\Node\Inline\HtmlInline;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlFilter;
use League\CommonMark\Xml\XmlNodeRendererInterface;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class HtmlInlineRenderer implements NodeRendererInterface, XmlNodeRendererInterface, ConfigurationAwareInterface
{
/** @psalm-readonly-allow-private-mutation */
private ConfigurationInterface $config;
/**
* @param HtmlInline $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): string
{
HtmlInline::assertInstanceOf($node);
$htmlInput = $this->config->get('html_input');
return HtmlFilter::filter($node->getLiteral(), $htmlInput);
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
public function getXmlTagName(Node $node): string
{
return 'html_inline';
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@]yZ' � � ; src/Extension/CommonMark/Renderer/Inline/StrongRenderer.phpnu �[��� <?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\Inline;
use League\CommonMark\Extension\CommonMark\Node\Inline\Strong;
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 StrongRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param Strong $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
Strong::assertInstanceOf($node);
$attrs = $node->data->get('attributes');
return new HtmlElement('strong', $attrs, $childRenderer->renderNodes($node->children()));
}
public function getXmlTagName(Node $node): string
{
return 'strong';
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@]����� � A src/Extension/CommonMark/Renderer/Block/ThematicBreakRenderer.phpnu �[��� <?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\ThematicBreak;
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 ThematicBreakRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param ThematicBreak $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
ThematicBreak::assertInstanceOf($node);
$attrs = $node->data->get('attributes');
return new HtmlElement('hr', $attrs, '', true);
}
public function getXmlTagName(Node $node): string
{
return 'thematic_break';
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@]n3`c c @ src/Extension/CommonMark/Renderer/Block/IndentedCodeRenderer.phpnu �[��� <?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\IndentedCode;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlElement;
use League\CommonMark\Util\Xml;
use League\CommonMark\Xml\XmlNodeRendererInterface;
final class IndentedCodeRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param IndentedCode $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
IndentedCode::assertInstanceOf($node);
$attrs = $node->data->get('attributes');
return new HtmlElement(
'pre',
[],
new HtmlElement('code', $attrs, Xml::escape($node->getLiteral()))
);
}
public function getXmlTagName(Node $node): string
{
return 'code_block';
}
/**
* @return array<string, scalar>
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@]���� � ; src/Extension/CommonMark/Renderer/Block/HeadingRenderer.phpnu �[��� <?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\Heading;
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 HeadingRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param Heading $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
Heading::assertInstanceOf($node);
$tag = 'h' . $node->getLevel();
$attrs = $node->data->get('attributes');
return new HtmlElement($tag, $attrs, $childRenderer->renderNodes($node->children()));
}
public function getXmlTagName(Node $node): string
{
return 'heading';
}
/**
* @param Heading $node
*
* @return array<string, scalar>
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlAttributes(Node $node): array
{
Heading::assertInstanceOf($node);
return ['level' => $node->getLevel()];
}
}
PK �@]>9@� � = src/Extension/CommonMark/Renderer/Block/ListBlockRenderer.phpnu �[��� <?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\ListBlock;
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 ListBlockRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param ListBlock $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
ListBlock::assertInstanceOf($node);
$listData = $node->getListData();
$tag = $listData->type === ListBlock::TYPE_BULLET ? 'ul' : 'ol';
$attrs = $node->data->get('attributes');
if ($listData->start !== null && $listData->start !== 1) {
$attrs['start'] = (string) $listData->start;
}
$innerSeparator = $childRenderer->getInnerSeparator();
return new HtmlElement($tag, $attrs, $innerSeparator . $childRenderer->renderNodes($node->children()) . $innerSeparator);
}
public function getXmlTagName(Node $node): string
{
return 'list';
}
/**
* @param ListBlock $node
*
* @return array<string, scalar>
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlAttributes(Node $node): array
{
ListBlock::assertInstanceOf($node);
$data = $node->getListData();
if ($data->type === ListBlock::TYPE_BULLET) {
return [
'type' => $data->type,
'tight' => $node->isTight() ? 'true' : 'false',
];
}
return [
'type' => $data->type,
'start' => $data->start ?? 1,
'tight' => $node->isTight(),
'delimiter' => $data->delimiter ?? ListBlock::DELIM_PERIOD,
];
}
}
PK �@]&�t+ + = src/Extension/CommonMark/Renderer/Block/HtmlBlockRenderer.phpnu �[��� <?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\HtmlBlock;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlFilter;
use League\CommonMark\Xml\XmlNodeRendererInterface;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class HtmlBlockRenderer implements NodeRendererInterface, XmlNodeRendererInterface, ConfigurationAwareInterface
{
/** @psalm-readonly-allow-private-mutation */
private ConfigurationInterface $config;
/**
* @param HtmlBlock $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): string
{
HtmlBlock::assertInstanceOf($node);
$htmlInput = $this->config->get('html_input');
return HtmlFilter::filter($node->getLiteral(), $htmlInput);
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
public function getXmlTagName(Node $node): string
{
return 'html_block';
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@]@ %�� � > src/Extension/CommonMark/Renderer/Block/BlockQuoteRenderer.phpnu �[��� <?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\BlockQuote;
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 BlockQuoteRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param BlockQuote $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
BlockQuote::assertInstanceOf($node);
$attrs = $node->data->get('attributes');
$filling = $childRenderer->renderNodes($node->children());
$innerSeparator = $childRenderer->getInnerSeparator();
if ($filling === '') {
return new HtmlElement('blockquote', $attrs, $innerSeparator);
}
return new HtmlElement(
'blockquote',
$attrs,
$innerSeparator . $filling . $innerSeparator
);
}
public function getXmlTagName(Node $node): string
{
return 'block_quote';
}
/**
* @param BlockQuote $node
*
* @return array<string, scalar>
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@]����� � > src/Extension/CommonMark/Renderer/Block/FencedCodeRenderer.phpnu �[��� <?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\FencedCode;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlElement;
use League\CommonMark\Util\Xml;
use League\CommonMark\Xml\XmlNodeRendererInterface;
final class FencedCodeRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param FencedCode $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
FencedCode::assertInstanceOf($node);
$attrs = $node->data->getData('attributes');
$infoWords = $node->getInfoWords();
if (\count($infoWords) !== 0 && $infoWords[0] !== '') {
$class = $infoWords[0];
if (! \str_starts_with($class, 'language-')) {
$class = 'language-' . $class;
}
$attrs->append('class', $class);
}
return new HtmlElement(
'pre',
[],
new HtmlElement('code', $attrs->export(), Xml::escape($node->getLiteral()))
);
}
public function getXmlTagName(Node $node): string
{
return 'code_block';
}
/**
* @param FencedCode $node
*
* @return array<string, scalar>
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlAttributes(Node $node): array
{
FencedCode::assertInstanceOf($node);
if (($info = $node->getInfo()) === null || $info === '') {
return [];
}
return ['info' => $info];
}
}
PK �@]#�t�2 2 < src/Extension/CommonMark/Renderer/Block/ListItemRenderer.phpnu �[��� <?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\Extension\TaskList\TaskListItemMarker;
use League\CommonMark\Node\Block\Paragraph;
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());
if (\substr($contents, 0, 1) === '<' && ! $this->startsTaskListItem($node)) {
$contents = "\n" . $contents;
}
if (\substr($contents, -1, 1) === '>') {
$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 startsTaskListItem(ListItem $block): bool
{
$firstChild = $block->firstChild();
return $firstChild instanceof Paragraph && $firstChild->firstChild() instanceof TaskListItemMarker;
}
}
PK �@]{���� � ; src/Extension/CommonMark/Parser/Inline/HtmlInlineParser.phpnu �[��� <?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\HtmlInline;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Parser\Inline\InlineParserMatch;
use League\CommonMark\Parser\InlineParserContext;
use League\CommonMark\Util\RegexHelper;
final class HtmlInlineParser implements InlineParserInterface
{
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::regex(RegexHelper::PARTIAL_HTMLTAG)->caseSensitive();
}
public function parse(InlineParserContext $inlineContext): bool
{
$inline = $inlineContext->getFullMatch();
$inlineContext->getCursor()->advanceBy($inlineContext->getFullMatchLength());
$inlineContext->getContainer()->appendChild(new HtmlInline($inline));
return true;
}
}
PK �@]�9�E 7 src/Extension/CommonMark/Parser/Inline/EntityParser.phpnu �[��� <?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;
use League\CommonMark\Util\Html5EntityDecoder;
use League\CommonMark\Util\RegexHelper;
final class EntityParser implements InlineParserInterface
{
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::regex(RegexHelper::PARTIAL_ENTITY);
}
public function parse(InlineParserContext $inlineContext): bool
{
$entity = $inlineContext->getFullMatch();
$inlineContext->getCursor()->advanceBy($inlineContext->getFullMatchLength());
$inlineContext->getContainer()->appendChild(new Text(Html5EntityDecoder::decode($entity)));
return true;
}
}
PK �@]��L�b b 9 src/Extension/CommonMark/Parser/Inline/AutolinkParser.phpnu �[��� <?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\Link;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Parser\Inline\InlineParserMatch;
use League\CommonMark\Parser\InlineParserContext;
use League\CommonMark\Util\UrlEncoder;
final class AutolinkParser implements InlineParserInterface
{
private const EMAIL_REGEX = '<([a-zA-Z0-9.!#$%&\'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>';
private const OTHER_LINK_REGEX = '<([A-Za-z][A-Za-z0-9.+-]{1,31}:[^<>\x00-\x20]*)>';
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::regex(self::EMAIL_REGEX . '|' . self::OTHER_LINK_REGEX);
}
public function parse(InlineParserContext $inlineContext): bool
{
$inlineContext->getCursor()->advanceBy($inlineContext->getFullMatchLength());
$matches = $inlineContext->getMatches();
if ($matches[1] !== '') {
$inlineContext->getContainer()->appendChild(new Link('mailto:' . UrlEncoder::unescapeAndEncode($matches[1]), $matches[1]));
return true;
}
if ($matches[2] !== '') {
$inlineContext->getContainer()->appendChild(new Link(UrlEncoder::unescapeAndEncode($matches[2]), $matches[2]));
return true;
}
return false; // This should never happen
}
}
PK �@],���k k : src/Extension/CommonMark/Parser/Inline/EscapableParser.phpnu �[��� <?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\Newline;
use League\CommonMark\Node\Inline\Text;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Parser\Inline\InlineParserMatch;
use League\CommonMark\Parser\InlineParserContext;
use League\CommonMark\Util\RegexHelper;
final class EscapableParser implements InlineParserInterface
{
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::string('\\');
}
public function parse(InlineParserContext $inlineContext): bool
{
$cursor = $inlineContext->getCursor();
$nextChar = $cursor->peek();
if ($nextChar === "\n") {
$cursor->advanceBy(2);
$inlineContext->getContainer()->appendChild(new Newline(Newline::HARDBREAK));
return true;
}
if ($nextChar !== null && RegexHelper::isEscapable($nextChar)) {
$cursor->advanceBy(2);
$inlineContext->getContainer()->appendChild(new Text($nextChar));
return true;
}
$cursor->advanceBy(1);
$inlineContext->getContainer()->appendChild(new Text('\\'));
return true;
}
}
PK �@]�%�a a < src/Extension/CommonMark/Parser/Inline/OpenBracketParser.phpnu �[��� <?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\Delimiter;
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
$delimiter = new Delimiter('[', 1, $node, true, false, $inlineContext->getCursor()->getPosition());
$inlineContext->getDelimiterStack()->push($delimiter);
return true;
}
}
PK �@]�5�^ ^ 9 src/Extension/CommonMark/Parser/Inline/BacktickParser.phpnu �[��� <?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\Inline\InlineParserInterface;
use League\CommonMark\Parser\Inline\InlineParserMatch;
use League\CommonMark\Parser\InlineParserContext;
final class BacktickParser implements InlineParserInterface
{
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();
while ($matchingTicks = $cursor->match('/`+/m')) {
if ($matchingTicks !== $ticks) {
continue;
}
$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;
}
}
PK �@]Ɗ>d d 5 src/Extension/CommonMark/Parser/Inline/BangParser.phpnu �[��� <?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\Delimiter;
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
$delimiter = new Delimiter('!', 1, $node, true, false, $cursor->getPosition());
$inlineContext->getDelimiterStack()->push($delimiter);
return true;
}
}
PK �@]^�� � = src/Extension/CommonMark/Parser/Inline/CloseBracketParser.phpnu �[��� <?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\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()->searchByCharacter(['[', '!']);
if ($opener === null) {
return false;
}
if (! $opener->isActive()) {
// no matched opener; remove from emphasis stack
$inlineContext->getDelimiterStack()->removeDelimiter($opener);
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->getIndex(), $startPos)) {
$reference = $link;
$link = ['url' => $link->getDestination(), 'title' => $link->getTitle()];
} else {
// No match
$inlineContext->getDelimiterStack()->removeDelimiter($opener); // Remove this opener from stack
$cursor->restoreState($previousState);
return false;
}
$isImage = $opener->getChar() === '!';
$inline = $this->createInline($link['url'], $link['title'], $isImage, $reference ?? null);
$opener->getInlineNode()->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->getPrevious();
$delimiterStack->processDelimiters($stackBottom, $this->environment->getDelimiterProcessors());
$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 (! $isImage) {
$inlineContext->getDelimiterStack()->removeEarlierMatches('[');
}
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, ?int $openerIndex, int $startPos): ?ReferenceInterface
{
if ($openerIndex === null) {
return null;
}
$savePos = $cursor->saveState();
$beforeLabel = $cursor->getPosition();
$n = LinkParserHelper::parseLinkLabel($cursor);
if ($n === 0 || $n === 2) {
$start = $openerIndex;
$length = $startPos - $openerIndex;
} else {
$start = $beforeLabel + 1;
$length = $n - 2;
}
$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;
}
}
PK �@]��:A� � < src/Extension/CommonMark/Parser/Block/IndentedCodeParser.phpnu �[��� <?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
{
$reversed = \array_reverse($this->strings->toArray(), true);
foreach ($reversed as $index => $line) {
if ($line !== '' && $line !== "\n" && ! \preg_match('/^(\n *)$/', $line)) {
break;
}
unset($reversed[$index]);
}
$fixed = \array_reverse($reversed);
$tmp = \implode("\n", $fixed);
if (\substr($tmp, -1) !== "\n") {
$tmp .= "\n";
}
$this->block->setLiteral($tmp);
}
}
PK �@]*P�� � < src/Extension/CommonMark/Parser/Block/HeadingStartParser.phpnu �[��� <?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\Parser\Block\BlockStart;
use League\CommonMark\Parser\Block\BlockStartParserInterface;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Parser\MarkdownParserStateInterface;
use League\CommonMark\Util\RegexHelper;
class HeadingStartParser implements BlockStartParserInterface
{
public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
{
if ($cursor->isIndented() || ! \in_array($cursor->getNextNonSpaceCharacter(), ['#', '-', '='], true)) {
return BlockStart::none();
}
$cursor->advanceToNextNonSpaceOrTab();
if ($atxHeading = self::getAtxHeader($cursor)) {
return BlockStart::of($atxHeading)->at($cursor);
}
$setextHeadingLevel = self::getSetextHeadingLevel($cursor);
if ($setextHeadingLevel > 0) {
$content = $parserState->getParagraphContent();
if ($content !== null) {
$cursor->advanceToEnd();
return BlockStart::of(new HeadingParser($setextHeadingLevel, $content))
->at($cursor)
->replaceActiveBlockParser();
}
}
return BlockStart::none();
}
private static function getAtxHeader(Cursor $cursor): ?HeadingParser
{
$match = RegexHelper::matchFirst('/^#{1,6}(?:[ \t]+|$)/', $cursor->getRemainder());
if (! $match) {
return null;
}
$cursor->advanceToNextNonSpaceOrTab();
$cursor->advanceBy(\strlen($match[0]));
$level = \strlen(\trim($match[0]));
$str = $cursor->getRemainder();
$str = \preg_replace('/^[ \t]*#+[ \t]*$/', '', $str);
\assert(\is_string($str));
$str = \preg_replace('/[ \t]+#+[ \t]*$/', '', $str);
\assert(\is_string($str));
return new HeadingParser($level, $str);
}
private static function getSetextHeadingLevel(Cursor $cursor): int
{
$match = RegexHelper::matchFirst('/^(?:=+|-+)[ \t]*$/', $cursor->getRemainder());
if ($match === null) {
return 0;
}
return $match[0][0] === '=' ? 1 : 2;
}
}
PK �@]{�j� � 9 src/Extension/CommonMark/Parser/Block/HtmlBlockParser.phpnu �[��� <?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\HtmlBlock;
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\RegexHelper;
final class HtmlBlockParser extends AbstractBlockContinueParser
{
/** @psalm-readonly */
private HtmlBlock $block;
private string $content = '';
private bool $finished = false;
/**
* @psalm-param HtmlBlock::TYPE_* $blockType
*
* @phpstan-param HtmlBlock::TYPE_* $blockType
*/
public function __construct(int $blockType)
{
$this->block = new HtmlBlock($blockType);
}
public function getBlock(): HtmlBlock
{
return $this->block;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
if ($this->finished) {
return BlockContinue::none();
}
if ($cursor->isBlank() && \in_array($this->block->getType(), [HtmlBlock::TYPE_6_BLOCK_ELEMENT, HtmlBlock::TYPE_7_MISC_ELEMENT], true)) {
return BlockContinue::none();
}
return BlockContinue::at($cursor);
}
public function addLine(string $line): void
{
if ($this->content !== '') {
$this->content .= "\n";
}
$this->content .= $line;
// Check for end condition
// phpcs:disable SlevomatCodingStandard.ControlStructures.EarlyExit.EarlyExitNotUsed
if ($this->block->getType() <= HtmlBlock::TYPE_5_CDATA) {
if (\preg_match(RegexHelper::getHtmlBlockCloseRegex($this->block->getType()), $line) === 1) {
$this->finished = true;
}
}
}
public function closeBlock(): void
{
$this->block->setLiteral($this->content);
$this->content = '';
}
}
PK �@]C�e� � A src/Extension/CommonMark/Parser/Block/IndentedCodeStartParser.phpnu �[��� <?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\Node\Block\Paragraph;
use League\CommonMark\Parser\Block\BlockStart;
use League\CommonMark\Parser\Block\BlockStartParserInterface;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Parser\MarkdownParserStateInterface;
final class IndentedCodeStartParser implements BlockStartParserInterface
{
public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
{
if (! $cursor->isIndented()) {
return BlockStart::none();
}
if ($parserState->getActiveBlockParser()->getBlock() instanceof Paragraph) {
return BlockStart::none();
}
if ($cursor->isBlank()) {
return BlockStart::none();
}
$cursor->advanceBy(Cursor::INDENT_LEVEL, true);
return BlockStart::of(new IndentedCodeParser())->at($cursor);
}
}
PK �@]Kz��* * : src/Extension/CommonMark/Parser/Block/BlockQuoteParser.phpnu �[��� <?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\BlockQuote;
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 BlockQuoteParser extends AbstractBlockContinueParser
{
/** @psalm-readonly */
private BlockQuote $block;
public function __construct()
{
$this->block = new BlockQuote();
}
public function getBlock(): BlockQuote
{
return $this->block;
}
public function isContainer(): bool
{
return true;
}
public function canContain(AbstractBlock $childBlock): bool
{
return true;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
if (! $cursor->isIndented() && $cursor->getNextNonSpaceCharacter() === '>') {
$cursor->advanceToNextNonSpaceOrTab();
$cursor->advanceBy(1);
$cursor->advanceBySpaceOrTab();
return BlockContinue::at($cursor);
}
return BlockContinue::none();
}
}
PK �@]}v##{ { 8 src/Extension/CommonMark/Parser/Block/ListItemParser.phpnu �[��� <?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\Node\Block\Paragraph;
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;
private bool $hadBlankLine = false;
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
{
if ($this->hadBlankLine) {
// We saw a blank line in this list item, that means the list block is loose.
//
// spec: if any of its constituent list items directly contain two block-level elements with a blank line
// between them
$parent = $this->block->parent();
if ($parent instanceof ListBlock) {
$parent->setTight(false);
}
}
return true;
}
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();
}
$activeBlock = $activeBlockParser->getBlock();
// If the active block is a code block, blank lines in it should not affect if the list is tight.
$this->hadBlankLine = $activeBlock instanceof Paragraph || $activeBlock instanceof ListItem;
$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();
}
}
PK �@]��ᄖ � = src/Extension/CommonMark/Parser/Block/ThematicBreakParser.phpnu �[��� <?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\ThematicBreak;
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 ThematicBreakParser extends AbstractBlockContinueParser
{
/** @psalm-readonly */
private ThematicBreak $block;
public function __construct()
{
$this->block = new ThematicBreak();
}
public function getBlock(): ThematicBreak
{
return $this->block;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
// a horizontal rule can never container > 1 line, so fail to match
return BlockContinue::none();
}
}
PK �@]7Bq�
�
: src/Extension/CommonMark/Parser/Block/FencedCodeParser.phpnu �[��� <?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,})(?= *$)/', $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");
}
}
}
PK �@]F�4$k k > src/Extension/CommonMark/Parser/Block/ListBlockStartParser.phpnu �[��� <?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.
$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), '/') . ']/';
}
}
PK �@]�Xѷ� � ? src/Extension/CommonMark/Parser/Block/FencedCodeStartParser.phpnu �[��� <?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\Parser\Block\BlockStart;
use League\CommonMark\Parser\Block\BlockStartParserInterface;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Parser\MarkdownParserStateInterface;
final class FencedCodeStartParser implements BlockStartParserInterface
{
public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
{
if ($cursor->isIndented() || ! \in_array($cursor->getNextNonSpaceCharacter(), ['`', '~'], true)) {
return BlockStart::none();
}
$indent = $cursor->getIndent();
$fence = $cursor->match('/^[ \t]*(?:`{3,}(?!.*`)|~{3,})/');
if ($fence === null) {
return BlockStart::none();
}
// fenced code block
$fence = \ltrim($fence, " \t");
return BlockStart::of(new FencedCodeParser(\strlen($fence), $fence[0], $indent))->at($cursor);
}
}
PK �@]���Y Y ? src/Extension/CommonMark/Parser/Block/BlockQuoteStartParser.phpnu �[��� <?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\Parser\Block\BlockStart;
use League\CommonMark\Parser\Block\BlockStartParserInterface;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Parser\MarkdownParserStateInterface;
final class BlockQuoteStartParser implements BlockStartParserInterface
{
public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
{
if ($cursor->isIndented()) {
return BlockStart::none();
}
if ($cursor->getNextNonSpaceCharacter() !== '>') {
return BlockStart::none();
}
$cursor->advanceToNextNonSpaceOrTab();
$cursor->advanceBy(1);
$cursor->advanceBySpaceOrTab();
return BlockStart::of(new BlockQuoteParser())->at($cursor);
}
}
PK �@]�}� V V > src/Extension/CommonMark/Parser/Block/HtmlBlockStartParser.phpnu �[��� <?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\HtmlBlock;
use League\CommonMark\Node\Block\Paragraph;
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;
final class HtmlBlockStartParser implements BlockStartParserInterface
{
public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
{
if ($cursor->isIndented() || $cursor->getNextNonSpaceCharacter() !== '<') {
return BlockStart::none();
}
$tmpCursor = clone $cursor;
$tmpCursor->advanceToNextNonSpaceOrTab();
$line = $tmpCursor->getRemainder();
for ($blockType = 1; $blockType <= 7; $blockType++) {
/** @psalm-var HtmlBlock::TYPE_* $blockType */
/** @phpstan-var HtmlBlock::TYPE_* $blockType */
$match = RegexHelper::matchAt(
RegexHelper::getHtmlBlockOpenRegex($blockType),
$line
);
if ($match !== null && ($blockType < 7 || $this->isType7BlockAllowed($cursor, $parserState))) {
return BlockStart::of(new HtmlBlockParser($blockType))->at($cursor);
}
}
return BlockStart::none();
}
private function isType7BlockAllowed(Cursor $cursor, MarkdownParserStateInterface $parserState): bool
{
// Type 7 blocks can't interrupt paragraphs
if ($parserState->getLastMatchedBlockParser()->getBlock() instanceof Paragraph) {
return false;
}
// Even lazy ones
return ! $parserState->getActiveBlockParser()->canHaveLazyContinuationLines();
}
}
PK �@]���W� � B src/Extension/CommonMark/Parser/Block/ThematicBreakStartParser.phpnu �[��� <?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\Parser\Block\BlockStart;
use League\CommonMark\Parser\Block\BlockStartParserInterface;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Parser\MarkdownParserStateInterface;
use League\CommonMark\Util\RegexHelper;
final class ThematicBreakStartParser implements BlockStartParserInterface
{
public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
{
if ($cursor->isIndented()) {
return BlockStart::none();
}
$match = RegexHelper::matchAt(RegexHelper::REGEX_THEMATIC_BREAK, $cursor->getLine(), $cursor->getNextNonSpacePosition());
if ($match === null) {
return BlockStart::none();
}
// Advance to the end of the string, consuming the entire line (of the thematic break)
$cursor->advanceToEnd();
return BlockStart::of(new ThematicBreakParser())->at($cursor);
}
}
PK �@]�nL�� � 7 src/Extension/CommonMark/Parser/Block/HeadingParser.phpnu �[��� <?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\Heading;
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;
final class HeadingParser extends AbstractBlockContinueParser implements BlockContinueParserWithInlinesInterface
{
/** @psalm-readonly */
private Heading $block;
private string $content;
public function __construct(int $level, string $content)
{
$this->block = new Heading($level);
$this->content = $content;
}
public function getBlock(): Heading
{
return $this->block;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
return BlockContinue::none();
}
public function parseInlines(InlineParserEngineInterface $inlineParser): void
{
$inlineParser->parse($this->content, $this->block);
}
}
PK �@]ϲ dD D 9 src/Extension/CommonMark/Parser/Block/ListBlockParser.phpnu �[��� <?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;
private bool $hadBlankLine = false;
private int $linesAfterBlank = 0;
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
{
if (! $childBlock instanceof ListItem) {
return false;
}
// Another list item is being added to this list block.
// If the previous line was blank, that means this list
// block is "loose" (not tight).
if ($this->hadBlankLine && $this->linesAfterBlank === 1) {
$this->block->setTight(false);
$this->hadBlankLine = false;
}
return true;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
if ($cursor->isBlank()) {
$this->hadBlankLine = true;
$this->linesAfterBlank = 0;
} elseif ($this->hadBlankLine) {
$this->linesAfterBlank++;
}
// 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);
}
}
PK �@]h�N� � K src/Extension/CommonMark/Delimiter/Processor/EmphasisDelimiterProcessor.phpnu �[��� <?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\DelimiterProcessorInterface;
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 DelimiterProcessorInterface, 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;
}
}
PK �@]�L8y� � ? src/Extension/Strikethrough/StrikethroughDelimiterProcessor.phpnu �[��� <?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\DelimiterProcessorInterface;
use League\CommonMark\Node\Inline\AbstractStringContainer;
final class StrikethroughDelimiterProcessor implements DelimiterProcessorInterface
{
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;
}
return \min($opener->getLength(), $closer->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);
}
}
PK �@]�}��' ' 6 src/Extension/Strikethrough/StrikethroughExtension.phpnu �[��� <?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\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Extension\ExtensionInterface;
final class StrikethroughExtension implements ExtensionInterface
{
public function register(EnvironmentBuilderInterface $environment): void
{
$environment->addDelimiterProcessor(new StrikethroughDelimiterProcessor());
$environment->addRenderer(Strikethrough::class, new StrikethroughRenderer());
}
}
PK �@]Y6�� � - src/Extension/Strikethrough/Strikethrough.phpnu �[��� <?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\Node\Inline\AbstractInline;
use League\CommonMark\Node\Inline\DelimitedInterface;
final class Strikethrough extends AbstractInline implements DelimitedInterface
{
private string $delimiter;
public function __construct(string $delimiter = '~~')
{
parent::__construct();
$this->delimiter = $delimiter;
}
public function getOpeningDelimiter(): string
{
return $this->delimiter;
}
public function getClosingDelimiter(): string
{
return $this->delimiter;
}
}
PK �@]Ȉ�\; ; 5 src/Extension/Strikethrough/StrikethroughRenderer.phpnu �[��� <?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\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlElement;
use League\CommonMark\Xml\XmlNodeRendererInterface;
final class StrikethroughRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param Strikethrough $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
Strikethrough::assertInstanceOf($node);
return new HtmlElement('del', $node->data->get('attributes'), $childRenderer->renderNodes($node->children()));
}
public function getXmlTagName(Node $node): string
{
return 'strikethrough';
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@]>�w w , src/Extension/Attributes/Node/Attributes.phpnu �[��� <?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\Node;
use League\CommonMark\Node\Block\AbstractBlock;
final class Attributes extends AbstractBlock
{
public const TARGET_PARENT = 0;
public const TARGET_PREVIOUS = 1;
public const TARGET_NEXT = 2;
/** @var array<string, mixed> */
private array $attributes;
private int $target = self::TARGET_NEXT;
/**
* @param array<string, mixed> $attributes
*/
public function __construct(array $attributes)
{
parent::__construct();
$this->attributes = $attributes;
}
/**
* @return array<string, mixed>
*/
public function getAttributes(): array
{
return $this->attributes;
}
/**
* @param array<string, mixed> $attributes
*/
public function setAttributes(array $attributes): void
{
$this->attributes = $attributes;
}
public function getTarget(): int
{
return $this->target;
}
public function setTarget(int $target): void
{
$this->target = $target;
}
}
PK �@] C�� � 2 src/Extension/Attributes/Node/AttributesInline.phpnu �[��� <?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\Node;
use League\CommonMark\Node\Inline\AbstractInline;
final class AttributesInline extends AbstractInline
{
/** @var array<string, mixed> */
private array $attributes;
private bool $block;
/**
* @param array<string, mixed> $attributes
*/
public function __construct(array $attributes, bool $block)
{
parent::__construct();
$this->attributes = $attributes;
$this->block = $block;
}
/**
* @return array<string, mixed>
*/
public function getAttributes(): array
{
return $this->attributes;
}
/**
* @param array<string, mixed> $attributes
*/
public function setAttributes(array $attributes): void
{
$this->attributes = $attributes;
}
public function isBlock(): bool
{
return $this->block;
}
}
PK �@]�c�>k k 2 src/Extension/Attributes/Util/AttributesHelper.phpnu �[��� <?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-z0-9-]+|' . 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);
$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;
}
}
PK �@]Z��C C 5 src/Extension/Attributes/Event/AttributesListener.phpnu �[��� <?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\Event;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\Attributes\Node\Attributes;
use League\CommonMark\Extension\Attributes\Node\AttributesInline;
use League\CommonMark\Extension\Attributes\Util\AttributesHelper;
use League\CommonMark\Extension\CommonMark\Node\Block\FencedCode;
use League\CommonMark\Extension\CommonMark\Node\Block\ListBlock;
use League\CommonMark\Extension\CommonMark\Node\Block\ListItem;
use League\CommonMark\Node\Inline\AbstractInline;
use League\CommonMark\Node\Node;
final class AttributesListener
{
private const DIRECTION_PREFIX = 'prefix';
private const DIRECTION_SUFFIX = 'suffix';
public function processDocument(DocumentParsedEvent $event): void
{
foreach ($event->getDocument()->iterator() as $node) {
if (! ($node instanceof Attributes || $node instanceof AttributesInline)) {
continue;
}
[$target, $direction] = self::findTargetAndDirection($node);
if ($target instanceof Node) {
$parent = $target->parent();
if ($parent instanceof ListItem && $parent->parent() instanceof ListBlock && $parent->parent()->isTight()) {
$target = $parent;
}
if ($direction === self::DIRECTION_SUFFIX) {
$attributes = AttributesHelper::mergeAttributes($target, $node->getAttributes());
} else {
$attributes = AttributesHelper::mergeAttributes($node->getAttributes(), $target);
}
$target->data->set('attributes', $attributes);
}
$node->detach();
}
}
/**
* @param Attributes|AttributesInline $node
*
* @return array<Node|string|null>
*/
private static function findTargetAndDirection($node): array
{
$target = null;
$direction = null;
$previous = $next = $node;
while (true) {
$previous = self::getPrevious($previous);
$next = self::getNext($next);
if ($previous === null && $next === null) {
if (! $node->parent() instanceof FencedCode) {
$target = $node->parent();
$direction = self::DIRECTION_SUFFIX;
}
break;
}
if ($node instanceof AttributesInline && ($previous === null || ($previous instanceof AbstractInline && $node->isBlock()))) {
continue;
}
if ($previous !== null && ! self::isAttributesNode($previous)) {
$target = $previous;
$direction = self::DIRECTION_SUFFIX;
break;
}
if ($next !== null && ! self::isAttributesNode($next)) {
$target = $next;
$direction = self::DIRECTION_PREFIX;
break;
}
}
return [$target, $direction];
}
/**
* Get any previous block (sibling or parent) this might apply to
*/
private static function getPrevious(?Node $node = null): ?Node
{
if ($node instanceof Attributes) {
if ($node->getTarget() === Attributes::TARGET_NEXT) {
return null;
}
if ($node->getTarget() === Attributes::TARGET_PARENT) {
return $node->parent();
}
}
return $node instanceof Node ? $node->previous() : null;
}
/**
* Get any previous block (sibling or parent) this might apply to
*/
private static function getNext(?Node $node = null): ?Node
{
if ($node instanceof Attributes && $node->getTarget() !== Attributes::TARGET_NEXT) {
return null;
}
return $node instanceof Node ? $node->next() : null;
}
private static function isAttributesNode(Node $node): bool
{
return $node instanceof Attributes || $node instanceof AttributesInline;
}
}
PK �@]0�dŘ � 0 src/Extension/Attributes/AttributesExtension.phpnu �[��� <?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;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\Attributes\Event\AttributesListener;
use League\CommonMark\Extension\Attributes\Parser\AttributesBlockStartParser;
use League\CommonMark\Extension\Attributes\Parser\AttributesInlineParser;
use League\CommonMark\Extension\ExtensionInterface;
final class AttributesExtension implements ExtensionInterface
{
public function register(EnvironmentBuilderInterface $environment): void
{
$environment->addBlockStartParser(new AttributesBlockStartParser());
$environment->addInlineParser(new AttributesInlineParser());
$environment->addEventListener(DocumentParsedEvent::class, [new AttributesListener(), 'processDocument']);
}
}
PK �@]Mǯ'� � : src/Extension/Attributes/Parser/AttributesInlineParser.phpnu �[��� <?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\Parser;
use League\CommonMark\Extension\Attributes\Node\AttributesInline;
use League\CommonMark\Extension\Attributes\Util\AttributesHelper;
use League\CommonMark\Node\StringContainerInterface;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Parser\Inline\InlineParserMatch;
use League\CommonMark\Parser\InlineParserContext;
final class AttributesInlineParser implements InlineParserInterface
{
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::string('{');
}
public function parse(InlineParserContext $inlineContext): bool
{
$cursor = $inlineContext->getCursor();
$char = (string) $cursor->peek(-1);
$attributes = AttributesHelper::parseAttributes($cursor);
if ($attributes === []) {
return false;
}
if ($char === ' ' && ($prev = $inlineContext->getContainer()->lastChild()) instanceof StringContainerInterface) {
$prev->setLiteral(\rtrim($prev->getLiteral(), ' '));
}
if ($char === '') {
$cursor->advanceToNextNonSpaceOrNewline();
}
$node = new AttributesInline($attributes, $char === ' ' || $char === '');
$inlineContext->getContainer()->appendChild($node);
return true;
}
}
PK �@]_;�0� � A src/Extension/Attributes/Parser/AttributesBlockContinueParser.phpnu �[��� <?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\Parser;
use League\CommonMark\Extension\Attributes\Node\Attributes;
use League\CommonMark\Extension\Attributes\Util\AttributesHelper;
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 AttributesBlockContinueParser extends AbstractBlockContinueParser
{
private Attributes $block;
private AbstractBlock $container;
private bool $hasSubsequentLine = false;
/**
* @param array<string, mixed> $attributes The attributes identified by the block start parser
* @param AbstractBlock $container The node we were in when these attributes were discovered
*/
public function __construct(array $attributes, AbstractBlock $container)
{
$this->block = new Attributes($attributes);
$this->container = $container;
}
public function getBlock(): AbstractBlock
{
return $this->block;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
$this->hasSubsequentLine = true;
$cursor->advanceToNextNonSpaceOrTab();
// Does this next line also have attributes?
$attributes = AttributesHelper::parseAttributes($cursor);
$cursor->advanceToNextNonSpaceOrTab();
if ($cursor->isAtEnd() && $attributes !== []) {
// It does! Merge them into what we parsed previously
$this->block->setAttributes(AttributesHelper::mergeAttributes(
$this->block->getAttributes(),
$attributes
));
// Tell the core parser we've consumed everything
return BlockContinue::at($cursor);
}
// Okay, so there are no attributes on the next line
// If this next line is blank we know we can't target the next node, it must be a previous one
if ($cursor->isBlank()) {
$this->block->setTarget(Attributes::TARGET_PREVIOUS);
}
return BlockContinue::none();
}
public function closeBlock(): void
{
// Attributes appearing at the very end of the document won't have any last lines to check
// so we can make that determination here
if (! $this->hasSubsequentLine) {
$this->block->setTarget(Attributes::TARGET_PREVIOUS);
}
// We know this block must apply to the "previous" block, but that could be a sibling or parent,
// so we check the containing block to see which one it might be.
if ($this->block->getTarget() === Attributes::TARGET_PREVIOUS && $this->block->parent() === $this->container) {
$this->block->setTarget(Attributes::TARGET_PARENT);
}
}
}
PK �@]Z���K K > src/Extension/Attributes/Parser/AttributesBlockStartParser.phpnu �[��� <?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\Parser;
use League\CommonMark\Extension\Attributes\Util\AttributesHelper;
use League\CommonMark\Parser\Block\BlockStart;
use League\CommonMark\Parser\Block\BlockStartParserInterface;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Parser\MarkdownParserStateInterface;
final class AttributesBlockStartParser implements BlockStartParserInterface
{
public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
{
$originalPosition = $cursor->getPosition();
$attributes = AttributesHelper::parseAttributes($cursor);
if ($attributes === [] && $originalPosition === $cursor->getPosition()) {
return BlockStart::none();
}
if ($cursor->getNextNonSpaceCharacter() !== null) {
return BlockStart::none();
}
return BlockStart::of(new AttributesBlockContinueParser($attributes, $parserState->getActiveBlockParser()->getBlock()))->at($cursor);
}
}
PK �@]�-��8 8 - src/Extension/TaskList/TaskListItemMarker.phpnu �[��� <?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\TaskList;
use League\CommonMark\Node\Inline\AbstractInline;
final class TaskListItemMarker extends AbstractInline
{
/** @psalm-readonly-allow-private-mutation */
private bool $checked;
public function __construct(bool $isCompleted)
{
parent::__construct();
$this->checked = $isCompleted;
}
public function isChecked(): bool
{
return $this->checked;
}
public function setChecked(bool $checked): void
{
$this->checked = $checked;
}
}
PK �@]"��MY Y 3 src/Extension/TaskList/TaskListItemMarkerParser.phpnu �[��� <?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\TaskList;
use League\CommonMark\Extension\CommonMark\Node\Block\ListItem;
use League\CommonMark\Node\Block\Paragraph;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Parser\Inline\InlineParserMatch;
use League\CommonMark\Parser\InlineParserContext;
final class TaskListItemMarkerParser implements InlineParserInterface
{
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::oneOf('[ ]', '[x]');
}
public function parse(InlineParserContext $inlineContext): bool
{
$container = $inlineContext->getContainer();
// Checkbox must come at the beginning of the first paragraph of the list item
if ($container->hasChildren() || ! ($container instanceof Paragraph && $container->parent() && $container->parent() instanceof ListItem)) {
return false;
}
$cursor = $inlineContext->getCursor();
$oldState = $cursor->saveState();
$cursor->advanceBy(3);
if ($cursor->getNextNonSpaceCharacter() === null) {
$cursor->restoreState($oldState);
return false;
}
$isChecked = $inlineContext->getFullMatch() !== '[ ]';
$container->appendChild(new TaskListItemMarker($isChecked));
return true;
}
}
PK �@],��� � , src/Extension/TaskList/TaskListExtension.phpnu �[��� <?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\TaskList;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Extension\ExtensionInterface;
final class TaskListExtension implements ExtensionInterface
{
public function register(EnvironmentBuilderInterface $environment): void
{
$environment->addInlineParser(new TaskListItemMarkerParser(), 35);
$environment->addRenderer(TaskListItemMarker::class, new TaskListItemMarkerRenderer());
}
}
PK �@]�7� 5 src/Extension/TaskList/TaskListItemMarkerRenderer.phpnu �[��� <?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\TaskList;
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 TaskListItemMarkerRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param TaskListItemMarker $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
TaskListItemMarker::assertInstanceOf($node);
$attrs = $node->data->get('attributes');
$checkbox = new HtmlElement('input', $attrs, '', true);
if ($node->isChecked()) {
$checkbox->setAttribute('checked', '');
}
$checkbox->setAttribute('disabled', '');
$checkbox->setAttribute('type', 'checkbox');
return $checkbox;
}
public function getXmlTagName(Node $node): string
{
return 'task_list_item_marker';
}
/**
* @param TaskListItemMarker $node
*
* @return array<string, scalar>
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlAttributes(Node $node): array
{
TaskListItemMarker::assertInstanceOf($node);
if ($node->isChecked()) {
return ['checked' => 'checked'];
}
return [];
}
}
PK �@]�
4$O O + src/Extension/SmartPunct/EllipsesParser.phpnu �[��� <?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\Node\Inline\Text;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Parser\Inline\InlineParserMatch;
use League\CommonMark\Parser\InlineParserContext;
final class EllipsesParser implements InlineParserInterface
{
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::oneOf('...', '. . .');
}
public function parse(InlineParserContext $inlineContext): bool
{
$inlineContext->getCursor()->advanceBy($inlineContext->getFullMatchLength());
$inlineContext->getContainer()->appendChild(new Text('…'));
return true;
}
}
PK �@]�K�{A A " src/Extension/SmartPunct/Quote.phpnu �[��� <?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\Node\Inline\AbstractStringContainer;
final class Quote extends AbstractStringContainer
{
public const DOUBLE_QUOTE = '"';
public const DOUBLE_QUOTE_OPENER = '“';
public const DOUBLE_QUOTE_CLOSER = '”';
public const SINGLE_QUOTE = "'";
public const SINGLE_QUOTE_OPENER = '‘';
public const SINGLE_QUOTE_CLOSER = '’';
}
PK �@]2"�?�
�
0 src/Extension/SmartPunct/SmartPunctExtension.phpnu �[��� <?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\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\ConfigurableExtensionInterface;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Node\Block\Paragraph;
use League\CommonMark\Node\Inline\Text;
use League\CommonMark\Renderer\Block as CoreBlockRenderer;
use League\CommonMark\Renderer\Inline as CoreInlineRenderer;
use League\Config\ConfigurationBuilderInterface;
use Nette\Schema\Expect;
final class SmartPunctExtension implements ConfigurableExtensionInterface
{
public function configureSchema(ConfigurationBuilderInterface $builder): void
{
$builder->addSchema('smartpunct', Expect::structure([
'double_quote_opener' => Expect::string(Quote::DOUBLE_QUOTE_OPENER),
'double_quote_closer' => Expect::string(Quote::DOUBLE_QUOTE_CLOSER),
'single_quote_opener' => Expect::string(Quote::SINGLE_QUOTE_OPENER),
'single_quote_closer' => Expect::string(Quote::SINGLE_QUOTE_CLOSER),
]));
}
public function register(EnvironmentBuilderInterface $environment): void
{
$environment
->addInlineParser(new QuoteParser(), 10)
->addInlineParser(new DashParser(), 0)
->addInlineParser(new EllipsesParser(), 0)
->addDelimiterProcessor(QuoteProcessor::createDoubleQuoteProcessor(
$environment->getConfiguration()->get('smartpunct/double_quote_opener'),
$environment->getConfiguration()->get('smartpunct/double_quote_closer')
))
->addDelimiterProcessor(QuoteProcessor::createSingleQuoteProcessor(
$environment->getConfiguration()->get('smartpunct/single_quote_opener'),
$environment->getConfiguration()->get('smartpunct/single_quote_closer')
))
->addEventListener(DocumentParsedEvent::class, new ReplaceUnpairedQuotesListener())
->addRenderer(Document::class, new CoreBlockRenderer\DocumentRenderer(), 0)
->addRenderer(Paragraph::class, new CoreBlockRenderer\ParagraphRenderer(), 0)
->addRenderer(Text::class, new CoreInlineRenderer\TextRenderer(), 0);
}
}
PK �@]Z���
�
( src/Extension/SmartPunct/QuoteParser.phpnu �[��� <?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
{
public const DOUBLE_QUOTES = [Quote::DOUBLE_QUOTE, Quote::DOUBLE_QUOTE_OPENER, Quote::DOUBLE_QUOTE_CLOSER];
public const SINGLE_QUOTES = [Quote::SINGLE_QUOTE, Quote::SINGLE_QUOTE_OPENER, Quote::SINGLE_QUOTE_CLOSER];
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::oneOf(...[...self::DOUBLE_QUOTES, ...self::SINGLE_QUOTES]);
}
/**
* 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();
$normalizedCharacter = $this->getNormalizedQuoteCharacter($char);
$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($normalizedCharacter, ['delim' => true]);
$inlineContext->getContainer()->appendChild($node);
// Add entry to stack to this opener
$inlineContext->getDelimiterStack()->push(new Delimiter($normalizedCharacter, 1, $node, $canOpen, $canClose));
return true;
}
private function getNormalizedQuoteCharacter(string $character): string
{
if (\in_array($character, self::DOUBLE_QUOTES, true)) {
return Quote::DOUBLE_QUOTE;
}
if (\in_array($character, self::SINGLE_QUOTES, true)) {
return Quote::SINGLE_QUOTE;
}
return $character;
}
/**
* @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];
}
}
PK �@]��Тr r ' src/Extension/SmartPunct/DashParser.phpnu �[��� <?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\Node\Inline\Text;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Parser\Inline\InlineParserMatch;
use League\CommonMark\Parser\InlineParserContext;
final class DashParser implements InlineParserInterface
{
private const EN_DASH = '–';
private const EM_DASH = '—';
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::regex('(?<!-)(-{2,})');
}
public function parse(InlineParserContext $inlineContext): bool
{
$count = $inlineContext->getFullMatchLength();
$inlineContext->getCursor()->advanceBy($count);
$enCount = 0;
$emCount = 0;
if ($count % 3 === 0) { // If divisible by 3, use all em dashes
$emCount = (int) ($count / 3);
} elseif ($count % 2 === 0) { // If divisible by 2, use all en dashes
$enCount = (int) ($count / 2);
} elseif ($count % 3 === 2) { // If 2 extra dashes, use en dash for last 2; em dashes for rest
$emCount = (int) (($count - 2) / 3);
$enCount = 1;
} else { // Use en dashes for last 4 hyphens; em dashes for rest
$emCount = (int) (($count - 4) / 3);
$enCount = 2;
}
$inlineContext->getContainer()->appendChild(new Text(
\str_repeat(self::EM_DASH, $emCount) . \str_repeat(self::EN_DASH, $enCount)
));
return true;
}
}
PK �@]�mk�2 2 : src/Extension/SmartPunct/ReplaceUnpairedQuotesListener.phpnu �[��� <?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\SmartPunct;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Node\Inline\AdjacentTextMerger;
use League\CommonMark\Node\Inline\Text;
use League\CommonMark\Node\Query;
/**
* Identifies any lingering Quote nodes that were missing pairs and converts them into Text nodes
*/
final class ReplaceUnpairedQuotesListener
{
public function __invoke(DocumentParsedEvent $event): void
{
$query = (new Query())->where(Query::type(Quote::class));
foreach ($query->findAll($event->getDocument()) as $quote) {
\assert($quote instanceof Quote);
$literal = $quote->getLiteral();
if ($literal === Quote::SINGLE_QUOTE) {
$literal = Quote::SINGLE_QUOTE_CLOSER;
} elseif ($literal === Quote::DOUBLE_QUOTE) {
$literal = Quote::DOUBLE_QUOTE_OPENER;
}
$quote->replaceWith($new = new Text($literal));
AdjacentTextMerger::mergeWithDirectlyAdjacentNodes($new);
}
}
}
PK �@]�%�d; ; + src/Extension/SmartPunct/QuoteProcessor.phpnu �[��� <?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\DelimiterInterface;
use League\CommonMark\Delimiter\Processor\DelimiterProcessorInterface;
use League\CommonMark\Node\Inline\AbstractStringContainer;
final class QuoteProcessor implements DelimiterProcessorInterface
{
/** @psalm-readonly */
private string $normalizedCharacter;
/** @psalm-readonly */
private string $openerCharacter;
/** @psalm-readonly */
private string $closerCharacter;
private function __construct(string $char, string $opener, string $closer)
{
$this->normalizedCharacter = $char;
$this->openerCharacter = $opener;
$this->closerCharacter = $closer;
}
public function getOpeningCharacter(): string
{
return $this->normalizedCharacter;
}
public function getClosingCharacter(): string
{
return $this->normalizedCharacter;
}
public function getMinLength(): int
{
return 1;
}
public function getDelimiterUse(DelimiterInterface $opener, DelimiterInterface $closer): int
{
return 1;
}
public function process(AbstractStringContainer $opener, AbstractStringContainer $closer, int $delimiterUse): void
{
$opener->insertAfter(new Quote($this->openerCharacter));
$closer->insertBefore(new Quote($this->closerCharacter));
}
/**
* Create a double-quote processor
*/
public static function createDoubleQuoteProcessor(string $opener = Quote::DOUBLE_QUOTE_OPENER, string $closer = Quote::DOUBLE_QUOTE_CLOSER): self
{
return new self(Quote::DOUBLE_QUOTE, $opener, $closer);
}
/**
* Create a single-quote processor
*/
public static function createSingleQuoteProcessor(string $opener = Quote::SINGLE_QUOTE_OPENER, string $closer = Quote::SINGLE_QUOTE_CLOSER): self
{
return new self(Quote::SINGLE_QUOTE, $opener, $closer);
}
}
PK �@];��� � , src/Extension/Autolink/AutolinkExtension.phpnu �[��� <?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\ExtensionInterface;
final class AutolinkExtension implements ExtensionInterface
{
public function register(EnvironmentBuilderInterface $environment): void
{
$environment->addInlineParser(new EmailAutolinkParser());
$environment->addInlineParser(new UrlAutolinkParser());
}
}
PK �@]���� � , src/Extension/Autolink/UrlAutolinkParser.phpnu �[��� <?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\-\_]++\.)+[\pL\pN\pM]++ # a multi-level domain name
|
[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;
/**
* @param array<int, string> $allowedProtocols
*/
public function __construct(array $allowedProtocols = ['http', 'https', 'ftp'])
{
/**
* @psalm-suppress PropertyTypeCoercion
*/
$this->finalRegex = \sprintf(self::REGEX, \implode('|', $allowedProtocols));
foreach ($allowedProtocols as $protocol) {
$this->prefixes[] = $protocol . '://';
}
}
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://' onto 'www' URLs
if (\substr($url, 0, 4) === 'www.') {
$inlineContext->getContainer()->appendChild(new Link('http://' . $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['('];
}
}
PK �@]�_��� � . src/Extension/Autolink/EmailAutolinkParser.phpnu �[��� <?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 EmailAutolinkParser implements InlineParserInterface
{
private const REGEX = '[A-Za-z0-9.\-_+]+@[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_.]+';
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::regex(self::REGEX);
}
public function parse(InlineParserContext $inlineContext): bool
{
$email = $inlineContext->getFullMatch();
// The last character cannot be - or _
if (\in_array(\substr($email, -1), ['-', '_'], true)) {
return false;
}
// Does the URL end with punctuation that should be stripped?
if (\substr($email, -1) === '.') {
$email = \substr($email, 0, -1);
}
$inlineContext->getCursor()->advanceBy(\strlen($email));
$inlineContext->getContainer()->appendChild(new Link('mailto:' . $email, $email));
return true;
}
}
PK �@]��oa� � > src/Extension/DefaultAttributes/DefaultAttributesExtension.phpnu �[��� <?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\DefaultAttributes;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\ConfigurableExtensionInterface;
use League\Config\ConfigurationBuilderInterface;
use Nette\Schema\Expect;
final class DefaultAttributesExtension implements ConfigurableExtensionInterface
{
public function configureSchema(ConfigurationBuilderInterface $builder): void
{
$builder->addSchema('default_attributes', Expect::arrayOf(
Expect::arrayOf(
Expect::type('string|string[]|bool|callable'), // attribute value(s)
'string' // attribute name
),
'string' // node FQCN
)->default([]));
}
public function register(EnvironmentBuilderInterface $environment): void
{
$environment->addEventListener(DocumentParsedEvent::class, [new ApplyDefaultAttributesProcessor(), 'onDocumentParsed']);
}
}
PK �@]�GO O C src/Extension/DefaultAttributes/ApplyDefaultAttributesProcessor.phpnu �[��� <?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\DefaultAttributes;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\Attributes\Util\AttributesHelper;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class ApplyDefaultAttributesProcessor implements ConfigurationAwareInterface
{
private ConfigurationInterface $config;
public function onDocumentParsed(DocumentParsedEvent $event): void
{
/** @var array<string, array<string, mixed>> $map */
$map = $this->config->get('default_attributes');
// Don't bother iterating if no default attributes are configured
if (! $map) {
return;
}
foreach ($event->getDocument()->iterator() as $node) {
// Check to see if any default attributes were defined
if (($attributesToApply = $map[\get_class($node)] ?? []) === []) {
continue;
}
$newAttributes = [];
foreach ($attributesToApply as $name => $value) {
if (\is_callable($value)) {
$value = $value($node);
// Callables are allowed to return `null` indicating that no changes should be made
if ($value !== null) {
$newAttributes[$name] = $value;
}
} else {
$newAttributes[$name] = $value;
}
}
// Merge these attributes into the node
if (\count($newAttributes) > 0) {
$node->data->set('attributes', AttributesHelper::mergeAttributes($node, $newAttributes));
}
}
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
}
PK �@]��� & src/Extension/Embed/EmbedProcessor.phpnu �[��� <?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\Embed;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\CommonMark\Node\Inline\Link;
use League\CommonMark\Node\Block\Paragraph;
use League\CommonMark\Node\Inline\Text;
use League\CommonMark\Node\NodeIterator;
final class EmbedProcessor
{
public const FALLBACK_REMOVE = 'remove';
public const FALLBACK_LINK = 'link';
private EmbedAdapterInterface $adapter;
private string $fallback;
public function __construct(EmbedAdapterInterface $adapter, string $fallback = self::FALLBACK_REMOVE)
{
$this->adapter = $adapter;
$this->fallback = $fallback;
}
public function __invoke(DocumentParsedEvent $event): void
{
$document = $event->getDocument();
$embeds = [];
foreach (new NodeIterator($document) as $node) {
if (! ($node instanceof Embed)) {
continue;
}
if ($node->parent() !== $document) {
$replacement = new Paragraph();
$replacement->appendChild(new Text($node->getUrl()));
$node->replaceWith($replacement);
} else {
$embeds[] = $node;
}
}
$this->adapter->updateEmbeds($embeds);
foreach ($embeds as $embed) {
if ($embed->getEmbedCode() !== null) {
continue;
}
if ($this->fallback === self::FALLBACK_REMOVE) {
$embed->detach();
} elseif ($this->fallback === self::FALLBACK_LINK) {
$paragraph = new Paragraph();
$paragraph->appendChild(new Link($embed->getUrl(), $embed->getUrl()));
$embed->replaceWith($paragraph);
}
}
}
}
PK �@]ht t . src/Extension/Embed/DomainFilteringAdapter.phpnu �[��� <?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\Embed;
class DomainFilteringAdapter implements EmbedAdapterInterface
{
private EmbedAdapterInterface $decorated;
/** @psalm-var non-empty-string */
private string $regex;
/**
* @param string[] $allowedDomains
*/
public function __construct(EmbedAdapterInterface $decorated, array $allowedDomains)
{
$this->decorated = $decorated;
$this->regex = self::createRegex($allowedDomains);
}
/**
* {@inheritDoc}
*/
public function updateEmbeds(array $embeds): void
{
$this->decorated->updateEmbeds(\array_values(\array_filter($embeds, function (Embed $embed): bool {
return \preg_match($this->regex, $embed->getUrl()) === 1;
})));
}
/**
* @param string[] $allowedDomains
*
* @psalm-return non-empty-string
*/
private static function createRegex(array $allowedDomains): string
{
$allowedDomains = \array_map('preg_quote', $allowedDomains);
return '/^(?:https?:\/\/)?(?:[^.]+\.)*(' . \implode('|', $allowedDomains) . ')/';
}
}
PK �@]* x� � ( src/Extension/Embed/EmbedStartParser.phpnu �[��� <?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\Embed;
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\LinkParserHelper;
class EmbedStartParser implements BlockStartParserInterface
{
public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
{
if ($cursor->isIndented() || $parserState->getParagraphContent() !== null || ! ($parserState->getActiveBlockParser()->isContainer())) {
return BlockStart::none();
}
// 0-3 leading spaces are okay
$cursor->advanceToNextNonSpaceOrTab();
// The line must begin with "https://"
if (! str_starts_with($cursor->getRemainder(), 'https://')) {
return BlockStart::none();
}
// A valid link must be found next
if (($dest = LinkParserHelper::parseLinkDestination($cursor)) === null) {
return BlockStart::none();
}
// Skip any trailing whitespace
$cursor->advanceToNextNonSpaceOrTab();
// We must be at the end of the line; otherwise, this link was not by itself
if (! $cursor->isAtEnd()) {
return BlockStart::none();
}
return BlockStart::of(new EmbedParser($dest))->at($cursor);
}
}
PK �@]F#�( ( - src/Extension/Embed/EmbedAdapterInterface.phpnu �[��� <?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\Embed;
/**
* Interface for a service which updates the embed code(s) for the given array of embeds
*/
interface EmbedAdapterInterface
{
/**
* @param Embed[] $embeds
*/
public function updateEmbeds(array $embeds): void;
}
PK �@]�*M�� � & src/Extension/Embed/EmbedExtension.phpnu �[��� <?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\Embed;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\ConfigurableExtensionInterface;
use League\Config\ConfigurationBuilderInterface;
use Nette\Schema\Expect;
final class EmbedExtension implements ConfigurableExtensionInterface
{
public function configureSchema(ConfigurationBuilderInterface $builder): void
{
$builder->addSchema('embed', Expect::structure([
'adapter' => Expect::type(EmbedAdapterInterface::class),
'allowed_domains' => Expect::arrayOf('string')->default([]),
'fallback' => Expect::anyOf('link', 'remove')->default('link'),
]));
}
public function register(EnvironmentBuilderInterface $environment): void
{
$adapter = $environment->getConfiguration()->get('embed.adapter');
\assert($adapter instanceof EmbedAdapterInterface);
$allowedDomains = $environment->getConfiguration()->get('embed.allowed_domains');
if ($allowedDomains !== []) {
$adapter = new DomainFilteringAdapter($adapter, $allowedDomains);
}
$environment
->addBlockStartParser(new EmbedStartParser(), 300)
->addEventListener(DocumentParsedEvent::class, new EmbedProcessor($adapter, $environment->getConfiguration()->get('embed.fallback')), 1010)
->addRenderer(Embed::class, new EmbedRenderer());
}
}
PK �@]��⤞ � 5 src/Extension/Embed/Bridge/OscaroteroEmbedAdapter.phpnu �[��� <?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\Embed\Bridge;
use Embed\Embed as EmbedLib;
use League\CommonMark\Exception\MissingDependencyException;
use League\CommonMark\Extension\Embed\Embed;
use League\CommonMark\Extension\Embed\EmbedAdapterInterface;
final class OscaroteroEmbedAdapter implements EmbedAdapterInterface
{
private EmbedLib $embedLib;
public function __construct(?EmbedLib $embed = null)
{
if ($embed === null) {
if (! \class_exists(EmbedLib::class)) {
throw new MissingDependencyException('The embed/embed package is not installed. Please install it with Composer to use this adapter.');
}
$embed = new EmbedLib();
}
$this->embedLib = $embed;
}
/**
* {@inheritDoc}
*/
public function updateEmbeds(array $embeds): void
{
$extractors = $this->embedLib->getMulti(...\array_map(static fn (Embed $embed) => $embed->getUrl(), $embeds));
foreach ($extractors as $i => $extractor) {
if ($extractor->code !== null) {
$embeds[$i]->setEmbedCode($extractor->code->html);
}
}
}
}
PK �@]^M`8 8 # src/Extension/Embed/EmbedParser.phpnu �[��� <?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\Embed;
use League\CommonMark\Node\Block\AbstractBlock;
use League\CommonMark\Parser\Block\BlockContinue;
use League\CommonMark\Parser\Block\BlockContinueParserInterface;
use League\CommonMark\Parser\Cursor;
class EmbedParser implements BlockContinueParserInterface
{
private Embed $embed;
public function __construct(string $url)
{
$this->embed = new Embed($url);
}
public function getBlock(): AbstractBlock
{
return $this->embed;
}
public function isContainer(): bool
{
return false;
}
public function canHaveLazyContinuationLines(): bool
{
return false;
}
public function canContain(AbstractBlock $childBlock): bool
{
return false;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
return BlockContinue::none();
}
public function addLine(string $line): void
{
}
public function closeBlock(): void
{
}
}
PK �@]
�a*B B % src/Extension/Embed/EmbedRenderer.phpnu �[��� <?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\Embed;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
class EmbedRenderer implements NodeRendererInterface
{
/**
* @param Embed $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer)
{
Embed::assertInstanceOf($node);
return $node->getEmbedCode() ?? '';
}
}
PK �@]
� � src/Extension/Embed/Embed.phpnu �[��� <?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\Embed;
use League\CommonMark\Node\Block\AbstractBlock;
final class Embed extends AbstractBlock
{
private string $url;
private ?string $embedCode;
public function __construct(string $url, ?string $embedCode = null)
{
parent::__construct();
$this->url = $url;
$this->embedCode = $embedCode;
}
public function getUrl(): string
{
return $this->url;
}
public function setUrl(string $url): void
{
$this->url = $url;
}
public function getEmbedCode(): ?string
{
return $this->embedCode;
}
public function setEmbedCode(?string $embedCode): void
{
$this->embedCode = $embedCode;
}
}
PK �@]3W�� � 4 src/Extension/ExternalLink/ExternalLinkExtension.phpnu �[��� <?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\ExternalLink;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\ConfigurableExtensionInterface;
use League\Config\ConfigurationBuilderInterface;
use Nette\Schema\Expect;
final class ExternalLinkExtension implements ConfigurableExtensionInterface
{
public function configureSchema(ConfigurationBuilderInterface $builder): void
{
$applyOptions = [
ExternalLinkProcessor::APPLY_NONE,
ExternalLinkProcessor::APPLY_ALL,
ExternalLinkProcessor::APPLY_INTERNAL,
ExternalLinkProcessor::APPLY_EXTERNAL,
];
$builder->addSchema('external_link', Expect::structure([
'internal_hosts' => Expect::type('string|string[]'),
'open_in_new_window' => Expect::bool(false),
'html_class' => Expect::string()->default(''),
'nofollow' => Expect::anyOf(...$applyOptions)->default(ExternalLinkProcessor::APPLY_NONE),
'noopener' => Expect::anyOf(...$applyOptions)->default(ExternalLinkProcessor::APPLY_EXTERNAL),
'noreferrer' => Expect::anyOf(...$applyOptions)->default(ExternalLinkProcessor::APPLY_EXTERNAL),
]));
}
public function register(EnvironmentBuilderInterface $environment): void
{
$environment->addEventListener(DocumentParsedEvent::class, new ExternalLinkProcessor($environment->getConfiguration()), -50);
}
}
PK �@]�q�3� � 4 src/Extension/ExternalLink/ExternalLinkProcessor.phpnu �[��� <?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\ExternalLink;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\CommonMark\Node\Inline\Link;
use League\Config\ConfigurationInterface;
final class ExternalLinkProcessor
{
public const APPLY_NONE = '';
public const APPLY_ALL = 'all';
public const APPLY_EXTERNAL = 'external';
public const APPLY_INTERNAL = 'internal';
/** @psalm-readonly */
private ConfigurationInterface $config;
public function __construct(ConfigurationInterface $config)
{
$this->config = $config;
}
public function __invoke(DocumentParsedEvent $e): void
{
$internalHosts = $this->config->get('external_link/internal_hosts');
$openInNewWindow = $this->config->get('external_link/open_in_new_window');
$classes = $this->config->get('external_link/html_class');
foreach ($e->getDocument()->iterator() as $link) {
if (! ($link instanceof Link)) {
continue;
}
$host = \parse_url($link->getUrl(), PHP_URL_HOST);
if (! \is_string($host)) {
// Something is terribly wrong with this URL
continue;
}
if (self::hostMatches($host, $internalHosts)) {
$link->data->set('external', false);
$this->applyRelAttribute($link, false);
continue;
}
// Host does not match our list
$this->markLinkAsExternal($link, $openInNewWindow, $classes);
}
}
private function markLinkAsExternal(Link $link, bool $openInNewWindow, string $classes): void
{
$link->data->set('external', true);
$this->applyRelAttribute($link, true);
if ($openInNewWindow) {
$link->data->set('attributes/target', '_blank');
}
if ($classes !== '') {
$link->data->append('attributes/class', $classes);
}
}
private function applyRelAttribute(Link $link, bool $isExternal): void
{
$options = [
'nofollow' => $this->config->get('external_link/nofollow'),
'noopener' => $this->config->get('external_link/noopener'),
'noreferrer' => $this->config->get('external_link/noreferrer'),
];
foreach ($options as $type => $option) {
switch (true) {
case $option === self::APPLY_ALL:
case $isExternal && $option === self::APPLY_EXTERNAL:
case ! $isExternal && $option === self::APPLY_INTERNAL:
$link->data->append('attributes/rel', $type);
}
}
// No rel attributes? Mark the attribute as 'false' so LinkRenderer doesn't add defaults
if (! $link->data->has('attributes/rel')) {
$link->data->set('attributes/rel', false);
}
}
/**
* @internal This method is only public so we can easily test it. DO NOT USE THIS OUTSIDE OF THIS EXTENSION!
*
* @param non-empty-string|list<non-empty-string> $compareTo
*/
public static function hostMatches(string $host, $compareTo): bool
{
foreach ((array) $compareTo as $c) {
if (\strpos($c, '/') === 0) {
if (\preg_match($c, $host)) {
return true;
}
} elseif ($c === $host) {
return true;
}
}
return false;
}
}
PK �@]R�E� � > src/Extension/DisallowedRawHtml/DisallowedRawHtmlExtension.phpnu �[��� <?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\DisallowedRawHtml;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Extension\CommonMark\Node\Block\HtmlBlock;
use League\CommonMark\Extension\CommonMark\Node\Inline\HtmlInline;
use League\CommonMark\Extension\CommonMark\Renderer\Block\HtmlBlockRenderer;
use League\CommonMark\Extension\CommonMark\Renderer\Inline\HtmlInlineRenderer;
use League\CommonMark\Extension\ConfigurableExtensionInterface;
use League\Config\ConfigurationBuilderInterface;
use Nette\Schema\Expect;
final class DisallowedRawHtmlExtension implements ConfigurableExtensionInterface
{
private const DEFAULT_DISALLOWED_TAGS = [
'title',
'textarea',
'style',
'xmp',
'iframe',
'noembed',
'noframes',
'script',
'plaintext',
];
public function configureSchema(ConfigurationBuilderInterface $builder): void
{
$builder->addSchema('disallowed_raw_html', Expect::structure([
'disallowed_tags' => Expect::listOf('string')->default(self::DEFAULT_DISALLOWED_TAGS)->mergeDefaults(false),
]));
}
public function register(EnvironmentBuilderInterface $environment): void
{
$environment->addRenderer(HtmlBlock::class, new DisallowedRawHtmlRenderer(new HtmlBlockRenderer()), 50);
$environment->addRenderer(HtmlInline::class, new DisallowedRawHtmlRenderer(new HtmlInlineRenderer()), 50);
}
}
PK �@]j �L� � = src/Extension/DisallowedRawHtml/DisallowedRawHtmlRenderer.phpnu �[��� <?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\DisallowedRawHtml;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class DisallowedRawHtmlRenderer implements NodeRendererInterface, ConfigurationAwareInterface
{
/** @psalm-readonly */
private NodeRendererInterface $innerRenderer;
/** @psalm-readonly-allow-private-mutation */
private ConfigurationInterface $config;
public function __construct(NodeRendererInterface $innerRenderer)
{
$this->innerRenderer = $innerRenderer;
}
public function render(Node $node, ChildNodeRendererInterface $childRenderer): ?string
{
$rendered = (string) $this->innerRenderer->render($node, $childRenderer);
if ($rendered === '') {
return '';
}
$tags = (array) $this->config->get('disallowed_raw_html/disallowed_tags');
if (\count($tags) === 0) {
return $rendered;
}
$regex = \sprintf('/<(\/?(?:%s)[ \/>])/i', \implode('|', \array_map('preg_quote', $tags)));
// Match these types of tags: <title> </title> <title x="sdf"> <title/> <title />
return \preg_replace($regex, '<$1', $rendered);
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
if ($this->innerRenderer instanceof ConfigurationAwareInterface) {
$this->innerRenderer->setConfiguration($configuration);
}
}
}
PK �@]u.1f� � / src/Extension/Footnote/Node/FootnoteBackref.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Node;
use League\CommonMark\Node\Inline\AbstractInline;
use League\CommonMark\Reference\ReferenceInterface;
use League\CommonMark\Reference\ReferenceableInterface;
/**
* Link from the footnote on the bottom of the document back to the reference
*/
final class FootnoteBackref extends AbstractInline implements ReferenceableInterface
{
/** @psalm-readonly */
private ReferenceInterface $reference;
public function __construct(ReferenceInterface $reference)
{
parent::__construct();
$this->reference = $reference;
}
public function getReference(): ReferenceInterface
{
return $this->reference;
}
}
PK �@]���X� � 1 src/Extension/Footnote/Node/FootnoteContainer.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Node;
use League\CommonMark\Node\Block\AbstractBlock;
final class FootnoteContainer extends AbstractBlock
{
}
PK �@]��wg g + src/Extension/Footnote/Node/FootnoteRef.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Node;
use League\CommonMark\Node\Inline\AbstractInline;
use League\CommonMark\Reference\ReferenceInterface;
use League\CommonMark\Reference\ReferenceableInterface;
final class FootnoteRef extends AbstractInline implements ReferenceableInterface
{
private ReferenceInterface $reference;
/** @psalm-readonly */
private ?string $content = null;
/**
* @param array<mixed> $data
*/
public function __construct(ReferenceInterface $reference, ?string $content = null, array $data = [])
{
parent::__construct();
$this->reference = $reference;
$this->content = $content;
if (\count($data) > 0) {
$this->data->import($data);
}
}
public function getReference(): ReferenceInterface
{
return $this->reference;
}
public function setReference(ReferenceInterface $reference): void
{
$this->reference = $reference;
}
public function getContent(): ?string
{
return $this->content;
}
}
PK �@]B�� � ( src/Extension/Footnote/Node/Footnote.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Node;
use League\CommonMark\Node\Block\AbstractBlock;
use League\CommonMark\Reference\ReferenceInterface;
use League\CommonMark\Reference\ReferenceableInterface;
final class Footnote extends AbstractBlock implements ReferenceableInterface
{
/** @psalm-readonly */
private ReferenceInterface $reference;
public function __construct(ReferenceInterface $reference)
{
parent::__construct();
$this->reference = $reference;
}
public function getReference(): ReferenceInterface
{
return $this->reference;
}
}
PK �@]��M�6 6 ; src/Extension/Footnote/Event/AnonymousFootnotesListener.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Event;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\Footnote\Node\Footnote;
use League\CommonMark\Extension\Footnote\Node\FootnoteBackref;
use League\CommonMark\Extension\Footnote\Node\FootnoteRef;
use League\CommonMark\Node\Block\Paragraph;
use League\CommonMark\Node\Inline\Text;
use League\CommonMark\Reference\Reference;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class AnonymousFootnotesListener implements ConfigurationAwareInterface
{
private ConfigurationInterface $config;
public function onDocumentParsed(DocumentParsedEvent $event): void
{
$document = $event->getDocument();
foreach ($document->iterator() as $node) {
if (! $node instanceof FootnoteRef || ($text = $node->getContent()) === null) {
continue;
}
// Anonymous footnote needs to create a footnote from its content
$existingReference = $node->getReference();
$newReference = new Reference(
$existingReference->getLabel(),
'#' . $this->config->get('footnote/ref_id_prefix') . $existingReference->getLabel(),
$existingReference->getTitle()
);
$paragraph = new Paragraph();
$paragraph->appendChild(new Text($text));
$paragraph->appendChild(new FootnoteBackref($newReference));
$footnote = new Footnote($newReference);
$footnote->appendChild($paragraph);
$document->appendChild($footnote);
}
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
}
PK �@]�>r��
�
8 src/Extension/Footnote/Event/GatherFootnotesListener.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Event;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\Footnote\Node\Footnote;
use League\CommonMark\Extension\Footnote\Node\FootnoteBackref;
use League\CommonMark\Extension\Footnote\Node\FootnoteContainer;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Node\NodeIterator;
use League\CommonMark\Reference\Reference;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class GatherFootnotesListener implements ConfigurationAwareInterface
{
private ConfigurationInterface $config;
public function onDocumentParsed(DocumentParsedEvent $event): void
{
$document = $event->getDocument();
$footnotes = [];
foreach ($document->iterator(NodeIterator::FLAG_BLOCKS_ONLY) as $node) {
if (! $node instanceof Footnote) {
continue;
}
// Look for existing reference with footnote label
$ref = $document->getReferenceMap()->get($node->getReference()->getLabel());
if ($ref !== null) {
// Use numeric title to get footnotes order
$footnotes[(int) $ref->getTitle()] = $node;
} else {
// Footnote call is missing, append footnote at the end
$footnotes[\PHP_INT_MAX] = $node;
}
$key = '#' . $this->config->get('footnote/footnote_id_prefix') . $node->getReference()->getDestination();
if ($document->data->has($key)) {
$this->createBackrefs($node, $document->data->get($key));
}
}
// Only add a footnote container if there are any
if (\count($footnotes) === 0) {
return;
}
$container = $this->getFootnotesContainer($document);
\ksort($footnotes);
foreach ($footnotes as $footnote) {
$container->appendChild($footnote);
}
}
private function getFootnotesContainer(Document $document): FootnoteContainer
{
$footnoteContainer = new FootnoteContainer();
$document->appendChild($footnoteContainer);
return $footnoteContainer;
}
/**
* Look for all footnote refs pointing to this footnote and create each footnote backrefs.
*
* @param Footnote $node The target footnote
* @param Reference[] $backrefs References to create backrefs for
*/
private function createBackrefs(Footnote $node, array $backrefs): void
{
// Backrefs should be added to the child paragraph
$target = $node->lastChild();
if ($target === null) {
// This should never happen, but you never know
$target = $node;
}
foreach ($backrefs as $backref) {
$target->appendChild(new FootnoteBackref(new Reference(
$backref->getLabel(),
'#' . $this->config->get('footnote/ref_id_prefix') . $backref->getLabel(),
$backref->getTitle()
)));
}
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
}
PK �@]pܵ 1 1 D src/Extension/Footnote/Event/FixOrphanedFootnotesAndRefsListener.phpnu �[��� <?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\Extension\Footnote\Event;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\Footnote\Node\Footnote;
use League\CommonMark\Extension\Footnote\Node\FootnoteRef;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Node\Inline\Text;
final class FixOrphanedFootnotesAndRefsListener
{
public function onDocumentParsed(DocumentParsedEvent $event): void
{
$document = $event->getDocument();
$map = $this->buildMapOfKnownFootnotesAndRefs($document);
foreach ($map['_flat'] as $node) {
if ($node instanceof FootnoteRef && ! isset($map[Footnote::class][$node->getReference()->getLabel()])) {
// Found an orphaned FootnoteRef without a corresponding Footnote
// Restore the original footnote ref text
$node->replaceWith(new Text(\sprintf('[^%s]', $node->getReference()->getLabel())));
}
// phpcs:disable SlevomatCodingStandard.ControlStructures.EarlyExit.EarlyExitNotUsed
if ($node instanceof Footnote && ! isset($map[FootnoteRef::class][$node->getReference()->getLabel()])) {
// Found an orphaned Footnote without a corresponding FootnoteRef
// Remove the footnote
$node->detach();
}
}
}
/** @phpstan-ignore-next-line */
private function buildMapOfKnownFootnotesAndRefs(Document $document): array // @phpcs:ignore
{
$map = [
Footnote::class => [],
FootnoteRef::class => [],
'_flat' => [],
];
foreach ($document->iterator() as $node) {
if ($node instanceof Footnote) {
$map[Footnote::class][$node->getReference()->getLabel()] = true;
$map['_flat'][] = $node;
} elseif ($node instanceof FootnoteRef) {
$map[FootnoteRef::class][$node->getReference()->getLabel()] = true;
$map['_flat'][] = $node;
}
}
return $map;
}
}
PK �@]~��& & 8 src/Extension/Footnote/Event/NumberFootnotesListener.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Event;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\Footnote\Node\FootnoteRef;
use League\CommonMark\Reference\Reference;
final class NumberFootnotesListener
{
public function onDocumentParsed(DocumentParsedEvent $event): void
{
$document = $event->getDocument();
$nextCounter = 1;
$usedLabels = [];
$usedCounters = [];
foreach ($document->iterator() as $node) {
if (! $node instanceof FootnoteRef) {
continue;
}
$existingReference = $node->getReference();
$label = $existingReference->getLabel();
$counter = $nextCounter;
$canIncrementCounter = true;
if (\array_key_exists($label, $usedLabels)) {
/*
* Reference is used again, we need to point
* to the same footnote. But with a different ID
*/
$counter = $usedCounters[$label];
$label .= '__' . ++$usedLabels[$label];
$canIncrementCounter = false;
}
// rewrite reference title to use a numeric link
$newReference = new Reference(
$label,
$existingReference->getDestination(),
(string) $counter
);
// Override reference with numeric link
$node->setReference($newReference);
$document->getReferenceMap()->add($newReference);
/*
* Store created references in document for
* creating FootnoteBackrefs
*/
$document->data->append($existingReference->getDestination(), $newReference);
$usedLabels[$label] = 1;
$usedCounters[$label] = $nextCounter;
if ($canIncrementCounter) {
$nextCounter++;
}
}
}
}
PK �@]����
�
, src/Extension/Footnote/FootnoteExtension.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\ConfigurableExtensionInterface;
use League\CommonMark\Extension\Footnote\Event\AnonymousFootnotesListener;
use League\CommonMark\Extension\Footnote\Event\FixOrphanedFootnotesAndRefsListener;
use League\CommonMark\Extension\Footnote\Event\GatherFootnotesListener;
use League\CommonMark\Extension\Footnote\Event\NumberFootnotesListener;
use League\CommonMark\Extension\Footnote\Node\Footnote;
use League\CommonMark\Extension\Footnote\Node\FootnoteBackref;
use League\CommonMark\Extension\Footnote\Node\FootnoteContainer;
use League\CommonMark\Extension\Footnote\Node\FootnoteRef;
use League\CommonMark\Extension\Footnote\Parser\AnonymousFootnoteRefParser;
use League\CommonMark\Extension\Footnote\Parser\FootnoteRefParser;
use League\CommonMark\Extension\Footnote\Parser\FootnoteStartParser;
use League\CommonMark\Extension\Footnote\Renderer\FootnoteBackrefRenderer;
use League\CommonMark\Extension\Footnote\Renderer\FootnoteContainerRenderer;
use League\CommonMark\Extension\Footnote\Renderer\FootnoteRefRenderer;
use League\CommonMark\Extension\Footnote\Renderer\FootnoteRenderer;
use League\Config\ConfigurationBuilderInterface;
use Nette\Schema\Expect;
final class FootnoteExtension implements ConfigurableExtensionInterface
{
public function configureSchema(ConfigurationBuilderInterface $builder): void
{
$builder->addSchema('footnote', Expect::structure([
'backref_class' => Expect::string('footnote-backref'),
'backref_symbol' => Expect::string('↩'),
'container_add_hr' => Expect::bool(true),
'container_class' => Expect::string('footnotes'),
'ref_class' => Expect::string('footnote-ref'),
'ref_id_prefix' => Expect::string('fnref:'),
'footnote_class' => Expect::string('footnote'),
'footnote_id_prefix' => Expect::string('fn:'),
]));
}
public function register(EnvironmentBuilderInterface $environment): void
{
$environment->addBlockStartParser(new FootnoteStartParser(), 51);
$environment->addInlineParser(new AnonymousFootnoteRefParser(), 35);
$environment->addInlineParser(new FootnoteRefParser(), 51);
$environment->addRenderer(FootnoteContainer::class, new FootnoteContainerRenderer());
$environment->addRenderer(Footnote::class, new FootnoteRenderer());
$environment->addRenderer(FootnoteRef::class, new FootnoteRefRenderer());
$environment->addRenderer(FootnoteBackref::class, new FootnoteBackrefRenderer());
$environment->addEventListener(DocumentParsedEvent::class, [new AnonymousFootnotesListener(), 'onDocumentParsed'], 40);
$environment->addEventListener(DocumentParsedEvent::class, [new FixOrphanedFootnotesAndRefsListener(), 'onDocumentParsed'], 30);
$environment->addEventListener(DocumentParsedEvent::class, [new NumberFootnotesListener(), 'onDocumentParsed'], 20);
$environment->addEventListener(DocumentParsedEvent::class, [new GatherFootnotesListener(), 'onDocumentParsed'], 10);
}
}
PK �@]��f�� � 7 src/Extension/Footnote/Renderer/FootnoteRefRenderer.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Renderer;
use League\CommonMark\Extension\Footnote\Node\FootnoteRef;
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;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class FootnoteRefRenderer implements NodeRendererInterface, XmlNodeRendererInterface, ConfigurationAwareInterface
{
private ConfigurationInterface $config;
/**
* @param FootnoteRef $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
FootnoteRef::assertInstanceOf($node);
$attrs = $node->data->getData('attributes');
$attrs->append('class', $this->config->get('footnote/ref_class'));
$attrs->set('href', \mb_strtolower($node->getReference()->getDestination(), 'UTF-8'));
$attrs->set('role', 'doc-noteref');
$idPrefix = $this->config->get('footnote/ref_id_prefix');
return new HtmlElement(
'sup',
[
'id' => $idPrefix . \mb_strtolower($node->getReference()->getLabel(), 'UTF-8'),
],
new HtmlElement(
'a',
$attrs->export(),
$node->getReference()->getTitle()
),
true
);
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
public function getXmlTagName(Node $node): string
{
return 'footnote_ref';
}
/**
* @param FootnoteRef $node
*
* @return array<string, scalar>
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlAttributes(Node $node): array
{
FootnoteRef::assertInstanceOf($node);
return [
'reference' => $node->getReference()->getLabel(),
];
}
}
PK �@]/ڰ�A A = src/Extension/Footnote/Renderer/FootnoteContainerRenderer.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Renderer;
use League\CommonMark\Extension\Footnote\Node\FootnoteContainer;
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;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class FootnoteContainerRenderer implements NodeRendererInterface, XmlNodeRendererInterface, ConfigurationAwareInterface
{
private ConfigurationInterface $config;
/**
* @param FootnoteContainer $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
FootnoteContainer::assertInstanceOf($node);
$attrs = $node->data->getData('attributes');
$attrs->append('class', $this->config->get('footnote/container_class'));
$attrs->set('role', 'doc-endnotes');
$contents = new HtmlElement('ol', [], $childRenderer->renderNodes($node->children()));
if ($this->config->get('footnote/container_add_hr')) {
$contents = [new HtmlElement('hr', [], null, true), $contents];
}
return new HtmlElement('div', $attrs->export(), $contents);
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
public function getXmlTagName(Node $node): string
{
return 'footnote_container';
}
/**
* @return array<string, scalar>
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@]�a�X X ; src/Extension/Footnote/Renderer/FootnoteBackrefRenderer.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Renderer;
use League\CommonMark\Extension\Footnote\Node\FootnoteBackref;
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;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class FootnoteBackrefRenderer implements NodeRendererInterface, XmlNodeRendererInterface, ConfigurationAwareInterface
{
public const DEFAULT_SYMBOL = '↩';
private ConfigurationInterface $config;
/**
* @param FootnoteBackref $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): string
{
FootnoteBackref::assertInstanceOf($node);
$attrs = $node->data->getData('attributes');
$attrs->append('class', $this->config->get('footnote/backref_class'));
$attrs->set('rev', 'footnote');
$attrs->set('href', \mb_strtolower($node->getReference()->getDestination(), 'UTF-8'));
$attrs->set('role', 'doc-backlink');
$symbol = $this->config->get('footnote/backref_symbol');
\assert(\is_string($symbol));
return ' ' . new HtmlElement('a', $attrs->export(), \htmlspecialchars($symbol), true);
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
public function getXmlTagName(Node $node): string
{
return 'footnote_backref';
}
/**
* @param FootnoteBackref $node
*
* @return array<string, scalar>
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlAttributes(Node $node): array
{
FootnoteBackref::assertInstanceOf($node);
return [
'reference' => $node->getReference()->getLabel(),
];
}
}
PK �@])v@ � � 4 src/Extension/Footnote/Renderer/FootnoteRenderer.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Renderer;
use League\CommonMark\Extension\Footnote\Node\Footnote;
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;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class FootnoteRenderer implements NodeRendererInterface, XmlNodeRendererInterface, ConfigurationAwareInterface
{
private ConfigurationInterface $config;
/**
* @param Footnote $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
Footnote::assertInstanceOf($node);
$attrs = $node->data->getData('attributes');
$attrs->append('class', $this->config->get('footnote/footnote_class'));
$attrs->set('id', $this->config->get('footnote/footnote_id_prefix') . \mb_strtolower($node->getReference()->getLabel(), 'UTF-8'));
$attrs->set('role', 'doc-endnote');
return new HtmlElement(
'li',
$attrs->export(),
$childRenderer->renderNodes($node->children()),
true
);
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
public function getXmlTagName(Node $node): string
{
return 'footnote';
}
/**
* @param Footnote $node
*
* @return array<string, scalar>
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlAttributes(Node $node): array
{
Footnote::assertInstanceOf($node);
return [
'reference' => $node->getReference()->getLabel(),
];
}
}
PK �@]��<zq q < src/Extension/Footnote/Parser/AnonymousFootnoteRefParser.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Parser;
use League\CommonMark\Environment\EnvironmentAwareInterface;
use League\CommonMark\Environment\EnvironmentInterface;
use League\CommonMark\Extension\Footnote\Node\FootnoteRef;
use League\CommonMark\Normalizer\TextNormalizerInterface;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Parser\Inline\InlineParserMatch;
use League\CommonMark\Parser\InlineParserContext;
use League\CommonMark\Reference\Reference;
use League\Config\ConfigurationInterface;
final class AnonymousFootnoteRefParser implements InlineParserInterface, EnvironmentAwareInterface
{
private ConfigurationInterface $config;
/** @psalm-readonly-allow-private-mutation */
private TextNormalizerInterface $slugNormalizer;
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::regex('\^\[([^\]]+)\]');
}
public function parse(InlineParserContext $inlineContext): bool
{
$inlineContext->getCursor()->advanceBy($inlineContext->getFullMatchLength());
[$label] = $inlineContext->getSubMatches();
$reference = $this->createReference($label);
$inlineContext->getContainer()->appendChild(new FootnoteRef($reference, $label));
return true;
}
private function createReference(string $label): Reference
{
$refLabel = $this->slugNormalizer->normalize($label, ['length' => 20]);
return new Reference(
$refLabel,
'#' . $this->config->get('footnote/footnote_id_prefix') . $refLabel,
$label
);
}
public function setEnvironment(EnvironmentInterface $environment): void
{
$this->config = $environment->getConfiguration();
$this->slugNormalizer = $environment->getSlugNormalizer();
}
}
PK �@]I�� 5 src/Extension/Footnote/Parser/FootnoteStartParser.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Parser;
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\Reference\Reference;
use League\CommonMark\Util\RegexHelper;
final class FootnoteStartParser implements BlockStartParserInterface
{
public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
{
if ($cursor->isIndented() || $parserState->getLastMatchedBlockParser()->canHaveLazyContinuationLines()) {
return BlockStart::none();
}
$match = RegexHelper::matchFirst(
'/^\[\^([^\s^\]]+)\]\:(?:\s|$)/',
$cursor->getLine(),
$cursor->getNextNonSpacePosition()
);
if (! $match) {
return BlockStart::none();
}
$cursor->advanceToNextNonSpaceOrTab();
$cursor->advanceBy(\strlen($match[0]));
$str = $cursor->getRemainder();
\preg_replace('/^\[\^([^\s^\]]+)\]\:(?:\s|$)/', '', $str);
if (\preg_match('/^\[\^([^\s^\]]+)\]\:(?:\s|$)/', $match[0], $matches) !== 1) {
return BlockStart::none();
}
$reference = new Reference($matches[1], $matches[1], $matches[1]);
$footnoteParser = new FootnoteParser($reference);
return BlockStart::of($footnoteParser)->at($cursor);
}
}
PK �@]d�� 0 src/Extension/Footnote/Parser/FootnoteParser.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Parser;
use League\CommonMark\Extension\Footnote\Node\Footnote;
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;
use League\CommonMark\Reference\ReferenceInterface;
final class FootnoteParser extends AbstractBlockContinueParser
{
/** @psalm-readonly */
private Footnote $block;
/** @psalm-readonly-allow-private-mutation */
private ?int $indentation = null;
public function __construct(ReferenceInterface $reference)
{
$this->block = new Footnote($reference);
}
public function getBlock(): Footnote
{
return $this->block;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
if ($cursor->isBlank()) {
return BlockContinue::at($cursor);
}
if ($cursor->isIndented()) {
$this->indentation ??= $cursor->getIndent();
$cursor->advanceBy($this->indentation, true);
return BlockContinue::at($cursor);
}
return BlockContinue::none();
}
public function isContainer(): bool
{
return true;
}
public function canContain(AbstractBlock $childBlock): bool
{
return true;
}
}
PK �@]�zɎ� � 3 src/Extension/Footnote/Parser/FootnoteRefParser.phpnu �[��� <?php
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
* (c) Rezo Zero / Ambroise Maupate
*
* 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\Footnote\Parser;
use League\CommonMark\Extension\Footnote\Node\FootnoteRef;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Parser\Inline\InlineParserMatch;
use League\CommonMark\Parser\InlineParserContext;
use League\CommonMark\Reference\Reference;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class FootnoteRefParser implements InlineParserInterface, ConfigurationAwareInterface
{
private ConfigurationInterface $config;
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::regex('\[\^([^\s\]]+)\]');
}
public function parse(InlineParserContext $inlineContext): bool
{
$inlineContext->getCursor()->advanceBy($inlineContext->getFullMatchLength());
[$label] = $inlineContext->getSubMatches();
$inlineContext->getContainer()->appendChild(new FootnoteRef($this->createReference($label)));
return true;
}
private function createReference(string $label): Reference
{
return new Reference(
$label,
'#' . $this->config->get('footnote/footnote_id_prefix') . $label,
$label
);
}
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
}
PK �@]���c c $ src/Extension/ExtensionInterface.phpnu �[��� <?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;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
interface ExtensionInterface
{
public function register(EnvironmentBuilderInterface $environment): void;
}
PK �@]��l � � 6 src/Extension/DescriptionList/Node/DescriptionTerm.phpnu �[��� <?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\DescriptionList\Node;
use League\CommonMark\Node\Block\AbstractBlock;
class DescriptionTerm extends AbstractBlock
{
}
PK �@]x��� � 6 src/Extension/DescriptionList/Node/DescriptionList.phpnu �[��� <?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\DescriptionList\Node;
use League\CommonMark\Node\Block\AbstractBlock;
class DescriptionList extends AbstractBlock
{
}
PK �@]_>X�C C 2 src/Extension/DescriptionList/Node/Description.phpnu �[��� <?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\DescriptionList\Node;
use League\CommonMark\Node\Block\AbstractBlock;
use League\CommonMark\Node\Block\TightBlockInterface;
class Description extends AbstractBlock implements TightBlockInterface
{
private bool $tight;
public function __construct(bool $tight = false)
{
parent::__construct();
$this->tight = $tight;
}
public function isTight(): bool
{
return $this->tight;
}
public function setTight(bool $tight): void
{
$this->tight = $tight;
}
}
PK �@]#�_�� � ? src/Extension/DescriptionList/Event/LooseDescriptionHandler.phpnu �[��� <?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\DescriptionList\Event;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\DescriptionList\Node\Description;
use League\CommonMark\Extension\DescriptionList\Node\DescriptionList;
use League\CommonMark\Extension\DescriptionList\Node\DescriptionTerm;
use League\CommonMark\Node\Block\Paragraph;
use League\CommonMark\Node\Inline\Newline;
use League\CommonMark\Node\NodeIterator;
final class LooseDescriptionHandler
{
public function __invoke(DocumentParsedEvent $event): void
{
foreach ($event->getDocument()->iterator(NodeIterator::FLAG_BLOCKS_ONLY) as $description) {
if (! $description instanceof Description) {
continue;
}
// Does this description need to be added to a list?
if (! $description->parent() instanceof DescriptionList) {
$list = new DescriptionList();
// Taking any preceding paragraphs with it
if (($paragraph = $description->previous()) instanceof Paragraph) {
$list->appendChild($paragraph);
}
$description->replaceWith($list);
$list->appendChild($description);
}
// Is this description preceded by a paragraph that should really be a term?
if (! (($paragraph = $description->previous()) instanceof Paragraph)) {
continue;
}
// Convert the paragraph into one or more terms
$term = new DescriptionTerm();
$paragraph->replaceWith($term);
foreach ($paragraph->children() as $child) {
if ($child instanceof Newline) {
$newTerm = new DescriptionTerm();
$term->insertAfter($newTerm);
$term = $newTerm;
continue;
}
$term->appendChild($child);
}
}
}
}
PK �@]�d�C� � H src/Extension/DescriptionList/Event/ConsecutiveDescriptionListMerger.phpnu �[��� <?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\DescriptionList\Event;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\DescriptionList\Node\DescriptionList;
use League\CommonMark\Node\NodeIterator;
final class ConsecutiveDescriptionListMerger
{
public function __invoke(DocumentParsedEvent $event): void
{
foreach ($event->getDocument()->iterator(NodeIterator::FLAG_BLOCKS_ONLY) as $node) {
if (! $node instanceof DescriptionList) {
continue;
}
if (! ($prev = $node->previous()) instanceof DescriptionList) {
continue;
}
// There's another description list behind this one; merge the current one into that
foreach ($node->children() as $child) {
$prev->appendChild($child);
}
$node->detach();
}
}
}
PK �@]c�0�o o : src/Extension/DescriptionList/DescriptionListExtension.phpnu �[��� <?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\DescriptionList;
use League\CommonMark\Environment\EnvironmentBuilderInterface;
use League\CommonMark\Event\DocumentParsedEvent;
use League\CommonMark\Extension\DescriptionList\Event\ConsecutiveDescriptionListMerger;
use League\CommonMark\Extension\DescriptionList\Event\LooseDescriptionHandler;
use League\CommonMark\Extension\DescriptionList\Node\Description;
use League\CommonMark\Extension\DescriptionList\Node\DescriptionList;
use League\CommonMark\Extension\DescriptionList\Node\DescriptionTerm;
use League\CommonMark\Extension\DescriptionList\Parser\DescriptionStartParser;
use League\CommonMark\Extension\DescriptionList\Renderer\DescriptionListRenderer;
use League\CommonMark\Extension\DescriptionList\Renderer\DescriptionRenderer;
use League\CommonMark\Extension\DescriptionList\Renderer\DescriptionTermRenderer;
use League\CommonMark\Extension\ExtensionInterface;
final class DescriptionListExtension implements ExtensionInterface
{
public function register(EnvironmentBuilderInterface $environment): void
{
$environment->addBlockStartParser(new DescriptionStartParser());
$environment->addEventListener(DocumentParsedEvent::class, new LooseDescriptionHandler(), 1001);
$environment->addEventListener(DocumentParsedEvent::class, new ConsecutiveDescriptionListMerger(), 1000);
$environment->addRenderer(DescriptionList::class, new DescriptionListRenderer());
$environment->addRenderer(DescriptionTerm::class, new DescriptionTermRenderer());
$environment->addRenderer(Description::class, new DescriptionRenderer());
}
}
PK �@]Zp�w w B src/Extension/DescriptionList/Renderer/DescriptionListRenderer.phpnu �[��� <?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\DescriptionList\Renderer;
use League\CommonMark\Extension\DescriptionList\Node\DescriptionList;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlElement;
final class DescriptionListRenderer implements NodeRendererInterface
{
/**
* @param DescriptionList $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): HtmlElement
{
DescriptionList::assertInstanceOf($node);
$separator = $childRenderer->getBlockSeparator();
return new HtmlElement('dl', [], $separator . $childRenderer->renderNodes($node->children()) . $separator);
}
}
PK �@]��V�" " B src/Extension/DescriptionList/Renderer/DescriptionTermRenderer.phpnu �[��� <?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\DescriptionList\Renderer;
use League\CommonMark\Extension\DescriptionList\Node\DescriptionTerm;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlElement;
final class DescriptionTermRenderer implements NodeRendererInterface
{
/**
* @param DescriptionTerm $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
DescriptionTerm::assertInstanceOf($node);
return new HtmlElement('dt', [], $childRenderer->renderNodes($node->children()));
}
}
PK �@]��H! > src/Extension/DescriptionList/Renderer/DescriptionRenderer.phpnu �[��� <?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\DescriptionList\Renderer;
use League\CommonMark\Extension\DescriptionList\Node\Description;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlElement;
final class DescriptionRenderer implements NodeRendererInterface
{
/**
* @param Description $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): \Stringable
{
Description::assertInstanceOf($node);
return new HtmlElement('dd', [], $childRenderer->renderNodes($node->children()));
}
}
PK �@]���x� � F src/Extension/DescriptionList/Parser/DescriptionListContinueParser.phpnu �[��� <?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\Extension\DescriptionList\Parser;
use League\CommonMark\Extension\DescriptionList\Node\Description;
use League\CommonMark\Extension\DescriptionList\Node\DescriptionList;
use League\CommonMark\Extension\DescriptionList\Node\DescriptionTerm;
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 DescriptionListContinueParser extends AbstractBlockContinueParser
{
private DescriptionList $block;
public function __construct()
{
$this->block = new DescriptionList();
}
public function getBlock(): DescriptionList
{
return $this->block;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
return BlockContinue::at($cursor);
}
public function isContainer(): bool
{
return true;
}
public function canContain(AbstractBlock $childBlock): bool
{
return $childBlock instanceof DescriptionTerm || $childBlock instanceof Description;
}
}
PK �@]9۞� F src/Extension/DescriptionList/Parser/DescriptionTermContinueParser.phpnu �[��� <?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\DescriptionList\Parser;
use League\CommonMark\Extension\DescriptionList\Node\DescriptionTerm;
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;
final class DescriptionTermContinueParser extends AbstractBlockContinueParser implements BlockContinueParserWithInlinesInterface
{
private DescriptionTerm $block;
private string $term;
public function __construct(string $term)
{
$this->block = new DescriptionTerm();
$this->term = $term;
}
public function getBlock(): DescriptionTerm
{
return $this->block;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
return BlockContinue::finished();
}
public function parseInlines(InlineParserEngineInterface $inlineParser): void
{
if ($this->term !== '') {
$inlineParser->parse($this->term, $this->block);
}
}
}
PK �@]`H� � ? src/Extension/DescriptionList/Parser/DescriptionStartParser.phpnu �[��� <?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\Extension\DescriptionList\Parser;
use League\CommonMark\Extension\DescriptionList\Node\Description;
use League\CommonMark\Node\Block\Paragraph;
use League\CommonMark\Parser\Block\BlockStart;
use League\CommonMark\Parser\Block\BlockStartParserInterface;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Parser\MarkdownParserStateInterface;
final class DescriptionStartParser implements BlockStartParserInterface
{
public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
{
if ($cursor->isIndented()) {
return BlockStart::none();
}
$cursor->advanceToNextNonSpaceOrTab();
if ($cursor->match('/^:[ \t]+/') === null) {
return BlockStart::none();
}
$terms = $parserState->getParagraphContent();
$activeBlock = $parserState->getActiveBlockParser()->getBlock();
if ($terms !== null && $terms !== '') {
// New description; tight; term(s) sitting in pending block that we will replace
return BlockStart::of(...[new DescriptionListContinueParser()], ...self::splitTerms($terms), ...[new DescriptionContinueParser(true, $cursor->getPosition())])
->at($cursor)
->replaceActiveBlockParser();
}
if ($activeBlock instanceof Paragraph && $activeBlock->parent() instanceof Description) {
// Additional description in the same list as the parent description
return BlockStart::of(new DescriptionContinueParser(true, $cursor->getPosition()))->at($cursor);
}
if ($activeBlock->lastChild() instanceof Paragraph) {
// New description; loose; term(s) sitting in previous closed paragraph block
return BlockStart::of(new DescriptionContinueParser(false, $cursor->getPosition()))->at($cursor);
}
// No preceding terms
return BlockStart::none();
}
/**
* @return array<int, DescriptionTermContinueParser>
*/
private static function splitTerms(string $terms): array
{
$ret = [];
foreach (\explode("\n", $terms) as $term) {
$ret[] = new DescriptionTermContinueParser($term);
}
return $ret;
}
}
PK �@]�K��\ \ B src/Extension/DescriptionList/Parser/DescriptionContinueParser.phpnu �[��� <?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\Extension\DescriptionList\Parser;
use League\CommonMark\Extension\DescriptionList\Node\Description;
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 DescriptionContinueParser extends AbstractBlockContinueParser
{
private Description $block;
private int $indentation;
public function __construct(bool $tight, int $indentation)
{
$this->block = new Description($tight);
$this->indentation = $indentation;
}
public function getBlock(): Description
{
return $this->block;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
if ($cursor->isBlank()) {
if ($this->block->firstChild() === null) {
// Blank line after empty item
return BlockContinue::none();
}
$cursor->advanceToNextNonSpaceOrTab();
return BlockContinue::at($cursor);
}
if ($cursor->getIndent() >= $this->indentation) {
$cursor->advanceBy($this->indentation, true);
return BlockContinue::at($cursor);
}
return BlockContinue::none();
}
public function isContainer(): bool
{
return true;
}
public function canContain(AbstractBlock $childBlock): bool
{
return true;
}
}
PK �@]�i src/ConverterInterface.phpnu �[��� <?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;
use League\CommonMark\Exception\CommonMarkException;
use League\CommonMark\Output\RenderedContentInterface;
use League\Config\Exception\ConfigurationExceptionInterface;
/**
* Interface for a service which converts content from one format (like Markdown) to another (like HTML).
*/
interface ConverterInterface
{
/**
* @throws CommonMarkException
* @throws ConfigurationExceptionInterface
*/
public function convert(string $input): RenderedContentInterface;
}
PK �@]ԧ7�L L ' src/Output/RenderedContentInterface.phpnu �[��� <?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\Output;
use League\CommonMark\Node\Block\Document;
interface RenderedContentInterface extends \Stringable
{
/**
* @psalm-mutation-free
*/
public function getDocument(): Document;
/**
* @psalm-mutation-free
*/
public function getContent(): string;
}
PK �@]�?� � src/Output/RenderedContent.phpnu �[��� <?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\Output;
use League\CommonMark\Node\Block\Document;
class RenderedContent implements RenderedContentInterface, \Stringable
{
/** @psalm-readonly */
private Document $document;
/** @psalm-readonly */
private string $content;
public function __construct(Document $document, string $content)
{
$this->document = $document;
$this->content = $content;
}
public function getDocument(): Document
{
return $this->document;
}
public function getContent(): string
{
return $this->content;
}
/**
* @psalm-mutation-free
*/
public function __toString(): string
{
return $this->content;
}
}
PK �@]�L�B� � * src/Exception/InvalidArgumentException.phpnu �[��� <?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\Exception;
class InvalidArgumentException extends \InvalidArgumentException implements CommonMarkException
{
}
PK �@]���v� � src/Exception/LogicException.phpnu �[��� <?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\Exception;
class LogicException extends \LogicException implements CommonMarkException
{
}
PK �@] V�� � src/Exception/IOException.phpnu �[��� <?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\Exception;
class IOException extends \RuntimeException implements CommonMarkException
{
}
PK �@]�&D� � % src/Exception/CommonMarkException.phpnu �[��� <?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\Exception;
/**
* Marker interface for all exceptions thrown by this library.
*/
interface CommonMarkException extends \Throwable
{
}
PK �@]�]�w� � - src/Exception/UnexpectedEncodingException.phpnu �[��� <?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\Exception;
final class UnexpectedEncodingException extends \RuntimeException implements CommonMarkException
{
}
PK �@]��� � , src/Exception/MissingDependencyException.phpnu �[��� <?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\Exception;
class MissingDependencyException extends \RuntimeException implements CommonMarkException
{
}
PK �@]�
� � - src/Exception/AlreadyInitializedException.phpnu �[��� <?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\Exception;
class AlreadyInitializedException extends LogicException implements CommonMarkException
{
}
PK �@]��� � * src/Renderer/MarkdownRendererInterface.phpnu �[��� <?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\Renderer;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Output\RenderedContentInterface;
/**
* Renders a parsed Document AST
*
* @deprecated since 2.3; use {@link DocumentRendererInterface} instead
*/
interface MarkdownRendererInterface
{
/**
* Render the given Document node (and all of its children)
*/
public function renderDocument(Document $document): RenderedContentInterface;
}
PK �@]f*��� � + src/Renderer/ChildNodeRendererInterface.phpnu �[��� <?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\Renderer;
use League\CommonMark\Node\Node;
/**
* Renders multiple nodes by delegating to the individual node renderers and adding spacing where needed
*/
interface ChildNodeRendererInterface
{
/**
* @param Node[] $nodes
*/
public function renderNodes(iterable $nodes): string;
public function getBlockSeparator(): string;
public function getInnerSeparator(): string;
}
PK �@]�=; ; $ src/Renderer/Inline/TextRenderer.phpnu �[��� <?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\Renderer\Inline;
use League\CommonMark\Node\Inline\Text;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\Xml;
use League\CommonMark\Xml\XmlNodeRendererInterface;
final class TextRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param Text $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): string
{
Text::assertInstanceOf($node);
return Xml::escape($node->getLiteral());
}
public function getXmlTagName(Node $node): string
{
return 'text';
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@]�w��� � ' src/Renderer/Inline/NewlineRenderer.phpnu �[��� <?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\Renderer\Inline;
use League\CommonMark\Node\Inline\Newline;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Xml\XmlNodeRendererInterface;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
final class NewlineRenderer implements NodeRendererInterface, XmlNodeRendererInterface, ConfigurationAwareInterface
{
/** @psalm-readonly-allow-private-mutation */
private ConfigurationInterface $config;
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->config = $configuration;
}
/**
* @param Newline $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): string
{
Newline::assertInstanceOf($node);
if ($node->getType() === Newline::HARDBREAK) {
return "<br />\n";
}
return $this->config->get('renderer/soft_break');
}
/**
* @param Newline $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function getXmlTagName(Node $node): string
{
Newline::assertInstanceOf($node);
return $node->getType() === Newline::SOFTBREAK ? 'softbreak' : 'linebreak';
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
}
PK �@]�v�|� � ' src/Renderer/Block/DocumentRenderer.phpnu �[��� <?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\Renderer\Block;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Node\Node;
use League\CommonMark\Renderer\ChildNodeRendererInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Xml\XmlNodeRendererInterface;
final class DocumentRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param Document $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer): string
{
Document::assertInstanceOf($node);
$wholeDoc = $childRenderer->renderNodes($node->children());
return $wholeDoc === '' ? '' : $wholeDoc . "\n";
}
public function getXmlTagName(Node $node): string
{
return 'document';
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
return [
'xmlns' => 'http://commonmark.org/xml/1.0',
];
}
}
PK �@]����� � ( src/Renderer/Block/ParagraphRenderer.phpnu �[��� <?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\Renderer\Block;
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 ParagraphRenderer implements NodeRendererInterface, XmlNodeRendererInterface
{
/**
* @param Paragraph $node
*
* {@inheritDoc}
*
* @psalm-suppress MoreSpecificImplementedParamType
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer)
{
Paragraph::assertInstanceOf($node);
if ($this->inTightList($node)) {
return $childRenderer->renderNodes($node->children());
}
$attrs = $node->data->get('attributes');
return new HtmlElement('p', $attrs, $childRenderer->renderNodes($node->children()));
}
public function getXmlTagName(Node $node): string
{
return 'paragraph';
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
return [];
}
private function inTightList(Paragraph $node): bool
{
// Only check up to two (2) levels above this for tightness
$i = 2;
while (($node = $node->parent()) && $i--) {
if ($node instanceof TightBlockInterface) {
return $node->isTight();
}
}
return false;
}
}
PK �@]�:Qd� � * src/Renderer/DocumentRendererInterface.phpnu �[��� <?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\Renderer;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Output\RenderedContentInterface;
/**
* Renders a parsed Document AST
*/
interface DocumentRendererInterface extends MarkdownRendererInterface
{
/**
* Render the given Document node (and all of its children)
*/
public function renderDocument(Document $document): RenderedContentInterface;
}
PK �@]�@�ɥ � , src/Renderer/NoMatchingRendererException.phpnu �[��� <?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\Renderer;
use League\CommonMark\Exception\LogicException;
class NoMatchingRendererException extends LogicException
{
}
PK �@]�쓲� � src/Renderer/HtmlDecorator.phpnu �[��� <?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\Renderer;
use League\CommonMark\Node\Node;
use League\CommonMark\Util\HtmlElement;
final class HtmlDecorator implements NodeRendererInterface
{
private NodeRendererInterface $inner;
private string $tag;
/** @var array<string, string|string[]|bool> */
private array $attributes;
private bool $selfClosing;
/**
* @param array<string, string|string[]|bool> $attributes
*/
public function __construct(NodeRendererInterface $inner, string $tag, array $attributes = [], bool $selfClosing = false)
{
$this->inner = $inner;
$this->tag = $tag;
$this->attributes = $attributes;
$this->selfClosing = $selfClosing;
}
/**
* {@inheritDoc}
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer)
{
return new HtmlElement($this->tag, $this->attributes, $this->inner->render($node, $childRenderer), $this->selfClosing);
}
}
PK �@]�{5� � & src/Renderer/NodeRendererInterface.phpnu �[��� <?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\Renderer;
use League\CommonMark\Exception\InvalidArgumentException;
use League\CommonMark\Node\Node;
interface NodeRendererInterface
{
/**
* @return \Stringable|string|null
*
* @throws InvalidArgumentException if the wrong type of Node is provided
*/
public function render(Node $node, ChildNodeRendererInterface $childRenderer);
}
PK �@]5O�V5 5 src/Renderer/HtmlRenderer.phpnu �[��� <?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\Renderer;
use League\CommonMark\Environment\EnvironmentInterface;
use League\CommonMark\Event\DocumentPreRenderEvent;
use League\CommonMark\Event\DocumentRenderedEvent;
use League\CommonMark\Node\Block\AbstractBlock;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Node\Node;
use League\CommonMark\Output\RenderedContent;
use League\CommonMark\Output\RenderedContentInterface;
final class HtmlRenderer implements DocumentRendererInterface, ChildNodeRendererInterface
{
/** @psalm-readonly */
private EnvironmentInterface $environment;
public function __construct(EnvironmentInterface $environment)
{
$this->environment = $environment;
}
public function renderDocument(Document $document): RenderedContentInterface
{
$this->environment->dispatch(new DocumentPreRenderEvent($document, 'html'));
$output = new RenderedContent($document, (string) $this->renderNode($document));
$event = new DocumentRenderedEvent($output);
$this->environment->dispatch($event);
return $event->getOutput();
}
/**
* {@inheritDoc}
*/
public function renderNodes(iterable $nodes): string
{
$output = '';
$isFirstItem = true;
foreach ($nodes as $node) {
if (! $isFirstItem && $node instanceof AbstractBlock) {
$output .= $this->getBlockSeparator();
}
$output .= $this->renderNode($node);
$isFirstItem = false;
}
return $output;
}
/**
* @return \Stringable|string
*
* @throws NoMatchingRendererException
*/
private function renderNode(Node $node)
{
$renderers = $this->environment->getRenderersForClass(\get_class($node));
foreach ($renderers as $renderer) {
\assert($renderer instanceof NodeRendererInterface);
if (($result = $renderer->render($node, $this)) !== null) {
return $result;
}
}
throw new NoMatchingRendererException('Unable to find corresponding renderer for node type ' . \get_class($node));
}
public function getBlockSeparator(): string
{
return $this->environment->getConfiguration()->get('renderer/block_separator');
}
public function getInnerSeparator(): string
{
return $this->environment->getConfiguration()->get('renderer/inner_separator');
}
}
PK �@]!L�}/ }/ src/Parser/MarkdownParser.phpnu �[��� <?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 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<int, BlockContinueParserInterface>
*
* @psalm-readonly-allow-private-mutation
*/
private array $activeBlockParsers = [];
/**
* @var array<int, BlockContinueParserWithInlinesInterface>
*
* @psalm-readonly-allow-private-mutation
*/
private array $closedBlockParsers = [];
public function __construct(EnvironmentInterface $environment)
{
$this->environment = $environment;
}
private function initialize(): void
{
$this->referenceMap = new ReferenceMap();
$this->lineNumber = 0;
$this->activeBlockParsers = [];
$this->closedBlockParsers = [];
$this->maxNestingLevel = $this->environment->getConfiguration()->get('max_nesting_level');
}
/**
* @throws CommonMarkException
*/
public function parse(string $input): Document
{
$this->initialize();
$documentParser = new DocumentBlockParser($this->referenceMap);
$this->activateBlockParser($documentParser);
$preParsedEvent = new DocumentPreParsedEvent($documentParser->getBlock(), new MarkdownInput($input));
$this->environment->dispatch($preParsedEvent);
$markdownInput = $preParsedEvent->getMarkdown();
foreach ($markdownInput->getLines() as $lineNumber => $line) {
$this->lineNumber = $lineNumber;
$this->parseLine($line);
}
// finalizeAndProcess
$this->closeBlockParsers(\count($this->activeBlockParsers), $this->lineNumber);
$this->processInlines();
$this->environment->dispatch(new DocumentParsedEvent($documentParser->getBlock()));
return $documentParser->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->cursor = new Cursor($line);
$matches = $this->parseBlockContinuation();
if ($matches === null) {
return;
}
$unmatchedBlocks = \count($this->activeBlockParsers) - $matches;
$blockParser = $this->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->getBlock() instanceof Paragraph || $blockParser->isContainer();
while ($tryBlockStarts) {
// this is a little performance optimization
if ($this->cursor->isBlank()) {
$this->cursor->advanceToEnd();
break;
}
if ($blockParser->getBlock()->getDepth() >= $this->maxNestingLevel) {
break;
}
$blockStart = $this->findBlockStart($blockParser);
if ($blockStart === null || $blockStart->isAborting()) {
$this->cursor->advanceToNextNonSpaceOrTab();
break;
}
if (($state = $blockStart->getCursorState()) !== null) {
$this->cursor->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 > 0) {
$this->closeBlockParsers($unmatchedBlocks, $this->lineNumber - 1);
$unmatchedBlocks = 0;
}
if ($blockStart->isReplaceActiveBlockParser()) {
$this->prepareActiveBlockParserForReplacement();
}
foreach ($blockStart->getBlockParsers() as $newBlockParser) {
$blockParser = $this->addChild($newBlockParser);
$tryBlockStarts = $newBlockParser->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 && ! $this->cursor->isBlank() && $this->getActiveBlockParser()->canHaveLazyContinuationLines()) {
$this->getActiveBlockParser()->addLine($this->cursor->getRemainder());
} else {
// finalize any blocks not matched
if ($unmatchedBlocks > 0) {
$this->closeBlockParsers($unmatchedBlocks, $this->lineNumber);
}
if (! $blockParser->isContainer()) {
$this->getActiveBlockParser()->addLine($this->cursor->getRemainder());
} elseif (! $this->cursor->isBlank()) {
$this->addChild(new ParagraphParser());
$this->getActiveBlockParser()->addLine($this->cursor->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 < \count($this->activeBlockParsers); $i++) {
$blockParser = $this->activeBlockParsers[$i];
$blockContinue = $blockParser->tryContinue(clone $this->cursor, $this->getActiveBlockParser());
if ($blockContinue === null) {
break;
}
if ($blockContinue->isFinalize()) {
$this->closeBlockParsers(\count($this->activeBlockParsers) - $i, $this->lineNumber);
return null;
}
if (($state = $blockContinue->getCursorState()) !== null) {
$this->cursor->restoreState($state);
}
$matches++;
}
return $matches;
}
private function findBlockStart(BlockContinueParserInterface $lastMatchedBlockParser): ?BlockStart
{
$matchedBlockParser = new MarkdownParserState($this->getActiveBlockParser(), $lastMatchedBlockParser);
foreach ($this->environment->getBlockStartParsers() as $blockStartParser) {
\assert($blockStartParser instanceof BlockStartParserInterface);
if (($result = $blockStartParser->tryStart(clone $this->cursor, $matchedBlockParser)) !== null) {
return $result;
}
}
return null;
}
private function closeBlockParsers(int $count, int $endLineNumber): void
{
for ($i = 0; $i < $count; $i++) {
$blockParser = $this->deactivateBlockParser();
$this->finalize($blockParser, $endLineNumber);
// phpcs:disable SlevomatCodingStandard.ControlStructures.EarlyExit.EarlyExitNotUsed
if ($blockParser instanceof BlockContinueParserWithInlinesInterface) {
// Remember for inline parsing
$this->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->updateReferenceMap($blockParser->getReferences());
}
$blockParser->getBlock()->setEndLine($endLineNumber);
$blockParser->closeBlock();
}
/**
* Walk through a block & children recursively, parsing string content into inline content where appropriate.
*/
private function processInlines(): void
{
$p = new InlineParserEngine($this->environment, $this->referenceMap);
foreach ($this->closedBlockParsers as $blockParser) {
$blockParser->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): BlockContinueParserInterface
{
$blockParser->getBlock()->setStartLine($this->lineNumber);
while (! $this->getActiveBlockParser()->canContain($blockParser->getBlock())) {
$this->closeBlockParsers(1, $this->lineNumber - 1);
}
$this->getActiveBlockParser()->getBlock()->appendChild($blockParser->getBlock());
$this->activateBlockParser($blockParser);
return $blockParser;
}
private function activateBlockParser(BlockContinueParserInterface $blockParser): void
{
$this->activeBlockParsers[] = $blockParser;
}
/**
* @throws ParserLogicException
*/
private function deactivateBlockParser(): BlockContinueParserInterface
{
$popped = \array_pop($this->activeBlockParsers);
if ($popped === null) {
throw new ParserLogicException('The last block parser should not be deactivated');
}
return $popped;
}
private function prepareActiveBlockParserForReplacement(): void
{
// Note that we don't want to parse inlines or finalize this block, as it's getting replaced.
$old = $this->deactivateBlockParser();
if ($old instanceof ParagraphParser) {
$this->updateReferenceMap($old->getReferences());
}
$old->getBlock()->detach();
}
/**
* @param ReferenceInterface[] $references
*/
private function updateReferenceMap(iterable $references): void
{
foreach ($references as $reference) {
if (! $this->referenceMap->contains($reference->getLabel())) {
$this->referenceMap->add($reference);
}
}
}
/**
* @throws ParserLogicException
*/
public function getActiveBlockParser(): BlockContinueParserInterface
{
$active = \end($this->activeBlockParsers);
if ($active === false) {
throw new ParserLogicException('No active block parsers are available');
}
return $active;
}
}
PK �@]��O8�7 �7 src/Parser/Cursor.phpnu �[��� <?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\Parser;
use League\CommonMark\Exception\UnexpectedEncodingException;
class Cursor
{
public const INDENT_LEVEL = 4;
/** @psalm-readonly */
private string $line;
/** @psalm-readonly */
private int $length;
/**
* @var int
*
* It's possible for this to be 1 char past the end, meaning we've parsed all chars and have
* reached the end. In this state, any character-returning method MUST return null.
*/
private int $currentPosition = 0;
private int $column = 0;
private int $indent = 0;
private int $previousPosition = 0;
private ?int $nextNonSpaceCache = null;
private bool $partiallyConsumedTab = false;
/**
* @var int|false
*
* @psalm-readonly
*/
private $lastTabPosition;
/** @psalm-readonly */
private bool $isMultibyte;
/** @var array<int, string> */
private array $charCache = [];
/**
* @param string $line The line being parsed (ASCII or UTF-8)
*/
public function __construct(string $line)
{
if (! \mb_check_encoding($line, 'UTF-8')) {
throw new UnexpectedEncodingException('Unexpected encoding - UTF-8 or ASCII was expected');
}
$this->line = $line;
$this->length = \mb_strlen($line, 'UTF-8') ?: 0;
$this->isMultibyte = $this->length !== \strlen($line);
$this->lastTabPosition = $this->isMultibyte ? \mb_strrpos($line, "\t", 0, 'UTF-8') : \strrpos($line, "\t");
}
/**
* Returns the position of the next character which is not a space (or tab)
*/
public function getNextNonSpacePosition(): int
{
if ($this->nextNonSpaceCache !== null) {
return $this->nextNonSpaceCache;
}
if ($this->currentPosition >= $this->length) {
return $this->length;
}
$cols = $this->column;
for ($i = $this->currentPosition; $i < $this->length; $i++) {
// This if-else was copied out of getCharacter() for performance reasons
if ($this->isMultibyte) {
$c = $this->charCache[$i] ??= \mb_substr($this->line, $i, 1, 'UTF-8');
} else {
$c = $this->line[$i];
}
if ($c === ' ') {
$cols++;
} elseif ($c === "\t") {
$cols += 4 - ($cols % 4);
} else {
break;
}
}
$this->indent = $cols - $this->column;
return $this->nextNonSpaceCache = $i;
}
/**
* Returns the next character which isn't a space (or tab)
*/
public function getNextNonSpaceCharacter(): ?string
{
$index = $this->getNextNonSpacePosition();
if ($index >= $this->length) {
return null;
}
if ($this->isMultibyte) {
return $this->charCache[$index] ??= \mb_substr($this->line, $index, 1, 'UTF-8');
}
return $this->line[$index];
}
/**
* Calculates the current indent (number of spaces after current position)
*/
public function getIndent(): int
{
if ($this->nextNonSpaceCache === null) {
$this->getNextNonSpacePosition();
}
return $this->indent;
}
/**
* Whether the cursor is indented to INDENT_LEVEL
*/
public function isIndented(): bool
{
if ($this->nextNonSpaceCache === null) {
$this->getNextNonSpacePosition();
}
return $this->indent >= self::INDENT_LEVEL;
}
public function getCharacter(?int $index = null): ?string
{
if ($index === null) {
$index = $this->currentPosition;
}
// Index out-of-bounds, or we're at the end
if ($index < 0 || $index >= $this->length) {
return null;
}
if ($this->isMultibyte) {
return $this->charCache[$index] ??= \mb_substr($this->line, $index, 1, 'UTF-8');
}
return $this->line[$index];
}
/**
* Slightly-optimized version of getCurrent(null)
*/
public function getCurrentCharacter(): ?string
{
if ($this->currentPosition >= $this->length) {
return null;
}
if ($this->isMultibyte) {
return $this->charCache[$this->currentPosition] ??= \mb_substr($this->line, $this->currentPosition, 1, 'UTF-8');
}
return $this->line[$this->currentPosition];
}
/**
* Returns the next character (or null, if none) without advancing forwards
*/
public function peek(int $offset = 1): ?string
{
return $this->getCharacter($this->currentPosition + $offset);
}
/**
* Whether the remainder is blank
*/
public function isBlank(): bool
{
return $this->nextNonSpaceCache === $this->length || $this->getNextNonSpacePosition() === $this->length;
}
/**
* Move the cursor forwards
*/
public function advance(): void
{
$this->advanceBy(1);
}
/**
* Move the cursor forwards
*
* @param int $characters Number of characters to advance by
* @param bool $advanceByColumns Whether to advance by columns instead of spaces
*/
public function advanceBy(int $characters, bool $advanceByColumns = false): void
{
$this->previousPosition = $this->currentPosition;
$this->nextNonSpaceCache = null;
if ($this->currentPosition >= $this->length || $characters === 0) {
return;
}
// Optimization to avoid tab handling logic if we have no tabs
if ($this->lastTabPosition === false || $this->currentPosition > $this->lastTabPosition) {
$length = \min($characters, $this->length - $this->currentPosition);
$this->partiallyConsumedTab = false;
$this->currentPosition += $length;
$this->column += $length;
return;
}
$nextFewChars = $this->isMultibyte ?
\mb_substr($this->line, $this->currentPosition, $characters, 'UTF-8') :
\substr($this->line, $this->currentPosition, $characters);
if ($characters === 1) {
$asArray = [$nextFewChars];
} elseif ($this->isMultibyte) {
/** @var string[] $asArray */
$asArray = \mb_str_split($nextFewChars, 1, 'UTF-8');
} else {
$asArray = \str_split($nextFewChars);
}
foreach ($asArray as $c) {
if ($c === "\t") {
$charsToTab = 4 - ($this->column % 4);
if ($advanceByColumns) {
$this->partiallyConsumedTab = $charsToTab > $characters;
$charsToAdvance = $charsToTab > $characters ? $characters : $charsToTab;
$this->column += $charsToAdvance;
$this->currentPosition += $this->partiallyConsumedTab ? 0 : 1;
$characters -= $charsToAdvance;
} else {
$this->partiallyConsumedTab = false;
$this->column += $charsToTab;
$this->currentPosition++;
$characters--;
}
} else {
$this->partiallyConsumedTab = false;
$this->currentPosition++;
$this->column++;
$characters--;
}
if ($characters <= 0) {
break;
}
}
}
/**
* Advances the cursor by a single space or tab, if present
*/
public function advanceBySpaceOrTab(): bool
{
$character = $this->getCurrentCharacter();
if ($character === ' ' || $character === "\t") {
$this->advanceBy(1, true);
return true;
}
return false;
}
/**
* Parse zero or more space/tab characters
*
* @return int Number of positions moved
*/
public function advanceToNextNonSpaceOrTab(): int
{
$newPosition = $this->nextNonSpaceCache ?? $this->getNextNonSpacePosition();
if ($newPosition === $this->currentPosition) {
return 0;
}
$this->advanceBy($newPosition - $this->currentPosition);
$this->partiallyConsumedTab = false;
// We've just advanced to where that non-space is,
// so any subsequent calls to find the next one will
// always return the current position.
$this->nextNonSpaceCache = $this->currentPosition;
$this->indent = 0;
return $this->currentPosition - $this->previousPosition;
}
/**
* Parse zero or more space characters, including at most one newline.
*
* Tab characters are not parsed with this function.
*
* @return int Number of positions moved
*/
public function advanceToNextNonSpaceOrNewline(): int
{
$remainder = $this->getRemainder();
// Optimization: Avoid the regex if we know there are no spaces or newlines
if ($remainder === '' || ($remainder[0] !== ' ' && $remainder[0] !== "\n")) {
$this->previousPosition = $this->currentPosition;
return 0;
}
$matches = [];
\preg_match('/^ *(?:\n *)?/', $remainder, $matches, \PREG_OFFSET_CAPTURE);
// [0][0] contains the matched text
// [0][1] contains the index of that match
$increment = $matches[0][1] + \strlen($matches[0][0]);
$this->advanceBy($increment);
return $this->currentPosition - $this->previousPosition;
}
/**
* Move the position to the very end of the line
*
* @return int The number of characters moved
*/
public function advanceToEnd(): int
{
$this->previousPosition = $this->currentPosition;
$this->nextNonSpaceCache = null;
$this->currentPosition = $this->length;
return $this->currentPosition - $this->previousPosition;
}
public function getRemainder(): string
{
if ($this->currentPosition >= $this->length) {
return '';
}
$prefix = '';
$position = $this->currentPosition;
if ($this->partiallyConsumedTab) {
$position++;
$charsToTab = 4 - ($this->column % 4);
$prefix = \str_repeat(' ', $charsToTab);
}
$subString = $this->isMultibyte ?
\mb_substr($this->line, $position, null, 'UTF-8') :
\substr($this->line, $position);
return $prefix . $subString;
}
public function getLine(): string
{
return $this->line;
}
public function isAtEnd(): bool
{
return $this->currentPosition >= $this->length;
}
/**
* Try to match a regular expression
*
* Returns the matching text and advances to the end of that match
*
* @psalm-param non-empty-string $regex
*/
public function match(string $regex): ?string
{
$subject = $this->getRemainder();
if (! \preg_match($regex, $subject, $matches, \PREG_OFFSET_CAPTURE)) {
return null;
}
// $matches[0][0] contains the matched text
// $matches[0][1] contains the index of that match
if ($this->isMultibyte) {
// PREG_OFFSET_CAPTURE always returns the byte offset, not the char offset, which is annoying
$offset = \mb_strlen(\substr($subject, 0, $matches[0][1]), 'UTF-8');
$matchLength = \mb_strlen($matches[0][0], 'UTF-8');
} else {
$offset = $matches[0][1];
$matchLength = \strlen($matches[0][0]);
}
// [0][0] contains the matched text
// [0][1] contains the index of that match
$this->advanceBy($offset + $matchLength);
return $matches[0][0];
}
/**
* Encapsulates the current state of this cursor in case you need to rollback later.
*
* WARNING: Do not parse or use the return value for ANYTHING except for
* passing it back into restoreState(), as the number of values and their
* contents may change in any future release without warning.
*/
public function saveState(): CursorState
{
return new CursorState([
$this->currentPosition,
$this->previousPosition,
$this->nextNonSpaceCache,
$this->indent,
$this->column,
$this->partiallyConsumedTab,
]);
}
/**
* Restore the cursor to a previous state.
*
* Pass in the value previously obtained by calling saveState().
*/
public function restoreState(CursorState $state): void
{
[
$this->currentPosition,
$this->previousPosition,
$this->nextNonSpaceCache,
$this->indent,
$this->column,
$this->partiallyConsumedTab,
] = $state->toArray();
}
public function getPosition(): int
{
return $this->currentPosition;
}
public function getPreviousText(): string
{
if ($this->isMultibyte) {
return \mb_substr($this->line, $this->previousPosition, $this->currentPosition - $this->previousPosition, 'UTF-8');
}
return \substr($this->line, $this->previousPosition, $this->currentPosition - $this->previousPosition);
}
public function getSubstring(int $start, ?int $length = null): string
{
if ($this->isMultibyte) {
return \mb_substr($this->line, $start, $length, 'UTF-8');
}
if ($length !== null) {
return \substr($this->line, $start, $length);
}
return \substr($this->line, $start);
}
public function getColumn(): int
{
return $this->column;
}
}
PK �@]�G_ ! src/Parser/InlineParserEngine.phpnu �[��� <?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\Parser;
use League\CommonMark\Environment\EnvironmentInterface;
use League\CommonMark\Node\Block\AbstractBlock;
use League\CommonMark\Node\Inline\AdjacentTextMerger;
use League\CommonMark\Node\Inline\Text;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Reference\ReferenceMapInterface;
/**
* @internal
*/
final class InlineParserEngine implements InlineParserEngineInterface
{
/** @psalm-readonly */
private EnvironmentInterface $environment;
/** @psalm-readonly */
private ReferenceMapInterface $referenceMap;
/**
* @var array<int, InlineParserInterface|string|bool>
* @psalm-var list<array{0: InlineParserInterface, 1: non-empty-string, 2: bool}>
* @phpstan-var array<int, array{0: InlineParserInterface, 1: non-empty-string, 2: bool}>
*/
private array $parsers = [];
public function __construct(EnvironmentInterface $environment, ReferenceMapInterface $referenceMap)
{
$this->environment = $environment;
$this->referenceMap = $referenceMap;
foreach ($environment->getInlineParsers() as $parser) {
\assert($parser instanceof InlineParserInterface);
$regex = $parser->getMatchDefinition()->getRegex();
$this->parsers[] = [$parser, $regex, \strlen($regex) !== \mb_strlen($regex, 'UTF-8')];
}
}
public function parse(string $contents, AbstractBlock $block): void
{
$contents = \trim($contents);
$cursor = new Cursor($contents);
$inlineParserContext = new InlineParserContext($cursor, $block, $this->referenceMap);
// Have all parsers look at the line to determine what they might want to parse and what positions they exist at
foreach ($this->matchParsers($contents) as $matchPosition => $parsers) {
$currentPosition = $cursor->getPosition();
// We've already gone past this point
if ($currentPosition > $matchPosition) {
continue;
}
// We've skipped over some uninteresting text that should be added as a plain text node
if ($currentPosition < $matchPosition) {
$cursor->advanceBy($matchPosition - $currentPosition);
$this->addPlainText($cursor->getPreviousText(), $block);
}
// We're now at a potential start - see which of the current parsers can handle it
$parsed = false;
foreach ($parsers as [$parser, $matches]) {
\assert($parser instanceof InlineParserInterface);
if ($parser->parse($inlineParserContext->withMatches($matches))) {
// A parser has successfully handled the text at the given position; don't consider any others at this position
$parsed = true;
break;
}
}
if ($parsed) {
continue;
}
// Despite potentially being interested, nothing actually parsed text here, so add the current character and continue onwards
$this->addPlainText((string) $cursor->getCurrentCharacter(), $block);
$cursor->advance();
}
// Add any remaining text that wasn't parsed
if (! $cursor->isAtEnd()) {
$this->addPlainText($cursor->getRemainder(), $block);
}
// Process any delimiters that were found
$delimiterStack = $inlineParserContext->getDelimiterStack();
$delimiterStack->processDelimiters(null, $this->environment->getDelimiterProcessors());
$delimiterStack->removeAll();
// Combine adjacent text notes into one
AdjacentTextMerger::mergeChildNodes($block);
}
private function addPlainText(string $text, AbstractBlock $container): void
{
$lastInline = $container->lastChild();
if ($lastInline instanceof Text && ! $lastInline->data->has('delim')) {
$lastInline->append($text);
} else {
$container->appendChild(new Text($text));
}
}
/**
* Given the current line, ask all the parsers which parts of the text they would be interested in parsing.
*
* The resulting array provides a list of character positions, which parsers are interested in trying to parse
* the text at those points, and (for convenience/optimization) what the matching text happened to be.
*
* @return array<array<int, InlineParserInterface|string>>
*
* @psalm-return array<int, list<array{0: InlineParserInterface, 1: non-empty-array<string>}>>
*
* @phpstan-return array<int, array<int, array{0: InlineParserInterface, 1: non-empty-array<string>}>>
*/
private function matchParsers(string $contents): array
{
$contents = \trim($contents);
$isMultibyte = ! \mb_check_encoding($contents, 'ASCII');
$ret = [];
foreach ($this->parsers as [$parser, $regex, $isRegexMultibyte]) {
if ($isMultibyte || $isRegexMultibyte) {
$regex .= 'u';
}
// See if the parser's InlineParserMatch regex matched against any part of the string
if (! \preg_match_all($regex, $contents, $matches, \PREG_OFFSET_CAPTURE | \PREG_SET_ORDER)) {
continue;
}
// For each part that matched...
foreach ($matches as $match) {
if ($isMultibyte) {
// PREG_OFFSET_CAPTURE always returns the byte offset, not the char offset, which is annoying
$offset = \mb_strlen(\substr($contents, 0, $match[0][1]), 'UTF-8');
} else {
$offset = \intval($match[0][1]);
}
// Remove the offsets, keeping only the matched text
$m = \array_column($match, 0);
if ($m === []) {
continue;
}
// Add this match to the list of character positions to stop at
$ret[$offset][] = [$parser, $m];
}
}
// Sort matches by position so we visit them in order
\ksort($ret);
return $ret;
}
}
PK �@]���, , # src/Parser/Inline/NewlineParser.phpnu �[��� <?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\Parser\Inline;
use League\CommonMark\Node\Inline\Newline;
use League\CommonMark\Node\Inline\Text;
use League\CommonMark\Parser\InlineParserContext;
final class NewlineParser implements InlineParserInterface
{
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::regex('\\n');
}
public function parse(InlineParserContext $inlineContext): bool
{
$inlineContext->getCursor()->advanceBy(1);
// Check previous inline for trailing spaces
$spaces = 0;
$lastInline = $inlineContext->getContainer()->lastChild();
if ($lastInline instanceof Text) {
$trimmed = \rtrim($lastInline->getLiteral(), ' ');
$spaces = \strlen($lastInline->getLiteral()) - \strlen($trimmed);
if ($spaces) {
$lastInline->setLiteral($trimmed);
}
}
if ($spaces >= 2) {
$inlineContext->getContainer()->appendChild(new Newline(Newline::HARDBREAK));
} else {
$inlineContext->getContainer()->appendChild(new Newline(Newline::SOFTBREAK));
}
return true;
}
}
PK �@]�iK� + src/Parser/Inline/InlineParserInterface.phpnu �[��� <?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\Parser\Inline;
use League\CommonMark\Parser\InlineParserContext;
interface InlineParserInterface
{
public function getMatchDefinition(): InlineParserMatch;
public function parse(InlineParserContext $inlineContext): bool;
}
PK �@]}jһ� � ' src/Parser/Inline/InlineParserMatch.phpnu �[��� <?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\Parser\Inline;
use League\CommonMark\Exception\InvalidArgumentException;
final class InlineParserMatch
{
private string $regex;
private bool $caseSensitive;
private function __construct(string $regex, bool $caseSensitive = false)
{
$this->regex = $regex;
$this->caseSensitive = $caseSensitive;
}
public function caseSensitive(): self
{
$this->caseSensitive = true;
return $this;
}
/**
* @internal
*
* @psalm-return non-empty-string
*/
public function getRegex(): string
{
return '/' . $this->regex . '/' . ($this->caseSensitive ? '' : 'i');
}
/**
* Match the given string (case-insensitive)
*/
public static function string(string $str): self
{
return new self(\preg_quote($str, '/'));
}
/**
* Match any of the given strings (case-insensitive)
*/
public static function oneOf(string ...$str): self
{
return new self(\implode('|', \array_map(static fn (string $str): string => \preg_quote($str, '/'), $str)));
}
/**
* Match a partial regular expression without starting/ending delimiters, anchors, or flags
*/
public static function regex(string $regex): self
{
return new self($regex);
}
public static function join(self ...$definitions): self
{
$regex = '';
$caseSensitive = null;
foreach ($definitions as $definition) {
$regex .= '(' . $definition->regex . ')';
if ($caseSensitive === null) {
$caseSensitive = $definition->caseSensitive;
} elseif ($caseSensitive !== $definition->caseSensitive) {
throw new InvalidArgumentException('Case-sensitive and case-insensitive definitions cannot be combined');
}
}
return new self($regex, $caseSensitive ?? false);
}
}
PK �@]I7MD6 6 " src/Parser/InlineParserContext.phpnu �[��� <?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\Parser;
use League\CommonMark\Delimiter\DelimiterStack;
use League\CommonMark\Node\Block\AbstractBlock;
use League\CommonMark\Reference\ReferenceMapInterface;
final class InlineParserContext
{
/** @psalm-readonly */
private AbstractBlock $container;
/** @psalm-readonly */
private ReferenceMapInterface $referenceMap;
/** @psalm-readonly */
private Cursor $cursor;
/** @psalm-readonly */
private DelimiterStack $delimiterStack;
/**
* @var string[]
* @psalm-var non-empty-array<string>
*
* @psalm-readonly-allow-private-mutation
*/
private array $matches;
public function __construct(Cursor $contents, AbstractBlock $container, ReferenceMapInterface $referenceMap)
{
$this->referenceMap = $referenceMap;
$this->container = $container;
$this->cursor = $contents;
$this->delimiterStack = new DelimiterStack();
}
public function getContainer(): AbstractBlock
{
return $this->container;
}
public function getReferenceMap(): ReferenceMapInterface
{
return $this->referenceMap;
}
public function getCursor(): Cursor
{
return $this->cursor;
}
public function getDelimiterStack(): DelimiterStack
{
return $this->delimiterStack;
}
/**
* @return string The full text that matched the InlineParserMatch definition
*/
public function getFullMatch(): string
{
return $this->matches[0];
}
/**
* @return int The length of the full match (in characters, not bytes)
*/
public function getFullMatchLength(): int
{
return \mb_strlen($this->matches[0], 'UTF-8');
}
/**
* @return string[] Similar to preg_match(), index 0 will contain the full match, and any other array elements will be captured sub-matches
*
* @psalm-return non-empty-array<string>
*/
public function getMatches(): array
{
return $this->matches;
}
/**
* @return string[]
*/
public function getSubMatches(): array
{
return \array_slice($this->matches, 1);
}
/**
* @param string[] $matches
*
* @psalm-param non-empty-array<string> $matches
*/
public function withMatches(array $matches): InlineParserContext
{
$ctx = clone $this;
$ctx->matches = $matches;
return $ctx;
}
}
PK �@]b$6
@ @ 1 src/Parser/Block/BlockContinueParserInterface.phpnu �[��� <?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\Parser\Block;
use League\CommonMark\Node\Block\AbstractBlock;
use League\CommonMark\Parser\Cursor;
/**
* Interface for a block continuation parser
*
* A block continue parser can only handle a single block instance. The current block being parsed is stored within this parser and
* can be returned once parsing has completed. If you need to parse multiple block continuations, instantiate a new parser for each one.
*/
interface BlockContinueParserInterface
{
/**
* Return the current block being parsed by this parser
*/
public function getBlock(): AbstractBlock;
/**
* Return whether we are parsing a container block
*/
public function isContainer(): bool;
/**
* Return whether we are interested in possibly lazily parsing any subsequent lines
*/
public function canHaveLazyContinuationLines(): bool;
/**
* Determine whether the current block being parsed can contain the given child block
*/
public function canContain(AbstractBlock $childBlock): bool;
/**
* Attempt to parse the given line
*/
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue;
/**
* Add the given line of text to the current block
*/
public function addLine(string $line): void;
/**
* Close and finalize the current block
*/
public function closeBlock(): void;
}
PK �@]+�Y� � 0 src/Parser/Block/AbstractBlockContinueParser.phpnu �[��� <?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\Parser\Block;
use League\CommonMark\Node\Block\AbstractBlock;
/**
* Base class for a block parser
*
* Slightly more convenient to extend from vs. implementing the interface
*/
abstract class AbstractBlockContinueParser implements BlockContinueParserInterface
{
public function isContainer(): bool
{
return false;
}
public function canHaveLazyContinuationLines(): bool
{
return false;
}
public function canContain(AbstractBlock $childBlock): bool
{
return false;
}
public function addLine(string $line): void
{
}
public function closeBlock(): void
{
}
}
PK �@]��֧�
�
src/Parser/Block/BlockStart.phpnu �[��� <?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\Parser\Block;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Parser\CursorState;
/**
* Result object for starting parsing of a block; see static methods for constructors
*/
final class BlockStart
{
/**
* @var BlockContinueParserInterface[]
*
* @psalm-readonly
*/
private array $blockParsers;
/** @psalm-readonly-allow-private-mutation */
private ?CursorState $cursorState = null;
/** @psalm-readonly-allow-private-mutation */
private bool $replaceActiveBlockParser = false;
private bool $isAborting = false;
private function __construct(BlockContinueParserInterface ...$blockParsers)
{
$this->blockParsers = $blockParsers;
}
/**
* @return BlockContinueParserInterface[]
*/
public function getBlockParsers(): iterable
{
return $this->blockParsers;
}
public function getCursorState(): ?CursorState
{
return $this->cursorState;
}
public function isReplaceActiveBlockParser(): bool
{
return $this->replaceActiveBlockParser;
}
/**
* @internal
*/
public function isAborting(): bool
{
return $this->isAborting;
}
/**
* Signal that we want to parse at the given cursor position
*
* @return $this
*/
public function at(Cursor $cursor): self
{
$this->cursorState = $cursor->saveState();
return $this;
}
/**
* Signal that we want to replace the active block parser with this one
*
* @return $this
*/
public function replaceActiveBlockParser(): self
{
$this->replaceActiveBlockParser = true;
return $this;
}
/**
* Signal that we cannot parse whatever is here
*
* @return null
*/
public static function none(): ?self
{
return null;
}
/**
* Signal that we'd like to register the given parser(s) so they can parse the current block
*/
public static function of(BlockContinueParserInterface ...$blockParsers): self
{
return new self(...$blockParsers);
}
/**
* Signal that the block parsing process should be aborted (no other block starts should be checked)
*
* @internal
*/
public static function abort(): self
{
$ret = new self();
$ret->isAborting = true;
return $ret;
}
}
PK �@]�OQ� ( src/Parser/Block/DocumentBlockParser.phpnu �[��� <?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\Parser\Block;
use League\CommonMark\Node\Block\AbstractBlock;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Reference\ReferenceMapInterface;
/**
* Parser implementation which ensures everything is added to the root-level Document
*/
final class DocumentBlockParser extends AbstractBlockContinueParser
{
/** @psalm-readonly */
private Document $document;
public function __construct(ReferenceMapInterface $referenceMap)
{
$this->document = new Document($referenceMap);
}
public function getBlock(): Document
{
return $this->document;
}
public function isContainer(): bool
{
return true;
}
public function canContain(AbstractBlock $childBlock): bool
{
return true;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
return BlockContinue::at($cursor);
}
}
PK �@]l�8�i i < src/Parser/Block/BlockContinueParserWithInlinesInterface.phpnu �[��� <?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\Parser\Block;
use League\CommonMark\Parser\InlineParserEngineInterface;
interface BlockContinueParserWithInlinesInterface extends BlockContinueParserInterface
{
/**
* Parse any inlines inside of the current block
*/
public function parseInlines(InlineParserEngineInterface $inlineParser): void;
}
PK �@]�w��1 1 . src/Parser/Block/BlockStartParserInterface.phpnu �[��� <?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\Parser\Block;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Parser\MarkdownParserStateInterface;
/**
* Interface for a block parser which identifies block starts.
*/
interface BlockStartParserInterface
{
/**
* Check whether we should handle the block at the current position
*
* @param Cursor $cursor A cloned copy of the cursor at the current parsing location
* @param MarkdownParserStateInterface $parserState Additional information about the state of the Markdown parser
*
* @return BlockStart|null The BlockStart that has been identified, or null if the block doesn't match here
*/
public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart;
}
PK �@]B/�< " src/Parser/Block/BlockContinue.phpnu �[��� <?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\Parser\Block;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Parser\CursorState;
/**
* Result object for continuing parsing of a block; see static methods for constructors.
*
* @psalm-immutable
*/
final class BlockContinue
{
/** @psalm-readonly */
private ?CursorState $cursorState = null;
/** @psalm-readonly */
private bool $finalize;
private function __construct(?CursorState $cursorState = null, bool $finalize = false)
{
$this->cursorState = $cursorState;
$this->finalize = $finalize;
}
public function getCursorState(): ?CursorState
{
return $this->cursorState;
}
public function isFinalize(): bool
{
return $this->finalize;
}
/**
* Signal that we cannot continue here
*
* @return null
*/
public static function none(): ?self
{
return null;
}
/**
* Signal that we're continuing at the given position
*/
public static function at(Cursor $cursor): self
{
return new self($cursor->saveState(), false);
}
/**
* Signal that we want to finalize and close the block
*/
public static function finished(): self
{
return new self(null, true);
}
}
PK �@]�U��� � $ src/Parser/Block/ParagraphParser.phpnu �[��� <?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\Parser\Block;
use League\CommonMark\Node\Block\Paragraph;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Parser\InlineParserEngineInterface;
use League\CommonMark\Reference\ReferenceInterface;
use League\CommonMark\Reference\ReferenceParser;
final class ParagraphParser extends AbstractBlockContinueParser implements BlockContinueParserWithInlinesInterface
{
/** @psalm-readonly */
private Paragraph $block;
/** @psalm-readonly */
private ReferenceParser $referenceParser;
public function __construct()
{
$this->block = new Paragraph();
$this->referenceParser = new ReferenceParser();
}
public function canHaveLazyContinuationLines(): bool
{
return true;
}
public function getBlock(): Paragraph
{
return $this->block;
}
public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue
{
if ($cursor->isBlank()) {
return BlockContinue::none();
}
return BlockContinue::at($cursor);
}
public function addLine(string $line): void
{
$this->referenceParser->parse($line);
}
public function closeBlock(): void
{
if ($this->referenceParser->hasReferences() && $this->referenceParser->getParagraphContent() === '') {
$this->block->detach();
}
}
public function parseInlines(InlineParserEngineInterface $inlineParser): void
{
$content = $this->getContentString();
if ($content !== '') {
$inlineParser->parse($content, $this->block);
}
}
public function getContentString(): string
{
return $this->referenceParser->getParagraphContent();
}
/**
* @return ReferenceInterface[]
*/
public function getReferences(): iterable
{
return $this->referenceParser->getReferences();
}
}
PK �@]��X� � 7 src/Parser/Block/SkipLinesStartingWithLettersParser.phpnu �[��� <?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\Parser\Block;
use League\CommonMark\Parser\Cursor;
use League\CommonMark\Parser\MarkdownParserStateInterface;
use League\CommonMark\Util\RegexHelper;
/**
* @internal
*
* This "parser" is actually a performance optimization.
*
* Most lines in a typical Markdown document probably won't match a block start. This is especially true for lines starting
* with letters - nothing in the core CommonMark spec or our supported extensions will match those lines as blocks. Therefore,
* if we can identify those lines and skip block start parsing, we can optimize performance by ~10%.
*
* Previously this optimization was hard-coded in the MarkdownParser but did not allow users to override this behavior.
* By implementing this optimization as a block parser instead, users wanting custom blocks starting with letters
* can instead register their block parser with a higher priority to ensure their parser is always called first.
*/
final class SkipLinesStartingWithLettersParser implements BlockStartParserInterface
{
public function tryStart(Cursor $cursor, MarkdownParserStateInterface $parserState): ?BlockStart
{
if (! $cursor->isIndented() && RegexHelper::isLetter($cursor->getNextNonSpaceCharacter())) {
$cursor->advanceToNextNonSpaceOrTab();
return BlockStart::abort();
}
return BlockStart::none();
}
}
PK �@]�J�{` ` " src/Parser/MarkdownParserState.phpnu �[��� <?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\Parser;
use League\CommonMark\Parser\Block\BlockContinueParserInterface;
use League\CommonMark\Parser\Block\ParagraphParser;
/**
* @internal You should rely on the interface instead
*/
final class MarkdownParserState implements MarkdownParserStateInterface
{
/** @psalm-readonly */
private BlockContinueParserInterface $activeBlockParser;
/** @psalm-readonly */
private BlockContinueParserInterface $lastMatchedBlockParser;
public function __construct(BlockContinueParserInterface $activeBlockParser, BlockContinueParserInterface $lastMatchedBlockParser)
{
$this->activeBlockParser = $activeBlockParser;
$this->lastMatchedBlockParser = $lastMatchedBlockParser;
}
public function getActiveBlockParser(): BlockContinueParserInterface
{
return $this->activeBlockParser;
}
public function getLastMatchedBlockParser(): BlockContinueParserInterface
{
return $this->lastMatchedBlockParser;
}
public function getParagraphContent(): ?string
{
if (! $this->lastMatchedBlockParser instanceof ParagraphParser) {
return null;
}
$paragraphParser = $this->lastMatchedBlockParser;
$content = $paragraphParser->getContentString();
return $content === '' ? null : $content;
}
}
PK �@]�p�7� � # src/Parser/ParserLogicException.phpnu �[��� <?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\Parser;
use League\CommonMark\Exception\CommonMarkException;
class ParserLogicException extends \LogicException implements CommonMarkException
{
}
PK �@]�1a4 4 + src/Parser/MarkdownParserStateInterface.phpnu �[��� <?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\Parser;
use League\CommonMark\Parser\Block\BlockContinueParserInterface;
interface MarkdownParserStateInterface
{
/**
* Returns the deepest open block parser
*/
public function getActiveBlockParser(): BlockContinueParserInterface;
/**
* Open block parser that was last matched during the continue phase. This is different from the currently active
* block parser, as an unmatched block is only closed when a new block is started.
*/
public function getLastMatchedBlockParser(): BlockContinueParserInterface;
/**
* Returns the current content of the paragraph if the matched block is a paragraph. The content can be multiple
* lines separated by newlines.
*/
public function getParagraphContent(): ?string;
}
PK �@]x�+y� � * src/Parser/InlineParserEngineInterface.phpnu �[��� <?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\Parser;
use League\CommonMark\Node\Block\AbstractBlock;
/**
* Parser for inline content (text, links, emphasized text, etc).
*/
interface InlineParserEngineInterface
{
/**
* Parse the given contents as inlines and insert them into the given block
*/
public function parse(string $contents, AbstractBlock $block): void;
}
PK �@]�c4�# # & src/Parser/MarkdownParserInterface.phpnu �[��� <?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\Parser;
use League\CommonMark\Exception\CommonMarkException;
use League\CommonMark\Node\Block\Document;
interface MarkdownParserInterface
{
/**
* @throws CommonMarkException
*/
public function parse(string $input): Document;
}
PK �@]W�)�h h src/Parser/CursorState.phpnu �[��� <?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\Parser;
/**
* Encapsulates the current state of a cursor in case you need to rollback later.
*
* WARNING: Do not attempt to use this class for ANYTHING except for
* type hinting and passing this object back into restoreState().
* The constructor, methods, and inner contents may change in any
* future release without warning!
*
* @internal
*
* @psalm-immutable
*/
final class CursorState
{
/**
* @var array<int, mixed>
*
* @psalm-readonly
*/
private array $state;
/**
* @internal
*
* @param array<int, mixed> $state
*/
public function __construct(array $state)
{
$this->state = $state;
}
/**
* @internal
*
* @return array<int, mixed>
*/
public function toArray(): array
{
return $this->state;
}
}
PK �@]�t�E� � ! src/Normalizer/SlugNormalizer.phpnu �[��� <?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\Normalizer;
use League\Config\ConfigurationAwareInterface;
use League\Config\ConfigurationInterface;
/**
* Creates URL-friendly strings based on the given string input
*/
final class SlugNormalizer implements TextNormalizerInterface, ConfigurationAwareInterface
{
/** @psalm-allow-private-mutation */
private int $defaultMaxLength = 255;
public function setConfiguration(ConfigurationInterface $configuration): void
{
$this->defaultMaxLength = $configuration->get('slug_normalizer/max_length');
}
/**
* {@inheritDoc}
*
* @psalm-immutable
*/
public function normalize(string $text, array $context = []): string
{
// Add any requested prefix
$slug = ($context['prefix'] ?? '') . $text;
// Trim whitespace
$slug = \trim($slug);
// Convert to lowercase
$slug = \mb_strtolower($slug, 'UTF-8');
// Try replacing whitespace with a dash
$slug = \preg_replace('/\s+/u', '-', $slug) ?? $slug;
// Try removing characters other than letters, numbers, and marks.
$slug = \preg_replace('/[^\p{L}\p{Nd}\p{Nl}\p{M}-]+/u', '', $slug) ?? $slug;
// Trim to requested length if given
if ($length = $context['length'] ?? $this->defaultMaxLength) {
$slug = \mb_substr($slug, 0, $length, 'UTF-8');
}
return $slug;
}
}
PK �@]��� � ' src/Normalizer/UniqueSlugNormalizer.phpnu �[��� <?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\Normalizer;
// phpcs:disable Squiz.Strings.DoubleQuoteUsage.ContainsVar
final class UniqueSlugNormalizer implements UniqueSlugNormalizerInterface
{
private TextNormalizerInterface $innerNormalizer;
/** @var array<string, bool> */
private array $alreadyUsed = [];
public function __construct(TextNormalizerInterface $innerNormalizer)
{
$this->innerNormalizer = $innerNormalizer;
}
public function clearHistory(): void
{
$this->alreadyUsed = [];
}
/**
* {@inheritDoc}
*
* @psalm-allow-private-mutation
*/
public function normalize(string $text, array $context = []): string
{
$normalized = $this->innerNormalizer->normalize($text, $context);
// If it's not unique, add an incremental number to the end until we get a unique version
if (\array_key_exists($normalized, $this->alreadyUsed)) {
$suffix = 0;
do {
++$suffix;
} while (\array_key_exists("$normalized-$suffix", $this->alreadyUsed));
$normalized = "$normalized-$suffix";
}
$this->alreadyUsed[$normalized] = true;
return $normalized;
}
}
PK �@]��R�� � 0 src/Normalizer/UniqueSlugNormalizerInterface.phpnu �[��� <?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\Normalizer;
interface UniqueSlugNormalizerInterface extends TextNormalizerInterface
{
public const DISABLED = false;
public const PER_ENVIRONMENT = 'environment';
public const PER_DOCUMENT = 'document';
/**
* Called by the Environment whenever the configured scope changes
*
* Currently, this will only be called PER_DOCUMENT.
*/
public function clearHistory(): void;
}
PK �@]V�|Z� � ! src/Normalizer/TextNormalizer.phpnu �[��� <?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\Normalizer;
/***
* Normalize text input using the steps given by the CommonMark spec to normalize labels
*
* @see https://spec.commonmark.org/0.29/#matches
*
* @psalm-immutable
*/
final class TextNormalizer implements TextNormalizerInterface
{
/**
* {@inheritDoc}
*
* @psalm-pure
*/
public function normalize(string $text, array $context = []): string
{
// Collapse internal whitespace to single space and remove
// leading/trailing whitespace
$text = \preg_replace('/[ \t\r\n]+/', ' ', \trim($text));
\assert(\is_string($text));
return \mb_convert_case($text, \MB_CASE_FOLD, 'UTF-8');
}
}
PK �@]�U�� * src/Normalizer/TextNormalizerInterface.phpnu �[��� <?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\Normalizer;
/**
* Creates a normalized version of the given input text
*/
interface TextNormalizerInterface
{
/**
* @param string $text The text to normalize
* @param array<string, mixed> $context Additional context about the text being normalized (optional)
*
* $context may include (but is not required to include) the following:
* - `prefix` - A string prefix to prepend to each normalized result
* - `length` - The requested maximum length
* - `node` - The node we're normalizing text for
*
* Implementations do not have to use or respect any information within that $context
*/
public function normalize(string $text, array $context = []): string;
}
PK �@]�ֵ�N N " src/MarkdownConverterInterface.phpnu �[��� <?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;
use League\CommonMark\Exception\CommonMarkException;
use League\CommonMark\Output\RenderedContentInterface;
/**
* Interface for a service which converts Markdown to HTML.
*
* @deprecated since 2.2; use {@link ConverterInterface} instead
*/
interface MarkdownConverterInterface
{
/**
* Converts Markdown to HTML.
*
* @deprecated since 2.2; use {@link ConverterInterface::convert()} instead
*
* @throws CommonMarkException
*/
public function convertToHtml(string $markdown): RenderedContentInterface;
}
PK �@]���� � src/Delimiter/Delimiter.phpnu �[��� <?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\Delimiter;
use League\CommonMark\Node\Inline\AbstractStringContainer;
final class Delimiter implements DelimiterInterface
{
/** @psalm-readonly */
private string $char;
/** @psalm-readonly-allow-private-mutation */
private int $length;
/** @psalm-readonly */
private int $originalLength;
/** @psalm-readonly */
private AbstractStringContainer $inlineNode;
/** @psalm-readonly-allow-private-mutation */
private ?DelimiterInterface $previous = null;
/** @psalm-readonly-allow-private-mutation */
private ?DelimiterInterface $next = null;
/** @psalm-readonly */
private bool $canOpen;
/** @psalm-readonly */
private bool $canClose;
/** @psalm-readonly-allow-private-mutation */
private bool $active;
/** @psalm-readonly */
private ?int $index = null;
public function __construct(string $char, int $numDelims, AbstractStringContainer $node, bool $canOpen, bool $canClose, ?int $index = null)
{
$this->char = $char;
$this->length = $numDelims;
$this->originalLength = $numDelims;
$this->inlineNode = $node;
$this->canOpen = $canOpen;
$this->canClose = $canClose;
$this->active = true;
$this->index = $index;
}
public function canClose(): bool
{
return $this->canClose;
}
public function canOpen(): bool
{
return $this->canOpen;
}
public function isActive(): bool
{
return $this->active;
}
public function setActive(bool $active): void
{
$this->active = $active;
}
public function getChar(): string
{
return $this->char;
}
public function getIndex(): ?int
{
return $this->index;
}
public function getNext(): ?DelimiterInterface
{
return $this->next;
}
public function setNext(?DelimiterInterface $next): void
{
$this->next = $next;
}
public function getLength(): int
{
return $this->length;
}
public function setLength(int $length): void
{
$this->length = $length;
}
public function getOriginalLength(): int
{
return $this->originalLength;
}
public function getInlineNode(): AbstractStringContainer
{
return $this->inlineNode;
}
public function getPrevious(): ?DelimiterInterface
{
return $this->previous;
}
public function setPrevious(?DelimiterInterface $previous): void
{
$this->previous = $previous;
}
}
PK �@]d�(�p p ! src/Delimiter/DelimiterParser.phpnu �[��� <?php
declare(strict_types=1);
namespace League\CommonMark\Delimiter;
use League\CommonMark\Delimiter\Processor\DelimiterProcessorCollection;
use League\CommonMark\Delimiter\Processor\DelimiterProcessorInterface;
use League\CommonMark\Node\Inline\Text;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Parser\Inline\InlineParserMatch;
use League\CommonMark\Parser\InlineParserContext;
use League\CommonMark\Util\RegexHelper;
/**
* Delimiter parsing is implemented as an Inline Parser with the lowest-possible priority
*
* @internal
*/
final class DelimiterParser implements InlineParserInterface
{
private DelimiterProcessorCollection $collection;
public function __construct(DelimiterProcessorCollection $collection)
{
$this->collection = $collection;
}
public function getMatchDefinition(): InlineParserMatch
{
return InlineParserMatch::oneOf(...$this->collection->getDelimiterCharacters());
}
public function parse(InlineParserContext $inlineContext): bool
{
$character = $inlineContext->getFullMatch();
$numDelims = 0;
$cursor = $inlineContext->getCursor();
$processor = $this->collection->getDelimiterProcessor($character);
\assert($processor !== null); // Delimiter processor should never be null here
$charBefore = $cursor->peek(-1);
if ($charBefore === null) {
$charBefore = "\n";
}
while ($cursor->peek($numDelims) === $character) {
++$numDelims;
}
if ($numDelims < $processor->getMinLength()) {
return false;
}
$cursor->advanceBy($numDelims);
$charAfter = $cursor->getCurrentCharacter();
if ($charAfter === null) {
$charAfter = "\n";
}
[$canOpen, $canClose] = self::determineCanOpenOrClose($charBefore, $charAfter, $character, $processor);
$node = new Text(\str_repeat($character, $numDelims), [
'delim' => true,
]);
$inlineContext->getContainer()->appendChild($node);
// Add entry to stack to this opener
if ($canOpen || $canClose) {
$delimiter = new Delimiter($character, $numDelims, $node, $canOpen, $canClose);
$inlineContext->getDelimiterStack()->push($delimiter);
}
return true;
}
/**
* @return bool[]
*/
private static function determineCanOpenOrClose(string $charBefore, string $charAfter, string $character, DelimiterProcessorInterface $delimiterProcessor): array
{
$afterIsWhitespace = \preg_match(RegexHelper::REGEX_UNICODE_WHITESPACE_CHAR, $charAfter);
$afterIsPunctuation = \preg_match(RegexHelper::REGEX_PUNCTUATION, $charAfter);
$beforeIsWhitespace = \preg_match(RegexHelper::REGEX_UNICODE_WHITESPACE_CHAR, $charBefore);
$beforeIsPunctuation = \preg_match(RegexHelper::REGEX_PUNCTUATION, $charBefore);
$leftFlanking = ! $afterIsWhitespace && (! $afterIsPunctuation || $beforeIsWhitespace || $beforeIsPunctuation);
$rightFlanking = ! $beforeIsWhitespace && (! $beforeIsPunctuation || $afterIsWhitespace || $afterIsPunctuation);
if ($character === '_') {
$canOpen = $leftFlanking && (! $rightFlanking || $beforeIsPunctuation);
$canClose = $rightFlanking && (! $leftFlanking || $afterIsPunctuation);
} else {
$canOpen = $leftFlanking && $character === $delimiterProcessor->getOpeningCharacter();
$canClose = $rightFlanking && $character === $delimiterProcessor->getClosingCharacter();
}
return [$canOpen, $canClose];
}
}
PK �@]�!x,� � $ src/Delimiter/DelimiterInterface.phpnu �[��� <?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\Delimiter;
use League\CommonMark\Node\Inline\AbstractStringContainer;
interface DelimiterInterface
{
public function canClose(): bool;
public function canOpen(): bool;
public function isActive(): bool;
public function setActive(bool $active): void;
public function getChar(): string;
public function getIndex(): ?int;
public function getNext(): ?DelimiterInterface;
public function setNext(?DelimiterInterface $next): void;
public function getLength(): int;
public function setLength(int $length): void;
public function getOriginalLength(): int;
public function getInlineNode(): AbstractStringContainer;
public function getPrevious(): ?DelimiterInterface;
public function setPrevious(?DelimiterInterface $previous): void;
}
PK �@]&1F7i i 8 src/Delimiter/Processor/DelimiterProcessorCollection.phpnu �[��� <?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\Delimiter\Processor;
use League\CommonMark\Exception\InvalidArgumentException;
final class DelimiterProcessorCollection implements DelimiterProcessorCollectionInterface
{
/**
* @var array<string,DelimiterProcessorInterface>|DelimiterProcessorInterface[]
*
* @psalm-readonly-allow-private-mutation
*/
private array $processorsByChar = [];
public function add(DelimiterProcessorInterface $processor): void
{
$opening = $processor->getOpeningCharacter();
$closing = $processor->getClosingCharacter();
if ($opening === $closing) {
$old = $this->processorsByChar[$opening] ?? null;
if ($old !== null && $old->getOpeningCharacter() === $old->getClosingCharacter()) {
$this->addStaggeredDelimiterProcessorForChar($opening, $old, $processor);
} else {
$this->addDelimiterProcessorForChar($opening, $processor);
}
} else {
$this->addDelimiterProcessorForChar($opening, $processor);
$this->addDelimiterProcessorForChar($closing, $processor);
}
}
public function getDelimiterProcessor(string $char): ?DelimiterProcessorInterface
{
return $this->processorsByChar[$char] ?? null;
}
/**
* @return string[]
*/
public function getDelimiterCharacters(): array
{
return \array_keys($this->processorsByChar);
}
private function addDelimiterProcessorForChar(string $delimiterChar, DelimiterProcessorInterface $processor): void
{
if (isset($this->processorsByChar[$delimiterChar])) {
throw new InvalidArgumentException(\sprintf('Delim processor for character "%s" already exists', $processor->getOpeningCharacter()));
}
$this->processorsByChar[$delimiterChar] = $processor;
}
private function addStaggeredDelimiterProcessorForChar(string $opening, DelimiterProcessorInterface $old, DelimiterProcessorInterface $new): void
{
if ($old instanceof StaggeredDelimiterProcessor) {
$s = $old;
} else {
$s = new StaggeredDelimiterProcessor($opening, $old);
}
$s->add($new);
$this->processorsByChar[$opening] = $s;
}
public function count(): int
{
return \count($this->processorsByChar);
}
}
PK �@]��sm� � A src/Delimiter/Processor/DelimiterProcessorCollectionInterface.phpnu �[��� <?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\Delimiter\Processor;
use League\CommonMark\Exception\InvalidArgumentException;
interface DelimiterProcessorCollectionInterface extends \Countable
{
/**
* Add the given delim processor to the collection
*
* @param DelimiterProcessorInterface $processor The delim processor to add
*
* @throws InvalidArgumentException Exception will be thrown if attempting to add multiple processors for the same character
*/
public function add(DelimiterProcessorInterface $processor): void;
/**
* Returns the delim processor which handles the given character if one exists
*/
public function getDelimiterProcessor(string $char): ?DelimiterProcessorInterface;
/**
* Returns an array of delimiter characters who have associated processors
*
* @return string[]
*/
public function getDelimiterCharacters(): array;
}
PK �@]pjʥ 7 src/Delimiter/Processor/DelimiterProcessorInterface.phpnu �[��� <?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\Delimiter\Processor;
use League\CommonMark\Delimiter\DelimiterInterface;
use League\CommonMark\Node\Inline\AbstractStringContainer;
/**
* Interface for a delimiter processor
*/
interface DelimiterProcessorInterface
{
/**
* Returns the character that marks the beginning of a delimited node.
*
* This must not clash with any other processors being added to the environment.
*/
public function getOpeningCharacter(): string;
/**
* Returns the character that marks the ending of a delimited node.
*
* This must not clash with any other processors being added to the environment.
*
* Note that for a symmetric delimiter such as "*", this is the same as the opening.
*/
public function getClosingCharacter(): string;
/**
* Minimum number of delimiter characters that are needed to active this.
*
* Must be at least 1.
*/
public function getMinLength(): int;
/**
* Determine how many (if any) of the delimiter characters should be used.
*
* This allows implementations to decide how many characters to be used
* based on the properties of the delimiter runs. An implementation can also
* return 0 when it doesn't want to allow this particular combination of
* delimiter runs.
*
* @param DelimiterInterface $opener The opening delimiter run
* @param DelimiterInterface $closer The closing delimiter run
*/
public function getDelimiterUse(DelimiterInterface $opener, DelimiterInterface $closer): int;
/**
* Process the matched delimiters, e.g. by wrapping the nodes between opener
* and closer in a new node, or appending a new node after the opener.
*
* Note that removal of the delimiter from the delimiter nodes and detaching
* them is done by the caller.
*
* @param AbstractStringContainer $opener The node that contained the opening delimiter
* @param AbstractStringContainer $closer The node that contained the closing delimiter
* @param int $delimiterUse The number of delimiters that were used
*/
public function process(AbstractStringContainer $opener, AbstractStringContainer $closer, int $delimiterUse): void;
}
PK �@] a�� 7 src/Delimiter/Processor/StaggeredDelimiterProcessor.phpnu �[��� <?php
declare(strict_types=1);
/*
* This file is part of the league/commonmark package.
*
* (c) Colin O'Dell <colinodell@gmail.com>
*
* 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\Delimiter\Processor;
use League\CommonMark\Delimiter\DelimiterInterface;
use League\CommonMark\Exception\InvalidArgumentException;
use League\CommonMark\Node\Inline\AbstractStringContainer;
/**
* An implementation of DelimiterProcessorInterface that dispatches all calls to two or more other DelimiterProcessors
* depending on the length of the delimiter run. All child DelimiterProcessors must have different minimum
* lengths. A given delimiter run is dispatched to the child with the largest acceptable minimum length. If no
* child is applicable, the one with the largest minimum length is chosen.
*
* @internal
*/
final class StaggeredDelimiterProcessor implements DelimiterProcessorInterface
{
/** @psalm-readonly */
private string $delimiterChar;
/** @psalm-readonly-allow-private-mutation */
private int $minLength = 0;
/**
* @var array<int, DelimiterProcessorInterface>|DelimiterProcessorInterface[]
*
* @psalm-readonly-allow-private-mutation
*/
private array $processors = []; // keyed by minLength in reverse order
public function __construct(string $char, DelimiterProcessorInterface $processor)
{
$this->delimiterChar = $char;
$this->add($processor);
}
public function getOpeningCharacter(): string
{
return $this->delimiterChar;
}
public function getClosingCharacter(): string
{
return $this->delimiterChar;
}
public function getMinLength(): int
{
return $this->minLength;
}
/**
* Adds the given processor to this staggered delimiter processor
*
* @throws InvalidArgumentException if attempting to add another processors for the same character and minimum length
*/
public function add(DelimiterProcessorInterface $processor): void
{
$len = $processor->getMinLength();
if (isset($this->processors[$len])) {
throw new InvalidArgumentException(\sprintf('Cannot add two delimiter processors for char "%s" and minimum length %d', $this->delimiterChar, $len));
}
$this->processors[$len] = $processor;
\krsort($this->processors);
$this->minLength = \min($this->minLength, $len);
}
public function getDelimiterUse(DelimiterInterface $opener, DelimiterInterface $closer): int
{
return $this->findProcessor($opener->getLength())->getDelimiterUse($opener, $closer);
}
public function process(AbstractStringContainer $opener, AbstractStringContainer $closer, int $delimiterUse): void
{
$this->findProcessor($delimiterUse)->process($opener, $closer, $delimiterUse);
}
private function findProcessor(int $len): DelimiterProcessorInterface
{
// Find the "longest" processor which can handle this length
foreach ($this->processors as $processor) {
if ($processor->getMinLength() <= $len) {
return $processor;
}
}
// Just use the first one in our list
$first = \reset($this->processors);
\assert($first instanceof DelimiterProcessorInterface);
return $first;
}
}
PK �@]���� � src/Delimiter/DelimiterStack.phpnu �[��� <?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\Delimiter;
use League\CommonMark\Delimiter\Processor\DelimiterProcessorCollection;
use League\CommonMark\Node\Inline\AdjacentTextMerger;
final class DelimiterStack
{
/** @psalm-readonly-allow-private-mutation */
private ?DelimiterInterface $top = null;
public function push(DelimiterInterface $newDelimiter): void
{
$newDelimiter->setPrevious($this->top);
if ($this->top !== null) {
$this->top->setNext($newDelimiter);
}
$this->top = $newDelimiter;
}
private function findEarliest(?DelimiterInterface $stackBottom = null): ?DelimiterInterface
{
$delimiter = $this->top;
while ($delimiter !== null && $delimiter->getPrevious() !== $stackBottom) {
$delimiter = $delimiter->getPrevious();
}
return $delimiter;
}
public function removeDelimiter(DelimiterInterface $delimiter): void
{
if ($delimiter->getPrevious() !== null) {
/** @psalm-suppress PossiblyNullReference */
$delimiter->getPrevious()->setNext($delimiter->getNext());
}
if ($delimiter->getNext() === null) {
// top of stack
$this->top = $delimiter->getPrevious();
} else {
/** @psalm-suppress PossiblyNullReference */
$delimiter->getNext()->setPrevious($delimiter->getPrevious());
}
}
private function removeDelimiterAndNode(DelimiterInterface $delimiter): void
{
$delimiter->getInlineNode()->detach();
$this->removeDelimiter($delimiter);
}
private function removeDelimitersBetween(DelimiterInterface $opener, DelimiterInterface $closer): void
{
$delimiter = $closer->getPrevious();
while ($delimiter !== null && $delimiter !== $opener) {
$previous = $delimiter->getPrevious();
$this->removeDelimiter($delimiter);
$delimiter = $previous;
}
}
public function removeAll(?DelimiterInterface $stackBottom = null): void
{
while ($this->top && $this->top !== $stackBottom) {
$this->removeDelimiter($this->top);
}
}
public function removeEarlierMatches(string $character): void
{
$opener = $this->top;
while ($opener !== null) {
if ($opener->getChar() === $character) {
$opener->setActive(false);
}
$opener = $opener->getPrevious();
}
}
/**
* @param string|string[] $characters
*/
public function searchByCharacter($characters): ?DelimiterInterface
{
if (! \is_array($characters)) {
$characters = [$characters];
}
$opener = $this->top;
while ($opener !== null) {
if (\in_array($opener->getChar(), $characters, true)) {
break;
}
$opener = $opener->getPrevious();
}
return $opener;
}
public function processDelimiters(?DelimiterInterface $stackBottom, DelimiterProcessorCollection $processors): void
{
$openersBottom = [];
// Find first closer above stackBottom
$closer = $this->findEarliest($stackBottom);
// Move forward, looking for closers, and handling each
while ($closer !== null) {
$delimiterChar = $closer->getChar();
$delimiterProcessor = $processors->getDelimiterProcessor($delimiterChar);
if (! $closer->canClose() || $delimiterProcessor === null) {
$closer = $closer->getNext();
continue;
}
$openingDelimiterChar = $delimiterProcessor->getOpeningCharacter();
$useDelims = 0;
$openerFound = false;
$potentialOpenerFound = false;
$opener = $closer->getPrevious();
while ($opener !== null && $opener !== $stackBottom && $opener !== ($openersBottom[$delimiterChar] ?? null)) {
if ($opener->canOpen() && $opener->getChar() === $openingDelimiterChar) {
$potentialOpenerFound = true;
$useDelims = $delimiterProcessor->getDelimiterUse($opener, $closer);
if ($useDelims > 0) {
$openerFound = true;
break;
}
}
$opener = $opener->getPrevious();
}
if (! $openerFound) {
if (! $potentialOpenerFound) {
// Only do this when we didn't even have a potential
// opener (one that matches the character and can open).
// If an opener was rejected because of the number of
// delimiters (e.g. because of the "multiple of 3"
// Set lower bound for future searches for openersrule),
// we want to consider it next time because the number
// of delimiters can change as we continue processing.
$openersBottom[$delimiterChar] = $closer->getPrevious();
if (! $closer->canOpen()) {
// We can remove a closer that can't be an opener,
// once we've seen there's no matching opener.
$this->removeDelimiter($closer);
}
}
$closer = $closer->getNext();
continue;
}
\assert($opener !== null);
$openerNode = $opener->getInlineNode();
$closerNode = $closer->getInlineNode();
// Remove number of used delimiters from stack and inline nodes.
$opener->setLength($opener->getLength() - $useDelims);
$closer->setLength($closer->getLength() - $useDelims);
$openerNode->setLiteral(\substr($openerNode->getLiteral(), 0, -$useDelims));
$closerNode->setLiteral(\substr($closerNode->getLiteral(), 0, -$useDelims));
$this->removeDelimitersBetween($opener, $closer);
// The delimiter processor can re-parent the nodes between opener and closer,
// so make sure they're contiguous already. Exclusive because we want to keep opener/closer themselves.
AdjacentTextMerger::mergeTextNodesBetweenExclusive($openerNode, $closerNode);
$delimiterProcessor->process($openerNode, $closerNode, $useDelims);
// No delimiter characters left to process, so we can remove delimiter and the now empty node.
if ($opener->getLength() === 0) {
$this->removeDelimiterAndNode($opener);
}
// phpcs:disable SlevomatCodingStandard.ControlStructures.EarlyExit.EarlyExitNotUsed
if ($closer->getLength() === 0) {
$next = $closer->getNext();
$this->removeDelimiterAndNode($closer);
$closer = $next;
}
}
// Remove all delimiters
$this->removeAll($stackBottom);
}
}
PK �@]��
� � src/CommonMarkConverter.phpnu �[��� <?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;
use League\CommonMark\Environment\Environment;
use League\CommonMark\Extension\CommonMark\CommonMarkCoreExtension;
/**
* Converts CommonMark-compatible Markdown to HTML.
*/
final class CommonMarkConverter extends MarkdownConverter
{
/**
* Create a new Markdown converter pre-configured for CommonMark
*
* @param array<string, mixed> $config
*/
public function __construct(array $config = [])
{
$environment = new Environment($config);
$environment->addExtension(new CommonMarkCoreExtension());
parent::__construct($environment);
}
public function getEnvironment(): Environment
{
\assert($this->environment instanceof Environment);
return $this->environment;
}
}
PK �@]� &*b b $ src/Xml/XmlNodeRendererInterface.phpnu �[��� <?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\Xml;
use League\CommonMark\Node\Node;
interface XmlNodeRendererInterface
{
public function getXmlTagName(Node $node): string;
/**
* @return array<string, string|int|float|bool>
*
* @psalm-return array<string, scalar>
*/
public function getXmlAttributes(Node $node): array;
}
PK �@]}"��F F src/Xml/XmlRenderer.phpnu �[��� <?php
declare(strict_types=1);
namespace League\CommonMark\Xml;
use League\CommonMark\Environment\EnvironmentInterface;
use League\CommonMark\Event\DocumentPreRenderEvent;
use League\CommonMark\Exception\InvalidArgumentException;
use League\CommonMark\Node\Block\Document;
use League\CommonMark\Node\Node;
use League\CommonMark\Node\StringContainerInterface;
use League\CommonMark\Output\RenderedContent;
use League\CommonMark\Output\RenderedContentInterface;
use League\CommonMark\Renderer\DocumentRendererInterface;
use League\CommonMark\Util\Xml;
final class XmlRenderer implements DocumentRendererInterface
{
private const INDENTATION = ' ';
private EnvironmentInterface $environment;
private XmlNodeRendererInterface $fallbackRenderer;
/** @var array<class-string, XmlNodeRendererInterface> */
private array $rendererCache = [];
public function __construct(EnvironmentInterface $environment)
{
$this->environment = $environment;
$this->fallbackRenderer = new FallbackNodeXmlRenderer();
}
public function renderDocument(Document $document): RenderedContentInterface
{
$this->environment->dispatch(new DocumentPreRenderEvent($document, 'xml'));
$xml = '<?xml version="1.0" encoding="UTF-8"?>';
$indent = 0;
$walker = $document->walker();
while ($event = $walker->next()) {
$node = $event->getNode();
$closeImmediately = ! $node->hasChildren();
$selfClosing = $closeImmediately && ! $node instanceof StringContainerInterface;
$renderer = $this->findXmlRenderer($node);
$tagName = $renderer->getXmlTagName($node);
if ($event->isEntering()) {
$attrs = $renderer->getXmlAttributes($node);
$xml .= "\n" . \str_repeat(self::INDENTATION, $indent);
$xml .= self::tag($tagName, $attrs, $selfClosing);
if ($node instanceof StringContainerInterface) {
$xml .= Xml::escape($node->getLiteral());
}
if ($closeImmediately && ! $selfClosing) {
$xml .= self::tag('/' . $tagName);
}
if (! $closeImmediately) {
$indent++;
}
} elseif (! $closeImmediately) {
$indent--;
$xml .= "\n" . \str_repeat(self::INDENTATION, $indent);
$xml .= self::tag('/' . $tagName);
}
}
return new RenderedContent($document, $xml . "\n");
}
/**
* @param array<string, string|int|float|bool> $attrs
*/
private static function tag(string $name, array $attrs = [], bool $selfClosing = \false): string
{
$result = '<' . $name;
foreach ($attrs as $key => $value) {
$result .= \sprintf(' %s="%s"', $key, self::convertAndEscape($value));
}
if ($selfClosing) {
$result .= ' /';
}
$result .= '>';
return $result;
}
/**
* @param string|int|float|bool $value
*/
private static function convertAndEscape($value): string
{
if (\is_string($value)) {
return Xml::escape($value);
}
if (\is_int($value) || \is_float($value)) {
return (string) $value;
}
if (\is_bool($value)) {
return $value ? 'true' : 'false';
}
// @phpstan-ignore-next-line
throw new InvalidArgumentException('$value must be a string, int, float, or bool');
}
private function findXmlRenderer(Node $node): XmlNodeRendererInterface
{
$class = \get_class($node);
if (\array_key_exists($class, $this->rendererCache)) {
return $this->rendererCache[$class];
}
foreach ($this->environment->getRenderersForClass($class) as $renderer) {
if ($renderer instanceof XmlNodeRendererInterface) {
return $this->rendererCache[$class] = $renderer;
}
}
return $this->rendererCache[$class] = $this->fallbackRenderer;
}
}
PK �@]a�*D D " src/Xml/MarkdownToXmlConverter.phpnu �[��� <?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\Xml;
use League\CommonMark\ConverterInterface;
use League\CommonMark\Environment\EnvironmentInterface;
use League\CommonMark\Exception\CommonMarkException;
use League\CommonMark\Output\RenderedContentInterface;
use League\CommonMark\Parser\MarkdownParser;
use League\CommonMark\Parser\MarkdownParserInterface;
use League\CommonMark\Renderer\DocumentRendererInterface;
final class MarkdownToXmlConverter implements ConverterInterface
{
/** @psalm-readonly */
private MarkdownParserInterface $parser;
/** @psalm-readonly */
private DocumentRendererInterface $renderer;
public function __construct(EnvironmentInterface $environment)
{
$this->parser = new MarkdownParser($environment);
$this->renderer = new XmlRenderer($environment);
}
/**
* Converts Markdown to XML
*
* @throws CommonMarkException
*/
public function convert(string $input): RenderedContentInterface
{
return $this->renderer->renderDocument($this->parser->parse($input));
}
/**
* Converts CommonMark to HTML.
*
* @see MarkdownToXmlConverter::convert()
*
* @throws CommonMarkException
*/
public function __invoke(string $input): RenderedContentInterface
{
return $this->convert($input);
}
}
PK �@]i �>� � # src/Xml/FallbackNodeXmlRenderer.phpnu �[��� <?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\Xml;
use League\CommonMark\Node\Block\AbstractBlock;
use League\CommonMark\Node\Inline\AbstractInline;
use League\CommonMark\Node\Node;
/**
* @internal
*/
final class FallbackNodeXmlRenderer implements XmlNodeRendererInterface
{
/**
* @var array<string, string>
*
* @psalm-allow-private-mutation
*/
private array $classCache = [];
/**
* @psalm-allow-private-mutation
*/
public function getXmlTagName(Node $node): string
{
$className = \get_class($node);
if (isset($this->classCache[$className])) {
return $this->classCache[$className];
}
$type = $node instanceof AbstractBlock ? 'block' : 'inline';
$shortName = \strtolower((new \ReflectionClass($node))->getShortName());
return $this->classCache[$className] = \sprintf('custom_%s_%s', $type, $shortName);
}
/**
* {@inheritDoc}
*/
public function getXmlAttributes(Node $node): array
{
$attrs = [];
foreach ($node->data->export() as $k => $v) {
if (self::isValueUsable($v)) {
$attrs[$k] = $v;
}
}
$reflClass = new \ReflectionClass($node);
foreach ($reflClass->getProperties() as $property) {
if (\in_array($property->getDeclaringClass()->getName(), [Node::class, AbstractBlock::class, AbstractInline::class], true)) {
continue;
}
$property->setAccessible(true);
$value = $property->getValue($node);
if (self::isValueUsable($value)) {
$attrs[$property->getName()] = $value;
}
}
return $attrs;
}
/**
* @param mixed $var
*
* @psalm-pure
*/
private static function isValueUsable($var): bool
{
return \is_string($var) || \is_int($var) || \is_float($var) || \is_bool($var);
}
}
PK �@]�f�F� � ( src/Reference/ReferenceableInterface.phpnu �[��� <?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;
}
PK �@]�:< ' src/Reference/ReferenceMapInterface.phpnu �[��� <?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;
}
PK �@]���M M src/Reference/ReferenceMap.phpnu �[��� <?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);
}
}
PK �@]z,�dž � src/Reference/Reference.phpnu �[��� <?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;
}
}
PK �@]�~�Lo o $ src/Reference/ReferenceInterface.phpnu �[��� <?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;
}
PK �@]�;S$ $ ! src/Reference/ReferenceParser.phpnu �[��� <?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;
}
}
PK �@]n�cUk Uk CHANGELOG.mdnu �[��� # Change Log
All notable changes to this project will be documented in this file.
Updates should follow the [Keep a CHANGELOG](https://keepachangelog.com/) principles.
**Upgrading from 1.x?** See <https://commonmark.thephpleague.com/2.0/upgrading/> for additional information.
## [Unreleased][unreleased]
## [2.4.2] - 2024-02-02
### Fixed
- Fixed declaration parser being too strict
- `FencedCodeRenderer`: don't add `language-` to class if already prefixed
## [2.4.1] - 2023-08-30
### Fixed
- Fixed `ExternalLinkProcessor` not fully disabling the `rel` attribute when configured to do so (#992)
## [2.4.0] - 2023-03-24
### Added
- Added generic `CommonMarkException` marker interface for all exceptions thrown by the library
- Added several new specific exception types implementing that marker interface:
- `AlreadyInitializedException`
- `InvalidArgumentException`
- `IOException`
- `LogicException`
- `MissingDependencyException`
- `NoMatchingRendererException`
- `ParserLogicException`
- Added more configuration options to the Heading Permalinks extension (#939):
- `heading_permalink/apply_id_to_heading` - When `true`, the `id` attribute will be applied to the heading element itself instead of the `<a>` tag
- `heading_permalink/heading_class` - class to apply to the heading element
- `heading_permalink/insert` - now accepts `none` to prevent the creation of the `<a>` link
- Added new `table/alignment_attributes` configuration option to control how table cell alignment is rendered (#959)
### Changed
- Change several thrown exceptions from `RuntimeException` to `LogicException` (or something extending it), including:
- `CallbackGenerator`s that fail to set a URL or return an expected value
- `MarkdownParser` when deactivating the last block parser or attempting to get an active block parser when they've all been closed
- Adding items to an already-initialized `Environment`
- Rendering a `Node` when no renderer has been registered for it
- `HeadingPermalinkProcessor` now throws `InvalidConfigurationException` instead of `RuntimeException` when invalid config values are given.
- `HtmlElement::setAttribute()` no longer requires the second parameter for boolean attributes
- Several small micro-optimizations
- Changed Strikethrough to only allow 1 or 2 tildes per the updated GFM spec
### Fixed
- Fixed inaccurate `@throws` docblocks throughout the codebase, including `ConverterInterface`, `MarkdownConverter`, and `MarkdownConverterInterface`.
- These previously suggested that only `\RuntimeException`s were thrown, which was inaccurate as `\LogicException`s were also possible.
## [2.3.9] - 2023-02-15
### Fixed
- Fixed autolink extension not detecting some URIs with underscores (#956)
## [2.3.8] - 2022-12-10
### Fixed
- Fixed parsing issues when `mb_internal_encoding()` is set to something other than `UTF-8` (#951)
## [2.3.7] - 2022-11-03
### Fixed
- Fixed `TaskListItemMarkerRenderer` not including HTML attributes set on the node by other extensions (#947)
## [2.3.6] - 2022-10-30
### Fixed
- Fixed unquoted attribute parsing when closing curly brace is followed by certain characters (like a `.`) (#943)
## [2.3.5] - 2022-07-29
### Fixed
- Fixed error using `InlineParserEngine` when no inline parsers are registered in the `Environment` (#908)
## [2.3.4] - 2022-07-17
### Changed
- Made a number of small tweaks to the embed extension's parsing behavior to fix #898:
- Changed `EmbedStartParser` to always capture embed-like lines in container blocks, regardless of parent block type
- Changed `EmbedProcessor` to also remove `Embed` blocks that aren't direct children of the `Document`
- Increased the priority of `EmbedProcessor` to `1010`
### Fixed
- Fixed `EmbedExtension` not parsing embeds following a list block (#898)
## [2.3.3] - 2022-06-07
### Fixed
- Fixed `DomainFilteringAdapter` not reindexing the embed list (#884, #885)
## [2.3.2] - 2022-06-03
### Fixed
- Fixed FootnoteExtension stripping extra characters from tab-indented footnotes (#881)
## [2.2.5] - 2022-06-03
### Fixed
- Fixed FootnoteExtension stripping extra characters from tab-indented footnotes (#881)
## [2.3.1] - 2022-05-14
### Fixed
- Fixed AutolinkExtension not ignoring trailing strikethrough syntax (#867)
## [2.2.4] - 2022-05-14
### Fixed
- Fixed AutolinkExtension not ignoring trailing strikethrough syntax (#867)
## [2.3.0] - 2022-04-07
### Added
- Added new `EmbedExtension` (#805)
- Added `DocumentRendererInterface` as a replacement for the now-deprecated `MarkdownRendererInterface`
### Deprecated
- Deprecated `MarkdownRendererInterface`; use `DocumentRendererInterface` instead
## [2.2.3] - 2022-02-26
### Fixed
- Fixed front matter parsing with Windows line endings (#821)
## [2.1.3] - 2022-02-26
### Fixed
- Fixed front matter parsing with Windows line endings (#821)
## [2.0.4] - 2022-02-26
### Fixed
- Fixed front matter parsing with Windows line endings (#821)
## [2.2.2] - 2022-02-13
### Fixed
- Fixed double-escaping of image alt text (#806, #810)
- Fixed Psalm typehints for event class names
## [2.2.1] - 2022-01-25
### Fixed
- Fixed `symfony/deprecation-contracts` constraint
### Removed
- Removed deprecation trigger from `MarkdownConverterInterface` to reduce noise
## [2.2.0] - 2022-01-22
### Added
- Added new `ConverterInterface`
- Added new `MarkdownToXmlConverter` class
- Added new `HtmlDecorator` class which can wrap existing renderers with additional HTML tags
- Added new `table/wrap` config to apply an optional wrapping/container element around a table (#780)
### Changed
- `HtmlElement` contents can now consist of any `Stringable`, not just `HtmlElement` and `string`
### Deprecated
- Deprecated `MarkdownConverterInterface` and its `convertToHtml()` method; use `ConverterInterface` and `convert()` instead
## [2.1.2] - 2022-02-13
### Fixed
- Fixed double-escaping of image alt text (#806, #810)
- Fixed Psalm typehints for event class names
## [2.1.1] - 2022-01-02
### Added
- Added missing return type to `Environment::dispatch()` to fix deprecation warning (#778)
## [2.1.0] - 2021-12-05
### Added
- Added support for ext-yaml in FrontMatterExtension (#715)
- Added support for symfony/yaml v6.0 in FrontMatterExtension (#739)
- Added new `heading_permalink/aria_hidden` config option (#741)
### Fixed
- Fixed PHP 8.1 deprecation warning (#759, #762)
## [2.0.3] - 2022-02-13
### Fixed
- Fixed double-escaping of image alt text (#806, #810)
- Fixed Psalm typehints for event class names
## [2.0.2] - 2021-08-14
### Changed
- Bumped minimum version of league/config to support PHP 8.1
### Fixed
- Fixed ability to register block parsers that identify lines starting with letters (#706)
## [2.0.1] - 2021-07-31
### Fixed
- Fixed nested autolinks (#689)
- Fixed description lists being parsed incorrectly (#692)
- Fixed Table of Contents not respecting Heading Permalink prefixes (#690)
## [2.0.0] - 2021-07-24
No changes were introduced since the previous RC2 release.
See all entries below for a list of changes between 1.x and 2.0.
## [2.0.0-rc2] - 2021-07-17
### Fixed
- Fixed Mentions inside of links creating nested links against the spec's rules (#688)
## [2.0.0-rc1] - 2021-07-10
No changes were introduced since the previous release.
## [2.0.0-beta3] - 2021-07-03
### Changed
- Any leading UTF-8 BOM will be stripped from the input
- The `getEnvironment()` method of `CommonMarkConverter` and `GithubFlavoredMarkdownConverter` will always return the concrete, configurable `Environment` for upgrading convenience
- Optimized AST iteration
- Lots of small micro-optimizations
## [2.0.0-beta2] - 2021-06-27
### Added
- Added new `Node::iterator()` method and `NodeIterator` class for faster AST iteration (#683, #684)
### Changed
- Made compatible with CommonMark spec 0.30.0
- Optimized link label parsing
- Optimized AST iteration for a 50% performance boost in some event listeners (#683, #684)
### Fixed
- Fixed processing instructions with EOLs
- Fixed case-insensitive matching for HTML tag types
- Fixed type 7 HTML blocks incorrectly interrupting lazy paragraphs
- Fixed newlines in reference labels not collapsing into spaces
- Fixed link label normalization with escaped newlines
- Fixed unnecessary AST iteration when no default attributes are configured
## [2.0.0-beta1] - 2021-06-20
### Added
- **Added three new extensions:**
- `FrontMatterExtension` ([see documentation](https://commonmark.thephpleague.com/extensions/front-matter/))
- `DescriptionListExtension` ([see documentation](https://commonmark.thephpleague.com/extensions/description-lists/))
- `DefaultAttributesExtension` ([see documentation](https://commonmark.thephpleague.com/extensions/default-attributes/))
- **Added new `XmlRenderer` to simplify AST debugging** ([see documentation](https://commonmark.thephpleague.com/xml/)) (#431)
- **Added the ability to configure disallowed raw HTML tags** (#507)
- **Added the ability for Mentions to use multiple characters for their symbol** (#514, #550)
- **Added the ability to delegate event dispatching to PSR-14 compliant event dispatcher libraries**
- **Added new configuration options:**
- Added `heading_permalink/min_heading_level` and `heading_permalink/max_heading_level` options to control which headings get permalinks (#519)
- Added `heading_permalink/fragment_prefix` to allow customizing the URL fragment prefix (#602)
- Added `footnote/backref_symbol` option for customizing backreference link appearance (#522)
- Added `slug_normalizer/max_length` option to control the maximum length of generated URL slugs
- Added `slug_normalizer/unique` option to control whether unique slugs should be generated per-document or per-environment
- **Added purity markers throughout the codebase** (verified with Psalm)
- Added `Query` class to simplify Node traversal when looking to take action on certain Nodes
- Added new `HtmlFilter` and `StringContainerHelper` utility classes
- Added new `AbstractBlockContinueParser` class to simplify the creation of custom block parsers
- Added several new classes and interfaces:
- `BlockContinue`
- `BlockContinueParserInterface`
- `BlockContinueParserWithInlinesInterface`
- `BlockStart`
- `BlockStartParserInterface`
- `ChildNodeRendererInterface`
- `ConfigurableExtensionInterface`
- `CursorState`
- `DashParser` (extracted from `PunctuationParser`)
- `DelimiterParser`
- `DocumentBlockParser`
- `DocumentPreRenderEvent`
- `DocumentRenderedEvent`
- `EllipsesParser` (extracted from `PunctuationParser`)
- `ExpressionInterface`
- `FallbackNodeXmlRenderer`
- `InlineParserEngineInterface`
- `InlineParserMatch`
- `MarkdownParserState`
- `MarkdownParserStateInterface`
- `MarkdownRendererInterface`
- `Query`
- `RawMarkupContainerInterface`
- `ReferenceableInterface`
- `RenderedContent`
- `RenderedContentInterface`
- `ReplaceUnpairedQuotesListener`
- `SpecReader`
- `TableOfContentsRenderer`
- `UniqueSlugNormalizer`
- `UniqueSlugNormalizerInterface`
- `XmlRenderer`
- `XmlNodeRendererInterface`
- Added several new methods:
- `Cursor::getCurrentCharacter()`
- `Environment::createDefaultConfiguration()`
- `Environment::setEventDispatcher()`
- `EnvironmentInterface::getExtensions()`
- `EnvironmentInterface::getInlineParsers()`
- `EnvironmentInterface::getSlugNormalizer()`
- `FencedCode::setInfo()`
- `Heading::setLevel()`
- `HtmlRenderer::renderDocument()`
- `InlineParserContext::getFullMatch()`
- `InlineParserContext::getFullMatchLength()`
- `InlineParserContext::getMatches()`
- `InlineParserContext::getSubMatches()`
- `LinkParserHelper::parsePartialLinkLabel()`
- `LinkParserHelper::parsePartialLinkTitle()`
- `Node::assertInstanceOf()`
- `RegexHelper::isLetter()`
- `StringContainerInterface::setLiteral()`
- `TableCell::getType()`
- `TableCell::setType()`
- `TableCell::getAlign()`
- `TableCell::setAlign()`
### Changed
- **Changed the converter return type**
- `CommonMarkConverter::convertToHtml()` now returns an instance of `RenderedContentInterface`. This can be cast to a string for backward compatibility with 1.x.
- **Table of Contents items are no longer wrapped with `<p>` tags** (#613)
- **Heading Permalinks now link to element IDs instead of using `name` attributes** (#602)
- **Heading Permalink IDs and URL fragments now have a `content` prefix by default** (#602)
- **Changes to configuration options:**
- `enable_em` has been renamed to `commonmark/enable_em`
- `enable_strong` has been renamed to `commonmark/enable_strong`
- `use_asterisk` has been renamed to `commonmark/use_asterisk`
- `use_underscore` has been renamed to `commonmark/use_underscore`
- `unordered_list_markers` has been renamed to `commonmark/unordered_list_markers`
- `mentions/*/symbol` has been renamed to `mentions/*/prefix`
- `mentions/*/regex` has been renamed to `mentions/*/pattern` and requires partial regular expressions (without delimiters or flags)
- `max_nesting_level` now defaults to `PHP_INT_MAX` and no longer supports floats
- `heading_permalink/slug_normalizer` has been renamed to `slug_normalizer/instance`
- **Event dispatching is now fully PSR-14 compliant**
- **Moved and renamed several classes** - [see the full list here](https://commonmark.thephpleague.com/2.0/upgrading/#classesnamespaces-renamed)
- The `HeadingPermalinkExtension` and `FootnoteExtension` were modified to ensure they never produce a slug which conflicts with slugs created by the other extension
- `SlugNormalizer::normalizer()` now supports optional prefixes and max length options passed in via the `$context` argument
- The `AbstractBlock::$data` and `AbstractInline::$data` arrays were replaced with a `Data` array-like object on the base `Node` class
- **Implemented a new approach to block parsing.** This was a massive change, so here are the highlights:
- Functionality previously found in block parsers and node elements has moved to block parser factories and block parsers, respectively ([more details](https://commonmark.thephpleague.com/2.0/upgrading/#new-block-parsing-approach))
- `ConfigurableEnvironmentInterface::addBlockParser()` is now `EnvironmentBuilderInterface::addBlockParserFactory()`
- `ReferenceParser` was re-implemented and works completely different than before
- The paragraph parser no longer needs to be added manually to the environment
- **Implemented a new approach to inline parsing** where parsers can now specify longer strings or regular expressions they want to parse (instead of just single characters):
- `InlineParserInterface::getCharacters()` is now `getMatchDefinition()` and returns an instance of `InlineParserMatch`
- `InlineParserContext::__construct()` now requires the contents to be provided as a `Cursor` instead of a `string`
- **Implemented delimiter parsing as a special type of inline parser** (via the new `DelimiterParser` class)
- **Changed block and inline rendering to use common methods and interfaces**
- `BlockRendererInterface` and `InlineRendererInterface` were replaced by `NodeRendererInterface` with slightly different parameters. All core renderers now implement this interface.
- `ConfigurableEnvironmentInterface::addBlockRenderer()` and `addInlineRenderer()` were combined into `EnvironmentBuilderInterface::addRenderer()`
- `EnvironmentInterface::getBlockRenderersForClass()` and `getInlineRenderersForClass()` are now just `getRenderersForClass()`
- **Completely refactored the Configuration implementation**
- All configuration-specific classes have been moved into a new `league/config` package with a new namespace
- `Configuration` objects must now be configured with a schema and all options must match that schema - arbitrary keys are no longer permitted
- `Configuration::__construct()` no longer accepts the default configuration values - use `Configuration::merge()` instead
- `ConfigurationInterface` now only contains a `get(string $key)`; this method no longer allows arbitrary default values to be returned if the option is missing
- `ConfigurableEnvironmentInterface` was renamed to `EnvironmentBuilderInterface`
- `ExtensionInterface::register()` now requires an `EnvironmentBuilderInterface` param instead of `ConfigurableEnvironmentInterface`
- **Added missing return types to virtually every class and interface method**
- Re-implemented the GFM Autolink extension using the new inline parser approach instead of document processors
- `EmailAutolinkProcessor` is now `EmailAutolinkParser`
- `UrlAutolinkProcessor` is now `UrlAutolinkParser`
- `HtmlElement` can now properly handle array (i.e. `class`) and boolean (i.e. `checked`) attribute values
- `HtmlElement` automatically flattens any attributes with array values into space-separated strings, removing duplicate entries
- Combined separate classes/interfaces into one:
- `DisallowedRawHtmlRenderer` replaces `DisallowedRawHtmlBlockRenderer` and `DisallowedRawHtmlInlineRenderer`
- `NodeRendererInterface` replaces `BlockRendererInterface` and `InlineRendererInterface`
- Renamed the following methods:
- `Environment` and `ConfigurableEnvironmentInterface`:
- `addBlockParser()` is now `addBlockStartParser()`
- `ReferenceMap` and `ReferenceMapInterface`:
- `addReference()` is now `add()`
- `getReference()` is now `get()`
- `listReferences()` is now `getIterator()`
- Various node (block/inline) classes:
- `getContent()` is now `getLiteral()`
- `setContent()` is now `setLiteral()`
- Moved and renamed the following constants:
- `EnvironmentInterface::HTML_INPUT_ALLOW` is now `HtmlFilter::ALLOW`
- `EnvironmentInterface::HTML_INPUT_ESCAPE` is now `HtmlFilter::ESCAPE`
- `EnvironmentInterface::HTML_INPUT_STRIP` is now `HtmlFilter::STRIP`
- `TableCell::TYPE_HEAD` is now `TableCell::TYPE_HEADER`
- `TableCell::TYPE_BODY` is now `TableCell::TYPE_DATA`
- Changed the visibility of the following properties:
- `AttributesInline::$attributes` is now `private`
- `AttributesInline::$block` is now `private`
- `TableCell::$align` is now `private`
- `TableCell::$type` is now `private`
- `TableSection::$type` is now `private`
- Several methods which previously returned `$this` now return `void`
- `Delimiter::setPrevious()`
- `Node::replaceChildren()`
- `Context::setTip()`
- `Context::setContainer()`
- `Context::setBlocksParsed()`
- `AbstractStringContainer::setContent()`
- `AbstractWebResource::setUrl()`
- Several classes are now marked `final`:
- `ArrayCollection`
- `Emphasis`
- `FencedCode`
- `Heading`
- `HtmlBlock`
- `HtmlElement`
- `HtmlInline`
- `IndentedCode`
- `Newline`
- `Strikethrough`
- `Strong`
- `Text`
- `Heading` nodes no longer directly contain a copy of their inner text
- `StringContainerInterface` can now be used for inlines, not just blocks
- `ArrayCollection` only supports integer keys
- `HtmlElement` now implements `Stringable`
- `Cursor::saveState()` and `Cursor::restoreState()` now use `CursorState` objects instead of arrays
- `NodeWalker::next()` now enters, traverses any children, and leaves all elements which may have children (basically all blocks plus any inlines with children). Previously, it only did this for elements explicitly marked as "containers".
- `InvalidOptionException` was removed
- Anything with a `getReference(): ReferenceInterface` method now implements `ReferencableInterface`
- The `SmartPunct` extension now replaces all unpaired `Quote` elements with `Text` elements towards the end of parsing, making the `QuoteRenderer` unnecessary
- Several changes made to the Footnote extension:
- Footnote identifiers can no longer contain spaces
- Anonymous footnotes can now span subsequent lines
- Footnotes can now contain multiple lines of content, including sub-blocks, by indenting them
- Footnote event listeners now have numbered priorities (but still execute in the same order)
- Footnotes must now be separated from previous content by a blank line
- The line numbers (keys) returned via `MarkdownInput::getLines()` now start at 1 instead of 0
- `DelimiterProcessorCollectionInterface` now extends `Countable`
- `RegexHelper::PARTIAL_` constants must always be used in case-insensitive contexts
- `HeadingPermalinkProcessor` no longer accepts text normalizers via the constructor - these must be provided via configuration instead
- Blocks which can't contain inlines will no longer be asked to render inlines
- `AnonymousFootnoteRefParser` and `HeadingPermalinkProcessor` now implement `EnvironmentAwareInterface` instead of `ConfigurationAwareInterface`
- The second argument to `TextNormalizerInterface::normalize()` must now be an array
- The `title` attribute for `Link` and `Image` nodes is now stored using a dedicated property instead of stashing it in `$data`
- `ListData::$delimiter` now returns either `ListBlock::DELIM_PERIOD` or `ListBlock::DELIM_PAREN` instead of the literal delimiter
### Fixed
- **Fixed parsing of footnotes without content**
- **Fixed rendering of orphaned footnotes and footnote refs**
- **Fixed some URL autolinks breaking too early** (#492)
- Fixed `AbstractStringContainer` not actually being `abstract`
### Removed
- **Removed support for PHP 7.1, 7.2, and 7.3** (#625, #671)
- **Removed all previously-deprecated functionality:**
- Removed the ability to pass custom `Environment` instances into the `CommonMarkConverter` and `GithubFlavoredMarkdownConverter` constructors
- Removed the `Converter` class and `ConverterInterface`
- Removed the `bin/commonmark` script
- Removed the `Html5Entities` utility class
- Removed the `InlineMentionParser` (use `MentionParser` instead)
- Removed `DefaultSlugGenerator` and `SlugGeneratorInterface` from the `Extension/HeadingPermalink/Slug` sub-namespace (use the new ones under `./SlugGenerator` instead)
- Removed the following `ArrayCollection` methods:
- `add()`
- `set()`
- `get()`
- `remove()`
- `isEmpty()`
- `contains()`
- `indexOf()`
- `containsKey()`
- `replaceWith()`
- `removeGaps()`
- Removed the `ConfigurableEnvironmentInterface::setConfig()` method
- Removed the `ListBlock::TYPE_UNORDERED` constant
- Removed the `CommonMarkConverter::VERSION` constant
- Removed the `HeadingPermalinkRenderer::DEFAULT_INNER_CONTENTS` constant
- Removed the `heading_permalink/inner_contents` configuration option
- **Removed now-unused classes:**
- `AbstractStringContainerBlock`
- `BlockRendererInterface`
- `Context`
- `ContextInterface`
- `Converter`
- `ConverterInterface`
- `InlineRendererInterface`
- `PunctuationParser` (was split into two classes: `DashParser` and `EllipsesParser`)
- `QuoteRenderer`
- `UnmatchedBlockCloser`
- Removed the following methods, properties, and constants:
- `AbstractBlock::$open`
- `AbstractBlock::$lastLineBlank`
- `AbstractBlock::isContainer()`
- `AbstractBlock::canContain()`
- `AbstractBlock::isCode()`
- `AbstractBlock::matchesNextLine()`
- `AbstractBlock::endsWithBlankLine()`
- `AbstractBlock::setLastLineBlank()`
- `AbstractBlock::shouldLastLineBeBlank()`
- `AbstractBlock::isOpen()`
- `AbstractBlock::finalize()`
- `AbstractBlock::getData()`
- `AbstractInline::getData()`
- `ConfigurableEnvironmentInterface::addBlockParser()`
- `ConfigurableEnvironmentInterface::mergeConfig()`
- `Delimiter::setCanClose()`
- `EnvironmentInterface::getConfig()`
- `EnvironmentInterface::getInlineParsersForCharacter()`
- `EnvironmentInterface::getInlineParserCharacterRegex()`
- `HtmlRenderer::renderBlock()`
- `HtmlRenderer::renderBlocks()`
- `HtmlRenderer::renderInline()`
- `HtmlRenderer::renderInlines()`
- `Node::isContainer()`
- `RegexHelper::matchAll()` (use the new `matchFirst()` method instead)
- `RegexHelper::REGEX_WHITESPACE`
- Removed the second `$contents` argument from the `Heading` constructor
### Deprecated
**The following things have been deprecated and will not be supported in v3.0:**
- `Environment::mergeConfig()` (set configuration before instantiation instead)
- `Environment::createCommonMarkEnvironment()` and `Environment::createGFMEnvironment()`
- Alternative 1: Use `CommonMarkConverter` or `GithubFlavoredMarkdownConverter` if you don't need to customize the environment
- Alternative 2: Instantiate a new `Environment` and add the necessary extensions yourself
[unreleased]: https://github.com/thephpleague/commonmark/compare/2.4.2...main
[2.4.2]: https://github.com/thephpleague/commonmark/compare/2.4.1...2.4.2
[2.4.1]: https://github.com/thephpleague/commonmark/compare/2.4.0...2.4.1
[2.4.0]: https://github.com/thephpleague/commonmark/compare/2.3.9...2.4.0
[2.3.9]: https://github.com/thephpleague/commonmark/compare/2.3.8...2.3.9
[2.3.8]: https://github.com/thephpleague/commonmark/compare/2.3.7...2.3.8
[2.3.7]: https://github.com/thephpleague/commonmark/compare/2.3.6...2.3.7
[2.3.6]: https://github.com/thephpleague/commonmark/compare/2.3.5...2.3.6
[2.3.5]: https://github.com/thephpleague/commonmark/compare/2.3.4...2.3.5
[2.3.4]: https://github.com/thephpleague/commonmark/compare/2.3.3...2.3.4
[2.3.3]: https://github.com/thephpleague/commonmark/compare/2.3.2...2.3.3
[2.3.2]: https://github.com/thephpleague/commonmark/compare/2.3.2...main
[2.3.1]: https://github.com/thephpleague/commonmark/compare/2.3.0...2.3.1
[2.3.0]: https://github.com/thephpleague/commonmark/compare/2.2.3...2.3.0
[2.2.5]: https://github.com/thephpleague/commonmark/compare/2.2.4...2.2.5
[2.2.4]: https://github.com/thephpleague/commonmark/compare/2.2.3...2.2.4
[2.2.3]: https://github.com/thephpleague/commonmark/compare/2.2.2...2.2.3
[2.2.2]: https://github.com/thephpleague/commonmark/compare/2.2.1...2.2.2
[2.2.1]: https://github.com/thephpleague/commonmark/compare/2.2.0...2.2.1
[2.2.0]: https://github.com/thephpleague/commonmark/compare/2.1.1...2.2.0
[2.1.3]: https://github.com/thephpleague/commonmark/compare/2.1.2...2.1.3
[2.1.2]: https://github.com/thephpleague/commonmark/compare/2.1.1...2.1.2
[2.1.1]: https://github.com/thephpleague/commonmark/compare/2.0.2...2.1.1
[2.1.0]: https://github.com/thephpleague/commonmark/compare/2.0.2...2.1.0
[2.0.4]: https://github.com/thephpleague/commonmark/compare/2.0.3...2.0.4
[2.0.3]: https://github.com/thephpleague/commonmark/compare/2.0.2...2.0.3
[2.0.2]: https://github.com/thephpleague/commonmark/compare/2.0.1...2.0.2
[2.0.1]: https://github.com/thephpleague/commonmark/compare/2.0.0...2.0.1
[2.0.0]: https://github.com/thephpleague/commonmark/compare/2.0.0-rc2...2.0.0
[2.0.0-rc2]: https://github.com/thephpleague/commonmark/compare/2.0.0-rc1...2.0.0-rc2
[2.0.0-rc1]: https://github.com/thephpleague/commonmark/compare/2.0.0-beta3...2.0.0-rc1
[2.0.0-beta3]: https://github.com/thephpleague/commonmark/compare/2.0.0-beta2...2.0.0-beta3
[2.0.0-beta2]: https://github.com/thephpleague/commonmark/compare/2.0.0-beta1...2.0.0-beta2
[2.0.0-beta1]: https://github.com/thephpleague/commonmark/compare/1.6...2.0.0-beta1
PK �@]Y�r�
composer.jsonnu �[��� {
"name": "league/commonmark",
"type": "library",
"description": "Highly-extensible PHP Markdown parser which fully supports the CommonMark spec and GitHub-Flavored Markdown (GFM)",
"keywords": ["markdown","parser","commonmark","gfm","github","flavored","github-flavored","md"],
"homepage": "https://commonmark.thephpleague.com",
"license": "BSD-3-Clause",
"authors": [
{
"name": "Colin O'Dell",
"email": "colinodell@gmail.com",
"homepage": "https://www.colinodell.com",
"role": "Lead Developer"
}
],
"support": {
"docs": "https://commonmark.thephpleague.com/",
"forum": "https://github.com/thephpleague/commonmark/discussions",
"issues": "https://github.com/thephpleague/commonmark/issues",
"rss": "https://github.com/thephpleague/commonmark/releases.atom",
"source": "https://github.com/thephpleague/commonmark"
},
"require": {
"php": "^7.4 || ^8.0",
"ext-mbstring": "*",
"league/config": "^1.1.1",
"psr/event-dispatcher": "^1.0",
"symfony/deprecation-contracts": "^2.1 || ^3.0",
"symfony/polyfill-php80": "^1.16"
},
"require-dev": {
"ext-json": "*",
"cebe/markdown": "^1.0",
"commonmark/cmark": "0.30.3",
"commonmark/commonmark.js": "0.30.0",
"composer/package-versions-deprecated": "^1.8",
"embed/embed": "^4.4",
"erusev/parsedown": "^1.0",
"github/gfm": "0.29.0",
"michelf/php-markdown": "^1.4 || ^2.0",
"nyholm/psr7": "^1.5",
"phpstan/phpstan": "^1.8.2",
"phpunit/phpunit": "^9.5.21 || ^10.5.9 || ^11.0.0",
"scrutinizer/ocular": "^1.8.1",
"symfony/finder": "^5.3 | ^6.0 || ^7.0",
"symfony/yaml": "^2.3 | ^3.0 | ^4.0 | ^5.0 | ^6.0 || ^7.0",
"unleashedtech/php-coding-standard": "^3.1.1",
"vimeo/psalm": "^4.24.0 || ^5.0.0"
},
"minimum-stability": "beta",
"suggest": {
"symfony/yaml": "v2.3+ required if using the Front Matter extension"
},
"repositories": [
{
"type": "package",
"package": {
"name": "commonmark/commonmark.js",
"version": "0.30.0",
"dist": {
"url": "https://github.com/commonmark/commonmark.js/archive/0.30.0.zip",
"type": "zip"
}
}
},
{
"type": "package",
"package": {
"name": "commonmark/cmark",
"version": "0.30.3",
"dist": {
"url": "https://github.com/commonmark/cmark/archive/0.30.3.zip",
"type": "zip"
}
}
},
{
"type": "package",
"package": {
"name": "github/gfm",
"version": "0.29.0",
"dist": {
"url": "https://github.com/github/cmark-gfm/archive/0.29.0.gfm.13.zip",
"type": "zip"
}
}
}
],
"autoload": {
"psr-4": {
"League\\CommonMark\\": "src"
}
},
"autoload-dev": {
"psr-4": {
"League\\CommonMark\\Tests\\Unit\\": "tests/unit",
"League\\CommonMark\\Tests\\Functional\\": "tests/functional",
"League\\CommonMark\\Tests\\PHPStan\\": "tests/phpstan"
}
},
"scripts": {
"phpcs": "phpcs",
"phpstan": "phpstan analyse",
"phpunit": "phpunit --no-coverage",
"psalm": "psalm --stats",
"test": [
"@phpcs",
"@phpstan",
"@psalm",
"@phpunit"
]
},
"extra": {
"branch-alias": {
"dev-main": "2.5-dev"
}
},
"config": {
"allow-plugins": {
"composer/package-versions-deprecated": true,
"dealerdirect/phpcodesniffer-composer-installer": true
},
"sort-packages": true
}
}
PK �@]U"�s� � .phpstorm.meta.phpnu �[��� <?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.
*/
namespace PHPSTORM_META
{
expectedArguments(\League\CommonMark\Util\HtmlElement::__construct(), 0, 'a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kdb', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'pre', 'progress', 'q', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr');
expectedArguments(\League\CommonMark\Extension\CommonMark\Node\Block\Heading::__construct(), 0, 1, 2, 3, 4, 5, 6);
expectedReturnValues(\League\CommonMark\Extension\CommonMark\Node\Block\Heading::getLevel(), 1, 2, 3, 4, 5, 6);
registerArgumentsSet('league_commonmark_htmlblock_types', \League\CommonMark\Extension\CommonMark\Node\Block\HtmlBlock::TYPE_1_CODE_CONTAINER, \League\CommonMark\Extension\CommonMark\Node\Block\HtmlBlock::TYPE_2_COMMENT, \League\CommonMark\Extension\CommonMark\Node\Block\HtmlBlock::TYPE_3, \League\CommonMark\Extension\CommonMark\Node\Block\HtmlBlock::TYPE_4, \League\CommonMark\Extension\CommonMark\Node\Block\HtmlBlock::TYPE_5_CDATA, \League\CommonMark\Extension\CommonMark\Node\Block\HtmlBlock::TYPE_6_BLOCK_ELEMENT, \League\CommonMark\Extension\CommonMark\Node\Block\HtmlBlock::TYPE_7_MISC_ELEMENT);
expectedArguments(\League\CommonMark\Extension\CommonMark\Node\Block\HtmlBlock::__construct(), 0, argumentsSet('league_commonmark_htmlblock_types'));
expectedArguments(\League\CommonMark\Extension\CommonMark\Node\Block\HtmlBlock::setType(), 0, argumentsSet('league_commonmark_htmlblock_types'));
expectedReturnValues(\League\CommonMark\Extension\CommonMark\Node\Block\HtmlBlock::getType(), argumentsSet('league_commonmark_htmlblock_types'));
expectedArguments(\League\CommonMark\Util\RegexHelper::getHtmlBlockOpenRegex(), 0, argumentsSet('league_commonmark_htmlblock_types'));
expectedArguments(\League\CommonMark\Util\RegexHelper::getHtmlBlockCloseRegex(), 0, argumentsSet('league_commonmark_htmlblock_types'));
registerArgumentsSet('league_commonmark_newline_types', \League\CommonMark\Node\Inline\Newline::HARDBREAK, \League\CommonMark\Node\Inline\Newline::SOFTBREAK);
expectedArguments(\League\CommonMark\Node\Inline\Newline::__construct(), 0, argumentsSet('league_commonmark_newline_types'));
expectedReturnValues(\League\CommonMark\Node\Inline\Newline::getType(), argumentsSet('league_commonmark_newline_types'));
registerArgumentsSet('league_commonmark_options',
'html_input',
'allow_unsafe_links',
'max_nesting_level',
'renderer',
'renderer/block_separator',
'renderer/inner_separator',
'renderer/soft_break',
'commonmark',
'commonmark/enable_em',
'commonmark/enable_strong',
'commonmark/use_asterisk',
'commonmark/use_underscore',
'commonmark/unordered_list_markers',
'disallowed_raw_html',
'disallowed_raw_html/disallowed_tags',
'external_link',
'external_link/html_class',
'external_link/internal_hosts',
'external_link/nofollow',
'external_link/noopener',
'external_link/noreferrer',
'external_link/open_in_new_window',
'footnote',
'footnote/backref_class',
'footnote/backref_symbol',
'footnote/container_add_hr',
'footnote/container_class',
'footnote/ref_class',
'footnote/ref_id_prefix',
'footnote/footnote_class',
'footnote/footnote_id_prefix',
'heading_permalink',
'heading_permalink/apply_id_to_heading',
'heading_permalink/heading_class',
'heading_permalink/html_class',
'heading_permalink/fragment_prefix',
'heading_permalink/id_prefix',
'heading_permalink/inner_contents',
'heading_permalink/insert',
'heading_permalink/max_heading_level',
'heading_permalink/min_heading_level',
'heading_permalink/symbol',
'heading_permalink/title',
'mentions',
'smartpunct/double_quote_closer',
'smartpunct/double_quote_opener',
'smartpunct/single_quote_closer',
'smartpunct/single_quote_opener',
'slug_normalizer',
'slug_normalizer/instance',
'slug_normalizer/max_length',
'slug_normalizer/unique',
'table',
'table/wrap',
'table/wrap/attributes',
'table/wrap/enabled',
'table/wrap/tag',
'table/alignment_attributes',
'table/alignment_attributes/left',
'table/alignment_attributes/center',
'table/alignment_attributes/right',
'table_of_contents',
'table_of_contents/html_class',
'table_of_contents/max_heading_level',
'table_of_contents/min_heading_level',
'table_of_contents/normalize',
'table_of_contents/placeholder',
'table_of_contents/position',
'table_of_contents/style',
);
expectedArguments(\League\Config\ConfigurationInterface::get(), 0, argumentsSet('league_commonmark_options'));
expectedArguments(\League\Config\ConfigurationInterface::exists(), 0, argumentsSet('league_commonmark_options'));
expectedArguments(\League\Config\MutableConfigurationInterface::set(), 0, argumentsSet('league_commonmark_options'));
}
PK �@]�� �/ �/ README.mdnu �[��� # league/commonmark
[](https://packagist.org/packages/league/commonmark)
[](https://packagist.org/packages/league/commonmark)
[](LICENSE)
[](https://github.com/thephpleague/commonmark/actions?query=workflow%3ATests+branch%3Amain)
[](https://scrutinizer-ci.com/g/thephpleague/commonmark/code-structure)
[](https://scrutinizer-ci.com/g/thephpleague/commonmark)
[](https://shepherd.dev/github/thephpleague/commonmark)
[](https://bestpractices.coreinfrastructure.org/projects/126)
[](https://www.colinodell.com/sponsor)
**league/commonmark** is a highly-extensible PHP Markdown parser created by [Colin O'Dell][@colinodell] which supports the full [CommonMark] spec and [GitHub-Flavored Markdown]. It is based on the [CommonMark JS reference implementation][commonmark.js] by [John MacFarlane] \([@jgm]\).
## 📦 Installation & Basic Usage
This project requires PHP 7.4 or higher with the `mbstring` extension. To install it via [Composer] simply run:
``` bash
$ composer require league/commonmark
```
The `CommonMarkConverter` class provides a simple wrapper for converting CommonMark to HTML:
```php
use League\CommonMark\CommonMarkConverter;
$converter = new CommonMarkConverter([
'html_input' => 'strip',
'allow_unsafe_links' => false,
]);
echo $converter->convert('# Hello World!');
// <h1>Hello World!</h1>
```
Or if you want GitHub-Flavored Markdown, use the `GithubFlavoredMarkdownConverter` class instead:
```php
use League\CommonMark\GithubFlavoredMarkdownConverter;
$converter = new GithubFlavoredMarkdownConverter([
'html_input' => 'strip',
'allow_unsafe_links' => false,
]);
echo $converter->convert('# Hello World!');
// <h1>Hello World!</h1>
```
Please note that only UTF-8 and ASCII encodings are supported. If your Markdown uses a different encoding please convert it to UTF-8 before running it through this library.
🔒 If you will be parsing untrusted input from users, please consider setting the `html_input` and `allow_unsafe_links` options per the example above. See <https://commonmark.thephpleague.com/security/> for more details. If you also do choose to allow raw HTML input from untrusted users, consider using a library (like [HTML Purifier](https://github.com/ezyang/htmlpurifier)) to provide additional HTML filtering.
## 📓 Documentation
Full documentation on advanced usage, configuration, and customization can be found at [commonmark.thephpleague.com][docs].
## ⏫ Upgrading
Information on how to upgrade to newer versions of this library can be found at <https://commonmark.thephpleague.com/releases>.
## 💻 GitHub-Flavored Markdown
The `GithubFlavoredMarkdownConverter` shown earlier is a drop-in replacement for the `CommonMarkConverter` which adds additional features found in the GFM spec:
- Autolinks
- Disallowed raw HTML
- Strikethrough
- Tables
- Task Lists
See the [Extensions documentation](https://commonmark.thephpleague.com/customization/extensions/) for more details on how to include only certain GFM features if you don't want them all.
## 🗃️ Related Packages
### Integrations
- [CakePHP 3](https://github.com/gourmet/common-mark)
- [Drupal](https://www.drupal.org/project/markdown)
- [Laravel 4+](https://github.com/GrahamCampbell/Laravel-Markdown)
- [Sculpin](https://github.com/bcremer/sculpin-commonmark-bundle)
- [Symfony 2 & 3](https://github.com/webuni/commonmark-bundle)
- [Symfony 4](https://github.com/avensome/commonmark-bundle)
- [Twig Markdown extension](https://github.com/twigphp/markdown-extension)
- [Twig filter and tag](https://github.com/aptoma/twig-markdown)
- [Laravel CommonMark Blog](https://github.com/spekulatius/laravel-commonmark-blog)
### Included Extensions
See [our extension documentation](https://commonmark.thephpleague.com/extensions/overview) for a full list of extensions bundled with this library.
### Community Extensions
Custom parsers/renderers can be bundled into extensions which extend CommonMark. Here are some that you may find interesting:
- [Emoji extension](https://github.com/ElGigi/CommonMarkEmoji) - UTF-8 emoji extension with Github tag.
- [Sup Sub extensions](https://github.com/OWS/commonmark-sup-sub-extensions) - Adds support of superscript and subscript (`<sup>` and `<sub>` HTML tags)
- [YouTube iframe extension](https://github.com/zoonru/commonmark-ext-youtube-iframe) - Replaces youtube link with iframe.
- [Lazy Image extension](https://github.com/simonvomeyser/commonmark-ext-lazy-image) - Adds various options for lazy loading of images.
- [Marker Extension](https://github.com/noah1400/commonmark-marker-extension) - Adds support of highlighted text (`<mark>` HTML tag)
Others can be found on [Packagist under the `commonmark-extension` package type](https://packagist.org/packages/league/commonmark?type=commonmark-extension).
If you build your own, feel free to submit a PR to add it to this list!
### Others
Check out the other cool things people are doing with `league/commonmark`: <https://packagist.org/packages/league/commonmark/dependents>
## 🏷️ Versioning
[SemVer](http://semver.org/) is followed closely. Minor and patch releases should not introduce breaking changes to the codebase; however, they might change the resulting AST or HTML output of parsed Markdown (due to bug fixes, spec changes, etc.) As a result, you might get slightly different HTML, but any custom code built onto this library should still function correctly.
Any classes or methods marked `@internal` are not intended for use outside of this library and are subject to breaking changes at any time, so please avoid using them.
## 🛠️ Maintenance & Support
When a new **minor** version (e.g. `2.0` -> `2.1`) is released, the previous one (`2.0`) will continue to receive security and critical bug fixes for *at least* 3 months.
When a new **major** version is released (e.g. `1.6` -> `2.0`), the previous one (`1.6`) will receive critical bug fixes for *at least* 3 months and security updates for 6 months after that new release comes out.
(This policy may change in the future and exceptions may be made on a case-by-case basis.)
**Professional support, including notification of new releases and security updates, is available through a [Tidelift Subscription](https://tidelift.com/subscription/pkg/packagist-league-commonmark?utm_source=packagist-league-commonmark&utm_medium=referral&utm_campaign=readme).**
## 👷♀️ Contributing
To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure with us.
If you encounter a bug in the spec, please report it to the [CommonMark] project. Any resulting fix will eventually be implemented in this project as well.
Contributions to this library are **welcome**, especially ones that:
* Improve usability or flexibility without compromising our ability to adhere to the [CommonMark spec]
* Mirror fixes made to the [reference implementation][commonmark.js]
* Optimize performance
* Fix issues with adhering to the [CommonMark spec]
Major refactoring to core parsing logic should be avoided if possible so that we can easily follow updates made to [the reference implementation][commonmark.js]. That being said, we will absolutely consider changes which don't deviate too far from the reference spec or which are favored by other popular CommonMark implementations.
Please see [CONTRIBUTING](https://github.com/thephpleague/commonmark/blob/main/.github/CONTRIBUTING.md) for additional details.
## 🧪 Testing
``` bash
$ composer test
```
This will also test league/commonmark against the latest supported spec.
## 🚀 Performance Benchmarks
You can compare the performance of **league/commonmark** to other popular parsers by running the included benchmark tool:
``` bash
$ ./tests/benchmark/benchmark.php
```
## 👥 Credits & Acknowledgements
- [Colin O'Dell][@colinodell]
- [John MacFarlane][@jgm]
- [All Contributors]
This code is partially based on the [CommonMark JS reference implementation][commonmark.js] which is written, maintained and copyrighted by [John MacFarlane]. This project simply wouldn't exist without his work.
### Sponsors
We'd also like to extend our sincere thanks the following sponsors who support ongoing development of this project:
- [Tidelift](https://tidelift.com/subscription/pkg/packagist-league-commonmark?utm_source=packagist-league-commonmark&utm_medium=referral&utm_campaign=readme) for offering support to both the maintainers and end-users through their [professional support](https://tidelift.com/subscription/pkg/packagist-league-commonmark?utm_source=packagist-league-commonmark&utm_medium=referral&utm_campaign=readme) program
- [Blackfire](https://www.blackfire.io/) for providing an Open-Source Profiler subscription
- [JetBrains](https://www.jetbrains.com/) for supporting this project with complimentary [PhpStorm](https://www.jetbrains.com/phpstorm/) licenses
- [Taylor Otwell](https://twitter.com/taylorotwell) for sponsoring this project through GitHub sponsors
Are you interested in sponsoring development of this project? See <https://www.colinodell.com/sponsor> for a list of ways to contribute.
## 📄 License
**league/commonmark** is licensed under the BSD-3 license. See the [`LICENSE`](LICENSE) file for more details.
## 🏛️ Governance
This project is primarily maintained by [Colin O'Dell][@colinodell]. Members of the [PHP League] Leadership Team may occasionally assist with some of these duties.
## 🗺️ Who Uses It?
This project is used by [Drupal](https://www.drupal.org/project/markdown), [Laravel Framework](https://laravel.com/), [Cachet](https://cachethq.io/), [Firefly III](https://firefly-iii.org/), [Neos](https://www.neos.io/), [Daux.io](https://daux.io/), and [more](https://packagist.org/packages/league/commonmark/dependents)!
---
<div align="center">
<b>
<a href="https://tidelift.com/subscription/pkg/packagist-league-commonmark?utm_source=packagist-league-commonmark&utm_medium=referral&utm_campaign=readme">Get professional support for league/commonmark with a Tidelift subscription</a>
</b>
<br>
<sub>
Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
</sub>
</div>
[CommonMark]: http://commonmark.org/
[CommonMark spec]: http://spec.commonmark.org/
[commonmark.js]: https://github.com/jgm/commonmark.js
[GitHub-Flavored Markdown]: https://github.github.com/gfm/
[John MacFarlane]: http://johnmacfarlane.net
[docs]: https://commonmark.thephpleague.com/
[docs-examples]: https://commonmark.thephpleague.com/customization/overview/#examples
[docs-example-twitter]: https://commonmark.thephpleague.com/customization/inline-parsing#example-1---twitter-handles
[docs-example-smilies]: https://commonmark.thephpleague.com/customization/inline-parsing#example-2---emoticons
[All Contributors]: https://github.com/thephpleague/commonmark/contributors
[@colinodell]: https://www.twitter.com/colinodell
[@jgm]: https://github.com/jgm
[jgm/stmd]: https://github.com/jgm/stmd
[Composer]: https://getcomposer.org/
[PHP League]: https://thephpleague.com
PK �@]����s s LICENSEnu �[��� PK �@]D2Ix
� src/Input/MarkdownInput.phpnu �[��� PK �@]#W�
$ src/Input/MarkdownInputInterface.phpnu �[��� PK �@]���%� � - d src/Environment/EnvironmentAwareInterface.phpnu �[��� PK �@] T1�T T ( p src/Environment/EnvironmentInterface.phpnu �[��� PK �@]���b b / src/Environment/EnvironmentBuilderInterface.phpnu �[��� PK �@]�R�M�: �: �+ src/Environment/Environment.phpnu �[��� PK �@]�:�U>
>
g src/MarkdownConverter.phpnu �[��� PK �@]� ��� � % �q src/Node/StringContainerInterface.phpnu �[��� PK �@] ��0b b at src/Node/NodeIterator.phpnu �[��� PK �@]K��s} } z src/Node/NodeWalkerEvent.phpnu �[��� PK �@]w�
]� � & �} src/Node/Query/ExpressionInterface.phpnu �[��� PK �@]sW�k k � src/Node/Query/OrExpr.phpnu �[��� PK �@]h��Wn n �� src/Node/Query/AndExpr.phpnu �[��� PK �@]
2ސ� � ( D� src/Node/RawMarkupContainerInterface.phpnu �[��� PK �@]���B B m� src/Node/Node.phpnu �[��� PK �@]j� �W W + � src/Node/Inline/AbstractStringContainer.phpnu �[��� PK �@]C�N�� � �� src/Node/Inline/Newline.phpnu �[��� PK �@]i�� � & �� src/Node/Inline/DelimitedInterface.phpnu �[��� PK �@]P3�0 " �� src/Node/Inline/AbstractInline.phpnu �[��� PK �@]j}RM M �� src/Node/Inline/Text.phpnu �[��� PK �@]���~� � & �� src/Node/Inline/AdjacentTextMerger.phpnu �[��� PK �@],�� � n� src/Node/NodeWalker.phpnu �[��� PK �@]�w�Q� � & N� src/Node/Block/TightBlockInterface.phpnu �[��� PK �@]Ҽƨ V� src/Node/Block/Document.phpnu �[��� PK �@]v�
� � �� src/Node/Block/Paragraph.phpnu �[��� PK �@]�t� � �� src/Node/Block/AbstractBlock.phpnu �[��� PK �@]5��� � �� src/Node/Query.phpnu �[��� PK �@]�j4L L " � src/Node/StringContainerHelper.phpnu �[��� PK �@]�!�� � �� src/Util/SpecReader.phpnu �[��� PK �@]BR�(;
;
f� src/Util/UrlEncoder.phpnu �[��� PK �@])Q�i i � src/Util/PrioritizedList.phpnu �[��� PK �@] �sX� � � src/Util/LinkParserHelper.phpnu �[��� PK �@] �A�( ( � src/Util/RegexHelper.phpnu �[��� PK �@]�My �= src/Util/Html5EntityDecoder.phpnu �[��� PK �@]�ؼ � SE src/Util/HtmlFilter.phpnu �[��� PK �@]�X���
�
VK src/Util/ArrayCollection.phpnu �[��� PK �@] w�?� � 6Y src/Util/Xml.phpnu �[��� PK �@]y0@, , X\ src/Util/HtmlElement.phpnu �[��� PK �@]��
�� � ' �l src/GithubFlavoredMarkdownConverter.phpnu �[��� PK �@]�oF/� � # �q src/Event/DocumentRenderedEvent.phpnu �[��� PK �@]A2hێ � $ �u src/Event/DocumentPreRenderEvent.phpnu �[��� PK �@]
�V2� � ! �y src/Event/DocumentParsedEvent.phpnu �[��� PK �@]0�!�� � �| src/Event/AbstractEvent.phpnu �[��� PK �@] �/E� � � src/Event/ListenerData.phpnu �[��� PK �@]��t t $ �� src/Event/DocumentPreParsedEvent.phpnu �[��� PK �@]G
0 ~� src/Extension/ConfigurableExtensionInterface.phpnu �[��� PK �@]�F� ! � src/Extension/Mention/Mention.phpnu �[��� PK �@]<@�(�
�
* 6� src/Extension/Mention/MentionExtension.phpnu �[��� PK �@]��T/� � ' .� src/Extension/Mention/MentionParser.phpnu �[��� PK �@]�U|� = � src/Extension/Mention/Generator/MentionGeneratorInterface.phpnu �[��� PK �@] �ݖN N ? �� src/Extension/Mention/Generator/StringTemplateLinkGenerator.phpnu �[��� PK �@]�G��G G 5 S� src/Extension/Mention/Generator/CallbackGenerator.phpnu �[��� PK �@]�C@� � ; �� src/Extension/HeadingPermalink/HeadingPermalinkRenderer.phpnu �[��� PK �@]��� � < K� src/Extension/HeadingPermalink/HeadingPermalinkProcessor.phpnu �[��� PK �@]rE{�� � 3 �� src/Extension/HeadingPermalink/HeadingPermalink.phpnu �[��� PK �@]�CO�S S < �� src/Extension/HeadingPermalink/HeadingPermalinkExtension.phpnu �[��� PK �@] ��� � 1 �� src/Extension/GithubFlavoredMarkdownExtension.phpnu �[��� PK �@]5��a� � 8 �� src/Extension/TableOfContents/TableOfContentsBuilder.phpnu �[��� PK �@]�_��� � 6 � src/Extension/TableOfContents/Node/TableOfContents.phpnu �[��� PK �@]è�� � A +� src/Extension/TableOfContents/Node/TableOfContentsPlaceholder.phpnu �[��� PK �@]�8�)� � : [� src/Extension/TableOfContents/TableOfContentsGenerator.phpnu �[��� PK �@] �DM. . C } src/Extension/TableOfContents/TableOfContentsGeneratorInterface.phpnu �[��� PK �@]v��h� � 9 src/Extension/TableOfContents/TableOfContentsRenderer.phpnu �[��� PK �@]�;ۿ D z src/Extension/TableOfContents/TableOfContentsPlaceholderRenderer.phpnu �[��� PK �@]��[� � B � src/Extension/TableOfContents/TableOfContentsPlaceholderParser.phpnu �[��� PK �@]U�Ti� � G W* src/Extension/TableOfContents/Normalizer/RelativeNormalizerStrategy.phpnu �[��� PK �@]SH� H z3 src/Extension/TableOfContents/Normalizer/NormalizerStrategyInterface.phpnu �[��� PK �@]I���e e C �5 src/Extension/TableOfContents/Normalizer/AsIsNormalizerStrategy.phpnu �[��� PK �@] @H H C �? src/Extension/TableOfContents/Normalizer/FlatNormalizerStrategy.phpnu �[��� PK �@]��{z z : �C src/Extension/TableOfContents/TableOfContentsExtension.phpnu �[��� PK �@]t�~�� � 2 oO src/Extension/InlinesOnly/InlinesOnlyExtension.phpnu �[��� PK �@]�1'� � + T^ src/Extension/InlinesOnly/ChildRenderer.phpnu �[��� PK �@]��� � @ db src/Extension/FrontMatter/Input/MarkdownInputWithFrontMatter.phpnu �[��� PK �@]�d�s� � D vg src/Extension/FrontMatter/Listener/FrontMatterPostRenderListener.phpnu �[��� PK �@]6��E� � ; �k src/Extension/FrontMatter/Listener/FrontMatterPreParser.phpnu �[��� PK �@]�cֿ � : p src/Extension/FrontMatter/FrontMatterProviderInterface.phpnu �[��� PK �@]NY �� � C 0r src/Extension/FrontMatter/Output/RenderedContentWithFrontMatter.phpnu �[��� PK �@]�Oj� � 2 sw src/Extension/FrontMatter/FrontMatterExtension.phpnu �[��� PK �@]R)n 8 �~ src/Extension/FrontMatter/FrontMatterParserInterface.phpnu �[��� PK �@]5$ � � C G� src/Extension/FrontMatter/Exception/InvalidFrontMatterException.phpnu �[��� PK �@]�iҍ' ' / J� src/Extension/FrontMatter/FrontMatterParser.phpnu �[��� PK �@]j�@� � ; Ѝ src/Extension/FrontMatter/Data/LibYamlFrontMatterParser.phpnu �[��� PK �@]��a a ? �� src/Extension/FrontMatter/Data/SymfonyYamlFrontMatterParser.phpnu �[��� PK �@]C���� � A ɗ src/Extension/FrontMatter/Data/FrontMatterDataParserInterface.phpnu �[��� PK �@]�2n�� � ( � src/Extension/Table/TableRowRenderer.phpnu �[��� PK �@] �P�8 8 # �� src/Extension/Table/TableParser.phpnu �[��� PK �@]�Y� � �� src/Extension/Table/Table.phpnu �[��� PK �@]�2�� � �� src/Extension/Table/TableRow.phpnu �[��� PK �@]��� � & �� src/Extension/Table/TableExtension.phpnu �[��� PK �@]_ �%� � ! � src/Extension/Table/TableCell.phpnu �[��� PK �@]�k߫� � % �� src/Extension/Table/TableRenderer.phpnu �[��� PK �@]_I��� � ( "� src/Extension/Table/TableStartParser.phpnu �[��� PK �@]�A�9
9
) O� src/Extension/Table/TableCellRenderer.phpnu �[��� PK �@]� �- - , �� src/Extension/Table/TableSectionRenderer.phpnu �[��� PK �@]��+j! ! $ j� src/Extension/Table/TableSection.phpnu �[��� PK �@]0֝�T T - � src/Extension/CommonMark/Node/Inline/Link.phpnu �[��� PK �@]P�2U U . � src/Extension/CommonMark/Node/Inline/Image.phpnu �[��� PK �@] <̋� � 1 C src/Extension/CommonMark/Node/Inline/Emphasis.phpnu �[��� PK �@]��h�6 6 - �
src/Extension/CommonMark/Node/Inline/Code.phpnu �[��� PK �@]�x�� � 3 % src/Extension/CommonMark/Node/Inline/HtmlInline.phpnu �[��� PK �@]놘�o o < ) src/Extension/CommonMark/Node/Inline/AbstractWebResource.phpnu �[��� PK �@]��� � / src/Extension/CommonMark/Node/Inline/Strong.phpnu �[��� PK �@]�5�i@ @ 0 P src/Extension/CommonMark/Node/Block/ListItem.phpnu �[��� PK �@]�`I�� � 2 � src/Extension/CommonMark/Node/Block/BlockQuote.phpnu �[��� PK �@]щ8� 1 � src/Extension/CommonMark/Node/Block/ListBlock.phpnu �[��� PK �@] t>Pb b / k& src/Extension/CommonMark/Node/Block/Heading.phpnu �[��� PK �@]�>l>� � 2 ,* src/Extension/CommonMark/Node/Block/FencedCode.phpnu �[��� PK �@]��_�8 8 0 �2 src/Extension/CommonMark/Node/Block/ListData.phpnu �[��� PK �@]��>�� � 5 7 src/Extension/CommonMark/Node/Block/ThematicBreak.phpnu �[��� PK �@]�[�� � 4 09 src/Extension/CommonMark/Node/Block/IndentedCode.phpnu �[��� PK �@]��0' ' 1 |< src/Extension/CommonMark/Node/Block/HtmlBlock.phpnu �[��� PK �@]h�{U U 4 D src/Extension/CommonMark/CommonMarkCoreExtension.phpnu �[��� PK �@]� ]�� � : �X src/Extension/CommonMark/Renderer/Inline/ImageRenderer.phpnu �[��� PK �@]S>qL9
9
9 e src/Extension/CommonMark/Renderer/Inline/LinkRenderer.phpnu �[��� PK �@] ?��� � = �o src/Extension/CommonMark/Renderer/Inline/EmphasisRenderer.phpnu �[��� PK �@](� � � 9 �u src/Extension/CommonMark/Renderer/Inline/CodeRenderer.phpnu �[��� PK �@]�� �2 2 ? B| src/Extension/CommonMark/Renderer/Inline/HtmlInlineRenderer.phpnu �[��� PK �@]yZ' � � ; � src/Extension/CommonMark/Renderer/Inline/StrongRenderer.phpnu �[��� PK �@]����� � A -� src/Extension/CommonMark/Renderer/Block/ThematicBreakRenderer.phpnu �[��� PK �@]n3`c c @ u� src/Extension/CommonMark/Renderer/Block/IndentedCodeRenderer.phpnu �[��� PK �@]���� � ; H� src/Extension/CommonMark/Renderer/Block/HeadingRenderer.phpnu �[��� PK �@]>9@� � = s� src/Extension/CommonMark/Renderer/Block/ListBlockRenderer.phpnu �[��� PK �@]&�t+ + = ~� src/Extension/CommonMark/Renderer/Block/HtmlBlockRenderer.phpnu �[��� PK �@]@ %�� � > � src/Extension/CommonMark/Renderer/Block/BlockQuoteRenderer.phpnu �[��� PK �@]����� � > � src/Extension/CommonMark/Renderer/Block/FencedCodeRenderer.phpnu �[��� PK �@]#�t�2 2 < 8� src/Extension/CommonMark/Renderer/Block/ListItemRenderer.phpnu �[��� PK �@]{���� � ; �� src/Extension/CommonMark/Parser/Inline/HtmlInlineParser.phpnu �[��� PK �@]�9�E 7 >� src/Extension/CommonMark/Parser/Inline/EntityParser.phpnu �[��� PK �@]��L�b b 9 �� src/Extension/CommonMark/Parser/Inline/AutolinkParser.phpnu �[��� PK �@],���k k : �� src/Extension/CommonMark/Parser/Inline/EscapableParser.phpnu �[��� PK �@]�%�a a < V� src/Extension/CommonMark/Parser/Inline/OpenBracketParser.phpnu �[��� PK �@]�5�^ ^ 9 #� src/Extension/CommonMark/Parser/Inline/BacktickParser.phpnu �[��� PK �@]Ɗ>d d 5 �� src/Extension/CommonMark/Parser/Inline/BangParser.phpnu �[��� PK �@]^�� � = �� src/Extension/CommonMark/Parser/Inline/CloseBracketParser.phpnu �[��� PK �@]��:A� � < � src/Extension/CommonMark/Parser/Block/IndentedCodeParser.phpnu �[��� PK �@]*P�� � < src/Extension/CommonMark/Parser/Block/HeadingStartParser.phpnu �[��� PK �@]{�j� � 9 J( src/Extension/CommonMark/Parser/Block/HtmlBlockParser.phpnu �[��� PK �@]C�e� � A �1 src/Extension/CommonMark/Parser/Block/IndentedCodeStartParser.phpnu �[��� PK �@]Kz��* * : �6 src/Extension/CommonMark/Parser/Block/BlockQuoteParser.phpnu �[��� PK �@]}v##{ { 8 m= src/Extension/CommonMark/Parser/Block/ListItemParser.phpnu �[��� PK �@]��ᄖ � = PI src/Extension/CommonMark/Parser/Block/ThematicBreakParser.phpnu �[��� PK �@]7Bq�
�
: SN src/Extension/CommonMark/Parser/Block/FencedCodeParser.phpnu �[��� PK �@]F�4$k k > �Y src/Extension/CommonMark/Parser/Block/ListBlockStartParser.phpnu �[��� PK �@]�Xѷ� � ? vo src/Extension/CommonMark/Parser/Block/FencedCodeStartParser.phpnu �[��� PK �@]���Y Y ? �t src/Extension/CommonMark/Parser/Block/BlockQuoteStartParser.phpnu �[��� PK �@]�}� V V > �y src/Extension/CommonMark/Parser/Block/HtmlBlockStartParser.phpnu �[��� PK �@]���W� � B S� src/Extension/CommonMark/Parser/Block/ThematicBreakStartParser.phpnu �[��� PK �@]�nL�� � 7 �� src/Extension/CommonMark/Parser/Block/HeadingParser.phpnu �[��� PK �@]ϲ dD D 9 � src/Extension/CommonMark/Parser/Block/ListBlockParser.phpnu �[��� PK �@]h�N� � K �� src/Extension/CommonMark/Delimiter/Processor/EmphasisDelimiterProcessor.phpnu �[��� PK �@]�L8y� � ? Ĥ src/Extension/Strikethrough/StrikethroughDelimiterProcessor.phpnu �[��� PK �@]�}��' ' 6 ԫ src/Extension/Strikethrough/StrikethroughExtension.phpnu �[��� PK �@]Y6�� � - a� src/Extension/Strikethrough/Strikethrough.phpnu �[��� PK �@]Ȉ�\; ; 5 R� src/Extension/Strikethrough/StrikethroughRenderer.phpnu �[��� PK �@]>�w w , � src/Extension/Attributes/Node/Attributes.phpnu �[��� PK �@] C�� � 2 ž src/Extension/Attributes/Node/AttributesInline.phpnu �[��� PK �@]�c�>k k 2 �� src/Extension/Attributes/Util/AttributesHelper.phpnu �[��� PK �@]Z��C C 5 �� src/Extension/Attributes/Event/AttributesListener.phpnu �[��� PK �@]0�dŘ � 0 e� src/Extension/Attributes/AttributesExtension.phpnu �[��� PK �@]Mǯ'� � : ]� src/Extension/Attributes/Parser/AttributesInlineParser.phpnu �[��� PK �@]_;�0� � A a� src/Extension/Attributes/Parser/AttributesBlockContinueParser.phpnu �[��� PK �@]Z���K K > � src/Extension/Attributes/Parser/AttributesBlockStartParser.phpnu �[��� PK �@]�-��8 8 - D src/Extension/TaskList/TaskListItemMarker.phpnu �[��� PK �@]"��MY Y 3 � src/Extension/TaskList/TaskListItemMarkerParser.phpnu �[��� PK �@],��� � , � src/Extension/TaskList/TaskListExtension.phpnu �[��� PK �@]�7� 5 � src/Extension/TaskList/TaskListItemMarkerRenderer.phpnu �[��� PK �@]�
4$O O + d src/Extension/SmartPunct/EllipsesParser.phpnu �[��� PK �@]�K�{A A " src/Extension/SmartPunct/Quote.phpnu �[��� PK �@]2"�?�
�
0 �# src/Extension/SmartPunct/SmartPunctExtension.phpnu �[��� PK �@]Z���
�
( �. src/Extension/SmartPunct/QuoteParser.phpnu �[��� PK �@]��Тr r ' �< src/Extension/SmartPunct/DashParser.phpnu �[��� PK �@]�mk�2 2 : ^D src/Extension/SmartPunct/ReplaceUnpairedQuotesListener.phpnu �[��� PK �@]�%�d; ; + �I src/Extension/SmartPunct/QuoteProcessor.phpnu �[��� PK �@];��� � , �S src/Extension/Autolink/AutolinkExtension.phpnu �[��� PK �@]���� � , �V src/Extension/Autolink/UrlAutolinkParser.phpnu �[��� PK �@]�_��� � . s src/Extension/Autolink/EmailAutolinkParser.phpnu �[��� PK �@]��oa� � > y src/Extension/DefaultAttributes/DefaultAttributesExtension.phpnu �[��� PK �@]�GO O C t~ src/Extension/DefaultAttributes/ApplyDefaultAttributesProcessor.phpnu �[��� PK �@]��� & 6� src/Extension/Embed/EmbedProcessor.phpnu �[��� PK �@]ht t . �� src/Extension/Embed/DomainFilteringAdapter.phpnu �[��� PK �@]* x� � ( s� src/Extension/Embed/EmbedStartParser.phpnu �[��� PK �@]F#�( ( - k� src/Extension/Embed/EmbedAdapterInterface.phpnu �[��� PK �@]�*M�� � & � src/Extension/Embed/EmbedExtension.phpnu �[��� PK �@]��⤞ � 5 +� src/Extension/Embed/Bridge/OscaroteroEmbedAdapter.phpnu �[��� PK �@]^M`8 8 # .� src/Extension/Embed/EmbedParser.phpnu �[��� PK �@]
�a*B B % �� src/Extension/Embed/EmbedRenderer.phpnu �[��� PK �@]
� � P� src/Extension/Embed/Embed.phpnu �[��� PK �@]3W�� � 4 �� src/Extension/ExternalLink/ExternalLinkExtension.phpnu �[��� PK �@]�q�3� � 4 �� src/Extension/ExternalLink/ExternalLinkProcessor.phpnu �[��� PK �@]R�E� � > � src/Extension/DisallowedRawHtml/DisallowedRawHtmlExtension.phpnu �[��� PK �@]j �L� � = Y� src/Extension/DisallowedRawHtml/DisallowedRawHtmlRenderer.phpnu �[��� PK �@]u.1f� � / I� src/Extension/Footnote/Node/FootnoteBackref.phpnu �[��� PK �@]���X� � 1 �� src/Extension/Footnote/Node/FootnoteContainer.phpnu �[��� PK �@]��wg g + �� src/Extension/Footnote/Node/FootnoteRef.phpnu �[��� PK �@]B�� � ( �� src/Extension/Footnote/Node/Footnote.phpnu �[��� PK �@]��M�6 6 ; �� src/Extension/Footnote/Event/AnonymousFootnotesListener.phpnu �[��� PK �@]�>r��
�
8 #� src/Extension/Footnote/Event/GatherFootnotesListener.phpnu �[��� PK �@]pܵ 1 1 D b src/Extension/Footnote/Event/FixOrphanedFootnotesAndRefsListener.phpnu �[��� PK �@]~��& & 8 src/Extension/Footnote/Event/NumberFootnotesListener.phpnu �[��� PK �@]����
�
, � src/Extension/Footnote/FootnoteExtension.phpnu �[��� PK �@]��f�� � 7 �' src/Extension/Footnote/Renderer/FootnoteRefRenderer.phpnu �[��� PK �@]/ڰ�A A = �1 src/Extension/Footnote/Renderer/FootnoteContainerRenderer.phpnu �[��� PK �@]�a�X X ; �: src/Extension/Footnote/Renderer/FootnoteBackrefRenderer.phpnu �[��� PK �@])v@ � � 4 _D src/Extension/Footnote/Renderer/FootnoteRenderer.phpnu �[��� PK �@]��<zq q < �M src/Extension/Footnote/Parser/AnonymousFootnoteRefParser.phpnu �[��� PK �@]I�� 5 �V src/Extension/Footnote/Parser/FootnoteStartParser.phpnu �[��� PK �@]d�� 0 �] src/Extension/Footnote/Parser/FootnoteParser.phpnu �[��� PK �@]�zɎ� � 3 Oe src/Extension/Footnote/Parser/FootnoteRefParser.phpnu �[��� PK �@]���c c $ ]l src/Extension/ExtensionInterface.phpnu �[��� PK �@]��l � � 6 o src/Extension/DescriptionList/Node/DescriptionTerm.phpnu �[��� PK �@]x��� � 6 (q src/Extension/DescriptionList/Node/DescriptionList.phpnu �[��� PK �@]_>X�C C 2 <s src/Extension/DescriptionList/Node/Description.phpnu �[��� PK �@]#�_�� � ? �v src/Extension/DescriptionList/Event/LooseDescriptionHandler.phpnu �[��� PK �@]�d�C� � H .� src/Extension/DescriptionList/Event/ConsecutiveDescriptionListMerger.phpnu �[��� PK �@]c�0�o o : 9� src/Extension/DescriptionList/DescriptionListExtension.phpnu �[��� PK �@]Zp�w w B � src/Extension/DescriptionList/Renderer/DescriptionListRenderer.phpnu �[��� PK �@]��V�" " B �� src/Extension/DescriptionList/Renderer/DescriptionTermRenderer.phpnu �[��� PK �@]��H! > �� src/Extension/DescriptionList/Renderer/DescriptionRenderer.phpnu �[��� PK �@]���x� � F � src/Extension/DescriptionList/Parser/DescriptionListContinueParser.phpnu �[��� PK �@]9۞� F u� src/Extension/DescriptionList/Parser/DescriptionTermContinueParser.phpnu �[��� PK �@]`H� � ? � src/Extension/DescriptionList/Parser/DescriptionStartParser.phpnu �[��� PK �@]�K��\ \ B ^� src/Extension/DescriptionList/Parser/DescriptionContinueParser.phpnu �[��� PK �@]�i ,� src/ConverterInterface.phpnu �[��� PK �@]ԧ7�L L ' �� src/Output/RenderedContentInterface.phpnu �[��� PK �@]�?� � ,� src/Output/RenderedContent.phpnu �[��� PK �@]�L�B� � * d� src/Exception/InvalidArgumentException.phpnu �[��� PK �@]���v� � Z� src/Exception/LogicException.phpnu �[��� PK �@] V�� � 2� src/Exception/IOException.phpnu �[��� PK �@]�&D� � % � src/Exception/CommonMarkException.phpnu �[��� PK �@]�]�w� � - � src/Exception/UnexpectedEncodingException.phpnu �[��� PK �@]��� � , � src/Exception/MissingDependencyException.phpnu �[��� PK �@]�
� � - �� src/Exception/AlreadyInitializedException.phpnu �[��� PK �@]��� � * �� src/Renderer/MarkdownRendererInterface.phpnu �[��� PK �@]f*��� � + � src/Renderer/ChildNodeRendererInterface.phpnu �[��� PK �@]�=; ; $ 6� src/Renderer/Inline/TextRenderer.phpnu �[��� PK �@]�w��� � ' �� src/Renderer/Inline/NewlineRenderer.phpnu �[��� PK �@]�v�|� � ' �� src/Renderer/Block/DocumentRenderer.phpnu �[��� PK �@]����� � (
� src/Renderer/Block/ParagraphRenderer.phpnu �[��� PK �@]�:Qd� � * � src/Renderer/DocumentRendererInterface.phpnu �[��� PK �@]�@�ɥ � , %� src/Renderer/NoMatchingRendererException.phpnu �[��� PK �@]�쓲� � &� src/Renderer/HtmlDecorator.phpnu �[��� PK �@]�{5� � & c� src/Renderer/NodeRendererInterface.phpnu �[��� PK �@]5O�V5 5 O src/Renderer/HtmlRenderer.phpnu �[��� PK �@]!L�}/ }/ � src/Parser/MarkdownParser.phpnu �[��� PK �@]��O8�7 �7 �< src/Parser/Cursor.phpnu �[��� PK �@]�G_ ! �t src/Parser/InlineParserEngine.phpnu �[��� PK �@]���, , # � src/Parser/Inline/NewlineParser.phpnu �[��� PK �@]�iK� + p� src/Parser/Inline/InlineParserInterface.phpnu �[��� PK �@]}jһ� � ' � src/Parser/Inline/InlineParserMatch.phpnu �[��� PK �@]I7MD6 6 " � src/Parser/InlineParserContext.phpnu �[��� PK �@]b$6
@ @ 1 z� src/Parser/Block/BlockContinueParserInterface.phpnu �[��� PK �@]+�Y� � 0 � src/Parser/Block/AbstractBlockContinueParser.phpnu �[��� PK �@]��֧�
�
.� src/Parser/Block/BlockStart.phpnu �[��� PK �@]�OQ� ( � src/Parser/Block/DocumentBlockParser.phpnu �[��� PK �@]l�8�i i < ~� src/Parser/Block/BlockContinueParserWithInlinesInterface.phpnu �[��� PK �@]�w��1 1 . S� src/Parser/Block/BlockStartParserInterface.phpnu �[��� PK �@]B/�< " �� src/Parser/Block/BlockContinue.phpnu �[��� PK �@]�U��� � $ S� src/Parser/Block/ParagraphParser.phpnu �[��� PK �@]��X� � 7 b� src/Parser/Block/SkipLinesStartingWithLettersParser.phpnu �[��� PK �@]�J�{` ` " W� src/Parser/MarkdownParserState.phpnu �[��� PK �@]�p�7� � # � src/Parser/ParserLogicException.phpnu �[��� PK �@]�1a4 4 + � src/Parser/MarkdownParserStateInterface.phpnu �[��� PK �@]x�+y� � * �� src/Parser/InlineParserEngineInterface.phpnu �[��� PK �@]�c4�# # & �� src/Parser/MarkdownParserInterface.phpnu �[��� PK �@]W�)�h h � src/Parser/CursorState.phpnu �[��� PK �@]�t�E� � ! �� src/Normalizer/SlugNormalizer.phpnu �[��� PK �@]��� � ' � src/Normalizer/UniqueSlugNormalizer.phpnu �[��� PK �@]��R�� � 0 �
src/Normalizer/UniqueSlugNormalizerInterface.phpnu �[��� PK �@]V�|Z� � ! src/Normalizer/TextNormalizer.phpnu �[��� PK �@]�U�� * # src/Normalizer/TextNormalizerInterface.phpnu �[��� PK �@]�ֵ�N N " � src/MarkdownConverterInterface.phpnu �[��� PK �@]���� � , src/Delimiter/Delimiter.phpnu �[��� PK �@]d�(�p p ! W& src/Delimiter/DelimiterParser.phpnu �[��� PK �@]�!x,� � $ 5 src/Delimiter/DelimiterInterface.phpnu �[��� PK �@]&1F7i i 8 /: src/Delimiter/Processor/DelimiterProcessorCollection.phpnu �[��� PK �@]��sm� � A F src/Delimiter/Processor/DelimiterProcessorCollectionInterface.phpnu �[��� PK �@]pjʥ 7 L src/Delimiter/Processor/DelimiterProcessorInterface.phpnu �[��� PK �@] a�� 7 �W src/Delimiter/Processor/StaggeredDelimiterProcessor.phpnu �[��� PK �@]���� � f src/Delimiter/DelimiterStack.phpnu �[��� PK �@]��
� � T� src/CommonMarkConverter.phpnu �[��� PK �@]� &*b b $ =� src/Xml/XmlNodeRendererInterface.phpnu �[��� PK �@]}"��F F � src/Xml/XmlRenderer.phpnu �[��� PK �@]a�*D D " �� src/Xml/MarkdownToXmlConverter.phpnu �[��� PK �@]i �>� � # � src/Xml/FallbackNodeXmlRenderer.phpnu �[��� PK �@]�f�F� � ( � src/Reference/ReferenceableInterface.phpnu �[��� PK �@]�:< ' � src/Reference/ReferenceMapInterface.phpnu �[��� PK �@]���M M n� src/Reference/ReferenceMap.phpnu �[��� PK �@]z,�dž � � src/Reference/Reference.phpnu �[��� PK �@]�~�Lo o $ ڽ src/Reference/ReferenceInterface.phpnu �[��� PK �@]�;S$ $ ! �� src/Reference/ReferenceParser.phpnu �[��� PK �@]n�cUk Uk � CHANGELOG.mdnu �[��� PK �@]Y�r�
�P composer.jsonnu �[��� PK �@]U"�s� � �` .phpstorm.meta.phpnu �[��� PK �@]�� �/ �/ y README.mdnu �[��� PK ''�~ �
