Markdown Package User Manual

The Markdown package converts CommonMark markup to T_eX commands. The functionality is provided both as a Lua module and as plain T_eX, L^aT_eX, and ConT_eXt macro packages that can be used to directly typeset T_eX documents containing markdown markup. Unlike other convertors, the Markdown package does not require any external programs, and makes it easy to redefine how each and every markdown element is rendered. Creative abuse of the markdown syntax is encouraged.

This document is a user manual for the Markdown package. It provides tutorials and code examples. For an in-depth description of the package requirements, interfaces, and implementation, please refer to the technical documentation.

1.1 Requirements

The package requires either our official Docker image, which contains the latest development version of the Markdown package, or a T_eX distribution: T_eX Live ≥ 2022 is known to work with the current version of the Markdown package and so are recent versions of MikT_eX. If you are using an older, incomplete, or atypical T_eX distribution, please consult the technical documentation for a detailed list of requirements.

1.2 Installation

If Markdown is not included in your T_eX distribution, you will need to install it.

git clone https://github.com/witiko/markdown

Next, enter the directory named markdown and run the make base command using GNU Make:

cd markdown
make base

1.2.1 Local Installation

To perform a local installation, place the above files into your T_eX directory structure. This is generally where the individual files should be placed:

where ⟨TEXMF⟩ corresponds to a root of your T_eX distribution, such as /usr/share/texmf and ~/texmf on UN*X systems or C:\Users\⟨Your username⟩\texmf on Windows systems. When in doubt, consult the manual of your T_eX distribution.

1.2.2 Portable Installation

Alternatively, you can also store the above files in the same folder as your T_eX document and distribute them together. This way your document can be portably typeset on legacy T_eX distributions.

1.3 First Document

In this section, we will take the necessary steps to typeset our first markdown document in T_eX. This will serve as our first hands-on experience with the package and also as a reassurance that the package has been correctly installed.

If you are using our official Docker image, you need to prefix all commands in this section with docker run --rm -v "$PWD"/workdir:/workdir -w /workdir witiko/markdown. For example, instead of luatex document.tex, you would execute the following command:

docker run --rm -v "$PWD"/workdir:/workdir -w /workdir witiko/markdown \
  luatex document.tex

1.3.1 Using Lua

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\begingroup
\catcode`\%=12
\catcode`\#=12
\input hello
\endgroup
\bye

1.3.1.1 Using the Lua Module

Using a text editor, create a text document named hello.lua with the following content:

#!/usr/bin/env texlua
local kpse = require("kpse")
kpse.set_program_name("luatex")
local markdown = require("markdown")
local convert = markdown.new()
print(convert("Hello *world*!"))

texlua hello.lua > hello.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!” Invoking pdfTeX should have the same effect:

texlua hello.lua > hello.tex
pdftex document.tex

1.3.1.2 Using the Lua Command-Line Interface

Using a text editor, create a text document named hello.md with the following content:

texlua ⟨CLI pathname⟩ -- hello.md hello.tex
luatex document.tex

where ⟨CLI pathname⟩ corresponds to the location of the Lua CLI script file, such as ~/texmf/scripts/markdown/markdown-cli.lua on UN*X systems or C:\Users\⟨Your username⟩\texmf\scripts\markdown\markdown-cli.lua on Windows systems. Use the command kpsewhich -a markdown-cli.lua to locate the Lua CLI script file using Kpathsea.

A PDF document named document.pdf should be produced and contain the text “Hello world!” Invoking pdfTeX should have the same effect:

texlua ⟨CLI pathname⟩ -- hello.md hello.tex
pdftex document.tex

1.3.2 Using Plain T_eX

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\markdownBegin
Hello *world*!
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!”

pdftex --shell-escape document.tex

This should also produce a PDF document named document.pdf with the same content.

Instead of writing your markdown document between \markdownBegin and \markdownEnd, you can also include markdown documents using the \markdownInput macro, similarly to how you might use the \input TeX primitive to include T_eX documents.

Using a text editor, create a text document named hello.md with the following content:

\input markdown
\markdownInput{hello.md}
\bye

Next, invoke LuaTeX or pdfTeX from the terminal like in the previous example. A PDF document named document.pdf should be produced and contain the text “Hello world!”

1.3.3 Using L^aT_eX

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}
\begin{markdown}
Hello *world*!
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!”

pdflatex --shell-escape document.tex

This should also produce a PDF document named document.pdf with the same content.

Instead of writing your markdown document between \begin{markdown} and \end{markdown}, you can also include markdown documents using the \markdownInput macro, similarly to how you might use the \input TeX primitive to include L^aT_eX documents.

Using a text editor, create a text document named hello.md with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}
\begin{markdown}
\markdownInput{hello.md}
\end{markdown}
\end{document}

Next, invoke LuaTeX or pdfTeX from the terminal like in the previous example. A PDF document named document.pdf should be produced and contain the text “Hello world!”

As the next step, try typesetting the example documents distributed along with the Markdown package:

git clone https://github.com/witiko/markdown
cd markdown/examples
lualatex latex-luatex.tex

A PDF document named latex-luatex.pdf should be produced. Open the text documents latex-luatex.tex and example.md in a text editor to see how the example documents are structured. Try changing the documents and typesetting them as follows:

lualatex latex-luatex.tex

1.3.4 Using ConT_eXt

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\starttext
\startmarkdown
Hello *world*!
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!”

Instead of writing your markdown document between \startmarkdown and \stopmarkdown, you can also include markdown documents using the \inputmarkdown macro, similarly to how you might use the \input TeX primitive to include ConT_eXt documents.

Using a text editor, create a text document named hello.md with the following content:

\usemodule[t][markdown]
\starttext
\inputmarkdown{hello.md}
\stoptext

Next, invoke LuaTeX from the terminal like in the previous example. A PDF document named document.pdf should be produced and contain the text “Hello world!”

As the next step, try typesetting the example documents distributed along with the Markdown package:

git clone https://github.com/witiko/markdown
cd markdown/examples
context --luatex context.tex

A PDF document named context.pdf should be produced. Open the text documents context.tex and example.md in a text editor to see how the example documents are structured. Try changing the documents and typesetting them as follows:

context --luatex context.tex

2 Examples

In this section, I will describe the individual parts of the Markdown package. Each part will be shown by example, leaving the implementation details to the technical documentation.

2.1 Interfaces

In this section, I will describe the individual interfaces exposed by the Markdown package starting with the low-level Lua interfaces and all the way up to the L^aT_eX and ConT_eXt interfaces intended for the ordinary user.

2.1.1 Lua

The Lua programming language is what drives the conversion from markdown to T_eX in the Markdown package. Based on the Lunamark Lua library by John MacFarlane, the Lua implementation is largely independent on T_eX, and can be used separately from typesetting a document. Lua provides two interfaces: a Lua module and a command-line interface (CLI).

2.1.1.1 Lua Module

A Lua module is a software library that can be used from in other programs. The markdown Lua module makes it possible to convert markdown to T_eX from within LuaT_eX documents and Lua scripts.

The markdown Lua module exposes the new(⟨options⟩) method, which creates a converter function from markdown to T_eX. The properties of the converter function are specified by the Lua table options. The parameter is optional; when unspecified, the behaviour will be the same as if ⟨options⟩ were an empty table.

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\input example
\endgroup
\bye

Using a text editor, create a text document named example.lua with the following content:

#!/usr/bin/env texlua
local kpse = require("kpse")
kpse.set_program_name("luatex")
local markdown = require("markdown")
local input, convert_nomath, convert_math, paragraph

input = [[$\sqrt{-1}$ *equals* $i$.]]
convert_nomath = markdown.new()
convert_math = markdown.new({texMathDollars = true})
paragraph = [[\par]]

print(
  convert_nomath(input) .. paragraph ..
  convert_math(input)
)

texlua example.lua > example.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

texlua example.lua > example.tex
pdftex document.tex

Rather than use the texlua interpreter, we can also access the markdown Lua module directly from our document. Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\directlua{
  local markdown = require("markdown")
  local input, convert_nomath, convert_math, paragraph

  input = [[$\string\sqrt{-1}$ *equals* $i$.]]
  convert_nomath = markdown.new()
  convert_math = markdown.new({texMathDollars = true})
  paragraph = [[\par]]

  tex.sprint(
    convert_nomath(input) .. paragraph ..
    convert_math(input)
  )
}
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

In this case, we cannot use pdfTeX, because pdfTeX does not define the \directlua T_eX command.

2.1.1.2 Lua Command-Line Interface

The Lua command-line interface (CLI) of the Markdown package makes the functionality of the Lua module accessible from the command line. This makes it possible to convert documents from markdown to T_eX manually without any knowledge of the Lua programming language.

The Lua command-line interface accepts the same options as the markdown Lua module, but now the options are specified as command-line parameters.

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\input nomath
\par
\input math
\endgroup
\bye

Using a text editor, create a text document named example.md with the following content:

$\sqrt{-1}$ *equals* $i$.

texlua ⟨CLI pathname⟩ -- example.md nomath.tex
texlua ⟨CLI pathname⟩ tex_math_dollars=true -- example.md math.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

texlua ⟨CLI pathname⟩ -- example.md nomath.tex
texlua ⟨CLI pathname⟩ tex_math_dollars=true -- example.md math.tex
pdftex document.tex

2.1.2 Plain T_eX

The plain T_eX interface provides T_eX commands that typeset markdown documents by using the Lua interface behind the scenes. Unlike the Lua interface, the plain TeX interface does not provide low-level tools for converting markdown to T_eX. Instead, its goal is to provide high-level typesetting capabilities.

The plain T_eX interface accepts the same options as the markdown Lua module, in addition to its own options, but now the options are specified as T_eX commands.

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts

\markdownBegin
$\sqrt{-1}$ *equals* $i$.
\markdownEnd

\def\markdownOptionTexMathDollars{true}
\markdownBegin
$\sqrt{-1}$ *equals* $i$.
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

pdftex --shell-escape document.tex

2.1.3 L^aT_eX

The L^aT_eX interface provides the same level of functionality as the plain T_eX interface by using the plain T_eX interface behind the scenes. Unlike the plain T_eX interface, the L^aT_eX interface uses familiar L^aT_eX idioms, such as package options and environments.

The L^aT_eX interface accepts the same options as the plain T_eX interface, but now the options are specified as ⟨key⟩ = ⟨value⟩ pairs and they are passed either as package options, in the \markdownSetup command, or as parameters for the markdown* L^aT_eX environment.

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}

\begin{markdown}
$\sqrt{-1}$ *equals* $i$
\end{markdown}

\begin{markdown}[texMathDollars]
$\sqrt{-1}$ *equals* $i$
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

pdflatex --shell-escape document.tex

2.1.4 ConT_eXt

The ConT_eXt interface provides the same level of functionality as the plain T_eX interface by using the plain T_eX interface behind the scenes. Unlike the plain T_eX interface, the ConT_eXt interface uses familiar ConT_eXt idioms as syntactic sugar.

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\starttext

\startmarkdown
$\sqrt{-1}$ *equals* $i$.
\stopmarkdown

\setupmarkdown[texmathdollars = yes]
\startmarkdown
$\sqrt{-1}$ *equals* $i$.
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2 Options

In this section, I will describe all the options recognized by the Markdown package.

2.2.1 Lua

Lua options control the conversion from markdown to T_eX. They are supported by all interfaces of the Markdown package starting with the low-level Lua interfaces and all the way up to the L^aT_eX and ConT_eXt interfaces.

2.2.1.1 Option eagerCache

Lua CLI Example

Using a text editor, create a text document named hello.md with the following content:

Next, invoke LuaTeX from the terminal with the eagerCache option disabled:

texlua ⟨CLI pathname⟩ eagerCache=false -- hello.md hello.tex

A T_eX document named hello.tex should be produced and contain the following code:

Hello \markdownRendererEmphasis{world}!\relax

Invoke LuaTeX from the terminal again, this time with the eagerCache option enabled:

texlua ⟨CLI pathname⟩ eagerCache=true -- hello.md hello.tex

A T_eX document named hello.tex should be produced and contain the following code:

\input ./⟨hash⟩.md.tex\relax

Additionally, a T_eX document named ⟨hash⟩.md.tex should be produced and contain the following code:

Hello \markdownRendererEmphasis{world}!\relax

2.2.1.2 Option singletonCache

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local convert1 = markdown.new({})
  local convert2 = markdown.new({singletonCache=false})
  local convert3 = markdown.new({singletonCache=true})
  local newline = [[^^J^^J]]
  tex.print(tostring(convert1) .. ", ")
  tex.print(tostring(convert2) .. ", ")
  tex.print(tostring(convert3))
}
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

As you can see, the caching causes convert1 and convert3 to be the same conversion function.

2.2.1.3 Option cacheDir

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local convert = markdown.new({cacheDir = "cache"})
  local input = "Hello *world*!"
  tex.sprint(convert(input)) }
\endgroup
\bye

Create an empty directory named cache next to our text document. Then, invoke LuaTeX from the terminal:

luatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!” Several cache files of the Markdown package will also be produced in the cache directory as we requested using the cacheDir option.

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\begingroup
\catcode`\%=12
\catcode`\#=12
\input hello
\endgroup
\bye

Using a text editor, create a text document named hello.md with the following content:

texlua ⟨CLI pathname⟩ cacheDir=cache -- hello.md hello.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!” A directory named cache containing several cache files of the Markdown package will also be produced as we requested using the cacheDir option.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionCacheDir{cache}
\markdownBegin
Hello *world*!
\markdownEnd
\bye

luatex document.tex

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[cacheDir=cache]{markdown}
\begin{document}
\begin{markdown}
Hello *world*!
\end{markdown}
\end{document}

lualatex document.tex

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[cacheDir = cache]
\starttext
\startmarkdown
Hello *world*!
\stopmarkdown
\stoptext

context --luatex document.tex

2.2.1.4 Option contentBlocksLanguageMap

L^aT_eX Example

Using a text editor, create a text document named table.csv with the following content:

Create also a text document named language-map.json with the following content:

{
  "tex": "LaTeX"
}

This is an example code listing in \LaTeX.

This is a *transcluded markdown document*.

\documentclass{article}
\usepackage{minted}
\usepackage[contentBlocks]{markdown}
\markdownSetup{
  contentBlocksLanguageMap = {language-map.json},
}
\begin{document}
\begin{markdown}
/table.csv  (An example table)
/code.tex   (An example code listing)
/part.md    (A file transclusion example)
\end{markdown}
\end{document}

lualatex --shell-escape document.tex

A PDF document named document.pdf should be produced and contain the following text:

Name	Surname	Born
Albert	Einstein	1879
Marie	Curie	1867
Thomas	Edison	1847

ConT_eXt Example

Using a text editor, create a text document named table.csv with the following content:

Create also a text document named language-map.json with the following content:

{
  "tex": "ConTeXt"
}

This is an example code listing in \ConTeXt.

This is a *transcluded markdown document*.

\usemodule[t][markdown]
\setupmarkdown
  [
    contentBlocks = yes,
    contentBlocksLanguageMap = language-map.json,
  ]
\definetyping [ConTeXt]
\setuptyping  [ConTeXt] [option=TEX]
\starttext
\startmarkdown
/table.csv  (An example table)
/code.tex   (An example code listing)
/part.md    (A file transclusion example)
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Name	Surname	Born
Albert	Einstein	1879
Marie	Curie	1867
Thomas	Edison	1847

2.2.1.5 Option debugExtensionsFileName

2.2.1.6 Option frozenCacheFileName

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local convert = markdown.new({finalizeCache = true, frozenCacheFileName = "cache.tex"})
  local input = "Hello *world*!"
  tex.sprint(convert(input)) }
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!” A frozen cache will also be produced in the cache.tex output file as we requested using the finalizeCache and frozenCacheFileName options.

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\begingroup
\catcode`\%=12
\catcode`\#=12
\input hello
\endgroup
\bye

Using a text editor, create a text document named hello.md with the following content:

texlua ⟨CLI pathname⟩ finalizeCache=true frozenCacheFileName=cache.tex -- hello.md hello.tex
luatex document.tex

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionFinalizeCache{true}
\def\markdownOptionFrozenCacheFileName{cache.tex}
\markdownBegin
Hello *world*!
\markdownEnd
\bye

luatex document.tex

Next, create a new text document frozen-document.tex with the following content:

\input markdown
\def\markdownOptionFrozenCache{true}
\def\markdownOptionFrozenCacheFileName{cache.tex}
\markdownBegin
Hi *world*!
\markdownEnd
\bye

pdftex -no-shell-escape frozen-document.tex

A PDF document named frozen-document.pdf should be produced and contain the text “Hello world!” Since we used the contents of the frozen cache using the \markdownOptionFrozenCache option, we were able to typeset the document without accessing the shell or invoking Lua, but the change in the content of the markdown document from “Hello world!” to “Hi world!” was not reflected.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass[finalizecache]{article}
\usepackage[frozenCacheFileName=cache.tex]{markdown}
\begin{document}
\begin{markdown}
Hello *world*!
\end{markdown}
\end{document}

lualatex document.tex

Next, create a new text document frozen-document.tex with the following content:

\documentclass[frozencache]{article}
\usepackage[frozenCacheFileName=cache.tex]{markdown}
\begin{document}
\begin{markdown}
Hi *world*!
\end{markdown}
\end{document}

pdflatex -no-shell-escape frozen-document.tex

A PDF document named frozen-document.pdf should be produced and contain the text “Hello world!” Since we used the contents of the frozen cache using the frozencache option, we were able to typeset the document without accessing the shell or invoking Lua, but the change in the content of the markdown document from “Hello world!” to “Hi world!” was not reflected.

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown
  [
    finalizeCache = yes,
    frozenCacheFileName = cache.tex,
  ]
\starttext
\startmarkdown
Hello *world*!
\stopmarkdown
\stoptext

context --luatex document.tex

Next, create a new text document frozen-document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown
  [
    frozenCache = yes,
    frozenCacheFileName = cache.tex,
  ]
\starttext
\startmarkdown
Hi *world*!
\stopmarkdown
\stoptext

context --luatex frozen-document.tex

2.2.1.7 Option autoIdentifiers

2.2.1.8 Option blankBeforeBlockquote

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local newline = [[^^J^^J]]
  local convert, input

  convert = markdown.new()
  input = "A paragraph." .. newline ..
          "> A quote."   .. newline
  tex.sprint(convert(input))

  convert = markdown.new({blankBeforeBlockquote = true})
  input = "A paragraph."   .. newline ..
          "> Not a quote." .. newline
  tex.sprint(convert(input)) }
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\input optionfalse
\input optiontrue
\endgroup
\bye

Using a text editor, create a text document named content.md with the following content:

A paragraph.
> A quote?

texlua ⟨CLI pathname⟩ -- content.md optionfalse.tex
texlua ⟨CLI pathname⟩ blankBeforeBlockquote=true -- content.md optiontrue.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown

\markdownBegin
A paragraph.
> A quote.
\markdownEnd

\def\markdownOptionBlankBeforeBlockquote{true}
\markdownBegin
A paragraph.
> Not a quote.
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}

\begin{markdown}
A paragraph.
> A quote.
\end{markdown}

\begin{markdown}[blankBeforeBlockquote]
A paragraph.
> Not a quote.
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\starttext

\startmarkdown
A paragraph.
> A quote.
\stopmarkdown

\setupmarkdown[blankBeforeBlockquote = yes]
\startmarkdown
A paragraph.
> Not a quote.
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.9 Option blankBeforeCodeFence

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local newline = [[^^J^^J]]
  local convert, input

  convert = markdown.new({fencedCode = true})
  input = "A paragraph."   .. newline ..
          "```"            .. newline ..
          "A fenced code." .. newline ..
          "```"            .. newline
  tex.sprint(convert(input))

  convert = markdown.new({
    fencedCode = true, blankBeforeCodeFence = true})
  input = "A paragraph."       .. newline ..
          "```"                .. newline ..
          "Not a fenced code." .. newline ..
          "```"                .. newline
  tex.sprint(convert(input)) }
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\input optionfalse
\input optiontrue
\endgroup
\bye

Using a text editor, create a text document named content.md with the following content:

A paragraph.
```
A code fence?
```

texlua ⟨CLI pathname⟩ fencedCode=true -- content.md optionfalse.tex
texlua ⟨CLI pathname⟩ fencedCode=true blankBeforeCodeFence=true  -- content.md optiontrue.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionFencedCode{true}

\markdownBegin
A paragraph.
```
A fenced code.
```
\markdownEnd

\def\markdownOptionBlankBeforeCodeFence{true}
\markdownBegin
A paragraph.
```
Not a fenced code.
```
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[fencedCode]{markdown}
\begin{document}

\begin{markdown}
A paragraph.
```
A fenced code.
```
\end{markdown}

\begin{markdown}[blankBeforeCodeFence]
A paragraph.
```
Not a fenced code.
```
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[fencedCode = yes]
\starttext

\startmarkdown
A paragraph.
```
A fenced code.
```
\stopmarkdown

\setupmarkdown[blankBeforeCodeFence = yes]
\startmarkdown
A paragraph.
```
Not a fenced code.
```
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.10 Option blankBeforeDivFence

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[fencedDivs]{markdown}
\begin{document}

\begin{markdown}
A paragraph.

::: {.identifier}
A fenced div.
:::
\end{markdown}

\begin{markdown}[blankBeforeDivFence]
A paragraph.

::: {.identifier}
Not a fenced div.
:::
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.11 Option blankBeforeHeading

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\def\markdownRendererHeadingOne#1{{\bf #1}\par}
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local newline = [[^^J^^J]]
  local convert, input

  convert = markdown.new()
  input = "A paragraph." .. newline ..
          "A heading."   .. newline ..
          "=========="   .. newline
  tex.sprint(convert(input))

  convert = markdown.new({blankBeforeHeading = true})
  input = "A paragraph."    .. newline ..
          "Not a heading."  .. newline ..
          "=============="  .. newline
  tex.sprint(convert(input)) }
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\input optionfalse
\input optiontrue
\endgroup
\bye

Using a text editor, create a text document named content.md with the following content:

A paragraph.
A heading?
==========

texlua ⟨CLI pathname⟩ -- content.md optionfalse.tex
texlua ⟨CLI pathname⟩ blankBeforeHeading=true  -- content.md optiontrue.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown

\markdownBegin
A paragraph.
A heading.
==========
\markdownEnd

\def\markdownOptionBlankBeforeHeading{true}
\markdownBegin
A paragraph.
Not a heading.
==============
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}

\begin{markdown}
A paragraph.
A heading.
==========
\end{markdown}

\begin{markdown}[blankBeforeHeading]
A paragraph.
Not a heading.
==============
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\starttext

\startmarkdown
A paragraph.
A heading.
==========
\stopmarkdown

\setupmarkdown[blankBeforeHeading = yes]
\startmarkdown
A paragraph.
Not a heading.
==============
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.12 Option blankBeforeList

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local newline = [[^^J^^J]]
  local convert, input

  convert = markdown.new()
  input = "A paragraph."   .. newline ..
          "- a list"       .. newline
  tex.sprint(convert(input))

  convert = markdown.new({
    blankBeforeList = true})
  input = "A paragraph."   .. newline ..
          "- not a list"     .. newline
  tex.sprint(convert(input)) }
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\input optionfalse
\input optiontrue
\endgroup
\bye

Using a text editor, create a text document named content.md with the following content:

A paragraph.
- a list?

texlua ⟨CLI pathname⟩ -- content.md optionfalse.tex
texlua ⟨CLI pathname⟩ blankBeforeList=true  -- content.md optiontrue.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown

\markdownBegin
A paragraph.
- a list
\markdownEnd

\def\markdownOptionBlankBeforeList{true}
\markdownBegin
A paragraph.
- not a list
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}

\begin{markdown}
A paragraph.
- a list
\end{markdown}

\begin{markdown}[blankBeforeList]
A paragraph.
- not a list
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\starttext

\startmarkdown
A paragraph.
- a list
\stopmarkdown

\setupmarkdown[blankBeforeList = yes]
\startmarkdown
A paragraph.
- not a list
\stopmarkdown

\stoptext

context document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.13 Option bracketedSpans

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[bracketedSpans]{markdown}
\usepackage{expl3}
\ExplSyntaxOn
\markdownSetup{
  renderers = {
    bracketedSpanAttributeContextBegin = {
      \group_begin:
      \color_group_begin:
      \markdownSetup{
        renderers = {
          attributeKeyValue = {
            \str_if_eq:nnT
              { ##1 }
              { color }
              {
                 \color_select:n { ##2 }
              }
          },
        },
      }
    },
    bracketedSpanAttributeContextEnd = {
      \color_group_end:
      \group_end:
    },
  },
}
\ExplSyntaxOff
\begin{document}
\begin{markdown}
Here is some [colored text]{color=red}.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.14 Option breakableBlockquotes

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\def\markdownRendererHeadingOne#1{{\bf #1}\par}
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local newline = [[^^J^^J]]
  local convert, input

  convert = markdown.new({breakableBlockquotes = false})
  input = "> A single"     .. newline .. newline ..
          "> block quote." .. newline
  tex.sprint(convert(input))

  convert = markdown.new()
  input = "> A block quote."       .. newline .. newline ..
          "> Another block quote." .. newline
  tex.sprint(convert(input)) }
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\input optionfalse
\input optiontrue
\endgroup
\bye

Using a text editor, create a text document named content.md with the following content:

> A single block quote

> or two block quotes?

texlua ⟨CLI pathname⟩ breakableBlockquotes=false -- content.md optionfalse.tex
texlua ⟨CLI pathname⟩  -- content.md optiontrue.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown

\def\markdownOptionBreakableBlockquotes{false}
\markdownBegin
> A single

> block quote.
\markdownEnd

\def\markdownOptionBreakableBlockquotes{true}
\markdownBegin
> A block quote.

> Another block quote.
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}

\begin{markdown}[breakableBlockquotes = false]
> A single

> block quote.
\end{markdown}

\begin{markdown}
> A block quote.

> Another block quote.
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\starttext

\setupmarkdown[breakableBlockquotes = no]
\startmarkdown
> A single

> block quote.
\stopmarkdown

\setupmarkdown[breakableBlockquotes = yes]
\startmarkdown
> A block quote.

> Another block quote.
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.15 Option citationNbsps

L^aT_eX Example

Using a text editor, create a text document named document.bib with the following content:

@book{knuth:tex,
  author    = "Knuth, Donald Ervin",
  title     = "The \TeX book, volume A of Computers and typesetting",
  publisher = "Addison-Wesley",
  year      = "1984"
}

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[citations]{markdown}
\begin{document}

\begin{markdown}
The TeXbook [@knuth:tex, p. 123 and 130] is good.
\end{markdown}

\begin{markdown}[citationNbsps = false]
The TeXbook [@knuth:tex, p. 123 and 130] is good.
\end{markdown}

\bibliographystyle{plain}
\bibliography{document.bib}
\end{document}

lualatex document.tex
bibtex document.aux
lualatex document.tex
lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text, where the middot (·) denotes a non-breaking space:

2.2.1.16 Option citations

L^aT_eX Example

Using a text editor, create a text document named document.bib with the following content:

@book{knuth:tex,
  author    = "Knuth, Donald Ervin",
  title     = "The \TeX book, volume A of Computers and typesetting",
  publisher = "Addison-Wesley",
  year      = "1984"
}

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[backend=biber]{biblatex}
\addbibresource{document.bib}
\usepackage[citations]{markdown}
\begin{document}

\begin{markdown}
The TeXbook [@knuth:tex, p. 123 and 130] was written by @knuth:tex.
\end{markdown}

\printbibliography
\end{document}

lualatex document.tex
biber document.bcf
lualatex document.tex
lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.17 Option codeSpans

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local convert = markdown.new()
  local input =
    "``This is a code span.'' " ..
    "``This is no longer a code span.''"
  tex.sprint(convert(input)) }
\par
\directlua{
  local markdown = require("markdown")
  local convert = markdown.new({codeSpans = false})
  local input =
    "``This is a quote.'' " ..
    "``This is another quote.''"
  tex.sprint(convert(input)) }
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\input optionfalse
\par
\input optiontrue
\endgroup
\bye

Using a text editor, create a text document named content.md with the following content:

``Is this a code span?'' ``Or a quote?''

texlua ⟨CLI pathname⟩ codeSpans=false -- content.md optionfalse.tex
texlua ⟨CLI pathname⟩ -- content.md optiontrue.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown

\markdownBegin
``This is a code span.''
``This is no longer a code span.''
\markdownEnd

\def\markdownOptionCodeSpans{false}
\markdownBegin
``This is a quote.''
``This is another quote.''
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}

\begin{markdown}
``This is a code span.''
``This is no longer a code span.''
\end{markdown}

\begin{markdown}[codeSpans=false]
``This is a quote.''
``This is another quote.''
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\starttext

\startmarkdown
``This is a code span.''
``This is no longer a code span.''
\stopmarkdown

\setupmarkdown[codeSpans = no]
\startmarkdown
``This is a quote.''
``This is another quote.''
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.18 Option contentBlocks

L^aT_eX Example

Using a text editor, create a text document named table.csv with the following content:

Create also a text document named markdown-languages.json with the following content:

{
  "tex": "LaTeX"
}

This is an example code listing in \LaTeX.

This is a *transcluded markdown document*.

\documentclass{article}
\usepackage{minted}
\usepackage[contentBlocks]{markdown}
\begin{document}
\begin{markdown}
/table.csv  (An example table)
/code.tex   (An example code listing)
/part.md    (A file transclusion example)
\end{markdown}
\end{document}

lualatex --shell-escape document.tex

A PDF document named document.pdf should be produced and contain the following text:

Name	Surname	Born
Albert	Einstein	1879
Marie	Curie	1867
Thomas	Edison	1847

ConT_eXt Example

Using a text editor, create a text document named table.csv with the following content:

Create also a text document named markdown-languages.json with the following content:

{
  "tex": "ConTeXt"
}

This is an example code listing in \ConTeXt.

This is a *transcluded markdown document*.

\usemodule[t][markdown]
\setupmarkdown[contentBlocks = yes]
\definetyping [ConTeXt]
\setuptyping  [ConTeXt] [option=TEX]
\starttext
\startmarkdown
/table.csv  (An example table)
/code.tex   (An example code listing)
/part.md    (A file transclusion example)
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Name	Surname	Born
Albert	Einstein	1879
Marie	Curie	1867
Thomas	Edison	1847

2.2.1.19 Option contentLevel

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionContentLevel{inline}
\markdownBegin
- this is
- a text
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}

\begin{markdown}
- this is
- a list
\end{markdown}

\begin{markdown}[contentLevel=inline]
- this is
- a text
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\starttext

\startmarkdown
- this is
- a list
\stopmarkdown

\setupmarkdown[contentLevel = inline]
\startmarkdown
- this is
- a text
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.20 Option debugExtensions

L^aT_eX Example

Using a text editor, create a text document named strike-through.lua with the following content:

local strike_through = {
  api_version = 2,
  grammar_version = 4,
  finalize_grammar = function(reader)
    local nonspacechar = lpeg.P(1) - lpeg.S("\t ")
    local doubleslashes = lpeg.P("//")
    local function between(p, starter, ender)
      ender = lpeg.B(nonspacechar) * ender
      return (starter * #nonspacechar
             * lpeg.Ct(p * (p - ender)^0) * ender)
    end

    local read_strike_through = between(
      lpeg.V("Inline"), doubleslashes, doubleslashes
    ) / function(s) return {"\\st{", s, "}"} end

    reader.insert_pattern("Inline after LinkAndEmph", read_strike_through,
                          "StrikeThrough")
    reader.add_special_character("/")
  end
}

return strike_through

Using a text editor, create also a text document named document.tex with the following content:

\documentclass{article}
\usepackage{soul}
\usepackage[extension = strike-through.lua,
            debugExtensions]{markdown}
\begin{document}
\begin{markdown}
This is //a lunar roving vehicle// strike-through text.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Furthermore, a JSON document named document.debug-extensions.json should also be produced and contain the following text:

{
    "Block": [
        "Blockquote",
        "Verbatim",
        "FencedCode (built-in fenced_code syntax extension)",
        "ThematicBreak",
        "BulletList",
        "OrderedList",
        "DisplayHtml",
        "Heading"
    ],
    "BlockOrParagraph": [
        "Block",
        "Paragraph",
        "Plain"
    ],
    "EndlineExceptions": [
        "EndlineExceptions (built-in fenced_code syntax extension)"
    ],
    "Inline": [
        "Str",
        "Space",
        "Endline",
        "EndlineBreak",
        "LinkAndEmph",
        "StrikeThrough (user-defined \"./strike-through.lua\" syntax extension)",
        "Code",
        "AutoLinkUrl",
        "AutoLinkEmail",
        "AutoLinkRelativeReference",
        "InlineHtml",
        "HtmlEntity",
        "EscapedChar",
        "Smart",
        "Symbol"
    ]
}

This output shows us that our user-defined syntax extension has been correctly inserted to the grammar of markdown.

2.2.1.21 Option definitionLists

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[definitionLists]{markdown}
\begin{document}
\begin{markdown}
Term 1

:   Definition 1

Term 2 with *inline markup*

:   Definition 2

        { some code, part of Definition 2 }

    Third paragraph of definition 2.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[definitionLists = yes]
\starttext
\startmarkdown
Term 1

:   Definition 1

Term 2 with *inline markup*

:   Definition 2

        { some code, part of Definition 2 }

    Third paragraph of definition 2.
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.22 Option expectJekyllData

L^aT_eX Example

Using a text editor, create a text document named jane-doe.yml with the following content:

name: Jane Doe
age:  99

Using a text editor, create also a text document named document.tex with the following content:

\documentclass{article}
\usepackage[jekyllData]{markdown}
\markdownSetup{
  jekyllDataRenderers = {
    name = {\gdef\name{#1}},
    code = {\gdef\age{#1}},
  },
  renderers = {
    jekyllDataEnd = {\name{} is \age{} years old.},
  }
}
\begin{document}
\markdownInput[expectJekyllData]{jane-doe.yml}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.23 Option extensions

L^aT_eX Example

Using a text editor, create a text document named strike-through.lua with the following content:

local strike_through = {
  api_version = 2,
  grammar_version = 4,
  finalize_grammar = function(reader)
    local nonspacechar = lpeg.P(1) - lpeg.S("\t ")
    local doubleslashes = lpeg.P("//")
    local function between(p, starter, ender)
      ender = lpeg.B(nonspacechar) * ender
      return (starter * #nonspacechar
             * lpeg.Ct(p * (p - ender)^0) * ender)
    end

    local read_strike_through = between(
      lpeg.V("Inline"), doubleslashes, doubleslashes
    ) / function(s) return {"\\st{", s, "}"} end

    reader.insert_pattern("Inline after LinkAndEmph", read_strike_through,
                          "StrikeThrough")
    reader.add_special_character("/")
  end
}

return strike_through

Using a text editor, create also a text document named document.tex with the following content:

\documentclass{article}
\usepackage{soul}
\usepackage[extension = strike-through.lua]{markdown}
\begin{document}
\begin{markdown}
This is //a lunar roving vehicle// strike-through text.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.24 Option fancyLists

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{minted}
\usepackage[fancyLists]{markdown}
\begin{document}
\begin{markdown}
a) first item
b) second item
c) third item
\end{markdown}
\end{document}

lualatex --shell-escape document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[fancyLists = yes]
\starttext
\startmarkdown
a) first item
b) second item
c) third item
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.25 Option fencedCode

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{minted}
\usepackage{markdown}
\begin{document}
\begin{markdown}
~~~ js
if (a > 3) {
    moveShip(5 * gravity, DOWN);
}
~~~~~~

  ``` html
  <pre>
    <code>
      // Some comments
      line 1 of code
      line 2 of code
      line 3 of code
    </code>
  </pre>
  ```
\end{markdown}
\end{document}

lualatex --shell-escape document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\definetyping [js]
\definetyping [html]
\setuptyping  [html] [option=XML]
\starttext
\startmarkdown
~~~ js
if (a > 3) {
    moveShip(5 * gravity, DOWN);
}
~~~~~~

  ``` html
  <pre>
    <code>
      // Some comments
      line 1 of code
      line 2 of code
      line 3 of code
    </code>
  </pre>
  ```
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.26 Option fencedCodeAttributes

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[fencedCode,
            fencedCodeAttributes]{markdown}
\usepackage{minted}
\markdownSetup{
  renderers = {
    fencedCodeAttributeContextBegin = {%
      \begingroup
      \markdownSetup{
        renderers = {
          attributeKeyValue = {%
            \setminted{{#1} = {#2}}%
          },
        },
      }%
    },
    fencedCodeAttributeContextEnd = {%
      \endgroup
    },
  },
}
\begin{document}
\begin{markdown}
~~~ js {linenos=true}
if (a > 3) {
    moveShip(5 * gravity, DOWN);
}
~~~~~~
\end{markdown}
\end{document}

lualatex --shell-escape document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.27 Option fencedDivs

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[fencedDivs]{markdown}
\begin{document}
\begin{markdown}{slice=special}
Here is a regular paragraph.

::::: {#special}
Here is a special paragraph.
:::::

And here is another regular paragraph.
\end{markdown}
\end{document}

lualatex --shell-escape document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.28 Option finalizeCache

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionFinalizeCache{true}
\markdownBegin
Hello *world*!
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!” A frozen cache will also be produced as we requested using the finalizeCache option.

\input markdown
\def\markdownOptionFrozenCache{true}
\markdownBegin
Hi *world*!
\markdownEnd
\bye

pdftex -no-shell-escape document.tex

A new PDF document named document.pdf should be produced and contain the same text “Hello world!” Since we used the contents of the frozen cache using the \markdownOptionFrozenCache option, we were able to typeset the document without accessing the shell or invoking Lua, but the change in the content of the markdown document from “Hello world!” to “Hi world!” was not reflected.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass[finalizecache]{article}
\usepackage{markdown}
\begin{document}
\begin{markdown}
Hello *world*!
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!” A frozen cache will also be produced as we requested using the finalizecache option.

\documentclass[frozencache]{article}
\usepackage{markdown}
\begin{document}
\begin{markdown}
Hi *world*!
\end{markdown}
\end{document}

pdflatex -no-shell-escape document.tex

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[finalizeCache = yes]
\starttext
\startmarkdown
Hello *world*!
\stopmarkdown
\stoptext

context --luatex document.tex

\usemodule[t][markdown]
\setupmarkdown[frozenCache = yes]
\starttext
\startmarkdown
Hi *world*!
\stopmarkdown
\stoptext

context --luatex document.tex

2.2.1.29 Option frozenCacheCounter

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local firstConvert = markdown.new({finalizeCache = true, frozenCacheCounter = 0})
  local firstInput = "Hello"
  local secondConvert = markdown.new({finalizeCache = true, frozenCacheCounter = 1})
  local secondInput = "*world*!"
  tex.sprint(firstConvert(firstInput) .. [[ ]] .. secondConvert(secondInput)) }
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!” A frozen cache with two entries will also be produced as we requested using the frozenCacheCounter option.

2.2.1.30 Option gfmAutoIdentifiers

2.2.1.31 Option hashEnumerators

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}

\begin{markdown}
#. Bird
#. McHale
#. Parish
\end{markdown}

\begin{markdown}[hashEnumerators]
#. Bird
#. McHale
#. Parish
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\starttext

\startmarkdown
#. Bird
#. McHale
#. Parish
\stopmarkdown

\setupmarkdown[hashEnumerators = yes]
\startmarkdown
#. Bird
#. McHale
#. Parish
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.32 Option headerAttributes

2.2.1.33 Option html

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local convert = markdown.new({html = false})
  local newline = [[^^J^^J]]
  local input =
    "<div>*There is no block tag support.*</div>"        .. newline ..
    "*There is no <inline tag="tag"></inline> support.*" .. newline ..
    "_There is no <!-- comment --> support._"            .. newline ..
    "_There is no <? HTML instruction ?> support._"
  tex.sprint(convert(input)) }
\par
\directlua{
  local markdown = require("markdown")
  local convert = markdown.new()
  local input =
    "<div>*There is block tag support.*</div>"        .. newline ..
    "*There is <inline tag="tag"></inline> support.*" .. newline ..
    "_There is <!-- comment --> support._"            .. newline ..
    "_There is <? HTML instruction ?> support._"
  tex.sprint(convert(input)) }
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\input optionfalse
\par
\input optiontrue
\endgroup
\bye

Using a text editor, create a text document named content.md with the following content:

<div>
*Is there block tag support?*
</div>
*Is there <inline tag="tag"></inline> support?*
_Is there <!-- comment --> support?_
_Is there <? HTML instruction ?> support?_

texlua ⟨CLI pathname⟩ html=false -- content.md optionfalse.tex
texlua ⟨CLI pathname⟩ -- content.md optiontrue.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts

\def\markdownOptionHtml{false}
\markdownBegin
<div>
*There is no block tag support.*
</div>
*There is no <inline tag="tag"></inline> support.*
_There is no <!-- comment --> support._
_There is no <? HTML instruction ?> support._
\markdownEnd

\def\markdownOptionHtml{true}
\markdownBegin
<div>
*There is block tag support.*
</div>
*There is <inline tag="tag"></inline> support.*
_There is <!-- comment --> support._
_There is <? HTML instruction ?> support._
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}

\begin{markdown}[html = false]
<div>
*There is no block tag support.*
</div>
*There is no <inline tag="tag"></inline> support.*
_There is no <!-- comment --> support._
_There is no <? HTML instruction ?> support._
\end{markdown}

\begin{markdown}
<div>
*There is block tag support.*
</div>
*There is <inline tag="tag"></inline> support.*
_There is <!-- comment --> support._
_There is <? HTML instruction ?> support._
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\starttext

\setupmarkdown[html = no]
\startmarkdown
<div>
*There is no block tag support.*
</div>
*There is no <inline tag="tag"></inline> support.*
_There is no <!-- comment --> support._
_There is no <? HTML instruction ?> support._
\stopmarkdown

\setupmarkdown[html = yes]
\startmarkdown
<div>
*There is block tag support.*
</div>
*There is <inline tag="tag"></inline> support.*
_There is <!-- comment --> support._
_There is <? HTML instruction ?> support._
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.34 Option hybrid

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local input, convert_safe, convert_unsafe, paragraph

  input = [[$\string\sqrt{-1}$ *equals* $i$.]]
  convert_safe = markdown.new()
  convert_unsafe = markdown.new({hybrid = true})
  paragraph = [[\par]]

  tex.sprint(
    convert_safe(input) .. paragraph ..
    convert_unsafe(input)
  )
}
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\input optionfalse
\par
\input optiontrue
\endgroup
\bye

Using a text editor, create a text document named content.md with the following content:

$\sqrt{-1}$ *equals* $i$.

texlua ⟨CLI pathname⟩ -- content.md optionfalse.tex
texlua ⟨CLI pathname⟩ hybrid=true -- content.md optiontrue.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts

\markdownBegin
$\sqrt{-1}$ *equals* $i$.
\markdownEnd

\def\markdownOptionHybrid{true}
\markdownBegin
$\sqrt{-1}$ *equals* $i$.
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}

\begin{markdown}
$\sqrt{-1}$ *equals* $i$.
\end{markdown}

\begin{markdown}[hybrid]
$\sqrt{-1}$ *equals* $i$.
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\starttext

\startmarkdown
$\sqrt{-1}$ *equals* $i$.
\stopmarkdown

\setupmarkdown[hybrid = yes]
\startmarkdown
$\sqrt{-1}$ *equals* $i$.
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.35 Option inlineCodeAttributes

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[inlineCodeAttributes]{markdown}
\usepackage{expl3}
\ExplSyntaxOn
\markdownSetup{
  renderers = {
    codeSpanAttributeContextBegin = {
      \group_begin:
      \color_group_begin:
      \markdownSetup{
        renderers = {
          attributeKeyValue = {
            \str_if_eq:nnT
              { ##1 }
              { color }
              {
                 \color_select:n { ##2 }
              }
          },
        },
      }
    },
    codeSpanAttributeContextEnd = {
      \color_group_end:
      \group_end:
    },
  },
}
\ExplSyntaxOff
\begin{document}
\begin{markdown}
Here is some `colored text`{color=red}.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.36 Option inlineNotes

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[inlineNotes]{markdown}
\begin{document}
\begin{markdown}
Here is an inline note.^[Inlines notes are easier to
write, since you don't have to pick an identifier and
move down to type the note.]
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[inlineNotes = yes]
\starttext
\startmarkdown
Here is an inline note.^[Inlines notes are easier to
write, since you don't have to pick an identifier and
move down to type the note.]
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.37 Option jekyllData

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionJekyllData{true}
\ExplSyntaxOn
\keys_define:nn
  { markdown/jekyllData }
  {
    name .code:n = { \gdef\name{#1} },
    age  .code:n = { \gdef\age{#1}  },
  }
\ExplSyntaxOff
\def\markdownRendererJekyllDataEnd{%
  \name{} is \age{} years old.}
\markdownBegin
---
name: Jane Doe
age:  99
---
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[jekyllData]{markdown}
\markdownSetup{
  jekyllDataRenderers = {
    name = {\gdef\name{#1}},
    code = {\gdef\age{#1}},
  },
  renderers = {
    jekyllDataEnd = {\name{} is \age{} years old.},
  }
}
\begin{document}

\begin{markdown}
---
name: Jane Doe
age:  99
---
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[jekyllData = yes]
\ExplSyntaxOn
\keys_define:nn
  { markdown/jekyllData }
  {
    name .code:n = { \gdef\name{#1} },
    age  .code:n = { \gdef\age{#1}  },
  }
\ExplSyntaxOff
\def\markdownRendererJekyllDataEnd{%
  \name{} is \age{} years old.}
\starttext

\startmarkdown
---
name: Jane Doe
age:  99
---
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.38 Option linkAttributes

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[linkAttributes]{markdown}
\usepackage{expl3, graphicx}
\ExplSyntaxOn
\markdownSetup{
  renderers = {
    imageAttributeContextBegin = {
      \group_begin:
      \markdownSetup{
        renderers = {
          attributeKeyValue = {
            \setkeys
              { Gin }
              { { ##1 } = { ##2 } }
          },
        },
      }
    },
    imageAttributeContextEnd = {
      \group_end:
    },
  },
}
\ExplSyntaxOff
\begin{document}
\begin{markdown}
Here is an example image:

 ![example image](example-image){width=5cm height=4cm}
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain an example image (from Martin Scharrer’s mwe package) displayed at size 5cm × 4cm.

2.2.1.39 Option lineBlocks

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionLineBlocks{true}
\markdownBegin
| I would spread the cloths under your feet:
| But I, being poor, have only my dreams;
| I have spread my dreams under your feet;
| Tread softly because you tread on my dreams.
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[lineBlocks]{markdown}
\begin{document}
\begin{markdown}
| I would spread the cloths under your feet:
| But I, being poor, have only my dreams;
| I have spread my dreams under your feet;
| Tread softly because you tread on my dreams.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[lineBlocks = yes]
\starttext
\startmarkdown
| I would spread the cloths under your feet:
| But I, being poor, have only my dreams;
| I have spread my dreams under your feet;
| Tread softly because you tread on my dreams.
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.40 Option mark

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[mark]{markdown}
\begin{document}
\begin{markdown}

This ==is highlighted text.==

\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.41 Option notes

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[notes]{markdown}
\begin{document}
\begin{markdown}
Here is a note reference,[^1] and another.[^longnote]

[^1]: Here is the note.

[^longnote]: Here's one with multiple blocks.

    Subsequent paragraphs are indented to show that they
belong to the previous note.

        { some.code }

    The whole paragraph can be indented, or just the
    first line.  In this way, multi-paragraph notes
    work like multi-paragraph list items.

This paragraph won't be part of the note, because it
isn't indented.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[notes = yes]
\starttext
\startmarkdown
Here is a note reference,[^1] and another.[^longnote]

[^1]: Here is the note.

[^longnote]: Here's one with multiple blocks.

    Subsequent paragraphs are indented to show that they
belong to the previous note.

        { some.code }

    The whole paragraph can be indented, or just the
    first line.  In this way, multi-paragraph notes
    work like multi-paragraph list items.

This paragraph won't be part of the note, because it
isn't indented.
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.42 Option pipeTables

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[pipeTables]{markdown}
\begin{document}
\begin{markdown}
| Right | Left | Default | Center |
|------:|:-----|---------|:------:|
|   12  |  12  |    12   |    12  |
|  123  |  123 |   123   |   123  |
|    1  |    1 |     1   |     1  |
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Right	Left	Default	Center
12	12	12	12
123	123	123	123
1	1	1	1

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[pipeTables = yes]
\starttext
\startmarkdown
| Right | Left | Default | Center |
|------:|:-----|---------|:------:|
|   12  |  12  |    12   |    12  |
|  123  |  123 |   123   |   123  |
|    1  |    1 |     1   |     1  |
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Right	Left	Default	Center
12	12	12	12
123	123	123	123
1	1	1	1

2.2.1.43 Option preserveTabs

2.2.1.44 Option rawAttribute

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[rawAttribute, fencedCode]{markdown}
\usepackage{expl3}
\begin{document}
\begin{markdown}
`$H_2 O$`{=tex} is a liquid.

``` {=html}
<p>Here is some HTML content that will be ignored.</p>
```
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.45 Option relativeReferences

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[headerAttributes, relativeReferences]{markdown}
\begin{document}
\begin{markdown}

I conclude in Section <#conclusion>.

Conclusion {#conclusion}
==========
In this paper, we have discovered that most
grandmas would rather eat dinner with their
grandchildren than get eaten. Begone, wolf!

\end{markdown}
\end{document}

lualatex document.tex
lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.46 Option shiftHeadings

Plain T_eX Example

Using a text editor, create a text document named example.md with the following content:

Using a text editor, create a text document named document.tex with the following content:

\input markdown

\font\normal=cmr10\normal
\font\big=cmr10 at 12pt
\def\markdownRendererHeadingTwo#1{{\big #1\par}}
\font\bigger=cmr10 scaled 1440
\def\markdownRendererHeadingOne#1{{\bigger #1\par}}

\def\markdownOptionShiftHeadings{-1}
\markdownInput{example.md}

\def\markdownOptionShiftHeadings{0}
\markdownInput{example.md}

\def\markdownOptionShiftHeadings{+1}
\markdownInput{example.md}

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{filecontents}[overwrite,nosearch,noheader]{example.md}
## A section
\end{filecontents}
\begin{document}
\markdownInput[shiftHeadings=-1]{example.md}
\markdownInput{example.md}
\markdownInput[shiftHeadings=+1]{example.md}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named example.md with the following content:

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\starttext

\inputmarkdown[shiftHeadings = -1]{example.md}
\inputmarkdown[shiftHeadings =  0]{example.md}
\inputmarkdown[shiftHeadings = +1]{example.md}

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.47 Option slice

Plain T_eX Example

Using a text editor, create a text document named hamlet.md with the following content:

# The Tragedy of Hamlet
Shakespeare's longest play.

## Act III {#act-3}
Hamlet kills Polonius.

## Act V   {#act-5}
Hamlet dies.

## Act I   {#act-1}
Hamlet talks to ghost.

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionHeaderAttributes{true}

\font\normal=cmr10\normal
\font\big=cmr10 at 12pt
\def\markdownRendererHeadingTwo#1{{\big #1\par}}
\font\bigger=cmr10 scaled 1440
\def\markdownRendererHeadingOne#1{{\bigger #1\par}}

\def\markdownOptionSlice{^ ^act-3}
\markdownInput{hamlet.md}

\def\markdownOptionSlice{act-1}
\markdownInput{hamlet.md}

\def\markdownOptionSlice{act-3 act-5}
\markdownInput{hamlet.md}

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[headerAttributes]{markdown}
\begin{filecontents}[overwrite,nosearch,noheader]{hamlet.md}
# The Tragedy of Hamlet
Shakespeare's longest play.

## Act III {#act-3}
Hamlet kills Polonius.

## Act V   {#act-5}
Hamlet dies.

## Act I   {#act-1}
Hamlet talks to ghost.
\end{filecontents}
\begin{document}
\markdownInput[slice=^ ^act-3]{hamlet.md}
\markdownInput[slice=act-1]{hamlet.md}
\markdownInput[slice=act-3 act-5]{hamlet.md}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named hamlet.md with the following content:

# The Tragedy of Hamlet
Shakespeare's longest play.

## Act III {#act-3}
Hamlet kills Polonius.

## Act V   {#act-5}
Hamlet dies.

## Act I   {#act-1}
Hamlet talks to ghost.

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[headerAttributes = yes]
\starttext

\inputmarkdown[slice = ^ ^act-3]{example.md}
\inputmarkdown[slice = act-1]{example.md}
\inputmarkdown[slice = act-3 act-5]{example.md}

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.48 Option smartEllipses

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\def\markdownRendererEllipsis{. . .}
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local convert = markdown.new()
  local input = "These are just three regular dots ..."
  tex.sprint(convert(input)) }
\par
\directlua{
  local markdown = require("markdown")
  local convert = markdown.new({smartEllipses = true})
  local input = "... and this is a victorian ellipsis."
  tex.sprint(convert(input)) }
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\def\markdownRendererEllipsis{. . .}
\begingroup
\catcode`\%=12
\catcode`\#=12
\input optionfalse
\par
\input optiontrue
\endgroup
\bye

Using a text editor, create a text document named content.md with the following content:

Are these just three regular dots, a victorian ellipsis, or ... ?

texlua ⟨CLI pathname⟩ -- content.md optionfalse.tex
texlua ⟨CLI pathname⟩ smartEllipses=true -- content.md optiontrue.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownRendererEllipsis{. . .}

\markdownBegin
These are just three regular dots ...
\markdownEnd

\def\markdownOptionSmartEllipses{true}
\markdownBegin
... and this is a victorian ellipsis.
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\markdownSetup{
  renderers = {
    ellipsis = {. . .}
  }
}
\begin{document}

\begin{markdown}
These are just three regular dots ...
\end{markdown}

\begin{markdown}[smartEllipses]
... and this is a victorian ellipsis.
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\def\markdownRendererEllipsis{. . .}
\starttext

\startmarkdown
These are just three regular dots ...
\stopmarkdown

\setupmarkdown[smartEllipses = yes]
\startmarkdown
... and this is a victorian ellipsis.
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.49 Option startNumber

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}

\begin{markdown}
The following list respects the numbers specified in the markup:

3. third item
4. fourth item
5. fifth item
\end{markdown}

\begin{markdown}[startNumber=false]
The following list does not respect the numbers specified in the
markup:

3. third item
4. fourth item
5. fifth item
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\starttext

\startmarkdown
The following list respects the numbers specified in the markup:

3. third item
4. fourth item
5. fifth item
\stopmarkdown

\setupmarkdown[startNumber = no]
\startmarkdown
The following list respects the numbers specified in the markup:

3. third item
4. fourth item
5. fifth item
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.50 Option strikeThrough

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionStrikeThrough{true}
\input soulutf8.sty
\def\markdownRendererStrikeThrough#1{\st{#1}}
\markdownBegin
This is ~~a lunar roving vehicle~~ strike-through text.
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[strikeThrough]{markdown}
\usepackage{soulutf8}
\markdownSetup{
  renderers = {
    strikeThrough = {\st{#1}},
  },
}
\begin{document}
\begin{markdown}
This is ~~a lunar roving vehicle~~ strike-through text.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[strikeThrough = yes]
\def\markdownRendererStrikeThrough#1{\overstrikes{#1}}
\starttext
\startmarkdown
This is ~~a lunar roving vehicle~~ strike-through text.
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.51 Option stripIndent

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionStripIndent{true}
\markdownBegin
    Hello *world*!
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!”

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[stripIndent]{markdown}
\begin{document}
    \begin{markdown}
        Hello *world*!
    \end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!”

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[stripIndent = yes]
\starttext
    \startmarkdown
        Hello *world*!
    \stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!”

2.2.1.52 Option subscripts

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[subscripts]{markdown}
\begin{document}
\begin{markdown}
H~2~O is a liquid.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[subscripts = yes]
\starttext
\startmarkdown
H~2~O is a liquid.
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.53 Option superscripts

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[superscripts]{markdown}
\begin{document}
\begin{markdown}
2^10^ is 1024.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[superscripts = yes]
\starttext
\startmarkdown
2^10^ is 1024.
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.54 Option tableAttributes

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[
  pipeTables,
  tableCaptions,
  tableAttributes,
  relativeReferences,
]{markdown}
\usepackage{expl3}
\ExplSyntaxOn
\markdownSetup{
  renderers = {
    tableAttributeContextBegin = {
      \group_begin:
      \markdownSetup{
        renderers = {
          attributeIdentifier = {
            \markdownSetup{
              renderers = {
                tableAttributeContextEnd = {
                  \label{##1}
                  \group_end:
                },
              },
            }
          },
        },
      }
    },
    tableAttributeContextEnd = {
      \group_end:
    },
  },
}
\ExplSyntaxOff
\begin{document}
\begin{markdown}
See Table <#example-table>.

| Right | Left | Default | Center |
|------:|:-----|---------|:------:|
|   12  |  12  |    12   |    12  |
|  123  |  123 |   123   |   123  |
|    1  |    1 |     1   |     1  |

  : Demonstration of pipe table syntax. {#example-table}
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Table 1. Demonstration of pipe table syntax.
Right	Left	Default	Center
12	12	12	12
123	123	123	123
1	1	1	1

2.2.1.55 Option tableCaptions

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[pipeTables, tableCaptions]{markdown}
\begin{document}
\begin{markdown}
| Right | Left | Default | Center |
|------:|:-----|---------|:------:|
|   12  |  12  |    12   |    12  |
|  123  |  123 |   123   |   123  |
|    1  |    1 |     1   |     1  |

: Demonstration of pipe table syntax.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Demonstration of pipe table syntax.
Right	Left	Default	Center
12	12	12	12
123	123	123	123
1	1	1	1

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown
  [
    pipeTables = yes,
    tableCaptions = yes,
  ]
\starttext
\startmarkdown
| Right | Left | Default | Center |
|------:|:-----|---------|:------:|
|   12  |  12  |    12   |    12  |
|  123  |  123 |   123   |   123  |
|    1  |    1 |     1   |     1  |

: Demonstration of pipe table syntax.
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Demonstration of pipe table syntax.
Right	Left	Default	Center
12	12	12	12
123	123	123	123
1	1	1	1

2.2.1.56 Option taskLists

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[taskLists]{markdown}
\markdownSetup{
  renderers = {
    untickedBox = No,
    halfTickedBox = Maybe,
    tickedBox = Yes,
  },
}
\begin{document}
\begin{markdown}
- [ ] you can't.
- [/] I can?
- [X] I can!
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[taskLists = yes]
\def\markdownRendererUntickedBox{No}
\def\markdownRendererHalftickedBox{Maybe}
\def\markdownRendererTickedBox{Yes}
\starttext
\startmarkdown
- [ ] you can't.
- [/] I can?
- [X] I can!
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.57 Option texComments

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionTexComments{true}
\markdownBegin
Hel%  this is a comment
   lo *world*!
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!”

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[texComments]{markdown}
\begin{document}
\begin{markdown}
Hel%  this is a comment
   lo *world*!
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!”

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[texComments = yes]
\starttext
\startmarkdown
Hel%  this is a comment
   lo *world*!
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the text “Hello world!”

2.2.1.58 Option texMathDollars

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local newline = [[^^J^^J]]
  local convert = markdown.new({texMathDollars = true})
  local input =
    [[$E=mc^2$]] .. newline .. newline ..
    [[$$\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx$$]]
  tex.sprint(convert(input)) }
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\input optionfalse
\par
\input optiontrue
\endgroup
\bye

Using a text editor, create a text document named content.md with the following content:

$E=mc^2$

$$\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx$$

texlua ⟨CLI pathname⟩ -- content.md optionfalse.tex
texlua ⟨CLI pathname⟩ texMathDollars=true -- content.md optiontrue.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown

\def\markdownOptionTexMathDollars{true}
\markdownBegin
$E=mc^2$

$$\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx$$
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[texMathDollars]{markdown}
\begin{document}

\begin{markdown}
$E=mc^2$

$$\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx$$
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[texMathDollars = yes]
\starttext

\startmarkdown
$E=mc^2$

$$\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx$$
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.59 Option texMathDoubleBackslash

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local newline = [[^^J^^J]]
  local convert = markdown.new({texMathDoubleBackslash = true})
  local input =
    [[\\(E=mc^2\\)]] .. newline .. newline ..
    [[\\[\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx\\]]]
  tex.sprint(convert(input)) }
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\input optionfalse
\par
\input optiontrue
\endgroup
\bye

Using a text editor, create a text document named content.md with the following content:

\\(E=mc^2\\)

\\[\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx\\]

texlua ⟨CLI pathname⟩ -- content.md optionfalse.tex
texlua ⟨CLI pathname⟩ texMathDoubleBackslash=true -- content.md optiontrue.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown

\def\markdownOptionTexMathDoubleBackslash{true}
\markdownBegin
\\(E=mc^2\\)

\\[\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx\\]
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[texMathDoubleBackslash]{markdown}
\begin{document}

\begin{markdown}
\\(E=mc^2\\)

\\[\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx\\]
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[texMathDoubleBackslash = yes]
\starttext

\startmarkdown
\\(E=mc^2\\)

\\[\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx\\]
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.60 Option texMathSingleBackslash

Lua Module Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\directlua{
  local markdown = require("markdown")
  local newline = [[^^J^^J]]
  local convert = markdown.new({texMathSingleBackslash = true})
  local input =
    [[\(E=mc^2\)]] .. newline .. newline ..
    [[\[\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx\]]]
  tex.sprint(convert(input)) }
\endgroup
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Lua CLI Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts
\begingroup
\catcode`\%=12
\catcode`\#=12
\input optionfalse
\par
\input optiontrue
\endgroup
\bye

Using a text editor, create a text document named content.md with the following content:

\(E=mc^2\)

\[\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx\]

texlua ⟨CLI pathname⟩ -- content.md optionfalse.tex
texlua ⟨CLI pathname⟩ texMathSingleBackslash=true -- content.md optiontrue.tex
luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown

\def\markdownOptionTexMathSingleBackslash{true}
\markdownBegin
\(E=mc^2\)

\[\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx\]
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[texMathSingleBackslash]{markdown}
\begin{document}

\begin{markdown}
\(E=mc^2\)

\[\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx\]
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[texMathSingleBackslash = yes]
\starttext

\startmarkdown
\(E=mc^2\)

\[\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx\]
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.61 Option tightLists

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begin{document}

\begin{markdown}
The following list is tight:

- first item
- second item
- third item

The following list is loose:

- first item
- second item that spans

  multiple paragraphs
- third item
\end{markdown}

\begin{markdown}[tightLists=false]
The following list is now also loose:

- first item
- second item
- third item
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.1.62 Option underscores

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionHybrid{true}

\markdownBegin
This is _emphasized text_ and this is a math subscript: $m\_n$.
\markdownEnd

\def\markdownOptionUnderscores{false}
\markdownBegin
This is *emphasized text* and this is a math subscript: $m_n$.
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[hybrid]{markdown}
\begin{document}

\begin{markdown}
This is _emphasized text_ and this is a math subscript: $m\_n$.
\end{markdown}

\begin{markdown}[underscores=false]
This is *emphasized text* and this is a math subscript: $m_n$.
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[hybrid = yes]
\starttext

\startmarkdown
This is _emphasized text_ and this is a math subscript: $m\_n$.
\stopmarkdown

\setupmarkdown[underscores = yes]
\startmarkdown
This is *emphasized text* and this is a math subscript: $m_n$.
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.2.2 Plain T_eX

Plain T_eX options control the communication between the T_eX interface and the markdown Lua module. They are supported by all higher-level interfaces of the Markdown package, i.e. the plain T_eX, L^aT_eX and ConT_eXt interfaces.

2.2.2.1 Setting Lua options from plain T_eX

As a rule of thumb, you can set all Lua options directly from plain T_eX. For example, to set the taskLists Lua option to true, you would include the following code in your plain T_eX document:

\def\markdownOptionTaskLists{true}

Alternatively, you can also set plain T_eX options using the \markdownSetup T_eX macro. For example, to set the taskLists Lua option to true, you would include the following code in your plain T_eX document:

\markdownSetup{taskLists = true}

2.2.2.2 Finalizing and Freezing the Cache

The \markdownOptionFrozenCache option uses the mapping previously created by the Lua interface finalizeCache option, and uses it to typeset the plain T_eX document without invoking Lua. As a result, the plain T_eX document becomes more portable, but further changes in the order and the content of markdown documents will not be reflected. It defaults to false.

The standard usage of the finalizeCache and frozenCache options is as follows:

2.2.2.3 File and Directory Names

The plain T_eX interface provides the following commands that you can use to specify the location of temporary files produced during the conversion from Markdown to T_eX:

The \markdownOptionCacheDir and \markdownOptionFrozenCacheFileName commands correspond to the cacheDir and frozenCacheFileName Lua options.

Using a text editor, create a folder named output-directory and a text document named document.tex with the following content:

\input lmfonts
\input markdown
\def\markdownOptionInputTempFileName{temporary-input.md}
\def\markdownOptionOutputDir{output-directory}
\def\markdownOptionCacheDir{output-directory/cache-directory}
\def\markdownOptionEagerCache{true}
\def\markdownOptionFinalizeCache{true}
\def\markdownOptionFrozenCacheFileName{output-directory/cache-directory/frozen-cache.tex}
\markdownBegin
Hello *world*!
\markdownEnd
\bye

luatex --output-directory output-directory document.tex

A text document named temporary-input.md should be produced in the folder named output-directory and contain the following text:

A folder named output-directory/cache-directory should also be produced and contain fragments of the converted markdown document. LuaTeX does not need other temporary files to perform the conversion from markdown to T_eX. To produce the remaining temporary files, invoke pdfTeX from the terminal:

pdftex --output-directory output-directory --shell-escape document.tex

Text document named temporary-output.md should be produced in the folder named output-directory. The document will contain the input markdown document converted to T_eX.

2.2.2.4 No default token renderer prototypes

The Markdown package provides default definitions for token renderer prototypes using the witiko/markdown/defaults theme. Although these default definitions provide a useful starting point for authors, they use extra resources, especially with higher-level T_eX formats such as L^aT_eX and ConT_eXt. Furthermore, the default definitions may change at any time, which may pose a problem for maintainers of Markdown themes and templates who may require a stable output.

The \markdownOptionPlain macro specifies whether higher-level T_eX formats should only use the plain T_eX default definitions or whether they should also use the format-specific default definitions. Whereas plain T_eX default definitions only provide definitions for simple elements such as emphasis, strong emphasis, and paragraph separators, format-specific default definitions add support for more complex elements such as lists, tables, and citations. On the flip side, plain T_eX default definitions load no extra resources and are rather stable, whereas format-specific default definitions load extra resources and are subject to a more rapid change.

\usepackage[plain]{markdown}

\def\markdownOptionPlain{true}
\usemodule[t][markdown]

The macro must be set before or during the loading of the package. Setting the macro after loading the package has no effect.

The \markdownOptionNoDefaults macro specifies whether we should prevent the loading of default definitions or not. This is useful in contexts, where we want to have total control over how all elements are rendered.

\usepackage[noDefaults]{markdown}

\def\markdownOptionNoDefaults{true}
\usemodule[t][markdown]

The macro must be set before or during the loading of the package. Setting the macro after loading the package has no effect.

2.2.2.5 Package Documentation

The \markdownOptionStripPercentSigns macro controls whether a percent sign (\%) at the beginning of a line will be discarded when reading Markdown input from a T_eX document. This enables the use of markdown when writing T_eX package documentation using the Doc L^aT_eX package by Frank Mittelbach. The recognized values of the macro are true (discard) and false (retain). It defaults to false.

Using a text editor, create a text document named document.dtx with the following content:

% \iffalse
\documentclass{ltxdoc}
\usepackage[stripPercentSigns]{markdown}
\begin{document}
\DocInput{document.dtx}
\end{document}
% \fi
%
% \begin{markdown}
% Hello *world*!
% \end{markdown}

lualatex document.dtx

A PDF document named document.pdf should be produced and contain the text “Hello world!”

2.2.3 Themes

User-defined themes for the Markdown package provide a domain-specific interpretation of Markdown tokens. Themes allow the authors to achieve a specific look and other high-level goals without low-level programming.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\markdownSetup{import=witiko/tilde}
\markdownBegin
Bartel~Leendert van~der~Waerden
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text, where the middot (·) denotes a non-breaking space:

2.2.4 Snippets

User-defined themes provide global control over high-level goals. However, it is often desirable to change only some local aspects of a document. Snippets provide syntactic sugar for defining and invoking various options locally.

Here is how we can use snippets to store options and invoke them later in L^aT_eX:

\markdownSetupSnippet{romanNumerals}{
  renderers = {
      olItemWithNumber = {%
          \item[\romannumeral#1\relax.]%
      },
  },
}
\begin{markdown}

The following ordered list will be preceded by arabic numerals:

1. wahid
2. aithnayn

\end{markdown}
\begin{markdown}[snippet=romanNumerals]

The following ordered list will be preceded by roman numerals:

3. tres
4. quattuor

\end{markdown}

If the romanNumerals snippet were defined in the jdoe/lists theme, we could import the jdoe/lists theme and use the qualified name jdoe/lists/romanNumerals to invoke the snippet:

\markdownSetup{import=jdoe/lists}
\begin{markdown}[snippet=jdoe/lists/romanNumerals]

The following ordered list will be preceded by roman numerals:

3. tres
4. quattuor

\end{markdown}

Alternatively, we can use the extended variant of the import L^aT_eX option that allows us to import the romanNumerals snippet to the current namespace for easier access:

\markdownSetup{
  import = {
    jdoe/lists = romanNumerals,
  },
}
\begin{markdown}[snippet=romanNumerals]

The following ordered list will be preceded by roman numerals:

3. tres
4. quattuor

\end{markdown}

Furthermore, we can also specify the name of the snippet in the current namespace, which can be different from the name of the snippet in the jdoe/lists theme. For example, we can make the snippet jdoe/lists/romanNumerals available under the name roman.

\markdownSetup{
  import = {
    jdoe/lists = romanNumerals as roman,
  },
}
\begin{markdown}[snippet=roman]

The following ordered list will be preceded by roman numerals:

3. tres
4. quattuor

\end{markdown}

Several themes and/or snippets can be loaded at once using the extended variant of the import L^aT_eX option:

\markdownSetup{
  import = {
    jdoe/longpackagename/lists = {
      arabic as arabic1,
      roman,
      alphabetic,
    },
    jdoe/anotherlongpackagename/lists = {
      arabic as arabic2,
    },
    jdoe/yetanotherlongpackagename,
  },
}

2.2.5 L^aT_eX

L^aT_eX options allow us to disable the redefinition of the default renderer prototypes from plain T_eX, load user-defined themes, and invoke user-defined set-up snippets.

2.2.5.1 Setting Lua and plain T_eX options from L^aT_eX

As a rule of thumb, we can set all Lua options directly from L^aT_eX. For example, to set the taskLists Lua option to true, we would include the following code in our L^aT_eX document:

\markdownSetup{
  taskLists = true,
}

We can also set all plain T_eX options directly from L^aT_eX. For example, to set the \markdownOptionInputTempFileName plain T_eX option to helper-script.lua, we would inclde the following code in our L^aT_eX document:

\markdownSetup{
  inputTempFileName = temporary-input.md,
}

2.2.6 Themes

In L^aT_eX, we expand on the concept of themes by allowing a theme to be a full-blown L^aT_eX package. Specifically, the key-values theme=⟨theme name⟩ and import=⟨theme name⟩ load a L^aT_eX package named markdowntheme⟨munged theme name⟩.sty if it exists and a T_eX document named markdowntheme\meta{munged theme name}.tex otherwise.

Having the Markdown package automatically load either the generic .tex theme file or the L^aT_eX-specific .sty theme file allows developers to have a single theme file, when the theme is small or the difference between T_eX formats is unimportant, and scale up to separate theme files native to different T_eX formats for large multi-format themes, where different code is needed for different T_eX formats. To enable code reuse, developers can load the .tex theme file from the .sty theme file using the \markdownLoadPlainTeXTheme macro.

For example, to load themes named witiko/beamer/MU and witiko/dot, you would use the following code in the preamble of your document:

\usepackage[
  import=witiko/beamer/MU,
  import=witiko/dot,
]{markdown}

Due to limitations of L^aT_eX, themes may not be loaded after the beginning of a L^aT_eX document.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[import=witiko/dot]{markdown}
\setkeys{Gin}{
  width=\columnwidth,
  height=0.65\paperheight,
  keepaspectratio}
\begin{document}
\begin{markdown}
``` dot Various formats of mathemathical formulae
digraph tree {
  margin = 0;
  rankdir = "LR";

  latex -> pmml;
  latex -> cmml;
  pmml -> slt;
  cmml -> opt;
  cmml -> prefix;
  cmml -> infix;
  pmml -> mterms [style=dashed];
  cmml -> mterms;

  latex [label = "LaTeX"];
  pmml [label = "Presentation MathML"];
  cmml [label = "Content MathML"];
  slt [label = "Symbol Layout Tree"];
  opt [label = "Operator Tree"];
  prefix [label = "Prefix"];
  infix [label = "Infix"];
  mterms [label = "M-Terms"];
}
```
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain a drawing of a directed graph similar to Figure 1 from the following conference article:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[import=witiko/graphicx/http]{markdown}
\begin{document}
\begin{markdown}
![img](https://github.com/witiko/markdown/raw/main/markdown.png
       "The banner of the Markdown package")
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following image:

2.2.7 Themes

In ConT_eXt, we expand on the concept of themes by allowing a theme to be a full-blown ConT_eXt module. Specifically, the key-values theme=⟨theme name⟩ and import=⟨theme name⟩ load a ConT_eXt module named t-markdowntheme⟨munged theme name⟩.tex if it exists and a T_eX document named markdowntheme\meta{munged theme name}.tex otherwise.

Having the Markdown package automatically load either the generic .tex theme file or the ConT_eXt-specific t-*.tex theme file allows developers to have a single theme file, when the theme is small or the difference between T_eX formats is unimportant, and scale up to separate theme files native to different T_eX formats for large multi-format themes, where different code is needed for different T_eX formats. To enable code reuse, developers can load the .tex theme file from the t-*.tex theme file using the \markdownLoadPlainTeXTheme macro.

\usemodule[t][markdown]
\setupmarkdown[import=witiko/tilde]

2.3 Markdown Tokens

A key feature of the Markdown package is the support for manipulating markdown tokens, such as headings, emphasized text, links, and lists, in T_eX. Instead of reducing T_eX to a PDF document producer, the Markdown package allows the user to specify how every markdown token should be processed and rendered.

2.3.1 Token Renderers

Token renderers are user-defined T_eX macros, which render markdown tokens. In this section, I will describe the individual token renderers.

2.3.1.1 Attribute Renderers

The following macros are only produced, when at least one of the following options for markdown attributes on different elements is enabled:

\markdownRendererAttributeIdentifier represents the ⟨identifier⟩ of a markdown element (id="⟨identifier⟩" in HTML and #⟨identifier⟩ in markdown attributes). The macro receives a single attribute that corresponds to the ⟨identifier⟩.

\markdownRendererAttributeClassName represents the ⟨class name⟩ of a markdown element (class="⟨class name⟩ …" in HTML and .⟨class name⟩ in markdown attributes). The macro receives a single attribute that corresponds to the ⟨class name⟩.

\markdownRendererAttributeKeyValue represents a HTML attribute in the form ⟨key⟩=⟨value⟩ that is neither an identifier nor a class name. The macro receives two attributes that correspond to the ⟨key⟩ and the ⟨value⟩, respectively.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[headerAttributes, underscores=false]{markdown}
\markdownSetup{
  renderers = {
    attributeIdentifier = {%
      \par
      \emph{(Identifier: #1)}
      \par
    },
    attributeClassName = {%
      \par
      \emph{(Class name: #1)}
      \par
    },
    attributeKeyValue = {%
      \par
      \emph{(Key: #1, Value: #2)}
      \par
    },
  },
}
\begin{document}
\begin{markdown}

# First top-level heading {jane=doe}

## A subheading {#identifier}

# Second top-level heading {.class_name}

\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.2 Block Quote Renderers

The \markdownRendererBlockQuoteBegin macro represents the beginning of a block quote. The macro receives no arguments.

The \markdownRendererBlockQuoteEnd macro represents the end of a block quote. The macro receives no arguments.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownRendererBlockQuoteBegin{%
  \begingroup
  \vskip\parindent
  \leftskip=2\parindent
  \parindent=0pt
}
\def\markdownRendererBlockQuoteEnd{%
  \par
  \vskip\parindent
  \endgroup
}
\markdownBegin
A quote from William Shakespeare's King Lear:

> This is the excellent foppery of the world that when we are
> sick in fortune---often the surfeit of our own behavior---we
> make guilty of our disasters the sun, the moon, and the
> stars [...]
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\markdownSetup{
  renderers = {
    blockQuoteBegin = {\begin{quote}},
    blockQuoteEnd = {\end{quote}},
  },
}
\begin{document}
\begin{markdown}
A quote from William Shakespeare's King Lear:

> This is the excellent foppery of the world that when we are
> sick in fortune---often the surfeit of our own behavior---we
> make guilty of our disasters the sun, the moon, and the
> stars [...]
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\def\markdownRendererBlockQuoteBegin{\startquotation}
\def\markdownRendererBlockQuoteEnd{\stopquotation}
\starttext
\startmarkdown
A quote from William Shakespeare's King Lear:

> This is the excellent foppery of the world that when we are
> sick in fortune---often the surfeit of our own behavior---we
> make guilty of our disasters the sun, the moon, and the
> stars [...]
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.3 Bracketed Spans Attribute Context Renderers

The following macros are only produced, when the bracketedSpans option is enabled.

The \markdownRendererBracketedSpanAttributeContextBegin and \markdownRendererBracketedSpanAttributeContextEnd macros represent the beginning and the end of a context in which the attributes of an inline bracketed span apply. The macros receive no arguments.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[bracketedSpans]{markdown}
\markdownSetup{
  renderers = {
    bracketedSpanAttributeContextBegin = {(},
    bracketedSpanAttributeContextEnd = {)},
  },
}
\begin{document}
\begin{markdown}

[foo [bar]{#identifier}]{key=value} [baz]{.class_name}

\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.4 Bullet List Renderers

The \markdownRendererUlBegin macro represents the beginning of a bulleted list that contains an item with several paragraphs of text (the list is not tight). The macro receives no arguments.

The \markdownRendererUlBeginTight macro represents the beginning of a bulleted list that contains no item with several paragraphs of text (the list is tight). This macro will only be produced, when the tightLists option is disabled. The macro receives no arguments.

The \markdownRendererUlItem macro represents an item in a bulleted list. The macro receives no arguments.

The \markdownRendererUlItemEnd macro represents the end of an item in a bulleted list. The macro receives no arguments.

The \markdownRendererUlEnd macro represents the end of a bulleted list that contains an item with several paragraphs of text (the list is not tight). The macro receives no arguments.

The \markdownRendererUlEndTight macro represents the end of a bulleted list that contains no item with several paragraphs of text (the list is tight). This macro will only be produced, when the tightLists option is disabled. The macro receives no arguments.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionTightLists{true}

\def\markdownRendererInterblockSeparator{}
\def\markdownRendererUlBeginTight{ (}
\def\markdownRendererUlItem{%
  \def\markdownRendererUlItem{%
    ,
    \def\markdownRendererUlItem{, and }%
  }%
}
\def\markdownRendererUlItemEnd{}
\def\markdownRendererUlEndTight{).}

\markdownBegin
This is a tight list

- the first item
- the second item
- the third item
\markdownEnd

\def\markdownRendererInterblockSeparator{%
  :\par
  \def\markdownRendererInterblockSeparator{\par}%
}
\def\markdownRendererUlBegin{}
\def\markdownRendererUlItem{--\kern 0.5em}
\def\markdownRendererUlItemEnd{.\par}
\def\markdownRendererUlEnd{}

\markdownBegin
This is a loose list

- This is the first item

- This is the second item

- This is the third item
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[tightLists]{markdown}
\begin{document}

\begin{markdown}[
  renderers = {
    interblockSeparator = {},
    ulBeginTight = { (},
    ulItem = {%
      \def\markdownRendererUlItem{%
        ,
        \def\markdownRendererUlItem{, and }%
      }%
    },
    ulItemEnd = {},
    ulEndTight = {).},
  },
]
This is a tight list

- the first item
- the second item
- the third item
\end{markdown}

\begin{markdown}[
  renderers = {
    interblockSeparator = {%
      :\par
      \def\markdownRendererInterblockSeparator{\par}%
    },
    ulBeginTight = {\begin{itemize}},
    ulItem = {\item},
    ulItemEnd = {.},
    ulEnd = {\end{itemize}},
  },
]
This is a loose list

- This is the first item

- This is the second item

- This is the third item
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[tightLists = yes]
\starttext

\def\markdownRendererInterblockSeparator{}
\def\markdownRendererUlBeginTight{ (}
\def\markdownRendererUlItem{%
  \def\markdownRendererUlItem{%
    ,
    \def\markdownRendererUlItem{, and }%
  }%
}
\def\markdownRendererUlItemEnd{}
\def\markdownRendererUlEndTight{).}

\startmarkdown
This is a tight list

- the first item
- the second item
- the third item
\stopmarkdown

\def\markdownRendererInterblockSeparator{%
  :\par
  \def\markdownRendererInterblockSeparator{\par}%
}
\def\markdownRendererUlBegin{\startitemize}
\def\markdownRendererUlItem{\item}
\def\markdownRendererUlItemEnd{.}
\def\markdownRendererUlEnd{\stopitemize}

\startmarkdown
This is a loose list

- This is the first item

- This is the second item

- This is the third item
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.5 Citation Renderers

The \markdownRendererCite macro represents a string of one or more parenthetical citations. This macro will only be produced, when the citations option is enabled. The macro receives the parameter {⟨number of citations⟩} followed by ⟨suppress author⟩ {⟨prenote⟩}{⟨postnote⟩}{⟨name⟩} repeated ⟨number of citations⟩ times. The ⟨suppress author⟩ parameter is either the token -, when the author’s name is to be suppressed, or + otherwise.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[citations]{markdown}
\newcount\citationsCounter
\newcount\citationsTotal
\makeatletter
\def\citations#1#2#3#4{%
  a parenthesized citation \emph{#4}
  \advance\citationsCounter by 1\relax
  \ifx\relax#2\relax
    \ifx\relax#3\relax\else
      with a postfix \emph{#3}%
    \fi
  \else
    with a prefix \emph{#2}%
    \ifx\relax#3\relax\else
      \ and a postfix \emph{#3}%
    \fi
  \fi
  \ifnum\citationsCounter>\citationsTotal\relax
    .%
    \expandafter\@gobble
  \else
    , and
  \fi\citations}
\makeatother
\markdownSetup{
  renderers = {
    cite = {%
      \citationsCounter=1%
      \citationsTotal=#1%
      This is
      \expandafter\citations
    },
  },
}
\begin{document}
\begin{markdown}
[see @abrahams90, pp. 12; @eijkhout91, pp. 34]
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

The \markdownRendererTextCite macro represents a string of one or more text citations. This macro will only be produced, when the citations option is enabled. The macro receives parameters in the same format as the \markdownRendererCite macro.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[citations]{markdown}
\newcount\citationsCounter
\newcount\citationsTotal
\makeatletter
\def\citations#1#2#3#4{%
  a text citation \emph{#4}
  \advance\citationsCounter by 1\relax
  \ifx\relax#2\relax
    \ifx\relax#3\relax\else
      with a postfix \emph{#3}%
    \fi
  \else
    with a prefix \emph{#2}%
    \ifx\relax#3\relax\else
      \ and a postfix \emph{#3}%
    \fi
  \fi
  \ifnum\citationsCounter>\citationsTotal\relax
    .%
    \expandafter\@gobble
  \else
    , and
  \fi\citations}
\makeatother
\markdownSetup{
  renderers = {
    textCite = {%
      \citationsCounter=1%
      \citationsTotal=#1%
      This is
      \expandafter\citations
    },
  },
}
\begin{document}
\begin{markdown}
@abrahams90 [pp. 12; also @eijkhout91]
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.6 Code Block Renderers

The \markdownRendererInputVerbatim macro represents a code block. The macro receives a single argument that corresponds to the filename of a file contaning the code block contents.

The \markdownRendererInputFencedCode macro represents a fenced code block. This macro will only be produced, when the fencedCode option is enabled. The macro receives three arguments that correspond to the filename of a file contaning the code block contents, the fully escaped code fence infostring that can be directly typeset, and the raw code fence infostring that can be used outside typesetting.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{verbatim}
\usepackage[hyphens]{url}
\usepackage[fencedCode]{markdown}
\markdownSetup{
  renderers = {
    interblockSeparator = {
      \def\markdownRendererInterblockSeparator{%
        \par
        \def\markdownRendererInterblockSeparator{%
          \def\markdownRendererInterblockSeparator{%
            \par
          }%
        }%
      }%
    },
    inputVerbatim = {
      is contained in file \url{#1}:%
      \verbatiminput{#1}%
    },
    inputFencedCode = {
      in #2 \markdownRendererInputVerbatim{#1}%
    },
  },
}
\begin{document}
\begin{markdown}
The following code

    def foo(bar):
      if len(bar) <= 1:
        return bar[0]
      elif len(bar) == 2:
        return sorted(bar)
      else:
        baz = len(bar) // 2
        return foo(bar[baz:], bar[:baz])

The following code

~~~ Python
>>> foo([4, 2, 1, 3])
[1, 2, 3, 4]
~~~~~~~~~~
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text except for the filename, which may differ:

2.3.1.7 Code Span Renderer

The \markdownRendererCodeSpan macro represents inline code span in the input text. It receives a single argument that corresponds to the inline code span.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\input lmfonts

\def\markdownRendererCodeSpan#1{#1}

\markdownBegin
`$\sqrt{-1}$ *equals* $i$`

$\sqrt{-1}$ *equals* $i$
\markdownEnd

\def\markdownOptionHybrid{true}
\markdownBegin
$\sqrt{-1}$ *equals* $i$
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[smartEllipses]{markdown}
\markdownSetup{
  renderers = {
    codeSpan = {#1},
  },
}
\begin{document}

\begin{markdown}
`$\sqrt{-1}$ *equals* $i$`

$\sqrt{-1}$ *equals* $i$
\end{markdown}

\begin{markdown}[hybrid]
$\sqrt{-1}$ *equals* $i$
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\def\markdownRendererCodeSpan#1{#1}
\starttext

\startmarkdown
`$\sqrt{-1}$ *equals* $i$`

$\sqrt{-1}$ *equals* $i$
\stopmarkdown

\setupmarkdown[hybrid = yes]
\startmarkdown
$\sqrt{-1}$ *equals* $i$
\stopmarkdown

\bye

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.8 Code Span Attribute Context Renderers

The following macros are only produced, when the inlineCodeAttributes option is enabled.

The \markdownRendererCodeSpanAttributeContextBegin and \markdownRendererCodeSpanAttributeContextEnd macros represent the beginning and the end of a context in which the attributes of an inline code span apply. The macros receive no arguments.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[inlineCodeAttributes]{markdown}
\markdownSetup{
  renderers = {
    codeSpanAttributeContextBegin = {(},
    codeSpan = {#1},
    codeSpanAttributeContextEnd = {)},
  },
}
\begin{document}
\begin{markdown}

foo `bar`{key=value} baz

\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.9 Content Block Renderers

The \markdownRendererContentBlock macro represents an iA Writer content block. It receives four arguments: the local file or online image filename extension cast to the lower case, the fully escaped uri that can be directly typeset, the raw uri that can be used outside typesetting, and the title of the content block.

The \markdownRendererContentBlockOnlineImage macro represents an iA Writer online image content block. The macro receives the same arguments as \markdownRendererContentBlock.

The \markdownRendererContentBlockCode macro represents an iA Writer content block that was recognized as a file in a known programming language by its filename extension s. If any markdown-languages.json file found by kpathsea⁷ contains a record (k,v), then a non-online-image content block with the filename extension s, s:lower() = k is considered to be in a known programming language v. The macro receives five arguments: the local file name extension s cast to the lower case, the language v, the fully escaped uri that can be directly typeset, the raw uri that can be used outside typesetting, and the title of the content block.

Note that you will need to place place a markdown-languages.json file inside your working directory or inside your local T_eX directory structure. In this file, you will define a mapping between filename extensions and the language names recognized by your favorite syntax highlighter; there may exist other creative uses beside syntax highlighting. The Languages.json file provided by Anton Sotkov is a good starting point.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionContentBlocks{true}
\def\markdownRendererContentBlock#1#2#3#4{%
  This is {\tt #2}, #4.
}
\def\markdownRendererContentBlockOnlineImage#1#2#3#4{%
  This is the image {\tt #2}, #4.
}
\def\markdownRendererContentBlockCode#1#2#3#4#5{%
  This is the #2 (\uppercase{#1}) document {\tt #3}, #5.
}
\markdownBegin
/document.tex (the document that we are currently typesetting)
/markdown-languages.json (the mapping between filename extensions
                          and programming language names)
https://tug.org/tugboat/noword.jpg (the logotype of TUGboat)
\markdownEnd
\bye

Create also a text document named markdown-languages.json with the following content:

{
  "json": "JavaScript Object Notation",
}

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\begin{filecontents}[overwrite,nosearch,noheader]{markdown-languages.json}
{
  "json": "JavaScript Object Notation",
}
\end{filecontents}
\usepackage[contentBlocks]{markdown}
\markdownSetup{
  renderers = {
    contentBlock = {This is \texttt{#2}, #4.},
    contentBlockOnlineImage = {This is the image \texttt{#2}, #4.},
    contentBlockCode = {%
      This is the #2 (\MakeUppercase{#1}) document \texttt{#3}, #5.
    },
  },
}
\begin{document}
\begin{markdown}
/document.tex (the document that we are currently typesetting)
/markdown-languages.json (the mapping between filename extensions
                          and programming language names)
https://tug.org/tugboat/noword.jpg (the logotype of TUGboat)
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[contentBlocks = yes]
\def\markdownRendererContentBlock#1#2#3#4{%
  This is {\tt #2}, #4.
}
\def\markdownRendererContentBlockOnlineImage#1#2#3#4{%
  This is the image {\tt #2}, #4.
}
\def\markdownRendererContentBlockCode#1#2#3#4#5{%
  This is the #2 (\uppercase{#1}) document {\tt #3}, #5.
}
\starttext
\startmarkdown
/document.tex (the document that we are currently typesetting)
/markdown-languages.json (the mapping between filename extensions
                          and programming language names)
https://tug.org/tugboat/noword.jpg (the logotype of TUGboat)
\stopmarkdown
\stoptext

Create also a text document named markdown-languages.json with the following content:

{
  "json": "JavaScript Object Notation",
}

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.10 Definition List Renderers

The following macros are only produced, when the definitionLists option is enabled.

The \markdownRendererDlBegin macro represents the beginning of a definition list that contains an item with several paragraphs of text (the list is not tight). The macro receives no arguments.

The \markdownRendererDlBeginTight macro represents the beginning of a definition list that contains no item with several paragraphs of text (the list is tight). This macro will only be produced, when the tightLists option is disabled. The macro receives no arguments.

The \markdownRendererDlItem macro represents a term in a definition list. The macro receives a single argument that corresponds to the term being defined.

The \markdownRendererDlItemEnd macro represents the end of a list of definitions for a single term.

The \markdownRendererDlDefinitionBegin macro represents the beginning of a definition in a definition list. There can be several definitions for a single term.

The \markdownRendererDlDefinitionEnd macro represents the end of a definition in a definition list. There can be several definitions for a single term.

The \markdownRendererDlEnd macro represents the end of a definition list that contains an item with several paragraphs of text (the list is not tight). The macro receives no arguments.

The \markdownRendererDlEndTight macro represents the end of a definition list that contains no item with several paragraphs of text (the list is tight). This macro will only be produced, when the tightLists option is disabled. The macro receives no arguments.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionDefinitionLists{true}
\def\markdownOptionTightLists{true}

\def\markdownRendererInterblockSeparator{%
  :%
  \def\markdownRendererInterblockSeparator{\par}%
}
\def\markdownRendererDlBeginTight{%
  \begingroup
  \parindent=0pt
}
\def\markdownRendererDlItem#1{%
  \par{\bf#1}%
  \def\markdownRendererDlDefinitionEnd{%
    ,
    \def\markdownRendererDlDefinitionEnd{%
      , and
      \def\markdownRendererDlDefinitionEnd{.}%
    }%
  }%
}
\def\markdownRendererDlItemEnd{}
\def\markdownRendererDlDefinitionBegin{\par--\kern 0.5em}
\def\markdownRendererDlEndTight{\endgroup}

\markdownBegin
This is a tight definition list

Coffee
:   black hot drink
:   prepared from roasted coffee beans
:   one of the most traded agricultural commodities in the world

Milk
:   white cold drink
:   nutrient-rich
:   produced on an industrial scale
\markdownEnd

\def\markdownRendererInterblockSeparator{%
  \def\markdownRendererInterblockSeparator{\par}%
}
\def\markdownRendererDlBegin{}
\def\markdownRendererDlItem#1{%
  . #1 is a
  \def\markdownRendererDlDefinitionBegin{%
    \def\markdownRendererDlDefinitionBegin{%
      ,
      \def\markdownRendererDlDefinitionBegin{, and }%
    }%
  }%
}
\def\markdownRendererDlItemEnd{}
\def\markdownRendererDlDefinitionEnd{}
\def\markdownRendererDlEnd{.}

\markdownBegin
This is a loose definition list

Coffee

:   black hot drink

:   prepared from roasted coffee beans

:   one of the most traded agricultural commodities in the world

Milk

:   white cold drink

:   nutrient-rich

:   produced on an industrial scale
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[definitionLists, tightLists]{markdown}
\begin{document}

\begin{markdown}[
  renderers = {
    interblockSeparator = {%
      :%
      \def\markdownRendererInterblockSeparator{\par}%
    },
    dlBeginTight = {\begin{description}},
    dlItem = {%
      \item[#1]
      \begin{itemize}
      \def\markdownRendererDlDefinitionEnd{%
        ,
        \def\markdownRendererDlDefinitionEnd{%
          , and
          \def\markdownRendererDlDefinitionEnd{.}%
        }%
      }%
    },
    dlItemEnd = {\end{itemize}},
    dlDefinitionBegin = \item,
    dlEndTight = {\end{description}},
  },
]
This is a tight definition list

Coffee
:   black hot drink
:   prepared from roasted coffee beans
:   one of the most traded agricultural commodities in the world

Milk
:   white cold drink
:   nutrient-rich
:   produced on an industrial scale
\end{markdown}

\begin{markdown}[
  renderers = {
    interblockSeparator = {%
      \def\markdownRendererInterblockSeparator{\par}%
    },
    dlBegin = {},
    dlItem = {%
      . #1 is a
      \def\markdownRendererDlDefinitionBegin{%
        \def\markdownRendererDlDefinitionBegin{%
          ,
          \def\markdownRendererDlDefinitionBegin{, and }%
        }%
      }%
    },
    dlItemEnd = {},
    dlDefinitionEnd = {},
    dlEnd = {.},
  },
]
This is a loose definition list

Coffee

:   black hot drink

:   prepared from roasted coffee beans

:   one of the most traded agricultural commodities in the world

Milk

:   white cold drink

:   nutrient-rich

:   produced on an industrial scale
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown
  [
    definitionLists = yes,
    tightLists = yes,
  ]
\starttext

\def\markdownRendererInterblockSeparator{%
  :%
  \def\markdownRendererInterblockSeparator{\par}%
}
\def\markdownRendererDlBeginTight{}
\def\markdownRendererDlItem#1{%
  \par{\bf#1}%
  \startitemize
  \def\markdownRendererDlDefinitionEnd{%
    ,
    \def\markdownRendererDlDefinitionEnd{%
      , and
      \def\markdownRendererDlDefinitionEnd{.}%
    }%
  }%
}
\def\markdownRendererDlItemEnd{\stopitemize}
\def\markdownRendererDlDefinitionBegin{\item}
\def\markdownRendererDlEndTight{}

\startmarkdown
This is a tight definition list

Coffee
:   black hot drink
:   prepared from roasted coffee beans
:   one of the most traded agricultural commodities in the world

Milk
:   white cold drink
:   nutrient-rich
:   produced on an industrial scale
\stopmarkdown

\def\markdownRendererInterblockSeparator{%
  \def\markdownRendererInterblockSeparator{\par}%
}
\def\markdownRendererDlBegin{}
\def\markdownRendererDlItem#1{%
  . #1 is a
  \def\markdownRendererDlDefinitionBegin{%
    \def\markdownRendererDlDefinitionBegin{%
      ,
      \def\markdownRendererDlDefinitionBegin{, and }%
    }%
  }%
}
\def\markdownRendererDlItemEnd{}
\def\markdownRendererDlDefinitionEnd{}
\def\markdownRendererDlEnd{.}

\startmarkdown
This is a loose definition list

Coffee

:   black hot drink

:   prepared from roasted coffee beans

:   one of the most traded agricultural commodities in the world

Milk

:   white cold drink

:   nutrient-rich

:   produced on an industrial scale
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.11 Ellipsis Renderer

The \markdownRendererEllipsis macro replaces any occurance of ASCII ellipses in the input text. This macro will only be produced, when the smartEllipses option is enabled. The macro receives no arguments.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionSmartEllipses{true}
\def\markdownRendererEllipsis{{\it SHAZAM}!}
\markdownBegin
The secret word is ...
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[smartEllipses]{markdown}
\markdownSetup{
  renderers = {
    ellipsis = \emph{SHAZAM}!,
  },
}
\begin{document}
\begin{markdown}
The secret word is ...
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[smartEllipses = yes]
\def\markdownRendererEllipsis{\emph{SHAZAM}!}
\starttext
\startmarkdown
The secret word is ...
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.12 Emphasis Renderers

The \markdownRendererEmphasis macro represents an emphasized span of text. The macro receives a single argument that corresponds to the emphasized span of text.

The \markdownRendererStrongEmphasis macro represents a strongly emphasized span of text. The macro receives a single argument that corresponds to the emphasized span of text.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownRendererEmphasis#1{{\it#1}}
\def\markdownRendererStrongEmphasis#1{{\bf#1}}
\markdownBegin
This is *emphasis*.

This is **strong emphasis**.
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\markdownSetup{
  renderers = {
    emphasis = {\emph{#1}},
    strongEmphasis = {\textbf{#1}},
  },
}
\begin{document}
\begin{markdown}
This is *emphasis*.

This is **strong emphasis**.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\def\markdownRendererEmphasis#1{\emph{#1}}
\def\markdownRendererStrongEmphasis#1{\bold{#1}}
\starttext
\startmarkdown
This is *emphasis*.

This is **strong emphasis**.
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.13 Fenced Code Attribute Context Renderers

The following macros are only produced, when the fencedCode option is enabled.

The \markdownRendererFencedCodeAttributeContextBegin and \markdownRendererFencedCodeAttributeContextEnd macros represent the beginning and the end of a context in which the attributes of a fenced code apply. The macros receive no arguments.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[fencedCode,
            fencedCodeAttributes]{markdown}
\usepackage{minted}
\markdownSetup{
  renderers = {
    fencedCodeAttributeContextBegin = {%
      \begingroup
      \markdownSetup{
        renderers = {
          attributeKeyValue = {%
            \setminted{{#1} = {#2}}%
          },
        },
      }%
    },
    fencedCodeAttributeContextEnd = {%
      \endgroup
    },
  },
}
\begin{document}
\begin{markdown}
~~~ js {linenos=true}
if (a > 3) {
    moveShip(5 * gravity, DOWN);
}
~~~~~~
\end{markdown}
\end{document}

lualatex --shell-escape document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.14 Fenced Div Attribute Context Renderers

The following macros are only produced, when the fencedDiv option is enabled.

The \markdownRendererFencedDivAttributeContextBegin and \markdownRendererFencedDivAttributeContextEnd macros represent the beginning and the end of a context in which the attributes of a div apply. The macros receive no arguments.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[fencedDivs]{markdown}
\markdownSetup{
  renderers = {
    fencedDivAttributeContextBegin = {%
      \par
      \emph{(The beginning of a fenced div attribute context)}
      \par
    },
    fencedDivAttributeContextEnd = {%
      \par
      \emph{(The end of a fenced div attribute context)}
      \par
    },
  },
}
\begin{document}
\begin{markdown}

::: {key=value}

foo

:::: {#identifier}

bar

::::

:::

::: {.class_name}

baz

:::

\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.15 Header Attribute Context Renderers

The following macros are only produced, when the autoIdentifiers, gfmAutoIdentifiers, or headerAttributes options are enabled.

The \markdownRendererHeaderAttributeContextBegin and \markdownRendererHeaderAttributeContextEnd macros represent the beginning and the end of a context in which the attributes of a heading apply. The macros receive no arguments.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[headerAttributes]{markdown}
\markdownSetup{
  renderers = {
    headerAttributeContextBegin = {%
      \par
      \emph{(The beginning of a header attribute context)}
      \par
    },
    headerAttributeContextEnd = {%
      \par
      \emph{(The end of a header attribute context)}
      \par
    },
  },
}
\begin{document}
\begin{markdown}

# First top-level heading

## A subheading {#identifier}

# Second top-level heading {.class_name}

\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.16 Heading Renderers

The \markdownRendererHeadingOne macro represents a first level heading. The macro receives a single argument that corresponds to the heading text.

The \markdownRendererHeadingTwo macro represents a second level heading. The macro receives a single argument that corresponds to the heading text.

The \markdownRendererHeadingThree macro represents a third level heading. The macro receives a single argument that corresponds to the heading text.

The \markdownRendererHeadingFour macro represents a fourth level heading. The macro receives a single argument that corresponds to the heading text.

The \markdownRendererHeadingFive macro represents a fifth level heading. The macro receives a single argument that corresponds to the heading text.

The \markdownRendererHeadingSix macro represents a sixth level heading. The macro receives a single argument that corresponds to the heading text.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownRendererInterblockSeparator{}
\def\markdownRendererHeadingOne{1}
\def\markdownRendererHeadingTwo{2}
\def\markdownRendererHeadingThree{3}
\def\markdownRendererHeadingFour{4}
\def\markdownRendererHeadingFive{5}
\def\markdownRendererHeadingSix{6}
\markdownBegin
######
#####
#####
###
######
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\markdownSetup{
  renderers = {
    interblockSeparator = {},
    headingOne = 1,
    headingTwo = 2,
    headingThree = 3,
    headingFour = 4,
    headingFive = 5,
    headingSix = 6,
  },
}
\begin{document}
\begin{markdown}
######
#####
#####
###
######
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\def\markdownRendererInterblockSeparator{}
\def\markdownRendererHeadingOne{1}
\def\markdownRendererHeadingTwo{2}
\def\markdownRendererHeadingThree{3}
\def\markdownRendererHeadingFour{4}
\def\markdownRendererHeadingFive{5}
\def\markdownRendererHeadingSix{6}
\starttext
\startmarkdown
######
#####
#####
###
######
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.17 Inline HTML Comment Renderer

The \markdownRendererInlineHtmlComment macro represents the contents of an inline HTML comment. This macro will only be produced, when the html option is enabled. The macro receives a single argument that corresponds to the contents of the HTML comment.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[html]{markdown}
\usepackage{marginnote}
\markdownSetup{
  renderers = {
    inlineHtmlComment = {\marginnote{#1}},
  },
}
\begin{document}
\begin{markdown}
A useful use of inline HTML comments are side notes.
<!-- Side notes are displayed in the horizontal margins next to the relevant
passages, which makes them *easier for the reader to find* than notes. -->
\end{markdown}
\end{document}

lualatex document.tex
lualatex document.tex

A PDF document named document.pdf should be produced and contain the following body text:

2.3.1.18 HTML Tag and Element Renderers

The \markdownRendererInlineHtmlTag macro represents an opening, closing, or empty inline HTML tag. This macro will only be produced, when the html option is enabled. The macro receives a single argument that corresponds to the contents of the HTML tag.

The \markdownRendererInputBlockHtmlElement macro represents a block HTML element. This macro will only be produced, when the html option is enabled. The macro receives a single argument that filename of a file containing the contents of the HTML element.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[html]{markdown}
\usepackage{marginnote}
\usepackage{verbatim}
\markdownSetup{
  renderers = {
    inlineHtmlTag = {\textbf{#1}},
    inputBlockHtmlElement = {\verbatiminput{#1}},
  },
}
\begin{document}
\begin{markdown}
<b>_Hello,_ world!</b><br/>

<div>_Hello,_ world!</div>
\end{markdown}
\end{document}

lualatex document.tex
lualatex document.tex

A PDF document named document.pdf should be produced and contain the following body text:

2.3.1.19 Image Renderer

The \markdownRendererImage macro represents an image. It receives four arguments: the label, the fully escaped uri that can be directly typeset, the raw uri that can be used outside typesetting, and the title of the link.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\begingroup
\catcode`\@=11
\catcode`\%=12
\catcode`\^^A=14
\global\def\markdownRendererImage#1#2#3#4{^^A
  \immediate\write18{^^A

    if printf '%s' "#3" | grep -q ^http; then
      OUTPUT="$(printf '%s' "#3" | md5sum | cut -d' ' -f1).^^A
              $(printf '%s' "#3" | sed 's/.*[.]//')";
      if ! [ -e "$OUTPUT" ]; then
        wget -O "$OUTPUT" '#3' || rm "$OUTPUT";
        convert "$OUTPUT" png:"$OUTPUT";
      fi;
      printf '%s%%' "$OUTPUT" > \jobname.fetched;
    else
      printf '%s%%' "#3"      > \jobname.fetched;
    fi^^A

  }^^A
  {^^A
    \everyeof={\noexpand}^^A
    \edef\filename{\@@input"\jobname.fetched" }^^A
    \includegraphics[width=\textwidth]{\filename}^^A
  }^^A
}
\endgroup
\begin{document}
\begin{markdown}
![TUGboat](https://tug.org/tugboat/noword.jpg)
\end{markdown}
\end{document}

lualatex --shell-escape document.tex

A PDF document named document.pdf should be produced and contain the following content. This assumes that you use a Unix-like operating system with Bourne or Bourne again shell as the default shell of the current user. It also assumes that the md5sum, wget, and convert binaries are installed and that the T_eX engine has shell access.

2.3.1.20 Image Attribute Context Renderers

The following macros are only produced, when the linkAttributes option is enabled.

The \markdownRendererImageAttributeContextBegin and \markdownRendererImageAttributeContextEnd macros represent the beginning and the end of a context in which the attributes of an image apply. The macros receive no arguments.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[linkAttributes]{markdown}
\markdownSetup{
  renderers = {
    imageAttributeContextBegin = {(},
    image = {#1},
    imageAttributeContextEnd = {)},
  },
}
\begin{document}
\begin{markdown}

foo ![bar](#bar){key=value} baz

\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.21 Interblock Separator Renderers

The \markdownRendererInterblockSeparator macro represents an interblock separator between two markdown block elements. The macro receives no arguments.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownRendererInterblockSeparator{%
  \par
  {\it(The end of a block)}%
  \par
}
\markdownBegin
- Hello *world*!

_Foo_ bar!
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\markdownSetup{
  renderers = {
    interblockSeparator = {%
      \par
      \emph{(The end of a block)}%
      \par
    },
  },
}
\begin{document}
\begin{markdown}
- Hello *world*!

_Foo_ bar!
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\def\markdownRendererInterblockSeparator{%
  \par
  \emph{(The end of a block)}%
  \par
}
\starttext
\startmarkdown
- Hello *world*!

_Foo_ bar!
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Users can use more than one blank line to delimit two block to indicate the end of a series of blocks that make up a logical paragraph. This produces a paragraph separator instead of an interblock separator. Between some blocks, such as markdown paragraphs, a paragraph separator is always produced.

The \markdownRendererParagraphSeparator macro represents a paragraph separator. The macro receives no arguments.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\markdownSetup{
  renderers = {
    paragraphSeparator = {%
      \par
      \emph{(The end of a paragraph)}%
      \par
    },
  },
}
\begin{document}
\begin{markdown}
Hello *world*!

_Foo_ bar!
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.22 Line Block Renderers

The following macros are only produced, when the lineBlocks option is enabled.

The \markdownRendererLineBlockBegin and \markdownRendererLineBlockEnd macros represent the beginning and the end of a line block. The macros receive no arguments.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionLineBlocks{true}
\markdownBegin
| I would spread the cloths under your feet:
| But I, being poor, have only my dreams;
| I have spread my dreams under your feet;
| Tread softly because you tread on my dreams.
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[lineBlocks]{markdown}
\begin{document}
\begin{markdown}
| I would spread the cloths under your feet:
| But I, being poor, have only my dreams;
| I have spread my dreams under your feet;
| Tread softly because you tread on my dreams.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[lineBlocks = yes]
\starttext
\startmarkdown
| I would spread the cloths under your feet:
| But I, being poor, have only my dreams;
| I have spread my dreams under your feet;
| Tread softly because you tread on my dreams.
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.23 Line Break Renderers

The \markdownRendererSoftLineBreak macro represents a soft line break. The macro receives no arguments.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownRendererSoftLineBreak{%
  \par
  {\it(A soft line break)}%
  \par
}
\markdownInput{example.md}
\bye

Using a text editor, create a text document named example.md with the following content:

Hello world!
_Foo_ bar!

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\markdownSetup{
  renderers = {
    softLineBreak = {%
      \par
      \emph{(A soft line break)}%
      \par
    },
  },
}
\begin{document}
\markdownInput{example.md}
\end{document}

Using a text editor, create a text document named example.md with the following content:

Hello world!
_Foo_ bar!

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

The \markdownRendererHardLineBreak macro represents a hard line break. The macro receives no arguments.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownRendererHardLineBreak{%
  \par
  {\it(A hard line break)}%
  \par
}
\markdownInput{example.md}
\bye

Using a text editor, create a text document named example.md with the following content. Note the two spaces at the end of the first line, which specify a hard line break. Due to the limitations of the T_eX input processor, hard line breaks would be ignored if we typed them directly into the document.tex document.

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\markdownSetup{
  renderers = {
    hardLineBreak = {%
      \par
      \emph{(A hard line break)}%
      \par
    },
  },
}
\begin{document}
\markdownInput{example.md}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.24 Link Renderer

The \markdownRendererLink macro represents a hyperlink. It receives four arguments: the label, the fully escaped uri that can be directly typeset, the raw uri that can be used outside typesetting, and the title of the link.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownRendererLink#1#2#3#4{%
  #1 {\tt#2} titled {\it#4}%
}
\markdownBegin
Please visit [the link][ctan].

 [ctan]: https://ctan.org/
         (the Comprehensive TeX Archive Network)
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\markdownSetup{
  renderers = {
    link = {%
      #1 \texttt{#2} titled \emph{#4}%
    },
  },
}
\begin{document}
\begin{markdown}
Please visit [the link][ctan].

 [ctan]: https://ctan.org/
         (the Comprehensive TeX Archive Network)
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\def\markdownRendererLink#1#2#3#4{%
  #1 {\tt#2} titled \emph{#4}%
}
\starttext
\startmarkdown
Please visit [the link][ctan].

 [ctan]: https://ctan.org/
         (the Comprehensive TeX Archive Network)
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.25 Link Attribute Context Renderers

The following macros are only produced, when the linkAttributes option is enabled.

The \markdownRendererLinkAttributeContextBegin and \markdownRendererLinkAttributeContextEnd macros represent the beginning and the end of a context in which the attributes of a hyperlink apply. The macros receive no arguments.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[linkAttributes]{markdown}
\markdownSetup{
  renderers = {
    linkAttributeContextBegin = {(},
    link = {#1},
    linkAttributeContextEnd = {)},
  },
}
\begin{document}
\begin{markdown}

foo [bar](#bar){key=value} baz

\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.26 Marked Text Renderer

The \markdownRendererMark macro represents a span of marked or highlighted text. The macro receives a single argument that corresponds to the marked text.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[mark]{markdown}
\usepackage{soul}
\markdownSetup{
  renderers = {
    mark = {\hl{#1}},
  },
}
\begin{document}
\begin{markdown}

This ==is highlighted text.==

\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.27 Markdown Document Renderers

The \markdownRendererDocumentBegin and \markdownRendererDocumentEnd macros represent the beginning and the end of a markdown document. The macros receive no arguments.

A T_eX document may contain any number of markdown documents. Additionally, markdown documents may appear not only in a sequence, but several markdown documents may also be nested. Redefinitions of the macros should take this into account.

L^aT_eX Example

Using a text editor, create a text document named nested.md with the following content:

This is a *nested* markdown document.

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[contentBlocks]{markdown}
\markdownSetup{
  renderers = {
    contentBlock = {%
      \markdownInput{#3}%
    },
    documentBegin = {%
      \par
      \emph{(The beginning of a document)}
      \par
      \begingroup
      \markdownSetup{snippet=first-nesting-level}%
    },
    documentEnd = {%
      \endgroup
      \par
      \emph{(The end of a document)}
      \par
    },
  },
}
\markdownSetupSnippet{first-nesting-level}{
  renderers = {
    documentBegin = {
      \par
      \emph{(The beginning of a nested document)}
      \par
      \begingroup
      \markdownSetup{snippet=second-nesting-level-and-below}
    },
  },
}
\markdownSetupSnippet{second-nesting-level-and-below}{
  renderers = {
    documentBegin = {
      \par
      \emph{(The beginning of a nested document)}
      \par
      \begingroup
    },
    documentEnd = {
      \endgroup
      \par
      \emph{(The end of a nested document)}
      \par
    },
  },
}
\begin{document}
\begin{markdown}
Hello *world*!

/nested.md

_Foo_ bar!
\end{markdown}
\begin{markdown}

Bar baz!

\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.28 Non-Breaking Space Renderer

L^aT_eX Example

Using a text editor, create a text document named document.bib with the following content:

@book{knuth:tex,
  author    = "Knuth, Donald Ervin",
  title     = "The \TeX book, volume A of Computers and typesetting",
  publisher = "Addison-Wesley",
  year      = "1984"
}

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[
  citations,
  citationNbsps,
]{markdown}
\markdownSetup{
  renderers = {
    nbsp = {$\cdot$},
  },
}
\begin{document}

\begin{markdown}
The TeXbook [@knuth:tex, p. 123 and 130] is good.
\end{markdown}

\bibliographystyle{plain}
\bibliography{document.bib}

\end{document}

lualatex document.tex
bibtex document.aux
lualatex document.tex
lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.29 Note Renderer

The \markdownRendererNote macro represents a note. This macro will only be produced, when the notes option is enabled. The macro receives a single argument that corresponds to the note text.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionNotes{true}
\def\markdownRendererNote#1{ (and \lowercase{#1})}
\markdownBegin
This is some text[^1] and this is some other text[^2].

 [^1]: this is a note

 [^2]: this is some other note
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[notes]{markdown}
\markdownSetup{
  renderers = {
    note = { (and \MakeLowercase{#1})},
  },
}
\begin{document}
\begin{markdown}
This is some text[^1] and this is some other text[^2].

 [^1]: this is a note

 [^2]: this is some other note
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[notes = yes]
\def\markdownRendererNote#1{ (and \lowercase{#1})}
\starttext
\startmarkdown
This is some text[^1] and this is some other text[^2].

 [^1]: this is a note

 [^2]: this is some other note
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.30 Ordered List Renderers

The \markdownRendererOlBegin macro represents the beginning of an ordered list that contains an item with several paragraphs of text (the list is not tight). This macro will only be produced, when the fancyLists option is disabled. The macro receives no arguments.

The \markdownRendererOlBeginTight macro represents the beginning of an ordered list that contains no item with several paragraphs of text (the list is tight). This macro will only be produced, when the tightLists option is enabled and the fancyLists option is disabled. The macro receives no arguments.

The \markdownRendererFancyOlBegin macro represents the beginning of a fancy ordered list that contains an item with several paragraphs of text (the list is not tight). This macro will only be produced, when the fancyLists option is enabled. The macro receives two arguments: the style of the list item labels (Decimal, LowerRoman, UpperRoman, LowerAlpha, and UpperAlpha), and the style of delimiters between list item labels and texts (Default, OneParen, and Period).

The \markdownRendererFancyOlBeginTight macro represents the beginning of a fancy ordered list that contains no item with several paragraphs of text (the list is tight). This macro will only be produced, when the fancyLists and tightLists options are enabled. The macro receives two arguments: the style of the list item labels, and the style of delimiters between list item labels and texts. See the \markdownRendererFancyOlBegin macro for the valid style values.

The \markdownRendererOlItem macro represents an item in an ordered list. This macro will only be produced, when the startNumber option is disabled and the fancyLists option is disabled. The macro receives no arguments.

The \markdownRendererOlItemEnd macro represents the end of an item in an ordered list. This macro will only be produced, when the fancyLists option is disabled. The macro receives no arguments.

The \markdownRendererOlItemWithNumber macro represents an item in an ordered list. This macro will only be produced, when the startNumber option is enabled and the fancyLists option is disabled. The macro receives a single numeric argument that corresponds to the item number.

The \markdownRendererFancyOlItem macro represents an item in a fancy ordered list. This macro will only be produced, when the startNumber option is disabled and the fancyLists option is enabled. The macro receives no arguments.

The \markdownRendererFancyOlItemEnd macro represents the end of an item in a fancy ordered list. This macro will only be produced, when the fancyLists option is enabled. The macro receives no arguments.

The \markdownRendererFancyOlItemWithNumber macro represents an item in a fancy ordered list. This macro will only be produced, when the startNumber and fancyLists options are enabled. The macro receives a single numeric argument that corresponds to the item number.

The \markdownRendererOlEnd macro represents the end of an ordered list that contains an item with several paragraphs of text (the list is not tight). This macro will only be produced, when the fancyLists option is disabled. The macro receives no arguments.

The \markdownRendererOlEndTight macro represents the end of an ordered list that contains no item with several paragraphs of text (the list is tight). This macro will only be produced, when the tightLists option is enabled and the fancyLists option is disabled. The macro receives no arguments.

The \markdownRendererFancyOlEnd macro represents the end of a fancy ordered list that contains an item with several paragraphs of text (the list is not tight). This macro will only be produced, when the fancyLists option is enabled. The macro receives no arguments.

The \markdownRendererFancyOlEndTight macro represents the end of a fancy ordered list that contains no item with several paragraphs of text (the list is tight). This macro will only be produced, when the fancyLists and tightLists options are enabled. The macro receives no arguments.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionTightLists{true}
\def\markdownOptionStartNumber{true}

\def\markdownRendererInterblockSeparator{}
\def\markdownRendererOlBeginTight{ (}
\def\markdownRendererOlItemWithNumber#1{%
  \ifnum #1=1\relax
    the first
  \else
    \ifnum #1=2\relax
      , the second
    \else
      , and the third
    \fi
  \fi
}
\def\markdownRendererOlItemEnd{}
\def\markdownRendererOlEndTight{).}

\markdownBegin
This is a tight list

1. item
2. item
3. item
\markdownEnd

\def\markdownRendererInterblockSeparator{%
  :\par
  \def\markdownRendererInterblockSeparator{\par}%
}
\def\markdownRendererOlBegin{}
\def\markdownRendererOlItemWithNumber#1{%
  #1.\kern 0.5em%
  This is the
  \ifnum #1=1\relax
    first
  \else
    \ifnum #1=2\relax
      second
    \else
      third
    \fi
  \fi
}
\def\markdownRendererOlItemEnd{.\par}
\def\markdownRendererOlEnd{}

\markdownBegin
This is a loose list

1. item

2. item

3. item
\markdownEnd

\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[tightLists, startNumber]{markdown}
\begin{document}

\begin{markdown}[
  renderers = {
    interblockSeparator = {},
    olBeginTight = { (},
    olItemWithNumber = {%
      \ifnum #1=1\relax
        the first
      \else
        \ifnum #1=2\relax
          , the second
        \else
          , and the third
        \fi
      \fi
    },
    olItemEnd = {},
    olEndTight = {).},
  },
]
This is a tight list

1. item
2. item
3. item
\end{markdown}

\begin{markdown}[
  renderers = {
    interblockSeparator = {%
      :\par
      \def\markdownRendererInterblockSeparator{\par}%
    },
    olBeginTight = {\begin{enumerate}},
    olItemWithNumber = {%
      \item This is the
      \ifnum #1=1\relax
        first
      \else
        \ifnum #1=2\relax
          second
        \else
          third
        \fi
      \fi
    },
    olItemEnd = {.},
    olEnd = {\end{enumerate}},
  },
]
This is a loose list

1. item

2. item

3. item
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown
  [
    tightLists = yes,
    startNumber = yes,
  ]
\starttext

\def\markdownRendererInterblockSeparator{}
\def\markdownRendererOlBeginTight{ (}
\def\markdownRendererOlItemWithNumber#1{%
  \ifnum #1=1\relax
    the first
  \else
    \ifnum #1=2\relax
      , the second
    \else
      , and the third
    \fi
  \fi
}
\def\markdownRendererOlItemEnd{}
\def\markdownRendererOlEndTight{).}

\startmarkdown
This is a tight list

1. item
2. item
3. item
\stopmarkdown

\def\markdownRendererInterblockSeparator{%
  :\par
  \def\markdownRendererInterblockSeparator{\par}%
}
\def\markdownRendererOlBegin{\startitemize}
\def\markdownRendererOlItemWithNumber#1{%
  \sym{#1.}
  This is the
  \ifnum #1=1\relax
    first
  \else
    \ifnum #1=2\relax
      second
    \else
      third
    \fi
  \fi
}
\def\markdownRendererOlItemEnd{.\par}
\def\markdownRendererOlEnd{\stopitemize}

\startmarkdown
This is a loose list

1. item

2. item

3. item
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.31 Raw Content Renderers

The \markdownRendererInputRawInline macro represents an inline raw span. The macro receives two arguments: the filename of a file contaning the inline raw span contents and the raw attribute that designates the format of the inline raw span. This macro will only be produced, when the rawAttribute option is enabled.

The \markdownRendererInputRawBlock macro represents a raw block. The macro receives two arguments: the filename of a file contaning the raw block and the raw attribute that designates the format of the raw block. This macro will only be produced, when the rawAttribute and fencedCode options are enabled.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[rawAttribute, fencedCode]{markdown}
\usepackage{expl3}
\ExplSyntaxOn
\cs_new:Nn
  \display_raw_content:nn
  {
    % If the raw attribute is TeX, execute the content as a TeX document.
    \str_if_eq:nnTF
      { #2 }
      { tex }
      { \markdownEscape { #1 } }
      % Otherwise, ignore the content.
      { }
  }
\markdownSetup{
  renderers = {
    rawInline = { \display_raw_content:nn { #1 } { #2 } },
    rawBlock  = { \display_raw_content:nn { #1 } { #2 } }
  },
}
\ExplSyntaxOff
\begin{document}
\begin{markdown}
`$H_2 O$`{=tex} is a liquid.

``` {=html}
<p>Here is some HTML content that will be ignored.</p>
```
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.32 Section Renderers

The \markdownRendererSectionBegin and \markdownRendererSectionEnd macros represent the beginning and the end of a section based on headings.

2.3.1.33 Replacement Character Renderers

The \markdownRendererReplacementCharacter macro represents the U+0000 and U+FFFD Unicode characters. The macro receives no arguments.

2.3.1.34 Special Character Renderers

The following macros replace any special plain T_eX characters, including the active pipe character (|) of ConT_eXt, in the input text:

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content. We will make the tilde behave as if it were written in T_eX, where it represents a non-breaking space.

\input markdown
\def\markdownRendererTilde{~}
\markdownBegin
Bartel~Leendert van~der~Waerden
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text, where the middot (·) denotes a non-breaking space:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content. We will make the tilde behave as if it were written in T_eX, where it represents a non-breaking space.

\documentclass{article}
\usepackage{markdown}
\markdownSetup{
  renderers = {
    tilde = ~,
  },
}
\begin{document}
\begin{markdown}
Bartel~Leendert van~der~Waerden
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text, where the middot (·) denotes a non-breaking space:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content. We will make the tilde behave as if it were written in T_eX, where it represents a non-breaking space.

\usemodule[t][markdown]
\def\markdownRendererTilde{~}
\starttext
\startmarkdown
Bartel~Leendert van~der~Waerden
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text, where the middot (·) denotes a non-breaking space:

2.3.1.35 Strike-Through Renderer

The \markdownRendererStrikeThrough macro represents a strike-through span of text. The macro receives a single argument that corresponds to the striked-out span of text. This macro will only be produced, when the strikeThrough option is enabled.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionStrikeThrough{true}
\input soulutf8.sty
\def\markdownRendererStrikeThrough#1{\st{#1}}
\markdownBegin
This is ~~a lunar roving vehicle~~ strike-through text.
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[strikeThrough]{markdown}
\usepackage{soulutf8}
\markdownSetup{
  renderers = {
    strikeThrough = {\st{#1}},
  },
}
\begin{document}
\begin{markdown}
This is ~~a lunar roving vehicle~~ strike-through text.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[strikeThrough = yes]
\def\markdownRendererStrikeThrough#1{\overstrikes{#1}}
\starttext
\startmarkdown
This is ~~a lunar roving vehicle~~ strike-through text.
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.36 Subscript Renderer

The \markdownRendererSubscript macro represents a subscript span of text. The macro receives a single argument that corresponds to the subscript span of text. This macro will only be produced, when the subscripts option is enabled.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionSubscripts{true}
\def\markdownRendererSubscript#1{ (#1 moles) and }
\markdownBegin
H~2~O is a liquid.
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[subscripts]{markdown}
\markdownSetup{
  renderers = {
    subscript = { (#1 moles) and },
  },
}
\begin{document}
\begin{markdown}
H~2~O is a liquid.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[subscripts = yes]
\def\markdownRendererSubscript#1{ (#1 moles) and }
\starttext
\startmarkdown
H~2~O is a liquid.
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.37 Superscript Renderer

The \markdownRendererSuperscript macro represents a superscript span of text. The macro receives a single argument that corresponds to the superscript span of text. This macro will only be produced, when the superscripts option is enabled.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionSuperscripts{true}
\def\markdownRendererSuperscript#1{ taken to the power of #1}
\markdownBegin
2^10^ is 1024.
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[superscripts]{markdown}
\markdownSetup{
  renderers = {
    superscript = { taken to the power of #1},
  },
}
\begin{document}
\begin{markdown}
2^10^ is 1024.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[superscripts = yes]
\def\markdownRendererSuperscript#1{ taken to the power of #1}
\starttext
\startmarkdown
2^10^ is 1024.
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.38 Table Attribute Context Renderers

The following macros are only produced, when the tableCaptions and tableAttributes options are enabled.

The \markdownRendererTableAttributeContextBegin and \markdownRendererTableAttributeContextEnd macros represent the beginning and the end of a context in which the attributes of a table apply. The macros receive no arguments.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[
  pipeTables,
  tableCaptions,
  tableAttributes,
  relativeReferences,
]{markdown}
\usepackage{expl3}
\ExplSyntaxOn
\markdownSetup{
  renderers = {
    tableAttributeContextBegin = {
      \group_begin:
      \markdownSetup{
        renderers = {
          attributeIdentifier = {
            \markdownSetup{
              renderers = {
                tableAttributeContextEnd = {
                  \label{##1}
                  \group_end:
                },
              },
            }
          },
        },
      }
    },
    tableAttributeContextEnd = {
      \group_end:
    },
  },
}
\ExplSyntaxOff
\begin{document}
\begin{markdown}
See Table <#example-table>.

| Right | Left | Default | Center |
|------:|:-----|---------|:------:|
|   12  |  12  |    12   |    12  |
|  123  |  123 |   123   |   123  |
|    1  |    1 |     1   |     1  |

  : Demonstration of pipe table syntax. {#example-table}
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Table 1. Demonstration of pipe table syntax.
Right	Left	Default	Center
12	12	12	12
123	123	123	123
1	1	1	1

2.3.1.39 Table Renderer

The \markdownRendererTable macro represents a table. This macro will only be produced, when the pipeTables option is enabled. The macro receives the parameters {⟨caption⟩}{⟨number of rows⟩}{⟨number of columns⟩} followed by {⟨alignments⟩} and then by {⟨row⟩} repeated ⟨number of rows⟩ times, where ⟨row⟩ is {⟨column⟩} repeated ⟨number of columns⟩ times, ⟨alignments⟩ is ⟨alignment⟩ repeated ⟨number of columns⟩ times, and ⟨alignment⟩ is one of the following:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[pipeTables, tableCaptions]{markdown}
\newcount\rowCounter
\newcount\columnCounter
\makeatletter
\def\processRow#1{%
  \columnCounter=1%
  \ifnum\rowCounter=0\relax
    As for the alignment,
  \else
    In row \the\rowCounter,
  \fi
  \processColumn#1
  \advance\rowCounter by 1\relax
  \ifnum\rowCounter>\rowTotal\relax
    \expandafter\@gobble
  \fi\processRow}%
\def\processColumn#1{%
  column number \the\columnCounter{}
  \ifnum\rowCounter=0\relax
    \if#1d{}has default alignment\fi
    \if#1l{}is left-aligned\fi
    \if#1c{}is centered\fi
    \if#1r{}is right-aligned\fi
  \else
    says \emph{#1}%
  \fi
  \advance\columnCounter by 1\relax
  \ifnum\columnCounter<\columnTotal\relax, \fi
  \ifnum\columnCounter=\columnTotal\relax, and \fi
  \ifnum\columnCounter>\columnTotal\relax
    .\expandafter\@gobble
  \fi\processColumn}%
\makeatother
\markdownSetup{
  renderers = {
    table = {%
      This is a table with caption \emph{#1} that is #3 colums wide
      and #2 rows long.
      \rowCounter=0%
      \def\rowTotal{#2}%
      \def\columnTotal{#3}%
      \processRow
    },
  },
}
\begin{document}
\begin{markdown}
| Right | Left | Default | Center |
|------:|:-----|---------|:------:|
|   12  |  12  |    12   |    12  |
|  123  |  123 |   123   |   123  |
|    1  |    1 |     1   |     1  |

  : Demonstration of pipe table syntax
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.40 T_eX Math Renderers

The \markdownRendererInlineMath and \markdownRendererDisplayMath macros represent inline and display T_eX math. Both macros receive a single argument that corresponds to the T_eX math content. These macros will only be produced, when the texMathDollars, texMathSingleBackslash, or texMathDoubleBackslash option are enabled.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionTexMathDollars{true}
\def\markdownRendererInlineMath#1{$#1\dots$}
\def\markdownRendererDisplayMath#1{$$#1\eqno(1)$$}
\markdownBegin
$E=mc^2$

$$\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx$$
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[texMathDollars]{markdown}
\usepackage{amsmath}
\def\markdownRendererInlineMath#1{\begin{math}#1\dots\end{math}}
\def\markdownRendererDisplayMath#1{\begin{equation}#1\end{equation}}
\begin{document}
\begin{markdown}
$E=mc^2$

$$\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx$$
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[texMathDollars = yes]
\def\markdownRendererInlineMath#1{$#1\dots$}%
\def\markdownRendererDisplayMath#1{\placeformula\startformula#1\stopformula}%
\starttext
\startmarkdown
$E=mc^2$

$$\hat{f} \left ( \xi  \right )= \int_{-\infty}^{\infty} f\left ( x  \right ) e^{-i2\pi \xi x} dx$$
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.41 Thematic Break Renderer

The \markdownRendererThematicBreak macro represents a thematic break. The macro receives no arguments.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownRendererThematicBreak{\vfil\break}
\markdownBegin
This is the first page.

***

This is the second page.
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\markdownSetup{
  renderers = {
    thematicBreak = \newpage,
  },
}
\begin{document}
\begin{markdown}
This is the first page.

***

This is the second page.
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\def\markdownRendererThematicBreak{\page[yes]}
\starttext
\startmarkdown
This is the first page.

***

This is the second page.
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.42 Tickbox Renderers

The macros named \markdownRendererTickedBox, \markdownRendererHalfTickedBox, and \markdownRendererUntickedBox represent ticked and unticked boxes, respectively. These macros will either be produced, when the taskLists option is enabled, or when the Ballot Box with X (☒, U+2612), Hourglass (⌛, U+231B) or Ballot Box (☐, U+2610) Unicode characters are encountered in the markdown input, respectively.

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[taskLists]{markdown}
\markdownSetup{
  renderers = {
    untickedBox = No,
    tickedBox = Yes,
  },
}
\begin{document}
\begin{markdown}
- [ ] you can't.
- [x] I can!
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[taskLists = yes]
\def\markdownRendererUntickedBox{No}
\def\markdownRendererTickedBox{Yes}
\starttext
\startmarkdown
- [ ] you can't.
- [x] I can!
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.1.43 YAML Metadata Renderers

The \markdownRendererJekyllDataBegin macro represents the beginning of a yaml document. This macro will only be produced when the jekyllData option is enabled. The macro receives no arguments.

The \markdownRendererJekyllDataEnd macro represents the end of a yaml document. This macro will only be produced when the jekyllData option is enabled. The macro receives no arguments.

The \markdownRendererJekyllDataMappingBegin macro represents the beginning of a mapping in a yaml document. This macro will only be produced when the jekyllData option is enabled. The macro receives two arguments: the scalar key in the parent structure, cast to a string following yaml serialization rules, and the number of items in the mapping.

The \markdownRendererJekyllDataMappingEnd macro represents the end of a mapping in a yaml document. This macro will only be produced when the jekyllData option is enabled. The macro receives no arguments.

The \markdownRendererJekyllDataSequenceBegin macro represents the beginning of a sequence in a yaml document. This macro will only be produced when the jekyllData option is enabled. The macro receives two arguments: the scalar key in the parent structure, cast to a string following yaml serialization rules, and the number of items in the sequence.

The \markdownRendererJekyllDataSequenceEnd macro represents the end of a sequence in a yaml document. This macro will only be produced when the jekyllData option is enabled. The macro receives no arguments.

The \markdownRendererJekyllDataBoolean macro represents a boolean scalar value in a yaml document. This macro will only be produced when the jekyllData option is enabled. The macro receives two arguments: the scalar key in the parent structure, and the scalar value, both cast to a string following yaml serialization rules.

The \markdownRendererJekyllDataNumber macro represents a numeric scalar value in a yaml document. This macro will only be produced when the jekyllData option is enabled. The macro receives two arguments: the scalar key in the parent structure, and the scalar value, both cast to a string following yaml serialization rules.

The \markdownRendererJekyllDataString macro represents a string scalar value in a yaml document. This macro will only be produced when the jekyllData option is enabled. The macro receives two arguments: the scalar key in the parent structure, cast to a string following yaml serialization rules, and the scalar value.

The \markdownRendererJekyllDataEmpty macro represents an empty scalar value in a yaml document. This macro will only be produced when the jekyllData option is enabled. The macro receives one argument: the scalar key in the parent structure, cast to a string following yaml serialization rules.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionJekyllData{true}
\def\markdownRendererJekyllDataString#1#2{\gdef\name{#2}}
\def\markdownRendererJekyllDataNumber#1#2{\gdef\age{#2}}
\def\markdownRendererJekyllDataEnd{%
  \name{} is \age{} years old.}
\markdownBegin
---
name: Jane Doe
age:  99
---
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[jekyllData]{markdown}
\markdownSetup{
  renderers = {
    jekyllDataString = {\gdef\name{#2}},
    jekyllDataNumber = {\gdef\age{#2}},
    jekyllDataEnd = {\name{} is \age{} years old.},
  }
}
\begin{document}

\begin{markdown}
---
name: Jane Doe
age:  99
---
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[jekyllData = yes]
\def\markdownRendererJekyllDataString#1#2{\gdef\name{#2}}
\def\markdownRendererJekyllDataNumber#1#2{\gdef\age{#2}}
\def\markdownRendererJekyllDataEnd{%
  \name{} is \age{} years old.}
\starttext

\startmarkdown
---
name: Jane Doe
age:  99
---
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.2 Token Renderer Prototypes

By default, token renderers point to package-defined T_eX macros, further referred to as prototypes, which provide useful default definitions.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownRendererTildePrototype{%
  Packages can specify token renderer prototypes.%
}
\markdownBegin
~
\markdownEnd

\def\markdownRendererTilde{%
  User-defined token renderers take precedence.%
}
\markdownBegin
~
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage{markdown}
\markdownSetup{
  rendererPrototypes = {
    tilde = {Packages can specify token renderer prototypes.},
  },
}
\begin{document}
\begin{markdown}
~
\end{markdown}

\begin{markdown}[
  renderers = {
    tilde = {User-defined token renderers take precedence.},
  },
]
~
\end{markdown}
\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\def\markdownRendererTildePrototype{%
  Packages can specify token renderer prototypes.%
}
\starttext
\startmarkdown
~
\stopmarkdown

\def\markdownRendererTilde{%
  User-defined token renderers take precedence.%
}
\startmarkdown
~
\stopmarkdown
\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

2.3.2.1 YAML Metadata Renderer Prototypes

By default, the renderer prototypes for YAML metadata provide a high-level interface that can be programmed using the markdown/jekyllData key–values from the l3keys module of the L^aT_eX3 kernel.

Plain T_eX Example

Using a text editor, create a text document named document.tex with the following content:

\input markdown
\def\markdownOptionJekyllData{true}
\ExplSyntaxOn
\keys_define:nn
  { markdown/jekyllData }
  {
    name .code:n = { \gdef\name{#1} },
    age  .code:n = { \gdef\age{#1}  },
  }
\ExplSyntaxOff
\def\markdownRendererJekyllDataEnd{%
  \name{} is \age{} years old.}
\markdownBegin
---
name: Jane Doe
age:  99
---
\markdownEnd
\bye

luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

L^aT_eX Example

Using a text editor, create a text document named document.tex with the following content:

\documentclass{article}
\usepackage[jekyllData]{markdown}
\markdownSetup{
  jekyllDataRenderers = {
    name = {\gdef\name{#1}},
    code = {\gdef\age{#1}},
  },
  renderers = {
    jekyllDataEnd = {\name{} is \age{} years old.},
  }
}
\begin{document}

\begin{markdown}
---
name: Jane Doe
age:  99
---
\end{markdown}

\end{document}

lualatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

ConT_eXt Example

Using a text editor, create a text document named document.tex with the following content:

\usemodule[t][markdown]
\setupmarkdown[jekyllData = yes]
\ExplSyntaxOn
\keys_define:nn
  { markdown/jekyllData }
  {
    name .code:n = { \gdef\name{#1} },
    age  .code:n = { \gdef\age{#1}  },
  }
\ExplSyntaxOff
\def\markdownRendererJekyllDataEnd{%
  \name{} is \age{} years old.}
\starttext

\startmarkdown
---
name: Jane Doe
age:  99
---
\stopmarkdown

\stoptext

context --luatex document.tex

A PDF document named document.pdf should be produced and contain the following text:

Inlines notes are easier to write, since you don’t have to pick an identifier and move down to type the note.↩︎
Inlines notes are easier to write, since you don’t have to pick an identifier and move down to type the note.↩︎
Here is the note.↩︎
Here’s one with multiple blocks.

Subsequent paragraphs are indented to show that they belong to the previous note.
```
{ some.code }
```
The whole paragraph can be indented, or just the first line. In this way, multi-paragraph notes work like multi-paragraph list items.↩︎
Here is the note.↩︎
Here’s one with multiple blocks.

Subsequent paragraphs are indented to show that they belong to the previous note.
```
{ some.code }
```
The whole paragraph can be indented, or just the first line. In this way, multi-paragraph notes work like multi-paragraph list items.↩︎
Filenames other than markdown-languages.json may be specified using the contentBlocksLanguageMap Lua option.↩︎

1 Introduction

1.1 Requirements

1.2 Installation

1.2.1 Local Installation

1.2.2 Portable Installation

1.3 First Document

1.3.1 Using Lua

1.3.1.1 Using the Lua Module

1.3.1.2 Using the Lua Command-Line Interface

1.3.2 Using Plain TeX

1.3.3 Using LaTeX

1.3.4 Using ConTeXt

2 Examples

2.1 Interfaces

2.1.1 Lua

2.1.1.1 Lua Module

2.1.1.2 Lua Command-Line Interface

2.1.2 Plain TeX

2.1.3 LaTeX

2.1.4 ConTeXt

2.2 Options

2.2.1 Lua

2.2.1.1 Option eagerCache

Lua CLI Example

2.2.1.2 Option singletonCache

Lua Module Example

2.2.1.3 Option cacheDir

Lua Module Example

Lua CLI Example

Plain TeX Example

LaTeX Example

ConTeXt Example

2.2.1.4 Option contentBlocksLanguageMap

LaTeX Example

ConTeXt Example

2.2.1.5 Option debugExtensionsFileName

2.2.1.6 Option frozenCacheFileName

Lua Module Example

Lua CLI Example

Plain TeX Example

LaTeX Example

ConTeXt Example

2.2.1.7 Option autoIdentifiers

2.2.1.8 Option blankBeforeBlockquote

Lua Module Example

Lua CLI Example

Plain TeX Example

LaTeX Example

ConTeXt Example

2.2.1.9 Option blankBeforeCodeFence

Lua Module Example

Lua CLI Example

Plain TeX Example

LaTeX Example

ConTeXt Example

2.2.1.10 Option blankBeforeDivFence

LaTeX Example

2.2.1.11 Option blankBeforeHeading

Lua Module Example

A heading.

Lua CLI Example

A heading?

Plain TeX Example

A heading.

LaTeX Example

A heading.

ConTeXt Example

A heading.

2.2.1.12 Option blankBeforeList

Lua Module Example

Lua CLI Example

Plain TeX Example

LaTeX Example

ConTeXt Example

2.2.1.13 Option bracketedSpans

LaTeX Example

2.2.1.14 Option breakableBlockquotes

Lua Module Example

Lua CLI Example

Plain TeX Example

1.3.2 Using Plain T_eX

1.3.3 Using L^aT_eX

1.3.4 Using ConT_eXt

2.1.2 Plain T_eX

2.1.3 L^aT_eX

2.1.4 ConT_eXt

2.2.1.1 Option `eagerCache`

2.2.1.2 Option `singletonCache`

2.2.1.3 Option `cacheDir`

Plain T_eX Example

L^aT_eX Example

ConT_eXt Example

2.2.1.4 Option `contentBlocksLanguageMap`

L^aT_eX Example

ConT_eXt Example

2.2.1.5 Option `debugExtensionsFileName`

2.2.1.6 Option `frozenCacheFileName`

Plain T_eX Example

L^aT_eX Example

ConT_eXt Example

2.2.1.7 Option `autoIdentifiers`

2.2.1.8 Option `blankBeforeBlockquote`

Plain T_eX Example

L^aT_eX Example

ConT_eXt Example

2.2.1.9 Option `blankBeforeCodeFence`

Plain T_eX Example

L^aT_eX Example

ConT_eXt Example

2.2.1.10 Option `blankBeforeDivFence`

L^aT_eX Example

2.2.1.11 Option `blankBeforeHeading`

Plain T_eX Example

L^aT_eX Example

ConT_eXt Example

2.2.1.12 Option `blankBeforeList`

Plain T_eX Example

L^aT_eX Example

ConT_eXt Example

2.2.1.13 Option `bracketedSpans`

L^aT_eX Example

2.2.1.14 Option `breakableBlockquotes`

Plain T_eX Example

L^aT_eX Example

ConT_eXt Example

2.2.1.15 Option `citationNbsps`

L^aT_eX Example

2.2.1.16 Option `citations`

L^aT_eX Example

2.2.1.17 Option `codeSpans`

Plain T_eX Example

L^aT_eX Example

ConT_eXt Example

2.2.1.18 Option `contentBlocks`

L^aT_eX Example

ConT_eXt Example

2.2.1.19 Option `contentLevel`

Plain T_eX Example

L^aT_eX Example

ConT_eXt Example

2.2.1.20 Option `debugExtensions`

L^aT_eX Example

2.2.1.21 Option `definitionLists`

L^aT_eX Example

ConT_eXt Example

2.2.1.22 Option `expectJekyllData`

L^aT_eX Example

2.2.1.23 Option `extensions`

L^aT_eX Example

2.2.1.24 Option `fancyLists`

L^aT_eX Example

ConT_eXt Example

2.2.1.25 Option `fencedCode`

L^aT_eX Example

ConT_eXt Example

2.2.1.26 Option `fencedCodeAttributes`

L^aT_eX Example

2.2.1.27 Option `fencedDivs`

L^aT_eX Example

2.2.1.28 Option `finalizeCache`