1#@!#!123s

: / proc / self / root / usr / local / psa / admin / plib / modules / catalog / vendor / erusev / parsedown /
Filename : Parsedown.php
back
<?php

namespace {
    #
    #
    # Parsedown
    # http://parsedown.org
    #
    # (c) Emanuil Rusev
    # http://erusev.com
    #
    # For the full license information, view the LICENSE file that was distributed
    # with this source code.
    #
    #
    class Parsedown
    {
        # ~
        const version = '1.8.0';
        # ~
        function text($text)
        {
            $Elements = $this->textElements($text);
            # convert to markup
            $markup = $this->elements($Elements);
            # trim line breaks
            $markup = \trim($markup, "\n");
            return $markup;
        }
        protected function textElements($text)
        {
            # make sure no definitions are set
            $this->DefinitionData = array();
            # standardize line breaks
            $text = \str_replace(array("\r\n", "\r"), "\n", $text);
            # remove surrounding line breaks
            $text = \trim($text, "\n");
            # split text into lines
            $lines = \explode("\n", $text);
            # iterate through lines to identify blocks
            return $this->linesElements($lines);
        }
        #
        # Setters
        #
        function setBreaksEnabled($breaksEnabled)
        {
            $this->breaksEnabled = $breaksEnabled;
            return $this;
        }
        protected $breaksEnabled;
        function setMarkupEscaped($markupEscaped)
        {
            $this->markupEscaped = $markupEscaped;
            return $this;
        }
        protected $markupEscaped;
        function setUrlsLinked($urlsLinked)
        {
            $this->urlsLinked = $urlsLinked;
            return $this;
        }
        protected $urlsLinked = \true;
        function setSafeMode($safeMode)
        {
            $this->safeMode = (bool) $safeMode;
            return $this;
        }
        protected $safeMode;
        function setStrictMode($strictMode)
        {
            $this->strictMode = (bool) $strictMode;
            return $this;
        }
        protected $strictMode;
        protected $safeLinksWhitelist = array('http://', 'https://', 'ftp://', 'ftps://', 'mailto:', 'tel:', 'data:image/png;base64,', 'data:image/gif;base64,', 'data:image/jpeg;base64,', 'irc:', 'ircs:', 'git:', 'ssh:', 'news:', 'steam:');
        #
        # Lines
        #
        protected $BlockTypes = array('#' => array('Header'), '*' => array('Rule', 'List'), '+' => array('List'), '-' => array('SetextHeader', 'Table', 'Rule', 'List'), '0' => array('List'), '1' => array('List'), '2' => array('List'), '3' => array('List'), '4' => array('List'), '5' => array('List'), '6' => array('List'), '7' => array('List'), '8' => array('List'), '9' => array('List'), ':' => array('Table'), '<' => array('Comment', 'Markup'), '=' => array('SetextHeader'), '>' => array('Quote'), '[' => array('Reference'), '_' => array('Rule'), '`' => array('FencedCode'), '|' => array('Table'), '~' => array('FencedCode'));
        # ~
        protected $unmarkedBlockTypes = array('Code');
        #
        # Blocks
        #
        protected function lines(array $lines)
        {
            return $this->elements($this->linesElements($lines));
        }
        protected function linesElements(array $lines)
        {
            $Elements = array();
            $CurrentBlock = null;
            foreach ($lines as $line) {
                if (\chop($line) === '') {
                    if (isset($CurrentBlock)) {
                        $CurrentBlock['interrupted'] = isset($CurrentBlock['interrupted']) ? $CurrentBlock['interrupted'] + 1 : 1;
                    }
                    continue;
                }
                while (($beforeTab = \strstr($line, "\t", \true)) !== \false) {
                    $shortage = 4 - \mb_strlen($beforeTab, 'utf-8') % 4;
                    $line = $beforeTab . \str_repeat(' ', $shortage) . \substr($line, \strlen($beforeTab) + 1);
                }
                $indent = \strspn($line, ' ');
                $text = $indent > 0 ? \substr($line, $indent) : $line;
                # ~
                $Line = array('body' => $line, 'indent' => $indent, 'text' => $text);
                # ~
                if (isset($CurrentBlock['continuable'])) {
                    $methodName = 'block' . $CurrentBlock['type'] . 'Continue';
                    $Block = $this->{$methodName}($Line, $CurrentBlock);
                    if (isset($Block)) {
                        $CurrentBlock = $Block;
                        continue;
                    } else {
                        if ($this->isBlockCompletable($CurrentBlock['type'])) {
                            $methodName = 'block' . $CurrentBlock['type'] . 'Complete';
                            $CurrentBlock = $this->{$methodName}($CurrentBlock);
                        }
                    }
                }
                # ~
                $marker = $text[0];
                # ~
                $blockTypes = $this->unmarkedBlockTypes;
                if (isset($this->BlockTypes[$marker])) {
                    foreach ($this->BlockTypes[$marker] as $blockType) {
                        $blockTypes[] = $blockType;
                    }
                }
                #
                # ~
                foreach ($blockTypes as $blockType) {
                    $Block = $this->{"block{$blockType}"}($Line, $CurrentBlock);
                    if (isset($Block)) {
                        $Block['type'] = $blockType;
                        if (!isset($Block['identified'])) {
                            if (isset($CurrentBlock)) {
                                $Elements[] = $this->extractElement($CurrentBlock);
                            }
                            $Block['identified'] = \true;
                        }
                        if ($this->isBlockContinuable($blockType)) {
                            $Block['continuable'] = \true;
                        }
                        $CurrentBlock = $Block;
                        continue 2;
                    }
                }
                # ~
                if (isset($CurrentBlock) and $CurrentBlock['type'] === 'Paragraph') {
                    $Block = $this->paragraphContinue($Line, $CurrentBlock);
                }
                if (isset($Block)) {
                    $CurrentBlock = $Block;
                } else {
                    if (isset($CurrentBlock)) {
                        $Elements[] = $this->extractElement($CurrentBlock);
                    }
                    $CurrentBlock = $this->paragraph($Line);
                    $CurrentBlock['identified'] = \true;
                }
            }
            # ~
            if (isset($CurrentBlock['continuable']) and $this->isBlockCompletable($CurrentBlock['type'])) {
                $methodName = 'block' . $CurrentBlock['type'] . 'Complete';
                $CurrentBlock = $this->{$methodName}($CurrentBlock);
            }
            # ~
            if (isset($CurrentBlock)) {
                $Elements[] = $this->extractElement($CurrentBlock);
            }
            # ~
            return $Elements;
        }
        protected function extractElement(array $Component)
        {
            if (!isset($Component['element'])) {
                if (isset($Component['markup'])) {
                    $Component['element'] = array('rawHtml' => $Component['markup']);
                } elseif (isset($Component['hidden'])) {
                    $Component['element'] = array();
                }
            }
            return $Component['element'];
        }
        protected function isBlockContinuable($Type)
        {
            return \method_exists($this, 'block' . $Type . 'Continue');
        }
        protected function isBlockCompletable($Type)
        {
            return \method_exists($this, 'block' . $Type . 'Complete');
        }
        #
        # Code
        protected function blockCode($Line, $Block = null)
        {
            if (isset($Block) and $Block['type'] === 'Paragraph' and !isset($Block['interrupted'])) {
                return;
            }
            if ($Line['indent'] >= 4) {
                $text = \substr($Line['body'], 4);
                $Block = array('element' => array('name' => 'pre', 'element' => array('name' => 'code', 'text' => $text)));
                return $Block;
            }
        }
        protected function blockCodeContinue($Line, $Block)
        {
            if ($Line['indent'] >= 4) {
                if (isset($Block['interrupted'])) {
                    $Block['element']['element']['text'] .= \str_repeat("\n", $Block['interrupted']);
                    unset($Block['interrupted']);
                }
                $Block['element']['element']['text'] .= "\n";
                $text = \substr($Line['body'], 4);
                $Block['element']['element']['text'] .= $text;
                return $Block;
            }
        }
        protected function blockCodeComplete($Block)
        {
            return $Block;
        }
        #
        # Comment
        protected function blockComment($Line)
        {
            if ($this->markupEscaped or $this->safeMode) {
                return;
            }
            if (\strpos($Line['text'], '<!--') === 0) {
                $Block = array('element' => array('rawHtml' => $Line['body'], 'autobreak' => \true));
                if (\strpos($Line['text'], '-->') !== \false) {
                    $Block['closed'] = \true;
                }
                return $Block;
            }
        }
        protected function blockCommentContinue($Line, array $Block)
        {
            if (isset($Block['closed'])) {
                return;
            }
            $Block['element']['rawHtml'] .= "\n" . $Line['body'];
            if (\strpos($Line['text'], '-->') !== \false) {
                $Block['closed'] = \true;
            }
            return $Block;
        }
        #
        # Fenced Code
        protected function blockFencedCode($Line)
        {
            $marker = $Line['text'][0];
            $openerLength = \strspn($Line['text'], $marker);
            if ($openerLength < 3) {
                return;
            }
            $infostring = \trim(\substr($Line['text'], $openerLength), "\t ");
            if (\strpos($infostring, '`') !== \false) {
                return;
            }
            $Element = array('name' => 'code', 'text' => '');
            if ($infostring !== '') {
                /**
                 * https://www.w3.org/TR/2011/WD-html5-20110525/elements.html#classes
                 * Every HTML element may have a class attribute specified.
                 * The attribute, if specified, must have a value that is a set
                 * of space-separated tokens representing the various classes
                 * that the element belongs to.
                 * [...]
                 * The space characters, for the purposes of this specification,
                 * are U+0020 SPACE, U+0009 CHARACTER TABULATION (tab),
                 * U+000A LINE FEED (LF), U+000C FORM FEED (FF), and
                 * U+000D CARRIAGE RETURN (CR).
                 */
                $language = \substr($infostring, 0, \strcspn($infostring, " \t\n\f\r"));
                $Element['attributes'] = array('class' => "language-{$language}");
            }
            $Block = array('char' => $marker, 'openerLength' => $openerLength, 'element' => array('name' => 'pre', 'element' => $Element));
            return $Block;
        }
        protected function blockFencedCodeContinue($Line, $Block)
        {
            if (isset($Block['complete'])) {
                return;
            }
            if (isset($Block['interrupted'])) {
                $Block['element']['element']['text'] .= \str_repeat("\n", $Block['interrupted']);
                unset($Block['interrupted']);
            }
            if (($len = \strspn($Line['text'], $Block['char'])) >= $Block['openerLength'] and \chop(\substr($Line['text'], $len), ' ') === '') {
                $Block['element']['element']['text'] = \substr($Block['element']['element']['text'], 1);
                $Block['complete'] = \true;
                return $Block;
            }
            $Block['element']['element']['text'] .= "\n" . $Line['body'];
            return $Block;
        }
        protected function blockFencedCodeComplete($Block)
        {
            return $Block;
        }
        #
        # Header
        protected function blockHeader($Line)
        {
            $level = \strspn($Line['text'], '#');
            if ($level > 6) {
                return;
            }
            $text = \trim($Line['text'], '#');
            if ($this->strictMode and isset($text[0]) and $text[0] !== ' ') {
                return;
            }
            $text = \trim($text, ' ');
            $Block = array('element' => array('name' => 'h' . $level, 'handler' => array('function' => 'lineElements', 'argument' => $text, 'destination' => 'elements')));
            return $Block;
        }
        #
        # List
        protected function blockList($Line, ?array $CurrentBlock = null)
        {
            list($name, $pattern) = $Line['text'][0] <= '-' ? array('ul', '[*+-]') : array('ol', '[0-9]{1,9}+[.\\)]');
            if (\preg_match('/^(' . $pattern . '([ ]++|$))(.*+)/', $Line['text'], $matches)) {
                $contentIndent = \strlen($matches[2]);
                if ($contentIndent >= 5) {
                    $contentIndent -= 1;
                    $matches[1] = \substr($matches[1], 0, -$contentIndent);
                    $matches[3] = \str_repeat(' ', $contentIndent) . $matches[3];
                } elseif ($contentIndent === 0) {
                    $matches[1] .= ' ';
                }
                $markerWithoutWhitespace = \strstr($matches[1], ' ', \true);
                $Block = array('indent' => $Line['indent'], 'pattern' => $pattern, 'data' => array('type' => $name, 'marker' => $matches[1], 'markerType' => $name === 'ul' ? $markerWithoutWhitespace : \substr($markerWithoutWhitespace, -1)), 'element' => array('name' => $name, 'elements' => array()));
                $Block['data']['markerTypeRegex'] = \preg_quote($Block['data']['markerType'], '/');
                if ($name === 'ol') {
                    $listStart = \ltrim(\strstr($matches[1], $Block['data']['markerType'], \true), '0') ?: '0';
                    if ($listStart !== '1') {
                        if (isset($CurrentBlock) and $CurrentBlock['type'] === 'Paragraph' and !isset($CurrentBlock['interrupted'])) {
                            return;
                        }
                        $Block['element']['attributes'] = array('start' => $listStart);
                    }
                }
                $Block['li'] = array('name' => 'li', 'handler' => array('function' => 'li', 'argument' => !empty($matches[3]) ? array($matches[3]) : array(), 'destination' => 'elements'));
                $Block['element']['elements'][] =& $Block['li'];
                return $Block;
            }
        }
        protected function blockListContinue($Line, array $Block)
        {
            if (isset($Block['interrupted']) and empty($Block['li']['handler']['argument'])) {
                return null;
            }
            $requiredIndent = $Block['indent'] + \strlen($Block['data']['marker']);
            if ($Line['indent'] < $requiredIndent and ($Block['data']['type'] === 'ol' and \preg_match('/^[0-9]++' . $Block['data']['markerTypeRegex'] . '(?:[ ]++(.*)|$)/', $Line['text'], $matches) or $Block['data']['type'] === 'ul' and \preg_match('/^' . $Block['data']['markerTypeRegex'] . '(?:[ ]++(.*)|$)/', $Line['text'], $matches))) {
                if (isset($Block['interrupted'])) {
                    $Block['li']['handler']['argument'][] = '';
                    $Block['loose'] = \true;
                    unset($Block['interrupted']);
                }
                unset($Block['li']);
                $text = isset($matches[1]) ? $matches[1] : '';
                $Block['indent'] = $Line['indent'];
                $Block['li'] = array('name' => 'li', 'handler' => array('function' => 'li', 'argument' => array($text), 'destination' => 'elements'));
                $Block['element']['elements'][] =& $Block['li'];
                return $Block;
            } elseif ($Line['indent'] < $requiredIndent and $this->blockList($Line)) {
                return null;
            }
            if ($Line['text'][0] === '[' and $this->blockReference($Line)) {
                return $Block;
            }
            if ($Line['indent'] >= $requiredIndent) {
                if (isset($Block['interrupted'])) {
                    $Block['li']['handler']['argument'][] = '';
                    $Block['loose'] = \true;
                    unset($Block['interrupted']);
                }
                $text = \substr($Line['body'], $requiredIndent);
                $Block['li']['handler']['argument'][] = $text;
                return $Block;
            }
            if (!isset($Block['interrupted'])) {
                $text = \preg_replace('/^[ ]{0,' . $requiredIndent . '}+/', '', $Line['body']);
                $Block['li']['handler']['argument'][] = $text;
                return $Block;
            }
        }
        protected function blockListComplete(array $Block)
        {
            if (isset($Block['loose'])) {
                foreach ($Block['element']['elements'] as &$li) {
                    if (\end($li['handler']['argument']) !== '') {
                        $li['handler']['argument'][] = '';
                    }
                }
            }
            return $Block;
        }
        #
        # Quote
        protected function blockQuote($Line)
        {
            if (\preg_match('/^>[ ]?+(.*+)/', $Line['text'], $matches)) {
                $Block = array('element' => array('name' => 'blockquote', 'handler' => array('function' => 'linesElements', 'argument' => (array) $matches[1], 'destination' => 'elements')));
                return $Block;
            }
        }
        protected function blockQuoteContinue($Line, array $Block)
        {
            if (isset($Block['interrupted'])) {
                return;
            }
            if ($Line['text'][0] === '>' and \preg_match('/^>[ ]?+(.*+)/', $Line['text'], $matches)) {
                $Block['element']['handler']['argument'][] = $matches[1];
                return $Block;
            }
            if (!isset($Block['interrupted'])) {
                $Block['element']['handler']['argument'][] = $Line['text'];
                return $Block;
            }
        }
        #
        # Rule
        protected function blockRule($Line)
        {
            $marker = $Line['text'][0];
            if (\substr_count($Line['text'], $marker) >= 3 and \chop($Line['text'], " {$marker}") === '') {
                $Block = array('element' => array('name' => 'hr'));
                return $Block;
            }
        }
        #
        # Setext
        protected function blockSetextHeader($Line, ?array $Block = null)
        {
            if (!isset($Block) or $Block['type'] !== 'Paragraph' or isset($Block['interrupted'])) {
                return;
            }
            if ($Line['indent'] < 4 and \chop(\chop($Line['text'], ' '), $Line['text'][0]) === '') {
                $Block['element']['name'] = $Line['text'][0] === '=' ? 'h1' : 'h2';
                return $Block;
            }
        }
        #
        # Markup
        protected function blockMarkup($Line)
        {
            if ($this->markupEscaped or $this->safeMode) {
                return;
            }
            if (\preg_match('/^<[\\/]?+(\\w*)(?:[ ]*+' . $this->regexHtmlAttribute . ')*+[ ]*+(\\/)?>/', $Line['text'], $matches)) {
                $element = \strtolower($matches[1]);
                if (\in_array($element, $this->textLevelElements)) {
                    return;
                }
                $Block = array('name' => $matches[1], 'element' => array('rawHtml' => $Line['text'], 'autobreak' => \true));
                return $Block;
            }
        }
        protected function blockMarkupContinue($Line, array $Block)
        {
            if (isset($Block['closed']) or isset($Block['interrupted'])) {
                return;
            }
            $Block['element']['rawHtml'] .= "\n" . $Line['body'];
            return $Block;
        }
        #
        # Reference
        protected function blockReference($Line)
        {
            if (\strpos($Line['text'], ']') !== \false and \preg_match('/^\\[(.+?)\\]:[ ]*+<?(\\S+?)>?(?:[ ]+["\'(](.+)["\')])?[ ]*+$/', $Line['text'], $matches)) {
                $id = \strtolower($matches[1]);
                $Data = array('url' => $matches[2], 'title' => isset($matches[3]) ? $matches[3] : null);
                $this->DefinitionData['Reference'][$id] = $Data;
                $Block = array('element' => array());
                return $Block;
            }
        }
        #
        # Table
        protected function blockTable($Line, ?array $Block = null)
        {
            if (!isset($Block) or $Block['type'] !== 'Paragraph' or isset($Block['interrupted'])) {
                return;
            }
            if (\strpos($Block['element']['handler']['argument'], '|') === \false and \strpos($Line['text'], '|') === \false and \strpos($Line['text'], ':') === \false or \strpos($Block['element']['handler']['argument'], "\n") !== \false) {
                return;
            }
            if (\chop($Line['text'], ' -:|') !== '') {
                return;
            }
            $alignments = array();
            $divider = $Line['text'];
            $divider = \trim($divider);
            $divider = \trim($divider, '|');
            $dividerCells = \explode('|', $divider);
            foreach ($dividerCells as $dividerCell) {
                $dividerCell = \trim($dividerCell);
                if ($dividerCell === '') {
                    return;
                }
                $alignment = null;
                if ($dividerCell[0] === ':') {
                    $alignment = 'left';
                }
                if (\substr($dividerCell, -1) === ':') {
                    $alignment = $alignment === 'left' ? 'center' : 'right';
                }
                $alignments[] = $alignment;
            }
            # ~
            $HeaderElements = array();
            $header = $Block['element']['handler']['argument'];
            $header = \trim($header);
            $header = \trim($header, '|');
            $headerCells = \explode('|', $header);
            if (\count($headerCells) !== \count($alignments)) {
                return;
            }
            foreach ($headerCells as $index => $headerCell) {
                $headerCell = \trim($headerCell);
                $HeaderElement = array('name' => 'th', 'handler' => array('function' => 'lineElements', 'argument' => $headerCell, 'destination' => 'elements'));
                if (isset($alignments[$index])) {
                    $alignment = $alignments[$index];
                    $HeaderElement['attributes'] = array('style' => "text-align: {$alignment};");
                }
                $HeaderElements[] = $HeaderElement;
            }
            # ~
            $Block = array('alignments' => $alignments, 'identified' => \true, 'element' => array('name' => 'table', 'elements' => array()));
            $Block['element']['elements'][] = array('name' => 'thead');
            $Block['element']['elements'][] = array('name' => 'tbody', 'elements' => array());
            $Block['element']['elements'][0]['elements'][] = array('name' => 'tr', 'elements' => $HeaderElements);
            return $Block;
        }
        protected function blockTableContinue($Line, array $Block)
        {
            if (isset($Block['interrupted'])) {
                return;
            }
            if (\count($Block['alignments']) === 1 or $Line['text'][0] === '|' or \strpos($Line['text'], '|')) {
                $Elements = array();
                $row = $Line['text'];
                $row = \trim($row);
                $row = \trim($row, '|');
                \preg_match_all('/(?:(\\\\[|])|[^|`]|`[^`]++`|`)++/', $row, $matches);
                $cells = \array_slice($matches[0], 0, \count($Block['alignments']));
                foreach ($cells as $index => $cell) {
                    $cell = \trim($cell);
                    $Element = array('name' => 'td', 'handler' => array('function' => 'lineElements', 'argument' => $cell, 'destination' => 'elements'));
                    if (isset($Block['alignments'][$index])) {
                        $Element['attributes'] = array('style' => 'text-align: ' . $Block['alignments'][$index] . ';');
                    }
                    $Elements[] = $Element;
                }
                $Element = array('name' => 'tr', 'elements' => $Elements);
                $Block['element']['elements'][1]['elements'][] = $Element;
                return $Block;
            }
        }
        #
        # ~
        #
        protected function paragraph($Line)
        {
            return array('type' => 'Paragraph', 'element' => array('name' => 'p', 'handler' => array('function' => 'lineElements', 'argument' => $Line['text'], 'destination' => 'elements')));
        }
        protected function paragraphContinue($Line, array $Block)
        {
            if (isset($Block['interrupted'])) {
                return;
            }
            $Block['element']['handler']['argument'] .= "\n" . $Line['text'];
            return $Block;
        }
        #
        # Inline Elements
        #
        protected $InlineTypes = array('!' => array('Image'), '&' => array('SpecialCharacter'), '*' => array('Emphasis'), ':' => array('Url'), '<' => array('UrlTag', 'EmailTag', 'Markup'), '[' => array('Link'), '_' => array('Emphasis'), '`' => array('Code'), '~' => array('Strikethrough'), '\\' => array('EscapeSequence'));
        # ~
        protected $inlineMarkerList = '!*_&[:<`~\\';
        #
        # ~
        #
        public function line($text, $nonNestables = array())
        {
            return $this->elements($this->lineElements($text, $nonNestables));
        }
        protected function lineElements($text, $nonNestables = array())
        {
            # standardize line breaks
            $text = \str_replace(array("\r\n", "\r"), "\n", $text);
            $Elements = array();
            $nonNestables = empty($nonNestables) ? array() : \array_combine($nonNestables, $nonNestables);
            # $excerpt is based on the first occurrence of a marker
            while ($excerpt = \strpbrk($text, $this->inlineMarkerList)) {
                $marker = $excerpt[0];
                $markerPosition = \strlen($text) - \strlen($excerpt);
                $Excerpt = array('text' => $excerpt, 'context' => $text);
                foreach ($this->InlineTypes[$marker] as $inlineType) {
                    # check to see if the current inline type is nestable in the current context
                    if (isset($nonNestables[$inlineType])) {
                        continue;
                    }
                    $Inline = $this->{"inline{$inlineType}"}($Excerpt);
                    if (!isset($Inline)) {
                        continue;
                    }
                    # makes sure that the inline belongs to "our" marker
                    if (isset($Inline['position']) and $Inline['position'] > $markerPosition) {
                        continue;
                    }
                    # sets a default inline position
                    if (!isset($Inline['position'])) {
                        $Inline['position'] = $markerPosition;
                    }
                    # cause the new element to 'inherit' our non nestables
                    $Inline['element']['nonNestables'] = isset($Inline['element']['nonNestables']) ? \array_merge($Inline['element']['nonNestables'], $nonNestables) : $nonNestables;
                    # the text that comes before the inline
                    $unmarkedText = \substr($text, 0, $Inline['position']);
                    # compile the unmarked text
                    $InlineText = $this->inlineText($unmarkedText);
                    $Elements[] = $InlineText['element'];
                    # compile the inline
                    $Elements[] = $this->extractElement($Inline);
                    # remove the examined text
                    $text = \substr($text, $Inline['position'] + $Inline['extent']);
                    continue 2;
                }
                # the marker does not belong to an inline
                $unmarkedText = \substr($text, 0, $markerPosition + 1);
                $InlineText = $this->inlineText($unmarkedText);
                $Elements[] = $InlineText['element'];
                $text = \substr($text, $markerPosition + 1);
            }
            $InlineText = $this->inlineText($text);
            $Elements[] = $InlineText['element'];
            foreach ($Elements as &$Element) {
                if (!isset($Element['autobreak'])) {
                    $Element['autobreak'] = \false;
                }
            }
            return $Elements;
        }
        #
        # ~
        #
        protected function inlineText($text)
        {
            $Inline = array('extent' => \strlen($text), 'element' => array());
            $Inline['element']['elements'] = self::pregReplaceElements($this->breaksEnabled ? '/[ ]*+\\n/' : '/(?:[ ]*+\\\\|[ ]{2,}+)\\n/', array(array('name' => 'br'), array('text' => "\n")), $text);
            return $Inline;
        }
        protected function inlineCode($Excerpt)
        {
            $marker = $Excerpt['text'][0];
            if (\preg_match('/^([' . $marker . ']++)[ ]*+(.+?)[ ]*+(?<![' . $marker . '])\\1(?!' . $marker . ')/s', $Excerpt['text'], $matches)) {
                $text = $matches[2];
                $text = \preg_replace('/[ ]*+\\n/', ' ', $text);
                return array('extent' => \strlen($matches[0]), 'element' => array('name' => 'code', 'text' => $text));
            }
        }
        protected function inlineEmailTag($Excerpt)
        {
            $hostnameLabel = '[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?';
            $commonMarkEmail = '[a-zA-Z0-9.!#$%&\'*+\\/=?^_`{|}~-]++@' . $hostnameLabel . '(?:\\.' . $hostnameLabel . ')*';
            if (\strpos($Excerpt['text'], '>') !== \false and \preg_match("/^<((mailto:)?{$commonMarkEmail})>/i", $Excerpt['text'], $matches)) {
                $url = $matches[1];
                if (!isset($matches[2])) {
                    $url = "mailto:{$url}";
                }
                return array('extent' => \strlen($matches[0]), 'element' => array('name' => 'a', 'text' => $matches[1], 'attributes' => array('href' => $url)));
            }
        }
        protected function inlineEmphasis($Excerpt)
        {
            if (!isset($Excerpt['text'][1])) {
                return;
            }
            $marker = $Excerpt['text'][0];
            if ($Excerpt['text'][1] === $marker and \preg_match($this->StrongRegex[$marker], $Excerpt['text'], $matches)) {
                $emphasis = 'strong';
            } elseif (\preg_match($this->EmRegex[$marker], $Excerpt['text'], $matches)) {
                $emphasis = 'em';
            } else {
                return;
            }
            return array('extent' => \strlen($matches[0]), 'element' => array('name' => $emphasis, 'handler' => array('function' => 'lineElements', 'argument' => $matches[1], 'destination' => 'elements')));
        }
        protected function inlineEscapeSequence($Excerpt)
        {
            if (isset($Excerpt['text'][1]) and \in_array($Excerpt['text'][1], $this->specialCharacters)) {
                return array('element' => array('rawHtml' => $Excerpt['text'][1]), 'extent' => 2);
            }
        }
        protected function inlineImage($Excerpt)
        {
            if (!isset($Excerpt['text'][1]) or $Excerpt['text'][1] !== '[') {
                return;
            }
            $Excerpt['text'] = \substr($Excerpt['text'], 1);
            $Link = $this->inlineLink($Excerpt);
            if ($Link === null) {
                return;
            }
            $Inline = array('extent' => $Link['extent'] + 1, 'element' => array('name' => 'img', 'attributes' => array('src' => $Link['element']['attributes']['href'], 'alt' => $Link['element']['handler']['argument']), 'autobreak' => \true));
            $Inline['element']['attributes'] += $Link['element']['attributes'];
            unset($Inline['element']['attributes']['href']);
            return $Inline;
        }
        protected function inlineLink($Excerpt)
        {
            $Element = array('name' => 'a', 'handler' => array('function' => 'lineElements', 'argument' => null, 'destination' => 'elements'), 'nonNestables' => array('Url', 'Link'), 'attributes' => array('href' => null, 'title' => null));
            $extent = 0;
            $remainder = $Excerpt['text'];
            if (\preg_match('/\\[((?:[^][]++|(?R))*+)\\]/', $remainder, $matches)) {
                $Element['handler']['argument'] = $matches[1];
                $extent += \strlen($matches[0]);
                $remainder = \substr($remainder, $extent);
            } else {
                return;
            }
            if (\preg_match('/^[(]\\s*+((?:[^ ()]++|[(][^ )]+[)])++)(?:[ ]+("[^"]*+"|\'[^\']*+\'))?\\s*+[)]/', $remainder, $matches)) {
                $Element['attributes']['href'] = $matches[1];
                if (isset($matches[2])) {
                    $Element['attributes']['title'] = \substr($matches[2], 1, -1);
                }
                $extent += \strlen($matches[0]);
            } else {
                if (\preg_match('/^\\s*\\[(.*?)\\]/', $remainder, $matches)) {
                    $definition = \strlen($matches[1]) ? $matches[1] : $Element['handler']['argument'];
                    $definition = \strtolower($definition);
                    $extent += \strlen($matches[0]);
                } else {
                    $definition = \strtolower($Element['handler']['argument']);
                }
                if (!isset($this->DefinitionData['Reference'][$definition])) {
                    return;
                }
                $Definition = $this->DefinitionData['Reference'][$definition];
                $Element['attributes']['href'] = $Definition['url'];
                $Element['attributes']['title'] = $Definition['title'];
            }
            return array('extent' => $extent, 'element' => $Element);
        }
        protected function inlineMarkup($Excerpt)
        {
            if ($this->markupEscaped or $this->safeMode or \strpos($Excerpt['text'], '>') === \false) {
                return;
            }
            if ($Excerpt['text'][1] === '/' and \preg_match('/^<\\/\\w[\\w-]*+[ ]*+>/s', $Excerpt['text'], $matches)) {
                return array('element' => array('rawHtml' => $matches[0]), 'extent' => \strlen($matches[0]));
            }
            if ($Excerpt['text'][1] === '!' and \preg_match('/^<!---?[^>-](?:-?+[^-])*-->/s', $Excerpt['text'], $matches)) {
                return array('element' => array('rawHtml' => $matches[0]), 'extent' => \strlen($matches[0]));
            }
            if ($Excerpt['text'][1] !== ' ' and \preg_match('/^<\\w[\\w-]*+(?:[ ]*+' . $this->regexHtmlAttribute . ')*+[ ]*+\\/?>/s', $Excerpt['text'], $matches)) {
                return array('element' => array('rawHtml' => $matches[0]), 'extent' => \strlen($matches[0]));
            }
        }
        protected function inlineSpecialCharacter($Excerpt)
        {
            if (\substr($Excerpt['text'], 1, 1) !== ' ' and \strpos($Excerpt['text'], ';') !== \false and \preg_match('/^&(#?+[0-9a-zA-Z]++);/', $Excerpt['text'], $matches)) {
                return array('element' => array('rawHtml' => '&' . $matches[1] . ';'), 'extent' => \strlen($matches[0]));
            }
            return;
        }
        protected function inlineStrikethrough($Excerpt)
        {
            if (!isset($Excerpt['text'][1])) {
                return;
            }
            if ($Excerpt['text'][1] === '~' and \preg_match('/^~~(?=\\S)(.+?)(?<=\\S)~~/', $Excerpt['text'], $matches)) {
                return array('extent' => \strlen($matches[0]), 'element' => array('name' => 'del', 'handler' => array('function' => 'lineElements', 'argument' => $matches[1], 'destination' => 'elements')));
            }
        }
        protected function inlineUrl($Excerpt)
        {
            if ($this->urlsLinked !== \true or !isset($Excerpt['text'][2]) or $Excerpt['text'][2] !== '/') {
                return;
            }
            if (\strpos($Excerpt['context'], 'http') !== \false and \preg_match('/\\bhttps?+:[\\/]{2}[^\\s<]+\\b\\/*+/ui', $Excerpt['context'], $matches, \PREG_OFFSET_CAPTURE)) {
                $url = $matches[0][0];
                $Inline = array('extent' => \strlen($matches[0][0]), 'position' => $matches[0][1], 'element' => array('name' => 'a', 'text' => $url, 'attributes' => array('href' => $url)));
                return $Inline;
            }
        }
        protected function inlineUrlTag($Excerpt)
        {
            if (\strpos($Excerpt['text'], '>') !== \false and \preg_match('/^<(\\w++:\\/{2}[^ >]++)>/i', $Excerpt['text'], $matches)) {
                $url = $matches[1];
                return array('extent' => \strlen($matches[0]), 'element' => array('name' => 'a', 'text' => $url, 'attributes' => array('href' => $url)));
            }
        }
        # ~
        protected function unmarkedText($text)
        {
            $Inline = $this->inlineText($text);
            return $this->element($Inline['element']);
        }
        #
        # Handlers
        #
        protected function handle(array $Element)
        {
            if (isset($Element['handler'])) {
                if (!isset($Element['nonNestables'])) {
                    $Element['nonNestables'] = array();
                }
                if (\is_string($Element['handler'])) {
                    $function = $Element['handler'];
                    $argument = $Element['text'];
                    unset($Element['text']);
                    $destination = 'rawHtml';
                } else {
                    $function = $Element['handler']['function'];
                    $argument = $Element['handler']['argument'];
                    $destination = $Element['handler']['destination'];
                }
                $Element[$destination] = $this->{$function}($argument, $Element['nonNestables']);
                if ($destination === 'handler') {
                    $Element = $this->handle($Element);
                }
                unset($Element['handler']);
            }
            return $Element;
        }
        protected function handleElementRecursive(array $Element)
        {
            return $this->elementApplyRecursive(array($this, 'handle'), $Element);
        }
        protected function handleElementsRecursive(array $Elements)
        {
            return $this->elementsApplyRecursive(array($this, 'handle'), $Elements);
        }
        protected function elementApplyRecursive($closure, array $Element)
        {
            $Element = \call_user_func($closure, $Element);
            if (isset($Element['elements'])) {
                $Element['elements'] = $this->elementsApplyRecursive($closure, $Element['elements']);
            } elseif (isset($Element['element'])) {
                $Element['element'] = $this->elementApplyRecursive($closure, $Element['element']);
            }
            return $Element;
        }
        protected function elementApplyRecursiveDepthFirst($closure, array $Element)
        {
            if (isset($Element['elements'])) {
                $Element['elements'] = $this->elementsApplyRecursiveDepthFirst($closure, $Element['elements']);
            } elseif (isset($Element['element'])) {
                $Element['element'] = $this->elementsApplyRecursiveDepthFirst($closure, $Element['element']);
            }
            $Element = \call_user_func($closure, $Element);
            return $Element;
        }
        protected function elementsApplyRecursive($closure, array $Elements)
        {
            foreach ($Elements as &$Element) {
                $Element = $this->elementApplyRecursive($closure, $Element);
            }
            return $Elements;
        }
        protected function elementsApplyRecursiveDepthFirst($closure, array $Elements)
        {
            foreach ($Elements as &$Element) {
                $Element = $this->elementApplyRecursiveDepthFirst($closure, $Element);
            }
            return $Elements;
        }
        protected function element(array $Element)
        {
            if ($this->safeMode) {
                $Element = $this->sanitiseElement($Element);
            }
            # identity map if element has no handler
            $Element = $this->handle($Element);
            $hasName = isset($Element['name']);
            $markup = '';
            if ($hasName) {
                $markup .= '<' . $Element['name'];
                if (isset($Element['attributes'])) {
                    foreach ($Element['attributes'] as $name => $value) {
                        if ($value === null) {
                            continue;
                        }
                        $markup .= " {$name}=\"" . self::escape($value) . '"';
                    }
                }
            }
            $permitRawHtml = \false;
            if (isset($Element['text'])) {
                $text = $Element['text'];
            } elseif (isset($Element['rawHtml'])) {
                $text = $Element['rawHtml'];
                $allowRawHtmlInSafeMode = isset($Element['allowRawHtmlInSafeMode']) && $Element['allowRawHtmlInSafeMode'];
                $permitRawHtml = !$this->safeMode || $allowRawHtmlInSafeMode;
            }
            $hasContent = isset($text) || isset($Element['element']) || isset($Element['elements']);
            if ($hasContent) {
                $markup .= $hasName ? '>' : '';
                if (isset($Element['elements'])) {
                    $markup .= $this->elements($Element['elements']);
                } elseif (isset($Element['element'])) {
                    $markup .= $this->element($Element['element']);
                } else {
                    if (!$permitRawHtml) {
                        $markup .= self::escape($text, \true);
                    } else {
                        $markup .= $text;
                    }
                }
                $markup .= $hasName ? '</' . $Element['name'] . '>' : '';
            } elseif ($hasName) {
                $markup .= ' />';
            }
            return $markup;
        }
        protected function elements(array $Elements)
        {
            $markup = '';
            $autoBreak = \true;
            foreach ($Elements as $Element) {
                if (empty($Element)) {
                    continue;
                }
                $autoBreakNext = isset($Element['autobreak']) ? $Element['autobreak'] : isset($Element['name']);
                // (autobreak === false) covers both sides of an element
                $autoBreak = !$autoBreak ? $autoBreak : $autoBreakNext;
                $markup .= ($autoBreak ? "\n" : '') . $this->element($Element);
                $autoBreak = $autoBreakNext;
            }
            $markup .= $autoBreak ? "\n" : '';
            return $markup;
        }
        # ~
        protected function li($lines)
        {
            $Elements = $this->linesElements($lines);
            if (!\in_array('', $lines) and isset($Elements[0]) and isset($Elements[0]['name']) and $Elements[0]['name'] === 'p') {
                unset($Elements[0]['name']);
            }
            return $Elements;
        }
        #
        # AST Convenience
        #
        /**
         * Replace occurrences $regexp with $Elements in $text. Return an array of
         * elements representing the replacement.
         */
        protected static function pregReplaceElements($regexp, $Elements, $text)
        {
            $newElements = array();
            while (\preg_match($regexp, $text, $matches, \PREG_OFFSET_CAPTURE)) {
                $offset = $matches[0][1];
                $before = \substr($text, 0, $offset);
                $after = \substr($text, $offset + \strlen($matches[0][0]));
                $newElements[] = array('text' => $before);
                foreach ($Elements as $Element) {
                    $newElements[] = $Element;
                }
                $text = $after;
            }
            $newElements[] = array('text' => $text);
            return $newElements;
        }
        #
        # Deprecated Methods
        #
        function parse($text)
        {
            $markup = $this->text($text);
            return $markup;
        }
        protected function sanitiseElement(array $Element)
        {
            static $goodAttribute = '/^[a-zA-Z0-9][a-zA-Z0-9-_]*+$/';
            static $safeUrlNameToAtt = array('a' => 'href', 'img' => 'src');
            if (!isset($Element['name'])) {
                unset($Element['attributes']);
                return $Element;
            }
            if (isset($safeUrlNameToAtt[$Element['name']])) {
                $Element = $this->filterUnsafeUrlInAttribute($Element, $safeUrlNameToAtt[$Element['name']]);
            }
            if (!empty($Element['attributes'])) {
                foreach ($Element['attributes'] as $att => $val) {
                    # filter out badly parsed attribute
                    if (!\preg_match($goodAttribute, $att)) {
                        unset($Element['attributes'][$att]);
                    } elseif (self::striAtStart($att, 'on')) {
                        unset($Element['attributes'][$att]);
                    }
                }
            }
            return $Element;
        }
        protected function filterUnsafeUrlInAttribute(array $Element, $attribute)
        {
            foreach ($this->safeLinksWhitelist as $scheme) {
                if (self::striAtStart($Element['attributes'][$attribute], $scheme)) {
                    return $Element;
                }
            }
            $Element['attributes'][$attribute] = \str_replace(':', '%3A', $Element['attributes'][$attribute]);
            return $Element;
        }
        #
        # Static Methods
        #
        protected static function escape($text, $allowQuotes = \false)
        {
            return \htmlspecialchars($text, $allowQuotes ? \ENT_NOQUOTES : \ENT_QUOTES, 'UTF-8');
        }
        protected static function striAtStart($string, $needle)
        {
            $len = \strlen($needle);
            if ($len > \strlen($string)) {
                return \false;
            } else {
                return \strtolower(\substr($string, 0, $len)) === \strtolower($needle);
            }
        }
        static function instance($name = 'default')
        {
            if (isset(self::$instances[$name])) {
                return self::$instances[$name];
            }
            $instance = new static();
            self::$instances[$name] = $instance;
            return $instance;
        }
        private static $instances = array();
        #
        # Fields
        #
        protected $DefinitionData;
        #
        # Read-Only
        protected $specialCharacters = array('\\', '`', '*', '_', '{', '}', '[', ']', '(', ')', '>', '#', '+', '-', '.', '!', '|', '~');
        protected $StrongRegex = array('*' => '/^[*]{2}((?:\\\\\\*|[^*]|[*][^*]*+[*])+?)[*]{2}(?![*])/s', '_' => '/^__((?:\\\\_|[^_]|_[^_]*+_)+?)__(?!_)/us');
        protected $EmRegex = array('*' => '/^[*]((?:\\\\\\*|[^*]|[*][*][^*]+?[*][*])+?)[*](?![*])/s', '_' => '/^_((?:\\\\_|[^_]|__[^_]*__)+?)_(?!_)\\b/us');
        protected $regexHtmlAttribute = '[a-zA-Z_:][\\w:.-]*+(?:\\s*+=\\s*+(?:[^"\'=<>`\\s]+|"[^"]*+"|\'[^\']*+\'))?+';
        protected $voidElements = array('area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source');
        protected $textLevelElements = array('a', 'br', 'bdo', 'abbr', 'blink', 'nextid', 'acronym', 'basefont', 'b', 'em', 'big', 'cite', 'small', 'spacer', 'listing', 'i', 'rp', 'del', 'code', 'strike', 'marquee', 'q', 'rt', 'ins', 'font', 'strong', 's', 'tt', 'kbd', 'mark', 'u', 'xm', 'sub', 'nobr', 'sup', 'ruby', 'var', 'span', 'wbr', 'time');
    }
}