View Source Earmark (Earmark v1.4.46)


Abstract Syntax Tree and Rendering

The AST generation has now been moved out to Earmark.Parser which is installed as a dependency.

This brings some changes to this documentation and also deprecates the usage of Earmark.as_ast

Earmark takes care of rendering the AST to HTML, exposing some AST Transformation Tools and providing a CLI as escript.

Therefore you will not find a detailed description of the supported Markdown here anymore as this is done in here


WARNING: This is just a proxy towards Earmark.Parser.as_ast and is deprecated, it will be removed in version 1.5!

Replace your calls to Earmark.as_ast with EarmarkParse.as_ast as soon as possible.

N.B. If all you use is Earmark.as_ast consider only using Earmark.Parser.

Also please refer yourself to the documentation of Earmark.Parser

The function is described below and the other two API functions as_html and as_html! are now based upon the structure of the result of as_ast.

{:ok, ast, []}                   = Earmark.Parser.as_ast(markdown)
{:ok, ast, deprecation_messages} = Earmark.Parser.as_ast(markdown)
{:error, ast, error_messages}    = Earmark.Parser.as_ast(markdown)


{:ok, html_doc, []}                   = Earmark.as_html(markdown)
{:ok, html_doc, deprecation_messages} = Earmark.as_html(markdown)
{:error, html_doc, error_messages}    = Earmark.as_html(markdown)


html_doc = Earmark.as_html!(markdown, options)

Formats the error_messages returned by as_html and adds the filename to each. Then prints them to stderr and just returns the html_doc


Options can be passed into as as_html/2 or as_html!/2 according to the documentation. A keyword list with legal options (c.f. Earmark.Options) or an Earmark.Options struct are accepted.

{status, html_doc, errors} = Earmark.as_html(markdown, options)
html_doc = Earmark.as_html!(markdown, options)
{status, ast, errors} = Earmark.Parser.as_ast(markdown, options)


All options passed through to Earmark.Parser.as_ast are defined therein, however some options concern only the rendering of the returned AST

These are:

  • compact_output: defaults to false

Normally Earmark aims to produce Human Readable output.

This will give results like these:

iex(1)> markdown = "# Hello\nWorld"
...(1)> Earmark.as_html!(markdown, compact_output: false)

But sometimes whitespace is not desired:

iex(2)> markdown = "# Hello\nWorld"
...(2)> Earmark.as_html!(markdown, compact_output: true)

Be cautions though when using this options, lines will become loooooong.

escape: defaulting to true

If set HTML will be properly escaped

  iex(3)> markdown = "Hello<br>World"
  ...(3)> Earmark.as_html!(markdown)

However disabling escape: gives you maximum control of the created document, which in some cases (e.g. inside tables) might even be necessary

  iex(4)> markdown = "Hello<br>World"
  ...(4)> Earmark.as_html!(markdown, escape: false)

inner_html: defaulting to false

This is especially useful inside templates, when a block element will disturb the layout as in this case

<span><%= Earmark.as_html!(....)%></span>
<span><%= Earmark.as_html!(....)%></span>

By means of the inner_html option the disturbing paragraph can be removed from as_html!'s output

  iex(5)> markdown = "Hello<br>World"
  ...(5)> Earmark.as_html!(markdown, escape: false, inner_html: true)

N.B. that this applies only to top level paragraphs, as can be seen here

  iex(6)> markdown = "- Item\n\nPara"
  ...(6)> Earmark.as_html!(markdown, inner_html: true)
  "<ul>\n  <li>\nItem  </li>\n</ul>\nPara\n"
  • postprocessor: defaults to nil

Before rendering, the AST is transformed by a postprocessor. For details, see the description of Earmark.Transform.map_ast below which will accept the same postprocessor. As a matter of fact, specifying postprocessor: fun is conceptually the same as

          |> Earmark.Parser.as_ast
          |> Earmark.Transform.map_ast(fun)
          |> Earmark.Transform.transform

with all the necessary bookkeeping for options and messages

  • renderer: defaults to Earmark.HtmlRenderer

    The module used to render the final document.

smartypants: defaulting to true

If set the following replacements will be made during rendering of inline text

"---"  "—"
"--"  "–"
"' → ""
?"  "”"
"..."  "…"

Command line

    $ mix
    $ ./earmark

Some options defined in the Earmark.Options struct can be specified as command line switches.


    $ ./earmark --help

to find out more, but here is a short example

    $ ./earmark --smartypants false --code-class-prefix "a- b-"

will call

    Earmark.as_html!( ..., %Earmark.Options{smartypants: false, code_class_prefix: "a- b-"})


By default, that is if the timeout option is not set Earmark uses parallel mapping as implemented in Earmark.pmap/2, which uses Task.await with its default timeout of 5000ms.

In rare cases that might not be enough.

By indicating a longer timeout option in milliseconds Earmark will use parallel mapping as implemented in Earmark.pmap/3, which will pass timeout to Task.await.

In both cases one can override the mapper function with either the mapper option (used if and only if timeout is nil) or the mapper_with_timeout function (used otherwise).

For the escript only the timeout command line argument can be used.


Please be aware that Markdown is not a secure format. It produces HTML from Markdown and HTML. It is your job to sanitize and or filter the output of Earmark.as_html if you cannot trust the input and are to serve the produced HTML on the Web.



DEPRECATED call Earmark.Parser.as_ast instead

See Earmark.Internal.as_html/2.

A convenience method that always returns an HTML representation of the markdown document passed in. In case of the presence of any error messages they are printed to stderr.

See Earmark.Internal.pmap/3.

Accesses current hex version of the Earmark application. Convenience for iex usage.


@type ast() :: [ast_node()]
@type ast_attribute() :: {ast_attribute_name(), ast_attribute_value()}
@type ast_attribute_name() :: binary()
@type ast_attribute_value() :: binary()
@type ast_attributes() :: [ast_attribute()]
@type ast_meta() :: map()
@type ast_node() :: binary() | ast_tuple()
@type ast_tag() :: binary()
@type ast_tuple() :: {ast_tag(), ast_attributes(), ast(), ast_meta()}


Link to this function

as_ast(lines, options \\ %Options{})

View Source

DEPRECATED call Earmark.Parser.as_ast instead

Link to this function

as_ast!(markdown, options \\ [])

View Source

See Earmark.Internal.as_ast!/2.

Link to this function

as_html(lines, options \\ [])

View Source

See Earmark.Internal.as_html/2.

Link to this function

as_html!(lines, options \\ [])

View Source

See Earmark.Internal.as_html!/2.

Link to this function

from_file!(filename, options \\ [])

View Source

A convenience method that always returns an HTML representation of the markdown document passed in. In case of the presence of any error messages they are printed to stderr.

Otherwise it behaves exactly as as_html.

Link to this function

pmap(collection, func, timeout \\ 5000)

View Source

See Earmark.Internal.pmap/3.

Link to this function

transform(ast, options \\ [])

View Source

See Earmark.Transform.transform/2.

Accesses current hex version of the Earmark application. Convenience for iex usage.