Markdown - Code Metrics - Inspection of "also support narrow nbsp" - cebe/markdown-latex - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b3baf4...febd9e )

by Carsten

created 2016-08-22 13:42 UTC

Markdown B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	326
Duplicated Lines	4.29 %

Coupling/Cohesion

Components	3
Dependencies	10

Test Coverage

Coverage

77.27%

Importance

Changes	13
Bugs	3	Features	1

Metric	Value
wmc	50
c	13
b	3
f	1
lcom	3
cbo	10
dl	14
loc	326
ccs	85
cts	110
cp	0.7727
rs	8.6206

22 Methods

Rating	Name	Duplication	Size	Complexity
A	prepare()	0	5	1
B	consumeParagraph()	0	21	8
A	renderParagraph()	0	4	1
A	renderQuote()	0	4	1
A	renderCode()	0	5	2
A	renderList()	0	11	3
A	renderHeadline()	0	10	4
A	renderHr()	0	4	1
C	renderLink()	7	23	7
A	renderImage()	7	14	3
A	parseInlineHtml()	0	13	3
A	renderLabel()	0	4	1
A	renderEmail()	0	5	1
A	renderUrl()	0	4	1
A	renderInlineCode()	0	8	2
A	renderStrong()	0	4	1
A	renderEmph()	0	4	1
A	escapeUrl()	0	4	1
A	escapeLatex()	0	7	2
A	parseEscape()	0	10	4
A	renderBackslash()	0	4	1
A	renderText()	0	11	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Markdown often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Markdown, and based on these observations, apply Extract Interface, too.

<?php
/**
 * @copyright Copyright (c) 2014 Carsten Brandt
 * @license https://github.com/cebe/markdown/blob/master/LICENSE
 * @link https://github.com/cebe/markdown#readme
 */

namespace cebe\markdown\latex;

use cebe\markdown\block\CodeTrait;
use cebe\markdown\block\HeadlineTrait;
use cebe\markdown\block\ListTrait;
use cebe\markdown\block\QuoteTrait;
use cebe\markdown\block\RuleTrait;

use cebe\markdown\inline\CodeTrait as InlineCodeTrait;
use cebe\markdown\inline\EmphStrongTrait;
use cebe\markdown\inline\LinkTrait;

use MikeVanRiel\TextToLatex;

/**
 * Markdown parser for the [initial markdown spec](http://daringfireball.net/projects/markdown/syntax).
 *
 * @author Carsten Brandt <[email protected]>
 */
class Markdown extends \cebe\markdown\Parser
{
	// include block element parsing using traits
	use CodeTrait;
	use HeadlineTrait;
	use ListTrait {
		// Check Ul List before headline
		identifyUl as protected identifyBUl;
		consumeUl as protected consumeBUl;
	}
	use QuoteTrait;
	use RuleTrait {
		// Check Hr before checking lists
		identifyHr as protected identifyAHr;
		consumeHr as protected consumeAHr;
	}

	// include inline element parsing using traits
	use InlineCodeTrait;
	use EmphStrongTrait;
	use LinkTrait;

	/**
	 * @var string this string will be prefixed to all auto generated labels.
	 * This can be used to disambiguate labels when combining multiple markdown files into one document.
	 */
	public $labelPrefix = '';

	/**
	 * @var array these are "escapeable" characters. When using one of these prefixed with a
	 * backslash, the character will be outputted without the backslash and is not interpreted
	 * as markdown.
	 */
	protected $escapeCharacters = [
		'\\', // backslash
		'`', // backtick
		'*', // asterisk
		'_', // underscore
		'{', '}', // curly braces
		'[', ']', // square brackets
		'(', ')', // parentheses
		'#', // hash mark
		'+', // plus sign
		'-', // minus sign (hyphen)
		'.', // dot
		'!', // exclamation mark
		'<', '>',
	];


	/**
	 * @inheritDoc
	 */
	protected function prepare()
	{
		// reset references
		$this->references = [];
	}

	/**
	 * Consume lines for a paragraph
	 *
	 * Allow headlines and code to break paragraphs
	 */
	protected function consumeParagraph($lines, $current)
	{
		// consume until newline
		$content = [];
		for ($i = $current, $count = count($lines); $i < $count; $i++) {
			$line = $lines[$i];
			if (!empty($line) && ltrim($line) !== '' &&
				!($line[0] === "\t" || $line[0] === " " && strncmp($line, '    ', 4) === 0) &&
				!$this->identifyHeadline($line, $lines, $i))
			{
				$content[] = $line;
			} else {
				break;
			}
		}
		$block = [
			'paragraph',
			'content' => $this->parseInline(implode("\n", $content)),
		];
		return [$block, --$i];
	}


	// rendering adjusted for LaTeX output


	/**
	 * @inheritdoc
	 */
	protected function renderParagraph($block)
	{
		return $this->renderAbsy($block['content']) . "\n\n";
	}

	/**
	 * @inheritdoc
	 */
	protected function renderQuote($block)
	{
		return '\begin{quote}' . $this->renderAbsy($block['content']) . "\\end{quote}\n";
	}

	/**
	 * @inheritdoc
	 */
	protected function renderCode($block)
	{
		$language = isset($block['language']) ? "\\lstset{language={$block['language']}}" : '\lstset{language={}}';
		return "$language\\begin{lstlisting}\n{$block['content']}\n\\end{lstlisting}\n";
	}

	/**
	 * @inheritdoc
	 */
	protected function renderList($block)
	{
		$type = ($block['list'] === 'ol') ? 'enumerate' : 'itemize';
		$output = "\\begin{{$type}}\n";

		foreach ($block['items'] as $item => $itemLines) {
			$output .= '\item ' . $this->renderAbsy($itemLines). "\n";
		}

		return "$output\\end{{$type}}\n";
	}

	/**
	 * @inheritdoc
	 */
	protected function renderHeadline($block)
	{
		$content = $this->renderAbsy($block['content']);
		switch($block['level']) {
			case 1: return "\\section{{$content}}\n";
			case 2: return "\\subsection{{$content}}\n";
			case 3: return "\\subsubsection{{$content}}\n";
			default: return "\\paragraph{{$content}}\n";
		}
	}

	/**
	 * @inheritdoc
	 */
	protected function renderHr($block)

	{
		return "\n\\noindent\\rule{\\textwidth}{0.4pt}\n";
	}

	/**
	 * @inheritdoc
	 */
	protected function renderLink($block)
	{
		if (isset($block['refkey'])) {

			if (($ref = $this->lookupReference($block['refkey'])) !== false) {
				$block = array_merge($block, $ref);
			} else {
				return $block['orig'];
			}
		}

		$url = $block['url'];
		$text = $this->renderAbsy($block['text']);
		if (strpos($url, '://') === false) {
			// consider all non absolute links as relative in the document
			// $title is ignored in this case.
			if (isset($url[0]) && $url[0] === '#') {
				$url = $this->labelPrefix . $url;
			}
			return '\hyperref['.str_replace('#', '::', $url).']{' . $text . '}';
		} else {
			return $text . '\\footnote{' . (empty($block['title']) ? '' : $this->escapeLatex($block['title']) . ': ') . '\url{' . $this->escapeUrl($url) . '}}';
		}
	}

	/**
	 * @inheritdoc
	 */
	protected function renderImage($block)
	{
		if (isset($block['refkey'])) {

			if (($ref = $this->lookupReference($block['refkey'])) !== false) {
				$block = array_merge($block, $ref);
			} else {
				return $block['orig'];
			}
		}

		// TODO create figure with caption with title
		$url = $this->escapeUrl($block['url']);
		return "\\noindent\\includegraphics[width=\\textwidth]{{$url}}";
	}

	/**
	 * Parses <a name="..."></a> tags as reference labels
	 */
	private function parseInlineHtml($text)
	{
		if (strpos($text, '>') !== false) {
			// convert a name markers to \labels
			if (preg_match('~^<((a|span)) (name|id)="(.*?)">.*?</\1>~i', $text, $matches)) {
				return [
					['label', 'name' => str_replace('#', '::', $this->labelPrefix . $matches[4])],
					strlen($matches[0])
				];
			}
		}
		return [['text', '<'], 1];
	}

	/**
	 * renders a reference label
	 */
	protected function renderLabel($block)
	{
		return "\\label{{$block['name']}}";
	}

	/**
	 * @inheritdoc
	 */
	protected function renderEmail($block)
	{
		$email = $this->escapeUrl($block[1]);
		return "\\href{mailto:{$email}}{{$email}}";
	}

	/**
	 * @inheritdoc
	 */
	protected function renderUrl($block)
	{
		return '\url{' . $this->escapeUrl($block[1]) . '}';
	}

	/**
	 * @inheritdoc
	 */
	protected function renderInlineCode($block)
	{
		if (strpos($block[1], '|') !== false) {
			return '\\lstinline`' . str_replace("\n", ' ', $block[1]) . '`'; // TODO make this more robust against code containing backticks
		} else {
			return '\\lstinline|' . str_replace("\n", ' ', $block[1]) . '|';
		}
	}

	/**
	 * @inheritdoc
	 */
	protected function renderStrong($block)
	{
		return '\textbf{' . $this->renderAbsy($block[1]) . '}';
	}

	/**
	 * @inheritdoc
	 */
	protected function renderEmph($block)
	{
		return '\textit{' . $this->renderAbsy($block[1]) . '}';
	}

	/**
	 * Parses escaped special characters.
	 * This allow a backslash to be interpreted as LaTeX
	 * @marker \
	 */
	protected function parseEscape($text)
	{
		if (isset($text[1]) && in_array($text[1], $this->escapeCharacters)) {
			if ($text[1] === '\\') {
				return [['backslash'], 2];
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
			}
			return [['text', $text[1]], 2];
		}
		return [['text', $text[0]], 1];
	}

	protected function renderBackslash()
	{
		return '\\';
	}

	private $_escaper;

	/**
	 * Escape special characters in URLs
	 */
	protected function escapeUrl($string)
	{
		return str_replace('%', '\\%', $this->escapeLatex($string));
	}

	/**
	 * Escape special LaTeX characters
	 */
	protected function escapeLatex($string)
	{
		if ($this->_escaper === null) {
			$this->_escaper = new TextToLatex();
		}
		return $this->_escaper->convert($string);
	}

	/**
	 * @inheritdocs
	 *
	 * Parses a newline indicated by two spaces on the end of a markdown line.
	 */
	protected function renderText($text)
	{
		$output = str_replace("  \n", "\\\\\n", $this->escapeLatex($text[1]));
		// support No-Break Space in LaTeX
		$output = preg_replace("/\x{00a0}/u", '~', $output);
		// support Narrow No-Break Space spaces in LaTeX
		// http://unicode-table.com/en/202F/
		// http://tex.stackexchange.com/questions/76132/how-to-typeset-a-small-non-breaking-space
		$output = preg_replace("/\x{202f}/u", '\nobreak\hspace{.16667em plus .08333em}', $output);
		return $output;
	}
}


1			<?php
2			/**
3			* @copyright Copyright (c) 2014 Carsten Brandt
4			* @license https://github.com/cebe/markdown/blob/master/LICENSE
5			* @link https://github.com/cebe/markdown#readme
6			*/
7
8			namespace cebe\markdown\latex;
9
10			use cebe\markdown\block\CodeTrait;
11			use cebe\markdown\block\HeadlineTrait;
12			use cebe\markdown\block\ListTrait;
13			use cebe\markdown\block\QuoteTrait;
14			use cebe\markdown\block\RuleTrait;
15
16			use cebe\markdown\inline\CodeTrait as InlineCodeTrait;
17			use cebe\markdown\inline\EmphStrongTrait;
18			use cebe\markdown\inline\LinkTrait;
19
20			use MikeVanRiel\TextToLatex;
21
22			/**
23			* Markdown parser for the [initial markdown spec](http://daringfireball.net/projects/markdown/syntax).
24			*
25			* @author Carsten Brandt <[email protected]>
26			*/
27			class Markdown extends \cebe\markdown\Parser
28			{
29			// include block element parsing using traits
30			use CodeTrait;
31			use HeadlineTrait;
32			use ListTrait {
33			// Check Ul List before headline
34			identifyUl as protected identifyBUl;
35			consumeUl as protected consumeBUl;
36			}
37			use QuoteTrait;
38			use RuleTrait {
39			// Check Hr before checking lists
40			identifyHr as protected identifyAHr;
41			consumeHr as protected consumeAHr;
42			}
43
44			// include inline element parsing using traits
45			use InlineCodeTrait;
46			use EmphStrongTrait;
47			use LinkTrait;
48
49			/**
50			* @var string this string will be prefixed to all auto generated labels.
51			* This can be used to disambiguate labels when combining multiple markdown files into one document.
52			*/
53			public $labelPrefix = '';
54
55			/**
56			* @var array these are "escapeable" characters. When using one of these prefixed with a
57			* backslash, the character will be outputted without the backslash and is not interpreted
58			* as markdown.
59			*/
60			protected $escapeCharacters = [
61			'\\', // backslash
62			'`', // backtick
63			'*', // asterisk
64			'_', // underscore
65			'{', '}', // curly braces
66			'[', ']', // square brackets
67			'(', ')', // parentheses
68			'#', // hash mark
69			'+', // plus sign
70			'-', // minus sign (hyphen)
71			'.', // dot
72			'!', // exclamation mark
73			'<', '>',
74			];
75
76
77			/**
78			* @inheritDoc
79			*/
80	21		protected function prepare()
81			{
82			// reset references
83	21		$this->references = [];
84	21		}
85
86			/**
87			* Consume lines for a paragraph
88			*
89			* Allow headlines and code to break paragraphs
90			*/
91	7		protected function consumeParagraph($lines, $current)
92			{
93			// consume until newline
94	7		$content = [];
95	7		for ($i = $current, $count = count($lines); $i < $count; $i++) {
96	7		$line = $lines[$i];
97	7		if (!empty($line) && ltrim($line) !== '' &&
98	7		!($line[0] === "\t" \|\| $line[0] === " " && strncmp($line, ' ', 4) === 0) &&
99	7		!$this->identifyHeadline($line, $lines, $i))
100	7		{
101	7		$content[] = $line;
102	7		} else {
103	6		break;
104			}
105	7		}
106			$block = [
107	7		'paragraph',
108	7		'content' => $this->parseInline(implode("\n", $content)),
109	7		];
110	7		return [$block, --$i];
111			}
112
113
114			// rendering adjusted for LaTeX output
115
116
117			/**
118			* @inheritdoc
119			*/
120	19		protected function renderParagraph($block)
121			{
122	19		return $this->renderAbsy($block['content']) . "\n\n";
123			}
124
125			/**
126			* @inheritdoc
127			*/
128	2		protected function renderQuote($block)
129			{
130	2		return '\begin{quote}' . $this->renderAbsy($block['content']) . "\\end{quote}\n";
131			}
132
133			/**
134			* @inheritdoc
135			*/
136	3		protected function renderCode($block)
137			{
138	3		$language = isset($block['language']) ? "\\lstset{language={$block['language']}}" : '\lstset{language={}}';
139	3		return "$language\\begin{lstlisting}\n{$block['content']}\n\\end{lstlisting}\n";
140			}
141
142			/**
143			* @inheritdoc
144			*/
145	2		protected function renderList($block)
146			{
147	2		$type = ($block['list'] === 'ol') ? 'enumerate' : 'itemize';
148	2		$output = "\\begin{{$type}}\n";
149
150	2		foreach ($block['items'] as $item => $itemLines) {
151	2		$output .= '\item ' . $this->renderAbsy($itemLines). "\n";
152	2		}
153
154	2		return "$output\\end{{$type}}\n";
155			}
156
157			/**
158			* @inheritdoc
159			*/
160	3		protected function renderHeadline($block)
161			{
162	3		$content = $this->renderAbsy($block['content']);
163	3		switch($block['level']) {
164	3		case 1: return "\\section{{$content}}\n";
165	3		case 2: return "\\subsection{{$content}}\n";
166	2		case 3: return "\\subsubsection{{$content}}\n";
167	2		default: return "\\paragraph{{$content}}\n";
168	2		}
169			}
170
171			/**
172			* @inheritdoc
173			*/
174	2		protected function renderHr($block)
			0 ignored issues – show Unused Code introduced 2016-08-22 12:56 UTC by Report Bug Copy Issue Report The parameter `$block` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
175			{
176	2		return "\n\\noindent\\rule{\\textwidth}{0.4pt}\n";
177			}
178
179			/**
180			* @inheritdoc
181			*/
182	2		protected function renderLink($block)
183			{
184	2	View Code Duplication	if (isset($block['refkey'])) {
			0 ignored issues – show Duplication introduced 2016-08-22 12:56 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
185			if (($ref = $this->lookupReference($block['refkey'])) !== false) {
186			$block = array_merge($block, $ref);
187			} else {
188			return $block['orig'];
189			}
190			}
191
192	2		$url = $block['url'];
193	2		$text = $this->renderAbsy($block['text']);
194	2		if (strpos($url, '://') === false) {
195			// consider all non absolute links as relative in the document
196			// $title is ignored in this case.
197			if (isset($url[0]) && $url[0] === '#') {
198			$url = $this->labelPrefix . $url;
199			}
200			return '\hyperref['.str_replace('#', '::', $url).']{' . $text . '}';
201			} else {
202	2		return $text . '\\footnote{' . (empty($block['title']) ? '' : $this->escapeLatex($block['title']) . ': ') . '\url{' . $this->escapeUrl($url) . '}}';
203			}
204			}
205
206			/**
207			* @inheritdoc
208			*/
209			protected function renderImage($block)
210			{
211		View Code Duplication	if (isset($block['refkey'])) {
			0 ignored issues – show Duplication introduced 2016-08-22 12:56 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
212			if (($ref = $this->lookupReference($block['refkey'])) !== false) {
213			$block = array_merge($block, $ref);
214			} else {
215			return $block['orig'];
216			}
217			}
218
219			// TODO create figure with caption with title
220			$url = $this->escapeUrl($block['url']);
221			return "\\noindent\\includegraphics[width=\\textwidth]{{$url}}";
222			}
223
224			/**
225			* Parses <a name="..."></a> tags as reference labels
226			*/
227	2		private function parseInlineHtml($text)
228			{
229	2		if (strpos($text, '>') !== false) {
230			// convert a name markers to \labels
231	2		if (preg_match('~^<((a\|span)) (name\|id)="(.?)">.?</\1>~i', $text, $matches)) {
232			return [
233	2		['label', 'name' => str_replace('#', '::', $this->labelPrefix . $matches[4])],
234	2		strlen($matches[0])
235	2		];
236			}
237			}
238			return [['text', '<'], 1];
239			}
240
241			/**
242			* renders a reference label
243			*/
244	2		protected function renderLabel($block)
245			{
246	2		return "\\label{{$block['name']}}";
247			}
248
249			/**
250			* @inheritdoc
251			*/
252	2		protected function renderEmail($block)
253			{
254	2		$email = $this->escapeUrl($block[1]);
255	2		return "\\href{mailto:{$email}}{{$email}}";
256			}
257
258			/**
259			* @inheritdoc
260			*/
261	2		protected function renderUrl($block)
262			{
263	2		return '\url{' . $this->escapeUrl($block[1]) . '}';
264			}
265
266			/**
267			* @inheritdoc
268			*/
269	1		protected function renderInlineCode($block)
270			{
271	1		if (strpos($block[1], '\|') !== false) {
272	1		return '\\lstinline`' . str_replace("\n", ' ', $block[1]) . '`'; // TODO make this more robust against code containing backticks
273			} else {
274			return '\\lstinline\|' . str_replace("\n", ' ', $block[1]) . '\|';
275			}
276			}
277
278			/**
279			* @inheritdoc
280			*/
281	1		protected function renderStrong($block)
282			{
283	1		return '\textbf{' . $this->renderAbsy($block[1]) . '}';
284			}
285
286			/**
287			* @inheritdoc
288			*/
289	1		protected function renderEmph($block)
290			{
291	1		return '\textit{' . $this->renderAbsy($block[1]) . '}';
292			}
293
294			/**
295			* Parses escaped special characters.
296			* This allow a backslash to be interpreted as LaTeX
297			* @marker \
298			*/
299	1		protected function parseEscape($text)
300			{
301	1		if (isset($text[1]) && in_array($text[1], $this->escapeCharacters)) {
302	1		if ($text[1] === '\\') {
303			return [['backslash'], 2];
			0 ignored issues – show Best Practice introduced 2016-08-22 12:56 UTC by Report Bug Copy Issue Report The expression `return array(array('backslash'), 2);` seems to be an `array`, but some of its elements' types (`string[]`) are incompatible with the return type of the parent method `cebe\markdown\Parser::parseEscape` of type `array<array\|integer>`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return new Author('Johannes'); } } class BlogPost extends Post { public function getAuthor() { return 'Johannes'; } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
304			}
305	1		return [['text', $text[1]], 2];
306			}
307			return [['text', $text[0]], 1];
308			}
309
310			protected function renderBackslash()
311			{
312			return '\\';
313			}
314
315			private $_escaper;
316
317			/**
318			* Escape special characters in URLs
319			*/
320	4		protected function escapeUrl($string)
321			{
322	4		return str_replace('%', '\\%', $this->escapeLatex($string));
323			}
324
325			/**
326			* Escape special LaTeX characters
327			*/
328	19		protected function escapeLatex($string)
329			{
330	19		if ($this->_escaper === null) {
331	19		$this->_escaper = new TextToLatex();
332	19		}
333	19		return $this->_escaper->convert($string);
334			}
335
336			/**
337			* @inheritdocs
338			*
339			* Parses a newline indicated by two spaces on the end of a markdown line.
340			*/
341	19		protected function renderText($text)
342			{
343	19		$output = str_replace(" \n", "\\\\\n", $this->escapeLatex($text[1]));
344			// support No-Break Space in LaTeX
345	19		$output = preg_replace("/\x{00a0}/u", '~', $output);
346			// support Narrow No-Break Space spaces in LaTeX
347			// http://unicode-table.com/en/202F/
348			// http://tex.stackexchange.com/questions/76132/how-to-typeset-a-small-non-breaking-space
349	19		$output = preg_replace("/\x{202f}/u", '\nobreak\hspace{.16667em plus .08333em}', $output);
350	19		return $output;
351			}
352			}
353

cebe / markdown-latex