GitHub Flavored Markdown, often shortened as GFM, is the dialect of Markdownthat is currently supported for user content on GitHub.com and GitHubEnterprise.
This formal specification, based on the CommonMark Spec, defines the syntax andsemantics of this dialect.
GFM is a strict superset of CommonMark. All the features which are supported inGitHub user content and that are not specified on the original CommonMark Specare hence known asextensions, and highlighted as such.
While GFM supports a wide range of inputs, it’s worth noting that GitHub.comand GitHub Enterprise perform additional post-processing and sanitization afterGFM is converted to HTML to ensure security and consistency of the website.
Markdown is a plain text format for writing structured documents,based on conventions for indicating formatting in emailand usenet posts. It was developed by John Gruber (withhelp from Aaron Swartz) and released in 2004 in the form of asyntax descriptionand a Perl script (Markdown.pl) for converting Markdown toHTML. In the next decade, dozens of implementations weredeveloped in many languages. Some extended the originalMarkdown syntax with conventions for footnotes, tables, andother document elements. Some allowed Markdown documents to berendered in formats other than HTML. Websites like Reddit,StackOverflow, and GitHub had millions of people using Markdown.And Markdown started to be used beyond the web, to author books,articles, slide shows, letters, and lecture notes.
What distinguishes Markdown from many other lightweight markupsyntaxes, which are often easier to write, is its readability.As Gruber writes:
The overriding design goal for Markdown’s formatting syntax isto make it as readable as possible. The idea is that aMarkdown-formatted document should be publishable as-is, asplain text, without looking like it’s been marked up with tagsor formatting instructions.(http://daringfireball.net/projects/markdown/)
The point can be illustrated by comparing a sample ofAsciiDoc withan equivalent sample of Markdown. Here is a sample ofAsciiDoc from the AsciiDoc manual:
1. List item one.+List item one continued with a second paragraph followed by anIndented block.+.................$ ls *.sh$ mv *.sh ~/tmp.................+List item continued with a third paragraph.2. List item two continued with an open block.+--This paragraph is part of the preceding list item.a. This list is nested and does not require explicit itemcontinuation.+This paragraph is part of the preceding list item.b. List item b.This paragraph belongs to item two of the outer list.--And here is the equivalent in Markdown:
1. List item one. List item one continued with a second paragraph followed by an Indented block. $ ls *.sh $ mv *.sh ~/tmp List item continued with a third paragraph.2. List item two continued with an open block. This paragraph is part of the preceding list item. 1. This list is nested and does not require explicit item continuation. This paragraph is part of the preceding list item. 2. List item b. This paragraph belongs to item two of the outer list.The AsciiDoc version is, arguably, easier to write. You don’t needto worry about indentation. But the Markdown version is much easierto read. The nesting of list items is apparent to the eye in thesource, not just in the processed document.
John Gruber’scanonical description of Markdown’ssyntaxdoes not specify the syntax unambiguously. Here are some examples ofquestions it does not answer:
How much indentation is needed for a sublist? The spec says thatcontinuation paragraphs need to be indented four spaces, but isnot fully explicit about sublists. It is natural to think thatthey, too, must be indented four spaces, butMarkdown.pl doesnot require that. This is hardly a “corner case,” and divergencesbetween implementations on this issue often lead to surprises forusers in real documents. (Seethis comment by JohnGruber.)
Is a blank line needed before a block quote or heading?Most implementations do not require the blank line. However,this can lead to unexpected results in hard-wrapped text, andalso to ambiguities in parsing (note that some implementationsput the heading inside the blockquote, while others do not).(John Gruber has also spokenin favor of requiring the blanklines.)
Is a blank line needed before an indented code block?(Markdown.pl requires it, but this is not mentioned in thedocumentation, and some implementations do not require it.)
paragraph code?What is the exact rule for determining when list items getwrapped in<p> tags? Can a list be partially “loose” and partially“tight”? What should we do with a list like this?
1. one2. two3. threeOr this?
1. one - a - b2. two(There are some relevant comments by John Gruberhere.)
Can list markers be indented? Can ordered list markers be right-aligned?
8. item 1 9. item 210. item 2aIs this one list with a thematic break in its second item,or two lists separated by a thematic break?
* a* * * * ** bWhen list markers change from numbers to bullets, do we havetwo lists or one? (The Markdown syntax description suggests two,but the perl scripts and many other implementations produce one.)
1. fee2. fie- foe- fumWhat are the precedence rules for the markers of inline structure?For example, is the following a valid link, or does the code spantake precedence ?
[a backtick (`)](/url) and [another backtick (`)](/url).What are the precedence rules for markers of emphasis and strongemphasis? For example, how should the following be parsed?
*foo *bar* baz*What are the precedence rules between block-level and inline-levelstructure? For example, how should the following be parsed?
- `a long code span can contain a hyphen like this - and it can screw things up`Can list items include section headings? (Markdown.pl does notallow this, but does allow blockquotes to include headings.)
- # HeadingCan list items be empty?
* a** bCan link references be defined inside block quotes or list items?
> Blockquote [foo].>> [foo]: /urlIf there are multiple definitions for the same reference, which takesprecedence?
[foo]: /url1[foo]: /url2[foo][]In the absence of a spec, early implementers consultedMarkdown.plto resolve these ambiguities. ButMarkdown.pl was quite buggy, andgave manifestly bad results in many cases, so it was not asatisfactory replacement for a spec.
Because there is no unambiguous spec, implementations have divergedconsiderably. As a result, users are often surprised to find thata document that renders one way on one system (say, a GitHub wiki)renders differently on another (say, converting to docbook usingpandoc). To make matters worse, because nothing in Markdown countsas a “syntax error,” the divergence often isn’t discovered right away.
This document attempts to specify Markdown syntax unambiguously.It contains many examples with side-by-side Markdown andHTML. These are intended to double as conformance tests. Anaccompanying scriptspec_tests.py can be used to run the testsagainst any Markdown program:
python test/spec_tests.py --spec spec.txt --program PROGRAMSince this document describes how Markdown is to be parsed intoan abstract syntax tree, it would have made sense to use an abstractrepresentation of the syntax tree instead of HTML. But HTML is capableof representing the structural distinctions we need to make, and thechoice of HTML for the tests makes it possible to run the tests againstan implementation without writing an abstract syntax tree renderer.
This document is generated from a text file,spec.txt, writtenin Markdown with a small extension for the side-by-side tests.The scripttools/makespec.py can be used to convertspec.txt intoHTML or CommonMark (which can then be converted into other formats).
In the examples, the→ character is used to represent tabs.
Any sequence ofcharacters is a valid CommonMarkdocument.
Acharacter is a Unicode code point. Although somecode points (for example, combining accents) do not correspond tocharacters in an intuitive sense, all code points count as charactersfor purposes of this spec.
This spec does not specify an encoding; it thinks of lines as composedofcharacters rather than bytes. A conforming parser may be limitedto a certain encoding.
Aline is a sequence of zero or morecharactersother than newline (U+000A) or carriage return (U+000D),followed by aline ending or by the end of file.
Aline ending is a newline (U+000A), a carriage return(U+000D) not followed by a newline, or a carriage return and afollowing newline.
A line containing no characters, or a line containing only spaces(U+0020) or tabs (U+0009), is called ablank line.
The following definitions of character classes will be used in this spec:
Awhitespace character is a space(U+0020), tab (U+0009), newline (U+000A), line tabulation (U+000B),form feed (U+000C), or carriage return (U+000D).
Whitespace is a sequence of one or morewhitespacecharacters.
AUnicode whitespace character isany code point in the UnicodeZs general category, or a tab (U+0009),carriage return (U+000D), newline (U+000A), or form feed(U+000C).
Unicode whitespace is a sequence of oneor moreUnicode whitespace characters.
Aspace isU+0020.
Anon-whitespace character is any characterthat is not awhitespace character.
AnASCII punctuation characteris!,",#,$,%,&,',(,),*,+,,,-,.,/ (U+0021–2F),:,;,<,=,>,?,@ (U+003A–0040),[,\,],^,_,` (U+005B–0060),{,|,}, or~ (U+007B–007E).
Apunctuation character is anASCIIpunctuation character or anything inthe general Unicode categoriesPc,Pd,Pe,Pf,Pi,Po, orPs.
Tabs in lines are not expanded tospaces. However,in contexts where whitespace helps to define block structure,tabs behave as if they were replaced by spaces with a tab stopof 4 characters.
Thus, for example, a tab can be used instead of four spacesin an indented code block. (Note, however, that internaltabs are passed through as literal tabs, not expanded tospaces.)
In the following example, a continuation paragraph of a listitem is indented with a tab; this has exactly the same effectas indentation with four spaces would:
Normally the> that begins a block quote may be followedoptionally by a space, which is not considered part of thecontent. In the following case> is followed by a tab,which is treated as if it were expanded into three spaces.Since one of these spaces is considered part of thedelimiter,foo is considered to be indented six spacesinside the block quote context, so we get an indentedcode block starting with two spaces.
For security reasons, the Unicode characterU+0000 must be replacedwith the REPLACEMENT CHARACTER (U+FFFD).
We can think of a document as a sequence ofblocks—structural elements like paragraphs, blockquotations, lists, headings, rules, and code blocks. Some blocks (likeblock quotes and list items) contain other blocks; others (likeheadings and paragraphs) containinline content—text,links, emphasized text, images, code spans, and so on.
Indicators of block structure always take precedence over indicatorsof inline structure. So, for example, the following is a list withtwo items, not a list with one item containing a code span:
This means that parsing can proceed in two steps: first, the blockstructure of the document can be discerned; second, text lines insideparagraphs, headings, and other block constructs can be parsed for inlinestructure. The second step requires information about link referencedefinitions that will be available only at the end of the firststep. Note that the first step requires processing lines in sequence,but the second can be parallelized, since the inline parsing ofone block element does not affect the inline parsing of any other.
We can divide blocks into two types:container blocks,which can contain other blocks, andleaf blocks,which cannot.
This section describes the different kinds of leaf block that make up aMarkdown document.
A line consisting of 0-3 spaces of indentation, followed by a sequenceof three or more matching-,_, or* characters, each followedoptionally by any number of spaces or tabs, forms athematic break.
Wrong characters:
Not enough characters:
One to three spaces indent are allowed:
Four spaces is too many:
More than three characters may be used:
Spaces are allowed between the characters:
Spaces are allowed at the end:
However, no other characters may occur in the line:
It is required that all of thenon-whitespace characters be the same.So, this is not a thematic break:
Thematic breaks do not need blank lines before or after:
Thematic breaks can interrupt a paragraph:
If a line of dashes that meets the above conditions for being athematic break could also be interpreted as the underline of asetextheading, the interpretation as asetext heading takes precedence. Thus, for example,this is a setext heading, not a paragraph followed by a thematic break:
When both a thematic break and a list item are possibleinterpretations of a line, the thematic break takes precedence:
If you want a thematic break in a list item, use a different bullet:
AnATX headingconsists of a string of characters, parsed as inline content, between anopening sequence of 1–6 unescaped# characters and an optionalclosing sequence of any number of unescaped# characters.The opening sequence of# characters must be followed by aspace or by the end of line. The optional closing sequence of#s must bepreceded by aspace and may be followed by spaces only. The opening# character may be indented 0-3 spaces. The raw contents of theheading are stripped of leading and trailing spaces before being parsedas inline content. The heading level is equal to the number of#characters in the opening sequence.
Simple headings:
#foo##foo###foo####foo#####foo######foo<h1>foo</h1><h2>foo</h2><h3>foo</h3><h4>foo</h4><h5>foo</h5><h6>foo</h6>More than six# characters is not a heading:
At least one space is required between the# characters and theheading’s contents, unless the heading is empty. Note that manyimplementations currently do not require the space. However, thespace was required by theoriginal ATX implementation,and it helps prevent things like the following from being parsed asheadings:
This is not a heading, because the first# is escaped:
Contents are parsed as inlines:
Leading and trailingwhitespace is ignored in parsing inline content:
One to three spaces indentation are allowed:
Four spaces are too much:
A closing sequence of# characters is optional:
It need not be the same length as the opening sequence:
Spaces are allowed after the closing sequence:
A sequence of# characters with anything butspaces following itis not a closing sequence, but counts as part of the contents of theheading:
The closing sequence must be preceded by a space:
Backslash-escaped# characters do not count as partof the closing sequence:
ATX headings need not be separated from surrounding content by blanklines, and they can interrupt paragraphs:
ATX headings can be empty:
Asetext heading consists of one or morelines of text, each containing at least onenon-whitespacecharacter, with no more than 3 spaces indentation, followed byasetext heading underline. The lines of text must be suchthat, were they not followed by the setext heading underline,they would be interpreted as a paragraph: they cannot beinterpretable as acode fence,ATX heading,block quote,thematic break,list item, orHTML block.
Asetext heading underline is a sequence of= characters or a sequence of- characters, with no more than 3spaces indentation and any number of trailing spaces. If a linecontaining a single- can be interpreted as anemptylist items, it should be interpreted this wayand not as asetext heading underline.
The heading is a level 1 heading if= characters are used inthesetext heading underline, and a level 2 heading if-characters are used. The contents of the heading are the resultof parsing the preceding lines of text as CommonMark inlinecontent.
In general, a setext heading need not be preceded or followed by ablank line. However, it cannot interrupt a paragraph, so when asetext heading comes after a paragraph, a blank line is needed betweenthem.
Simple examples:
The content of the header may span more than one line:
The contents are the result of parsing the headings’s rawcontent as inlines. The heading’s raw content is formed byconcatenating the lines and removing initial and finalwhitespace.
The underlining can be any length:
The heading content can be indented up to three spaces, and neednot line up with the underlining:
Four spaces indent is too much:
The setext heading underline can be indented up to three spaces, andmay have trailing spaces:
Four spaces is too much:
The setext heading underline cannot contain internal spaces:
Trailing spaces in the content line do not cause a line break:
Nor does a backslash at the end:
Since indicators of block structure take precedence overindicators of inline structure, the following are setext headings:
`Foo----`<atitle="alot---ofdashes"/><h2>`Foo</h2><p>`</p><h2><atitle="alot</h2><p>ofdashes"/></p>The setext heading underline cannot be alazy continuationline in a list item or block quote:
A blank line is needed between a paragraph and a followingsetext heading, since otherwise the paragraph becomes partof the heading’s content:
But in general a blank line is not required before or aftersetext headings:
Setext headings cannot be empty:
Setext heading text lines must not be interpretable as blockconstructs other than paragraphs. So, the line of dashesin these examples gets interpreted as a thematic break:
If you want a heading with> foo as its literal text, you canuse backslash escapes:
Compatibility note: Most existing Markdown implementationsdo not allow the text of setext headings to span multiple lines.But there is no consensus about how to interpret
Foobar---bazOne can find four different interpretations:
We find interpretation 4 most natural, and interpretation 4increases the expressive power of CommonMark, by allowingmultiline headings. Authors who want interpretation 1 canput a blank line after the first paragraph:
Authors who want interpretation 2 can put blank lines aroundthe thematic break,
or use a thematic break that cannot count as asetext headingunderline, such as
Authors who want interpretation 3 can use backslash escapes:
Anindented code block is composed of one or moreindented chunks separated by blank lines.Anindented chunk is a sequence of non-blank lines,each indented four or more spaces. The contents of the code block arethe literal contents of the lines, including trailingline endings, minus four spaces of indentation.An indented code block has noinfo string.
An indented code block cannot interrupt a paragraph, so there must bea blank line between a paragraph and a following indented code block.(A blank line is not needed, however, between a code block and a followingparagraph.)
If there is any ambiguity between an interpretation of indentationas a code block and as indicating that material belongs to alistitem, the list item interpretation takes precedence:
The contents of a code block are literal text, and do not get parsedas Markdown:
Here we have three chunks separated by blank lines:
Any initial spaces beyond four will be included in the content, evenin interior blank lines:
An indented code block cannot interrupt a paragraph. (Thisallows hanging indents and the like.)
However, any non-blank line with fewer than four leading spaces endsthe code block immediately. So a paragraph may occur immediatelyafter indented code:
And indented code can occur immediately before and after other kinds ofblocks:
#HeadingfooHeading------foo----<h1>Heading</h1><pre><code>foo</code></pre><h2>Heading</h2><pre><code>foo</code></pre><hr/>The first line can be indented more than four spaces:
Blank lines preceding or following an indented code blockare not included in it:
Trailing spaces are included in the code block’s content:
Acode fence is a sequenceof at least three consecutive backtick characters (`) ortildes (~). (Tildes and backticks cannot be mixed.)Afenced code blockbegins with a code fence, indented no more than three spaces.
The line with the opening code fence may optionally contain some textfollowing the code fence; this is trimmed of leading and trailingwhitespace and called theinfo string. If theinfo string comesafter a backtick fence, it may not contain any backtickcharacters. (The reason for this restriction is that otherwisesome inline code would be incorrectly interpreted as thebeginning of a fenced code block.)
The content of the code block consists of all subsequent lines, untila closingcode fence of the same type as the code blockbegan with (backticks or tildes), and with at least as many backticksor tildes as the opening code fence. If the leading code fence isindented N spaces, then up to N spaces of indentation are removed fromeach line of the content (if present). (If a content line is notindented, it is preserved unchanged. If it is indented less than Nspaces, all of the indentation is removed.)
The closing code fence may be indented up to three spaces, and may befollowed only by spaces, which are ignored. If the end of thecontaining block (or document) is reached and no closing code fencehas been found, the code block contains all of the lines after theopening code fence until the end of the containing block (ordocument). (An alternative spec would require backtracking in theevent that a closing code fence is not found. But this makes parsingmuch less efficient, and there seems to be no real down side to thebehavior described here.)
A fenced code block may interrupt a paragraph, and does not requirea blank line either before or after.
The content of a code fence is treated as literal text, not parsedas inlines. The first word of theinfo string is typically used tospecify the language of the code sample, and rendered in theclassattribute of thecode tag. However, this spec does not mandate anyparticular treatment of theinfo string.
Here is a simple example with backticks:
With tildes:
Fewer than three backticks is not enough:
The closing code fence must use the same character as the openingfence:
The closing code fence must be at least as long as the opening fence:
Unclosed code blocks are closed by the end of the document(or the enclosingblock quote orlist item):
A code block can have all empty lines as its content:
A code block can be empty:
Fences can be indented. If the opening fence is indented,content lines will have equivalent opening indentation removed,if present:
Four spaces indentation produces an indented code block:
Closing fences may be indented by 0-3 spaces, and their indentationneed not match that of the opening fence:
This is not a closing fence, because it is indented 4 spaces:
Code fences (opening and closing) cannot contain internal spaces:
Fenced code blocks can interrupt paragraphs, and can be followeddirectly by paragraphs, without a blank line between:
Other blocks can also occur before and after fenced code blockswithout an intervening blank line:
Aninfo string can be provided after the opening code fence.Although this spec doesn’t mandate any particular treatment ofthe info string, the first word is typically used to specifythe language of the code block. In HTML output, the language isnormally indicated by adding a class to thecode element consistingoflanguage- followed by the language name.
```rubydeffoo(x)return3end```<pre><codeclass="language-ruby">deffoo(x)return3end</code></pre>~~~~rubystartline=3$%@#$deffoo(x)return3end~~~~~~~<pre><codeclass="language-ruby">deffoo(x)return3end</code></pre>Info strings for backtick code blocks cannot contain backticks:
Info strings for tilde code blocks can contain backticks and tildes:
Closing code fences cannot haveinfo strings:
AnHTML block is a group of lines that is treatedas raw HTML (and will not be escaped in HTML output).
There are seven kinds ofHTML block, which can be defined by theirstart and end conditions. The block begins with a line that meets astart condition (after up to three spaces optional indentation).It ends with the first subsequent line that meets a matchingendcondition, or the last line of the document, or the last line ofthecontainer block containing the current HTMLblock, if no line is encountered that meets theend condition. Ifthe first line meets both thestart condition and theendcondition, the block will contain just that line.
Start condition: line begins with the string<script,<pre, or<style (case-insensitive), followed by whitespace,the string>, or the end of the line.
End condition: line contains an end tag</script>,</pre>, or</style> (case-insensitive; itneed not match the start tag).
Start condition: line begins with the string<!--.
End condition: line contains the string-->.
Start condition: line begins with the string<?.
End condition: line contains the string?>.
Start condition: line begins with the string<!followed by an uppercase ASCII letter.
End condition: line contains the character>.
Start condition: line begins with the string<![CDATA[.
End condition: line contains the string]]>.
Start condition: line begins the string< or</followed by one of the strings (case-insensitive)address,article,aside,base,basefont,blockquote,body,caption,center,col,colgroup,dd,details,dialog,dir,div,dl,dt,fieldset,figcaption,figure,footer,form,frame,frameset,h1,h2,h3,h4,h5,h6,head,header,hr,html,iframe,legend,li,link,main,menu,menuitem,nav,noframes,ol,optgroup,option,p,param,section,source,summary,table,tbody,td,tfoot,th,thead,title,tr,track,ul, followedbywhitespace, the end of the line, the string>, orthe string/>.
End condition: line is followed by ablank line.
Start condition: line begins with a completeopen tag(with anytag name other thanscript,style, orpre) or a completeclosing tag,followed only bywhitespace or the end of the line.
End condition: line is followed by ablank line.
HTML blocks continue until they are closed by their appropriateend condition, or the last line of the document or othercontainerblock. This means any HTMLwithin an HTMLblock that might otherwise be recognised as a start condition willbe ignored by the parser and passed through as-is, without changingthe parser’s state.
For instance,<pre> within a HTML block started by<table> will not affectthe parser state; as the HTML block was started in by start condition 6, itwill end at any blank line. This can be surprising:
<table><tr><td><pre>**Hello**,_world_.</pre></td></tr></table><table><tr><td><pre>**Hello**,<p><em>world</em>.</pre></p></td></tr></table>In this case, the HTML block is terminated by the newline — the**Hello**text remains verbatim — and regular parsing resumes, with a paragraph,emphasisedworld and inline and block HTML following.
All types ofHTML blocks except type 7 may interrupta paragraph. Blocks of type 7 may not interrupt a paragraph.(This restriction is intended to prevent unwanted interpretationof long tags inside a wrapped paragraph as starting HTML blocks.)
Some simple examples follow. Here are some basic HTML blocksof type 6:
A block can also start with a closing tag:
Here we have two HTML blocks with a Markdown paragraph between them:
The tag on the first line can be partial, as longas it is split where there would be whitespace:
An open tag need not be closed:
A partial tag need not even be completed (garbagein, garbage out):
The initial tag doesn’t even need to be a validtag, as long as it starts like one:
In type 6 blocks, the initial tag need not be on a line byitself:
Everything until the next blank line or end of documentgets included in the HTML block. So, in the followingexample, what looks like a Markdown code blockis actually part of the HTML block, which continues until a blankline or the end of the document is reached:
To start anHTML block with a tag that isnot in thelist of block-level tags in (6), you must put the tag byitself on the first line (and it must be complete):
In type 7 blocks, thetag name can be anything:
These rules are designed to allow us to work with tags thatcan function as either block-level or inline-level tags.The<del> tag is a nice example. We can surround content with<del> tags in three different ways. In this case, we get a rawHTML block, because the<del> tag is on a line by itself:
In this case, we get a raw HTML block that just includesthe<del> tag (because it ends with the following blankline). So the contents get interpreted as CommonMark:
Finally, in this case, the<del> tags are interpretedasraw HTMLinside the CommonMark paragraph. (Becausethe tag is not on a line by itself, we get inline HTMLrather than anHTML block.)
HTML tags designed to contain literal content(script,style,pre), comments, processing instructions,and declarations are treated somewhat differently.Instead of ending at the first blank line, these blocksend at the first line containing a corresponding end tag.As a result, these blocks can contain blank lines:
A pre tag (type 1):
<prelanguage="haskell"><code>importText.HTML.TagSoupmain::IO()main=print$parseTagstags</code></pre>okay<prelanguage="haskell"><code>importText.HTML.TagSoupmain::IO()main=print$parseTagstags</code></pre><p>okay</p>A script tag (type 1):
<scripttype="text/javascript">//JavaScriptexampledocument.getElementById("demo").innerHTML="HelloJavaScript!";</script>okay<scripttype="text/javascript">//JavaScriptexampledocument.getElementById("demo").innerHTML="HelloJavaScript!";</script><p>okay</p>A style tag (type 1):
<styletype="text/css">h1{color:red;}p{color:blue;}</style>okay<styletype="text/css">h1{color:red;}p{color:blue;}</style><p>okay</p>If there is no matching end tag, the block will end at theend of the document (or the enclosingblock quoteorlist item):
The end tag can occur on the same line as the start tag:
Note that anything on the last line after theend tag will be included in theHTML block:
A comment (type 2):
A processing instruction (type 3):
A declaration (type 4):
CDATA (type 5):
<![CDATA[functionmatchwo(a,b){if(a<b&&a<0)then{return1;}else{return0;}}]]>okay<![CDATA[functionmatchwo(a,b){if(a<b&&a<0)then{return1;}else{return0;}}]]><p>okay</p>The opening tag can be indented 1-3 spaces, but not 4:
An HTML block of types 1–6 can interrupt a paragraph, and need not bepreceded by a blank line.
However, a following blank line is needed, except at the end ofa document, and except for blocks of types 1–5,above:
HTML blocks of type 7 cannot interrupt a paragraph:
This rule differs from John Gruber’s original Markdown syntaxspecification, which says:
The only restrictions are that block-level HTML elements —e.g.
<div>,<table>,<pre>,<p>, etc. — must be separated fromsurrounding content by blank lines, and the start and end tags of theblock should not be indented with tabs or spaces.
In some ways Gruber’s rule is more restrictive than the one givenhere:
Most Markdown implementations (including some of Gruber’s own) do notrespect all of these restrictions.
There is one respect, however, in which Gruber’s rule is more liberalthan the one given here, since it allows blank lines to occur insidean HTML block. There are two reasons for disallowing them here.First, it removes the need to parse balanced tags, which isexpensive and can require backtracking from the end of the documentif no matching end tag is found. Second, it provides a very simpleand flexible way of including Markdown content inside HTML tags:simply separate the Markdown from the HTML using blank lines:
Compare:
Some Markdown implementations have adopted a convention ofinterpreting content inside tags as text if the open tag hasthe attributemarkdown=1. The rule given above seems a simpler andmore elegant way of achieving the same expressive power, which is alsomuch simpler to parse.
The main potential drawback is that one can no longer paste HTMLblocks into Markdown documents with 100% reliability. However,in most cases this will work fine, because the blank lines inHTML are usually followed by HTML block tags. For example:
There are problems, however, if the inner tags are indentedand separated by spaces, as then they will be interpreted asan indented code block:
<table><tr><td>Hi</td></tr></table><table><tr><pre><code><td>Hi</td></code></pre></tr></table>Fortunately, blank lines are usually not necessary and can bedeleted. The exception is inside<pre> tags, but as describedabove, raw HTML blocks starting with<pre>can contain blank lines.
Alink reference definitionconsists of alink label, indented up to three spaces, followedby a colon (:), optionalwhitespace (including up to oneline ending), alink destination,optionalwhitespace (including up to oneline ending), and an optionallinktitle, which if it is present must be separatedfrom thelink destination bywhitespace.No furthernon-whitespace characters may occur on the line.
Alink reference definitiondoes not correspond to a structural element of a document. Instead, itdefines a label which can be used inreference linksand reference-styleimages elsewhere in the document.Linkreference definitions can come either before or after the links that usethem.
[Foo*bar\]]:my_(url)'title(withparens)'[Foo*bar\]]<p><ahref="my_(url)"title="title(withparens)">Foo*bar]</a></p>The title may extend over multiple lines:
However, it may not contain ablank line:
[foo]:/url'titlewithblankline'[foo]<p>[foo]:/url'title</p><p>withblankline'</p><p>[foo]</p>The title may be omitted:
The link destination may not be omitted:
However, an empty link destination may be specified usingangle brackets:
The title must be separated from the link destination bywhitespace:
Both title and destination can contain backslash escapesand literal backslashes:
[foo]:/url\bar\*baz"foo\"bar\baz"[foo]<p><ahref="/url%5Cbar*baz"title="foo"bar\baz">foo</a></p>A link can come before its corresponding definition:
If there are several matching definitions, the first one takesprecedence:
As noted in the section onLinks, matching of labels iscase-insensitive (seematches).
Here is a link reference definition with no corresponding link.It contributes nothing to the document.
Here is another one:
This is not a link reference definition, because there arenon-whitespace characters after the title:
This is a link reference definition, but it has no title:
This is not a link reference definition, because it is indentedfour spaces:
This is not a link reference definition, because it occurs insidea code block:
Alink reference definition cannot interrupt a paragraph.
However, it can directly follow other block elements, such as headingsand thematic breaks, and it need not be followed by a blank line.
Severallink reference definitionscan occur one after another, without intervening blank lines.
[foo]:/foo-url"foo"[bar]:/bar-url"bar"[baz]:/baz-url[foo],[bar],[baz]<p><ahref="/foo-url"title="foo">foo</a>,<ahref="/bar-url"title="bar">bar</a>,<ahref="/baz-url">baz</a></p>Link reference definitions can occurinside block containers, like lists and block quotations. Theyaffect the entire document, not just the container in which theyare defined:
Whether something is alink reference definition isindependent of whether the link reference it defines isused in the document. Thus, for example, the followingdocument contains just a link reference definition, andno visible content:
A sequence of non-blank lines that cannot be interpreted as otherkinds of blocks forms aparagraph.The contents of the paragraph are the result of parsing theparagraph’s raw content as inlines. The paragraph’s raw contentis formed by concatenating the lines and removing initial and finalwhitespace.
A simple example with two paragraphs:
Paragraphs can contain multiple lines, but no blank lines:
Multiple blank lines between paragraph have no effect:
Leading spaces are skipped:
Lines after the first may be indented any amount, since indentedcode blocks cannot interrupt paragraphs.
However, the first line may be indented at most three spaces,or an indented code block will be triggered:
Final spaces are stripped before inline parsing, so a paragraphthat ends with two or more spaces will not end with ahard linebreak:
Blank lines between block-level elements are ignored,except for the role they play in determining whether alististight orloose.
Blank lines at the beginning and end of the document are also ignored.
GFM enables thetable extension, where an additional leaf block type isavailable.
Atable is an arrangement of data with rows and columns, consisting of asingle header row, adelimiter row separating the header from the data, andzero or more data rows.
Each row consists of cells containing arbitrary text, in whichinlines areparsed, separated by pipes (|). A leading and trailing pipe is alsorecommended for clarity of reading, and if there’s otherwise parsing ambiguity.Spaces between pipes and cell content are trimmed. Block-level elements cannotbe inserted in a table.
Thedelimiter row consists of cells whose only content are hyphens (-),and optionally, a leading or trailing colon (:), or both, to indicate left,right, or center alignment respectively.
|foo|bar||---|---||baz|bim|<table><thead><tr><th>foo</th><th>bar</th></tr></thead><tbody><tr><td>baz</td><td>bim</td></tr></tbody></table>Cells in one column don’t need to match length, though it’s easier to read ifthey are. Likewise, use of leading and trailing pipes may be inconsistent:
|abc|defghi|:-:|-----------:bar|baz<table><thead><tr><thalign="center">abc</th><thalign="right">defghi</th></tr></thead><tbody><tr><tdalign="center">bar</td><tdalign="right">baz</td></tr></tbody></table>Include a pipe in a cell’s content by escaping it, including inside otherinline spans:
|f\|oo||------||b`\|`az||b**\|**im|<table><thead><tr><th>f|oo</th></tr></thead><tbody><tr><td>b<code>|</code>az</td></tr><tr><td>b<strong>|</strong>im</td></tr></tbody></table>The table is broken at the first empty line, or beginning of anotherblock-level structure:
|abc|def||---|---||bar|baz|>bar<table><thead><tr><th>abc</th><th>def</th></tr></thead><tbody><tr><td>bar</td><td>baz</td></tr></tbody></table><blockquote><p>bar</p></blockquote>|abc|def||---|---||bar|baz|barbar<table><thead><tr><th>abc</th><th>def</th></tr></thead><tbody><tr><td>bar</td><td>baz</td></tr><tr><td>bar</td><td></td></tr></tbody></table><p>bar</p>The header row must match thedelimiter row in the number of cells. If not,a table will not be recognized:
The remainder of the table’s rows may vary in the number of cells. If thereare a number of cells fewer than the number of cells in the header row, emptycells are inserted. If there are greater, the excess is ignored:
|abc|def||---|---||bar||bar|baz|boo|<table><thead><tr><th>abc</th><th>def</th></tr></thead><tbody><tr><td>bar</td><td></td></tr><tr><td>bar</td><td>baz</td></tr></tbody></table>If there are no rows in the body, no<tbody> is generated in HTML output:
Acontainer block is a block that has otherblocks as its contents. There are two basic kinds of container blocks:block quotes andlist items.Lists are meta-containers forlist items.
We define the syntax for container blocks recursively. The generalform of the definition is:
If X is a sequence of blocks, then the result oftransforming X in such-and-such a way is a container of type Ywith these blocks as its content.
So, we explain what counts as a block quote or list item by explaininghow these can begenerated from their contents. This should sufficeto define the syntax, although it does not give a recipe forparsingthese constructions. (A recipe is provided below in the section entitledA parsing strategy.)
Ablock quote markerconsists of 0-3 spaces of initial indent, plus (a) the character> togetherwith a following space, or (b) a single character> not followed by a space.
The following rules defineblock quotes:
Basic case. If a string of linesLs constitute a sequenceof blocksBs, then the result of prepending ablock quotemarker to the beginning of each line inLsis ablock quote containingBs.
Laziness. If a string of linesLs constitute ablockquote with contentsBs, then the result of deletingthe initialblock quote marker from one ormore lines in which the nextnon-whitespace character after theblockquote marker isparagraph continuationtext is a block quote withBs as its content.Paragraph continuation text is textthat will be parsed as part of the content of a paragraph, but doesnot occur at the beginning of the paragraph.
Consecutiveness. A document cannot contain twoblockquotes in a row unless there is ablank line between them.
Nothing else counts as ablock quote.
Here is a simple example:
The spaces after the> characters can be omitted:
The> characters can be indented 1-3 spaces:
Four spaces gives us a code block:
The Laziness clause allows us to omit the> beforeparagraph continuation text:
A block quote can contain some lazy and some non-lazycontinuation lines:
Laziness only applies to lines that would have been continuations ofparagraphs had they been prepended withblock quote markers.For example, the> cannot be omitted in the second line of
> foo> ---without changing the meaning:
Similarly, if we omit the> in the second line of
> - foo> - barthen the block quote ends after the first line:
For the same reason, we can’t omit the> in front ofsubsequent lines of an indented or fenced code block:
>```foo```<blockquote><pre><code></code></pre></blockquote><p>foo</p><pre><code></code></pre>Note that in the following case, we have alazycontinuation line:
To see why, note that in
> foo> - barthe- bar is indented too far to start a list, and can’tbe an indented code block because indented code blocks cannotinterrupt paragraphs, so it isparagraph continuation text.
A block quote can be empty:
A block quote can have initial or final blank lines:
A blank line always separates block quotes:
(Most current Markdown implementations, including John Gruber’soriginalMarkdown.pl, will parse this example as a single block quotewith two paragraphs. But it seems better to allow the author to decidewhether two block quotes or one are wanted.)
Consecutiveness means that if we put these block quotes together,we get a single block quote:
To get a block quote with two paragraphs, use:
Block quotes can interrupt paragraphs:
In general, blank lines are not needed before or after blockquotes:
However, because of laziness, a blank line is needed betweena block quote and a following paragraph:
It is a consequence of the Laziness rule that any numberof initial>s may be omitted on a continuation line of anested block quote:
>>>foobar<blockquote><blockquote><blockquote><p>foobar</p></blockquote></blockquote></blockquote>>>>foo>bar>>baz<blockquote><blockquote><blockquote><p>foobarbaz</p></blockquote></blockquote></blockquote>When including an indented code block in a block quote,remember that theblock quote marker includesboth the> and a following space. Sofive spaces are needed afterthe>:
>code>notcode<blockquote><pre><code>code</code></pre></blockquote><blockquote><p>notcode</p></blockquote>Alist marker is abullet list marker or anordered list marker.
Abullet list markeris a-,+, or* character.
Anordered list markeris a sequence of 1–9 arabic digits (0-9), followed by either a. character or a) character. (The reason for the lengthlimit is that with 10 digits we start seeing integer overflowsin some browsers.)
The following rules definelist items:
Basic case. If a sequence of linesLs constitute a sequence ofblocksBs starting with anon-whitespace character, andM is alist marker of widthW followed by 1 ≤N ≤ 4 spaces, then the resultof prependingM and the following spaces to the first line ofLs, and indenting subsequent lines ofLs byW + N spaces, is alist item withBs as its contents. The type of the list item(bullet or ordered) is determined by the type of its list marker.If the list item is ordered, then it is also assigned a startnumber, based on the ordered list marker.
Exceptions:
For example, letLs be the lines
Aparagraphwithtwolines.indentedcode>Ablockquote.<p>Aparagraphwithtwolines.</p><pre><code>indentedcode</code></pre><blockquote><p>Ablockquote.</p></blockquote>And letM be the marker1., andN = 2. Then rule #1 saysthat the following is an ordered list item with start number 1,and the same contents asLs:
1.Aparagraphwithtwolines.indentedcode>Ablockquote.<ol><li><p>Aparagraphwithtwolines.</p><pre><code>indentedcode</code></pre><blockquote><p>Ablockquote.</p></blockquote></li></ol>The most important thing to notice is that the position ofthe text after the list marker determines how much indentationis needed in subsequent blocks in the list item. If the listmarker takes up two spaces, and there are three spaces betweenthe list marker and the nextnon-whitespace character, then blocksmust be indented five spaces in order to fall under the listitem.
Here are some examples showing how far content must be indented to beput under the list item:
It is tempting to think of this in terms of columns: the continuationblocks must be indented at least to the column of the firstnon-whitespace character after the list marker. However, that is not quite right.The spaces after the list marker determine how much relative indentationis needed. Which column this indentation reaches will depend onhow the list item is embedded in other constructions, as shown bythis example:
>>1.one>>>>two<blockquote><blockquote><ol><li><p>one</p><p>two</p></li></ol></blockquote></blockquote>Heretwo occurs in the same column as the list marker1.,but is actually contained in the list item, because there issufficient indentation after the last containing blockquote marker.
The converse is also possible. In the following example, the wordtwooccurs far to the right of the initial text of the list item,one, butit is not considered part of the list item, because it is not indentedfar enough past the blockquote marker:
>>-one>>>>two<blockquote><blockquote><ul><li>one</li></ul><p>two</p></blockquote></blockquote>Note that at least one space is needed between the list marker andany following content, so these are not list items:
A list item may contain blocks that are separated by more thanone blank line.
A list item may contain any kind of block:
1.foo```bar```baz>bam<ol><li><p>foo</p><pre><code>bar</code></pre><p>baz</p><blockquote><p>bam</p></blockquote></li></ol>A list item that contains an indented code block will preserveempty lines within the code block verbatim.
Note that ordered list start numbers must be nine digits or less:
A start number may begin with 0s:
A start number may not be negative:
An indented code block will have to be indented four spaces beyondthe edge of the region where text will be included in the list item.In the following case that is 6 spaces:
And in this case it is 11 spaces:
If thefirst block in the list item is an indented code block,then by rule #2, the contents must be indentedone space after thelist marker:
indentedcodeparagraphmorecode<pre><code>indentedcode</code></pre><p>paragraph</p><pre><code>morecode</code></pre>1.indentedcodeparagraphmorecode<ol><li><pre><code>indentedcode</code></pre><p>paragraph</p><pre><code>morecode</code></pre></li></ol>Note that an additional space indent is interpreted as spaceinside the code block:
1.indentedcodeparagraphmorecode<ol><li><pre><code>indentedcode</code></pre><p>paragraph</p><pre><code>morecode</code></pre></li></ol>Note that rules #1 and #2 only apply to two cases: (a) casesin which the lines to be included in a list item begin with anon-whitespace character, and (b) cases in whichthey begin with an indented codeblock. In a case like the following, where the first block begins witha three-space indent, the rules do not allow us to form a list item byindenting the whole thing and prepending a list marker:
This is not a significant restriction, because when a block beginswith 1-3 spaces indent, the indentation can always be removed withouta change in interpretation, allowing rule #1 to be applied. So, inthe above case:
Here are some list items that start with a blank line but are not empty:
-foo-```bar```-baz<ul><li>foo</li><li><pre><code>bar</code></pre></li><li><pre><code>baz</code></pre></li></ul>When the list item starts with a blank line, the number of spacesfollowing the list marker doesn’t change the required indentation:
A list item can begin with at most one blank line.In the following example,foo is not part of the listitem:
Here is an empty bullet list item:
It does not matter whether there are spaces following thelist marker:
Here is an empty ordered list item:
A list may start or end with an empty list item:
However, an empty list item cannot interrupt a paragraph:
Indented one space:
1.Aparagraphwithtwolines.indentedcode>Ablockquote.<ol><li><p>Aparagraphwithtwolines.</p><pre><code>indentedcode</code></pre><blockquote><p>Ablockquote.</p></blockquote></li></ol>Indented two spaces:
1.Aparagraphwithtwolines.indentedcode>Ablockquote.<ol><li><p>Aparagraphwithtwolines.</p><pre><code>indentedcode</code></pre><blockquote><p>Ablockquote.</p></blockquote></li></ol>Indented three spaces:
1.Aparagraphwithtwolines.indentedcode>Ablockquote.<ol><li><p>Aparagraphwithtwolines.</p><pre><code>indentedcode</code></pre><blockquote><p>Ablockquote.</p></blockquote></li></ol>Four spaces indent gives a code block:
1.Aparagraphwithtwolines.indentedcode>Ablockquote.<pre><code>1.Aparagraphwithtwolines.indentedcode>Ablockquote.</code></pre>Here is an example withlazy continuation lines:
1.Aparagraphwithtwolines.indentedcode>Ablockquote.<ol><li><p>Aparagraphwithtwolines.</p><pre><code>indentedcode</code></pre><blockquote><p>Ablockquote.</p></blockquote></li></ol>Indentation can be partially deleted:
These examples show how laziness can work in nested structures:
>1.>Blockquotecontinuedhere.<blockquote><ol><li><blockquote><p>Blockquotecontinuedhere.</p></blockquote></li></ol></blockquote>>1.>Blockquote>continuedhere.<blockquote><ol><li><blockquote><p>Blockquotecontinuedhere.</p></blockquote></li></ol></blockquote>The rules for sublists follow from the general rulesabove. A sublist must be indented the same numberof spaces a paragraph would need to be in order to be includedin the list item.
So, in this case we need two spaces indent:
-foo-bar-baz-boo<ul><li>foo<ul><li>bar<ul><li>baz<ul><li>boo</li></ul></li></ul></li></ul></li></ul>One is not enough:
Here we need four, because the list marker is wider:
Three is not enough:
A list may be the first block in a list item:
A list item can contain a heading:
John Gruber’s Markdown spec says the following about list items:
“List markers typically start at the left margin, but may be indentedby up to three spaces. List markers must be followed by one or morespaces or a tab.”
“To make lists look nice, you can wrap items with hanging indents….But if you don’t want to, you don’t have to.”
“List items may consist of multiple paragraphs. Each subsequentparagraph in a list item must be indented by either 4 spaces or onetab.”
“It looks nice if you indent every line of the subsequent paragraphs,but here again, Markdown will allow you to be lazy.”
“To put a blockquote within a list item, the blockquote’s>delimiters need to be indented.”
“To put a code block within a list item, the code block needs to beindented twice — 8 spaces or two tabs.”
These rules specify that a paragraph under a list item must be indentedfour spaces (presumably, from the left margin, rather than the start ofthe list marker, but this is not said), and that code under a list itemmust be indented eight spaces instead of the usual four. They also saythat a block quote must be indented, but not by how much; however, theexample given has four spaces indentation. Although nothing is saidabout other kinds of block-level content, it is certainly reasonable toinfer thatall block elements under a list item, including otherlists, must be indented four spaces. This principle has been called thefour-space rule.
The four-space rule is clear and principled, and if the referenceimplementationMarkdown.pl had followed it, it probably would havebecome the standard. However,Markdown.pl allowed paragraphs andsublists to start with only two spaces indentation, at least on theouter level. Worse, its behavior was inconsistent: a sublist of anouter-level list needed two spaces indentation, but a sublist of thissublist needed three spaces. It is not surprising, then, that differentimplementations of Markdown have developed very different rules fordetermining what comes under a list item. (Pandoc and python-Markdown,for example, stuck with Gruber’s syntax description and the four-spacerule, while discount, redcarpet, marked, PHP Markdown, and othersfollowedMarkdown.pl’s behavior more closely.)
Unfortunately, given the divergences between implementations, thereis no way to give a spec for list items that will be guaranteed notto break any existing documents. However, the spec given here shouldcorrectly handle lists formatted with either the four-space rule orthe more forgivingMarkdown.pl behavior, provided they are laid outin a way that is natural for a human to read.
The strategy here is to let the width and indentation of the list markerdetermine the indentation necessary for blocks to fall under the listitem, rather than having a fixed and arbitrary number. The writer canthink of the body of the list item as a unit which gets indented to theright enough to fit the list marker (and any indentation on the listmarker). (The laziness rule, #5, then allows continuation lines to beunindented if needed.)
This rule is superior, we claim, to any rule requiring a fixed level ofindentation from the margin. The four-space rule is clear butunnatural. It is quite unintuitive that
- foo bar - bazshould be parsed as two lists with an intervening paragraph,
<ul><li>foo</li></ul><p>bar</p><ul><li>baz</li></ul>as the four-space rule demands, rather than a single list,
<ul><li><p>foo</p><p>bar</p><ul><li>baz</li></ul></li></ul>The choice of four spaces is arbitrary. It can be learned, but it isnot likely to be guessed, and it trips up beginners regularly.
Would it help to adopt a two-space rule? The problem is that sucha rule, together with the rule allowing 1–3 spaces indentation of theinitial list marker, allows text that is indentedless than theoriginal list marker to be included in the list item. For example,Markdown.pl parses
- one twoas a single list item, withtwo a continuation paragraph:
<ul><li><p>one</p><p>two</p></li></ul>and similarly
> - one>> twoas
<blockquote><ul><li><p>one</p><p>two</p></li></ul></blockquote>This is extremely unintuitive.
Rather than requiring a fixed indent from the margin, we could requirea fixed indent (say, two spaces, or even one space) from the list marker (whichmay itself be indented). This proposal would remove the last anomalydiscussed. Unlike the spec presented above, it would count the followingas a list item with a subparagraph, even though the paragraphbaris not indented as far as the first paragraphfoo:
10. foo barArguably this text does read like a list item withbar as a subparagraph,which may count in favor of the proposal. However, on this proposal indentedcode would have to be indented six spaces after the list marker. And thiswould break a lot of existing Markdown, which has the pattern:
1. foo indented codewhere the code is indented eight spaces. The spec above, by contrast, willparse this text as expected, since the code block’s indentation is measuredfrom the beginning offoo.
The one case that needs special treatment is a list item thatstartswith indented code. How much indentation is required in that case, sincewe don’t have a “first paragraph” to measure from? Rule #2 simply stipulatesthat in such cases, we require one space indentation from the list marker(and then the normal four spaces for the indented code). This will match thefour-space rule in cases where the list marker plus its initial indentationtakes four spaces (a common case), but diverge in other cases.
GFM enables thetasklist extension, where an additional processing step isperformed onlist items.
Atask list item is alist item where the first block in itis a paragraph which begins with atask list item marker and at least onewhitespace character before any other content.
Atask list item marker consists of an optional number of spaces, a leftbracket ([), either a whitespace character or the letterx in eitherlowercase or uppercase, and then a right bracket (]).
When rendered, thetask list item marker is replaced with a semantic checkbox element;in an HTML output, this would be an<input type="checkbox"> element.
If the character between the brackets is a whitespace character, the checkboxis unchecked. Otherwise, the checkbox is checked.
This spec does not define how the checkbox elements are interacted with: in practice,implementors are free to render the checkboxes as disabled or inmutable elements,or they may dynamically handle dynamic interactions (i.e. checking, unchecking) inthe final rendered document.
-[]foo-[x]bar<ul><li><inputdisabled=""type="checkbox">foo</li><li><inputchecked=""disabled=""type="checkbox">bar</li></ul>Task lists can be arbitrarily nested:
-[x]foo-[]bar-[x]baz-[]bim<ul><li><inputchecked=""disabled=""type="checkbox">foo<ul><li><inputdisabled=""type="checkbox">bar</li><li><inputchecked=""disabled=""type="checkbox">baz</li></ul></li><li><inputdisabled=""type="checkbox">bim</li></ul>Alist is a sequence of one or morelist itemsof the same type. The list itemsmay be separated by any number of blank lines.
Two list items areof the same typeif they begin with alist marker of the same type.Two list markers are of thesame type if (a) they are bullet list markers using the same character(-,+, or*) or (b) they are ordered list numbers with the samedelimiter (either. or)).
A list is anordered listif its constituent list items begin withordered list markers, and abullet list if its constituent listitems begin withbullet list markers.
Thestart numberof anordered list is determined by the list number ofits initial list item. The numbers of subsequent list items aredisregarded.
A list isloose if any of its constituentlist items are separated by blank lines, or if any of its constituentlist items directly contain two block-level elements with a blank linebetween them. Otherwise a list istight.(The difference in HTML output is that paragraphs in a loose list arewrapped in<p> tags, while paragraphs in a tight list are not.)
Changing the bullet or ordered list delimiter starts a new list:
In CommonMark, a list can interrupt a paragraph. That is,no blank line is needed to separate a paragraph from a followinglist:
Markdown.pl does not allow this, through fear of triggering a listvia a numeral in a hard-wrapped line:
The number of windows in my house is14. The number of doors is 6.Oddly, though,Markdown.pldoes allow a blockquote tointerrupt a paragraph, even though the same considerations mightapply.
In CommonMark, we do allow lists to interrupt paragraphs, fortwo reasons. First, it is natural and not uncommon for peopleto start lists without blank lines:
I need to buy- new shoes- a coat- a plane ticketSecond, we are attracted to a
principle of uniformity:if a chunk of text has a certainmeaning, it will continue to have the same meaning when put into acontainer block (such as a list item or blockquote).
(Indeed, the spec forlist items andblock quotes presupposesthis principle.) This principle implies that if
* I need to buy - new shoes - a coat - a plane ticketis a list item containing a paragraph followed by a nested sublist,as all Markdown implementations agree it is (though the paragraphmay be rendered without<p> tags, since the list is “tight”),then
I need to buy- new shoes- a coat- a plane ticketby itself should be a paragraph followed by a nested sublist.
Since it is well established Markdown practice to allow lists tointerrupt paragraphs inside list items, theprinciple ofuniformity requires us to allow this outside list items aswell. (reStructuredTexttakes a different approach, requiring blank lines before listseven inside other list items.)
In order to solve of unwanted lists in paragraphs withhard-wrapped numerals, we allow only lists starting with1 tointerrupt paragraphs. Thus,
Thenumberofwindowsinmyhouseis14.Thenumberofdoorsis6.<p>Thenumberofwindowsinmyhouseis14.Thenumberofdoorsis6.</p>We may still get an unintended result in cases like
Thenumberofwindowsinmyhouseis1.Thenumberofdoorsis6.<p>Thenumberofwindowsinmyhouseis</p><ol><li>Thenumberofdoorsis6.</li></ol>but this rule should prevent most spurious list captures.
There can be any number of blank lines between items:
-foo-bar-bazbim<ul><li>foo<ul><li>bar<ul><li><p>baz</p><p>bim</p></li></ul></li></ul></li></ul>To separate consecutive lists of the same type, or to separate alist from an indented code block that would otherwise be parsedas a subparagraph of the final list item, you can insert a blank HTMLcomment:
-foo-bar<!---->-baz-bim<ul><li>foo</li><li>bar</li></ul><!----><ul><li>baz</li><li>bim</li></ul>-foonotcode-foo<!---->code<ul><li><p>foo</p><p>notcode</p></li><li><p>foo</p></li></ul><!----><pre><code>code</code></pre>List items need not be indented to the same level. The followinglist items will be treated as items at the same list level,since none is indented enough to belong to the previous listitem:
-a-b-c-d-e-f-g<ul><li>a</li><li>b</li><li>c</li><li>d</li><li>e</li><li>f</li><li>g</li></ul>Note, however, that list items may not be indented more thanthree spaces. Here- e is treated as a paragraph continuationline, because it is indented more than three spaces:
And here,3. c is treated as in indented code block,because it is indented four spaces and preceded by ablank line.
This is a loose list, because there is a blank line betweentwo of the list items:
So is this, with a empty second item:
These are loose lists, even though there is no space between the items,because one of the items directly contains two block-level elementswith a blank line between them:
This is a tight list, because the blank lines are in a code block:
This is a tight list, because the blank line is between twoparagraphs of a sublist. So the sublist is loose whilethe outer list is tight:
This is a tight list, because the blank line is inside theblock quote:
This list is tight, because the consecutive block elementsare not separated by blank lines:
-a>b```c```-d<ul><li>a<blockquote><p>b</p></blockquote><pre><code>c</code></pre></li><li>d</li></ul>A single-paragraph list is tight:
This list is loose, because of the blank line between thetwo block elements in the list item:
Here the outer list is loose, the inner list tight:
-a-b-c-d-e-f<ul><li><p>a</p><ul><li>b</li><li>c</li></ul></li><li><p>d</p><ul><li>e</li><li>f</li></ul></li></ul>Inlines are parsed sequentially from the beginning of the characterstream to the end (left to right, in left-to-right languages).Thus, for example, in
hi is parsed as code, leaving the backtick at the end as a literalbacktick.
Any ASCII punctuation character may be backslash-escaped:
\!\"\#\$\%\&\'\(\)\*\+\,\-\.\/\:\;\<\=\>\?\@\[\\\]\^\_\`\{\|\}\~<p>!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~</p>Backslashes before other characters are treated as literalbackslashes:
Escaped characters are treated as regular characters and donot have their usual Markdown meanings:
\*notemphasized*\<br/>notatag\[notalink](/foo)\`notcode`1\.notalist\*notalist\#notaheading\[foo]:/url"notareference"\önotacharacterentity<p>*notemphasized*<br/>notatag[notalink](/foo)`notcode`1.notalist*notalist#notaheading[foo]:/url"notareference"&ouml;notacharacterentity</p>If a backslash is itself escaped, the following character is not:
A backslash at the end of the line is ahard line break:
Backslash escapes do not work in code blocks, code spans, autolinks, orraw HTML:
<http://example.com?find=\*><p><ahref="http://example.com?find=%5C*">http://example.com?find=\*</a></p>But they work in all other contexts, including URLs and link titles,link references, andinfo strings infenced code blocks:
Valid HTML entity references and numeric character referencescan be used in place of the corresponding Unicode character,with the following exceptions:
Entity and character references are not recognized in codeblocks and code spans.
Entity and character references cannot stand in place ofspecial characters that define structural elements inCommonMark. For example, although* can be usedin place of a literal* character,* cannot replace* in emphasis delimiters, bullet list markers, or thematicbreaks.
Conforming CommonMark parsers need not store information aboutwhether a particular character was represented in the sourceusing a Unicode character or an entity reference.
Entity references consist of& + any of the validHTML5 entity names +;. Thedocumenthttps://html.spec.whatwg.org/multipage/entities.jsonis used as an authoritative source for the valid entityreferences and their corresponding code points.
&©ÆĎ¾ℋⅆ∲≧̸<p> &©ÆĎ¾ℋⅆ∲≧̸</p>Decimal numeric characterreferencesconsist of&# + a string of 1–7 arabic digits +;. Anumeric character reference is parsed as the correspondingUnicode character. Invalid Unicode code points will be replaced bythe REPLACEMENT CHARACTER (U+FFFD). For security reasons,the code pointU+0000 will also be replaced byU+FFFD.
Hexadecimal numeric characterreferences consist of&# +eitherX orx + a string of 1-6 hexadecimal digits +;.They too are parsed as the corresponding Unicode character (thistime specified with a hexadecimal numeral instead of decimal).
Here are some nonentities:
 &x;&#;&#x;�&#abcdef0;&ThisIsNotDefined;&hi?;<p>&nbsp&x;&#;&#x;&#87654321;&#abcdef0;&ThisIsNotDefined;&hi?;</p>Although HTML5 does accept some entity referenceswithout a trailing semicolon (such as©), these are notrecognized here, because it makes the grammar too ambiguous:
Strings that are not on the list of HTML5 named entities are notrecognized as entity references either:
Entity and numeric character references are recognized in anycontext besides code spans or code blocks, includingURLs,link titles, andfenced code blockinfo strings:
[foo][foo]:/föö"föö"<p><ahref="/f%C3%B6%C3%B6"title="föö">foo</a></p>Entity and numeric character references are treated as literaltext in code spans and code blocks:
Entity and numeric character references cannot be usedin place of symbols indicating structure in CommonMarkdocuments.
Abacktick stringis a string of one or more backtick characters (`) that is neitherpreceded nor followed by a backtick.
Acode span begins with a backtick string and ends witha backtick string of equal length. The contents of the code span arethe characters between the two backtick strings, normalized in thefollowing ways:
This is a simple code span:
Here two backticks are used, because the code contains a backtick.This example also illustrates stripping of a single leading andtrailing space:
This example shows the motivation for stripping leading and trailingspaces:
Note that onlyone space is stripped:
The stripping only happens if the space is on bothsides of the string:
Onlyspaces, and notunicode whitespace in general, arestripped in this way:
No stripping occurs if the code span contains only spaces:
Line endings are treated like spaces:
Interior spaces are not collapsed:
Note that browsers will typically collapse consecutive spaceswhen rendering<code> elements, so it is recommended thatthe following CSS be used:
code{white-space: pre-wrap;}Note that backslash escapes do not work in code spans. All backslashesare treated literally:
Backslash escapes are never needed, because one can always choose astring ofn backtick characters as delimiters, where the code doesnot contain any strings of exactlyn backtick characters.
Code span backticks have higher precedence than any other inlineconstructs except HTML tags and autolinks. Thus, for example, this isnot parsed as emphasized text, since the second* is part of a codespan:
And this is not parsed as a link:
Code spans, HTML tags, and autolinks have the same precedence.Thus, this is code:
But this is an HTML tag:
And this is code:
But this is an autolink:
When a backtick string is not closed by a matching backtick string,we just have literal backticks:
The following case also illustrates the need for opening andclosing backtick strings to be equal in length:
John Gruber’s originalMarkdown syntaxdescription says:
Markdown treats asterisks (
*) and underscores (_) as indicators ofemphasis. Text wrapped with one*or_will be wrapped with an HTML<em>tag; double*’s or_’s will be wrapped with an HTML<strong>tag.
This is enough for most users, but these rules leave much undecided,especially when it comes to nested emphasis. The originalMarkdown.pl test suite makes it clear that triple*** and___ delimiters can be used for strong emphasis, and mostimplementations have also allowed the following patterns:
***strong emph******strong** in emph****emph* in strong****in strong *emph****in emph **strong***The following patterns are less widely supported, but the intentis clear and they are useful (especially in contexts like bibliographyentries):
*emph *with emph* in it***strong **with strong** in it**Many implementations have also restricted intraword emphasis tothe* forms, to avoid unwanted emphasis in words containinginternal underscores. (It is best practice to put these in codespans, but users often do not.)
internal emphasis: foo*bar*bazno emphasis: foo_bar_bazThe rules given below capture all of these patterns, while allowingfor efficient parsing strategies that do not backtrack.
First, some definitions. Adelimiter run is eithera sequence of one or more* characters that is not preceded orfollowed by a non-backslash-escaped* character, or a sequenceof one or more_ characters that is not preceded or followed bya non-backslash-escaped_ character.
Aleft-flanking delimiter run isadelimiter run that is (1) not followed byUnicode whitespace,and either (2a) not followed by apunctuation character, or(2b) followed by apunctuation character andpreceded byUnicode whitespace or apunctuation character.For purposes of this definition, the beginning and the end ofthe line count as Unicode whitespace.
Aright-flanking delimiter run isadelimiter run that is (1) not preceded byUnicode whitespace,and either (2a) not preceded by apunctuation character, or(2b) preceded by apunctuation character andfollowed byUnicode whitespace or apunctuation character.For purposes of this definition, the beginning and the end ofthe line count as Unicode whitespace.
Here are some examples of delimiter runs.
left-flanking but not right-flanking:
***abc _abc**"abc" _"abc"right-flanking but not left-flanking:
abc*** abc_"abc"**"abc"_Both left and right-flanking:
abc***def"abc"_"def"Neither left nor right-flanking:
abc *** defa _ b(The idea of distinguishing left-flanking and right-flankingdelimiter runs based on the character before and the characterafter comes from Roopesh Chander’svfmd.vfmd uses the terminology “emphasis indicator string” instead of “delimiterrun,” and its rules for distinguishing left- and right-flanking runsare a bit more complex than the ones given here.)
The following rules define emphasis and strong emphasis:
A single* charactercan open emphasisiff (if and only if) it is part of aleft-flanking delimiter run.
A single_ charactercan open emphasis iffit is part of aleft-flanking delimiter runand either (a) not part of aright-flanking delimiter runor (b) part of aright-flanking delimiter runpreceded by punctuation.
A single* charactercan close emphasisiff it is part of aright-flanking delimiter run.
A single_ charactercan close emphasis iffit is part of aright-flanking delimiter runand either (a) not part of aleft-flanking delimiter runor (b) part of aleft-flanking delimiter runfollowed by punctuation.
A double**can open strong emphasisiff it is part of aleft-flanking delimiter run.
A double__can open strong emphasis iffit is part of aleft-flanking delimiter runand either (a) not part of aright-flanking delimiter runor (b) part of aright-flanking delimiter runpreceded by punctuation.
A double**can close strong emphasisiff it is part of aright-flanking delimiter run.
A double__can close strong emphasis iffit is part of aright-flanking delimiter runand either (a) not part of aleft-flanking delimiter runor (b) part of aleft-flanking delimiter runfollowed by punctuation.
Emphasis begins with a delimiter thatcan open emphasis and endswith a delimiter thatcan close emphasis, and that uses the samecharacter (_ or*) as the opening delimiter. Theopening and closing delimiters must belong to separatedelimiter runs. If one of the delimiters can bothopen and close emphasis, then the sum of the lengths of thedelimiter runs containing the opening and closing delimitersmust not be a multiple of 3 unless both lengths aremultiples of 3.
Strong emphasis begins with a delimiter thatcan open strong emphasis and ends with a delimiter thatcan close strong emphasis, and that uses the same character(_ or*) as the opening delimiter. Theopening and closing delimiters must belong to separatedelimiter runs. If one of the delimiters can both openand close strong emphasis, then the sum of the lengths ofthe delimiter runs containing the opening and closingdelimiters must not be a multiple of 3 unless both lengthsare multiples of 3.
A literal* character cannot occur at the beginning or end of*-delimited emphasis or**-delimited strong emphasis, unless itis backslash-escaped.
A literal_ character cannot occur at the beginning or end of_-delimited emphasis or__-delimited strong emphasis, unless itis backslash-escaped.
Where rules 1–12 above are compatible with multiple parsings,the following principles resolve ambiguity:
The number of nestings should be minimized. Thus, for example,an interpretation<strong>...</strong> is always preferred to<em><em>...</em></em>.
An interpretation<em><strong>...</strong></em> is alwayspreferred to<strong><em>...</em></strong>.
When two potential emphasis or strong emphasis spans overlap,so that the second begins before the first ends and ends afterthe first ends, the first takes precedence. Thus, for example,*foo _bar* baz_ is parsed as<em>foo _bar</em> baz_ ratherthan*foo <em>bar* baz</em>.
When there are two potential emphasis or strong emphasis spanswith the same closing delimiter, the shorter one (the one thatopens later) takes precedence. Thus, for example,**foo **bar baz** is parsed as**foo <strong>bar baz</strong>rather than<strong>foo **bar baz</strong>.
Inline code spans, links, images, and HTML tags group more tightlythan emphasis. So, when there is a choice between an interpretationthat contains one of these elements and one that does not, theformer always wins. Thus, for example,*[foo*](bar) isparsed as*<a href="bar">foo*</a> rather than as<em>[foo</em>](bar).
These rules can be illustrated through a series of examples.
Rule 1:
This is not emphasis, because the opening* is followed bywhitespace, and hence not part of aleft-flanking delimiter run:
This is not emphasis, because the opening* is precededby an alphanumeric and followed by punctuation, and hencenot part of aleft-flanking delimiter run:
Unicode nonbreaking spaces count as whitespace, too:
Intraword emphasis with* is permitted:
Rule 2:
This is not emphasis, because the opening_ is followed bywhitespace:
This is not emphasis, because the opening_ is precededby an alphanumeric and followed by punctuation:
Emphasis with_ is not allowed inside words:
Here_ does not generate emphasis, because the first delimiter runis right-flanking and the second left-flanking:
This is emphasis, even though the opening delimiter isboth left- and right-flanking, because it is preceded bypunctuation:
Rule 3:
This is not emphasis, because the closing delimiter doesnot match the opening delimiter:
This is not emphasis, because the closing* is preceded bywhitespace:
A newline also counts as whitespace:
This is not emphasis, because the second* ispreceded by punctuation and followed by an alphanumeric(hence it is not part of aright-flanking delimiter run:
The point of this restriction is more easily appreciatedwith this example:
Intraword emphasis with* is allowed:
Rule 4:
This is not emphasis, because the closing_ is preceded bywhitespace:
This is not emphasis, because the second_ ispreceded by punctuation and followed by an alphanumeric:
This is emphasis within emphasis:
Intraword emphasis is disallowed for_:
This is emphasis, even though the closing delimiter isboth left- and right-flanking, because it is followed bypunctuation:
Rule 5:
This is not strong emphasis, because the opening delimiter isfollowed by whitespace:
This is not strong emphasis, because the opening** is precededby an alphanumeric and followed by punctuation, and hencenot part of aleft-flanking delimiter run:
Intraword strong emphasis with** is permitted:
Rule 6:
This is not strong emphasis, because the opening delimiter isfollowed by whitespace:
A newline counts as whitespace:
This is not strong emphasis, because the opening__ is precededby an alphanumeric and followed by punctuation:
Intraword strong emphasis is forbidden with__:
This is strong emphasis, even though the opening delimiter isboth left- and right-flanking, because it is preceded bypunctuation:
Rule 7:
This is not strong emphasis, because the closing delimiter is precededby whitespace:
(Nor can it be interpreted as an emphasized*foo bar *, because ofRule 11.)
This is not strong emphasis, because the second** ispreceded by punctuation and followed by an alphanumeric:
The point of this restriction is more easily appreciatedwith these examples:
**Gomphocarpus(*Gomphocarpusphysocarpus*,syn.*Asclepiasphysocarpa*)**<p><strong>Gomphocarpus(<em>Gomphocarpusphysocarpus</em>,syn.<em>Asclepiasphysocarpa</em>)</strong></p>Intraword emphasis:
Rule 8:
This is not strong emphasis, because the closing delimiter ispreceded by whitespace:
This is not strong emphasis, because the second__ ispreceded by punctuation and followed by an alphanumeric:
The point of this restriction is more easily appreciatedwith this example:
Intraword strong emphasis is forbidden with__:
This is strong emphasis, even though the closing delimiter isboth left- and right-flanking, because it is followed bypunctuation:
Rule 9:
Any nonempty sequence of inline elements can be the contents of anemphasized span.
In particular, emphasis and strong emphasis can be nestedinside emphasis:
Note that in the preceding case, the interpretation
<p><em>foo</em><em>bar<em></em>baz</em></p>is precluded by the condition that a delimiter thatcan both open and close (like the* afterfoo)cannot form emphasis if the sum of the lengths ofthe delimiter runs containing the opening andclosing delimiters is a multiple of 3 unlessboth lengths are multiples of 3.
For the same reason, we don’t get two consecutiveemphasis sections in this example:
The same condition ensures that the followingcases are all strong emphasis nested insideemphasis, even when the interior spaces areomitted:
When the lengths of the interior closing and openingdelimiter runs areboth multiples of 3, though,they can match to create emphasis:
foo******bar*********baz<p>foo<strong><strong><strong>bar</strong></strong></strong>***baz</p>Indefinite levels of nesting are possible:
There can be no empty emphasis or strong emphasis:
Rule 10:
Any nonempty sequence of inline elements can be the contents of anstrongly emphasized span.
In particular, emphasis and strong emphasis can be nestedinside strong emphasis:
Indefinite levels of nesting are possible:
**foo*bar**baz**bim*bop**<p><strong>foo<em>bar<strong>baz</strong>bim</em>bop</strong></p>There can be no empty emphasis or strong emphasis:
Rule 11:
Note that when delimiters do not match evenly, Rule 11 determinesthat the excess literal* characters will appear outside of theemphasis, rather than inside it:
Rule 12:
Note that when delimiters do not match evenly, Rule 12 determinesthat the excess literal_ characters will appear outside of theemphasis, rather than inside it:
Rule 13 implies that if you want emphasis nested directly insideemphasis, you must use different delimiters:
However, strong emphasis within strong emphasis is possible withoutswitching delimiters:
Rule 13 can be applied to arbitrarily long sequences ofdelimiters:
Rule 14:
Rule 15:
Rule 16:
Rule 17:
**a<http://foo.bar/?q=**><p>**a<ahref="http://foo.bar/?q=**">http://foo.bar/?q=**</a></p>__a<http://foo.bar/?q=__><p>__a<ahref="http://foo.bar/?q=__">http://foo.bar/?q=__</a></p>GFM enables thestrikethrough extension, where an additional emphasis type isavailable.
Strikethrough text is any text wrapped in a matching pair of one or two tildes(~).
As with regular emphasis delimiters, a new paragraph will cause strikethroughparsing to cease:
Three or more tildes do not create a strikethrough:
A link containslink text (the visible text), alink destination(the URI that is the link destination), and optionally alink title.There are two basic kinds of links in Markdown. Ininline links thedestination and title are given immediately after the link text. Inreference links the destination and title are defined elsewhere inthe document.
Alink text consists of a sequence of zero or moreinline elements enclosed by square brackets ([ and]). Thefollowing rules apply:
Links may not contain other links, at any level of nesting. Ifmultiple otherwise valid link definitions appear nested inside eachother, the inner-most definition is used.
Brackets are allowed in thelink text only if (a) theyare backslash-escaped or (b) they appear as a matched pair of brackets,with an open bracket[, a sequence of zero or more inlines, anda close bracket].
Backtickcode spans,autolinks, and rawHTML tags bind more tightlythan the brackets in link text. Thus, for example,[foo`]` could not be a link text, since the second]is part of a code span.
The brackets in link text bind more tightly than markers foremphasis and strong emphasis. Thus, for example,*[foo*](url) is a link.
Alink destination consists of either
a sequence of zero or more characters between an opening< and aclosing> that contains no line breaks or unescaped< or> characters, or
a nonempty sequence of characters that does not start with<, does not include ASCII space or control characters, andincludes parentheses only if (a) they are backslash-escaped or(b) they are part of a balanced pair of unescaped parentheses.(Implementations may impose limits on parentheses nesting toavoid performance issues, but at least three levels of nestingshould be supported.)
Alink title consists of either
a sequence of zero or more characters between straight double-quotecharacters ("), including a" character only if it isbackslash-escaped, or
a sequence of zero or more characters between straight single-quotecharacters ('), including a' character only if it isbackslash-escaped, or
a sequence of zero or more characters between matching parentheses((...)), including a( or) character only if it isbackslash-escaped.
Althoughlink titles may span multiple lines, they may not containablank line.
Aninline link consists of alink text followed immediatelyby a left parenthesis(, optionalwhitespace, an optionallink destination, an optionallink title separated from the linkdestination bywhitespace, optionalwhitespace, and a rightparenthesis). The link’s text consists of the inlines containedin thelink text (excluding the enclosing square brackets).The link’s URI consists of the link destination, excluding enclosing<...> if present, with backslash-escapes in effect as describedabove. The link’s title consists of the link title, excluding itsenclosing delimiters, with backslash-escapes in effect as describedabove.
Here is a simple inline link:
The title may be omitted:
Both the title and the destination may be omitted:
The destination can only contain spaces if it isenclosed in pointy brackets:
The destination cannot contain line breaks,even if enclosed in pointy brackets:
The destination can contain) if it is enclosedin pointy brackets:
Pointy brackets that enclose links must be unescaped:
These are not links, because the opening pointy bracketis not matched properly:
Parentheses inside the link destination may be escaped:
Any number of parentheses are allowed without escaping, as long as they arebalanced:
However, if you have unbalanced parentheses, you need to escape or use the<...> form:
Parentheses and other symbols can also be escaped, as usualin Markdown:
A link can contain fragment identifiers and queries:
[link](#fragment)[link](http://example.com#fragment)[link](http://example.com?foo=3#frag)<p><ahref="#fragment">link</a></p><p><ahref="http://example.com#fragment">link</a></p><p><ahref="http://example.com?foo=3#frag">link</a></p>Note that a backslash before a non-escapable character isjust a backslash:
URL-escaping should be left alone inside the destination, as allURL-escaped characters are also valid URL characters. Entity andnumerical character references in the destination will be parsedinto the corresponding Unicode code points, as usual. These maybe optionally URL-escaped when written as HTML, but this specdoes not enforce any particular policy for rendering URLs inHTML or other formats. Renderers may make different decisionsabout how to escape or normalize URLs in the output.
Note that, because titles can often be parsed as destinations,if you try to omit the destination and keep the title, you’llget unexpected results:
Titles may be in single quotes, double quotes, or parentheses:
[link](/url"title")[link](/url'title')[link](/url(title))<p><ahref="/url"title="title">link</a><ahref="/url"title="title">link</a><ahref="/url"title="title">link</a></p>Backslash escapes and entity and numeric character referencesmay be used in titles:
Titles must be separated from the link using awhitespace.OtherUnicode whitespace like non-breaking space doesn’t work.
Nested balanced quotes are not allowed without escaping:
But it is easy to work around this by using a different quote type:
[link](/url'title"and"title')<p><ahref="/url"title="title"and"title">link</a></p>(Note:Markdown.pl did allow double quotes inside a double-quotedtitle, and its test suite included a test demonstrating this.But it is hard to see a good rationale for the extra complexity thisbrings, since there are already many ways—backslash escaping,entity and numeric character references, or using a differentquote type for the enclosing title—to write titles containingdouble quotes.Markdown.pl’s handling of titles has a numberof other strange features. For example, it allows single-quotedtitles in inline links, but not reference links. And, inreference links but not inline links, it allows a title to beginwith" and end with).Markdown.pl 1.0.1 even allowstitles with no closing quotation mark, though 1.0.2b8 does not.It seems preferable to adopt a simple, rational rule that worksthe same way in inline links and link reference definitions.)
Whitespace is allowed around the destination and title:
But it is not allowed between the link text and thefollowing parenthesis:
The link text may contain balanced brackets, but not unbalanced ones,unless they are escaped:
The link text may contain inline content:
[link*foo**bar**`#`*](/uri)<p><ahref="/uri">link<em>foo<strong>bar</strong><code>#</code></em></a></p>However, links may not contain other links, at any level of nesting.
[foo*[bar[baz](/uri)](/uri)*](/uri)<p>[foo<em>[bar<ahref="/uri">baz</a>](/uri)</em>](/uri)</p>These cases illustrate the precedence of link text grouping overemphasis grouping:
Note that brackets thataren’t part of links do not takeprecedence:
These cases illustrate the precedence of HTML tags, code spans,and autolinks over link grouping:
[foo<http://example.com/?search=](uri)><p>[foo<ahref="http://example.com/?search=%5D(uri)">http://example.com/?search=](uri)</a></p>There are three kinds ofreference links:full,collapsed,andshortcut.
Afull reference linkconsists of alink text immediately followed by alink labelthatmatches alink reference definition elsewhere in the document.
Alink label begins with a left bracket ([) and endswith the first right bracket (]) that is not backslash-escaped.Between these brackets there must be at least onenon-whitespace character.Unescaped square bracket characters are not allowed inside theopening and closing square brackets oflink labels. A linklabel can have at most 999 characters inside the squarebrackets.
One labelmatchesanother just in case their normalized forms are equal. To normalize alabel, strip off the opening and closing brackets,perform theUnicode case fold, strip leading and trailingwhitespace and collapse consecutive internalwhitespace to a single space. If there are multiplematching reference link definitions, the one that comes first in thedocument is used. (It is desirable in such cases to emit a warning.)
The link’s URI and title are provided by the matchinglinkreference definition.
Here is a simple example:
The rules for thelink text are the same as withinline links. Thus:
The link text may contain balanced brackets, but not unbalanced ones,unless they are escaped:
The link text may contain inline content:
[link*foo**bar**`#`*][ref][ref]:/uri<p><ahref="/uri">link<em>foo<strong>bar</strong><code>#</code></em></a></p>[][ref][ref]:/uri<p><ahref="/uri"><imgsrc="moon.jpg"alt="moon"/></a></p>However, links may not contain other links, at any level of nesting.
[foo*bar[baz][ref]*][ref][ref]:/uri<p>[foo<em>bar<ahref="/uri">baz</a></em>]<ahref="/uri">ref</a></p>(In the examples above, we have twoshortcut reference linksinstead of onefull reference link.)
The following cases illustrate the precedence of link text grouping overemphasis grouping:
These cases illustrate the precedence of HTML tags, code spans,and autolinks over link grouping:
[foo<http://example.com/?search=][ref]>[ref]:/uri<p>[foo<ahref="http://example.com/?search=%5D%5Bref%5D">http://example.com/?search=][ref]</a></p>Matching is case-insensitive:
Unicode case fold is used:
Consecutive internalwhitespace is treated as one space forpurposes of determining matching:
Nowhitespace is allowed between thelink text and thelink label:
This is a departure from John Gruber’s original Markdown syntaxdescription, which explicitly allows whitespace between the linktext and the link label. It brings reference links in line withinline links, which (according to both original Markdown andthis spec) cannot have whitespace after the link text. Moreimportantly, it prevents inadvertent capture of consecutiveshortcut reference links. If whitespace is allowed between thelink text and the link label, then in the following we will havea single reference link, not two shortcut reference links, asintended:
[foo][bar][foo]: /url1[bar]: /url2(Note thatshortcut reference links were introduced by Gruberhimself in a beta version ofMarkdown.pl, but never includedin the official syntax description. Without shortcut referencelinks, it is harmless to allow space between the link text andlink label; but once shortcut references are introduced, it istoo dangerous to allow this, as it frequently leads tounintended results.)
When there are multiple matchinglink reference definitions,the first is used:
Note that matching is performed on normalized strings, not parsedinline content. So the following does not match, even though thelabels define equivalent inline content:
Link labels cannot contain brackets, unless they arebackslash-escaped:
Note that in this example] is not backslash-escaped:
Alink label must contain at least onenon-whitespace character:
Acollapsed reference linkconsists of alink label thatmatches alink reference definition elsewhere in thedocument, followed by the string[].The contents of the first link label are parsed as inlines,which are used as the link’s text. The link’s URI and title areprovided by the matching reference link definition. Thus,[foo][] is equivalent to[foo][foo].
The link labels are case-insensitive:
As with full reference links,whitespace is notallowed between the two sets of brackets:
Ashortcut reference linkconsists of alink label thatmatches alink reference definition elsewhere in thedocument and is not followed by[] or a link label.The contents of the first link label are parsed as inlines,which are used as the link’s text. The link’s URI and titleare provided by the matching link reference definition.Thus,[foo] is equivalent to[foo][].
[[*foo*bar]][*foo*bar]:/url"title"<p>[<ahref="/url"title="title"><em>foo</em>bar</a>]</p>The link labels are case-insensitive:
A space after the link text should be preserved:
If you just want bracketed text, you can backslash-escape theopening bracket to avoid links:
Note that this is a link, because a link label ends with the firstfollowing closing bracket:
Full and compact references take precedence over shortcutreferences:
Inline links also take precedence:
In the following case[bar][baz] is parsed as a reference,[foo] as normal text:
Here, though,[foo][bar] is parsed as a reference, since[bar] is defined:
Here[foo] is not parsed as a shortcut reference, because itis followed by a link label (even though[bar] is not defined):
Syntax for images is like the syntax for links, with onedifference. Instead oflink text, we have animage description. The rules for this are thesame as forlink text, except that (a) animage description starts with![ rather than[, and(b) an image description may contain links.An image description has inline elementsas its contents. When an image is rendered to HTML,this is standardly used as the image’salt attribute.
![foo*bar*][foo*bar*]:train.jpg"train&tracks"<p><imgsrc="train.jpg"alt="foobar"title="train&tracks"/></p>Though this spec is concerned with parsing, not rendering, it isrecommended that in rendering to HTML, only the plain string contentof theimage description be used. Note that inthe above example, the alt attribute’s value isfoo bar, notfoo [bar](/url) orfoo <a href="/url">bar</a>. Only the plain stringcontent is rendered, without formatting.
![foo*bar*][][foo*bar*]:train.jpg"train&tracks"<p><imgsrc="train.jpg"alt="foobar"title="train&tracks"/></p>![foo*bar*][foobar][FOOBAR]:train.jpg"train&tracks"<p><imgsrc="train.jpg"alt="foobar"title="train&tracks"/></p>My![foobar](/path/to/train.jpg"title")<p>My<imgsrc="/path/to/train.jpg"alt="foobar"title="title"/></p>Reference-style:
Collapsed:
The labels are case-insensitive:
As with reference links,whitespace is not allowedbetween the two sets of brackets:
Shortcut:
Note that link labels cannot contain unescaped brackets:
The link labels are case-insensitive:
If you just want a literal! followed by bracketed text, you canbackslash-escape the opening[:
If you want a link after a literal!, backslash-escape the!:
Autolinks are absolute URIs and email addresses inside< and>. They are parsed as links, with the URL or email addressas the link label.
AURI autolink consists of<, followed by anabsolute URI followed by>. It is parsed asa link to the URI, with the URI as the link’s label.
Anabsolute URI,for these purposes, consists of ascheme followed by a colon (:)followed by zero or more characters other than ASCIIwhitespace and control characters,<, and>. Ifthe URI includes these characters, they must be percent-encoded(e.g.%20 for a space).
For purposes of this spec, ascheme is any sequenceof 2–32 characters beginning with an ASCII letter and followedby any combination of ASCII letters, digits, or the symbols plus(“+”), period (“.”), or hyphen (“-”).
Here are some valid autolinks:
<http://foo.bar.baz/test?q=hello&id=22&boolean><p><ahref="http://foo.bar.baz/test?q=hello&id=22&boolean">http://foo.bar.baz/test?q=hello&id=22&boolean</a></p><irc://foo.bar:2233/baz><p><ahref="irc://foo.bar:2233/baz">irc://foo.bar:2233/baz</a></p>Uppercase is also fine:
Note that many strings that count asabsolute URIs forpurposes of this spec are not valid URIs, because theirschemes are not registered or because of other problemswith their syntax:
<made-up-scheme://foo,bar><p><ahref="made-up-scheme://foo,bar">made-up-scheme://foo,bar</a></p>Spaces are not allowed in autolinks:
Backslash-escapes do not work inside autolinks:
<http://example.com/\[\><p><ahref="http://example.com/%5C%5B%5C">http://example.com/\[\</a></p>Anemail autolinkconsists of<, followed by anemail address,followed by>. The link’s label is the email address,and the URL ismailto: followed by the email address.
Anemail address,for these purposes, is anything that matchesthenon-normative regex from the HTML5spec:
/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/Examples of email autolinks:
<foo+special@Bar.baz-bar0.com><p><ahref="mailto:foo+special@Bar.baz-bar0.com">foo+special@Bar.baz-bar0.com</a></p>Backslash-escapes do not work inside email autolinks:
These are not autolinks:
GFM enables theautolink extension, where autolinks will be recognised in agreater number of conditions.
Autolinks can also be constructed without requiring the use of< and to>to delimit them, although they will be recognized under a smaller set ofcircumstances. All such recognized autolinks can only come at the beginning ofa line, after whitespace, or any of the delimiting characters*,_,~,and(.
Anextended www autolink will be recognizedwhen the textwww. is found followed by avalid domain.Avalid domain consists of segmentsof alphanumeric characters, underscores (_) and hyphens (-)separated by periods (.).There must be at least one period,and no underscores may be present in the last two segments of the domain.
The schemehttp will be inserted automatically:
After avalid domain, zero or more non-space non-< characters may follow:
Visitwww.commonmark.org/helpformoreinformation.<p>Visit<ahref="http://www.commonmark.org/help">www.commonmark.org/help</a>formoreinformation.</p>We then applyextended autolink path validation as follows:
Trailing punctuation (specifically,?,!,.,,,:,*,_, and~)will not be considered part of the autolink, though they may be included in theinterior of the link:
Visitwww.commonmark.org.Visitwww.commonmark.org/a.b.<p>Visit<ahref="http://www.commonmark.org">www.commonmark.org</a>.</p><p>Visit<ahref="http://www.commonmark.org/a.b">www.commonmark.org/a.b</a>.</p>When an autolink ends in), we scan the entire autolink for the total numberof parentheses. If there is a greater number of closing parentheses thanopening ones, we don’t consider the unmatched trailing parentheses part of theautolink, in order to facilitate including an autolink inside a parenthesis:
www.google.com/search?q=Markup+(business)www.google.com/search?q=Markup+(business)))(www.google.com/search?q=Markup+(business))(www.google.com/search?q=Markup+(business)<p><ahref="http://www.google.com/search?q=Markup+(business)">www.google.com/search?q=Markup+(business)</a></p><p><ahref="http://www.google.com/search?q=Markup+(business)">www.google.com/search?q=Markup+(business)</a>))</p><p>(<ahref="http://www.google.com/search?q=Markup+(business)">www.google.com/search?q=Markup+(business)</a>)</p><p>(<ahref="http://www.google.com/search?q=Markup+(business)">www.google.com/search?q=Markup+(business)</a></p>This check is only done when the link ends in a closing parentheses), so ifthe only parentheses are in the interior of the autolink, no special rules areapplied:
www.google.com/search?q=(business))+ok<p><ahref="http://www.google.com/search?q=(business))+ok">www.google.com/search?q=(business))+ok</a></p>If an autolink ends in a semicolon (;), we check to see if it appears toresemble anentity reference; if the preceding text is&followed by one or more alphanumeric characters. If so, it is excluded fromthe autolink:
www.google.com/search?q=commonmark&hl=enwww.google.com/search?q=commonmark&hl;<p><ahref="http://www.google.com/search?q=commonmark&hl=en">www.google.com/search?q=commonmark&hl=en</a></p><p><ahref="http://www.google.com/search?q=commonmark">www.google.com/search?q=commonmark</a>&hl;</p>< immediately ends an autolink.
www.commonmark.org/he<lp<p><ahref="http://www.commonmark.org/he">www.commonmark.org/he</a><lp</p>Anextended url autolink will be recognised when one of the schemeshttp://, orhttps://, followed by avalid domain, then zero ormore non-space non-< characters according toextended autolink path validation:
http://commonmark.org(Visithttps://encrypted.google.com/search?q=Markup+(business))<p><ahref="http://commonmark.org">http://commonmark.org</a></p><p>(Visit<ahref="https://encrypted.google.com/search?q=Markup+(business)">https://encrypted.google.com/search?q=Markup+(business)</a>)</p>Anextended email autolink will be recognised when an email address isrecognised within any text node. Email addresses are recognised according tothe following rules:
.,-,_, or+.@ symbol.- or_,separated by periods (.).There must be at least one period.The last character must not be one of- or_.The schememailto: will automatically be added to the generated link:
+ can occur before the@, but not after.
hello@mail+xyz.exampleisn'tvalid,buthello+xyz@mail.exampleis.<p>hello@mail+xyz.exampleisn'tvalid,but<ahref="mailto:hello+xyz@mail.example">hello+xyz@mail.example</a>is.</p>.,-, and_ can occur on both sides of the@, but only. may occur atthe end of the email address, in which case it will not be considered part ofthe address:
a.b-c_d@a.ba.b-c_d@a.b.a.b-c_d@a.b-a.b-c_d@a.b_<p><ahref="mailto:a.b-c_d@a.b">a.b-c_d@a.b</a></p><p><ahref="mailto:a.b-c_d@a.b">a.b-c_d@a.b</a>.</p><p>a.b-c_d@a.b-</p><p>a.b-c_d@a.b_</p>Anextended protocol autolink will be recognised when a protocol isrecognised within any text node. Valid protocols are:
mailto:xmpp:The scheme of the protocol will automatically be added to the generated link.All the rules of email address autolinking apply.
mailto:foo@bar.bazmailto:a.b-c_d@a.bmailto:a.b-c_d@a.b.mailto:a.b-c_d@a.b/mailto:a.b-c_d@a.b-mailto:a.b-c_d@a.b_xmpp:foo@bar.bazxmpp:foo@bar.baz.<p><ahref="mailto:foo@bar.baz">mailto:foo@bar.baz</a></p><p><ahref="mailto:a.b-c_d@a.b">mailto:a.b-c_d@a.b</a></p><p><ahref="mailto:a.b-c_d@a.b">mailto:a.b-c_d@a.b</a>.</p><p><ahref="mailto:a.b-c_d@a.b">mailto:a.b-c_d@a.b</a>/</p><p>mailto:a.b-c_d@a.b-</p><p>mailto:a.b-c_d@a.b_</p><p><ahref="xmpp:foo@bar.baz">xmpp:foo@bar.baz</a></p><p><ahref="xmpp:foo@bar.baz">xmpp:foo@bar.baz</a>.</p>A described in thespecificationxmpp offers an optional/ followed by a resource. The resource can containall alphanumeric characters, as well as@ and..
xmpp:foo@bar.baz/txtxmpp:foo@bar.baz/txt@binxmpp:foo@bar.baz/txt@bin.com<p><ahref="xmpp:foo@bar.baz/txt">xmpp:foo@bar.baz/txt</a></p><p><ahref="xmpp:foo@bar.baz/txt@bin">xmpp:foo@bar.baz/txt@bin</a></p><p><ahref="xmpp:foo@bar.baz/txt@bin.com">xmpp:foo@bar.baz/txt@bin.com</a></p>Further/ characters are not considered part of the domain:
xmpp:foo@bar.baz/txt/bin<p><ahref="xmpp:foo@bar.baz/txt">xmpp:foo@bar.baz/txt</a>/bin</p>Text between< and> that looks like an HTML tag is parsed as araw HTML tag and will be rendered in HTML without escaping.Tag and attribute names are not limited to current HTML tags,so custom tags (and even, say, DocBook tags) may be used.
Here is the grammar for tags:
Atag name consists of an ASCII letterfollowed by zero or more ASCII letters, digits, orhyphens (-).
Anattribute consists ofwhitespace,anattribute name, and an optionalattribute value specification.
Anattribute nameconsists of an ASCII letter,_, or:, followed by zero or more ASCIIletters, digits,_,.,:, or-. (Note: This is the XMLspecification restricted to ASCII. HTML5 is laxer.)
Anattribute value specificationconsists of optionalwhitespace,a= character, optionalwhitespace, and anattributevalue.
Anattribute valueconsists of anunquoted attribute value,asingle-quoted attribute value, or adouble-quoted attribute value.
Anunquoted attribute valueis a nonempty string of characters notincludingwhitespace,",',=,<,>, or`.
Asingle-quoted attribute valueconsists of', zero or morecharacters not including', and a final'.
Adouble-quoted attribute valueconsists of", zero or morecharacters not including", and a final".
Anopen tag consists of a< character, atag name,zero or moreattributes, optionalwhitespace, an optional/character, and a> character.
Aclosing tag consists of the string</, atag name, optionalwhitespace, and the character>.
AnHTML comment consists of<!-- +text +-->,wheretext does not start with> or->, does not end with-,and does not contain--. (See theHTML5 spec.)
Aprocessing instructionconsists of the string<?, a stringof characters not including the string?>, and the string?>.
Adeclaration consists of thestring<!, a name consisting of one or more uppercase ASCII letters,whitespace, a string of characters not including thecharacter>, and the character>.
ACDATA section consists ofthe string<![CDATA[, a string of characters not including the string]]>, and the string]]>.
AnHTML tag consists of anopen tag, aclosing tag,anHTML comment, aprocessing instruction, adeclaration,or aCDATA section.
Here are some simple open tags:
Empty elements:
Whitespace is allowed:
With attributes:
<afoo="bar"bam='baz<em>"</em>'_booleanzoop:33=zoop:33/><p><afoo="bar"bam='baz<em>"</em>'_booleanzoop:33=zoop:33/></p>Custom tag names can be used:
Illegal tag names, not parsed as HTML:
Illegal attribute names:
Illegal attribute values:
Illegalwhitespace:
<a><foo><bar/><foobar=bazbim!bop/><p><a><foo><bar/><foobar=bazbim!bop/></p>Missingwhitespace:
Closing tags:
Illegal attributes in closing tag:
Comments:
Not comments:
Processing instructions:
Declarations:
CDATA sections:
Entity and numeric character references are preserved in HTMLattributes:
Backslash escapes do not work in HTML attributes:
GFM enables thetagfilter extension, where the following HTML tags will befiltered when rendering HTML output:
<title><textarea><style><xmp><iframe><noembed><noframes><script><plaintext>Filtering is done by replacing the leading< with the entity<. Thesetags are chosen in particular as they change how HTML is interpreted in a wayunique to them (i.e. nested HTML is interpreted differently), and this isusually undesireable in the context of other rendered Markdown content.
All other HTML tags are left untouched.
<strong><title><style><em><blockquote><xmp>isdisallowed.<XMP>isalsodisallowed.</blockquote><p><strong><title><style><em></p><blockquote><xmp>isdisallowed.<XMP>isalsodisallowed.</blockquote>A line break (not in a code span or HTML tag) that is precededby two or more spaces and does not occur at the end of a blockis parsed as ahard line break (renderedin HTML as a<br /> tag):
For a more visible alternative, a backslash before theline ending may be used instead of two spaces:
More than two spaces can be used:
Leading spaces at the beginning of the next line are ignored:
Line breaks can occur inside emphasis, links, and other constructsthat allow inline content:
Line breaks do not occur inside code spans
or HTML tags:
Hard line breaks are for separating inline content within a block.Neither syntax for hard line breaks works at the end of a paragraph orother block element:
A regular line break (not in a code span or HTML tag) that is notpreceded by two or more spaces or a backslash is parsed as asoftbreak. (A softbreak may be rendered in HTML either as aline ending or as a space. The result will be the same inbrowsers. In the examples here, aline ending will be used.)
Spaces at the end of the line and beginning of the next line areremoved:
A conforming parser may render a soft line break in HTML either as aline break or as a space.
A renderer may also provide an option to render soft line breaksas hard line breaks.
Any characters not given an interpretation by the above rules willbe parsed as plain textual content.
Internal spaces are preserved verbatim:
In this appendix we describe some features of the parsing strategyused in the CommonMark reference implementations.
Parsing has two phases:
In the first phase, lines of input are consumed and the blockstructure of the document—its division into paragraphs, block quotes,list items, and so on—is constructed. Text is assigned to theseblocks but not parsed. Link reference definitions are parsed and amap of links is constructed.
In the second phase, the raw text contents of paragraphs and headingsare parsed into sequences of Markdown inline elements (strings,code spans, links, emphasis, and so on), using the map of linkreferences constructed in phase 1.
At each point in processing, the document is represented as a tree ofblocks. The root of the tree is adocument block. Thedocumentmay have any number of other blocks aschildren. These childrenmay, in turn, have other blocks as children. The last child of a blockis normally consideredopen, meaning that subsequent lines of inputcan alter its contents. (Blocks that are not open areclosed.)Here, for example, is a possible document tree, with the open blocksmarked by arrows:
-> document -> block_quote paragraph "Lorem ipsum dolor\nsit amet." -> list (type=bullet tight=true bullet_char=-) list_item paragraph "Qui *quodsi iracundia*" -> list_item -> paragraph "aliquando id"Each line that is processed has an effect on this tree. The line isanalyzed and, depending on its contents, the document may be alteredin one or more of the following ways:
Once a line has been incorporated into the tree in this way,it can be discarded, so input can be read in a stream.
For each line, we follow this procedure:
First we iterate through the open blocks, starting with theroot document, and descending through last children down to the lastopen block. Each block imposes a condition that the line must satisfyif the block is to remain open. For example, a block quote requires a> character. A paragraph requires a non-blank line.In this phase we may match all or just some of the openblocks. But we cannot close unmatched blocks yet, because we may have alazy continuation line.
Next, after consuming the continuation markers for existingblocks, we look for new block starts (e.g.> for a block quote).If we encounter a new block start, we close any blocks unmatchedin step 1 before creating the new block as a child of the lastmatched block.
Finally, we look at the remainder of the line (after blockmarkers like>, list markers, and indentation have been consumed).This is text that can be incorporated into the last openblock (a paragraph, code block, heading, or raw HTML).
Setext headings are formed when we see a line of a paragraphthat is asetext heading underline.
Reference link definitions are detected when a paragraph is closed;the accumulated text lines are parsed to see if they begin withone or more reference link definitions. Any remainder becomes anormal paragraph.
We can see how this works by considering how the tree above isgenerated by four lines of Markdown:
> Lorem ipsum dolorsit amet.> - Qui *quodsi iracundia*> - aliquando idAt the outset, our document model is just
-> documentThe first line of our text,
> Lorem ipsum dolorcauses ablock_quote block to be created as a child of ouropendocument block, and aparagraph block as a child oftheblock_quote. Then the text is added to the last openblock, theparagraph:
-> document -> block_quote -> paragraph "Lorem ipsum dolor"The next line,
sit amet.is a “lazy continuation” of the openparagraph, so it gets addedto the paragraph’s text:
-> document -> block_quote -> paragraph "Lorem ipsum dolor\nsit amet."The third line,
> - Qui *quodsi iracundia*causes theparagraph block to be closed, and a newlist blockopened as a child of theblock_quote. Alist_item is alsoadded as a child of thelist, and aparagraph as a child ofthelist_item. The text is then added to the newparagraph:
-> document -> block_quote paragraph "Lorem ipsum dolor\nsit amet." -> list (type=bullet tight=true bullet_char=-) -> list_item -> paragraph "Qui *quodsi iracundia*"The fourth line,
> - aliquando idcauses thelist_item (and its child theparagraph) to be closed,and a newlist_item opened up as child of thelist. Aparagraphis added as a child of the newlist_item, to contain the text.We thus obtain the final tree:
-> document -> block_quote paragraph "Lorem ipsum dolor\nsit amet." -> list (type=bullet tight=true bullet_char=-) list_item paragraph "Qui *quodsi iracundia*" -> list_item -> paragraph "aliquando id"Once all of the input has been parsed, all open blocks are closed.
We then “walk the tree,” visiting every node, and parse rawstring contents of paragraphs and headings as inlines. At thispoint we have seen all the link reference definitions, so we canresolve reference links as we go.
document block_quote paragraph str "Lorem ipsum dolor" softbreak str "sit amet." list (type=bullet tight=true bullet_char=-) list_item paragraph str "Qui " emph str "quodsi iracundia" list_item paragraph str "aliquando id"Notice how theline ending in the first paragraph hasbeen parsed as asoftbreak, and the asterisks in the first list itemhave become anemph.
By far the trickiest part of inline parsing is handling emphasis,strong emphasis, links, and images. This is done using the followingalgorithm.
When we’re parsing inlines and we hit either
* or_ characters, or[ or![we insert a text node with these symbols as its literal content, and weadd a pointer to this text node to thedelimiter stack.
Thedelimiter stack is a doubly linked list. Eachelement contains a pointer to a text node, plus information about
[,![,*,_)When we hit a] character, we call thelook for link or imageprocedure (see below).
When we hit the end of the input, we call theprocess emphasisprocedure (see below), withstack_bottom = NULL.
Starting at the top of the delimiter stack, we look backwardsthrough the stack for an opening[ or![ delimiter.
If we don’t find one, we return a literal text node].
If we do find one, but it’s notactive, we remove the inactivedelimiter from the stack, and return a literal text node].
If we find one and it’s active, then we parse ahead to see ifwe have an inline link/image, reference link/image, compact referencelink/image, or shortcut reference link/image.
If we don’t, then we remove the opening delimiter from thedelimiter stack and return a literal text node].
If we do, then
We return a link or image node whose children are the inlinesafter the text node pointed to by the opening delimiter.
We runprocess emphasis on these inlines, with the[ openerasstack_bottom.
We remove the opening delimiter.
If we have a link (and not an image), we also set all[ delimiters before the opening delimiter toinactive. (Thiswill prevent us from getting links within links.)
Parameterstack_bottom sets a lower bound to how far wedescend in thedelimiter stack. If it is NULL, we cango all the way to the bottom. Otherwise, we stop beforevisitingstack_bottom.
Letcurrent_position point to the element on thedelimiter stackjust abovestack_bottom (or the first element ifstack_bottomis NULL).
We keep track of theopeners_bottom for each delimitertype (*,_) and each length of the closing delimiter run(modulo 3). Initialize this tostack_bottom.
Then we repeat the following until we run out of potentialclosers:
Movecurrent_position forward in the delimiter stack (if needed)until we find the first potential closer with delimiter* or_.(This will be the potential closer closestto the beginning of the input – the first one in parse order.)
Now, look back in the stack (staying abovestack_bottom andtheopeners_bottom for this delimiter type) for thefirst matching potential opener (“matching” means same delimiter).
If one is found:
Figure out whether we have emphasis or strong emphasis:if both closer and opener spans have length >= 2, we havestrong, otherwise regular.
Insert an emph or strong emph node accordingly, afterthe text node corresponding to the opener.
Remove any delimiters between the opener and closer fromthe delimiter stack.
Remove 1 (for regular emph) or 2 (for strong emph) delimitersfrom the opening and closing text nodes. If they become emptyas a result, remove them and remove the corresponding elementof the delimiter stack. If the closing node is removed, resetcurrent_position to the next element in the stack.
If none is found:
Setopeners_bottom to the element beforecurrent_position.(We know that there are no openers for this kind of closer up to andincluding this point, so this puts a lower bound on future searches.)
If the closer atcurrent_position is not a potential opener,remove it from the delimiter stack (since we know it can’tbe a closer either).
Advancecurrent_position to the next element in the stack.
After we’re done, we remove all delimiters abovestack_bottom from thedelimiter stack.