From bfc36d31bde169062e74403fd2837963e63f5eaf Mon Sep 17 00:00:00 2001 From: Matthias Dittrich Date: Wed, 30 Dec 2015 00:19:53 +0100 Subject: [PATCH] add a bit of documentation and remove some stale files. --- docs/content/development.md | 23 + tests/commonmark_spec.htm | 8540 ----------------------------------- tests/commonmark_spec_tests | 3024 ------------- 3 files changed, 23 insertions(+), 11564 deletions(-) create mode 100644 docs/content/development.md delete mode 100644 tests/commonmark_spec.htm delete mode 100644 tests/commonmark_spec_tests diff --git a/docs/content/development.md b/docs/content/development.md new file mode 100644 index 000000000..d18542fd1 --- /dev/null +++ b/docs/content/development.md @@ -0,0 +1,23 @@ +F# Formatting: Development Topics +================================== + +Improve Common-Mark Test Coverage +---------------- +See https://github.com/tpetricek/FSharp.Formatting/pull/343 + +Update Common-Mark Test Suite +---------------- + + ./build.sh CreateTestJson + git add -A + git commit -m "Update Common-Mark test suite" + +More information +---------------- + +The project is hosted on [GitHub](https://github.com/tpetricek/FSharp.Formatting) where you can +[report issues](https://github.com/tpetricek/FSharp.Formatting/issues), fork the project and submit pull requests. +Thanks to [Gustavo Guerra](https://github.com/ovatsus) for a great build script and +[Steffen Forkmann](https://github.com/forki) for the great build tool [FAKE](https://github.com/fsharp/FAKE). +The library is available under Apache 2.0. For more information see the +[License file](https://github.com/tpetricek/FSharp.Formatting/blob/master/LICENSE.md) in the GitHub repository. diff --git a/tests/commonmark_spec.htm b/tests/commonmark_spec.htm deleted file mode 100644 index b883b5a23..000000000 --- a/tests/commonmark_spec.htm +++ /dev/null @@ -1,8540 +0,0 @@ - - - - -CommonMark Spec - - - - - -

CommonMark Spec

-
Version 0.22 (2015-08-23)
-
- John MacFarlane -
-
-Creative - Commons BY-SA
CommonMark Spec by - John MacFarlane is licensed under a - Creative - Commons Attribution-ShareAlike 4.0 International License. -
-
-
- -
-

1 Introduction

-

1.1 What is Markdown?

-

Markdown is a plain text format for writing structured documents, -based on conventions used for indicating formatting in email and -usenet posts. It was developed in 2004 by John Gruber, who wrote -the first Markdown-to-HTML converter in perl, and it soon became -widely used in websites. By 2014 there were dozens of -implementations in many languages. Some of them extended basic -Markdown syntax with conventions for footnotes, definition lists, -tables, and other constructs, and some allowed output not just in -HTML but in LaTeX and many other formats.

-

1.2 Why is a spec needed?

-

John Gruber’s canonical description of Markdown’s -syntax -does not specify the syntax unambiguously. Here are some examples of -questions it does not answer:

-
    -
  1. -

    How much indentation is needed for a sublist? The spec says that -continuation paragraphs need to be indented four spaces, but is -not fully explicit about sublists. It is natural to think that -they, too, must be indented four spaces, but Markdown.pl does -not require that. This is hardly a “corner case,” and divergences -between implementations on this issue often lead to surprises for -users in real documents. (See this comment by John -Gruber.)

    -
    2. -
  2. -

    Is a blank line needed before a block quote or header? -Most implementations do not require the blank line. However, -this can lead to unexpected results in hard-wrapped text, and -also to ambiguities in parsing (note that some implementations -put the header inside the blockquote, while others do not). -(John Gruber has also spoken in favor of requiring the blank -lines.)

    -
    3. -
  3. -

    Is a blank line needed before an indented code block? -(Markdown.pl requires it, but this is not mentioned in the -documentation, and some implementations do not require it.)

    -
    paragraph
-    code?
-
    -
    4. -
  4. -

    What is the exact rule for determining when list items get -wrapped in <p> tags? Can a list be partially “loose” and partially -“tight”? What should we do with a list like this?

    -
    1. one
-
-2. two
-3. three
-
    -

    Or this?

    -
    1.  one
-    - a
-
-    - b
-2.  two
-
    -

    (There are some relevant comments by John Gruber -here.)

    -
    5. -
  5. -

    Can list markers be indented? Can ordered list markers be right-aligned?

    -
     8. item 1
- 9. item 2
-10. item 2a
-
    -
    6. -
  6. -

    Is this one list with a horizontal rule in its second item, -or two lists separated by a horizontal rule?

    -
    * a
-* * * * *
-* b
-
    -
    7. -
  7. -

    When list markers change from numbers to bullets, do we have -two lists or one? (The Markdown syntax description suggests two, -but the perl scripts and many other implementations produce one.)

    -
    1. fee
-2. fie
--  foe
--  fum
-
    -
    8. -
  8. -

    What are the precedence rules for the markers of inline structure? -For example, is the following a valid link, or does the code span -take precedence ?

    -
    [a backtick (`)](/url) and [another backtick (`)](/url).
-
    -
    9. -
  9. -

    What are the precedence rules for markers of emphasis and strong -emphasis? For example, how should the following be parsed?

    -
    *foo *bar* baz*
-
    -
    10. -
  10. -

    What are the precedence rules between block-level and inline-level -structure? For example, how should the following be parsed?

    -
    - `a long code span can contain a hyphen like this
-  - and it can screw things up`
-
    -
    11. -
  11. -

    Can list items include section headers? (Markdown.pl does not -allow this, but does allow blockquotes to include headers.)

    -
    - # Heading
-
    -
    12. -
  12. -

    Can list items be empty?

    -
    * a
-*
-* b
-
    -
    13. -
  13. -

    Can link references be defined inside block quotes or list items?

    -
    > Blockquote [foo].
->
-> [foo]: /url
-
    -
    14. -
  14. -

    If there are multiple definitions for the same reference, which takes -precedence?

    -
    [foo]: /url1
-[foo]: /url2
-
-[foo][]
-
    -
    15. -
-

In the absence of a spec, early implementers consulted Markdown.pl -to resolve these ambiguities. But Markdown.pl was quite buggy, and -gave manifestly bad results in many cases, so it was not a -satisfactory replacement for a spec.

-

Because there is no unambiguous spec, implementations have diverged -considerably. As a result, users are often surprised to find that -a document that renders one way on one system (say, a github wiki) -renders differently on another (say, converting to docbook using -pandoc). To make matters worse, because nothing in Markdown counts -as a “syntax error,” the divergence often isn’t discovered right away.

-

1.3 About this document

-

This document attempts to specify Markdown syntax unambiguously. -It contains many examples with side-by-side Markdown and -HTML. These are intended to double as conformance tests. An -accompanying script spec_tests.py can be used to run the tests -against any Markdown program:

-
python test/spec_tests.py --spec spec.txt --program PROGRAM
-
-

Since this document describes how Markdown is to be parsed into -an abstract syntax tree, it would have made sense to use an abstract -representation of the syntax tree instead of HTML. But HTML is capable -of representing the structural distinctions we need to make, and the -choice of HTML for the tests makes it possible to run the tests against -an implementation without writing an abstract syntax tree renderer.

-

This document is generated from a text file, spec.txt, written -in Markdown with a small extension for the side-by-side tests. -The script tools/makespec.py can be used to convert spec.txt into -HTML or CommonMark (which can then be converted into other formats).

-

In the examples, the → character is used to represent tabs.

-

2 Preliminaries

-

2.1 Characters and lines

-

Any sequence of characters is a valid CommonMark -document.

-

A character is a Unicode code point. Although some -code points (for example, combining accents) do not correspond to -characters in an intuitive sense, all code points count as characters -for purposes of this spec.

-

This spec does not specify an encoding; it thinks of lines as composed -of characters rather than bytes. A conforming parser may be limited -to a certain encoding.

-

A line is a sequence of zero or more characters -other than newline (U+000A) or carriage return (U+000D), -followed by a line ending or by the end of file.

-

A line ending is a newline (U+000A), a carriage return -(U+000D) not followed by a newline, or a carriage return and a -following newline.

-

A line containing no characters, or a line containing only spaces -(U+0020) or tabs (U+0009), is called a blank line.

-

The following definitions of character classes will be used in this spec:

-

A whitespace 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 more whitespace -characters.

-

A Unicode whitespace character is -any code point in the Unicode Zs class, or a tab (U+0009), -carriage return (U+000D), newline (U+000A), or form feed -(U+000C).

-

Unicode whitespace is a sequence of one -or more Unicode whitespace characters.

-

A space is U+0020.

-

A non-whitespace character is any character -that is not a whitespace character.

-

An ASCII punctuation character -is !, ", #, $, %, &, ', (, ), -*, +, ,, -, ., /, :, ;, <, =, >, ?, @, -[, \, ], ^, _, `, {, |, }, or ~.

-

A punctuation character is an ASCII -punctuation character or anything in -the Unicode classes Pc, Pd, Pe, Pf, Pi, Po, or Ps.

-

2.2 Tabs

-

Tabs in lines are not expanded to spaces. However, -in contexts where indentation is significant for the -document’s structure, tabs behave as if they were replaced -by spaces with a tab stop of 4 characters.

-
-
Example 1  (interact)
-
→foo→baz→→bim
-
-
<pre><code>foo→baz→→bim
-</code></pre>
-
-
-
-
Example 2  (interact)
-
  →foo→baz→→bim
-
-
<pre><code>foo→baz→→bim
-</code></pre>
-
-
-
-
Example 3  (interact)
-
    a→a
-    ὐ→a
-
-
<pre><code>a→a
-ὐ→a
-</code></pre>
-
-
-
-
Example 4  (interact)
-
  - foo
-
-→bar
-
-
<ul>
-<li>
-<p>foo</p>
-<p>bar</p>
-</li>
-</ul>
-
-
-
-
Example 5  (interact)
-
>→foo→bar
-
-
<blockquote>
-<p>foo→bar</p>
-</blockquote>
-
-
-
-
Example 6  (interact)
-
    foo
-→bar
-
-
<pre><code>foo
-bar
-</code></pre>
-
-
-

2.3 Insecure characters

-

For security reasons, the Unicode character U+0000 must be replaced -with the replacement character (U+FFFD).

-

3 Blocks and inlines

-

We can think of a document as a sequence of -blocks—structural elements like paragraphs, block -quotations, lists, headers, rules, and code blocks. Some blocks (like -block quotes and list items) contain other blocks; others (like -headers and paragraphs) contain inline content—text, -links, emphasized text, images, code, and so on.

-

3.1 Precedence

-

Indicators of block structure always take precedence over indicators -of inline structure. So, for example, the following is a list with -two items, not a list with one item containing a code span:

-
-
Example 7  (interact)
-
- `one
-- two`
-
-
<ul>
-<li>`one</li>
-<li>two`</li>
-</ul>
-
-
-

This means that parsing can proceed in two steps: first, the block -structure of the document can be discerned; second, text lines inside -paragraphs, headers, and other block constructs can be parsed for inline -structure. The second step requires information about link reference -definitions that will be available only at the end of the first -step. Note that the first step requires processing lines in sequence, -but the second can be parallelized, since the inline parsing of -one block element does not affect the inline parsing of any other.

-

3.2 Container blocks and leaf blocks

-

We can divide blocks into two types: -container blocks, -which can contain other blocks, and leaf blocks, -which cannot.

-

4 Leaf blocks

-

This section describes the different kinds of leaf block that make up a -Markdown document.

-

4.1 Horizontal rules

-

A line consisting of 0-3 spaces of indentation, followed by a sequence -of three or more matching -, _, or * characters, each followed -optionally by any number of spaces, forms a -horizontal rule.

-
-
Example 8  (interact)
-
***
----
-___
-
-
<hr />
-<hr />
-<hr />
-
-
-

Wrong characters:

-
-
Example 9  (interact)
-
+++
-
-
<p>+++</p>
-
-
-
-
Example 10  (interact)
-
===
-
-
<p>===</p>
-
-
-

Not enough characters:

-
-
Example 11  (interact)
-
--
-**
-__
-
-
<p>--
-**
-__</p>
-
-
-

One to three spaces indent are allowed:

-
-
Example 12  (interact)
-
 ***
-  ***
-   ***
-
-
<hr />
-<hr />
-<hr />
-
-
-

Four spaces is too many:

-
-
Example 13  (interact)
-
    ***
-
-
<pre><code>***
-</code></pre>
-
-
-
-
Example 14  (interact)
-
Foo
-    ***
-
-
<p>Foo
-***</p>
-
-
-

More than three characters may be used:

-
-
Example 15  (interact)
-
_____________________________________
-
-
<hr />
-
-
-

Spaces are allowed between the characters:

-
-
Example 16  (interact)
-
 - - -
-
-
<hr />
-
-
-
-
Example 17  (interact)
-
 **  * ** * ** * **
-
-
<hr />
-
-
-
-
Example 18  (interact)
-
-     -      -      -
-
-
<hr />
-
-
-

Spaces are allowed at the end:

-
-
Example 19  (interact)
-
- - - -    
-
-
<hr />
-
-
-

However, no other characters may occur in the line:

-
-
Example 20  (interact)
-
_ _ _ _ a
-
-a------
-
----a---
-
-
<p>_ _ _ _ a</p>
-<p>a------</p>
-<p>---a---</p>
-
-
-

It is required that all of the non-whitespace characters be the same. -So, this is not a horizontal rule:

-
-
Example 21  (interact)
-
 *-*
-
-
<p><em>-</em></p>
-
-
-

Horizontal rules do not need blank lines before or after:

-
-
Example 22  (interact)
-
- foo
-***
-- bar
-
-
<ul>
-<li>foo</li>
-</ul>
-<hr />
-<ul>
-<li>bar</li>
-</ul>
-
-
-

Horizontal rules can interrupt a paragraph:

-
-
Example 23  (interact)
-
Foo
-***
-bar
-
-
<p>Foo</p>
-<hr />
-<p>bar</p>
-
-
-

If a line of dashes that meets the above conditions for being a -horizontal rule could also be interpreted as the underline of a setext -header, the interpretation as a -setext header takes precedence. Thus, for example, -this is a setext header, not a paragraph followed by a horizontal rule:

-
-
Example 24  (interact)
-
Foo
----
-bar
-
-
<h2>Foo</h2>
-<p>bar</p>
-
-
-

When both a horizontal rule and a list item are possible -interpretations of a line, the horizontal rule takes precedence:

-
-
Example 25  (interact)
-
* Foo
-* * *
-* Bar
-
-
<ul>
-<li>Foo</li>
-</ul>
-<hr />
-<ul>
-<li>Bar</li>
-</ul>
-
-
-

If you want a horizontal rule in a list item, use a different bullet:

-
-
Example 26  (interact)
-
- Foo
-- * * *
-
-
<ul>
-<li>Foo</li>
-<li>
-<hr />
-</li>
-</ul>
-
-
-

4.2 ATX headers

-

An ATX header -consists of a string of characters, parsed as inline content, between an -opening sequence of 1–6 unescaped # characters and an optional -closing sequence of any number of unescaped # characters. -The opening sequence of # characters cannot be followed directly by a -non-whitespace character. The optional closing sequence of #s must be -preceded by a space and may be followed by spaces only. The opening -# character may be indented 0-3 spaces. The raw contents of the -header are stripped of leading and trailing spaces before being parsed -as inline content. The header level is equal to the number of # -characters in the opening sequence.

-

Simple headers:

-
-
Example 27  (interact)
-
# 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 header:

-
-
Example 28  (interact)
-
####### foo
-
-
<p>####### foo</p>
-
-
-

At least one space is required between the # characters and the -header’s contents, unless the header is empty. Note that many -implementations currently do not require the space. However, the -space was required by the -original ATX implementation, -and it helps prevent things like the following from being parsed as -headers:

-
-
Example 29  (interact)
-
#5 bolt
-
-#foobar
-
-
<p>#5 bolt</p>
-<p>#foobar</p>
-
-
-

This is not a header, because the first # is escaped:

-
-
Example 30  (interact)
-
\## foo
-
-
<p>## foo</p>
-
-
-

Contents are parsed as inlines:

-
-
Example 31  (interact)
-
# foo *bar* \*baz\*
-
-
<h1>foo <em>bar</em> *baz*</h1>
-
-
-

Leading and trailing blanks are ignored in parsing inline content:

-
-
Example 32  (interact)
-
#                  foo                     
-
-
<h1>foo</h1>
-
-
-

One to three spaces indentation are allowed:

-
-
Example 33  (interact)
-
 ### foo
-  ## foo
-   # foo
-
-
<h3>foo</h3>
-<h2>foo</h2>
-<h1>foo</h1>
-
-
-

Four spaces are too much:

-
-
Example 34  (interact)
-
    # foo
-
-
<pre><code># foo
-</code></pre>
-
-
-
-
Example 35  (interact)
-
foo
-    # bar
-
-
<p>foo
-# bar</p>
-
-
-

A closing sequence of # characters is optional:

-
-
Example 36  (interact)
-
## foo ##
-  ###   bar    ###
-
-
<h2>foo</h2>
-<h3>bar</h3>
-
-
-

It need not be the same length as the opening sequence:

-
-
Example 37  (interact)
-
# foo ##################################
-##### foo ##
-
-
<h1>foo</h1>
-<h5>foo</h5>
-
-
-

Spaces are allowed after the closing sequence:

-
-
Example 38  (interact)
-
### foo ###     
-
-
<h3>foo</h3>
-
-
-

A sequence of # characters with anything but spaces following it -is not a closing sequence, but counts as part of the contents of the -header:

-
-
Example 39  (interact)
-
### foo ### b
-
-
<h3>foo ### b</h3>
-
-
-

The closing sequence must be preceded by a space:

-
-
Example 40  (interact)
-
# foo#
-
-
<h1>foo#</h1>
-
-
-

Backslash-escaped # characters do not count as part -of the closing sequence:

-
-
Example 41  (interact)
-
### foo \###
-## foo #\##
-# foo \#
-
-
<h3>foo ###</h3>
-<h2>foo ###</h2>
-<h1>foo #</h1>
-
-
-

ATX headers need not be separated from surrounding content by blank -lines, and they can interrupt paragraphs:

-
-
Example 42  (interact)
-
****
-## foo
-****
-
-
<hr />
-<h2>foo</h2>
-<hr />
-
-
-
-
Example 43  (interact)
-
Foo bar
-# baz
-Bar foo
-
-
<p>Foo bar</p>
-<h1>baz</h1>
-<p>Bar foo</p>
-
-
-

ATX headers can be empty:

-
-
Example 44  (interact)
-
## 
-#
-### ###
-
-
<h2></h2>
-<h1></h1>
-<h3></h3>
-
-
-

4.3 Setext headers

-

A setext header -consists of a line of text, containing at least one non-whitespace character, -with no more than 3 spaces indentation, followed by a setext header -underline. The line of text must be -one that, were it not followed by the setext header underline, -would be interpreted as part of a paragraph: it cannot be -interpretable as a code fence, ATX header, -block quote, horizontal rule, -list item, or HTML block.

-

A setext header underline is a sequence of -= characters or a sequence of - characters, with no more than 3 -spaces indentation and any number of trailing spaces. If a line -containing a single - can be interpreted as an -empty list items, it should be interpreted this way -and not as a setext header underline.

-

The header is a level 1 header if = characters are used in the -setext header underline, and a level 2 -header if - characters are used. The contents of the header are the -result of parsing the first line as Markdown inline content.

-

In general, a setext header need not be preceded or followed by a -blank line. However, it cannot interrupt a paragraph, so when a -setext header comes after a paragraph, a blank line is needed between -them.

-

Simple examples:

-
-
Example 45  (interact)
-
Foo *bar*
-=========
-
-Foo *bar*
----------
-
-
<h1>Foo <em>bar</em></h1>
-<h2>Foo <em>bar</em></h2>
-
-
-

The underlining can be any length:

-
-
Example 46  (interact)
-
Foo
--------------------------
-
-Foo
-=
-
-
<h2>Foo</h2>
-<h1>Foo</h1>
-
-
-

The header content can be indented up to three spaces, and need -not line up with the underlining:

-
-
Example 47  (interact)
-
   Foo
----
-
-  Foo
------
-
-  Foo
-  ===
-
-
<h2>Foo</h2>
-<h2>Foo</h2>
-<h1>Foo</h1>
-
-
-

Four spaces indent is too much:

-
-
Example 48  (interact)
-
    Foo
-    ---
-
-    Foo
----
-
-
<pre><code>Foo
----
-
-Foo
-</code></pre>
-<hr />
-
-
-

The setext header underline can be indented up to three spaces, and -may have trailing spaces:

-
-
Example 49  (interact)
-
Foo
-   ----      
-
-
<h2>Foo</h2>
-
-
-

Four spaces is too much:

-
-
Example 50  (interact)
-
Foo
-    ---
-
-
<p>Foo
----</p>
-
-
-

The setext header underline cannot contain internal spaces:

-
-
Example 51  (interact)
-
Foo
-= =
-
-Foo
---- -
-
-
<p>Foo
-= =</p>
-<p>Foo</p>
-<hr />
-
-
-

Trailing spaces in the content line do not cause a line break:

-
-
Example 52  (interact)
-
Foo  
------
-
-
<h2>Foo</h2>
-
-
-

Nor does a backslash at the end:

-
-
Example 53  (interact)
-
Foo\
-----
-
-
<h2>Foo\</h2>
-
-
-

Since indicators of block structure take precedence over -indicators of inline structure, the following are setext headers:

-
-
Example 54  (interact)
-
`Foo
-----
-`
-
-<a title="a lot
----
-of dashes"/>
-
-
<h2>`Foo</h2>
-<p>`</p>
-<h2>&lt;a title=&quot;a lot</h2>
-<p>of dashes&quot;/&gt;</p>
-
-
-

The setext header underline cannot be a lazy continuation -line in a list item or block quote:

-
-
Example 55  (interact)
-
> Foo
----
-
-
<blockquote>
-<p>Foo</p>
-</blockquote>
-<hr />
-
-
-
-
Example 56  (interact)
-
- Foo
----
-
-
<ul>
-<li>Foo</li>
-</ul>
-<hr />
-
-
-

A setext header cannot interrupt a paragraph:

-
-
Example 57  (interact)
-
Foo
-Bar
----
-
-Foo
-Bar
-===
-
-
<p>Foo
-Bar</p>
-<hr />
-<p>Foo
-Bar
-===</p>
-
-
-

But in general a blank line is not required before or after:

-
-
Example 58  (interact)
-
---
-Foo
----
-Bar
----
-Baz
-
-
<hr />
-<h2>Foo</h2>
-<h2>Bar</h2>
-<p>Baz</p>
-
-
-

Setext headers cannot be empty:

-
-
Example 59  (interact)
-

-====
-
-
<p>====</p>
-
-
-

Setext header text lines must not be interpretable as block -constructs other than paragraphs. So, the line of dashes -in these examples gets interpreted as a horizontal rule:

-
-
Example 60  (interact)
-
---
----
-
-
<hr />
-<hr />
-
-
-
-
Example 61  (interact)
-
- foo
------
-
-
<ul>
-<li>foo</li>
-</ul>
-<hr />
-
-
-
-
Example 62  (interact)
-
    foo
----
-
-
<pre><code>foo
-</code></pre>
-<hr />
-
-
-
-
Example 63  (interact)
-
> foo
------
-
-
<blockquote>
-<p>foo</p>
-</blockquote>
-<hr />
-
-
-

If you want a header with > foo as its literal text, you can -use backslash escapes:

-
-
Example 64  (interact)
-
\> foo
-------
-
-
<h2>&gt; foo</h2>
-
-
-

4.4 Indented code blocks

-

An indented code block is composed of one or more -indented chunks separated by blank lines. -An indented chunk is a sequence of non-blank lines, -each indented four or more spaces. The contents of the code block are -the literal contents of the lines, including trailing -line endings, minus four spaces of indentation. -An indented code block has no info string.

-

An indented code block cannot interrupt a paragraph, so there must be -a blank line between a paragraph and a following indented code block. -(A blank line is not needed, however, between a code block and a following -paragraph.)

-
-
Example 65  (interact)
-
    a simple
-      indented code block
-
-
<pre><code>a simple
-  indented code block
-</code></pre>
-
-
-

If there is any ambiguity between an interpretation of indentation -as a code block and as indicating that material belongs to a list -item, the list item interpretation takes precedence:

-
-
Example 66  (interact)
-
  - foo
-
-    bar
-
-
<ul>
-<li>
-<p>foo</p>
-<p>bar</p>
-</li>
-</ul>
-
-
-
-
Example 67  (interact)
-
1.  foo
-
-    - bar
-
-
<ol>
-<li>
-<p>foo</p>
-<ul>
-<li>bar</li>
-</ul>
-</li>
-</ol>
-
-
-

The contents of a code block are literal text, and do not get parsed -as Markdown:

-
-
Example 68  (interact)
-
    <a/>
-    *hi*
-
-    - one
-
-
<pre><code>&lt;a/&gt;
-*hi*
-
-- one
-</code></pre>
-
-
-

Here we have three chunks separated by blank lines:

-
-
Example 69  (interact)
-
    chunk1
-
-    chunk2
-  
- 
- 
-    chunk3
-
-
<pre><code>chunk1
-
-chunk2
-
-
-
-chunk3
-</code></pre>
-
-
-

Any initial spaces beyond four will be included in the content, even -in interior blank lines:

-
-
Example 70  (interact)
-
    chunk1
-      
-      chunk2
-
-
<pre><code>chunk1
-  
-  chunk2
-</code></pre>
-
-
-

An indented code block cannot interrupt a paragraph. (This -allows hanging indents and the like.)

-
-
Example 71  (interact)
-
Foo
-    bar
-
-
-
<p>Foo
-bar</p>
-
-
-

However, any non-blank line with fewer than four leading spaces ends -the code block immediately. So a paragraph may occur immediately -after indented code:

-
-
Example 72  (interact)
-
    foo
-bar
-
-
<pre><code>foo
-</code></pre>
-<p>bar</p>
-
-
-

And indented code can occur immediately before and after other kinds of -blocks:

-
-
Example 73  (interact)
-
# Header
-    foo
-Header
-------
-    foo
-----
-
-
<h1>Header</h1>
-<pre><code>foo
-</code></pre>
-<h2>Header</h2>
-<pre><code>foo
-</code></pre>
-<hr />
-
-
-

The first line can be indented more than four spaces:

-
-
Example 74  (interact)
-
        foo
-    bar
-
-
<pre><code>    foo
-bar
-</code></pre>
-
-
-

Blank lines preceding or following an indented code block -are not included in it:

-
-
Example 75  (interact)
-

-    
-    foo
-    
-
-
-
<pre><code>foo
-</code></pre>
-
-
-

Trailing spaces are included in the code block’s content:

-
-
Example 76  (interact)
-
    foo  
-
-
<pre><code>foo  
-</code></pre>
-
-
-

4.5 Fenced code blocks

-

A code fence is a sequence -of at least three consecutive backtick characters (`) or -tildes (~). (Tildes and backticks cannot be mixed.) -A fenced code block -begins with a code fence, indented no more than three spaces.

-

The line with the opening code fence may optionally contain some text -following the code fence; this is trimmed of leading and trailing -spaces and called the info string. -The info string may not contain any backtick -characters. (The reason for this restriction is that otherwise -some inline code would be incorrectly interpreted as the -beginning of a fenced code block.)

-

The content of the code block consists of all subsequent lines, until -a closing code fence of the same type as the code block -began with (backticks or tildes), and with at least as many backticks -or tildes as the opening code fence. If the leading code fence is -indented N spaces, then up to N spaces of indentation are removed from -each line of the content (if present). (If a content line is not -indented, it is preserved unchanged. If it is indented less than N -spaces, all of the indentation is removed.)

-

The closing code fence may be indented up to three spaces, and may be -followed only by spaces, which are ignored. If the end of the -containing block (or document) is reached and no closing code fence -has been found, the code block contains all of the lines after the -opening code fence until the end of the containing block (or -document). (An alternative spec would require backtracking in the -event that a closing code fence is not found. But this makes parsing -much less efficient, and there seems to be no real down side to the -behavior described here.)

-

A fenced code block may interrupt a paragraph, and does not require -a blank line either before or after.

-

The content of a code fence is treated as literal text, not parsed -as inlines. The first word of the info string is typically used to -specify the language of the code sample, and rendered in the class -attribute of the code tag. However, this spec does not mandate any -particular treatment of the info string.

-

Here is a simple example with backticks:

-
-
Example 77  (interact)
-
```
-<
- >
-```
-
-
<pre><code>&lt;
- &gt;
-</code></pre>
-
-
-

With tildes:

-
-
Example 78  (interact)
-
~~~
-<
- >
-~~~
-
-
<pre><code>&lt;
- &gt;
-</code></pre>
-
-
-

The closing code fence must use the same character as the opening -fence:

-
-
Example 79  (interact)
-
```
-aaa
-~~~
-```
-
-
<pre><code>aaa
-~~~
-</code></pre>
-
-
-
-
Example 80  (interact)
-
~~~
-aaa
-```
-~~~
-
-
<pre><code>aaa
-```
-</code></pre>
-
-
-

The closing code fence must be at least as long as the opening fence:

-
-
Example 81  (interact)
-
````
-aaa
-```
-``````
-
-
<pre><code>aaa
-```
-</code></pre>
-
-
-
-
Example 82  (interact)
-
~~~~
-aaa
-~~~
-~~~~
-
-
<pre><code>aaa
-~~~
-</code></pre>
-
-
-

Unclosed code blocks are closed by the end of the document -(or the enclosing [block quote] or [list item]):

-
-
Example 83  (interact)
-
```
-
-
<pre><code></code></pre>
-
-
-
-
Example 84  (interact)
-
`````
-
-```
-aaa
-
-
<pre><code>
-```
-aaa
-</code></pre>
-
-
-
-
Example 85  (interact)
-
> ```
-> aaa
-
-bbb
-
-
<blockquote>
-<pre><code>aaa
-</code></pre>
-</blockquote>
-<p>bbb</p>
-
-
-

A code block can have all empty lines as its content:

-
-
Example 86  (interact)
-
```
-
-  
-```
-
-
<pre><code>
-  
-</code></pre>
-
-
-

A code block can be empty:

-
-
Example 87  (interact)
-
```
-```
-
-
<pre><code></code></pre>
-
-
-

Fences can be indented. If the opening fence is indented, -content lines will have equivalent opening indentation removed, -if present:

-
-
Example 88  (interact)
-
 ```
- aaa
-aaa
-```
-
-
<pre><code>aaa
-aaa
-</code></pre>
-
-
-
-
Example 89  (interact)
-
  ```
-aaa
-  aaa
-aaa
-  ```
-
-
<pre><code>aaa
-aaa
-aaa
-</code></pre>
-
-
-
-
Example 90  (interact)
-
   ```
-   aaa
-    aaa
-  aaa
-   ```
-
-
<pre><code>aaa
- aaa
-aaa
-</code></pre>
-
-
-

Four spaces indentation produces an indented code block:

-
-
Example 91  (interact)
-
    ```
-    aaa
-    ```
-
-
<pre><code>```
-aaa
-```
-</code></pre>
-
-
-

Closing fences may be indented by 0-3 spaces, and their indentation -need not match that of the opening fence:

-
-
Example 92  (interact)
-
```
-aaa
-  ```
-
-
<pre><code>aaa
-</code></pre>
-
-
-
-
Example 93  (interact)
-
   ```
-aaa
-  ```
-
-
<pre><code>aaa
-</code></pre>
-
-
-

This is not a closing fence, because it is indented 4 spaces:

-
-
Example 94  (interact)
-
```
-aaa
-    ```
-
-
<pre><code>aaa
-    ```
-</code></pre>
-
-
-

Code fences (opening and closing) cannot contain internal spaces:

-
-
Example 95  (interact)
-
``` ```
-aaa
-
-
<p><code></code>
-aaa</p>
-
-
-
-
Example 96  (interact)
-
~~~~~~
-aaa
-~~~ ~~
-
-
<pre><code>aaa
-~~~ ~~
-</code></pre>
-
-
-

Fenced code blocks can interrupt paragraphs, and can be followed -directly by paragraphs, without a blank line between:

-
-
Example 97  (interact)
-
foo
-```
-bar
-```
-baz
-
-
<p>foo</p>
-<pre><code>bar
-</code></pre>
-<p>baz</p>
-
-
-

Other blocks can also occur before and after fenced code blocks -without an intervening blank line:

-
-
Example 98  (interact)
-
foo
----
-~~~
-bar
-~~~
-# baz
-
-
<h2>foo</h2>
-<pre><code>bar
-</code></pre>
-<h1>baz</h1>
-
-
-

An info string can be provided after the opening code fence. -Opening and closing spaces will be stripped, and the first word, prefixed -with language-, is used as the value for the class attribute of the -code element within the enclosing pre element.

-
-
Example 99  (interact)
-
```ruby
-def foo(x)
-  return 3
-end
-```
-
-
<pre><code class="language-ruby">def foo(x)
-  return 3
-end
-</code></pre>
-
-
-
-
Example 100  (interact)
-
~~~~    ruby startline=3 $%@#$
-def foo(x)
-  return 3
-end
-~~~~~~~
-
-
<pre><code class="language-ruby">def foo(x)
-  return 3
-end
-</code></pre>
-
-
-
-
Example 101  (interact)
-
````;
-````
-
-
<pre><code class="language-;"></code></pre>
-
-
-

Info strings for backtick code blocks cannot contain backticks:

-
-
Example 102  (interact)
-
``` aa ```
-foo
-
-
<p><code>aa</code>
-foo</p>
-
-
-

Closing code fences cannot have info strings:

-
-
Example 103  (interact)
-
```
-``` aaa
-```
-
-
<pre><code>``` aaa
-</code></pre>
-
-
-

4.6 HTML blocks

-

An HTML block is a group of lines that is treated -as raw HTML (and will not be escaped in HTML output).

-

There are seven kinds of HTML block, which can be defined -by their start and end conditions. The block begins with a line that -meets a start condition (after up to three spaces -optional indentation). It ends with the first subsequent line that -meets a matching end condition, or the last line of -the document, if no line is encountered that meets the -end condition. If the first line meets both the start condition -and the end condition, the block will contain just that line.

-
    -
  1. -

    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; it -need not match the start tag).

    -
    2. -
  2. -

    Start condition: line begins with the string <!--.
    -End condition: line contains the string -->.

    -
    3. -
  3. -

    Start condition: line begins with the string <?.
    -End condition: line contains the string ?>.

    -
    4. -
  4. -

    Start condition: line begins with the string <! -followed by an uppercase ASCII letter.
    -End condition: line contains the character >.

    -
    5. -
  5. -

    Start condition: line begins with the string -<![CDATA[.
    -End condition: line contains the string ]]>.

    -
    6. -
  6. -

    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, head, header, hr, -html, iframe, legend, li, link, main, menu, menuitem, -meta, nav, noframes, ol, optgroup, option, p, param, -section, source, summary, table, tbody, td, -tfoot, th, thead, title, tr, track, ul, followed -by whitespace, the end of the line, the string >, or -the string />.
    -End condition: line is followed by a blank line.

    -
    7. -
  7. -

    Start condition: line begins with a complete open tag -or closing tag (with any tag name other than script, -style, or pre) followed only by whitespace -or the end of the line.
    -End condition: line is followed by a blank line.

    -
    8. -
-

All types of HTML blocks except type 7 may interrupt -a paragraph. Blocks of type 7 may not interrupt a paragraph. -(This restriction is intended to prevent unwanted interpretation -of long tags inside a wrapped paragraph as starting HTML blocks.)

-

Some simple examples follow. Here are some basic HTML blocks -of type 6:

-
-
Example 104  (interact)
-
<table>
-  <tr>
-    <td>
-           hi
-    </td>
-  </tr>
-</table>
-
-okay.
-
-
<table>
-  <tr>
-    <td>
-           hi
-    </td>
-  </tr>
-</table>
-<p>okay.</p>
-
-
-
-
Example 105  (interact)
-
 <div>
-  *hello*
-         <foo><a>
-
-
 <div>
-  *hello*
-         <foo><a>
-
-
-

A block can also start with a closing tag:

-
-
Example 106  (interact)
-
</div>
-*foo*
-
-
</div>
-*foo*
-
-
-

Here we have two HTML blocks with a Markdown paragraph between them:

-
-
Example 107  (interact)
-
<DIV CLASS="foo">
-
-*Markdown*
-
-</DIV>
-
-
<DIV CLASS="foo">
-<p><em>Markdown</em></p>
-</DIV>
-
-
-

The tag on the first line can be partial, as long -as it is split where there would be whitespace:

-
-
Example 108  (interact)
-
<div id="foo"
-  class="bar">
-</div>
-
-
<div id="foo"
-  class="bar">
-</div>
-
-
-
-
Example 109  (interact)
-
<div id="foo" class="bar
-  baz">
-</div>
-
-
<div id="foo" class="bar
-  baz">
-</div>
-
-
-

An open tag need not be closed:

-
-
Example 110  (interact)
-
<div>
-*foo*
-
-*bar*
-
-
<div>
-*foo*
-<p><em>bar</em></p>
-
-
-

A partial tag need not even be completed (garbage -in, garbage out):

-
-
Example 111  (interact)
-
<div id="foo"
-*hi*
-
-
<div id="foo"
-*hi*
-
-
-
-
Example 112  (interact)
-
<div class
-foo
-
-
<div class
-foo
-
-
-

The initial tag doesn’t even need to be a valid -tag, as long as it starts like one:

-
-
Example 113  (interact)
-
<div *???-&&&-<---
-*foo*
-
-
<div *???-&&&-<---
-*foo*
-
-
-

In type 6 blocks, the initial tag need not be on a line by -itself:

-
-
Example 114  (interact)
-
<div><a href="bar">*foo*</a></div>
-
-
<div><a href="bar">*foo*</a></div>
-
-
-
-
Example 115  (interact)
-
<table><tr><td>
-foo
-</td></tr></table>
-
-
<table><tr><td>
-foo
-</td></tr></table>
-
-
-

Everything until the next blank line or end of document -gets included in the HTML block. So, in the following -example, what looks like a Markdown code block -is actually part of the HTML block, which continues until a blank -line or the end of the document is reached:

-
-
Example 116  (interact)
-
<div></div>
-``` c
-int x = 33;
-```
-
-
<div></div>
-``` c
-int x = 33;
-```
-
-
-

To start an HTML block with a tag that is not in the -list of block-level tags in (6), you must put the tag by -itself on the first line (and it must be complete):

-
-
Example 117  (interact)
-
<a href="foo">
-*bar*
-</a>
-
-
<a href="foo">
-*bar*
-</a>
-
-
-

In type 7 blocks, the tag name can be anything:

-
-
Example 118  (interact)
-
<Warning>
-*bar*
-</Warning>
-
-
<Warning>
-*bar*
-</Warning>
-
-
-
-
Example 119  (interact)
-
<i class="foo">
-*bar*
-</i>
-
-
<i class="foo">
-*bar*
-</i>
-
-
-
-
Example 120  (interact)
-
</ins>
-*bar*
-
-
</ins>
-*bar*
-
-
-

These rules are designed to allow us to work with tags that -can 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 raw -HTML block, because the <del> tag is on a line by itself:

-
-
Example 121  (interact)
-
<del>
-*foo*
-</del>
-
-
<del>
-*foo*
-</del>
-
-
-

In this case, we get a raw HTML block that just includes -the <del> tag (because it ends with the following blank -line). So the contents get interpreted as CommonMark:

-
-
Example 122  (interact)
-
<del>
-
-*foo*
-
-</del>
-
-
<del>
-<p><em>foo</em></p>
-</del>
-
-
-

Finally, in this case, the <del> tags are interpreted -as raw HTML inside the CommonMark paragraph. (Because -the tag is not on a line by itself, we get inline HTML -rather than an HTML block.)

-
-
Example 123  (interact)
-
<del>*foo*</del>
-
-
<p><del><em>foo</em></del></p>
-
-
-

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 blocks -end at the first line containing a corresponding end tag. -As a result, these blocks can contain blank lines:

-

A pre tag (type 1):

-
-
Example 124  (interact)
-
<pre language="haskell"><code>
-import Text.HTML.TagSoup
-
-main :: IO ()
-main = print $ parseTags tags
-</code></pre>
-
-
<pre language="haskell"><code>
-import Text.HTML.TagSoup
-
-main :: IO ()
-main = print $ parseTags tags
-</code></pre>
-
-
-

A script tag (type 1):

-
-
Example 125  (interact)
-
<script type="text/javascript">
-// JavaScript example
-
-document.getElementById("demo").innerHTML = "Hello JavaScript!";
-</script>
-
-
<script type="text/javascript">
-// JavaScript example
-
-document.getElementById("demo").innerHTML = "Hello JavaScript!";
-</script>
-
-
-

A style tag (type 1):

-
-
Example 126  (interact)
-
<style
-  type="text/css">
-h1 {color:red;}
-
-p {color:blue;}
-</style>
-
-
<style
-  type="text/css">
-h1 {color:red;}
-
-p {color:blue;}
-</style>
-
-
-

If there is no matching end tag, the block will end at the -end of the document (or the enclosing [block quote] or -[list item]):

-
-
Example 127  (interact)
-
<style
-  type="text/css">
-
-foo
-
-
<style
-  type="text/css">
-
-foo
-
-
-
-
Example 128  (interact)
-
> <div>
-> foo
-
-bar
-
-
<blockquote>
-<div>
-foo
-</blockquote>
-<p>bar</p>
-
-
-
-
Example 129  (interact)
-
- <div>
-- foo
-
-
<ul>
-<li>
-<div>
-</li>
-<li>foo</li>
-</ul>
-
-
-

The end tag can occur on the same line as the start tag:

-
-
Example 130  (interact)
-
<style>p{color:red;}</style>
-*foo*
-
-
<style>p{color:red;}</style>
-<p><em>foo</em></p>
-
-
-
-
Example 131  (interact)
-
<!-- foo -->*bar*
-*baz*
-
-
<!-- foo -->*bar*
-<p><em>baz</em></p>
-
-
-

Note that anything on the last line after the -end tag will be included in the HTML block:

-
-
Example 132  (interact)
-
<script>
-foo
-</script>1. *bar*
-
-
<script>
-foo
-</script>1. *bar*
-
-
-

A comment (type 2):

-
-
Example 133  (interact)
-
<!-- Foo
-
-bar
-   baz -->
-
-
<!-- Foo
-
-bar
-   baz -->
-
-
-

A processing instruction (type 3):

-
-
Example 134  (interact)
-
<?php
-
-  echo '>';
-
-?>
-
-
<?php
-
-  echo '>';
-
-?>
-
-
-

A declaration (type 4):

-
-
Example 135  (interact)
-
<!DOCTYPE html>
-
-
<!DOCTYPE html>
-
-
-

CDATA (type 5):

-
-
Example 136  (interact)
-
<![CDATA[
-function matchwo(a,b)
-{
-  if (a < b && a < 0) then {
-    return 1;
-
-  } else {
-
-    return 0;
-  }
-}
-]]>
-
-
<![CDATA[
-function matchwo(a,b)
-{
-  if (a < b && a < 0) then {
-    return 1;
-
-  } else {
-
-    return 0;
-  }
-}
-]]>
-
-
-

The opening tag can be indented 1-3 spaces, but not 4:

-
-
Example 137  (interact)
-
  <!-- foo -->
-
-    <!-- foo -->
-
-
  <!-- foo -->
-<pre><code>&lt;!-- foo --&gt;
-</code></pre>
-
-
-
-
Example 138  (interact)
-
  <div>
-
-    <div>
-
-
  <div>
-<pre><code>&lt;div&gt;
-</code></pre>
-
-
-

An HTML block of types 1–6 can interrupt a paragraph, and need not be -preceded by a blank line.

-
-
Example 139  (interact)
-
Foo
-<div>
-bar
-</div>
-
-
<p>Foo</p>
-<div>
-bar
-</div>
-
-
-

However, a following blank line is needed, except at the end of -a document, and except for blocks of types 1–5, above:

-
-
Example 140  (interact)
-
<div>
-bar
-</div>
-*foo*
-
-
<div>
-bar
-</div>
-*foo*
-
-
-

HTML blocks of type 7 cannot interrupt a paragraph:

-
-
Example 141  (interact)
-
Foo
-<a href="bar">
-baz
-
-
<p>Foo
-<a href="bar">
-baz</p>
-
-
-

This rule differs from John Gruber’s original Markdown syntax -specification, which says:

-
-

The only restrictions are that block-level HTML elements — -e.g. <div>, <table>, <pre>, <p>, etc. — must be separated from -surrounding content by blank lines, and the start and end tags of the -block should not be indented with tabs or spaces.

-
-

In some ways Gruber’s rule is more restrictive than the one given -here:

- -

Most Markdown implementations (including some of Gruber’s own) do not -respect all of these restrictions.

-

There is one respect, however, in which Gruber’s rule is more liberal -than the one given here, since it allows blank lines to occur inside -an HTML block. There are two reasons for disallowing them here. -First, it removes the need to parse balanced tags, which is -expensive and can require backtracking from the end of the document -if no matching end tag is found. Second, it provides a very simple -and flexible way of including Markdown content inside HTML tags: -simply separate the Markdown from the HTML using blank lines:

-

Compare:

-
-
Example 142  (interact)
-
<div>
-
-*Emphasized* text.
-
-</div>
-
-
<div>
-<p><em>Emphasized</em> text.</p>
-</div>
-
-
-
-
Example 143  (interact)
-
<div>
-*Emphasized* text.
-</div>
-
-
<div>
-*Emphasized* text.
-</div>
-
-
-

Some Markdown implementations have adopted a convention of -interpreting content inside tags as text if the open tag has -the attribute markdown=1. The rule given above seems a simpler and -more elegant way of achieving the same expressive power, which is also -much simpler to parse.

-

The main potential drawback is that one can no longer paste HTML -blocks into Markdown documents with 100% reliability. However, -in most cases this will work fine, because the blank lines in -HTML are usually followed by HTML block tags. For example:

-
-
Example 144  (interact)
-
<table>
-
-<tr>
-
-<td>
-Hi
-</td>
-
-</tr>
-
-</table>
-
-
<table>
-<tr>
-<td>
-Hi
-</td>
-</tr>
-</table>
-
-
-

There are problems, however, if the inner tags are indented -and separated by spaces, as then they will be interpreted as -an indented code block:

-
-
Example 145  (interact)
-
<table>
-
-  <tr>
-
-    <td>
-      Hi
-    </td>
-
-  </tr>
-
-</table>
-
-
<table>
-  <tr>
-<pre><code>&lt;td&gt;
-  Hi
-&lt;/td&gt;
-</code></pre>
-  </tr>
-</table>
-
-
-

Fortunately, blank lines are usually not necessary and can be -deleted. The exception is inside <pre> tags, but as described -above, raw HTML blocks starting with <pre> can contain blank -lines.

-

4.7 Link reference definitions

-

A link reference definition -consists of a link label, indented up to three spaces, followed -by a colon (:), optional whitespace (including up to one -line ending), a link destination, -optional whitespace (including up to one -line ending), and an optional link -title, which if it is present must be separated -from the link destination by whitespace. -No further non-whitespace characters may occur on the line.

-

A link reference definition -does not correspond to a structural element of a document. Instead, it -defines a label which can be used in reference links -and reference-style images elsewhere in the document. Link -reference definitions can come either before or after the links that use -them.

-
-
Example 146  (interact)
-
[foo]: /url "title"
-
-[foo]
-
-
<p><a href="/url" title="title">foo</a></p>
-
-
-
-
Example 147  (interact)
-
   [foo]: 
-      /url  
-           'the title'  
-
-[foo]
-
-
<p><a href="/url" title="the title">foo</a></p>
-
-
-
-
Example 148  (interact)
-
[Foo*bar\]]:my_(url) 'title (with parens)'
-
-[Foo*bar\]]
-
-
<p><a href="my_(url)" title="title (with parens)">Foo*bar]</a></p>
-
-
-
-
Example 149  (interact)
-
[Foo bar]:
-<my url>
-'title'
-
-[Foo bar]
-
-
<p><a href="my%20url" title="title">Foo bar</a></p>
-
-
-

The title may extend over multiple lines:

-
-
Example 150  (interact)
-
[foo]: /url '
-title
-line1
-line2
-'
-
-[foo]
-
-
<p><a href="/url" title="
-title
-line1
-line2
-">foo</a></p>
-
-
-

However, it may not contain a blank line:

-
-
Example 151  (interact)
-
[foo]: /url 'title
-
-with blank line'
-
-[foo]
-
-
<p>[foo]: /url 'title</p>
-<p>with blank line'</p>
-<p>[foo]</p>
-
-
-

The title may be omitted:

-
-
Example 152  (interact)
-
[foo]:
-/url
-
-[foo]
-
-
<p><a href="/url">foo</a></p>
-
-
-

The link destination may not be omitted:

-
-
Example 153  (interact)
-
[foo]:
-
-[foo]
-
-
<p>[foo]:</p>
-<p>[foo]</p>
-
-
-

Both title and destination can contain backslash escapes -and literal backslashes:

-
-
Example 154  (interact)
-
[foo]: /url\bar\*baz "foo\"bar\baz"
-
-[foo]
-
-
<p><a href="/url%5Cbar*baz" title="foo&quot;bar\baz">foo</a></p>
-
-
-

A link can come before its corresponding definition:

-
-
Example 155  (interact)
-
[foo]
-
-[foo]: url
-
-
<p><a href="url">foo</a></p>
-
-
-

If there are several matching definitions, the first one takes -precedence:

-
-
Example 156  (interact)
-
[foo]
-
-[foo]: first
-[foo]: second
-
-
<p><a href="first">foo</a></p>
-
-
-

As noted in the section on Links, matching of labels is -case-insensitive (see matches).

-
-
Example 157  (interact)
-
[FOO]: /url
-
-[Foo]
-
-
<p><a href="/url">Foo</a></p>
-
-
-
-
Example 158  (interact)
-
[ΑΓΩ]: /φου
-
-[αγω]
-
-
<p><a href="/%CF%86%CE%BF%CF%85">αγω</a></p>
-
-
-

Here is a link reference definition with no corresponding link. -It contributes nothing to the document.

-
-
Example 159  (interact)
-
[foo]: /url
-
-
-
-

Here is another one:

-
-
Example 160  (interact)
-
[
-foo
-]: /url
-bar
-
-
<p>bar</p>
-
-
-

This is not a link reference definition, because there are -non-whitespace characters after the title:

-
-
Example 161  (interact)
-
[foo]: /url "title" ok
-
-
<p>[foo]: /url &quot;title&quot; ok</p>
-
-
-

This is a link reference definition, but it has no title:

-
-
Example 162  (interact)
-
[foo]: /url
-"title" ok
-
-
<p>&quot;title&quot; ok</p>
-
-
-

This is not a link reference definition, because it is indented -four spaces:

-
-
Example 163  (interact)
-
    [foo]: /url "title"
-
-[foo]
-
-
<pre><code>[foo]: /url &quot;title&quot;
-</code></pre>
-<p>[foo]</p>
-
-
-

This is not a link reference definition, because it occurs inside -a code block:

-
-
Example 164  (interact)
-
```
-[foo]: /url
-```
-
-[foo]
-
-
<pre><code>[foo]: /url
-</code></pre>
-<p>[foo]</p>
-
-
-

A link reference definition cannot interrupt a paragraph.

-
-
Example 165  (interact)
-
Foo
-[bar]: /baz
-
-[bar]
-
-
<p>Foo
-[bar]: /baz</p>
-<p>[bar]</p>
-
-
-

However, it can directly follow other block elements, such as headers -and horizontal rules, and it need not be followed by a blank line.

-
-
Example 166  (interact)
-
# [Foo]
-[foo]: /url
-> bar
-
-
<h1><a href="/url">Foo</a></h1>
-<blockquote>
-<p>bar</p>
-</blockquote>
-
-
-

Several link reference definitions -can occur one after another, without intervening blank lines.

-
-
Example 167  (interact)
-
[foo]: /foo-url "foo"
-[bar]: /bar-url
-  "bar"
-[baz]: /baz-url
-
-[foo],
-[bar],
-[baz]
-
-
<p><a href="/foo-url" title="foo">foo</a>,
-<a href="/bar-url" title="bar">bar</a>,
-<a href="/baz-url">baz</a></p>
-
-
-

Link reference definitions can occur -inside block containers, like lists and block quotations. They -affect the entire document, not just the container in which they -are defined:

-
-
Example 168  (interact)
-
[foo]
-
-> [foo]: /url
-
-
<p><a href="/url">foo</a></p>
-<blockquote>
-</blockquote>
-
-
-

4.8 Paragraphs

-

A sequence of non-blank lines that cannot be interpreted as other -kinds of blocks forms a paragraph. -The contents of the paragraph are the result of parsing the -paragraph’s raw content as inlines. The paragraph’s raw content -is formed by concatenating the lines and removing initial and final -whitespace.

-

A simple example with two paragraphs:

-
-
Example 169  (interact)
-
aaa
-
-bbb
-
-
<p>aaa</p>
-<p>bbb</p>
-
-
-

Paragraphs can contain multiple lines, but no blank lines:

-
-
Example 170  (interact)
-
aaa
-bbb
-
-ccc
-ddd
-
-
<p>aaa
-bbb</p>
-<p>ccc
-ddd</p>
-
-
-

Multiple blank lines between paragraph have no effect:

-
-
Example 171  (interact)
-
aaa
-
-
-bbb
-
-
<p>aaa</p>
-<p>bbb</p>
-
-
-

Leading spaces are skipped:

-
-
Example 172  (interact)
-
  aaa
- bbb
-
-
<p>aaa
-bbb</p>
-
-
-

Lines after the first may be indented any amount, since indented -code blocks cannot interrupt paragraphs.

-
-
Example 173  (interact)
-
aaa
-             bbb
-                                       ccc
-
-
<p>aaa
-bbb
-ccc</p>
-
-
-

However, the first line may be indented at most three spaces, -or an indented code block will be triggered:

-
-
Example 174  (interact)
-
   aaa
-bbb
-
-
<p>aaa
-bbb</p>
-
-
-
-
Example 175  (interact)
-
    aaa
-bbb
-
-
<pre><code>aaa
-</code></pre>
-<p>bbb</p>
-
-
-

Final spaces are stripped before inline parsing, so a paragraph -that ends with two or more spaces will not end with a hard line -break:

-
-
Example 176  (interact)
-
aaa     
-bbb     
-
-
<p>aaa<br />
-bbb</p>
-
-
-

4.9 Blank lines

-

Blank lines between block-level elements are ignored, -except for the role they play in determining whether a list -is tight or loose.

-

Blank lines at the beginning and end of the document are also ignored.

-
-
Example 177  (interact)
-
  
-
-aaa
-  
-
-# aaa
-
-  
-
-
<p>aaa</p>
-<h1>aaa</h1>
-
-
-

5 Container blocks

-

A container block is a block that has other -blocks as its contents. There are two basic kinds of container blocks: -block quotes and list items. -Lists are meta-containers for list items.

-

We define the syntax for container blocks recursively. The general -form of the definition is:

-
-

If X is a sequence of blocks, then the result of -transforming X in such-and-such a way is a container of type Y -with these blocks as its content.

-
-

So, we explain what counts as a block quote or list item by explaining -how these can be generated from their contents. This should suffice -to define the syntax, although it does not give a recipe for parsing -these constructions. (A recipe is provided below in the section entitled -A parsing strategy.)

-

5.1 Block quotes

-

A block quote marker -consists of 0-3 spaces of initial indent, plus (a) the character > together -with a following space, or (b) a single character > not followed by a space.

-

The following rules define block quotes:

-
    -
  1. -

    Basic case. If a string of lines Ls constitute a sequence -of blocks Bs, then the result of prepending a block quote -marker to the beginning of each line in Ls -is a block quote containing Bs.

    -
    2. -
  2. -

    Laziness. If a string of lines Ls constitute a block -quote with contents Bs, then the result of deleting -the initial block quote marker from one or -more lines in which the next non-whitespace character after the block -quote marker is paragraph continuation -text is a block quote with Bs as its content. -Paragraph continuation text is text -that will be parsed as part of the content of a paragraph, but does -not occur at the beginning of the paragraph.

    -
    3. -
  3. -

    Consecutiveness. A document cannot contain two block -quotes in a row unless there is a blank line between them.

    -
    4. -
-

Nothing else counts as a block quote.

-

Here is a simple example:

-
-
Example 178  (interact)
-
> # Foo
-> bar
-> baz
-
-
<blockquote>
-<h1>Foo</h1>
-<p>bar
-baz</p>
-</blockquote>
-
-
-

The spaces after the > characters can be omitted:

-
-
Example 179  (interact)
-
># Foo
->bar
-> baz
-
-
<blockquote>
-<h1>Foo</h1>
-<p>bar
-baz</p>
-</blockquote>
-
-
-

The > characters can be indented 1-3 spaces:

-
-
Example 180  (interact)
-
   > # Foo
-   > bar
- > baz
-
-
<blockquote>
-<h1>Foo</h1>
-<p>bar
-baz</p>
-</blockquote>
-
-
-

Four spaces gives us a code block:

-
-
Example 181  (interact)
-
    > # Foo
-    > bar
-    > baz
-
-
<pre><code>&gt; # Foo
-&gt; bar
-&gt; baz
-</code></pre>
-
-
-

The Laziness clause allows us to omit the > before a -paragraph continuation line:

-
-
Example 182  (interact)
-
> # Foo
-> bar
-baz
-
-
<blockquote>
-<h1>Foo</h1>
-<p>bar
-baz</p>
-</blockquote>
-
-
-

A block quote can contain some lazy and some non-lazy -continuation lines:

-
-
Example 183  (interact)
-
> bar
-baz
-> foo
-
-
<blockquote>
-<p>bar
-baz
-foo</p>
-</blockquote>
-
-
-

Laziness only applies to lines that would have been continuations of -paragraphs had they been prepended with block quote markers. -For example, the > cannot be omitted in the second line of

-
> foo
-> ---
-
-

without changing the meaning:

-
-
Example 184  (interact)
-
> foo
----
-
-
<blockquote>
-<p>foo</p>
-</blockquote>
-<hr />
-
-
-

Similarly, if we omit the > in the second line of

-
> - foo
-> - bar
-
-

then the block quote ends after the first line:

-
-
Example 185  (interact)
-
> - foo
-- bar
-
-
<blockquote>
-<ul>
-<li>foo</li>
-</ul>
-</blockquote>
-<ul>
-<li>bar</li>
-</ul>
-
-
-

For the same reason, we can’t omit the > in front of -subsequent lines of an indented or fenced code block:

-
-
Example 186  (interact)
-
>     foo
-    bar
-
-
<blockquote>
-<pre><code>foo
-</code></pre>
-</blockquote>
-<pre><code>bar
-</code></pre>
-
-
-
-
Example 187  (interact)
-
> ```
-foo
-```
-
-
<blockquote>
-<pre><code></code></pre>
-</blockquote>
-<p>foo</p>
-<pre><code></code></pre>
-
-
-

Note that in the following case, we have a paragraph -continuation line:

-
-
Example 188  (interact)
-
> foo
-    - bar
-
-
<blockquote>
-<p>foo
-- bar</p>
-</blockquote>
-
-
-

To see why, note that in

-
> foo
->     - bar
-
-

the - bar is indented too far to start a list, and can’t -be an indented code block because indented code blocks cannot -interrupt paragraphs, so it is a [paragraph continuation line].

-

A block quote can be empty:

-
-
Example 189  (interact)
-
>
-
-
<blockquote>
-</blockquote>
-
-
-
-
Example 190  (interact)
-
>
->  
-> 
-
-
<blockquote>
-</blockquote>
-
-
-

A block quote can have initial or final blank lines:

-
-
Example 191  (interact)
-
>
-> foo
->  
-
-
<blockquote>
-<p>foo</p>
-</blockquote>
-
-
-

A blank line always separates block quotes:

-
-
Example 192  (interact)
-
> foo
-
-> bar
-
-
<blockquote>
-<p>foo</p>
-</blockquote>
-<blockquote>
-<p>bar</p>
-</blockquote>
-
-
-

(Most current Markdown implementations, including John Gruber’s -original Markdown.pl, will parse this example as a single block quote -with two paragraphs. But it seems better to allow the author to decide -whether two block quotes or one are wanted.)

-

Consecutiveness means that if we put these block quotes together, -we get a single block quote:

-
-
Example 193  (interact)
-
> foo
-> bar
-
-
<blockquote>
-<p>foo
-bar</p>
-</blockquote>
-
-
-

To get a block quote with two paragraphs, use:

-
-
Example 194  (interact)
-
> foo
->
-> bar
-
-
<blockquote>
-<p>foo</p>
-<p>bar</p>
-</blockquote>
-
-
-

Block quotes can interrupt paragraphs:

-
-
Example 195  (interact)
-
foo
-> bar
-
-
<p>foo</p>
-<blockquote>
-<p>bar</p>
-</blockquote>
-
-
-

In general, blank lines are not needed before or after block -quotes:

-
-
Example 196  (interact)
-
> aaa
-***
-> bbb
-
-
<blockquote>
-<p>aaa</p>
-</blockquote>
-<hr />
-<blockquote>
-<p>bbb</p>
-</blockquote>
-
-
-

However, because of laziness, a blank line is needed between -a block quote and a following paragraph:

-
-
Example 197  (interact)
-
> bar
-baz
-
-
<blockquote>
-<p>bar
-baz</p>
-</blockquote>
-
-
-
-
Example 198  (interact)
-
> bar
-
-baz
-
-
<blockquote>
-<p>bar</p>
-</blockquote>
-<p>baz</p>
-
-
-
-
Example 199  (interact)
-
> bar
->
-baz
-
-
<blockquote>
-<p>bar</p>
-</blockquote>
-<p>baz</p>
-
-
-

It is a consequence of the Laziness rule that any number -of initial >s may be omitted on a continuation line of a -nested block quote:

-
-
Example 200  (interact)
-
> > > foo
-bar
-
-
<blockquote>
-<blockquote>
-<blockquote>
-<p>foo
-bar</p>
-</blockquote>
-</blockquote>
-</blockquote>
-
-
-
-
Example 201  (interact)
-
>>> foo
-> bar
->>baz
-
-
<blockquote>
-<blockquote>
-<blockquote>
-<p>foo
-bar
-baz</p>
-</blockquote>
-</blockquote>
-</blockquote>
-
-
-

When including an indented code block in a block quote, -remember that the block quote marker includes -both the > and a following space. So five spaces are needed after -the >:

-
-
Example 202  (interact)
-
>     code
-
->    not code
-
-
<blockquote>
-<pre><code>code
-</code></pre>
-</blockquote>
-<blockquote>
-<p>not code</p>
-</blockquote>
-
-
-

5.2 List items

-

A list marker is a -bullet list marker or an ordered list marker.

-

A bullet list marker -is a -, +, or * character.

-

An ordered list marker -is a sequence of 1–9 arabic digits (0-9), followed by either a -. character or a ) character. (The reason for the length -limit is that with 10 digits we start seeing integer overflows -in some browsers.)

-

The following rules define list items:

-
    -
  1. Basic case. If a sequence of lines Ls constitute a sequence of -blocks Bs starting with a non-whitespace character and not separated -from each other by more than one blank line, and M is a list -marker of width W followed by 0 < N < 5 spaces, then the result -of prepending M and the following spaces to the first line of -Ls, and indenting subsequent lines of Ls by W + N spaces, is a -list item with Bs 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 start -number, based on the ordered list marker.
    2. -
-

For example, let Ls be the lines

-
-
Example 203  (interact)
-
A paragraph
-with two lines.
-
-    indented code
-
-> A block quote.
-
-
<p>A paragraph
-with two lines.</p>
-<pre><code>indented code
-</code></pre>
-<blockquote>
-<p>A block quote.</p>
-</blockquote>
-
-
-

And let M be the marker 1., and N = 2. Then rule #1 says -that the following is an ordered list item with start number 1, -and the same contents as Ls:

-
-
Example 204  (interact)
-
1.  A paragraph
-    with two lines.
-
-        indented code
-
-    > A block quote.
-
-
<ol>
-<li>
-<p>A paragraph
-with two lines.</p>
-<pre><code>indented code
-</code></pre>
-<blockquote>
-<p>A block quote.</p>
-</blockquote>
-</li>
-</ol>
-
-
-

The most important thing to notice is that the position of -the text after the list marker determines how much indentation -is needed in subsequent blocks in the list item. If the list -marker takes up two spaces, and there are three spaces between -the list marker and the next non-whitespace character, then blocks -must be indented five spaces in order to fall under the list -item.

-

Here are some examples showing how far content must be indented to be -put under the list item:

-
-
Example 205  (interact)
-
- one
-
- two
-
-
<ul>
-<li>one</li>
-</ul>
-<p>two</p>
-
-
-
-
Example 206  (interact)
-
- one
-
-  two
-
-
<ul>
-<li>
-<p>one</p>
-<p>two</p>
-</li>
-</ul>
-
-
-
-
Example 207  (interact)
-
 -    one
-
-     two
-
-
<ul>
-<li>one</li>
-</ul>
-<pre><code> two
-</code></pre>
-
-
-
-
Example 208  (interact)
-
 -    one
-
-      two
-
-
<ul>
-<li>
-<p>one</p>
-<p>two</p>
-</li>
-</ul>
-
-
-

It is tempting to think of this in terms of columns: the continuation -blocks must be indented at least to the column of the first -non-whitespace character after the list marker. However, that is not quite right. -The spaces after the list marker determine how much relative indentation -is needed. Which column this indentation reaches will depend on -how the list item is embedded in other constructions, as shown by -this example:

-
-
Example 209  (interact)
-
   > > 1.  one
->>
->>     two
-
-
<blockquote>
-<blockquote>
-<ol>
-<li>
-<p>one</p>
-<p>two</p>
-</li>
-</ol>
-</blockquote>
-</blockquote>
-
-
-

Here two occurs in the same column as the list marker 1., -but is actually contained in the list item, because there is -sufficient indentation after the last containing blockquote marker.

-

The converse is also possible. In the following example, the word two -occurs far to the right of the initial text of the list item, one, but -it is not considered part of the list item, because it is not indented -far enough past the blockquote marker:

-
-
Example 210  (interact)
-
>>- 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 and -any following content, so these are not list items:

-
-
Example 211  (interact)
-
-one
-
-2.two
-
-
<p>-one</p>
-<p>2.two</p>
-
-
-

A list item may not contain blocks that are separated by more than -one blank line. Thus, two blank lines will end a list, unless the -two blanks are contained in a fenced code block.

-
-
Example 212  (interact)
-
- foo
-
-  bar
-
-- foo
-
-
-  bar
-
-- ```
-  foo
-
-
-  bar
-  ```
-
-- baz
-
-  + ```
-    foo
-
-
-    bar
-    ```
-
-
<ul>
-<li>
-<p>foo</p>
-<p>bar</p>
-</li>
-<li>
-<p>foo</p>
-</li>
-</ul>
-<p>bar</p>
-<ul>
-<li>
-<pre><code>foo
-
-
-bar
-</code></pre>
-</li>
-<li>
-<p>baz</p>
-<ul>
-<li>
-<pre><code>foo
-
-
-bar
-</code></pre>
-</li>
-</ul>
-</li>
-</ul>
-
-
-

A list item may contain any kind of block:

-
-
Example 213  (interact)
-
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>
-
-
-

Note that ordered list start numbers must be nine digits or less:

-
-
Example 214  (interact)
-
123456789. ok
-
-
<ol start="123456789">
-<li>ok</li>
-</ol>
-
-
-
-
Example 215  (interact)
-
1234567890. not ok
-
-
<p>1234567890. not ok</p>
-
-
-

A start number may begin with 0s:

-
-
Example 216  (interact)
-
0. ok
-
-
<ol start="0">
-<li>ok</li>
-</ol>
-
-
-
-
Example 217  (interact)
-
003. ok
-
-
<ol start="3">
-<li>ok</li>
-</ol>
-
-
-

A start number may not be negative:

-
-
Example 218  (interact)
-
-1. not ok
-
-
<p>-1. not ok</p>
-
-
-
    -
  1. Item starting with indented code. If a sequence of lines Ls -constitute a sequence of blocks Bs starting with an indented code -block and not separated from each other by more than one blank line, -and M is a list marker of width W followed by -one space, then the result of prepending M and the following -space to the first line of Ls, and indenting subsequent lines of -Ls by W + 1 spaces, is a list item with Bs as its contents. -If a line is empty, then it need not be indented. 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 -start number, based on the ordered list marker.
    2. -
-

An indented code block will have to be indented four spaces beyond -the edge of the region where text will be included in the list item. -In the following case that is 6 spaces:

-
-
Example 219  (interact)
-
- foo
-
-      bar
-
-
<ul>
-<li>
-<p>foo</p>
-<pre><code>bar
-</code></pre>
-</li>
-</ul>
-
-
-

And in this case it is 11 spaces:

-
-
Example 220  (interact)
-
  10.  foo
-
-           bar
-
-
<ol start="10">
-<li>
-<p>foo</p>
-<pre><code>bar
-</code></pre>
-</li>
-</ol>
-
-
-

If the first block in the list item is an indented code block, -then by rule #2, the contents must be indented one space after the -list marker:

-
-
Example 221  (interact)
-
    indented code
-
-paragraph
-
-    more code
-
-
<pre><code>indented code
-</code></pre>
-<p>paragraph</p>
-<pre><code>more code
-</code></pre>
-
-
-
-
Example 222  (interact)
-
1.     indented code
-
-   paragraph
-
-       more code
-
-
<ol>
-<li>
-<pre><code>indented code
-</code></pre>
-<p>paragraph</p>
-<pre><code>more code
-</code></pre>
-</li>
-</ol>
-
-
-

Note that an additional space indent is interpreted as space -inside the code block:

-
-
Example 223  (interact)
-
1.      indented code
-
-   paragraph
-
-       more code
-
-
<ol>
-<li>
-<pre><code> indented code
-</code></pre>
-<p>paragraph</p>
-<pre><code>more code
-</code></pre>
-</li>
-</ol>
-
-
-

Note that rules #1 and #2 only apply to two cases: (a) cases -in which the lines to be included in a list item begin with a -non-whitespace character, and (b) cases in which -they begin with an indented code -block. In a case like the following, where the first block begins with -a three-space indent, the rules do not allow us to form a list item by -indenting the whole thing and prepending a list marker:

-
-
Example 224  (interact)
-
   foo
-
-bar
-
-
<p>foo</p>
-<p>bar</p>
-
-
-
-
Example 225  (interact)
-
-    foo
-
-  bar
-
-
<ul>
-<li>foo</li>
-</ul>
-<p>bar</p>
-
-
-

This is not a significant restriction, because when a block begins -with 1-3 spaces indent, the indentation can always be removed without -a change in interpretation, allowing rule #1 to be applied. So, in -the above case:

-
-
Example 226  (interact)
-
-  foo
-
-   bar
-
-
<ul>
-<li>
-<p>foo</p>
-<p>bar</p>
-</li>
-</ul>
-
-
-
    -
  1. Item starting with a blank line. If a sequence of lines Ls -starting with a single blank line constitute a (possibly empty) -sequence of blocks Bs, not separated from each other by more than -one blank line, and M is a list marker of width W, -then the result of prepending M to the first line of Ls, and -indenting subsequent lines of Ls by W + 1 spaces, is a list -item with Bs as its contents. -If a line is empty, then it need not be indented. 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 -start number, based on the ordered list marker.
    2. -
-

Here are some list items that start with a blank line but are not empty:

-
-
Example 227  (interact)
-
-
-  foo
--
-  ```
-  bar
-  ```
--
-      baz
-
-
<ul>
-<li>foo</li>
-<li>
-<pre><code>bar
-</code></pre>
-</li>
-<li>
-<pre><code>baz
-</code></pre>
-</li>
-</ul>
-
-
-

A list item can begin with at most one blank line. -In the following example, foo is not part of the list -item:

-
-
Example 228  (interact)
-
-
-
-  foo
-
-
<ul>
-<li></li>
-</ul>
-<p>foo</p>
-
-
-

Here is an empty bullet list item:

-
-
Example 229  (interact)
-
- foo
--
-- bar
-
-
<ul>
-<li>foo</li>
-<li></li>
-<li>bar</li>
-</ul>
-
-
-

It does not matter whether there are spaces following the list marker:

-
-
Example 230  (interact)
-
- foo
--   
-- bar
-
-
<ul>
-<li>foo</li>
-<li></li>
-<li>bar</li>
-</ul>
-
-
-

Here is an empty ordered list item:

-
-
Example 231  (interact)
-
1. foo
-2.
-3. bar
-
-
<ol>
-<li>foo</li>
-<li></li>
-<li>bar</li>
-</ol>
-
-
-

A list may start or end with an empty list item:

-
-
Example 232  (interact)
-
*
-
-
<ul>
-<li></li>
-</ul>
-
-
-
    -
  1. Indentation. If a sequence of lines Ls constitutes a list item -according to rule #1, #2, or #3, then the result of indenting each line -of Ls by 1-3 spaces (the same for each line) also constitutes a -list item with the same contents and attributes. If a line is -empty, then it need not be indented.
    2. -
-

Indented one space:

-
-
Example 233  (interact)
-
 1.  A paragraph
-     with two lines.
-
-         indented code
-
-     > A block quote.
-
-
<ol>
-<li>
-<p>A paragraph
-with two lines.</p>
-<pre><code>indented code
-</code></pre>
-<blockquote>
-<p>A block quote.</p>
-</blockquote>
-</li>
-</ol>
-
-
-

Indented two spaces:

-
-
Example 234  (interact)
-
  1.  A paragraph
-      with two lines.
-
-          indented code
-
-      > A block quote.
-
-
<ol>
-<li>
-<p>A paragraph
-with two lines.</p>
-<pre><code>indented code
-</code></pre>
-<blockquote>
-<p>A block quote.</p>
-</blockquote>
-</li>
-</ol>
-
-
-

Indented three spaces:

-
-
Example 235  (interact)
-
   1.  A paragraph
-       with two lines.
-
-           indented code
-
-       > A block quote.
-
-
<ol>
-<li>
-<p>A paragraph
-with two lines.</p>
-<pre><code>indented code
-</code></pre>
-<blockquote>
-<p>A block quote.</p>
-</blockquote>
-</li>
-</ol>
-
-
-

Four spaces indent gives a code block:

-
-
Example 236  (interact)
-
    1.  A paragraph
-        with two lines.
-
-            indented code
-
-        > A block quote.
-
-
<pre><code>1.  A paragraph
-    with two lines.
-
-        indented code
-
-    &gt; A block quote.
-</code></pre>
-
-
-
    -
  1. Laziness. If a string of lines Ls constitute a list -item with contents Bs, then the result of deleting -some or all of the indentation from one or more lines in which the -next non-whitespace character after the indentation is -paragraph continuation text is a -list item with the same contents and attributes. The unindented -lines are called -lazy continuation lines.
    2. -
-

Here is an example with lazy continuation lines:

-
-
Example 237  (interact)
-
  1.  A paragraph
-with two lines.
-
-          indented code
-
-      > A block quote.
-
-
<ol>
-<li>
-<p>A paragraph
-with two lines.</p>
-<pre><code>indented code
-</code></pre>
-<blockquote>
-<p>A block quote.</p>
-</blockquote>
-</li>
-</ol>
-
-
-

Indentation can be partially deleted:

-
-
Example 238  (interact)
-
  1.  A paragraph
-    with two lines.
-
-
<ol>
-<li>A paragraph
-with two lines.</li>
-</ol>
-
-
-

These examples show how laziness can work in nested structures:

-
-
Example 239  (interact)
-
> 1. > Blockquote
-continued here.
-
-
<blockquote>
-<ol>
-<li>
-<blockquote>
-<p>Blockquote
-continued here.</p>
-</blockquote>
-</li>
-</ol>
-</blockquote>
-
-
-
-
Example 240  (interact)
-
> 1. > Blockquote
-> continued here.
-
-
<blockquote>
-<ol>
-<li>
-<blockquote>
-<p>Blockquote
-continued here.</p>
-</blockquote>
-</li>
-</ol>
-</blockquote>
-
-
-
    -
  1. That’s all. Nothing that is not counted as a list item by rules -#1–5 counts as a list item.
    2. -
-

The rules for sublists follow from the general rules above. A sublist -must be indented the same number of spaces a paragraph would need to be -in order to be included in the list item.

-

So, in this case we need two spaces indent:

-
-
Example 241  (interact)
-
- foo
-  - bar
-    - baz
-
-
<ul>
-<li>foo
-<ul>
-<li>bar
-<ul>
-<li>baz</li>
-</ul>
-</li>
-</ul>
-</li>
-</ul>
-
-
-

One is not enough:

-
-
Example 242  (interact)
-
- foo
- - bar
-  - baz
-
-
<ul>
-<li>foo</li>
-<li>bar</li>
-<li>baz</li>
-</ul>
-
-
-

Here we need four, because the list marker is wider:

-
-
Example 243  (interact)
-
10) foo
-    - bar
-
-
<ol start="10">
-<li>foo
-<ul>
-<li>bar</li>
-</ul>
-</li>
-</ol>
-
-
-

Three is not enough:

-
-
Example 244  (interact)
-
10) foo
-   - bar
-
-
<ol start="10">
-<li>foo</li>
-</ol>
-<ul>
-<li>bar</li>
-</ul>
-
-
-

A list may be the first block in a list item:

-
-
Example 245  (interact)
-
- - foo
-
-
<ul>
-<li>
-<ul>
-<li>foo</li>
-</ul>
-</li>
-</ul>
-
-
-
-
Example 246  (interact)
-
1. - 2. foo
-
-
<ol>
-<li>
-<ul>
-<li>
-<ol start="2">
-<li>foo</li>
-</ol>
-</li>
-</ul>
-</li>
-</ol>
-
-
-

A list item can contain a header:

-
-
Example 247  (interact)
-
- # Foo
-- Bar
-  ---
-  baz
-
-
<ul>
-<li>
-<h1>Foo</h1>
-</li>
-<li>
-<h2>Bar</h2>
-baz</li>
-</ul>
-
-
-

5.2.1 Motivation

-

John Gruber’s Markdown spec says the following about list items:

-
    -
  1. -

    “List markers typically start at the left margin, but may be indented -by up to three spaces. List markers must be followed by one or more -spaces or a tab.”

    -
    2. -
  2. -

    “To make lists look nice, you can wrap items with hanging indents…. -But if you don’t want to, you don’t have to.”

    -
    3. -
  3. -

    “List items may consist of multiple paragraphs. Each subsequent -paragraph in a list item must be indented by either 4 spaces or one -tab.”

    -
    4. -
  4. -

    “It looks nice if you indent every line of the subsequent paragraphs, -but here again, Markdown will allow you to be lazy.”

    -
    5. -
  5. -

    “To put a blockquote within a list item, the blockquote’s > -delimiters need to be indented.”

    -
    6. -
  6. -

    “To put a code block within a list item, the code block needs to be -indented twice — 8 spaces or two tabs.”

    -
    7. -
-

These rules specify that a paragraph under a list item must be indented -four spaces (presumably, from the left margin, rather than the start of -the list marker, but this is not said), and that code under a list item -must be indented eight spaces instead of the usual four. They also say -that a block quote must be indented, but not by how much; however, the -example given has four spaces indentation. Although nothing is said -about other kinds of block-level content, it is certainly reasonable to -infer that all block elements under a list item, including other -lists, must be indented four spaces. This principle has been called the -four-space rule.

-

The four-space rule is clear and principled, and if the reference -implementation Markdown.pl had followed it, it probably would have -become the standard. However, Markdown.pl allowed paragraphs and -sublists to start with only two spaces indentation, at least on the -outer level. Worse, its behavior was inconsistent: a sublist of an -outer-level list needed two spaces indentation, but a sublist of this -sublist needed three spaces. It is not surprising, then, that different -implementations of Markdown have developed very different rules for -determining what comes under a list item. (Pandoc and python-Markdown, -for example, stuck with Gruber’s syntax description and the four-space -rule, while discount, redcarpet, marked, PHP Markdown, and others -followed Markdown.pl’s behavior more closely.)

-

Unfortunately, given the divergences between implementations, there -is no way to give a spec for list items that will be guaranteed not -to break any existing documents. However, the spec given here should -correctly handle lists formatted with either the four-space rule or -the more forgiving Markdown.pl behavior, provided they are laid out -in a way that is natural for a human to read.

-

The strategy here is to let the width and indentation of the list marker -determine the indentation necessary for blocks to fall under the list -item, rather than having a fixed and arbitrary number. The writer can -think of the body of the list item as a unit which gets indented to the -right enough to fit the list marker (and any indentation on the list -marker). (The laziness rule, #5, then allows continuation lines to be -unindented if needed.)

-

This rule is superior, we claim, to any rule requiring a fixed level of -indentation from the margin. The four-space rule is clear but -unnatural. It is quite unintuitive that

-
- foo
-
-  bar
-
-  - baz
-
-

should 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 is -not likely to be guessed, and it trips up beginners regularly.

-

Would it help to adopt a two-space rule? The problem is that such -a rule, together with the rule allowing 1–3 spaces indentation of the -initial list marker, allows text that is indented less than the -original list marker to be included in the list item. For example, -Markdown.pl parses

-
   - one
-
-  two
-
-

as a single list item, with two a continuation paragraph:

-
<ul>
-<li>
-<p>one</p>
-<p>two</p>
-</li>
-</ul>
-
-

and similarly

-
>   - one
->
->  two
-
-

as

-
<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 require -a fixed indent (say, two spaces, or even one space) from the list marker (which -may itself be indented). This proposal would remove the last anomaly -discussed. Unlike the spec presented above, it would count the following -as a list item with a subparagraph, even though the paragraph bar -is not indented as far as the first paragraph foo:

-
 10. foo
-
-   bar  
-
-

Arguably this text does read like a list item with bar as a subparagraph, -which may count in favor of the proposal. However, on this proposal indented -code would have to be indented six spaces after the list marker. And this -would break a lot of existing Markdown, which has the pattern:

-
1.  foo
-
-        indented code
-
-

where the code is indented eight spaces. The spec above, by contrast, will -parse this text as expected, since the code block’s indentation is measured -from the beginning of foo.

-

The one case that needs special treatment is a list item that starts -with indented code. How much indentation is required in that case, since -we don’t have a “first paragraph” to measure from? Rule #2 simply stipulates -that 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 the -four-space rule in cases where the list marker plus its initial indentation -takes four spaces (a common case), but diverge in other cases.

-

5.3 Lists

-

A list is a sequence of one or more -list items of the same type. The list items -may be separated by single blank lines, but two -blank lines end all containing lists.

-

Two list items are of the same type -if they begin with a list marker of the same type. -Two list markers are of the -same type if (a) they are bullet list markers using the same character -(-, +, or *) or (b) they are ordered list numbers with the same -delimiter (either . or )).

-

A list is an ordered list -if its constituent list items begin with -ordered list markers, and a -bullet list if its constituent list -items begin with bullet list markers.

-

The start number -of an ordered list is determined by the list number of -its initial list item. The numbers of subsequent list items are -disregarded.

-

A list is loose if any of its constituent -list items are separated by blank lines, or if any of its constituent -list items directly contain two block-level elements with a blank line -between them. Otherwise a list is tight. -(The difference in HTML output is that paragraphs in a loose list are -wrapped in <p> tags, while paragraphs in a tight list are not.)

-

Changing the bullet or ordered list delimiter starts a new list:

-
-
Example 248  (interact)
-
- foo
-- bar
-+ baz
-
-
<ul>
-<li>foo</li>
-<li>bar</li>
-</ul>
-<ul>
-<li>baz</li>
-</ul>
-
-
-
-
Example 249  (interact)
-
1. foo
-2. bar
-3) baz
-
-
<ol>
-<li>foo</li>
-<li>bar</li>
-</ol>
-<ol start="3">
-<li>baz</li>
-</ol>
-
-
-

In CommonMark, a list can interrupt a paragraph. That is, -no blank line is needed to separate a paragraph from a following -list:

-
-
Example 250  (interact)
-
Foo
-- bar
-- baz
-
-
<p>Foo</p>
-<ul>
-<li>bar</li>
-<li>baz</li>
-</ul>
-
-
-

Markdown.pl does not allow this, through fear of triggering a list -via a numeral in a hard-wrapped line:

-
-
Example 251  (interact)
-
The number of windows in my house is
-14.  The number of doors is 6.
-
-
<p>The number of windows in my house is</p>
-<ol start="14">
-<li>The number of doors is 6.</li>
-</ol>
-
-
-

Oddly, Markdown.pl does allow a blockquote to interrupt a paragraph, -even though the same considerations might apply. We think that the two -cases should be treated the same. Here are two reasons for allowing -lists to interrupt paragraphs:

-

First, it is natural and not uncommon for people to start lists without -blank lines:

-
I need to buy
-- new shoes
-- a coat
-- a plane ticket
-
-

Second, we are attracted to a

-
-

principle of uniformity: -if a chunk of text has a certain -meaning, it will continue to have the same meaning when put into a -container block (such as a list item or blockquote).

-
-

(Indeed, the spec for list items and block quotes presupposes -this principle.) This principle implies that if

-
  * I need to buy
-    - new shoes
-    - a coat
-    - a plane ticket
-
-

is a list item containing a paragraph followed by a nested sublist, -as all Markdown implementations agree it is (though the paragraph -may be rendered without <p> tags, since the list is “tight”), -then

-
I need to buy
-- new shoes
-- a coat
-- a plane ticket
-
-

by itself should be a paragraph followed by a nested sublist.

-

Our adherence to the principle of uniformity -thus inclines us to think that there are two coherent packages:

-
    -
  1. -

    Require blank lines before all lists and blockquotes, -including lists that occur as sublists inside other list items.

    -
    2. -
  2. -

    Require blank lines in none of these places.

    -
    3. -
-

reStructuredText takes -the first approach, for which there is much to be said. But the second -seems more consistent with established practice with Markdown.

-

There can be blank lines between items, but two blank lines end -a list:

-
-
Example 252  (interact)
-
- foo
-
-- bar
-
-
-- baz
-
-
<ul>
-<li>
-<p>foo</p>
-</li>
-<li>
-<p>bar</p>
-</li>
-</ul>
-<ul>
-<li>baz</li>
-</ul>
-
-
-

As illustrated above in the section on list items, -two blank lines between blocks within a list item will also end a -list:

-
-
Example 253  (interact)
-
- foo
-
-
-  bar
-- baz
-
-
<ul>
-<li>foo</li>
-</ul>
-<p>bar</p>
-<ul>
-<li>baz</li>
-</ul>
-
-
-

Indeed, two blank lines will end all containing lists:

-
-
Example 254  (interact)
-
- foo
-  - bar
-    - baz
-
-
-      bim
-
-
<ul>
-<li>foo
-<ul>
-<li>bar
-<ul>
-<li>baz</li>
-</ul>
-</li>
-</ul>
-</li>
-</ul>
-<pre><code>  bim
-</code></pre>
-
-
-

Thus, two blank lines can be used to separate consecutive lists of -the same type, or to separate a list from an indented code block -that would otherwise be parsed as a subparagraph of the final list -item:

-
-
Example 255  (interact)
-
- foo
-- bar
-
-
-- baz
-- bim
-
-
<ul>
-<li>foo</li>
-<li>bar</li>
-</ul>
-<ul>
-<li>baz</li>
-<li>bim</li>
-</ul>
-
-
-
-
Example 256  (interact)
-
-   foo
-
-    notcode
-
--   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 following -list items will be treated as items at the same list level, -since none is indented enough to belong to the previous list -item:

-
-
Example 257  (interact)
-
- a
- - b
-  - c
-   - d
-    - e
-   - f
-  - g
- - h
-- i
-
-
<ul>
-<li>a</li>
-<li>b</li>
-<li>c</li>
-<li>d</li>
-<li>e</li>
-<li>f</li>
-<li>g</li>
-<li>h</li>
-<li>i</li>
-</ul>
-
-
-
-
Example 258  (interact)
-
1. a
-
-  2. b
-
-    3. c
-
-
<ol>
-<li>
-<p>a</p>
-</li>
-<li>
-<p>b</p>
-</li>
-<li>
-<p>c</p>
-</li>
-</ol>
-
-
-

This is a loose list, because there is a blank line between -two of the list items:

-
-
Example 259  (interact)
-
- a
-- b
-
-- c
-
-
<ul>
-<li>
-<p>a</p>
-</li>
-<li>
-<p>b</p>
-</li>
-<li>
-<p>c</p>
-</li>
-</ul>
-
-
-

So is this, with a empty second item:

-
-
Example 260  (interact)
-
* a
-*
-
-* c
-
-
<ul>
-<li>
-<p>a</p>
-</li>
-<li></li>
-<li>
-<p>c</p>
-</li>
-</ul>
-
-
-

These are loose lists, even though there is no space between the items, -because one of the items directly contains two block-level elements -with a blank line between them:

-
-
Example 261  (interact)
-
- a
-- b
-
-  c
-- d
-
-
<ul>
-<li>
-<p>a</p>
-</li>
-<li>
-<p>b</p>
-<p>c</p>
-</li>
-<li>
-<p>d</p>
-</li>
-</ul>
-
-
-
-
Example 262  (interact)
-
- a
-- b
-
-  [ref]: /url
-- d
-
-
<ul>
-<li>
-<p>a</p>
-</li>
-<li>
-<p>b</p>
-</li>
-<li>
-<p>d</p>
-</li>
-</ul>
-
-
-

This is a tight list, because the blank lines are in a code block:

-
-
Example 263  (interact)
-
- a
-- ```
-  b
-
-
-  ```
-- c
-
-
<ul>
-<li>a</li>
-<li>
-<pre><code>b
-
-
-</code></pre>
-</li>
-<li>c</li>
-</ul>
-
-
-

This is a tight list, because the blank line is between two -paragraphs of a sublist. So the sublist is loose while -the outer list is tight:

-
-
Example 264  (interact)
-
- a
-  - b
-
-    c
-- d
-
-
<ul>
-<li>a
-<ul>
-<li>
-<p>b</p>
-<p>c</p>
-</li>
-</ul>
-</li>
-<li>d</li>
-</ul>
-
-
-

This is a tight list, because the blank line is inside the -block quote:

-
-
Example 265  (interact)
-
* a
-  > b
-  >
-* c
-
-
<ul>
-<li>a
-<blockquote>
-<p>b</p>
-</blockquote>
-</li>
-<li>c</li>
-</ul>
-
-
-

This list is tight, because the consecutive block elements -are not separated by blank lines:

-
-
Example 266  (interact)
-
- 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:

-
-
Example 267  (interact)
-
- a
-
-
<ul>
-<li>a</li>
-</ul>
-
-
-
-
Example 268  (interact)
-
- a
-  - b
-
-
<ul>
-<li>a
-<ul>
-<li>b</li>
-</ul>
-</li>
-</ul>
-
-
-

This list is loose, because of the blank line between the -two block elements in the list item:

-
-
Example 269  (interact)
-
1. ```
-   foo
-   ```
-
-   bar
-
-
<ol>
-<li>
-<pre><code>foo
-</code></pre>
-<p>bar</p>
-</li>
-</ol>
-
-
-

Here the outer list is loose, the inner list tight:

-
-
Example 270  (interact)
-
* foo
-  * bar
-
-  baz
-
-
<ul>
-<li>
-<p>foo</p>
-<ul>
-<li>bar</li>
-</ul>
-<p>baz</p>
-</li>
-</ul>
-
-
-
-
Example 271  (interact)
-
- 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>
-
-
-

6 Inlines

-

Inlines are parsed sequentially from the beginning of the character -stream to the end (left to right, in left-to-right languages). -Thus, for example, in

-
-
Example 272  (interact)
-
`hi`lo`
-
-
<p><code>hi</code>lo`</p>
-
-
-

hi is parsed as code, leaving the backtick at the end as a literal -backtick.

-

6.1 Backslash escapes

-

Any ASCII punctuation character may be backslash-escaped:

-
-
Example 273  (interact)
-
\!\"\#\$\%\&\'\(\)\*\+\,\-\.\/\:\;\<\=\>\?\@\[\\\]\^\_\`\{\|\}\~
-
-
<p>!&quot;#$%&amp;'()*+,-./:;&lt;=&gt;?@[\]^_`{|}~</p>
-
-
-

Backslashes before other characters are treated as literal -backslashes:

-
-
Example 274  (interact)
-
\→\A\a\ \3\φ\«
-
-
<p>\→\A\a\ \3\φ\«</p>
-
-
-

Escaped characters are treated as regular characters and do -not have their usual Markdown meanings:

-
-
Example 275  (interact)
-
\*not emphasized*
-\<br/> not a tag
-\[not a link](/foo)
-\`not code`
-1\. not a list
-\* not a list
-\# not a header
-\[foo]: /url "not a reference"
-
-
<p>*not emphasized*
-&lt;br/&gt; not a tag
-[not a link](/foo)
-`not code`
-1. not a list
-* not a list
-# not a header
-[foo]: /url &quot;not a reference&quot;</p>
-
-
-

If a backslash is itself escaped, the following character is not:

-
-
Example 276  (interact)
-
\\*emphasis*
-
-
<p>\<em>emphasis</em></p>
-
-
-

A backslash at the end of the line is a hard line break:

-
-
Example 277  (interact)
-
foo\
-bar
-
-
<p>foo<br />
-bar</p>
-
-
-

Backslash escapes do not work in code blocks, code spans, autolinks, or -raw HTML:

-
-
Example 278  (interact)
-
`` \[\` ``
-
-
<p><code>\[\`</code></p>
-
-
-
-
Example 279  (interact)
-
    \[\]
-
-
<pre><code>\[\]
-</code></pre>
-
-
-
-
Example 280  (interact)
-
~~~
-\[\]
-~~~
-
-
<pre><code>\[\]
-</code></pre>
-
-
-
-
Example 281  (interact)
-
<http://example.com?find=\*>
-
-
<p><a href="http://example.com?find=%5C*">http://example.com?find=\*</a></p>
-
-
-
-
Example 282  (interact)
-
<a href="/bar\/)">
-
-
<a href="/bar\/)">
-
-
-

But they work in all other contexts, including URLs and link titles, -link references, and info strings in fenced code blocks:

-
-
Example 283  (interact)
-
[foo](/bar\* "ti\*tle")
-
-
<p><a href="/bar*" title="ti*tle">foo</a></p>
-
-
-
-
Example 284  (interact)
-
[foo]
-
-[foo]: /bar\* "ti\*tle"
-
-
<p><a href="/bar*" title="ti*tle">foo</a></p>
-
-
-
-
Example 285  (interact)
-
``` foo\+bar
-foo
-```
-
-
<pre><code class="language-foo+bar">foo
-</code></pre>
-
-
-

6.2 Entities

-

With the goal of making this standard as HTML-agnostic as possible, all -valid HTML entities (except in code blocks and code spans) -are recognized as such and converted into Unicode characters before -they are stored in the AST. This means that renderers to formats other -than HTML need not be HTML-entity aware. HTML renderers may either escape -Unicode characters as entities or leave them as they are. (However, -", &, <, and > must always be rendered as entities.)

-

Named entities consist of & + any of the valid -HTML5 entity names + ;. The -following document -is used as an authoritative source of the valid entity names and their -corresponding code points.

-
-
Example 286  (interact)
-
&nbsp; &amp; &copy; &AElig; &Dcaron;
-&frac34; &HilbertSpace; &DifferentialD;
-&ClockwiseContourIntegral; &ngE;
-
-
<p>  &amp; © Æ Ď
-¾ ℋ ⅆ
-∲ ≧̸</p>
-
-
-

Decimal entities -consist of &# + a string of 1–8 arabic digits + ;. Again, these -entities need to be recognised and transformed into their corresponding -Unicode code points. Invalid Unicode code points will be replaced by -the “unknown code point” character (U+FFFD). For security reasons, -the code point U+0000 will also be replaced by U+FFFD.

-
-
Example 287  (interact)
-
&#35; &#1234; &#992; &#98765432; &#0;
-
-
<p># Ӓ Ϡ � �</p>
-
-
-

Hexadecimal entities consist of &# + either -X or x + a string of 1-8 hexadecimal digits + ;. They will also -be parsed and turned into the corresponding Unicode code points in the -AST.

-
-
Example 288  (interact)
-
&#X22; &#XD06; &#xcab;
-
-
<p>&quot; ആ ಫ</p>
-
-
-

Here are some nonentities:

-
-
Example 289  (interact)
-
&nbsp &x; &#; &#x; &ThisIsWayTooLongToBeAnEntityIsntIt; &hi?;
-
-
<p>&amp;nbsp &amp;x; &amp;#; &amp;#x; &amp;ThisIsWayTooLongToBeAnEntityIsntIt; &amp;hi?;</p>
-
-
-

Although HTML5 does accept some entities without a trailing semicolon -(such as &copy), these are not recognized as entities here, because it -makes the grammar too ambiguous:

-
-
Example 290  (interact)
-
&copy
-
-
<p>&amp;copy</p>
-
-
-

Strings that are not on the list of HTML5 named entities are not -recognized as entities either:

-
-
Example 291  (interact)
-
&MadeUpEntity;
-
-
<p>&amp;MadeUpEntity;</p>
-
-
-

Entities are recognized in any context besides code spans or -code blocks, including raw HTML, URLs, link titles, and -fenced code blocks:

-
-
Example 292  (interact)
-
<a href="&ouml;&ouml;.html">
-
-
<a href="&ouml;&ouml;.html">
-
-
-
-
Example 293  (interact)
-
[foo](/f&ouml;&ouml; "f&ouml;&ouml;")
-
-
<p><a href="/f%C3%B6%C3%B6" title="föö">foo</a></p>
-
-
-
-
Example 294  (interact)
-
[foo]
-
-[foo]: /f&ouml;&ouml; "f&ouml;&ouml;"
-
-
<p><a href="/f%C3%B6%C3%B6" title="föö">foo</a></p>
-
-
-
-
Example 295  (interact)
-
``` f&ouml;&ouml;
-foo
-```
-
-
<pre><code class="language-föö">foo
-</code></pre>
-
-
-

Entities are treated as literal text in code spans and code blocks:

-
-
Example 296  (interact)
-
`f&ouml;&ouml;`
-
-
<p><code>f&amp;ouml;&amp;ouml;</code></p>
-
-
-
-
Example 297  (interact)
-
    f&ouml;f&ouml;
-
-
<pre><code>f&amp;ouml;f&amp;ouml;
-</code></pre>
-
-
-

6.3 Code spans

-

A backtick string -is a string of one or more backtick characters (`) that is neither -preceded nor followed by a backtick.

-

A code span begins with a backtick string and ends with -a backtick string of equal length. The contents of the code span are -the characters between the two backtick strings, with leading and -trailing spaces and line endings removed, and -whitespace collapsed to single spaces.

-

This is a simple code span:

-
-
Example 298  (interact)
-
`foo`
-
-
<p><code>foo</code></p>
-
-
-

Here two backticks are used, because the code contains a backtick. -This example also illustrates stripping of leading and trailing spaces:

-
-
Example 299  (interact)
-
`` foo ` bar  ``
-
-
<p><code>foo ` bar</code></p>
-
-
-

This example shows the motivation for stripping leading and trailing -spaces:

-
-
Example 300  (interact)
-
` `` `
-
-
<p><code>``</code></p>
-
-
-

Line endings are treated like spaces:

-
-
Example 301  (interact)
-
``
-foo
-``
-
-
<p><code>foo</code></p>
-
-
-

Interior spaces and line endings are collapsed into -single spaces, just as they would be by a browser:

-
-
Example 302  (interact)
-
`foo   bar
-  baz`
-
-
<p><code>foo bar baz</code></p>
-
-
-

Q: Why not just leave the spaces, since browsers will collapse them -anyway? A: Because we might be targeting a non-HTML format, and we -shouldn’t rely on HTML-specific rendering assumptions.

-

(Existing implementations differ in their treatment of internal -spaces and line endings. Some, including Markdown.pl and -showdown, convert an internal line ending into a -<br /> tag. But this makes things difficult for those who like to -hard-wrap their paragraphs, since a line break in the midst of a code -span will cause an unintended line break in the output. Others just -leave internal spaces as they are, which is fine if only HTML is being -targeted.)

-
-
Example 303  (interact)
-
`foo `` bar`
-
-
<p><code>foo `` bar</code></p>
-
-
-

Note that backslash escapes do not work in code spans. All backslashes -are treated literally:

-
-
Example 304  (interact)
-
`foo\`bar`
-
-
<p><code>foo\</code>bar`</p>
-
-
-

Backslash escapes are never needed, because one can always choose a -string of n backtick characters as delimiters, where the code does -not contain any strings of exactly n backtick characters.

-

Code span backticks have higher precedence than any other inline -constructs except HTML tags and autolinks. Thus, for example, this is -not parsed as emphasized text, since the second * is part of a code -span:

-
-
Example 305  (interact)
-
*foo`*`
-
-
<p>*foo<code>*</code></p>
-
-
-

And this is not parsed as a link:

-
-
Example 306  (interact)
-
[not a `link](/foo`)
-
-
<p>[not a <code>link](/foo</code>)</p>
-
-
-

Code spans, HTML tags, and autolinks have the same precedence. -Thus, this is code:

-
-
Example 307  (interact)
-
`<a href="`">`
-
-
<p><code>&lt;a href=&quot;</code>&quot;&gt;`</p>
-
-
-

But this is an HTML tag:

-
-
Example 308  (interact)
-
<a href="`">`
-
-
<p><a href="`">`</p>
-
-
-

And this is code:

-
-
Example 309  (interact)
-
`<http://foo.bar.`baz>`
-
-
<p><code>&lt;http://foo.bar.</code>baz&gt;`</p>
-
-
-

But this is an autolink:

-
-
Example 310  (interact)
-
<http://foo.bar.`baz>`
-
-
<p><a href="http://foo.bar.%60baz">http://foo.bar.`baz</a>`</p>
-
-
-

When a backtick string is not closed by a matching backtick string, -we just have literal backticks:

-
-
Example 311  (interact)
-
```foo``
-
-
<p>```foo``</p>
-
-
-
-
Example 312  (interact)
-
`foo
-
-
<p>`foo</p>
-
-
-

6.4 Emphasis and strong emphasis

-

John Gruber’s original Markdown syntax -description says:

-
-

Markdown treats asterisks (*) and underscores (_) as indicators of -emphasis. 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 original -Markdown.pl test suite makes it clear that triple *** and -___ delimiters can be used for strong emphasis, and most -implementations 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 intent -is clear and they are useful (especially in contexts like bibliography -entries):

-
*emph *with emph* in it*
-**strong **with strong** in it**
-
-

Many implementations have also restricted intraword emphasis to -the * forms, to avoid unwanted emphasis in words containing -internal underscores. (It is best practice to put these in code -spans, but users often do not.)

-
internal emphasis: foo*bar*baz
-no emphasis: foo_bar_baz
-
-

The rules given below capture all of these patterns, while allowing -for efficient parsing strategies that do not backtrack.

-

First, some definitions. A delimiter run is either -a sequence of one or more * characters that is not preceded or -followed by a * character, or a sequence of one or more _ -characters that is not preceded or followed by a _ character.

-

A left-flanking delimiter run is -a delimiter run that is (a) not followed by Unicode whitespace, -and (b) either not followed by a punctuation character, or -preceded by Unicode whitespace or a punctuation character. -For purposes of this definition, the beginning and the end of -the line count as Unicode whitespace.

-

A right-flanking delimiter run is -a delimiter run that is (a) not preceded by Unicode whitespace, -and (b) either not preceded by a punctuation character, or -followed by Unicode whitespace or a punctuation character. -For purposes of this definition, the beginning and the end of -the line count as Unicode whitespace.

-

Here are some examples of delimiter runs.

- -

(The idea of distinguishing left-flanking and right-flanking -delimiter runs based on the character before and the character -after comes from Roopesh Chander’s -vfmd. -vfmd uses the terminology “emphasis indicator string” instead of “delimiter -run,” and its rules for distinguishing left- and right-flanking runs -are a bit more complex than the ones given here.)

-

The following rules define emphasis and strong emphasis:

-
    -
  1. -

    A single * character can open emphasis -iff (if and only if) it is part of a left-flanking delimiter run.

    -
    2. -
  2. -

    A single _ character can open emphasis iff -it is part of a left-flanking delimiter run -and either (a) not part of a right-flanking delimiter run -or (b) part of a [right-flanking delimeter run] -preceded by punctuation.

    -
    3. -
  3. -

    A single * character can close emphasis -iff it is part of a right-flanking delimiter run.

    -
    4. -
  4. -

    A single _ character can close emphasis iff -it is part of a right-flanking delimiter run -and either (a) not part of a left-flanking delimiter run -or (b) part of a [left-flanking delimeter run] -followed by punctuation.

    -
    5. -
  5. -

    A double ** can open strong emphasis -iff it is part of a left-flanking delimiter run.

    -
    6. -
  6. -

    A double __ can open strong emphasis iff -it is part of a left-flanking delimiter run -and either (a) not part of a right-flanking delimiter run -or (b) part of a [right-flanking delimeter run] -preceded by punctuation.

    -
    7. -
  7. -

    A double ** can close strong emphasis -iff it is part of a right-flanking delimiter run.

    -
    8. -
  8. -

    A double __ can close strong emphasis -it is part of a right-flanking delimiter run -and either (a) not part of a left-flanking delimiter run -or (b) part of a [left-flanking delimeter run] -followed by punctuation.

    -
    9. -
  9. -

    Emphasis begins with a delimiter that can open emphasis and ends -with a delimiter that can close emphasis, and that uses the same -character (_ or *) as the opening delimiter. There must -be a nonempty sequence of inlines between the open delimiter -and the closing delimiter; these form the contents of the emphasis -inline.

    -
    10. -
  10. -

    Strong emphasis begins with a delimiter that -can open strong emphasis and ends with a delimiter that -can close strong emphasis, and that uses the same character -(_ or *) as the opening delimiter. -There must be a nonempty sequence of inlines between the open -delimiter and the closing delimiter; these form the contents of -the strong emphasis inline.

    -
    11. -
  11. -

    A literal * character cannot occur at the beginning or end of -*-delimited emphasis or **-delimited strong emphasis, unless it -is backslash-escaped.

    -
    12. -
  12. -

    A literal _ character cannot occur at the beginning or end of -_-delimited emphasis or __-delimited strong emphasis, unless it -is backslash-escaped.

    -
    13. -
-

Where rules 1–12 above are compatible with multiple parsings, -the following principles resolve ambiguity:

-
    -
  1. -

    The number of nestings should be minimized. Thus, for example, -an interpretation <strong>...</strong> is always preferred to -<em><em>...</em></em>.

    -
    2. -
  2. -

    An interpretation <strong><em>...</em></strong> is always -preferred to <em><strong>..</strong></em>.

    -
    3. -
  3. -

    When two potential emphasis or strong emphasis spans overlap, -so that the second begins before the first ends and ends after -the first ends, the first takes precedence. Thus, for example, -*foo _bar* baz_ is parsed as <em>foo _bar</em> baz_ rather -than *foo <em>bar* baz</em>. For the same reason, -**foo*bar** is parsed as <em><em>foo</em>bar</em>* -rather than <strong>foo*bar</strong>.

    -
    4. -
  4. -

    When there are two potential emphasis or strong emphasis spans -with the same closing delimiter, the shorter one (the one that -opens later) takes precedence. Thus, for example, -**foo **bar baz** is parsed as **foo <strong>bar baz</strong> -rather than <strong>foo **bar baz</strong>.

    -
    5. -
  5. -

    Inline code spans, links, images, and HTML tags group more tightly -than emphasis. So, when there is a choice between an interpretation -that contains one of these elements and one that does not, the -former always wins. Thus, for example, *[foo*](bar) is -parsed as *<a href="bar">foo*</a> rather than as -<em>[foo</em>](bar).

    -
    6. -
-

These rules can be illustrated through a series of examples.

-

Rule 1:

-
-
Example 313  (interact)
-
*foo bar*
-
-
<p><em>foo bar</em></p>
-
-
-

This is not emphasis, because the opening * is followed by -whitespace, and hence not part of a left-flanking delimiter run:

-
-
Example 314  (interact)
-
a * foo bar*
-
-
<p>a * foo bar*</p>
-
-
-

This is not emphasis, because the opening * is preceded -by an alphanumeric and followed by punctuation, and hence -not part of a left-flanking delimiter run:

-
-
Example 315  (interact)
-
a*"foo"*
-
-
<p>a*&quot;foo&quot;*</p>
-
-
-

Unicode nonbreaking spaces count as whitespace, too:

-
-
Example 316  (interact)
-
* a *
-
-
<p>* a *</p>
-
-
-

Intraword emphasis with * is permitted:

-
-
Example 317  (interact)
-
foo*bar*
-
-
<p>foo<em>bar</em></p>
-
-
-
-
Example 318  (interact)
-
5*6*78
-
-
<p>5<em>6</em>78</p>
-
-
-

Rule 2:

-
-
Example 319  (interact)
-
_foo bar_
-
-
<p><em>foo bar</em></p>
-
-
-

This is not emphasis, because the opening _ is followed by -whitespace:

-
-
Example 320  (interact)
-
_ foo bar_
-
-
<p>_ foo bar_</p>
-
-
-

This is not emphasis, because the opening _ is preceded -by an alphanumeric and followed by punctuation:

-
-
Example 321  (interact)
-
a_"foo"_
-
-
<p>a_&quot;foo&quot;_</p>
-
-
-

Emphasis with _ is not allowed inside words:

-
-
Example 322  (interact)
-
foo_bar_
-
-
<p>foo_bar_</p>
-
-
-
-
Example 323  (interact)
-
5_6_78
-
-
<p>5_6_78</p>
-
-
-
-
Example 324  (interact)
-
пристаням_стремятся_
-
-
<p>пристаням_стремятся_</p>
-
-
-

Here _ does not generate emphasis, because the first delimiter run -is right-flanking and the second left-flanking:

-
-
Example 325  (interact)
-
aa_"bb"_cc
-
-
<p>aa_&quot;bb&quot;_cc</p>
-
-
-

This is emphasis, even though the opening delimiter is -both left- and right-flanking, because it is preceded by -punctuation:

-
-
Example 326  (interact)
-
foo-_(bar)_
-
-
<p>foo-<em>(bar)</em></p>
-
-
-

Rule 3:

-

This is not emphasis, because the closing delimiter does -not match the opening delimiter:

-
-
Example 327  (interact)
-
_foo*
-
-
<p>_foo*</p>
-
-
-

This is not emphasis, because the closing * is preceded by -whitespace:

-
-
Example 328  (interact)
-
*foo bar *
-
-
<p>*foo bar *</p>
-
-
-

A newline also counts as whitespace:

-
-
Example 329  (interact)
-
*foo bar
-*
-
-
<p>*foo bar</p>
-<ul>
-<li></li>
-</ul>
-
-
-

This is not emphasis, because the second * is -preceded by punctuation and followed by an alphanumeric -(hence it is not part of a right-flanking delimiter run:

-
-
Example 330  (interact)
-
*(*foo)
-
-
<p>*(*foo)</p>
-
-
-

The point of this restriction is more easily appreciated -with this example:

-
-
Example 331  (interact)
-
*(*foo*)*
-
-
<p><em>(<em>foo</em>)</em></p>
-
-
-

Intraword emphasis with * is allowed:

-
-
Example 332  (interact)
-
*foo*bar
-
-
<p><em>foo</em>bar</p>
-
-
-

Rule 4:

-

This is not emphasis, because the closing _ is preceded by -whitespace:

-
-
Example 333  (interact)
-
_foo bar _
-
-
<p>_foo bar _</p>
-
-
-

This is not emphasis, because the second _ is -preceded by punctuation and followed by an alphanumeric:

-
-
Example 334  (interact)
-
_(_foo)
-
-
<p>_(_foo)</p>
-
-
-

This is emphasis within emphasis:

-
-
Example 335  (interact)
-
_(_foo_)_
-
-
<p><em>(<em>foo</em>)</em></p>
-
-
-

Intraword emphasis is disallowed for _:

-
-
Example 336  (interact)
-
_foo_bar
-
-
<p>_foo_bar</p>
-
-
-
-
Example 337  (interact)
-
_пристаням_стремятся
-
-
<p>_пристаням_стремятся</p>
-
-
-
-
Example 338  (interact)
-
_foo_bar_baz_
-
-
<p><em>foo_bar_baz</em></p>
-
-
-

This is emphasis, even though the closing delimiter is -both left- and right-flanking, because it is followed by -punctuation:

-
-
Example 339  (interact)
-
_(bar)_.
-
-
<p><em>(bar)</em>.</p>
-
-
-

Rule 5:

-
-
Example 340  (interact)
-
**foo bar**
-
-
<p><strong>foo bar</strong></p>
-
-
-

This is not strong emphasis, because the opening delimiter is -followed by whitespace:

-
-
Example 341  (interact)
-
** foo bar**
-
-
<p>** foo bar**</p>
-
-
-

This is not strong emphasis, because the opening ** is preceded -by an alphanumeric and followed by punctuation, and hence -not part of a left-flanking delimiter run:

-
-
Example 342  (interact)
-
a**"foo"**
-
-
<p>a**&quot;foo&quot;**</p>
-
-
-

Intraword strong emphasis with ** is permitted:

-
-
Example 343  (interact)
-
foo**bar**
-
-
<p>foo<strong>bar</strong></p>
-
-
-

Rule 6:

-
-
Example 344  (interact)
-
__foo bar__
-
-
<p><strong>foo bar</strong></p>
-
-
-

This is not strong emphasis, because the opening delimiter is -followed by whitespace:

-
-
Example 345  (interact)
-
__ foo bar__
-
-
<p>__ foo bar__</p>
-
-
-

A newline counts as whitespace:

-
-
Example 346  (interact)
-
__
-foo bar__
-
-
<p>__
-foo bar__</p>
-
-
-

This is not strong emphasis, because the opening __ is preceded -by an alphanumeric and followed by punctuation:

-
-
Example 347  (interact)
-
a__"foo"__
-
-
<p>a__&quot;foo&quot;__</p>
-
-
-

Intraword strong emphasis is forbidden with __:

-
-
Example 348  (interact)
-
foo__bar__
-
-
<p>foo__bar__</p>
-
-
-
-
Example 349  (interact)
-
5__6__78
-
-
<p>5__6__78</p>
-
-
-
-
Example 350  (interact)
-
пристаням__стремятся__
-
-
<p>пристаням__стремятся__</p>
-
-
-
-
Example 351  (interact)
-
__foo, __bar__, baz__
-
-
<p><strong>foo, <strong>bar</strong>, baz</strong></p>
-
-
-

This is strong emphasis, even though the opening delimiter is -both left- and right-flanking, because it is preceded by -punctuation:

-
-
Example 352  (interact)
-
foo-__(bar)__
-
-
<p>foo-<strong>(bar)</strong></p>
-
-
-

Rule 7:

-

This is not strong emphasis, because the closing delimiter is preceded -by whitespace:

-
-
Example 353  (interact)
-
**foo bar **
-
-
<p>**foo bar **</p>
-
-
-

(Nor can it be interpreted as an emphasized *foo bar *, because of -Rule 11.)

-

This is not strong emphasis, because the second ** is -preceded by punctuation and followed by an alphanumeric:

-
-
Example 354  (interact)
-
**(**foo)
-
-
<p>**(**foo)</p>
-
-
-

The point of this restriction is more easily appreciated -with these examples:

-
-
Example 355  (interact)
-
*(**foo**)*
-
-
<p><em>(<strong>foo</strong>)</em></p>
-
-
-
-
Example 356  (interact)
-
**Gomphocarpus (*Gomphocarpus physocarpus*, syn.
-*Asclepias physocarpa*)**
-
-
<p><strong>Gomphocarpus (<em>Gomphocarpus physocarpus</em>, syn.
-<em>Asclepias physocarpa</em>)</strong></p>
-
-
-
-
Example 357  (interact)
-
**foo "*bar*" foo**
-
-
<p><strong>foo &quot;<em>bar</em>&quot; foo</strong></p>
-
-
-

Intraword emphasis:

-
-
Example 358  (interact)
-
**foo**bar
-
-
<p><strong>foo</strong>bar</p>
-
-
-

Rule 8:

-

This is not strong emphasis, because the closing delimiter is -preceded by whitespace:

-
-
Example 359  (interact)
-
__foo bar __
-
-
<p>__foo bar __</p>
-
-
-

This is not strong emphasis, because the second __ is -preceded by punctuation and followed by an alphanumeric:

-
-
Example 360  (interact)
-
__(__foo)
-
-
<p>__(__foo)</p>
-
-
-

The point of this restriction is more easily appreciated -with this example:

-
-
Example 361  (interact)
-
_(__foo__)_
-
-
<p><em>(<strong>foo</strong>)</em></p>
-
-
-

Intraword strong emphasis is forbidden with __:

-
-
Example 362  (interact)
-
__foo__bar
-
-
<p>__foo__bar</p>
-
-
-
-
Example 363  (interact)
-
__пристаням__стремятся
-
-
<p>__пристаням__стремятся</p>
-
-
-
-
Example 364  (interact)
-
__foo__bar__baz__
-
-
<p><strong>foo__bar__baz</strong></p>
-
-
-

This is strong emphasis, even though the closing delimiter is -both left- and right-flanking, because it is followed by -punctuation:

-
-
Example 365  (interact)
-
__(bar)__.
-
-
<p><strong>(bar)</strong>.</p>
-
-
-

Rule 9:

-

Any nonempty sequence of inline elements can be the contents of an -emphasized span.

-
-
Example 366  (interact)
-
*foo [bar](/url)*
-
-
<p><em>foo <a href="/url">bar</a></em></p>
-
-
-
-
Example 367  (interact)
-
*foo
-bar*
-
-
<p><em>foo
-bar</em></p>
-
-
-

In particular, emphasis and strong emphasis can be nested -inside emphasis:

-
-
Example 368  (interact)
-
_foo __bar__ baz_
-
-
<p><em>foo <strong>bar</strong> baz</em></p>
-
-
-
-
Example 369  (interact)
-
_foo _bar_ baz_
-
-
<p><em>foo <em>bar</em> baz</em></p>
-
-
-
-
Example 370  (interact)
-
__foo_ bar_
-
-
<p><em><em>foo</em> bar</em></p>
-
-
-
-
Example 371  (interact)
-
*foo *bar**
-
-
<p><em>foo <em>bar</em></em></p>
-
-
-
-
Example 372  (interact)
-
*foo **bar** baz*
-
-
<p><em>foo <strong>bar</strong> baz</em></p>
-
-
-

But note:

-
-
Example 373  (interact)
-
*foo**bar**baz*
-
-
<p><em>foo</em><em>bar</em><em>baz</em></p>
-
-
-

The difference is that in the preceding case, the internal delimiters -can close emphasis, while in the cases with spaces, they cannot.

-
-
Example 374  (interact)
-
***foo** bar*
-
-
<p><em><strong>foo</strong> bar</em></p>
-
-
-
-
Example 375  (interact)
-
*foo **bar***
-
-
<p><em>foo <strong>bar</strong></em></p>
-
-
-

Note, however, that in the following case we get no strong -emphasis, because the opening delimiter is closed by the first -* before bar:

-
-
Example 376  (interact)
-
*foo**bar***
-
-
<p><em>foo</em><em>bar</em>**</p>
-
-
-

Indefinite levels of nesting are possible:

-
-
Example 377  (interact)
-
*foo **bar *baz* bim** bop*
-
-
<p><em>foo <strong>bar <em>baz</em> bim</strong> bop</em></p>
-
-
-
-
Example 378  (interact)
-
*foo [*bar*](/url)*
-
-
<p><em>foo <a href="/url"><em>bar</em></a></em></p>
-
-
-

There can be no empty emphasis or strong emphasis:

-
-
Example 379  (interact)
-
** is not an empty emphasis
-
-
<p>** is not an empty emphasis</p>
-
-
-
-
Example 380  (interact)
-
**** is not an empty strong emphasis
-
-
<p>**** is not an empty strong emphasis</p>
-
-
-

Rule 10:

-

Any nonempty sequence of inline elements can be the contents of an -strongly emphasized span.

-
-
Example 381  (interact)
-
**foo [bar](/url)**
-
-
<p><strong>foo <a href="/url">bar</a></strong></p>
-
-
-
-
Example 382  (interact)
-
**foo
-bar**
-
-
<p><strong>foo
-bar</strong></p>
-
-
-

In particular, emphasis and strong emphasis can be nested -inside strong emphasis:

-
-
Example 383  (interact)
-
__foo _bar_ baz__
-
-
<p><strong>foo <em>bar</em> baz</strong></p>
-
-
-
-
Example 384  (interact)
-
__foo __bar__ baz__
-
-
<p><strong>foo <strong>bar</strong> baz</strong></p>
-
-
-
-
Example 385  (interact)
-
____foo__ bar__
-
-
<p><strong><strong>foo</strong> bar</strong></p>
-
-
-
-
Example 386  (interact)
-
**foo **bar****
-
-
<p><strong>foo <strong>bar</strong></strong></p>
-
-
-
-
Example 387  (interact)
-
**foo *bar* baz**
-
-
<p><strong>foo <em>bar</em> baz</strong></p>
-
-
-

But note:

-
-
Example 388  (interact)
-
**foo*bar*baz**
-
-
<p><em><em>foo</em>bar</em>baz**</p>
-
-
-

The difference is that in the preceding case, the internal delimiters -can close emphasis, while in the cases with spaces, they cannot.

-
-
Example 389  (interact)
-
***foo* bar**
-
-
<p><strong><em>foo</em> bar</strong></p>
-
-
-
-
Example 390  (interact)
-
**foo *bar***
-
-
<p><strong>foo <em>bar</em></strong></p>
-
-
-

Indefinite levels of nesting are possible:

-
-
Example 391  (interact)
-
**foo *bar **baz**
-bim* bop**
-
-
<p><strong>foo <em>bar <strong>baz</strong>
-bim</em> bop</strong></p>
-
-
-
-
Example 392  (interact)
-
**foo [*bar*](/url)**
-
-
<p><strong>foo <a href="/url"><em>bar</em></a></strong></p>
-
-
-

There can be no empty emphasis or strong emphasis:

-
-
Example 393  (interact)
-
__ is not an empty emphasis
-
-
<p>__ is not an empty emphasis</p>
-
-
-
-
Example 394  (interact)
-
____ is not an empty strong emphasis
-
-
<p>____ is not an empty strong emphasis</p>
-
-
-

Rule 11:

-
-
Example 395  (interact)
-
foo ***
-
-
<p>foo ***</p>
-
-
-
-
Example 396  (interact)
-
foo *\**
-
-
<p>foo <em>*</em></p>
-
-
-
-
Example 397  (interact)
-
foo *_*
-
-
<p>foo <em>_</em></p>
-
-
-
-
Example 398  (interact)
-
foo *****
-
-
<p>foo *****</p>
-
-
-
-
Example 399  (interact)
-
foo **\***
-
-
<p>foo <strong>*</strong></p>
-
-
-
-
Example 400  (interact)
-
foo **_**
-
-
<p>foo <strong>_</strong></p>
-
-
-

Note that when delimiters do not match evenly, Rule 11 determines -that the excess literal * characters will appear outside of the -emphasis, rather than inside it:

-
-
Example 401  (interact)
-
**foo*
-
-
<p>*<em>foo</em></p>
-
-
-
-
Example 402  (interact)
-
*foo**
-
-
<p><em>foo</em>*</p>
-
-
-
-
Example 403  (interact)
-
***foo**
-
-
<p>*<strong>foo</strong></p>
-
-
-
-
Example 404  (interact)
-
****foo*
-
-
<p>***<em>foo</em></p>
-
-
-
-
Example 405  (interact)
-
**foo***
-
-
<p><strong>foo</strong>*</p>
-
-
-
-
Example 406  (interact)
-
*foo****
-
-
<p><em>foo</em>***</p>
-
-
-

Rule 12:

-
-
Example 407  (interact)
-
foo ___
-
-
<p>foo ___</p>
-
-
-
-
Example 408  (interact)
-
foo _\__
-
-
<p>foo <em>_</em></p>
-
-
-
-
Example 409  (interact)
-
foo _*_
-
-
<p>foo <em>*</em></p>
-
-
-
-
Example 410  (interact)
-
foo _____
-
-
<p>foo _____</p>
-
-
-
-
Example 411  (interact)
-
foo __\___
-
-
<p>foo <strong>_</strong></p>
-
-
-
-
Example 412  (interact)
-
foo __*__
-
-
<p>foo <strong>*</strong></p>
-
-
-
-
Example 413  (interact)
-
__foo_
-
-
<p>_<em>foo</em></p>
-
-
-

Note that when delimiters do not match evenly, Rule 12 determines -that the excess literal _ characters will appear outside of the -emphasis, rather than inside it:

-
-
Example 414  (interact)
-
_foo__
-
-
<p><em>foo</em>_</p>
-
-
-
-
Example 415  (interact)
-
___foo__
-
-
<p>_<strong>foo</strong></p>
-
-
-
-
Example 416  (interact)
-
____foo_
-
-
<p>___<em>foo</em></p>
-
-
-
-
Example 417  (interact)
-
__foo___
-
-
<p><strong>foo</strong>_</p>
-
-
-
-
Example 418  (interact)
-
_foo____
-
-
<p><em>foo</em>___</p>
-
-
-

Rule 13 implies that if you want emphasis nested directly inside -emphasis, you must use different delimiters:

-
-
Example 419  (interact)
-
**foo**
-
-
<p><strong>foo</strong></p>
-
-
-
-
Example 420  (interact)
-
*_foo_*
-
-
<p><em><em>foo</em></em></p>
-
-
-
-
Example 421  (interact)
-
__foo__
-
-
<p><strong>foo</strong></p>
-
-
-
-
Example 422  (interact)
-
_*foo*_
-
-
<p><em><em>foo</em></em></p>
-
-
-

However, strong emphasis within strong emphasis is possible without -switching delimiters:

-
-
Example 423  (interact)
-
****foo****
-
-
<p><strong><strong>foo</strong></strong></p>
-
-
-
-
Example 424  (interact)
-
____foo____
-
-
<p><strong><strong>foo</strong></strong></p>
-
-
-

Rule 13 can be applied to arbitrarily long sequences of -delimiters:

-
-
Example 425  (interact)
-
******foo******
-
-
<p><strong><strong><strong>foo</strong></strong></strong></p>
-
-
-

Rule 14:

-
-
Example 426  (interact)
-
***foo***
-
-
<p><strong><em>foo</em></strong></p>
-
-
-
-
Example 427  (interact)
-
_____foo_____
-
-
<p><strong><strong><em>foo</em></strong></strong></p>
-
-
-

Rule 15:

-
-
Example 428  (interact)
-
*foo _bar* baz_
-
-
<p><em>foo _bar</em> baz_</p>
-
-
-
-
Example 429  (interact)
-
**foo*bar**
-
-
<p><em><em>foo</em>bar</em>*</p>
-
-
-
-
Example 430  (interact)
-
*foo __bar *baz bim__ bam*
-
-
<p><em>foo <strong>bar *baz bim</strong> bam</em></p>
-
-
-

Rule 16:

-
-
Example 431  (interact)
-
**foo **bar baz**
-
-
<p>**foo <strong>bar baz</strong></p>
-
-
-
-
Example 432  (interact)
-
*foo *bar baz*
-
-
<p>*foo <em>bar baz</em></p>
-
-
-

Rule 17:

-
-
Example 433  (interact)
-
*[bar*](/url)
-
-
<p>*<a href="/url">bar*</a></p>
-
-
-
-
Example 434  (interact)
-
_foo [bar_](/url)
-
-
<p>_foo <a href="/url">bar_</a></p>
-
-
-
-
Example 435  (interact)
-
*<img src="foo" title="*"/>
-
-
<p>*<img src="foo" title="*"/></p>
-
-
-
-
Example 436  (interact)
-
**<a href="**">
-
-
<p>**<a href="**"></p>
-
-
-
-
Example 437  (interact)
-
__<a href="__">
-
-
<p>__<a href="__"></p>
-
-
-
-
Example 438  (interact)
-
*a `*`*
-
-
<p><em>a <code>*</code></em></p>
-
-
-
-
Example 439  (interact)
-
_a `_`_
-
-
<p><em>a <code>_</code></em></p>
-
-
-
-
Example 440  (interact)
-
**a<http://foo.bar/?q=**>
-
-
<p>**a<a href="http://foo.bar/?q=**">http://foo.bar/?q=**</a></p>
-
-
-
-
Example 441  (interact)
-
__a<http://foo.bar/?q=__>
-
-
<p>__a<a href="http://foo.bar/?q=__">http://foo.bar/?q=__</a></p>
-
-
-

6.5 Links

-

A link contains link text (the visible text), a link destination -(the URI that is the link destination), and optionally a link title. -There are two basic kinds of links in Markdown. In inline links the -destination and title are given immediately after the link text. In -reference links the destination and title are defined elsewhere in -the document.

-

A link text consists of a sequence of zero or more -inline elements enclosed by square brackets ([ and ]). The -following rules apply:

- -

A link destination consists of either

- -

A link title consists of either

- -

Although link titles may span multiple lines, they may not contain -a blank line.

-

An inline link consists of a link text followed immediately -by a left parenthesis (, optional whitespace, an optional -link destination, an optional link title separated from the link -destination by whitespace, optional whitespace, and a right -parenthesis ). The link’s text consists of the inlines contained -in the link 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 described -above. The link’s title consists of the link title, excluding its -enclosing delimiters, with backslash-escapes in effect as described -above.

-

Here is a simple inline link:

-
-
Example 442  (interact)
-
[link](/uri "title")
-
-
<p><a href="/uri" title="title">link</a></p>
-
-
-

The title may be omitted:

-
-
Example 443  (interact)
-
[link](/uri)
-
-
<p><a href="/uri">link</a></p>
-
-
-

Both the title and the destination may be omitted:

-
-
Example 444  (interact)
-
[link]()
-
-
<p><a href="">link</a></p>
-
-
-
-
Example 445  (interact)
-
[link](<>)
-
-
<p><a href="">link</a></p>
-
-
-

If the destination contains spaces, it must be enclosed in pointy -braces:

-
-
Example 446  (interact)
-
[link](/my uri)
-
-
<p>[link](/my uri)</p>
-
-
-
-
Example 447  (interact)
-
[link](</my uri>)
-
-
<p><a href="/my%20uri">link</a></p>
-
-
-

The destination cannot contain line breaks, even with pointy braces:

-
-
Example 448  (interact)
-
[link](foo
-bar)
-
-
<p>[link](foo
-bar)</p>
-
-
-
-
Example 449  (interact)
-
[link](<foo
-bar>)
-
-
<p>[link](<foo
-bar>)</p>
-
-
-

One level of balanced parentheses is allowed without escaping:

-
-
Example 450  (interact)
-
[link]((foo)and(bar))
-
-
<p><a href="(foo)and(bar)">link</a></p>
-
-
-

However, if you have parentheses within parentheses, you need to escape -or use the <...> form:

-
-
Example 451  (interact)
-
[link](foo(and(bar)))
-
-
<p>[link](foo(and(bar)))</p>
-
-
-
-
Example 452  (interact)
-
[link](foo(and\(bar\)))
-
-
<p><a href="foo(and(bar))">link</a></p>
-
-
-
-
Example 453  (interact)
-
[link](<foo(and(bar))>)
-
-
<p><a href="foo(and(bar))">link</a></p>
-
-
-

Parentheses and other symbols can also be escaped, as usual -in Markdown:

-
-
Example 454  (interact)
-
[link](foo\)\:)
-
-
<p><a href="foo):">link</a></p>
-
-
-

A link can contain fragment identifiers and queries:

-
-
Example 455  (interact)
-
[link](#fragment)
-
-[link](http://example.com#fragment)
-
-[link](http://example.com?foo=bar&baz#fragment)
-
-
<p><a href="#fragment">link</a></p>
-<p><a href="http://example.com#fragment">link</a></p>
-<p><a href="http://example.com?foo=bar&amp;baz#fragment">link</a></p>
-
-
-

Note that a backslash before a non-escapable character is -just a backslash:

-
-
Example 456  (interact)
-
[link](foo\bar)
-
-
<p><a href="foo%5Cbar">link</a></p>
-
-
-

URL-escaping should be left alone inside the destination, as all -URL-escaped characters are also valid URL characters. HTML entities in -the destination will be parsed into the corresponding Unicode -code points, as usual, and optionally URL-escaped when written as HTML.

-
-
Example 457  (interact)
-
[link](foo%20b&auml;)
-
-
<p><a href="foo%20b%C3%A4">link</a></p>
-
-
-

Note that, because titles can often be parsed as destinations, -if you try to omit the destination and keep the title, you’ll -get unexpected results:

-
-
Example 458  (interact)
-
[link]("title")
-
-
<p><a href="%22title%22">link</a></p>
-
-
-

Titles may be in single quotes, double quotes, or parentheses:

-
-
Example 459  (interact)
-
[link](/url "title")
-[link](/url 'title')
-[link](/url (title))
-
-
<p><a href="/url" title="title">link</a>
-<a href="/url" title="title">link</a>
-<a href="/url" title="title">link</a></p>
-
-
-

Backslash escapes and entities may be used in titles:

-
-
Example 460  (interact)
-
[link](/url "title \"&quot;")
-
-
<p><a href="/url" title="title &quot;&quot;">link</a></p>
-
-
-

Nested balanced quotes are not allowed without escaping:

-
-
Example 461  (interact)
-
[link](/url "title "and" title")
-
-
<p>[link](/url &quot;title &quot;and&quot; title&quot;)</p>
-
-
-

But it is easy to work around this by using a different quote type:

-
-
Example 462  (interact)
-
[link](/url 'title "and" title')
-
-
<p><a href="/url" title="title &quot;and&quot; title">link</a></p>
-
-
-

(Note: Markdown.pl did allow double quotes inside a double-quoted -title, and its test suite included a test demonstrating this. -But it is hard to see a good rationale for the extra complexity this -brings, since there are already many ways—backslash escaping, -entities, or using a different quote type for the enclosing title—to -write titles containing double quotes. Markdown.pl’s handling of -titles has a number of other strange features. For example, it allows -single-quoted titles in inline links, but not reference links. And, in -reference links but not inline links, it allows a title to begin with -" and end with ). Markdown.pl 1.0.1 even allows titles with no closing -quotation mark, though 1.0.2b8 does not. It seems preferable to adopt -a simple, rational rule that works the same way in inline links and -link reference definitions.)

-

Whitespace is allowed around the destination and title:

-
-
Example 463  (interact)
-
[link](   /uri
-  "title"  )
-
-
<p><a href="/uri" title="title">link</a></p>
-
-
-

But it is not allowed between the link text and the -following parenthesis:

-
-
Example 464  (interact)
-
[link] (/uri)
-
-
<p>[link] (/uri)</p>
-
-
-

The link text may contain balanced brackets, but not unbalanced ones, -unless they are escaped:

-
-
Example 465  (interact)
-
[link [foo [bar]]](/uri)
-
-
<p><a href="/uri">link [foo [bar]]</a></p>
-
-
-
-
Example 466  (interact)
-
[link] bar](/uri)
-
-
<p>[link] bar](/uri)</p>
-
-
-
-
Example 467  (interact)
-
[link [bar](/uri)
-
-
<p>[link <a href="/uri">bar</a></p>
-
-
-
-
Example 468  (interact)
-
[link \[bar](/uri)
-
-
<p><a href="/uri">link [bar</a></p>
-
-
-

The link text may contain inline content:

-
-
Example 469  (interact)
-
[link *foo **bar** `#`*](/uri)
-
-
<p><a href="/uri">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>
-
-
-
-
Example 470  (interact)
-
[![moon](moon.jpg)](/uri)
-
-
<p><a href="/uri"><img src="moon.jpg" alt="moon" /></a></p>
-
-
-

However, links may not contain other links, at any level of nesting.

-
-
Example 471  (interact)
-
[foo [bar](/uri)](/uri)
-
-
<p>[foo <a href="/uri">bar</a>](/uri)</p>
-
-
-
-
Example 472  (interact)
-
[foo *[bar [baz](/uri)](/uri)*](/uri)
-
-
<p>[foo <em>[bar <a href="/uri">baz</a>](/uri)</em>](/uri)</p>
-
-
-
-
Example 473  (interact)
-
![[[foo](uri1)](uri2)](uri3)
-
-
<p><img src="uri3" alt="[foo](uri2)" /></p>
-
-
-

These cases illustrate the precedence of link text grouping over -emphasis grouping:

-
-
Example 474  (interact)
-
*[foo*](/uri)
-
-
<p>*<a href="/uri">foo*</a></p>
-
-
-
-
Example 475  (interact)
-
[foo *bar](baz*)
-
-
<p><a href="baz*">foo *bar</a></p>
-
-
-

Note that brackets that aren’t part of links do not take -precedence:

-
-
Example 476  (interact)
-
*foo [bar* baz]
-
-
<p><em>foo [bar</em> baz]</p>
-
-
-

These cases illustrate the precedence of HTML tags, code spans, -and autolinks over link grouping:

-
-
Example 477  (interact)
-
[foo <bar attr="](baz)">
-
-
<p>[foo <bar attr="](baz)"></p>
-
-
-
-
Example 478  (interact)
-
[foo`](/uri)`
-
-
<p>[foo<code>](/uri)</code></p>
-
-
-
-
Example 479  (interact)
-
[foo<http://example.com/?search=](uri)>
-
-
<p>[foo<a href="http://example.com/?search=%5D(uri)">http://example.com/?search=](uri)</a></p>
-
-
-

There are three kinds of reference links: -full, collapsed, -and shortcut.

-

A full reference link -consists of a link text, optional whitespace, and a link label -that matches a link reference definition elsewhere in the document.

-

A link label begins with a left bracket ([) and ends -with the first right bracket (]) that is not backslash-escaped. -Between these brackets there must be at least one non-whitespace character. -Unescaped square bracket characters are not allowed in -link labels. A link label can have at most 999 -characters inside the square brackets.

-

One label matches -another just in case their normalized forms are equal. To normalize a -label, perform the Unicode case fold and collapse consecutive internal -whitespace to a single space. If there are multiple -matching reference link definitions, the one that comes first in the -document is used. (It is desirable in such cases to emit a warning.)

-

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 are provided by the -matching link reference definition.

-

Here is a simple example:

-
-
Example 480  (interact)
-
[foo][bar]
-
-[bar]: /url "title"
-
-
<p><a href="/url" title="title">foo</a></p>
-
-
-

The rules for the link text are the same as with -inline links. Thus:

-

The link text may contain balanced brackets, but not unbalanced ones, -unless they are escaped:

-
-
Example 481  (interact)
-
[link [foo [bar]]][ref]
-
-[ref]: /uri
-
-
<p><a href="/uri">link [foo [bar]]</a></p>
-
-
-
-
Example 482  (interact)
-
[link \[bar][ref]
-
-[ref]: /uri
-
-
<p><a href="/uri">link [bar</a></p>
-
-
-

The link text may contain inline content:

-
-
Example 483  (interact)
-
[link *foo **bar** `#`*][ref]
-
-[ref]: /uri
-
-
<p><a href="/uri">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>
-
-
-
-
Example 484  (interact)
-
[![moon](moon.jpg)][ref]
-
-[ref]: /uri
-
-
<p><a href="/uri"><img src="moon.jpg" alt="moon" /></a></p>
-
-
-

However, links may not contain other links, at any level of nesting.

-
-
Example 485  (interact)
-
[foo [bar](/uri)][ref]
-
-[ref]: /uri
-
-
<p>[foo <a href="/uri">bar</a>]<a href="/uri">ref</a></p>
-
-
-
-
Example 486  (interact)
-
[foo *bar [baz][ref]*][ref]
-
-[ref]: /uri
-
-
<p>[foo <em>bar <a href="/uri">baz</a></em>]<a href="/uri">ref</a></p>
-
-
-

(In the examples above, we have two shortcut reference links -instead of one full reference link.)

-

The following cases illustrate the precedence of link text grouping over -emphasis grouping:

-
-
Example 487  (interact)
-
*[foo*][ref]
-
-[ref]: /uri
-
-
<p>*<a href="/uri">foo*</a></p>
-
-
-
-
Example 488  (interact)
-
[foo *bar][ref]
-
-[ref]: /uri
-
-
<p><a href="/uri">foo *bar</a></p>
-
-
-

These cases illustrate the precedence of HTML tags, code spans, -and autolinks over link grouping:

-
-
Example 489  (interact)
-
[foo <bar attr="][ref]">
-
-[ref]: /uri
-
-
<p>[foo <bar attr="][ref]"></p>
-
-
-
-
Example 490  (interact)
-
[foo`][ref]`
-
-[ref]: /uri
-
-
<p>[foo<code>][ref]</code></p>
-
-
-
-
Example 491  (interact)
-
[foo<http://example.com/?search=][ref]>
-
-[ref]: /uri
-
-
<p>[foo<a href="http://example.com/?search=%5D%5Bref%5D">http://example.com/?search=][ref]</a></p>
-
-
-

Matching is case-insensitive:

-
-
Example 492  (interact)
-
[foo][BaR]
-
-[bar]: /url "title"
-
-
<p><a href="/url" title="title">foo</a></p>
-
-
-

Unicode case fold is used:

-
-
Example 493  (interact)
-
[Толпой][Толпой] is a Russian word.
-
-[ТОЛПОЙ]: /url
-
-
<p><a href="/url">Толпой</a> is a Russian word.</p>
-
-
-

Consecutive internal whitespace is treated as one space for -purposes of determining matching:

-
-
Example 494  (interact)
-
[Foo
-  bar]: /url
-
-[Baz][Foo bar]
-
-
<p><a href="/url">Baz</a></p>
-
-
-

There can be whitespace between the link text and the link label:

-
-
Example 495  (interact)
-
[foo] [bar]
-
-[bar]: /url "title"
-
-
<p><a href="/url" title="title">foo</a></p>
-
-
-
-
Example 496  (interact)
-
[foo]
-[bar]
-
-[bar]: /url "title"
-
-
<p><a href="/url" title="title">foo</a></p>
-
-
-

When there are multiple matching link reference definitions, -the first is used:

-
-
Example 497  (interact)
-
[foo]: /url1
-
-[foo]: /url2
-
-[bar][foo]
-
-
<p><a href="/url1">bar</a></p>
-
-
-

Note that matching is performed on normalized strings, not parsed -inline content. So the following does not match, even though the -labels define equivalent inline content:

-
-
Example 498  (interact)
-
[bar][foo\!]
-
-[foo!]: /url
-
-
<p>[bar][foo!]</p>
-
-
-

Link labels cannot contain brackets, unless they are -backslash-escaped:

-
-
Example 499  (interact)
-
[foo][ref[]
-
-[ref[]: /uri
-
-
<p>[foo][ref[]</p>
-<p>[ref[]: /uri</p>
-
-
-
-
Example 500  (interact)
-
[foo][ref[bar]]
-
-[ref[bar]]: /uri
-
-
<p>[foo][ref[bar]]</p>
-<p>[ref[bar]]: /uri</p>
-
-
-
-
Example 501  (interact)
-
[[[foo]]]
-
-[[[foo]]]: /url
-
-
<p>[[[foo]]]</p>
-<p>[[[foo]]]: /url</p>
-
-
-
-
Example 502  (interact)
-
[foo][ref\[]
-
-[ref\[]: /uri
-
-
<p><a href="/uri">foo</a></p>
-
-
-

A link label must contain at least one non-whitespace character:

-
-
Example 503  (interact)
-
[]
-
-[]: /uri
-
-
<p>[]</p>
-<p>[]: /uri</p>
-
-
-
-
Example 504  (interact)
-
[
- ]
-
-[
- ]: /uri
-
-
<p>[
-]</p>
-<p>[
-]: /uri</p>
-
-
-

A collapsed reference link -consists of a link label that matches a -link reference definition elsewhere in the -document, optional whitespace, and 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 are -provided by the matching reference link definition. Thus, -[foo][] is equivalent to [foo][foo].

-
-
Example 505  (interact)
-
[foo][]
-
-[foo]: /url "title"
-
-
<p><a href="/url" title="title">foo</a></p>
-
-
-
-
Example 506  (interact)
-
[*foo* bar][]
-
-[*foo* bar]: /url "title"
-
-
<p><a href="/url" title="title"><em>foo</em> bar</a></p>
-
-
-

The link labels are case-insensitive:

-
-
Example 507  (interact)
-
[Foo][]
-
-[foo]: /url "title"
-
-
<p><a href="/url" title="title">Foo</a></p>
-
-
-

As with full reference links, whitespace is allowed -between the two sets of brackets:

-
-
Example 508  (interact)
-
[foo] 
-[]
-
-[foo]: /url "title"
-
-
<p><a href="/url" title="title">foo</a></p>
-
-
-

A shortcut reference link -consists of a link label that matches a -link reference definition elsewhere in the -document 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 title -are provided by the matching link reference definition. -Thus, [foo] is equivalent to [foo][].

-
-
Example 509  (interact)
-
[foo]
-
-[foo]: /url "title"
-
-
<p><a href="/url" title="title">foo</a></p>
-
-
-
-
Example 510  (interact)
-
[*foo* bar]
-
-[*foo* bar]: /url "title"
-
-
<p><a href="/url" title="title"><em>foo</em> bar</a></p>
-
-
-
-
Example 511  (interact)
-
[[*foo* bar]]
-
-[*foo* bar]: /url "title"
-
-
<p>[<a href="/url" title="title"><em>foo</em> bar</a>]</p>
-
-
-
-
Example 512  (interact)
-
[[bar [foo]
-
-[foo]: /url
-
-
<p>[[bar <a href="/url">foo</a></p>
-
-
-

The link labels are case-insensitive:

-
-
Example 513  (interact)
-
[Foo]
-
-[foo]: /url "title"
-
-
<p><a href="/url" title="title">Foo</a></p>
-
-
-

A space after the link text should be preserved:

-
-
Example 514  (interact)
-
[foo] bar
-
-[foo]: /url
-
-
<p><a href="/url">foo</a> bar</p>
-
-
-

If you just want bracketed text, you can backslash-escape the -opening bracket to avoid links:

-
-
Example 515  (interact)
-
\[foo]
-
-[foo]: /url "title"
-
-
<p>[foo]</p>
-
-
-

Note that this is a link, because a link label ends with the first -following closing bracket:

-
-
Example 516  (interact)
-
[foo*]: /url
-
-*[foo*]
-
-
<p>*<a href="/url">foo*</a></p>
-
-
-

Full references take precedence over shortcut references:

-
-
Example 517  (interact)
-
[foo][bar]
-
-[foo]: /url1
-[bar]: /url2
-
-
<p><a href="/url2">foo</a></p>
-
-
-

In the following case [bar][baz] is parsed as a reference, -[foo] as normal text:

-
-
Example 518  (interact)
-
[foo][bar][baz]
-
-[baz]: /url
-
-
<p>[foo]<a href="/url">bar</a></p>
-
-
-

Here, though, [foo][bar] is parsed as a reference, since -[bar] is defined:

-
-
Example 519  (interact)
-
[foo][bar][baz]
-
-[baz]: /url1
-[bar]: /url2
-
-
<p><a href="/url2">foo</a><a href="/url1">baz</a></p>
-
-
-

Here [foo] is not parsed as a shortcut reference, because it -is followed by a link label (even though [bar] is not defined):

-
-
Example 520  (interact)
-
[foo][bar][baz]
-
-[baz]: /url1
-[foo]: /url2
-
-
<p>[foo]<a href="/url1">bar</a></p>
-
-
-

6.6 Images

-

Syntax for images is like the syntax for links, with one -difference. Instead of link text, we have an -image description. The rules for this are the -same as for link text, except that (a) an -image description starts with ![ rather than [, and -(b) an image description may contain links. -An image description has inline elements -as its contents. When an image is rendered to HTML, -this is standardly used as the image’s alt attribute.

-
-
Example 521  (interact)
-
![foo](/url "title")
-
-
<p><img src="/url" alt="foo" title="title" /></p>
-
-
-
-
Example 522  (interact)
-
![foo *bar*]
-
-[foo *bar*]: train.jpg "train & tracks"
-
-
<p><img src="train.jpg" alt="foo bar" title="train &amp; tracks" /></p>
-
-
-
-
Example 523  (interact)
-
![foo ![bar](/url)](/url2)
-
-
<p><img src="/url2" alt="foo bar" /></p>
-
-
-
-
Example 524  (interact)
-
![foo [bar](/url)](/url2)
-
-
<p><img src="/url2" alt="foo bar" /></p>
-
-
-

Though this spec is concerned with parsing, not rendering, it is -recommended that in rendering to HTML, only the plain string content -of the image description be used. Note that in -the above example, the alt attribute’s value is foo bar, not foo [bar](/url) or foo <a href="/url">bar</a>. Only the plain string -content is rendered, without formatting.

-
-
Example 525  (interact)
-
![foo *bar*][]
-
-[foo *bar*]: train.jpg "train & tracks"
-
-
<p><img src="train.jpg" alt="foo bar" title="train &amp; tracks" /></p>
-
-
-
-
Example 526  (interact)
-
![foo *bar*][foobar]
-
-[FOOBAR]: train.jpg "train & tracks"
-
-
<p><img src="train.jpg" alt="foo bar" title="train &amp; tracks" /></p>
-
-
-
-
Example 527  (interact)
-
![foo](train.jpg)
-
-
<p><img src="train.jpg" alt="foo" /></p>
-
-
-
-
Example 528  (interact)
-
My ![foo bar](/path/to/train.jpg  "title"   )
-
-
<p>My <img src="/path/to/train.jpg" alt="foo bar" title="title" /></p>
-
-
-
-
Example 529  (interact)
-
![foo](<url>)
-
-
<p><img src="url" alt="foo" /></p>
-
-
-
-
Example 530  (interact)
-
![](/url)
-
-
<p><img src="/url" alt="" /></p>
-
-
-

Reference-style:

-
-
Example 531  (interact)
-
![foo] [bar]
-
-[bar]: /url
-
-
<p><img src="/url" alt="foo" /></p>
-
-
-
-
Example 532  (interact)
-
![foo] [bar]
-
-[BAR]: /url
-
-
<p><img src="/url" alt="foo" /></p>
-
-
-

Collapsed:

-
-
Example 533  (interact)
-
![foo][]
-
-[foo]: /url "title"
-
-
<p><img src="/url" alt="foo" title="title" /></p>
-
-
-
-
Example 534  (interact)
-
![*foo* bar][]
-
-[*foo* bar]: /url "title"
-
-
<p><img src="/url" alt="foo bar" title="title" /></p>
-
-
-

The labels are case-insensitive:

-
-
Example 535  (interact)
-
![Foo][]
-
-[foo]: /url "title"
-
-
<p><img src="/url" alt="Foo" title="title" /></p>
-
-
-

As with full reference links, whitespace is allowed -between the two sets of brackets:

-
-
Example 536  (interact)
-
![foo] 
-[]
-
-[foo]: /url "title"
-
-
<p><img src="/url" alt="foo" title="title" /></p>
-
-
-

Shortcut:

-
-
Example 537  (interact)
-
![foo]
-
-[foo]: /url "title"
-
-
<p><img src="/url" alt="foo" title="title" /></p>
-
-
-
-
Example 538  (interact)
-
![*foo* bar]
-
-[*foo* bar]: /url "title"
-
-
<p><img src="/url" alt="foo bar" title="title" /></p>
-
-
-

Note that link labels cannot contain unescaped brackets:

-
-
Example 539  (interact)
-
![[foo]]
-
-[[foo]]: /url "title"
-
-
<p>![[foo]]</p>
-<p>[[foo]]: /url &quot;title&quot;</p>
-
-
-

The link labels are case-insensitive:

-
-
Example 540  (interact)
-
![Foo]
-
-[foo]: /url "title"
-
-
<p><img src="/url" alt="Foo" title="title" /></p>
-
-
-

If you just want bracketed text, you can backslash-escape the -opening ! and [:

-
-
Example 541  (interact)
-
\!\[foo]
-
-[foo]: /url "title"
-
-
<p>![foo]</p>
-
-
-

If you want a link after a literal !, backslash-escape the -!:

-
-
Example 542  (interact)
-
\![foo]
-
-[foo]: /url "title"
-
-
<p>!<a href="/url" title="title">foo</a></p>
-
-
-

6.7 Autolinks

-

Autolinks are absolute URIs and email addresses inside -< and >. They are parsed as links, with the URL or email address -as the link label.

-

A URI autolink consists of <, followed by an -absolute URI not containing <, followed by >. It is parsed as -a link to the URI, with the URI as the link’s label.

-

An absolute URI, -for these purposes, consists of a [scheme] followed by a colon (:) -followed by zero or more characters other than ASCII -whitespace and control characters, <, and >. If -the URI includes these characters, you must use percent-encoding -(e.g. %20 for a space).

-

The following schemes -are recognized (case-insensitive): -coap, doi, javascript, aaa, aaas, about, acap, cap, -cid, crid, data, dav, dict, dns, file, ftp, geo, go, -gopher, h323, http, https, iax, icap, im, imap, info, -ipp, iris, iris.beep, iris.xpc, iris.xpcs, iris.lwz, ldap, -mailto, mid, msrp, msrps, mtqp, mupdate, news, nfs, -ni, nih, nntp, opaquelocktoken, pop, pres, rtsp, -service, session, shttp, sieve, sip, sips, sms, snmp,soap.beep, soap.beeps, tag, tel, telnet, tftp, thismessage, -tn3270, tip, tv, urn, vemmi, ws, wss, xcon, -xcon-userid, xmlrpc.beep, xmlrpc.beeps, xmpp, z39.50r, -z39.50s, adiumxtra, afp, afs, aim, apt,attachment, aw, -beshare, bitcoin, bolo, callto, chrome,chrome-extension, -com-eventbrite-attendee, content, cvs,dlna-playsingle, -dlna-playcontainer, dtn, dvb, ed2k, facetime, feed, -finger, fish, gg, git, gizmoproject, gtalk, hcp, icon, -ipn, irc, irc6, ircs, itms, jar, jms, keyparc, lastfm, -ldaps, magnet, maps, market,message, mms, ms-help, -msnim, mumble, mvn, notes, oid, palm, paparazzi, -platform, proxy, psyc, query, res, resource, rmi, rsync, -rtmp, secondlife, sftp, sgn, skype, smb, soldat, -spotify, ssh, steam, svn, teamspeak, things, udp, -unreal, ut2004, ventrilo, view-source, webcal, wtai, -wyciwyg, xfire, xri, ymsgr.

-

Here are some valid autolinks:

-
-
Example 543  (interact)
-
<http://foo.bar.baz>
-
-
<p><a href="http://foo.bar.baz">http://foo.bar.baz</a></p>
-
-
-
-
Example 544  (interact)
-
<http://foo.bar.baz/test?q=hello&id=22&boolean>
-
-
<p><a href="http://foo.bar.baz/test?q=hello&amp;id=22&amp;boolean">http://foo.bar.baz/test?q=hello&amp;id=22&amp;boolean</a></p>
-
-
-
-
Example 545  (interact)
-
<irc://foo.bar:2233/baz>
-
-
<p><a href="irc://foo.bar:2233/baz">irc://foo.bar:2233/baz</a></p>
-
-
-

Uppercase is also fine:

-
-
Example 546  (interact)
-
<MAILTO:FOO@BAR.BAZ>
-
-
<p><a href="MAILTO:FOO@BAR.BAZ">MAILTO:FOO@BAR.BAZ</a></p>
-
-
-

Spaces are not allowed in autolinks:

-
-
Example 547  (interact)
-
<http://foo.bar/baz bim>
-
-
<p>&lt;http://foo.bar/baz bim&gt;</p>
-
-
-

Backslash-escapes do not work inside autolinks:

-
-
Example 548  (interact)
-
<http://example.com/\[\>
-
-
<p><a href="http://example.com/%5C%5B%5C">http://example.com/\[\</a></p>
-
-
-

An email autolink -consists of <, followed by an email address, -followed by >. The link’s label is the email address, -and the URL is mailto: followed by the email address.

-

An email address, -for these purposes, is anything that matches -the non-normative regex from the HTML5 -spec:

-
/^[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:

-
-
Example 549  (interact)
-
<foo@bar.example.com>
-
-
<p><a href="mailto:foo@bar.example.com">foo@bar.example.com</a></p>
-
-
-
-
Example 550  (interact)
-
<foo+special@Bar.baz-bar0.com>
-
-
<p><a href="mailto:foo+special@Bar.baz-bar0.com">foo+special@Bar.baz-bar0.com</a></p>
-
-
-

Backslash-escapes do not work inside email autolinks:

-
-
Example 551  (interact)
-
<foo\+@bar.example.com>
-
-
<p>&lt;foo+@bar.example.com&gt;</p>
-
-
-

These are not autolinks:

-
-
Example 552  (interact)
-
<>
-
-
<p>&lt;&gt;</p>
-
-
-
-
Example 553  (interact)
-
<heck://bing.bong>
-
-
<p>&lt;heck://bing.bong&gt;</p>
-
-
-
-
Example 554  (interact)
-
< http://foo.bar >
-
-
<p>&lt; http://foo.bar &gt;</p>
-
-
-
-
Example 555  (interact)
-
<foo.bar.baz>
-
-
<p>&lt;foo.bar.baz&gt;</p>
-
-
-
-
Example 556  (interact)
-
<localhost:5001/foo>
-
-
<p>&lt;localhost:5001/foo&gt;</p>
-
-
-
-
Example 557  (interact)
-
http://example.com
-
-
<p>http://example.com</p>
-
-
-
-
Example 558  (interact)
-
foo@bar.example.com
-
-
<p>foo@bar.example.com</p>
-
-
-

6.8 Raw HTML

-

Text between < and > that looks like an HTML tag is parsed as a -raw 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:

-

A tag name consists of an ASCII letter -followed by zero or more ASCII letters, digits, or -hyphens (-).

-

An attribute consists of whitespace, -an attribute name, and an optional -attribute value specification.

-

An attribute name -consists of an ASCII letter, _, or :, followed by zero or more ASCII -letters, digits, _, ., :, or -. (Note: This is the XML -specification restricted to ASCII. HTML5 is laxer.)

-

An attribute value specification -consists of optional whitespace, -a = character, optional whitespace, and an attribute -value.

-

An attribute value -consists of an unquoted attribute value, -a single-quoted attribute value, or a double-quoted attribute value.

-

An unquoted attribute value -is a nonempty string of characters not -including spaces, ", ', =, <, >, or `.

-

A single-quoted attribute value -consists of ', zero or more -characters not including ', and a final '.

-

A double-quoted attribute value -consists of ", zero or more -characters not including ", and a final ".

-

An open tag consists of a < character, a tag name, -zero or more [attributes](@attribute], optional whitespace, an optional / -character, and a > character.

-

A closing tag consists of the string </, a -tag name, optional whitespace, and the character >.

-

An HTML comment consists of <!-- + text + -->, -where text does not start with > or ->, does not end with -, -and does not contain --. (See the -HTML5 spec.)

-

A processing instruction -consists of the string <?, a string -of characters not including the string ?>, and the string -?>.

-

A declaration consists of the -string <!, a name consisting of one or more uppercase ASCII letters, -whitespace, a string of characters not including the -character >, and the character >.

-

A CDATA section consists of -the string <![CDATA[, a string of characters not including the string -]]>, and the string ]]>.

-

An HTML tag consists of an open tag, a closing tag, -an HTML comment, a processing instruction, a declaration, -or a CDATA section.

-

Here are some simple open tags:

-
-
Example 559  (interact)
-
<a><bab><c2c>
-
-
<p><a><bab><c2c></p>
-
-
-

Empty elements:

-
-
Example 560  (interact)
-
<a/><b2/>
-
-
<p><a/><b2/></p>
-
-
-

Whitespace is allowed:

-
-
Example 561  (interact)
-
<a  /><b2
-data="foo" >
-
-
<p><a  /><b2
-data="foo" ></p>
-
-
-

With attributes:

-
-
Example 562  (interact)
-
<a foo="bar" bam = 'baz <em>"</em>'
-_boolean zoop:33=zoop:33 />
-
-
<p><a foo="bar" bam = 'baz <em>"</em>'
-_boolean zoop:33=zoop:33 /></p>
-
-
-

Custom tag names can be used:

-
-
Example 563  (interact)
-
<responsive-image src="foo.jpg" />
-
-<My-Tag>
-foo
-</My-Tag>
-
-
<responsive-image src="foo.jpg" />
-<My-Tag>
-foo
-</My-Tag>
-
-
-

Illegal tag names, not parsed as HTML:

-
-
Example 564  (interact)
-
<33> <__>
-
-
<p>&lt;33&gt; &lt;__&gt;</p>
-
-
-

Illegal attribute names:

-
-
Example 565  (interact)
-
<a h*#ref="hi">
-
-
<p>&lt;a h*#ref=&quot;hi&quot;&gt;</p>
-
-
-

Illegal attribute values:

-
-
Example 566  (interact)
-
<a href="hi'> <a href=hi'>
-
-
<p>&lt;a href=&quot;hi'&gt; &lt;a href=hi'&gt;</p>
-
-
-

Illegal whitespace:

-
-
Example 567  (interact)
-
< a><
-foo><bar/ >
-
-
<p>&lt; a&gt;&lt;
-foo&gt;&lt;bar/ &gt;</p>
-
-
-

Missing whitespace:

-
-
Example 568  (interact)
-
<a href='bar'title=title>
-
-
<p>&lt;a href='bar'title=title&gt;</p>
-
-
-

Closing tags:

-
-
Example 569  (interact)
-
</a>
-</foo >
-
-
</a>
-</foo >
-
-
-

Illegal attributes in closing tag:

-
-
Example 570  (interact)
-
</a href="foo">
-
-
<p>&lt;/a href=&quot;foo&quot;&gt;</p>
-
-
-

Comments:

-
-
Example 571  (interact)
-
foo <!-- this is a
-comment - with hyphen -->
-
-
<p>foo <!-- this is a
-comment - with hyphen --></p>
-
-
-
-
Example 572  (interact)
-
foo <!-- not a comment -- two hyphens -->
-
-
<p>foo &lt;!-- not a comment -- two hyphens --&gt;</p>
-
-
-

Not comments:

-
-
Example 573  (interact)
-
foo <!--> foo -->
-
-foo <!-- foo--->
-
-
<p>foo &lt;!--&gt; foo --&gt;</p>
-<p>foo &lt;!-- foo---&gt;</p>
-
-
-

Processing instructions:

-
-
Example 574  (interact)
-
foo <?php echo $a; ?>
-
-
<p>foo <?php echo $a; ?></p>
-
-
-

Declarations:

-
-
Example 575  (interact)
-
foo <!ELEMENT br EMPTY>
-
-
<p>foo <!ELEMENT br EMPTY></p>
-
-
-

CDATA sections:

-
-
Example 576  (interact)
-
foo <![CDATA[>&<]]>
-
-
<p>foo <![CDATA[>&<]]></p>
-
-
-

Entities are preserved in HTML attributes:

-
-
Example 577  (interact)
-
<a href="&ouml;">
-
-
<a href="&ouml;">
-
-
-

Backslash escapes do not work in HTML attributes:

-
-
Example 578  (interact)
-
<a href="\*">
-
-
<a href="\*">
-
-
-
-
Example 579  (interact)
-
<a href="\"">
-
-
<p>&lt;a href=&quot;&quot;&quot;&gt;</p>
-
-
-

6.9 Hard line breaks

-

A line break (not in a code span or HTML tag) that is preceded -by two or more spaces and does not occur at the end of a block -is parsed as a hard line break (rendered -in HTML as a <br /> tag):

-
-
Example 580  (interact)
-
foo  
-baz
-
-
<p>foo<br />
-baz</p>
-
-
-

For a more visible alternative, a backslash before the -line ending may be used instead of two spaces:

-
-
Example 581  (interact)
-
foo\
-baz
-
-
<p>foo<br />
-baz</p>
-
-
-

More than two spaces can be used:

-
-
Example 582  (interact)
-
foo       
-baz
-
-
<p>foo<br />
-baz</p>
-
-
-

Leading spaces at the beginning of the next line are ignored:

-
-
Example 583  (interact)
-
foo  
-     bar
-
-
<p>foo<br />
-bar</p>
-
-
-
-
Example 584  (interact)
-
foo\
-     bar
-
-
<p>foo<br />
-bar</p>
-
-
-

Line breaks can occur inside emphasis, links, and other constructs -that allow inline content:

-
-
Example 585  (interact)
-
*foo  
-bar*
-
-
<p><em>foo<br />
-bar</em></p>
-
-
-
-
Example 586  (interact)
-
*foo\
-bar*
-
-
<p><em>foo<br />
-bar</em></p>
-
-
-

Line breaks do not occur inside code spans

-
-
Example 587  (interact)
-
`code  
-span`
-
-
<p><code>code span</code></p>
-
-
-
-
Example 588  (interact)
-
`code\
-span`
-
-
<p><code>code\ span</code></p>
-
-
-

or HTML tags:

-
-
Example 589  (interact)
-
<a href="foo  
-bar">
-
-
<p><a href="foo  
-bar"></p>
-
-
-
-
Example 590  (interact)
-
<a href="foo\
-bar">
-
-
<p><a href="foo\
-bar"></p>
-
-
-

Hard line breaks are for separating inline content within a block. -Neither syntax for hard line breaks works at the end of a paragraph or -other block element:

-
-
Example 591  (interact)
-
foo\
-
-
<p>foo\</p>
-
-
-
-
Example 592  (interact)
-
foo  
-
-
<p>foo</p>
-
-
-
-
Example 593  (interact)
-
### foo\
-
-
<h3>foo\</h3>
-
-
-
-
Example 594  (interact)
-
### foo  
-
-
<h3>foo</h3>
-
-
-

6.10 Soft line breaks

-

A regular line break (not in a code span or HTML tag) that is not -preceded by two or more spaces or a backslash is parsed as a -softbreak. (A softbreak may be rendered in HTML either as a -line ending or as a space. The result will be the same in -browsers. In the examples here, a line ending will be used.)

-
-
Example 595  (interact)
-
foo
-baz
-
-
<p>foo
-baz</p>
-
-
-

Spaces at the end of the line and beginning of the next line are -removed:

-
-
Example 596  (interact)
-
foo 
- baz
-
-
<p>foo
-baz</p>
-
-
-

A conforming parser may render a soft line break in HTML either as a -line break or as a space.

-

A renderer may also provide an option to render soft line breaks -as hard line breaks.

-

6.11 Textual content

-

Any characters not given an interpretation by the above rules will -be parsed as plain textual content.

-
-
Example 597  (interact)
-
hello $.;'there
-
-
<p>hello $.;'there</p>
-
-
-
-
Example 598  (interact)
-
Foo χρῆν
-
-
<p>Foo χρῆν</p>
-
-
-

Internal spaces are preserved verbatim:

-
-
Example 599  (interact)
-
Multiple     spaces
-
-
<p>Multiple     spaces</p>
-
-
- -

Appendix: A parsing strategy

-

In this appendix we describe some features of the parsing strategy -used in the CommonMark reference implementations.

-

Overview

-

Parsing has two phases:

-
    -
  1. -

    In the first phase, lines of input are consumed and the block -structure of the document—its division into paragraphs, block quotes, -list items, and so on—is constructed. Text is assigned to these -blocks but not parsed. Link reference definitions are parsed and a -map of links is constructed.

    -
    2. -
  2. -

    In the second phase, the raw text contents of paragraphs and headers -are parsed into sequences of Markdown inline elements (strings, -code spans, links, emphasis, and so on), using the map of link -references constructed in phase 1.

    -
    3. -
-

At each point in processing, the document is represented as a tree of -blocks. The root of the tree is a document block. The document -may have any number of other blocks as children. These children -may, in turn, have other blocks as children. The last child of a block -is normally considered open, meaning that subsequent lines of input -can alter its contents. (Blocks that are not open are closed.) -Here, for example, is a possible document tree, with the open blocks -marked 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"
-
-

Phase 1: block structure

-

Each line that is processed has an effect on this tree. The line is -analyzed and, depending on its contents, the document may be altered -in one or more of the following ways:

-
    -
  1. One or more open blocks may be closed.
    2. -
  2. One or more new blocks may be created as children of the -last open block.
    3. -
  3. Text may be added to the last (deepest) open block remaining -on the tree.
    4. -
-

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:

-
    -
  1. -

    First we iterate through the open blocks, starting with the -root document, and descending through last children down to the last -open block. Each block imposes a condition that the line must satisfy -if 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 open -blocks. But we cannot close unmatched blocks yet, because we may have a -lazy continuation line.

    -
    2. -
  2. -

    Next, after consuming the continuation markers for existing -blocks, we look for new block starts (e.g. > for a block quote. -If we encounter a new block start, we close any blocks unmatched -in step 1 before creating the new block as a child of the last -matched block.

    -
    3. -
  3. -

    Finally, we look at the remainder of the line (after block -markers like >, list markers, and indentation have been consumed). -This is text that can be incorporated into the last open -block (a paragraph, code block, header, or raw HTML).

    -
    4. -
-

Setext headers are formed when we detect that the second line of -a paragraph is a setext header line.

-

Reference link definitions are detected when a paragraph is closed; -the accumulated text lines are parsed to see if they begin with -one or more reference link definitions. Any remainder becomes a -normal paragraph.

-

We can see how this works by considering how the tree above is -generated by four lines of Markdown:

-
> Lorem ipsum dolor
-sit amet.
-> - Qui *quodsi iracundia*
-> - aliquando id
-
-

At the outset, our document model is just

-
-> document
-
-

The first line of our text,

-
> Lorem ipsum dolor
-
-

causes a block_quote block to be created as a child of our -open document block, and a paragraph block as a child of -the block_quote. Then the text is added to the last open -block, the paragraph:

-
-> document
-  -> block_quote
-    -> paragraph
-         "Lorem ipsum dolor"
-
-

The next line,

-
sit amet.
-
-

is a “lazy continuation” of the open paragraph, so it gets added -to the paragraph’s text:

-
-> document
-  -> block_quote
-    -> paragraph
-         "Lorem ipsum dolor\nsit amet."
-
-

The third line,

-
> - Qui *quodsi iracundia*
-
-

causes the paragraph block to be closed, and a new list block -opened as a child of the block_quote. A list_item is also -added as a child of the list, and a paragraph as a child of -the list_item. The text is then added to the new paragraph:

-
-> 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 id
-
-

causes the list_item (and its child the paragraph) to be closed, -and a new list_item opened up as child of the list. A paragraph -is added as a child of the new list_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"
-
-

Phase 2: inline structure

-

Once all of the input has been parsed, all open blocks are closed.

-

We then “walk the tree,” visiting every node, and parse raw -string contents of paragraphs and headers as inlines. At this -point we have seen all the link reference definitions, so we can -resolve 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 the line ending in the first paragraph has -been parsed as a softbreak, and the asterisks in the first list item -have become an emph.

-

An algorithm for parsing nested emphasis and links

-

By far the trickiest part of inline parsing is handling emphasis, -strong emphasis, links, and images. This is done using the following -algorithm.

-

When we’re parsing inlines and we hit either

- -

we insert a text node with these symbols as its literal content, and we -add a pointer to this text node to the delimiter stack.

-

The delimiter stack is a doubly linked list. Each -element contains a pointer to a text node, plus information about

- -

When we hit a ] character, we call the look for link or image -procedure (see below).

-

When we hit the end of the input, we call the process emphasis -procedure (see below), with stack_bottom = NULL.

-

look for link or image

-

Starting at the top of the delimiter stack, we look backwards -through the stack for an opening [ or ![ delimiter.

- -

process emphasis

-

Parameter stack_bottom sets a lower bound to how far we -descend in the delimiter stack. If it is NULL, we can -go all the way to the bottom. Otherwise, we stop before -visiting stack_bottom.

-

Let current_position point to the element on the delimiter stack -just above stack_bottom (or the first element if stack_bottom -is NULL).

-

We keep track of the openers_bottom for each delimiter -type (*, _). Initialize this to stack_bottom.

-

Then we repeat the following until we run out of potential -closers:

- -

After we’re done, we remove all delimiters above stack_bottom from the -delimiter stack.

- - - diff --git a/tests/commonmark_spec_tests b/tests/commonmark_spec_tests deleted file mode 100644 index e4291da24..000000000 --- a/tests/commonmark_spec_tests +++ /dev/null @@ -1,3024 +0,0 @@ -:( foo baz bim -)_(
foo	baz		bim
-
-)::( foo baz bim -)_(
foo	baz		bim
-
-)::( a a - ὐ a -)_(
a	a
-ὐ	a
-
-)::( - foo - - bar -)_( -)::(> foo bar -)_(
-

foo bar

-
-)::( foo - bar -)_(
foo
-bar
-
-)::(- `one -- two` -)_( -)::(*** ---- -___ -)_(
-
-
-)::(+++ -)_(

+++

-)::(=== -)_(

===

-)::(-- -** -__ -)_(

-- -** -__

-)::( *** - *** - *** -)_(
-
-
-)::( *** -)_(
***
-
-)::(Foo - *** -)_(

Foo -***

-)::(_____________________________________ -)_(
-)::( - - - -)_(
-)::( ** * ** * ** * ** -)_(
-)::(- - - - -)_(
-)::(- - - - -)_(
-)::(_ _ _ _ a - -a------ - ----a--- -)_(

_ _ _ _ a

-

a------

-

---a---

-)::( *-* -)_(

-

-)::(- foo -*** -- bar -)_( -
- -)::(Foo -*** -bar -)_(

Foo

-
-

bar

-)::(Foo ---- -bar -)_(

Foo

-

bar

-)::(* Foo -* * * -* Bar -)_( -
- -)::(- Foo -- * * * -)_( -)::(# foo -## foo -### foo -#### foo -##### foo -###### foo -)_(

foo

-

foo

-

foo

-

foo

-
foo
-
foo
-)::(####### foo -)_(

####### foo

-)::(#5 bolt - -#foobar -)_(

#5 bolt

-

#foobar

-)::(\## foo -)_(

## foo

-)::(# foo *bar* \*baz\* -)_(

foo bar *baz*

-)::(# foo -)_(

foo

-)::( ### foo - ## foo - # foo -)_(

foo

-

foo

-

foo

-)::( # foo -)_(
# foo
-
-)::(foo - # bar -)_(

foo -# bar

-)::(## foo ## - ### bar ### -)_(

foo

-

bar

-)::(# foo ################################## -##### foo ## -)_(

foo

-
foo
-)::(### foo ### -)_(

foo

-)::(### foo ### b -)_(

foo ### b

-)::(# foo# -)_(

foo#

-)::(### foo \### -## foo #\## -# foo \# -)_(

foo ###

-

foo ###

-

foo #

-)::(**** -## foo -**** -)_(
-

foo

-
-)::(Foo bar -# baz -Bar foo -)_(

Foo bar

-

baz

-

Bar foo

-)::(## -# -### ### -)_(

-

-

-)::(Foo *bar* -========= - -Foo *bar* ---------- -)_(

Foo bar

-

Foo bar

-)::(Foo -------------------------- - -Foo -= -)_(

Foo

-

Foo

-)::( Foo ---- - - Foo ------ - - Foo - === -)_(

Foo

-

Foo

-

Foo

-)::( Foo - --- - - Foo ---- -)_(
Foo
----
-
-Foo
-
-
-)::(Foo - ---- -)_(

Foo

-)::(Foo - --- -)_(

Foo ----

-)::(Foo -= = - -Foo ---- - -)_(

Foo -= =

-

Foo

-
-)::(Foo ------ -)_(

Foo

-)::(Foo\ ----- -)_(

Foo\

-)::(`Foo ----- -` - -<a title="a lot ---- -of dashes"/> -)_(

`Foo

-

`

-

<a title="a lot

-

of dashes"/>

-)::(> Foo ---- -)_(
-

Foo

-
-
-)::(- Foo ---- -)_( -
-)::(Foo -Bar ---- - -Foo -Bar -=== -)_(

Foo -Bar

-
-

Foo -Bar -===

-)::(--- -Foo ---- -Bar ---- -Baz -)_(
-

Foo

-

Bar

-

Baz

-)::( -==== -)_(

====

-)::(--- ---- -)_(
-
-)::(- foo ------ -)_( -
-)::( foo ---- -)_(
foo
-
-
-)::(> foo ------ -)_(
-

foo

-
-
-)::(\> foo ------- -)_(

> foo

-)::( a simple - indented code block -)_(
a simple
-  indented code block
-
-)::( - foo - - bar -)_( -)::(1. foo - - - bar -)_(
    -
  1. -

    foo

    -
      -
    • bar
      • -
    -
    2. -
-)::( <a/> - *hi* - - - one -)_(
<a/>
-*hi*
-
-- one
-
-)::( chunk1 - - chunk2 - - - - chunk3 -)_(
chunk1
-
-chunk2
-
-
-
-chunk3
-
-)::( chunk1 - - chunk2 -)_(
chunk1
-  
-  chunk2
-
-)::(Foo - bar - -)_(

Foo -bar

-)::( foo -bar -)_(
foo
-
-

bar

-)::(# Header - foo -Header ------- - foo ----- -)_(

Header

-
foo
-
-

Header

-
foo
-
-
-)::( foo - bar -)_(
    foo
-bar
-
-)::( - - foo - - -)_(
foo
-
-)::( foo -)_(
foo  
-
-)::(``` -< - > -``` -)_(
<
- >
-
-)::(~~~ -< - > -~~~ -)_(
<
- >
-
-)::(``` -aaa -~~~ -``` -)_(
aaa
-~~~
-
-)::(~~~ -aaa -``` -~~~ -)_(
aaa
-```
-
-)::(```` -aaa -``` -`````` -)_(
aaa
-```
-
-)::(~~~~ -aaa -~~~ -~~~~ -)_(
aaa
-~~~
-
-)::(``` -)_(
-)::(````` - -``` -aaa -)_(

-```
-aaa
-
-)::(> ``` -> aaa - -bbb -)_(
-
aaa
-
-
-

bbb

-)::(``` - - -``` -)_(

-  
-
-)::(``` -``` -)_(
-)::( ``` - aaa -aaa -``` -)_(
aaa
-aaa
-
-)::( ``` -aaa - aaa -aaa - ``` -)_(
aaa
-aaa
-aaa
-
-)::( ``` - aaa - aaa - aaa - ``` -)_(
aaa
- aaa
-aaa
-
-)::( ``` - aaa - ``` -)_(
```
-aaa
-```
-
-)::(``` -aaa - ``` -)_(
aaa
-
-)::( ``` -aaa - ``` -)_(
aaa
-
-)::(``` -aaa - ``` -)_(
aaa
-    ```
-
-)::(``` ``` -aaa -)_(

-aaa

-)::(~~~~~~ -aaa -~~~ ~~ -)_(
aaa
-~~~ ~~
-
-)::(foo -``` -bar -``` -baz -)_(

foo

-
bar
-
-

baz

-)::(foo ---- -~~~ -bar -~~~ -# baz -)_(

foo

-
bar
-
-

baz

-)::(```ruby -def foo(x) - return 3 -end -``` -)_(
def foo(x)
-  return 3
-end
-
-)::(~~~~ ruby startline=3 $%@#$ -def foo(x) - return 3 -end -~~~~~~~ -)_(
def foo(x)
-  return 3
-end
-
-)::(````; -```` -)_(
-)::(``` aa ``` -foo -)_(

aa -foo

-)::(``` -``` aaa -``` -)_(
``` aaa
-
-)::(<table> - <tr> - <td> - hi - </td> - </tr> -</table> - -okay. -)_( - - - -
- hi -
-

okay.

-)::( <div> - *hello* - <foo><a> -)_(
- *hello* - -)::(</div> -*foo* -)_(
-*foo* -)::(<DIV CLASS="foo"> - -*Markdown* - -</DIV> -)_(
-

Markdown

-
-)::(<div id="foo" - class="bar"> -</div> -)_(
-
-)::(<div id="foo" class="bar - baz"> -</div> -)_(
-
-)::(<div> -*foo* - -*bar* -)_(
-*foo* -

bar

-)::(<div id="foo" -*hi* -)_( -)::(<table><tr><td> -foo -</td></tr></table> -)_(
-foo -
-)::(<div></div> -``` c -int x = 33; -``` -)_(
-``` c -int x = 33; -``` -)::(<a href="foo"> -*bar* -</a> -)_( -*bar* - -)::(<Warning> -*bar* -</Warning> -)_( -*bar* - -)::(<i class="foo"> -*bar* -</i> -)_( -*bar* - -)::(</ins> -*bar* -)_( -*bar* -)::(<del> -*foo* -</del> -)_( -*foo* - -)::(<del> - -*foo* - -</del> -)_( -

foo

- -)::(<del>*foo*</del> -)_(

foo

-)::(<pre language="haskell"><code> -import Text.HTML.TagSoup - -main :: IO () -main = print $ parseTags tags -</code></pre> -)_(

-import Text.HTML.TagSoup
-
-main :: IO ()
-main = print $ parseTags tags
-
-)::(<script type="text/javascript"> -// JavaScript example - -document.getElementById("demo").innerHTML = "Hello JavaScript!"; -</script> -)_( -)::(<style - type="text/css"> -h1 {color:red;} - -p {color:blue;} -</style> -)_( -)::(<style - type="text/css"> - -foo -)_( -

foo

-)::(<!-- foo -->*bar* -*baz* -)_(*bar* -

baz

-)::(<script> -foo -</script>1. *bar* -)_(1. *bar* -)::(<!-- Foo - -bar - baz --> -)_( -)::(<?php - - echo '>'; - -?> -)_('; - -?> -)::(<!DOCTYPE html> -)_( -)::(<![CDATA[ -function matchwo(a,b) -{ - if (a < b && a < 0) then { - return 1; - - } else { - - return 0; - } -} -]]> -)_( -)::( <!-- foo --> - - <!-- foo --> -)_( -
<!-- foo -->
-
-)::( <div> - - <div> -)_(
-
<div>
-
-)::(Foo -<div> -bar -</div> -)_(

Foo

-
-bar -
-)::(<div> -bar -</div> -*foo* -)_(
-bar -
-*foo* -)::(Foo -<a href="bar"> -baz -)_(

Foo - -baz

-)::(<div> - -*Emphasized* text. - -</div> -)_(
-

Emphasized text.

-
-)::(<div> -*Emphasized* text. -</div> -)_(
-*Emphasized* text. -
-)::(<table> - -<tr> - -<td> -Hi -</td> - -</tr> - -</table> -)_( - - - -
-Hi -
-)::(<table> - - <tr> - - <td> - Hi - </td> - - </tr> - -</table> -)_( - -
<td>
-  Hi
-</td>
-
- -
-)::([foo]: /url "title" - -[foo] -)_(

foo

-)::( [foo]: - /url - 'the title' - -[foo] -)_(

foo

-)::([Foo*bar\]]:my_(url) 'title (with parens)' - -[Foo*bar\]] -)_(

Foo*bar]

-)::([Foo bar]: -<my url> -'title' - -[Foo bar] -)_(

Foo bar

-)::([foo]: /url ' -title -line1 -line2 -' - -[foo] -)_(

foo

-)::([foo]: /url 'title - -with blank line' - -[foo] -)_(

[foo]: /url 'title

-

with blank line'

-

[foo]

-)::([foo]: -/url - -[foo] -)_(

foo

-)::([foo]: - -[foo] -)_(

[foo]:

-

[foo]

-)::([foo]: /url\bar\*baz "foo\"bar\baz" - -[foo] -)_(

foo

-)::([foo] - -[foo]: url -)_(

foo

-)::([foo] - -[foo]: first -[foo]: second -)_(

foo

-)::([FOO]: /url - -[Foo] -)_(

Foo

-)::([ΑΓΩ]: /φου - -[αγω] -)_(

αγω

-)::([foo]: /url -)_()::([ -foo -]: /url -bar -)_(

bar

-)::([foo]: /url "title" ok -)_(

[foo]: /url "title" ok

-)::([foo]: /url -"title" ok -)_(

"title" ok

-)::( [foo]: /url "title" - -[foo] -)_(
[foo]: /url "title"
-
-

[foo]

-)::(``` -[foo]: /url -``` - -[foo] -)_(
[foo]: /url
-
-

[foo]

-)::(Foo -[bar]: /baz - -[bar] -)_(

Foo -[bar]: /baz

-

[bar]

-)::(# [Foo] -[foo]: /url -> bar -)_(

Foo

-
-

bar

-
-)::([foo]: /foo-url "foo" -[bar]: /bar-url - "bar" -[baz]: /baz-url - -[foo], -[bar], -[baz] -)_(

foo, -bar, -baz

-)::([foo] - -> [foo]: /url -)_(

foo

-
-
-)::(aaa - -bbb -)_(

aaa

-

bbb

-)::(aaa -bbb - -ccc -ddd -)_(

aaa -bbb

-

ccc -ddd

-)::(aaa - - -bbb -)_(

aaa

-

bbb

-)::( aaa - bbb -)_(

aaa -bbb

-)::(aaa - bbb - ccc -)_(

aaa -bbb -ccc

-)::( aaa -bbb -)_(

aaa -bbb

-)::( aaa -bbb -)_(
aaa
-
-

bbb

-)::(aaa -bbb -)_(

aaa
-bbb

-)::( - -aaa - - -# aaa - - -)_(

aaa

-

aaa

-)::(> # Foo -> bar -> baz -)_(
-

Foo

-

bar -baz

-
-)::(># Foo ->bar -> baz -)_(
-

Foo

-

bar -baz

-
-)::( > # Foo - > bar - > baz -)_(
-

Foo

-

bar -baz

-
-)::( > # Foo - > bar - > baz -)_(
> # Foo
-> bar
-> baz
-
-)::(> # Foo -> bar -baz -)_(
-

Foo

-

bar -baz

-
-)::(> bar -baz -> foo -)_(
-

bar -baz -foo

-
-)::(> foo ---- -)_(
-

foo

-
-
-)::(> - foo -- bar -)_(
-
    -
  • foo
    • -
-
-
    -
  • bar
    • -
-)::(> foo - bar -)_(
-
foo
-
-
-
bar
-
-)::(> ``` -foo -``` -)_(
-
-
-

foo

-
-)::(> foo - - bar -)_(
-

foo -- bar

-
-)::(> -)_(
-
-)::(> -> -> -)_(
-
-)::(> -> foo -> -)_(
-

foo

-
-)::(> foo - -> bar -)_(
-

foo

-
-
-

bar

-
-)::(> foo -> bar -)_(
-

foo -bar

-
-)::(> foo -> -> bar -)_(
-

foo

-

bar

-
-)::(foo -> bar -)_(

foo

-
-

bar

-
-)::(> aaa -*** -> bbb -)_(
-

aaa

-
-
-
-

bbb

-
-)::(> bar -baz -)_(
-

bar -baz

-
-)::(> bar - -baz -)_(
-

bar

-
-

baz

-)::(> bar -> -baz -)_(
-

bar

-
-

baz

-)::(> > > foo -bar -)_(
-
-
-

foo -bar

-
-
-
-)::(>>> foo -> bar ->>baz -)_(
-
-
-

foo -bar -baz

-
-
-
-)::(> code - -> not code -)_(
-
code
-
-
-
-

not code

-
-)::(A paragraph -with two lines. - - indented code - -> A block quote. -)_(

A paragraph -with two lines.

-
indented code
-
-
-

A block quote.

-
-)::(1. A paragraph - with two lines. - - indented code - - > A block quote. -)_(
    -
  1. -

    A paragraph -with two lines.

    -
    indented code
-
    -
    -

    A block quote.

    -
    -
    2. -
-)::(- one - - two -)_(
    -
  • one
    • -
-

two

-)::(- one - - two -)_(
    -
  • -

    one

    -

    two

    -
    • -
-)::( - one - - two -)_(
    -
  • one
    • -
-
 two
-
-)::( - one - - two -)_(
    -
  • -

    one

    -

    two

    -
    • -
-)::( > > 1. one ->> ->> two -)_(
-
-
    -
  1. -

    one

    -

    two

    -
    2. -
-
-
-)::(>>- one ->> - > > two -)_(
-
-
    -
  • one
    • -
-

two

-
-
-)::(-one - -2.two -)_(

-one

-

2.two

-)::(- foo - - bar - -- foo - - - bar - -- ``` - foo - - - bar - ``` - -- baz - - + ``` - foo - - - bar - ``` -)_(
    -
  • -

    foo

    -

    bar

    -
    • -
  • -

    foo

    -
    • -
-

bar

-
    -
  • -
    foo
-
-
-bar
-
    -
    • -
  • -

    baz

    -
      -
    • -
      foo
-
-
-bar
-
      -
      • -
    -
    • -
-)::(1. foo - - ``` - bar - ``` - - baz - - > bam -)_(
    -
  1. -

    foo

    -
    bar
-
    -

    baz

    -
    -

    bam

    -
    -
    2. -
-)::(123456789. ok -)_(
    -
  1. ok
    2. -
-)::(1234567890. not ok -)_(

1234567890. not ok

-)::(0. ok -)_(
    -
  1. ok
    2. -
-)::(003. ok -)_(
    -
  1. ok
    2. -
-)::(-1. not ok -)_(

-1. not ok

-)::(- foo - - bar -)_(
    -
  • -

    foo

    -
    bar
-
    -
    • -
-)::( 10. foo - - bar -)_(
    -
  1. -

    foo

    -
    bar
-
    -
    2. -
-)::( indented code - -paragraph - - more code -)_(
indented code
-
-

paragraph

-
more code
-
-)::(1. indented code - - paragraph - - more code -)_(
    -
  1. -
    indented code
-
    -

    paragraph

    -
    more code
-
    -
    2. -
-)::(1. indented code - - paragraph - - more code -)_(
    -
  1. -
     indented code
-
    -

    paragraph

    -
    more code
-
    -
    2. -
-)::( foo - -bar -)_(

foo

-

bar

-)::(- foo - - bar -)_(
    -
  • foo
    • -
-

bar

-)::(- foo - - bar -)_(
    -
  • -

    foo

    -

    bar

    -
    • -
-)::(- - foo -- - ``` - bar - ``` -- - baz -)_(
    -
  • foo
    • -
  • -
    bar
-
    -
    • -
  • -
    baz
-
    -
    • -
-)::(- - - foo -)_(
    -
  • -
-

foo

-)::(- foo -- -- bar -)_(
    -
  • foo
    • -
  • -
  • bar
    • -
-)::(- foo -- -- bar -)_(
    -
  • foo
    • -
  • -
  • bar
    • -
-)::(1. foo -2. -3. bar -)_(
    -
  1. foo
    2. -
  2. -
  3. bar
    4. -
-)::(* -)_(
    -
  • -
-)::( 1. A paragraph - with two lines. - - indented code - - > A block quote. -)_(
    -
  1. -

    A paragraph -with two lines.

    -
    indented code
-
    -
    -

    A block quote.

    -
    -
    2. -
-)::( 1. A paragraph - with two lines. - - indented code - - > A block quote. -)_(
    -
  1. -

    A paragraph -with two lines.

    -
    indented code
-
    -
    -

    A block quote.

    -
    -
    2. -
-)::( 1. A paragraph - with two lines. - - indented code - - > A block quote. -)_(
    -
  1. -

    A paragraph -with two lines.

    -
    indented code
-
    -
    -

    A block quote.

    -
    -
    2. -
-)::( 1. A paragraph - with two lines. - - indented code - - > A block quote. -)_(
1.  A paragraph
-    with two lines.
-
-        indented code
-
-    > A block quote.
-
-)::( 1. A paragraph -with two lines. - - indented code - - > A block quote. -)_(
    -
  1. -

    A paragraph -with two lines.

    -
    indented code
-
    -
    -

    A block quote.

    -
    -
    2. -
-)::( 1. A paragraph - with two lines. -)_(
    -
  1. A paragraph -with two lines.
    2. -
-)::(> 1. > Blockquote -continued here. -)_(
-
    -
  1. -
    -

    Blockquote -continued here.

    -
    -
    2. -
-
-)::(> 1. > Blockquote -> continued here. -)_(
-
    -
  1. -
    -

    Blockquote -continued here.

    -
    -
    2. -
-
-)::(- foo - - bar - - baz -)_(
    -
  • foo -
      -
    • bar -
        -
      • baz
        • -
      -
      • -
    -
    • -
-)::(- foo - - bar - - baz -)_(
    -
  • foo
    • -
  • bar
    • -
  • baz
    • -
-)::(10) foo - - bar -)_(
    -
  1. foo -
      -
    • bar
      • -
    -
    2. -
-)::(10) foo - - bar -)_(
    -
  1. foo
    2. -
-
    -
  • bar
    • -
-)::(- - foo -)_(
    -
  • -
      -
    • foo
      • -
    -
    • -
-)::(1. - 2. foo -)_(
    -
  1. -
      -
    • -
        -
      1. foo
        2. -
      -
      • -
    -
    2. -
-)::(- # Foo -- Bar - --- - baz -)_(
    -
  • -

    Foo

    -
    • -
  • -

    Bar

    -baz
    • -
-)::(- foo -- bar -+ baz -)_(
    -
  • foo
    • -
  • bar
    • -
-
    -
  • baz
    • -
-)::(1. foo -2. bar -3) baz -)_(
    -
  1. foo
    2. -
  2. bar
    3. -
-
    -
  1. baz
    2. -
-)::(Foo -- bar -- baz -)_(

Foo

-
    -
  • bar
    • -
  • baz
    • -
-)::(The number of windows in my house is -14. The number of doors is 6. -)_(

The number of windows in my house is

-
    -
  1. The number of doors is 6.
    2. -
-)::(- foo - -- bar - - -- baz -)_(
    -
  • -

    foo

    -
    • -
  • -

    bar

    -
    • -
-
    -
  • baz
    • -
-)::(- foo - - - bar -- baz -)_(
    -
  • foo
    • -
-

bar

-
    -
  • baz
    • -
-)::(- foo - - bar - - baz - - - bim -)_(
    -
  • foo -
      -
    • bar -
        -
      • baz
        • -
      -
      • -
    -
    • -
-
  bim
-
-)::(- foo -- bar - - -- baz -- bim -)_(
    -
  • foo
    • -
  • bar
    • -
-
    -
  • baz
    • -
  • bim
    • -
-)::(- foo - - notcode - -- foo - - - code -)_(
    -
  • -

    foo

    -

    notcode

    -
    • -
  • -

    foo

    -
    • -
-
code
-
-)::(- a - - b - - c - - d - - e - - f - - g - - h -- i -)_(
    -
  • a
    • -
  • b
    • -
  • c
    • -
  • d
    • -
  • e
    • -
  • f
    • -
  • g
    • -
  • h
    • -
  • i
    • -
-)::(1. a - - 2. b - - 3. c -)_(
    -
  1. -

    a

    -
    2. -
  2. -

    b

    -
    3. -
  3. -

    c

    -
    4. -
-)::(- a -- b - -- c -)_(
    -
  • -

    a

    -
    • -
  • -

    b

    -
    • -
  • -

    c

    -
    • -
-)::(* a -* - -* c -)_(
    -
  • -

    a

    -
    • -
  • -
  • -

    c

    -
    • -
-)::(- a -- b - - c -- d -)_(
    -
  • -

    a

    -
    • -
  • -

    b

    -

    c

    -
    • -
  • -

    d

    -
    • -
-)::(- a -- b - - [ref]: /url -- d -)_(
    -
  • -

    a

    -
    • -
  • -

    b

    -
    • -
  • -

    d

    -
    • -
-)::(- a -- ``` - b - - - ``` -- c -)_(
    -
  • a
    • -
  • -
    b
-
-
-
    -
    • -
  • c
    • -
-)::(- a - - b - - c -- d -)_(
    -
  • a -
      -
    • -

      b

      -

      c

      -
      • -
    -
    • -
  • d
    • -
-)::(* a - > b - > -* c -)_(
    -
  • a -
    -

    b

    -
    -
    • -
  • c
    • -
-)::(- a - > b - ``` - c - ``` -- d -)_(
    -
  • a -
    -

    b

    -
    -
    c
-
    -
    • -
  • d
    • -
-)::(- a -)_(
    -
  • a
    • -
-)::(- a - - b -)_(
    -
  • a -
      -
    • b
      • -
    -
    • -
-)::(1. ``` - foo - ``` - - bar -)_(
    -
  1. -
    foo
-
    -

    bar

    -
    2. -
-)::(* foo - * bar - - baz -)_(
    -
  • -

    foo

    -
      -
    • bar
      • -
    -

    baz

    -
    • -
-)::(- a - - b - - c - -- d - - e - - f -)_(
    -
  • -

    a

    -
      -
    • b
      • -
    • c
      • -
    -
    • -
  • -

    d

    -
      -
    • e
      • -
    • f
      • -
    -
    • -
-)::(`hi`lo` -)_(

hilo`

-)::(\!\"\#\$\%\&\'\(\)\*\+\,\-\.\/\:\;\<\=\>\?\@\[\\\]\^\_\`\{\|\}\~ -)_(

!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

-)::(\ \A\a\ \3\φ\« -)_(

\ \A\a\ \3\φ\«

-)::(\*not emphasized* -\<br/> not a tag -\[not a link](/foo) -\`not code` -1\. not a list -\* not a list -\# not a header -\[foo]: /url "not a reference" -)_(

*not emphasized* -<br/> not a tag -[not a link](/foo) -`not code` -1. not a list -* not a list -# not a header -[foo]: /url "not a reference"

-)::(\\*emphasis* -)_(

\emphasis

-)::(foo\ -bar -)_(

foo
-bar

-)::(`` \[\` `` -)_(

\[\`

-)::( \[\] -)_(
\[\]
-
-)::(~~~ -\[\] -~~~ -)_(
\[\]
-
-)::(<http://example.com?find=\*> -)_(

http://example.com?find=\*

-)::(<a href="/bar\/)"> -)_( -)::([foo](/bar\* "ti\*tle") -)_(

foo

-)::([foo] - -[foo]: /bar\* "ti\*tle" -)_(

foo

-)::(``` foo\+bar -foo -``` -)_(
foo
-
-)::(&nbsp; &amp; &copy; &AElig; &Dcaron; -&frac34; &HilbertSpace; &DifferentialD; -&ClockwiseContourIntegral; &ngE; -)_(

  & © Æ Ď -¾ ℋ ⅆ -∲ ≧̸

-)::(&#35; &#1234; &#992; &#98765432; &#0; -)_(

# Ӓ Ϡ � �

-)::(&#X22; &#XD06; &#xcab; -)_(

" ആ ಫ

-)::(&nbsp &x; &#; &#x; &ThisIsWayTooLongToBeAnEntityIsntIt; &hi?; -)_(

&nbsp &x; &#; &#x; &ThisIsWayTooLongToBeAnEntityIsntIt; &hi?;

-)::(&copy -)_(

&copy

-)::(&MadeUpEntity; -)_(

&MadeUpEntity;

-)::(<a href="&ouml;&ouml;.html"> -)_( -)::([foo](/f&ouml;&ouml; "f&ouml;&ouml;") -)_(

foo

-)::([foo] - -[foo]: /f&ouml;&ouml; "f&ouml;&ouml;" -)_(

foo

-)::(``` f&ouml;&ouml; -foo -``` -)_(
foo
-
-)::(`f&ouml;&ouml;` -)_(

f&ouml;&ouml;

-)::( f&ouml;f&ouml; -)_(
f&ouml;f&ouml;
-
-)::(`foo` -)_(

foo

-)::(`` foo ` bar `` -)_(

foo ` bar

-)::(` `` ` -)_(

``

-)::(`` -foo -`` -)_(

foo

-)::(`foo bar - baz` -)_(

foo bar baz

-)::(`foo `` bar` -)_(

foo `` bar

-)::(`foo\`bar` -)_(

foo\bar`

-)::(*foo`*` -)_(

*foo*

-)::([not a `link](/foo`) -)_(

[not a link](/foo)

-)::(`<a href="`">` -)_(

<a href="">`

-)::(<a href="`">` -)_(

`

-)::(`<http://foo.bar.`baz>` -)_(

<http://foo.bar.baz>`

-)::(<http://foo.bar.`baz>` -)_(

http://foo.bar.`baz`

-)::(```foo`` -)_(

```foo``

-)::(`foo -)_(

`foo

-)::(*foo bar* -)_(

foo bar

-)::(a * foo bar* -)_(

a * foo bar*

-)::(a*"foo"* -)_(

a*"foo"*

-)::(* a * -)_(

* a *

-)::(foo*bar* -)_(

foobar

-)::(5*6*78 -)_(

5678

-)::(_foo bar_ -)_(

foo bar

-)::(_ foo bar_ -)_(

_ foo bar_

-)::(a_"foo"_ -)_(

a_"foo"_

-)::(foo_bar_ -)_(

foo_bar_

-)::(5_6_78 -)_(

5_6_78

-)::(пристаням_стремятся_ -)_(

пристаням_стремятся_

-)::(aa_"bb"_cc -)_(

aa_"bb"_cc

-)::(foo-_(bar)_ -)_(

foo-(bar)

-)::(_foo* -)_(

_foo*

-)::(*foo bar * -)_(

*foo bar *

-)::(*foo bar -* -)_(

*foo bar

-
    -
  • -
-)::(*(*foo) -)_(

*(*foo)

-)::(*(*foo*)* -)_(

(foo)

-)::(*foo*bar -)_(

foobar

-)::(_foo bar _ -)_(

_foo bar _

-)::(_(_foo) -)_(

_(_foo)

-)::(_(_foo_)_ -)_(

(foo)

-)::(_foo_bar -)_(

_foo_bar

-)::(_пристаням_стремятся -)_(

_пристаням_стремятся

-)::(_foo_bar_baz_ -)_(

foo_bar_baz

-)::(_(bar)_. -)_(

(bar).

-)::(**foo bar** -)_(

foo bar

-)::(** foo bar** -)_(

** foo bar**

-)::(a**"foo"** -)_(

a**"foo"**

-)::(foo**bar** -)_(

foobar

-)::(__foo bar__ -)_(

foo bar

-)::(__ foo bar__ -)_(

__ foo bar__

-)::(__ -foo bar__ -)_(

__ -foo bar__

-)::(a__"foo"__ -)_(

a__"foo"__

-)::(foo__bar__ -)_(

foo__bar__

-)::(5__6__78 -)_(

5__6__78

-)::(пристаням__стремятся__ -)_(

пристаням__стремятся__

-)::(__foo, __bar__, baz__ -)_(

foo, bar, baz

-)::(foo-__(bar)__ -)_(

foo-(bar)

-)::(**foo bar ** -)_(

**foo bar **

-)::(**(**foo) -)_(

**(**foo)

-)::(*(**foo**)* -)_(

(foo)

-)::(**Gomphocarpus (*Gomphocarpus physocarpus*, syn. -*Asclepias physocarpa*)** -)_(

Gomphocarpus (Gomphocarpus physocarpus, syn. -Asclepias physocarpa)

-)::(**foo "*bar*" foo** -)_(

foo "bar" foo

-)::(**foo**bar -)_(

foobar

-)::(__foo bar __ -)_(

__foo bar __

-)::(__(__foo) -)_(

__(__foo)

-)::(_(__foo__)_ -)_(

(foo)

-)::(__foo__bar -)_(

__foo__bar

-)::(__пристаням__стремятся -)_(

__пристаням__стремятся

-)::(__foo__bar__baz__ -)_(

foo__bar__baz

-)::(__(bar)__. -)_(

(bar).

-)::(*foo [bar](/url)* -)_(

foo bar

-)::(*foo -bar* -)_(

foo -bar

-)::(_foo __bar__ baz_ -)_(

foo bar baz

-)::(_foo _bar_ baz_ -)_(

foo bar baz

-)::(__foo_ bar_ -)_(

foo bar

-)::(*foo *bar** -)_(

foo bar

-)::(*foo **bar** baz* -)_(

foo bar baz

-)::(*foo**bar**baz* -)_(

foobarbaz

-)::(***foo** bar* -)_(

foo bar

-)::(*foo **bar*** -)_(

foo bar

-)::(*foo**bar*** -)_(

foobar**

-)::(*foo **bar *baz* bim** bop* -)_(

foo bar baz bim bop

-)::(*foo [*bar*](/url)* -)_(

foo bar

-)::(** is not an empty emphasis -)_(

** is not an empty emphasis

-)::(**** is not an empty strong emphasis -)_(

**** is not an empty strong emphasis

-)::(**foo [bar](/url)** -)_(

foo bar

-)::(**foo -bar** -)_(

foo -bar

-)::(__foo _bar_ baz__ -)_(

foo bar baz

-)::(__foo __bar__ baz__ -)_(

foo bar baz

-)::(____foo__ bar__ -)_(

foo bar

-)::(**foo **bar**** -)_(

foo bar

-)::(**foo *bar* baz** -)_(

foo bar baz

-)::(**foo*bar*baz** -)_(

foobarbaz**

-)::(***foo* bar** -)_(

foo bar

-)::(**foo *bar*** -)_(

foo bar

-)::(**foo *bar **baz** -bim* bop** -)_(

foo bar baz -bim bop

-)::(**foo [*bar*](/url)** -)_(

foo bar

-)::(__ is not an empty emphasis -)_(

__ is not an empty emphasis

-)::(____ is not an empty strong emphasis -)_(

____ is not an empty strong emphasis

-)::(foo *** -)_(

foo ***

-)::(foo *\** -)_(

foo *

-)::(foo *_* -)_(

foo _

-)::(foo ***** -)_(

foo *****

-)::(foo **\*** -)_(

foo *

-)::(foo **_** -)_(

foo _

-)::(**foo* -)_(

*foo

-)::(*foo** -)_(

foo*

-)::(***foo** -)_(

*foo

-)::(****foo* -)_(

***foo

-)::(**foo*** -)_(

foo*

-)::(*foo**** -)_(

foo***

-)::(foo ___ -)_(

foo ___

-)::(foo _\__ -)_(

foo _

-)::(foo _*_ -)_(

foo *

-)::(foo _____ -)_(

foo _____

-)::(foo __\___ -)_(

foo _

-)::(foo __*__ -)_(

foo *

-)::(__foo_ -)_(

_foo

-)::(_foo__ -)_(

foo_

-)::(___foo__ -)_(

_foo

-)::(____foo_ -)_(

___foo

-)::(__foo___ -)_(

foo_

-)::(_foo____ -)_(

foo___

-)::(**foo** -)_(

foo

-)::(*_foo_* -)_(

foo

-)::(__foo__ -)_(

foo

-)::(_*foo*_ -)_(

foo

-)::(****foo**** -)_(

foo

-)::(____foo____ -)_(

foo

-)::(******foo****** -)_(

foo

-)::(***foo*** -)_(

foo

-)::(_____foo_____ -)_(

foo

-)::(*foo _bar* baz_ -)_(

foo _bar baz_

-)::(**foo*bar** -)_(

foobar*

-)::(*foo __bar *baz bim__ bam* -)_(

foo bar *baz bim bam

-)::(**foo **bar baz** -)_(

**foo bar baz

-)::(*foo *bar baz* -)_(

*foo bar baz

-)::(*[bar*](/url) -)_(

*bar*

-)::(_foo [bar_](/url) -)_(

_foo bar_

-)::(*<img src="foo" title="*"/> -)_(

*

-)::(**<a href="**"> -)_(

**

-)::(__<a href="__"> -)_(

__

-)::(*a `*`* -)_(

a *

-)::(_a `_`_ -)_(

a _

-)::(**a<http://foo.bar/?q=**> -)_(

**ahttp://foo.bar/?q=**

-)::(__a<http://foo.bar/?q=__> -)_(

__ahttp://foo.bar/?q=__

-)::([link](/uri "title") -)_(

link

-)::([link](/uri) -)_(

link

-)::([link]() -)_(

link

-)::([link](<>) -)_(

link

-)::([link](/my uri) -)_(

[link](/my uri)

-)::([link](</my uri>) -)_(

link

-)::([link](foo -bar) -)_(

[link](foo -bar)

-)::([link](<foo -bar>) -)_(

[link]()

-)::([link]((foo)and(bar)) -)_(

link

-)::([link](foo(and(bar))) -)_(

[link](foo(and(bar)))

-)::([link](foo(and\(bar\))) -)_(

link

-)::([link](<foo(and(bar))>) -)_(

link

-)::([link](foo\)\:) -)_(

link

-)::([link](#fragment) - -[link](http://example.com#fragment) - -[link](http://example.com?foo=bar&baz#fragment) -)_(

link

-

link

-

link

-)::([link](foo\bar) -)_(

link

-)::([link](foo%20b&auml;) -)_(

link

-)::([link]("title") -)_(

link

-)::([link](/url "title") -[link](/url 'title') -[link](/url (title)) -)_(

link -link -link

-)::([link](/url "title \"&quot;") -)_(

link

-)::([link](/url "title "and" title") -)_(

[link](/url "title "and" title")

-)::([link](/url 'title "and" title') -)_(

link

-)::([link]( /uri - "title" ) -)_(

link

-)::([link] (/uri) -)_(

[link] (/uri)

-)::([link [foo [bar]]](/uri) -)_(

link [foo [bar]]

-)::([link] bar](/uri) -)_(

[link] bar](/uri)

-)::([link [bar](/uri) -)_(

[link bar

-)::([link \[bar](/uri) -)_(

link [bar

-)::([link *foo **bar** `#`*](/uri) -)_(

link foo bar #

-)::([![moon](moon.jpg)](/uri) -)_(

moon

-)::([foo [bar](/uri)](/uri) -)_(

[foo bar](/uri)

-)::([foo *[bar [baz](/uri)](/uri)*](/uri) -)_(

[foo [bar baz](/uri)](/uri)

-)::(![[[foo](uri1)](uri2)](uri3) -)_(

[foo](uri2)

-)::(*[foo*](/uri) -)_(

*foo*

-)::([foo *bar](baz*) -)_(

foo *bar

-)::(*foo [bar* baz] -)_(

foo [bar baz]

-)::([foo <bar attr="](baz)"> -)_(

[foo

-)::([foo`](/uri)` -)_(

[foo](/uri)

-)::([foo<http://example.com/?search=](uri)> -)_(

[foohttp://example.com/?search=](uri)

-)::([foo][bar] - -[bar]: /url "title" -)_(

foo

-)::([link [foo [bar]]][ref] - -[ref]: /uri -)_(

link [foo [bar]]

-)::([link \[bar][ref] - -[ref]: /uri -)_(

link [bar

-)::([link *foo **bar** `#`*][ref] - -[ref]: /uri -)_(

link foo bar #

-)::([![moon](moon.jpg)][ref] - -[ref]: /uri -)_(

moon

-)::([foo [bar](/uri)][ref] - -[ref]: /uri -)_(

[foo bar]ref

-)::([foo *bar [baz][ref]*][ref] - -[ref]: /uri -)_(

[foo bar baz]ref

-)::(*[foo*][ref] - -[ref]: /uri -)_(

*foo*

-)::([foo *bar][ref] - -[ref]: /uri -)_(

foo *bar

-)::([foo <bar attr="][ref]"> - -[ref]: /uri -)_(

[foo

-)::([foo`][ref]` - -[ref]: /uri -)_(

[foo][ref]

-)::([foo<http://example.com/?search=][ref]> - -[ref]: /uri -)_(

[foohttp://example.com/?search=][ref]

-)::([foo][BaR] - -[bar]: /url "title" -)_(

foo

-)::([Толпой][Толпой] is a Russian word. - -[ТОЛПОЙ]: /url -)_(

Толпой is a Russian word.

-)::([Foo - bar]: /url - -[Baz][Foo bar] -)_(

Baz

-)::([foo] [bar] - -[bar]: /url "title" -)_(

foo

-)::([foo] -[bar] - -[bar]: /url "title" -)_(

foo

-)::([foo]: /url1 - -[foo]: /url2 - -[bar][foo] -)_(

bar

-)::([bar][foo\!] - -[foo!]: /url -)_(

[bar][foo!]

-)::([foo][ref[] - -[ref[]: /uri -)_(

[foo][ref[]

-

[ref[]: /uri

-)::([foo][ref[bar]] - -[ref[bar]]: /uri -)_(

[foo][ref[bar]]

-

[ref[bar]]: /uri

-)::([[[foo]]] - -[[[foo]]]: /url -)_(

[[[foo]]]

-

[[[foo]]]: /url

-)::([foo][ref\[] - -[ref\[]: /uri -)_(

foo

-)::([] - -[]: /uri -)_(

[]

-

[]: /uri

-)::([ - ] - -[ - ]: /uri -)_(

[ -]

-

[ -]: /uri

-)::([foo][] - -[foo]: /url "title" -)_(

foo

-)::([*foo* bar][] - -[*foo* bar]: /url "title" -)_(

foo bar

-)::([Foo][] - -[foo]: /url "title" -)_(

Foo

-)::([foo] -[] - -[foo]: /url "title" -)_(

foo

-)::([foo] - -[foo]: /url "title" -)_(

foo

-)::([*foo* bar] - -[*foo* bar]: /url "title" -)_(

foo bar

-)::([[*foo* bar]] - -[*foo* bar]: /url "title" -)_(

[foo bar]

-)::([[bar [foo] - -[foo]: /url -)_(

[[bar foo

-)::([Foo] - -[foo]: /url "title" -)_(

Foo

-)::([foo] bar - -[foo]: /url -)_(

foo bar

-)::(\[foo] - -[foo]: /url "title" -)_(

[foo]

-)::([foo*]: /url - -*[foo*] -)_(

*foo*

-)::([foo][bar] - -[foo]: /url1 -[bar]: /url2 -)_(

foo

-)::([foo][bar][baz] - -[baz]: /url -)_(

[foo]bar

-)::([foo][bar][baz] - -[baz]: /url1 -[bar]: /url2 -)_(

foobaz

-)::([foo][bar][baz] - -[baz]: /url1 -[foo]: /url2 -)_(

[foo]bar

-)::(![foo](/url "title") -)_(

foo

-)::(![foo *bar*] - -[foo *bar*]: train.jpg "train & tracks" -)_(

foo bar

-)::(![foo ![bar](/url)](/url2) -)_(

foo bar

-)::(![foo [bar](/url)](/url2) -)_(

foo bar

-)::(![foo *bar*][] - -[foo *bar*]: train.jpg "train & tracks" -)_(

foo bar

-)::(![foo *bar*][foobar] - -[FOOBAR]: train.jpg "train & tracks" -)_(

foo bar

-)::(![foo](train.jpg) -)_(

foo

-)::(My ![foo bar](/path/to/train.jpg "title" ) -)_(

My foo bar

-)::(![foo](<url>) -)_(

foo

-)::(![](/url) -)_(

-)::(![foo] [bar] - -[bar]: /url -)_(

foo

-)::(![foo] [bar] - -[BAR]: /url -)_(

foo

-)::(![foo][] - -[foo]: /url "title" -)_(

foo

-)::(![*foo* bar][] - -[*foo* bar]: /url "title" -)_(

foo bar

-)::(![Foo][] - -[foo]: /url "title" -)_(

Foo

-)::(![foo] -[] - -[foo]: /url "title" -)_(

foo

-)::(![foo] - -[foo]: /url "title" -)_(

foo

-)::(![*foo* bar] - -[*foo* bar]: /url "title" -)_(

foo bar

-)::(![[foo]] - -[[foo]]: /url "title" -)_(

![[foo]]

-

[[foo]]: /url "title"

-)::(![Foo] - -[foo]: /url "title" -)_(

Foo

-)::(\!\[foo] - -[foo]: /url "title" -)_(

![foo]

-)::(\![foo] - -[foo]: /url "title" -)_(

!foo

-)::(<http://foo.bar.baz> -)_(

http://foo.bar.baz

-)::(<http://foo.bar.baz/test?q=hello&id=22&boolean> -)_(

http://foo.bar.baz/test?q=hello&id=22&boolean

-)::(<irc://foo.bar:2233/baz> -)_(

irc://foo.bar:2233/baz

-)::(<MAILTO:FOO@BAR.BAZ> -)_(

MAILTO:FOO@BAR.BAZ

-)::(<http://foo.bar/baz bim> -)_(

<http://foo.bar/baz bim>

-)::(<http://example.com/\[\> -)_(

http://example.com/\[\

-)::(<foo@bar.example.com> -)_(

foo@bar.example.com

-)::(<foo+special@Bar.baz-bar0.com> -)_(

foo+special@Bar.baz-bar0.com

-)::(<foo\+@bar.example.com> -)_(

<foo+@bar.example.com>

-)::(<> -)_(

<>

-)::(<heck://bing.bong> -)_(

<heck://bing.bong>

-)::(< http://foo.bar > -)_(

< http://foo.bar >

-)::(<foo.bar.baz> -)_(

<foo.bar.baz>

-)::(<localhost:5001/foo> -)_(

<localhost:5001/foo>

-)::(http://example.com -)_(

http://example.com

-)::(foo@bar.example.com -)_(

foo@bar.example.com

-)::(<a><bab><c2c> -)_(

-)::(<a/><b2/> -)_(

-)::(<a /><b2 -data="foo" > -)_(

-)::(<a foo="bar" bam = 'baz <em>"</em>' -_boolean zoop:33=zoop:33 /> -)_(

-)::(<responsive-image src="foo.jpg" /> - -<My-Tag> -foo -</My-Tag> -)_( - -foo - -)::(<33> <__> -)_(

<33> <__>

-)::(<a h*#ref="hi"> -)_(

<a h*#ref="hi">

-)::(<a href="hi'> <a href=hi'> -)_(

<a href="hi'> <a href=hi'>

-)::(< a>< -foo><bar/ > -)_(

< a>< -foo><bar/ >

-)::(<a href='bar'title=title> -)_(

<a href='bar'title=title>

-)::(</a> -</foo > -)_( - -)::(</a href="foo"> -)_(

</a href="foo">

-)::(foo <!-- this is a -comment - with hyphen --> -)_(

foo

-)::(foo <!-- not a comment -- two hyphens --> -)_(

foo <!-- not a comment -- two hyphens -->

-)::(foo <!--> foo --> - -foo <!-- foo---> -)_(

foo <!--> foo -->

-

foo <!-- foo--->

-)::(foo <?php echo $a; ?> -)_(

foo

-)::(foo <!ELEMENT br EMPTY> -)_(

foo

-)::(foo <![CDATA[>&<]]> -)_(

foo &<]]>

-)::(<a href="&ouml;"> -)_( -)::(<a href="\*"> -)_( -)::(<a href="\""> -)_(

<a href=""">

-)::(foo -baz -)_(

foo
-baz

-)::(foo\ -baz -)_(

foo
-baz

-)::(foo -baz -)_(

foo
-baz

-)::(foo - bar -)_(

foo
-bar

-)::(foo\ - bar -)_(

foo
-bar

-)::(*foo -bar* -)_(

foo
-bar

-)::(*foo\ -bar* -)_(

foo
-bar

-)::(`code -span` -)_(

code span

-)::(`code\ -span` -)_(

code\ span

-)::(<a href="foo -bar"> -)_(

-)::(<a href="foo\ -bar"> -)_(

-)::(foo\ -)_(

foo\

-)::(foo -)_(

foo

-)::(### foo\ -)_(

foo\

-)::(### foo -)_(

foo

-)::(foo -baz -)_(

foo -baz

-)::(foo - baz -)_(

foo -baz

-)::(hello $.;'there -)_(

hello $.;'there

-)::(Foo χρῆν -)_(

Foo χρῆν

-)::(Multiple spaces -)_(

Multiple spaces

-): \ No newline at end of file