Hannesalm / EventCalendar

#

# Markdown  -  A text-to-HTML conversion tool for web writers

#

# PHP Markdown  

# Copyright (c) 2004-2015 Michel Fortin  

# <https://michelf.ca/projects/php-markdown/>

#

# Original Markdown  

# Copyright (c) 2004-2006 John Gruber  

# <http://daringfireball.net/projects/markdown/>

#

namespace Michelf;

#

# Markdown Parser Class

#

class Markdown implements MarkdownInterface {

	### Version ###

	const  MARKDOWNLIB_VERSION  =  "1.5.0";

	### Simple Function Interface ###

	public static function defaultTransform($text) {

	#

	# Initialize the parser and return the result of its transform method.

	# This will work fine for derived classes too.

	#

		# Take parser class on which this function was called.

		$parser_class = \get_called_class();

		# try to take parser from the static parser list

		static $parser_list;

		$parser =& $parser_list[$parser_class];

		# create the parser it not already set

		if (!$parser)

			$parser = new $parser_class;

		# Transform text using parser.

		return $parser->transform($text);

	}

	### Configuration Variables ###

	# Change to ">" for HTML output.

	public $empty_element_suffix = " />";

	public $tab_width = 4;

	# Change to `true` to disallow markup or entities.

	public $no_markup = false;

	public $no_entities = false;

	# Predefined urls and titles for reference links and images.

	public $predef_urls = array();

	public $predef_titles = array();

	# Optional filter function for URLs

	public $url_filter_func = null;

	# Optional header id="" generation callback function.

	public $header_id_func = null;

	# Class attribute to toggle "enhanced ordered list" behaviour

	# setting this to true will allow ordered lists to start from the index

	# number that is defined first.  For example:

	# 2. List item two

	# 3. List item three

	# 

	# becomes

	# <ol start="2">

	# <li>List item two</li>

	# <li>List item three</li>

	# </ol>

	public $enhanced_ordered_list = false;

	### Parser Implementation ###

	# Regex to match balanced [brackets].

	# Needed to insert a maximum bracked depth while converting to PHP.

	protected $nested_brackets_depth = 6;

	protected $nested_brackets_re;

	protected $nested_url_parenthesis_depth = 4;

	protected $nested_url_parenthesis_re;

	# Table of hash values for escaped characters:

	protected $escape_chars = '\`*_{}[]()>#+-.!';

	protected $escape_chars_re;

	public function __construct() {

	#

	# Constructor function. Initialize appropriate member variables.

	#

		$this->_initDetab();

		$this->prepareItalicsAndBold();

		$this->nested_brackets_re = 

			str_repeat('(?>[^\[\]]+|\[', $this->nested_brackets_depth).

			str_repeat('\])*', $this->nested_brackets_depth);

		$this->nested_url_parenthesis_re = 

			str_repeat('(?>[^()\s]+|\(', $this->nested_url_parenthesis_depth).

			str_repeat('(?>\)))*', $this->nested_url_parenthesis_depth);

		$this->escape_chars_re = '['.preg_quote($this->escape_chars).']';

		# Sort document, block, and span gamut in ascendent priority order.

		asort($this->document_gamut);

		asort($this->block_gamut);

		asort($this->span_gamut);

	}

	# Internal hashes used during transformation.

	protected $urls = array();

	protected $titles = array();

	protected $html_hashes = array();

	# Status flag to avoid invalid nesting.

	protected $in_anchor = false;

	protected function setup() {

	#

	# Called before the transformation process starts to setup parser 

	# states.

	#

		# Clear global hashes.

		$this->urls = $this->predef_urls;

		$this->titles = $this->predef_titles;

		$this->html_hashes = array();

		$this->in_anchor = false;

	}

	protected function teardown() {

	#

	# Called after the transformation process to clear any variable 

	# which may be taking up memory unnecessarly.

	#

		$this->urls = array();

		$this->titles = array();

		$this->html_hashes = array();

	}

	public function transform($text) {

	#

	# Main function. Performs some preprocessing on the input text

	# and pass it through the document gamut.

	#

		$this->setup();

		# Remove UTF-8 BOM and marker character in input, if present.

		$text = preg_replace('{^\xEF\xBB\xBF|\x1A}', '', $text);

		# Standardize line endings:

		#   DOS to Unix and Mac to Unix

		$text = preg_replace('{\r\n?}', "\n", $text);

		# Make sure $text ends with a couple of newlines:

		$text .= "\n\n";

		# Convert all tabs to spaces.

		$text = $this->detab($text);

		# Turn block-level HTML blocks into hash entries

		$text = $this->hashHTMLBlocks($text);

		# Strip any lines consisting only of spaces and tabs.

		# This makes subsequent regexen easier to write, because we can

		# match consecutive blank lines with /\n+/ instead of something

		# contorted like /[ ]*\n+/ .

		$text = preg_replace('/^[ ]+$/m', '', $text);

		# Run document gamut methods.

		foreach ($this->document_gamut as $method => $priority) {

			$text = $this->$method($text);

		}

		$this->teardown();

		return $text . "\n";

	}

	protected $document_gamut = array(

		# Strip link definitions, store in hashes.

		"stripLinkDefinitions" => 20,

		"runBasicBlockGamut"   => 30,

	#

		$less_than_tab = $this->tab_width - 1;

		# Link defs are in the form: ^[id]: url "optional title"

		$text = preg_replace_callback('{

							^[ ]{0,'.$less_than_tab.'}\[(.+)\][ ]?:	# id = $1

							  [ ]*

							  \n?				# maybe *one* newline

							  [ ]*

							(?:

							  <(.+?)>			# url = $2

							|

							  (\S+?)			# url = $3

							)

							  [ ]*

							  \n?				# maybe one newline

							  [ ]*

							(?:

								(?<=\s)			# lookbehind for whitespace

								["(]

								(.*?)			# title = $4

								[")]

								[ ]*

							)?	# title is optional

							(?:\n+|\Z)

			}xm',

			array($this, '_stripLinkDefinitions_callback'),

			$text);

		return $text;

	}

	protected function _stripLinkDefinitions_callback($matches) {

		$link_id = strtolower($matches[1]);

		$url = $matches[2] == '' ? $matches[3] : $matches[2];

		$this->urls[$link_id] = $url;

		$this->titles[$link_id] =& $matches[4];

		return ''; # String that will replace the block

	}

	protected function hashHTMLBlocks($text) {

		if ($this->no_markup)  return $text;

		$less_than_tab = $this->tab_width - 1;

		# Hashify HTML blocks:

		# We only want to do this for block-level HTML tags, such as headers,

		# lists, and tables. That's because we still want to wrap <p>s around

		# "paragraphs" that are wrapped in non-block-level tags, such as anchors,

		# phrase emphasis, and spans. The list of tags we're looking for is

		# hard-coded:

		#

		# *  List "a" is made of tags which can be both inline or block-level.

		#    These will be treated block-level when the start tag is alone on 

		#    its line, otherwise they're not matched here and will be taken as 

		#    inline later.

		# *  List "b" is made of tags which are always block-level;

		#

		$block_tags_a_re = 'ins|del';

		$block_tags_b_re = 'p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|address|'.

						   'script|noscript|style|form|fieldset|iframe|math|svg|'.

						   'article|section|nav|aside|hgroup|header|footer|'.

						   'figure';

		# Regular expression for the content of a block tag.

		$nested_tags_level = 4;

		$attr = '

			(?>				# optional tag attributes

			  \s			# starts with whitespace

			  (?>

				[^>"/]+		# text outside quotes

			  |

				/+(?!>)		# slash not followed by ">"

			  |

				"[^"]*"		# text inside double quotes (tolerate ">")

			  |

				\'[^\']*\'	# text inside single quotes (tolerate ">")

			  )*

			)?	

			';

		$content =

			str_repeat('

				(?>

				  [^<]+			# content without tag

				|

				  <\2			# nested opening tag

					'.$attr.'	# attributes

					(?>

					  />

					|

					  >', $nested_tags_level).	# end of opening tag

					  '.*?'.					# last level nested tag content

			str_repeat('

					  </\2\s*>	# closing nested tag

					)

				  |				

					<(?!/\2\s*>	# other tags with a different name

				  )

				)*',

				$nested_tags_level);

		$content2 = str_replace('\2', '\3', $content);

		# First, look for nested blocks, e.g.:

		# 	<div>

		# 		<div>

		# 		tags for inner block must be indented.

		# 		</div>

		# 	</div>

		#

		# The outermost tags must start at the left margin for this to match, and

		# the inner nested divs must be indented.

		# We need to do this before the next, more liberal match, because the next

		# match will start at the first `<div>` and stop at the first `</div>`.

		$text = preg_replace_callback('{(?>

			(?>

				(?<=\n)			# Starting on its own line

				|				# or

				\A\n?			# the at beginning of the doc

			)

			(						# save in $1

			  # Match from `\n<tag>` to `</tag>\n`, handling nested tags 

			  # in between.

						[ ]{0,'.$less_than_tab.'}

						<('.$block_tags_b_re.')# start tag = $2

						'.$attr.'>			# attributes followed by > and \n

						'.$content.'		# content, support nesting

						</\2>				# the matching end tag

						[ ]*				# trailing spaces/tabs

						(?=\n+|\Z)	# followed by a newline or end of document

			| # Special version for tags of group a.

						[ ]{0,'.$less_than_tab.'}

						<('.$block_tags_a_re.')# start tag = $3

						'.$attr.'>[ ]*\n	# attributes followed by >

						'.$content2.'		# content, support nesting

						</\3>				# the matching end tag

						[ ]*				# trailing spaces/tabs

						(?=\n+|\Z)	# followed by a newline or end of document

			| # Special case just for <hr />. It was easier to make a special 

			  # case than to make the other regex more complicated.

						[ ]{0,'.$less_than_tab.'}

						<(hr)				# start tag = $2

						'.$attr.'			# attributes

						/?>					# the matching end tag

						[ ]*

						(?=\n{2,}|\Z)		# followed by a blank line or end of document

			| # Special case for standalone HTML comments:

					[ ]{0,'.$less_than_tab.'}

					(?s:

						<!-- .*? -->

					)

					[ ]*

					(?=\n{2,}|\Z)		# followed by a blank line or end of document

			| # PHP and ASP-style processor instructions (<? and <%)

					[ ]{0,'.$less_than_tab.'}

					(?s:

						<([?%])			# $2

						.*?

						\2>

					)

					[ ]*

					(?=\n{2,}|\Z)		# followed by a blank line or end of document

			)

			)}Sxmi',

			array($this, '_hashHTMLBlocks_callback'),

			$text);

		return $text;

	}

	protected function _hashHTMLBlocks_callback($matches) {

		$text = $matches[1];

		$key  = $this->hashBlock($text);

		return "\n\n$key\n\n";

	}

	protected function hashPart($text, $boundary = 'X') {

	#

	# Called whenever a tag must be hashed when a function insert an atomic 

	# element in the text stream. Passing $text to through this function gives

	# a unique text-token which will be reverted back when calling unhash.

	#

	# The $boundary argument specify what character should be used to surround

	# the token. By convension, "B" is used for block elements that needs not

	# to be wrapped into paragraph tags at the end, ":" is used for elements

	# that are word separators and "X" is used in the general case.

	#

		# Swap back any tag hash found in $text so we do not have to `unhash`

		# multiple times at the end.

		$text = $this->unhash($text);

		# Then hash the block.

		static $i = 0;

		$key = "$boundary\x1A" . ++$i . $boundary;

		$this->html_hashes[$key] = $text;

		return $key; # String that will replace the tag.

	}

	protected function hashBlock($text) {

	#

	# Shortcut function for hashPart with block-level boundaries.

	#

		return $this->hashPart($text, 'B');

	}

	protected $block_gamut = array(

	#

	# These are all the transformations that form block-level

	# tags like paragraphs, headers, and list items.

	#

		"doHeaders"         => 10,

		"doHorizontalRules" => 20,

		"doLists"           => 40,

		"doCodeBlocks"      => 50,

		"doBlockQuotes"     => 60,

		);

	protected function runBlockGamut($text) {

	#

	# Run block gamut tranformations.

	#

		# We need to escape raw HTML in Markdown source before doing anything 

		# else. This need to be done for each block, and not only at the 

		# begining in the Markdown function since hashed blocks can be part of

		# list items and could have been indented. Indented blocks would have 

		# been seen as a code block in a previous pass of hashHTMLBlocks.

		$text = $this->hashHTMLBlocks($text);

		return $this->runBasicBlockGamut($text);

	}

	protected function runBasicBlockGamut($text) {

	#

	# Run block gamut tranformations, without hashing HTML blocks. This is 

	# useful when HTML blocks are known to be already hashed, like in the first

	# whole-document pass.

	#

		foreach ($this->block_gamut as $method => $priority) {

			$text = $this->$method($text);

		}

		# Finally form paragraph and restore hashed blocks.

		$text = $this->formParagraphs($text);

		return $text;

	}

	protected function doHorizontalRules($text) {

		# Do Horizontal Rules:

		return preg_replace(

			'{

				^[ ]{0,3}	# Leading space

				([-*_])		# $1: First marker

				(?>			# Repeated marker group

					[ ]{0,2}	# Zero, one, or two spaces.

					\1			# Marker character

				){2,}		# Group repeated at least twice

				[ ]*		# Tailing spaces

				$			# End of line.

			}mx',

			"\n".$this->hashBlock("<hr$this->empty_element_suffix")."\n", 

			$text);

	}

	protected $span_gamut = array(

	#

	# These are all the transformations that occur *within* block-level

	# tags like paragraphs, headers, and list items.

	#

		# Process character escapes, code spans, and inline HTML

		# in one shot.

		"parseSpan"           => -30,

		# Process anchor and image tags. Images must come first,

		# because ![foo][f] looks like an anchor.

		"doImages"            =>  10,

		"doAnchors"           =>  20,

		# Make links out of things like `<http://example.com/>`

		# Must come after doAnchors, because you can use < and >

		# delimiters in inline links like [this](<url>).

		"doAutoLinks"         =>  30,

		"encodeAmpsAndAngles" =>  40,

		"doItalicsAndBold"    =>  50,

		"doHardBreaks"        =>  60,

		);

	protected function runSpanGamut($text) {

	#

	# Run span gamut tranformations.

	#

		foreach ($this->span_gamut as $method => $priority) {

			$text = $this->$method($text);

		}

		return $text;

	}

	protected function doHardBreaks($text) {

		# Do hard breaks:

		if ($this->in_anchor) return $text;

		$this->in_anchor = true;

		#

		# First, handle reference-style links: [link text] [id]

		#

		$text = preg_replace_callback('{

			(					# wrap whole match in $1

			  \[

				('.$this->nested_brackets_re.')	# link text = $2

			  \]

			  [ ]?				# one optional space

			  (?:\n[ ]*)?		# one optional newline followed by spaces

			  \[

				(.*?)		# id = $3

			  \]

			)

			}xs',

			array($this, '_doAnchors_reference_callback'), $text);

		#

		# Next, inline-style links: [link text](url "optional title")

		#

		$text = preg_replace_callback('{

			(				# wrap whole match in $1

			  \[

				('.$this->nested_brackets_re.')	# link text = $2

			  \]

			  \(			# literal paren

				[ \n]*

				(?:

					<(.+?)>	# href = $3

				|

					('.$this->nested_url_parenthesis_re.')	# href = $4

				)

				[ \n]*

				(			# $5

				  ([\'"])	# quote char = $6

				  (.*?)		# Title = $7

				  \6		# matching quote

				  [ \n]*	# ignore any spaces/tabs between closing quote and )

				)?			# title is optional

			  \)

			)

			}xs',

			array($this, '_doAnchors_inline_callback'), $text);

			  \[

				([^\[\]]+)		# link text = $2; can\'t contain [ or ]

			  \]

			)

			}xs',

			array($this, '_doAnchors_reference_callback'), $text);

		$this->in_anchor = false;

		return $text;

	}

	protected function _doAnchors_reference_callback($matches) {

		$whole_match =  $matches[1];

		$link_text   =  $matches[2];

		# lower-case and turn embedded newlines into spaces

		$link_id = strtolower($link_id);

		$link_id = preg_replace('{[ ]?\n}', ' ', $link_id);

		if (isset($this->urls[$link_id])) {

			$url = $this->urls[$link_id];

			}

			$link_text = $this->runSpanGamut($link_text);

			$result .= ">$link_text</a>";

			$result = $this->hashPart($result);

		}

		else {

			$result = $whole_match;

		}

		// if the URL was of the form <s p a c e s> it got caught by the HTML

		// tag parser and hashed. Need to reverse the process before using the URL.

		$unhashed = $this->unhash($url);

		if ($unhashed != $url)

			$url = preg_replace('/^<(.*)>$/', '\1', $unhashed);

		$url = $this->encodeURLAttribute($url);

		$result = "<a href=\"$url\"";

		if (isset($title)) {

			$title = $this->encodeAttribute($title);

			$result .=  " title=\"$title\"";

		}

		$link_text = $this->runSpanGamut($link_text);

		$result .= ">$link_text</a>";

		return $this->hashPart($result);

		#

		# First, handle reference-style labeled images: ![alt text][id]

		#

		$text = preg_replace_callback('{

			(				# wrap whole match in $1

			  !\[

				('.$this->nested_brackets_re.')		# alt text = $2

			  \]

			  [ ]?				# one optional space

			  (?:\n[ ]*)?		# one optional newline followed by spaces

			  \[

				(.*?)		# id = $3

			  \]

			)

			}xs', 

			array($this, '_doImages_reference_callback'), $text);

		#

		# Next, handle inline images:  ![alt text](url "optional title")

		# Don't forget: encode * and _

		#

		$text = preg_replace_callback('{

			(				# wrap whole match in $1

			  !\[

				('.$this->nested_brackets_re.')		# alt text = $2

			  \]

			  \s?			# One optional whitespace character

			  \(			# literal paren

				[ \n]*

				(?:

					<(\S*)>	# src url = $3

				|

					('.$this->nested_url_parenthesis_re.')	# src url = $4

				)

				[ \n]*

				(			# $5

				  ([\'"])	# quote char = $6

				  (.*?)		# title = $7

				  \6		# matching quote

				  [ \n]*

				)?			# title is optional

			  \)

			)

			}xs',

			array($this, '_doImages_inline_callback'), $text);

		return $text;

	}

	protected function _doImages_reference_callback($matches) {

		$whole_match = $matches[1];

		$alt_text    = $matches[2];

			}

			$result .= $this->empty_element_suffix;

			$result = $this->hashPart($result);

		}

		else {

			# If there's no such link ID, leave intact:

			$result = $whole_match;

		}

		$alt_text = $this->encodeAttribute($alt_text);

		$url = $this->encodeURLAttribute($url);

		$result = "<img src=\"$url\" alt=\"$alt_text\"";

		if (isset($title)) {

			$title = $this->encodeAttribute($title);

			$result .=  " title=\"$title\""; # $title already quoted

		}

		$result .= $this->empty_element_suffix;

		return $this->hashPart($result);

	}

	protected function doHeaders($text) {

		# Setext-style headers:

		#	  Header 1

		#	  ========

		#  

		#	  Header 2

		#	  --------

		#

		$text = preg_replace_callback('{ ^(.+?)[ ]*\n(=+|-+)[ ]*\n+ }mx',

			array($this, '_doHeaders_callback_setext'), $text);

		# atx-style headers:

		#	# Header 1

		#	## Header 2

		#	## Header 2 with closing hashes ##

		#	...

		#	###### Header 6

		#

		$text = preg_replace_callback('{

				^(\#{1,6})	# $1 = string of #\'s

				[ ]*

				(.+?)		# $2 = Header text

				[ ]*

				\#*			# optional closing #\'s (not counted)

				\n+

			}xm',

			array($this, '_doHeaders_callback_atx'), $text);

		return $text;

	}

		# id attribute generation

		$idAtt = $this->_generateIdFromHeaderValue($matches[1]);

		$block = "<h$level$idAtt>".$this->runSpanGamut($matches[1])."</h$level>";

		return "\n" . $this->hashBlock($block) . "\n\n";

	}

	protected function _doHeaders_callback_atx($matches) {

		# id attribute generation

		$idAtt = $this->_generateIdFromHeaderValue($matches[2]);

		$level = strlen($matches[1]);

		$block = "<h$level$idAtt>".$this->runSpanGamut($matches[2])."</h$level>";

		return "\n" . $this->hashBlock($block) . "\n\n";

	}

	protected function _generateIdFromHeaderValue($headerValue) {

		# if a header_id_func property is set, we can use it to automatically

		# generate an id attribute.

		#

		# This method returns a string in the form id="foo", or an empty string

		# otherwise.

		if (!is_callable($this->header_id_func)) {

			return "";

		}

		$idValue = call_user_func($this->header_id_func, $headerValue);

		if (!$idValue) return "";

		return ' id="' . $this->encodeAttribute($idValue) . '"';

	}

	protected function doLists($text) {

	#

	# Form HTML ordered (numbered) and unordered (bulleted) lists.

	#

		$less_than_tab = $this->tab_width - 1;

		# Re-usable patterns to match list item bullets and number markers:

		$marker_ul_re  = '[*+-]';

		$marker_ol_re  = '\d+[\.]';

		$markers_relist = array(

			$marker_ul_re => $marker_ol_re,

			$marker_ol_re => $marker_ul_re,

			);

		foreach ($markers_relist as $marker_re => $other_marker_re) {

			# Re-usable pattern to match any entirel ul or ol list:

			$whole_list_re = '

				(								# $1 = whole list

				  (								# $2

					([ ]{0,'.$less_than_tab.'})	# $3 = number of spaces

					('.$marker_re.')			# $4 = first list item marker

					[ ]+

				  )

				  (?s:.+?)

				  (								# $5

					  \z

					|

					  \n{2,}

					  (?=\S)

					  (?!						# Negative lookahead for another list item marker

						[ ]*

						'.$marker_re.'[ ]+

					  )

					|

					  (?=						# Lookahead for another kind of list

					    \n

						\3						# Must have the same indentation

						'.$other_marker_re.'[ ]+

					  )

				  )

				)

			'; // mx

			# We use a different prefix before nested lists than top-level lists.

			# See extended comment in _ProcessListItems().

			if ($this->list_level) {

				$text = preg_replace_callback('{

						^

						'.$whole_list_re.'

					}mx',

					array($this, '_doLists_callback'), $text);

			}

			else {

				$text = preg_replace_callback('{

						(?:(?<=\n)\n|\A\n?) # Must eat the newline

						'.$whole_list_re.'

					}mx',

					array($this, '_doLists_callback'), $text);

			}

		}

		return $text;

	}

	protected function _doLists_callback($matches) {

		$list_type = preg_match("/$marker_ul_re/", $matches[4]) ? "ul" : "ol";

		$marker_any_re = ( $list_type == "ul" ? $marker_ul_re : $marker_ol_re );

		$list .= "\n";

		$result = $this->processListItems($list, $marker_any_re);

		$ol_start = 1;

		if ($this->enhanced_ordered_list) {

			# Get the start number for ordered list.

			if ($list_type == 'ol') {

				$ol_start_array = array();

				$ol_start_check = preg_match("/$marker_ol_start_re/", $matches[4], $ol_start_array);

				if ($ol_start_check){

					$ol_start = $ol_start_array[0];

				}

			}

		}

		if ($ol_start > 1 && $list_type == 'ol'){

			$result = $this->hashBlock("<$list_type start=\"$ol_start\">\n" . $result . "</$list_type>");

		} else {

			$result = $this->hashBlock("<$list_type>\n" . $result . "</$list_type>");

		}

		return "\n". $result ."\n\n";

	}

	protected $list_level = 0;

	protected function processListItems($list_str, $marker_any_re) {

	#

	#	Process the contents of a single ordered or unordered list, splitting it

	#	into individual list items.

	#

		# The $this->list_level global keeps track of when we're inside a list.

		# Each time we enter a list, we increment it; when we leave a list,

		# we decrement. If it's zero, we're not in a list anymore.

		#

		# We do this because when we're not inside a list, we want to treat

		# something like this:

		#

		#		I recommend upgrading to version

		#		8. Oops, now this line is treated

		#		as a sub-list.

		#

		# As a single paragraph, despite the fact that the second line starts

		# with a digit-period-space sequence.

		#

		# Whereas when we're inside a list (or sub-list), that line will be

		# treated as the start of a sub-list. What a kludge, huh? This is

		# an aspect of Markdown's syntax that's hard to parse perfectly

		# without resorting to mind-reading. Perhaps the solution is to

		# change the syntax rules such that sub-lists must start with a

		# starting cardinal number; e.g. "1." or "a.".

		$this->list_level++;

		# trim trailing blank lines:

		$list_str = preg_replace("/\n{2,}\\z/", "\n", $list_str);

		$list_str = preg_replace_callback('{

			(\n)?							# leading line = $1

			(^[ ]*)							# leading whitespace = $2

			('.$marker_any_re.'				# list marker and space = $3

				(?:[ ]+|(?=\n))	# space only required if item is not empty

			)

			((?s:.*?))						# list item text   = $4

			(?:(\n+(?=\n))|\n)				# tailing blank line = $5

			(?= \n* (\z | \2 ('.$marker_any_re.') (?:[ ]+|(?=\n))))

			}xm',

			array($this, '_processListItems_callback'), $list_str);

		$this->list_level--;

		return $list_str;

	}

	protected function _processListItems_callback($matches) {

		$item = $matches[4];

		$leading_line =& $matches[1];