Pandoc Lua 过滤器

原文

Pandoc has long supported filters, which allow the pandoc abstract syntax tree (AST) to be manipulated between the parsing and the writing phase. Traditional pandoc filters accept a JSON representation of the pandoc AST and produce an altered JSON representation of the AST. They may be written in any programming language, and invoked from pandoc using the --filter option.

Although traditional filters are very flexible, they have a couple of disadvantages. First, there is some overhead in writing JSON to stdout and reading it from stdin (twice, once on each side of the filter). Second, whether a filter will work will depend on details of the user’s environment. A filter may require an interpreter for a certain programming language to be available, as well as a library for manipulating the pandoc AST in JSON form. One cannot simply provide a filter that can be used by anyone who has a certain version of the pandoc executable.

Starting with version 2.0, pandoc makes it possible to write filters in Lua without any external dependencies at all. A Lua interpreter (version 5.4) and a Lua library for creating pandoc filters is built into the pandoc executable. Pandoc data types are marshaled to Lua directly, avoiding the overhead of writing JSON to stdout and reading it from stdin.

Here is an example of a Lua filter that converts strong emphasis to small caps:

return {
  Strong = function (elem)
    return pandoc.SmallCaps(elem.content)
  end,
}

function Strong(elem)
  return pandoc.SmallCaps(elem.content)
end

This says: walk the AST, and when you find a Strong element, replace it with a SmallCaps element with the same content.

To run it, save it in a file, say smallcaps.lua, and invoke pandoc with --lua-filter=smallcaps.lua.

Here’s a quick performance comparison, converting the pandoc manual (MANUAL.txt) to HTML, with versions of the same JSON filter written in compiled Haskell (smallcaps) and interpreted Python (smallcaps.py):

Command	Time
`pandoc`	1.01s
`pandoc --filter ./smallcaps`	1.36s
`pandoc --filter ./smallcaps.py`	1.40s
`pandoc --lua-filter ./smallcaps.lua`	1.03s

As you can see, the Lua filter avoids the substantial overhead associated with marshaling to and from JSON over a pipe.

Lua filters are tables with element names as keys and values consisting of functions acting on those elements.

Filters are expected to be put into separate files and are passed via the --lua-filter command-line argument. For example, if a filter is defined in a file current-date.lua, then it would be applied like this:

pandoc --lua-filter=current-date.lua -f markdown MANUAL.txt

The --lua-filter option may be supplied multiple times. Pandoc applies all filters (including JSON filters specified via --filter and Lua filters specified via --lua-filter) in the order they appear on the command line.

Pandoc expects each Lua file to return a filter. If there is no value returned by the filter script, then pandoc will try to generate a single filter by collecting all top-level functions whose names correspond to those of pandoc elements (e.g., Str, Para, Meta, or Pandoc). (That is why the two examples above are equivalent.)

walk method was made available, this was the only way to run multiple filters from one Lua file. However, returning a list of filters is now discouraged in favor of using the walk method, and this functionality may be removed at some point.

For each filter, the document is traversed and each element subjected to the filter. Elements for which the filter contains an entry (i.e. a function of the same name) are passed to Lua element filtering function. In other words, filter entries will be called for each corresponding element in the document, getting the respective element as input.

The return value of a filter function must be one of the following:

nil: this means that the object should remain unchanged.
a pandoc object: this must be of the same type as the input and will replace the original object.
a list of pandoc objects: these will replace the original object; the list is merged with the neighbors of the original objects (spliced into the list the original object belongs to); returning an empty list deletes the object.

The function’s output must result in an element of the same type as the input. This means a filter function acting on an inline element must return either nil, an inline, or a list of inlines, and a function filtering a block element must return one of nil, a block, or a list of block elements. Pandoc will throw an error if this condition is violated.

If there is no function matching the element’s node type, then the filtering system will look for a more general fallback function. Two fallback functions are supported, Inline and Block. Each matches elements of the respective type.

Elements without matching functions are left untouched.

See module documentation for a list of pandoc elements.

Inlines (inlines)

These filter functions are special in that the result must either be nil, in which case the list is left unchanged, or must be a list of the correct type, i.e., the same type as the input argument. Single elements are not allowed as return values, as a single element in this context usually hints at a bug.

See “Remove spaces before normal citations” for an example.

This functionality has been added in pandoc 2.9.2.

local filter = {
  traverse = 'topdown',
  -- ... filter functions ...
}
return filter

Inline elements,
the Inlines filter function,
functions for Block elements ,
the Blocks filter function,
the Meta filter function, and last
the Pandoc filter function.

It is still possible to force a different order by manually running the filters using the walk method. For example, if the filter for Meta is to be run before that for Str, one can write

function Pandoc(doc)
  doc = doc:walk { Meta = Meta } -- (1)
  return doc:walk { Str = Str }  -- (2)
end

It is sometimes more natural to traverse the document tree depth-first from the root towards the leaves, and all in a single run.

For example, a block list [Plain [Str "a"], Para [Str "b"]] will try the following filter functions, in order: Blocks, Plain, Inlines, Str, Para, Inlines, Str.

Topdown traversals can be cut short by returning false as a second value from the filter function. No child-element of the returned element is processed in that case.

For example, to exclude the contents of a footnote from being processed, one might write

traverse = 'topdown'
function Note (n)
  return n, false
end

FORMAT: The global FORMAT is set to the format of the pandoc writer being used (html5, latex, etc.), so the behavior of a filter can be made conditional on the eventual output format.
PANDOC_READER_OPTIONS

The pandoc Lua module is loaded into the filter’s Lua environment and provides a set of functions and constants to make creation and manipulation of elements easier. The global variable pandoc is bound to the module and should generally not be overwritten for this reason.

Two major functionalities are provided by the module: element creator functions and access to some of pandoc’s main functionalities.

Element creator functions like Str, Para, and Pandoc are designed to allow easy creation of new elements that are simple to use and can be read back from the Lua environment. Internally, pandoc uses these functions to create the Lua objects which are passed to element filter functions. This means that elements created via this module will behave exactly as those elements accessible through the filter function parameter.

walk_block and walk_inline allow filters to be applied inside specific block or inline elements;
read allows filters to parse strings into pandoc documents;
pipe runs an external command with input from and output to strings;
the pandoc.mediabag module allows access to the “mediabag,” which stores binary content such as images that may be included in the final document;
the pandoc.utils module contains various utility functions.

Initialization of pandoc’s Lua interpreter can be controlled by placing a file init.lua in pandoc’s data directory. A common use-case would be to load additional modules, or even to alter default modules.

The following snippet is an example of code that might be useful when added to init.lua. The snippet adds all Unicode-aware functions defined in the text module to the default string module, prefixed with the string uc_.

for name, fn in pairs(require 'text') do
  string['uc_' .. name] = fn
end

luacheck may be used for this purpose. A Luacheck configuration file for pandoc filters is available at https://github.com/rnwst/pandoc-luacheckrc.

William Lupton has written a Lua module with some handy functions for debugging Lua filters, including functions that can pretty-print the Pandoc AST elements manipulated by the filters: it is available at https://github.com/wlupton/pandoc-lua-logging.

It is possible to use a debugging interface to halt execution and step through a Lua filter line by line as it is run inside Pandoc. This is accomplished using the remote-debugging interface of the package mobdebug. Although mobdebug can be run from the terminal, it is more useful run within the donation-ware Lua editor and IDE, ZeroBrane Studio. ZeroBrane offers a REPL console and UI to step-through and view all variables and state.

ZeroBrane doesn’t come with Lua 5.4 bundled, but it can debug it, so you should install Lua 5.4, and then add mobdebug and its dependency luasocket using luarocks. ZeroBrane can use your Lua 5.4 install by adding path.lua = "/path/to/your/lua" in your ZeroBrane settings file. Next, open your Lua filter in ZeroBrane, and add require('mobdebug').start() at the line where you want your breakpoint. Then make sure the Project > Lua Interpreter is set to the “Lua” you added in settings and enable “Start Debugger Server” see detailed instructions here. Run Pandoc as you normally would, and ZeroBrane should break at the correct line.

AST elements not updated

The following filters are presented as examples. A repository of useful Lua filters (which may also serve as good examples) is available at https://github.com/pandoc/lua-filters.

return {
  Str = function (elem)
    if elem.text == "{{helloworld}}" then
      return pandoc.Emph {pandoc.Str "Hello, World"}
    else
      return elem
    end
  end,
}

-- Filter images with this function if the target format is LaTeX.
if FORMAT:match 'latex' then
  function Image (elem)
    -- Surround all images with image-centering raw LaTeX.
    return {
      pandoc.RawInline('latex', '\\hfill\\break{\\centering'),
      elem,
      pandoc.RawInline('latex', '\\par}')
    }
  end
end

-- Filter images with this function if the target format is HTML
if FORMAT:match 'html' then
  function Image (elem)
    -- Use CSS style to center image
    elem.attributes.style = 'margin:auto; display: block;'
    return elem
  end
end

function Meta(m)
  if m.date == nil then
    m.date = os.date("%B %e, %Y")
    return m
  end
end

local function is_space_before_author_in_text(spc, cite)
  return spc and spc.t == 'Space'
    and cite and cite.t == 'Cite'
    -- there must be only a single citation, and it must have
    -- mode 'AuthorInText'
    and #cite.citations == 1
    and cite.citations[1].mode == 'AuthorInText'
end

function Inlines (inlines)
  -- Go from end to start to avoid problems with shifting indices.
  for i = #inlines-1, 1, -1 do
    if is_space_before_author_in_text(inlines[i], inlines[i+1]) then
      inlines:remove(i)
    end
  end
  return inlines
end

local vars = {}

local function get_vars (meta)
  for k, v in pairs(meta) do
    if pandoc.utils.type(v) == 'Inlines' then
      vars["%" .. k .. "%"] = {table.unpack(v)}
    end
  end
end

local function replace (el)
  if vars[el.text] then
    return pandoc.Span(vars[el.text])
  else
    return el
  end
end

function Pandoc(doc)
  return doc:walk { Meta = get_vars }:walk { Str = replace }
end

---
name: Samuel Q. Smith
occupation: Professor of Oenology
---

Name

:   %name%

Occupation

:   %occupation%

<dl>
<dt>Name</dt>
<dd><p><span>Samuel Q. Smith</span></p>
</dd>
<dt>Occupation</dt>
<dd><p><span>Professor of Oenology</span></p>
</dd>
</dl>

walk to transform inline elements inside headers), removes footnotes, and replaces links with regular text.

-- we use pandoc.text to get a UTF-8 aware 'upper' function
local text = pandoc.text

function Header(el)
    if el.level == 1 then
      return el:walk {
        Str = function(el)
            return pandoc.Str(text.upper(el.text))
        end
      }
    end
end

function Link(el)
    return el.content
end

function Note(el)
    return {}
end

-- creates a handout from an article, using its headings,
-- blockquotes, numbered examples, figures, and any
-- Divs with class "handout"

function Pandoc(doc)
    local hblocks = {}
    for i,el in pairs(doc.blocks) do
        if (el.t == "Div" and el.classes[1] == "handout") or
           (el.t == "BlockQuote") or
           (el.t == "OrderedList" and el.style == "Example") or
           (el.t == "Para" and #el.c == 1 and el.c[1].t == "Image") or
           (el.t == "Header") then
           table.insert(hblocks, el)
        end
    end
    return pandoc.Pandoc(hblocks, doc.meta)
end

This filter counts the words in the body of a document (omitting metadata like titles and abstracts), including words in code. It should be more accurate than wc -w run directly on a Markdown document, since the latter will count markup characters, like the # in front of an ATX header, or tags in HTML documents, as words. To run it, pandoc --lua-filter wordcount.lua myfile.md.

-- counts words in a document

words = 0

wordcount = {
  Str = function(el)
    -- we don't count a word if it's entirely punctuation:
    if el.text:match("%P") then
        words = words + 1
    end
  end,

  Code = function(el)
    _,n = el.text:gsub("%S+","")
    words = words + n
  end,

  CodeBlock = function(el)
    _,n = el.text:gsub("%S+","")
    words = words + n
  end
}

function Pandoc(el)
    -- skip metadata, just count body:
    el.blocks:walk(wordcount)
    print(words .. " words in body")
    os.exit(0)
end

pandoc.Table constructor.

This is my table caption.
This	is my	table
Cell 1	Cell 2	Cell 3
Cell 4	Cell 5	Cell 6
This is my table footer.

Note that:

The number of columns in the resulting Table element is equal to the number of entries in the colspecs parameter.
A ColSpec object must contain the cell alignment, but the column width is optional.
A TableBody object is specified using a Lua table in the bodies parameter because there is no pandoc.TableBody constructor.

function Pandoc ()
  local caption = pandoc.Caption( "This is my table caption." )
  local colspecs = {
    { pandoc.AlignLeft },
    { pandoc.AlignDefault }, 
    { pandoc.AlignCenter }, 
    { pandoc.AlignRight },
    { pandoc.AlignDefault }
  }
  local head = pandoc.TableHead{
    pandoc.Row{
      pandoc.Cell( "This" ), 
      pandoc.Cell( "is my" ), 
      pandoc.Cell( "table" ),
      pandoc.Cell( "header" )
    }
  }
  local bodies = {
    {
      attr={},
      body={ 
        pandoc.Row{
          pandoc.Cell( "Cell 1" ), 
          pandoc.Cell( "Cell 2" ), 
          pandoc.Cell( "Cell 3" )
        },
        pandoc.Row{
          pandoc.Cell( "Cell 4" ), 
          pandoc.Cell( "Cell 5" ), 
          pandoc.Cell( "Cell 6" )
        }
      },
      head={},
      row_head_columns=0
    }
  }
  local foot = pandoc.TableFoot{
    pandoc.Row{
      pandoc.Cell( "This is my table footer.", pandoc.AlignDefault, 1, 4 )
    }
  }
  return pandoc.Pandoc { 
    pandoc.Table(caption, colspecs, head, bodies, foot) 
  }
end

https://abcnotation.com.)

Images are added to the mediabag. For output to binary formats, pandoc will use images in the mediabag. For textual formats, use --extract-media to specify a directory where the files in the mediabag will be written, or (for HTML only) use --embed-resources.

-- Pandoc filter to process code blocks with class "abc" containing
-- ABC notation into images.
--
-- * Assumes that abcm2ps and ImageMagick's convert are in the path.
-- * For textual output formats, use --extract-media=abc-images
-- * For HTML formats, you may alternatively use --embed-resources

local filetypes = { html = {"png", "image/png"}
                  , latex = {"pdf", "application/pdf"}
                  }
local filetype = filetypes[FORMAT][1] or "png"
local mimetype = filetypes[FORMAT][2] or "image/png"

local function abc2eps(abc, filetype)
    local eps = pandoc.pipe("abcm2ps", {"-q", "-O", "-", "-"}, abc)
    local final = pandoc.pipe("convert", {"-", filetype .. ":-"}, eps)
    return final
end

function CodeBlock(block)
    if block.classes[1] == "abc" then
        local img = abc2eps(block.text, filetype)
        local fname = pandoc.sha1(img) .. "." .. filetype
        pandoc.mediabag.insert(fname, mimetype, img)
        return pandoc.Para{ pandoc.Image({pandoc.Str("abc tune")}, fname) }
    end
end

pdf2svg, so both of these must be in the system path. Converted images are cached in the working directory and given filenames based on a hash of the source, so that they need not be regenerated each time the document is built. (A more sophisticated version of this might put these in a special cache directory.)

local system = require 'pandoc.system'

local tikz_doc_template = [[
\documentclass{standalone}
\usepackage{xcolor}
\usepackage{tikz}
\begin{document}
\nopagecolor
%s
\end{document}
]]

local function tikz2image(src, filetype, outfile)
  system.with_temporary_directory('tikz2image', function (tmpdir)
    system.with_working_directory(tmpdir, function()
      local f = io.open('tikz.tex', 'w')
      f:write(tikz_doc_template:format(src))
      f:close()
      os.execute('pdflatex tikz.tex')
      if filetype == 'pdf' then
        os.rename('tikz.pdf', outfile)
      else
        os.execute('pdf2svg tikz.pdf ' .. outfile)
      end
    end)
  end)
end

extension_for = {
  html = 'svg',
  html4 = 'svg',
  html5 = 'svg',
  latex = 'pdf',
  beamer = 'pdf' }

local function file_exists(name)
  local f = io.open(name, 'r')
  if f ~= nil then
    io.close(f)
    return true
  else
    return false
  end
end

local function starts_with(start, str)
  return str:sub(1, #start) == start
end


function RawBlock(el)
  if starts_with('\\begin{tikzpicture}', el.text) then
    local filetype = extension_for[FORMAT] or 'svg'
    local fbasename = pandoc.sha1(el.text) .. '.' .. filetype
    local fname = system.get_working_directory() .. '/' .. fbasename
    if not file_exists(fname) then
      tikz2image(el.text, filetype, fname)
    end
    return pandoc.Para({pandoc.Image({}, fbasename)})
  else
   return el
  end
end

Example of use:

pandoc --lua-filter tikz.lua -s -o cycle.html <<EOF
Here is a diagram of the cycle:

\begin{tikzpicture}

\def \n {5}
\def \radius {3cm}
\def \margin {8} % margin in angles, depends on the radius

\foreach \s in {1,...,\n}
{
  \node[draw, circle] at ({360/\n * (\s - 1)}:\radius) {$\s$};
  \draw[->, >=latex] ({360/\n * (\s - 1)+\margin}:\radius)
    arc ({360/\n * (\s - 1)+\margin}:{360/\n * (\s)-\margin}:\radius);
}
\end{tikzpicture}
EOF

pandoc module for functions to create these objects.

clone ()

All instances of the types listed here, with the exception of read-only objects, can be cloned via the clone() method.

Usage:

local emph = pandoc.Emph {pandoc.Str 'important'}
local cloned_emph = emph:clone()  -- note the colon

pandoc.Pandoc constructor. Pandoc values are equal in Lua if and only if they are equal in Haskell.

blocks: document content (Blocks)
meta: document meta information (Meta object)

self

Results:

cloned and normalized document. (Pandoc)

traversal order. Returns a (deep) copy on which the filter has been applied: the original element is left untouched.

Parameters:

self: the element (Pandoc)
lua_filter: map of filter functions (table)

Result:

Usage:

-- returns `pandoc.Pandoc{pandoc.Para{pandoc.Str 'Bye'}}`
return pandoc.Pandoc{pandoc.Para('Hi')}:walk {
  Str = function (_) return 'Bye' end,
}

MetaValues.

Values of this type can be created with the pandoc.Meta constructor. Meta values are equal in Lua if and only if they are equal in Haskell.

Document meta information items. This is not a separate type, but describes a set of types that can be used in places were a MetaValue is expected. The types correspond to the following Haskell type constructors:

boolean → MetaBool
string or number → MetaString
Inlines → MetaInlines
Blocks → MetaBlocks
List/integer indexed table → MetaList
string-indexed table → MetaMap

pandoc.MetaBool, pandoc.MetaString, pandoc.MetaInlines, pandoc.MetaBlocks, pandoc.MetaList, and pandoc.MetaMap can be used to ensure that a value is treated in the intended way. E.g., an empty table is normally treated as a MetaMap, but can be made into an empty MetaList by calling pandoc.MetaList{}. However, the same can be accomplished by using the generic functions like pandoc.List, pandoc.Inlines, or pandoc.Blocks.

Use the function pandoc.utils.type to get the type of a metadata value.

traversal order. Returns a (deep) copy on which the filter has been applied: the original element is left untouched.

Note that the filter is applied to the subtree, but not to the self block element. The rationale is that otherwise the element could be deleted by the filter, or replaced with multiple block elements, which might lead to possibly unexpected results.

Parameters:

self: the element (Block)
lua_filter: map of filter functions (table)

Result:

Usage:

-- returns `pandoc.Para{pandoc.Str 'Bye'}`
return pandoc.Para('Hi'):walk {
  Str = function (_) return 'Bye' end,
}

pandoc.BlockQuote constructor.

Fields:

content: block content (Blocks)
tag, t: the literal BlockQuote (string)

pandoc.BulletList constructor.

Fields:

content: list items (List of items, i.e., List of Blocks)
tag, t: the literal BulletList (string)

pandoc.CodeBlock constructor.

Fields:

text: code string (string)
attr: element attributes (Attr)
identifier: alias for attr.identifier (string)
classes: alias for attr.classes (List of strings)
attributes: alias for attr.attributes (Attributes)
tag, t: the literal CodeBlock (string)

pandoc.DefinitionList constructor.

Fields:

content: list of items
tag, t: the literal DefinitionList (string)

pandoc.Div constructor.

Fields:

content: block content (Blocks)
attr: element attributes (Attr)
identifier: alias for attr.identifier (string)
classes: alias for attr.classes (List of strings)
attributes: alias for attr.attributes (Attributes)
tag, t: the literal Div (string)

pandoc.Figure constructor.

Fields:

content: block content (Blocks)
caption: figure caption (Caption)
attr: element attributes (Attr)
identifier: alias for attr.identifier (string)
classes: alias for attr.classes (List of strings)
attributes: alias for attr.attributes (Attributes)
tag, t: the literal Figure (string)

pandoc.HorizontalRule constructor.

Fields:

tag, t: the literal HorizontalRule (string)

pandoc.LineBlock constructor.

Fields:

content: inline content (List of lines, i.e. List of Inlines)
tag, t: the literal LineBlock (string)

pandoc.OrderedList constructor.

Fields:

content: list items (List of items, i.e., List of Blocks)
listAttributes: list parameters (ListAttributes)
start: alias for listAttributes.start (integer)
style: alias for listAttributes.style (string)
delimiter: alias for listAttributes.delimiter (string)
tag, t: the literal OrderedList (string)

pandoc.Para constructor.

Fields:

content: inline content (Inlines)
tag, t: the literal Para (string)

pandoc.Plain constructor.

Fields:

content: inline content (Inlines)
tag, t: the literal Plain (string)

pandoc.RawBlock constructor.

Fields:

format: format of content (string)
text: raw content (string)
tag, t: the literal RawBlock (string)

pandoc.Table constructor.

Fields:

attr: table attributes (Attr)
caption: table caption (Caption)
colspecs: column specifications, i.e., alignments and widths (List of ColSpecs)
head: table head (TableHead)
bodies: table bodies (List of TableBodys)
foot: table foot (TableFoot)
identifier: alias for attr.identifier (string)
classes: alias for attr.classes (List of strings)
attributes: alias for attr.attributes (Attributes)
tag, t: the literal Table (string)

A table cell is a list of blocks.

Alignment is a string value indicating the horizontal alignment of a table column. AlignLeft, AlignRight, and AlignCenter leads cell content to be left-aligned, right-aligned, and centered, respectively. The default alignment is AlignDefault (often equivalent to centered).

Block elements, with the same methods as a generic List. It is usually not necessary to create values of this type in user scripts, as pandoc can convert other types into Blocks wherever a value of this type is expected:

a list of Block (or Block-like) values is used directly;
a single Inlines value is wrapped into a Plain element;
string values are turned into an Inlines value by splitting the string into words (see Inlines), and then wrapping the result into a Plain singleton.

pandoc.List module.

Additionally, the following methods are available on Blocks values:

traversal order. Returns a (deep) copy on which the filter has been applied: the original list is left untouched.

Parameters:

self: the list (Blocks)
lua_filter: map of filter functions (table)

Result:

Usage:

-- returns `pandoc.Blocks{pandoc.Para('Salve!')}`
return pandoc.Blocks{pandoc.Plain('Salve!)}:walk {
  Plain = function (p) return pandoc.Para(p.content) end,
}

traversal order. Returns a (deep) copy on which the filter has been applied: the original element is left untouched.

Note that the filter is applied to the subtree, but not to the self inline element. The rationale is that otherwise the element could be deleted by the filter, or replaced with multiple inline elements, which might lead to possibly unexpected results.

Parameters:

self: the element (Inline)
lua_filter: map of filter functions (table)

Result:

filtered inline element (Inline)

Usage:

-- returns `pandoc.SmallCaps('SPQR)`
return pandoc.SmallCaps('spqr'):walk {
  Str = function (s) return string.upper(s.text) end,
}

pandoc.Cite constructor.

Fields:

content: (Inlines)
citations: citation entries (List of Citations)
tag, t: the literal Cite (string)

pandoc.Code constructor.

Fields:

text: code string (string)
attr: attributes (Attr)
identifier: alias for attr.identifier (string)
classes: alias for attr.classes (List of strings)
attributes: alias for attr.attributes (Attributes)
tag, t: the literal Code (string)

pandoc.Emph constructor.

Fields:

content: inline content (Inlines)
tag, t: the literal Emph (string)

pandoc.Image constructor.

Fields:

caption: text used to describe the image (Inlines)
src: path to the image file (string)
title: brief image description (string)
attr: attributes (Attr)
identifier: alias for attr.identifier (string)
classes: alias for attr.classes (List of strings)
attributes: alias for attr.attributes (Attributes)
tag, t: the literal Image (string)

pandoc.LineBreak constructor.

Fields:

tag, t: the literal LineBreak (string)

pandoc.Link constructor.

Fields:

attr: attributes (Attr)
content: text for this link (Inlines)
target: the link target (string)
title: brief link description
identifier: alias for attr.identifier (string)
classes: alias for attr.classes (List of strings)
attributes: alias for attr.attributes (Attributes)
tag, t: the literal Link (string)

pandoc.Math constructor.

Fields:

mathtype: specifier determining whether the math content should be shown inline (InlineMath) or on a separate line (DisplayMath) (string)
text: math content (string)
tag, t: the literal Math (string)

pandoc.Note constructor.

Fields:

content: (Blocks)
tag, t: the literal Note (string)

pandoc.Quoted constructor.

Fields:

quotetype: type of quotes to be used; one of SingleQuote or DoubleQuote (string)
content: quoted text (Inlines)
tag, t: the literal Quoted (string)

pandoc.RawInline constructor.

Fields:

format: the format of the content (string)
text: raw content (string)
tag, t: the literal RawInline (string)

pandoc.SmallCaps constructor.

Fields:

content: (Inlines)
tag, t: the literal SmallCaps (string)

pandoc.SoftBreak constructor.

Fields:

tag, t: the literal SoftBreak (string)

pandoc.Space constructor.

Fields:

tag, t: the literal Space (string)

pandoc.Span constructor.

Fields:

attr: attributes (Attr)
content: wrapped content (Inlines)
identifier: alias for attr.identifier (string)
classes: alias for attr.classes (List of strings)
attributes: alias for attr.attributes (Attributes)
tag, t: the literal Span (string)

pandoc.Str constructor.

Fields:

text: content (string)
tag, t: the literal Str (string)

pandoc.Strikeout constructor.

Fields:

content: inline content (Inlines)
tag, t: the literal Strikeout (string)

pandoc.Strong constructor.

Fields:

content: inline content (Inlines)
tag, t: the literal Strong (string)

pandoc.Subscript constructor.

Fields:

content: inline content (Inlines)
tag, t: the literal Subscript (string)

pandoc.Superscript constructor.

Fields:

content: inline content (Inlines)
tag, t: the literal Superscript (string)

pandoc.Underline constructor.

Fields:

content: inline content (Inlines)
tag, t: the literal Underline (string)

Inline elements, with the same methods as a generic List. It is usually not necessary to create values of this type in user scripts, as pandoc can convert other types into Inlines wherever a value of this type is expected:

lists of Inline (or Inline-like) values are used directly;
single Inline values are converted into a list containing just that element;
String values are split into words, converting line breaks into SoftBreak elements, and other whitespace characters into Spaces.

pandoc.List module.

Additionally, the following methods are available on Inlines values:

walk(self, lua_filter)

Applies a Lua filter to the Inlines list. Just as for full-document filters, the order in which elements are handled are Inline → Inlines → Block → Blocks. The filter is applied to all list items and to the list itself. Returns a (deep) copy on which the filter has been applied: the original list is left untouched.

Parameters:

self

Result:

Usage:

-- returns `pandoc.Inlines{pandoc.SmallCaps('SPQR')}`
return pandoc.Inlines{pandoc.Emph('spqr')}:walk {
  Str = function (s) return string.upper(s.text) end,
  Emph = function (e) return pandoc.SmallCaps(e.content) end,
}

pandoc.Attr constructor. For convenience, it is usually not necessary to construct the value directly if it is part of an element, and it is sufficient to pass an HTML-like table. E.g., to create a span with identifier “text” and classes “a” and “b”, one can write:

local span = pandoc.Span('text', {id = 'text', class = 'a b'})

This also works when using the attr setter:

local span = pandoc.Span 'text'
span.attr = {id = 'text', class = 'a b', other_attribute = '1'}

Attr values are equal in Lua if and only if they are equal in Haskell.

Fields:

identifier: element identifier (string)
classes: element classes (List of strings)
attributes: collection of key/value pairs (Attributes)

long

attr: cell attributes
alignment

pandoc.Citation constructor.

Citation values are equal in Lua if and only if they are equal in Haskell.

Fields:

id: citation identifier, e.g., a bibtex key (string)
mode: citation mode, one of AuthorInText, SuppressAuthor, or NormalCitation (string)
prefix: citation prefix (Inlines)
suffix: citation suffix (Inlines)
note_num: note number (integer)
hash: hash (integer)

Alignment).
table column width, as a fraction of the page width (number).

pandoc.ListAttributes constructor.

Fields:

start: number of the first list item (integer)
style: style used for list numbers; possible values are DefaultStyle, Example, Decimal, LowerRoman, UpperRoman, LowerAlpha, and UpperAlpha (string)
delimiter: delimiter of list numbers; one of DefaultDelim, Period, OneParen, and TwoParens (string)

attr

attr

attr

Pandoc reader options

Fields:

abbreviations: set of known abbreviations (set of strings)
columns: number of columns in terminal (integer)
default_image_extension: default extension for images (string)
extensions: string representation of the syntax extensions bit field (sequence of strings)
indented_code_classes: default classes for indented code blocks (list of strings)
standalone: whether the input was a standalone document with header (boolean)
strip_comments: HTML comments are stripped instead of parsed as raw HTML (boolean)
tab_stop: width (i.e. equivalent number of spaces) of tab stops (integer)
track_changes: track changes setting for docx; one of accept-changes, reject-changes, and all-changes (string)

chunk_template: Template used to generate chunked HTML filenames (string)
cite_method: How to print cites – one of ‘citeproc’, ‘natbib’, or ‘biblatex’ (string)
columns: Characters in a line (for text wrapping) (integer)
dpi: DPI for pixel to/from inch/cm conversions (integer)
email_obfuscation: How to obfuscate emails – one of ‘none’, ‘references’, or ‘javascript’ (string)
epub_chapter_level: Header level for chapters, i.e., how the document is split into separate files (integer)
epub_fonts: Paths to fonts to embed (sequence of strings)
epub_metadata: Metadata to include in EPUB (string|nil)
epub_subdirectory: Subdir for epub in OCF (string)
extensions: Markdown extensions that can be used (sequence of strings)
highlight_style: Style to use for highlighting; see the output of pandoc --print-highlight-style=... for an example structure. The value nil means that no highlighting is used. (table|nil)
html_math_method: How to print math in HTML; one of ‘plain’, ‘mathjax’, ‘mathml’, ‘webtex’, ‘katex’, ‘gladtex’, or a table with keys method and url. (string|table)
html_q_tags: Use <q> tags for quotes in HTML (boolean)
identifier_prefix: Prefix for section & note ids in HTML and for footnote marks in markdown (string)
incremental: True if lists should be incremental (boolean)
listings: Use listings package for code (boolean)
number_offset: Starting number for section, subsection, … (sequence of integers)
number_sections: Number sections in LaTeX (boolean)
prefer_ascii: Prefer ASCII representations of characters when possible (boolean)
reference_doc: Path to reference document if specified (string|nil)
reference_links: Use reference links in writing markdown, rst (boolean)
reference_location: Location of footnotes and references for writing markdown; one of ‘end-of-block’, ‘end-of-section’, ‘end-of-document’. The common prefix may be omitted when setting this value. (string)
section_divs: Put sections in div tags in HTML (boolean)
setext_headers: Use setext headers for levels 1-2 in markdown (boolean)
slide_level: Force header level of slides (integer|nil)
tab_stop: Tabstop for conversion btw spaces and tabs (integer)
table_of_contents: Include table of contents (boolean)
template

input_files

pandoc.layout module can be used to create and modify Doc values. All functions in that module that take a Doc value as their first argument are also available as Doc methods. E.g., (pandoc.layout.literal 'text'):render().

If a string is passed to a function expecting a Doc, then the string is treated as a literal value. I.e., the following two lines are equivalent:

test = pandoc.layout.quotes(pandoc.layout.literal 'this')
test = pandoc.layout.quotes('this')

pandoc.List module. See there for available methods.

Values of this type can be created with the pandoc.List constructor, turning a normal Lua table into a List.

Tables is possible with the pandoc.utils.to_simple_table and pandoc.utils.from_simple_table function, respectively. Instances of this type can also be created directly with the pandoc.SimpleTable constructor.

Fields:

caption: Inlines
aligns: column alignments (List of Alignments)
widths: column widths; a (List of numbers)
headers: table header row (List of simple cells, i.e., List of Blocks)
rows: table rows (List of rows, where a row is a list of simple cells, i.e., List of Blocks)

A version object. This represents a software version like “2.7.3”. The object behaves like a numerically indexed table, i.e., if version represents the version 2.7.3, then

version[1] == 2
version[2] == 7
version[3] == 3
#version == 3   -- length

Comparisons are performed element-wise, i.e.

Version '1.12' > Version '1.9'

pandoc.types.Version constructor.

actual

Usage:

PANDOC_VERSION:must_be_at_least '2.7.3'
PANDOC_API_VERSION:must_be_at_least(
  '1.17.4',
  'pandoc-types is too old: expected version %s, got %s'
)

heading

Inlines), number (string|nil), id (string), path (string), and level (integer).

Fields:

chunks: list of chunks that make up the document (list of Chunks).
meta: the document’s metadata (Meta)
toc: table of contents information (table)

Fields and functions for pandoc scripts; includes constructors for document tree elements, functions to parse text in a given format, and functions to filter and modify a subtree.

blocks

Returns:

content

Returns:

list of Block elements (Blocks)

inlines

Returns:

values

Returns:

list of meta values (List)

content

Returns:

BlockQuote element (Block)

items

Returns:

BulletList element (Block)

text: code string (string)
attr

Returns:

CodeBlock element (Block)

Block)

content

Returns:

Figure element.

Parameters:

content: figure block content (Blocks)
caption: figure caption (Caption)
attr: element attributes (Attr)

Returns:

Block)

content

Returns:

LineBlock element (Block)

items

Returns:

OrderedList element (Block)

content

Returns:

content

Returns:

caption

Returns:

Blocks list.

Parameters:

block_like_elements: List where each element can be treated as a Block value, or a single such value. (Blocks)

Returns:

list of block elements (Blocks)

content

Returns:

code: code string (string)
attr

Returns:

content

Returns:

caption

Returns:

content

Returns:

content

Returns:

quotetype: type of quotes (QuoteType)
content

Returns:

content

Returns:

content

Returns:

content

Returns:

content

Returns:

content

Returns:

content

Returns:

content

Returns:

Inlines list:

copies a list of Inline elements into a fresh list; any string s within the list is treated as pandoc.Str(s);
turns a single Inline into a singleton list;
splits a string into Str-wrapped words, treating interword spaces as Spaces or SoftBreaks.

Parameters:

inline_like_elements: List where each element can be treated as an Inline value, or just a single such value. (Inlines)

Returns:

identifier

Returns:

long

Returns:

Since: 3.6.1

blocks

Returns:

attribs

Returns:

id: citation ID (e.g. BibTeX key) (string)
mode: citation rendering mode (CitationMode)
prefix

Returns:

new citation object (Citation)

cells

Returns:

body

Returns:

rows

Returns:

rows

Returns:

SimpleTable (caption, align, widths, header, rows)

Usage:

local caption = "Overview"
local aligns = {pandoc.AlignDefault, pandoc.AlignDefault}
local widths = {0, 0} -- let pandoc determine col widths
local headers = {{pandoc.Plain({pandoc.Str "Language"})},
                 {pandoc.Plain({pandoc.Str "Typing"})}}
local rows = {
  {{pandoc.Plain "Haskell"}, {pandoc.Plain "static"}},
  {{pandoc.Plain "Lua"}, {pandoc.Plain "Dynamic"}},
}
simple_table = pandoc.SimpleTable(
  caption,
  aligns,
  widths,
  headers,
  rows
)

Parameters:

caption

Returns:

AuthorInText

ReaderOptions value.

Parameters

opts: Either a table with a subset of the properties of a ReaderOptions object, or another ReaderOptions object. Uses the defaults specified in the manual for all properties that are not explicitly specified. Throws an error if a table contains properties which are not present in a ReaderOptions object. (ReaderOptions|table)

Returns: new ReaderOptions object

Usage:

-- copy of the reader options that were defined on the command line.
local cli_opts = pandoc.ReaderOptions(PANDOC_READER_OPTIONS)

-- default reader options, but columns set to 66.
local short_colums_opts = pandoc.ReaderOptions {columns = 66}

WriterOptions value.

Parameters

opts: Either a table with a subset of the properties of a WriterOptions object, or another WriterOptions object. Uses the defaults specified in the manual for all properties that are not explicitly specified. Throws an error if a table contains properties which are not present in a WriterOptions object. (WriterOptions|table)

Returns: new WriterOptions object

Usage:

-- copy of the writer options that were defined on the command line.
local cli_opts = pandoc.WriterOptions(PANDOC_WRITER_OPTIONS)

-- default writer options, but DPI set to 300.
local short_colums_opts = pandoc.WriterOptions {dpi = 300}

Runs command with arguments, passing it some input, and returns the output.

Parameters:

command: program to run; the executable will be resolved using default system methods (string).
args: list of arguments to pass to the program (list of strings).
input: data which is piped into the program via stdin (string).

Returns:

Output of command, i.e. data printed to stdout (string)

Raises:

A table containing the keys command, error_code, and output is thrown if the command exits with a non-zero error code.

Usage:

local output = pandoc.pipe("sed", {"-e","s/a/b/"}, "abc")

Apply a filter inside a block element, walking its contents. Returns a (deep) copy on which the filter has been applied: the original element is left untouched.

Parameters:

element: the block element
filter: a Lua filter (table of functions) to be applied within the block element

Returns: the transformed block element

Apply a filter inside an inline element, walking its contents. Returns a (deep) copy on which the filter has been applied: the original element is left untouched.

Parameters:

element: the inline element
filter: a Lua filter (table of functions) to be applied within the inline element

Returns: the transformed inline element

Runs a function with a modified pandoc state.

The given callback is invoked after setting the pandoc state to the given values. The modifiable options are restored to their original values once the callback has returned.

The following state variables can be controlled:

request_headers (list of key-value tuples)
resource_path (list of filepaths)
user_data_dir (string)

Other options are ignored, and the rest of the state is not modified.

Usage:

local opts = {
  request_headers = {
    {'Authorization', 'Basic my-secret'}
  }
}
pandoc.with_state(opts, function ()
  local mime, contents = pandoc.mediabag.fetch(image_url)
)

Parse the given string into a Pandoc document.

The parser is run in the same environment that was used to read the main input files; it has full access to the file-system and the mediabag. This means that if the document specifies files to be included, as is possible in formats like LaTeX, reStructuredText, and Org, then these will be included in the resulting document. Any media elements are added to those retrieved from the other parsed input files. Use the read_env parameter to modify this behavior.

The format parameter defines the format flavor that will be parsed. This can be either a string, using + and - to enable and disable extensions, or a table with fields format (string) and extensions (table). The extensions table can be a list of all enabled extensions, or a table with extensions as keys and their activation status as values (true or 'enable' to enable an extension, false or 'disable' to disable it).

Note: The extensions field in reader_options is ignored, as the function will always use the format extensions specified via the format parameter.

Parameters:

markup: the markup to be parsed (string|Sources)
format: format specification; defaults to "markdown". See the description above for a complete description of this parameter. (string|table)
reader_options

Returns: pandoc document (Pandoc)

Usage:

local org_markup = "/emphasis/"  -- Input to be read
local document = pandoc.read(org_markup, "org")
-- Get the first block of the document
local block = document.blocks[1]
-- The inline element in that block is an `Emph`
assert(block.content[1].t == "Emph")

doc

Returns: - converted document (string)

Usage:

local doc = pandoc.Pandoc(
  {pandoc.Para {pandoc.Strong 'Tea'}}
)
local html = pandoc.write(doc, 'html')
assert(html == "<p><strong>Tea</strong></p>")

doc

Returns: - converted document (string)

Usage:

-- Adding this function converts a classic writer into a
-- new-style custom writer.
function Writer (doc, opts)
  PANDOC_DOCUMENT = doc
  PANDOC_WRITER_OPTIONS = opts
  loadfile(PANDOC_SCRIPT_FILE)()
  return pandoc.write_classic(doc, opts)
end

Command line options and argument parsing.

parse_options (args)

Parses command line arguments into pandoc options. Typically this function will be used in stand-alone pandoc Lua scripts, taking the list of arguments from the global arg.

Parameters:

args: list of command line arguments ({string,...})

Returns:

parsed options, using their JSON-like representation. (table)

Since: 3.0

repl ([env])

Starts a read-eval-print loop (REPL). The function returns all values of the last evaluated input. Exit the REPL by pressing ctrl-d or ctrl-c; press F1 to get a list of all key bindings.

The REPL is started in the global namespace, unless the env parameter is specified. In that case, the global namespace is merged into the given table and the result is used as _ENV value for the repl.

Specifically, local variables cannot be accessed, unless they are explicitly passed via the env parameter; e.g.

function Pandoc (doc)
  -- start repl, allow to access the `doc` parameter
  -- in the repl
  return pandoc.cli.repl{ doc = doc }
end

Note: it seems that the function exits immediately on Windows, without prompting for user input.

Parameters:

env: Extra environment; the global environment is merged into this table. (table)

Returns:

The result(s) of the last evaluated input, or nothing if the last input resulted in an error.

Since: 3.1.2

This module exposes internal pandoc functions and utility functions.

blocks_to_inlines (blocks[, sep])

Squash a list of blocks into a list of inlines.

Usage

local blocks = {
  pandoc.Para{ pandoc.Str 'Paragraph1' },
  pandoc.Para{ pandoc.Emph 'Paragraph2' }
}
local inlines = pandoc.utils.blocks_to_inlines(blocks)
assert(
  inlines == pandoc.Inlines {
    pandoc.Str 'Paragraph1',
    pandoc.Linebreak(),
    pandoc.Emph{ pandoc.Str 'Paragraph2' }
  }
)

Parameters:

blocks

Returns:

Since: 2.2.3

citeproc (doc)

Process the citations in the file, replacing them with rendered citations and adding a bibliography. See the manual section on citation rendering for details.

Usage:

-- Lua filter that behaves like `--citeproc`
function Pandoc (doc)
  return pandoc.utils.citeproc(doc)
end

Parameters:

doc

Returns:

Since: 2.19.1

Blocks.

Parameters:

object: Retrieve documentation for this object (any)
format: result format; defaults to 'ansi' (string|table)

Returns:

rendered documentation (string|Blocks)

Since: 3.8.4

equals (element1, element2)

Test equality of AST elements. Elements in Lua are considered equal if and only if the objects obtained by unmarshaling are equal.

This function is deprecated. Use the normal Lua == equality operator instead.

Parameters:

element1: (any)
element2: (any)

Returns:

Whether the two objects represent the same element (boolean)

Since: 2.5

Table block element from a SimpleTable. This is useful for dealing with legacy code which was written for pandoc versions older than 2.10.

Usage:

local simple = pandoc.SimpleTable(table)
-- modify, using pre pandoc 2.10 methods
simple.caption = pandoc.SmallCaps(simple.caption)
-- create normal table block again
table = pandoc.utils.from_simple_table(simple)

Parameters:

simple_tbl: (SimpleTable)

Returns:

table block element (Block)

Since: 2.11

Block elements into sections. Divs will be created beginning at each Header and containing following content until the next Header of comparable level. If number_sections is true, a number attribute will be added to each Header containing the section number. If base_level is non-null, Header levels will be reorganized so that there are no gaps, and so that the base level is the level specified.

Parameters:

number_sections: whether section divs should get an additional number attribute containing the section number. (boolean)
baselevel: shift top-level headings to this level (integer|nil)
blocks: list of blocks to process (Blocks)

Returns:

Since: 2.8

normalize_date (date)

Parse a date and convert (if possible) to “YYYY-MM-DD” format. We limit years to the range 1601-9999 (ISO 8601 accepts greater than or equal to 1583, but MS Word only accepts dates starting 1601). Returns nil instead of a string if the conversion failed.

Parameters:

date: the date string (string)

Returns:

normalized date, or nil if normalization failed. (string|nil)

Since: 2.0.6

references (doc)

Get references defined inline in the metadata and via an external bibliography. Only references that are actually cited in the document (either with a genuine citation or with nocite) are returned. URL variables are converted to links.

The structure used represent reference values corresponds to that used in CSL JSON; the return value can be use as references metadata, which is one of the values used by pandoc and citeproc when generating bibliographies.

Usage:

-- Include all cited references in document
function Pandoc (doc)
  doc.meta.references = pandoc.utils.references(doc)
  doc.meta.bibliography = nil
  return doc
end

Parameters:

doc

Returns:

lift of references. (table)

Since: 2.17

doc

Returns:

Since: 2.1.1

doc

Returns:

Since: 3.2.1

element

Returns:

A plain string representation of the given element. (string)

Since: 2.0.6

to_roman_numeral (n)

Converts an integer < 4000 to uppercase roman numeral.

Usage:

local to_roman_numeral = pandoc.utils.to_roman_numeral
local pandoc_birth_year = to_roman_numeral(2006)
-- pandoc_birth_year == 'MMVI'

Parameters:

n: positive integer below 4000 (integer)

Returns:

A roman numeral. (string)

Since: 2.0.6

to_simple_table (tbl)

Converts a table into an old/simple table.

Usage:

local simple = pandoc.utils.to_simple_table(table)
-- modify, using pre pandoc 2.10 methods
simple.caption = pandoc.SmallCaps(simple.caption)
-- create normal table block again
table = pandoc.utils.from_simple_table(simple)

Parameters:

tbl

Returns:

Since: 2.11

type (value)

Pandoc-friendly version of Lua’s default type function, returning type information similar to what is presented in the manual.

The function works by checking the metafield __name. If the argument has a string-valued metafield __name, then it returns that string. Otherwise it behaves just like the normal type function.

Usage:

-- Prints one of 'string', 'boolean', 'Inlines', 'Blocks',
-- 'table', and 'nil', corresponding to the Haskell constructors
-- MetaString, MetaBool, MetaInlines, MetaBlocks, MetaMap,
-- and an unset value, respectively.

function Meta (meta)
  print('type of metavalue `author`:', pandoc.utils.type(meta.author))
end

Parameters:

value: any Lua value (any)

Returns:

type of the given value (string)

Since: 2.17

v

Returns:

The pandoc.mediabag module allows accessing pandoc’s media storage. The “media bag” is used when pandoc is called with the --extract-media or (for HTML only) --embed-resources option.

The module is loaded as part of module pandoc and can either be accessed via the pandoc.mediabag field, or explicitly required, e.g.:

local mb = require 'pandoc.mediabag'

fetch (source)

Fetches the given source from a URL or local file. Returns two values: the contents of the file and the MIME type (or an empty string).

The function will first try to retrieve source from the mediabag; if that fails, it will try to download it or read it from the local file system while respecting pandoc’s “resource path” setting.

Usage:

local diagram_url = 'https://pandoc.org/diagram.jpg'
local mt, contents = pandoc.mediabag.fetch(diagram_url)

Parameters:

source: path to a resource; either a local file path or URI (string)

Returns:

The entry’s MIME type, or nil if the file was not found. (string)
Contents of the file, or nil if the file was not found. (string)

Since: 2.0

doc

Returns:

Since: 2.19

insert (filepath, mimetype, contents)

Adds a new entry to pandoc’s media bag. Replaces any existing media bag entry the same filepath.

Usage:

local fp = 'media/hello.txt'
local mt = 'text/plain'
local contents = 'Hello, World!'
pandoc.mediabag.insert(fp, mt, contents)

Parameters:

filepath: filename and path relative to the output folder. (string)
mimetype: the item’s MIME type; use nil if the MIME type is unknown or unavailable. (string|nil)
contents: the binary contents of the file. (string)

Since: 2.0

list should be preferred.

Usage:

for fp, mt, contents in pandoc.mediabag.items() do
  -- print(fp, mt, contents)
end

Returns:

Iterator triple:

The iterator function; must be called with the iterator state and the current iterator value.
Iterator state – an opaque value to be passed to the iterator function.
Initial iterator value.

Since: 2.7.3

list ()

Get a summary of the current media bag contents.

Usage:

-- calculate the size of the media bag.
local mb_items = pandoc.mediabag.list()
local sum = 0
for i = 1, #mb_items do
    sum = sum + mb_items[i].length
end
print(sum)

Returns:

A list of elements summarizing each entry in the media bag. The summary item contains the keys path, type, and length, giving the filepath, MIME type, and length of contents in bytes, respectively. (table)

Since: 2.0

lookup (filepath)

Lookup a media item in the media bag, and return its MIME type and contents.

Usage:

local filename = 'media/diagram.png'
local mt, contents = pandoc.mediabag.lookup(filename)

Parameters:

filepath: name of the file to look up. (string)

Returns:

The entry’s MIME type, or nil if the file was not found. (string)
Contents of the file, or nil if the file was not found. (string)

Since: 2.0

make_data_uri (mime_type, raw_data)

Convert the input data into a data URI as defined by RFC 2397.

Example:

-- Embed an unofficial pandoc logo
local pandoc_logo_url = 'https://raw.githubusercontent.com/'
  .. 'tarleb/pandoc-logo/main/pandoc.svg'

local datauri = pandoc.mediabag.make_data_uri(
  pandoc.mediabag.fetch(pandoc_logo_url)
)

local image = pandoc.Image('Logo', datauri)

Parameters:

mime_type: MIME type of the data (string)
raw_data: data to encode (string)

Returns:

Since: 3.7.1

write (dir[, fp])

Writes the contents of mediabag to the given target directory. If fp is given, then only the resource with the given name will be extracted. Omitting that parameter means that the whole mediabag gets extracted. An error is thrown if fp is given but cannot be found in the mediabag.

Parameters:

dir: path of the target directory (string)
fp: canonical name (relative path) of resource (string)

Since: 3.0

pandoc.List([table])

:at (index[, default])

Returns the element at the given index, or default if the list contains no item at the given position.

Negative integers count back from the last item in the list.

Parameters:

index: element position (integer)
default: the default value that is returned if the index is out of range (any)

Returns:

the list item at index, or default.

table.insert.

Parameters:

pos: index of the new value; defaults to length of the list + 1
value: value to insert into the list

Create an iterator over the list. The resulting function returns the next value each time it is called.

Usage:

for item in List{1, 1, 2, 3, 5, 8}:iter() do
  -- process item
end

Parameters:

step: step width with which to step through the list. Negative step sizes will cause the iterator to start from the end of the list. Defaults to 1. (integer)

Returns:

Create a new List. If the optional argument table is given, set the metatable of that value to pandoc.List.

The function also accepts an iterator, in which case it creates a new list from the return values of the iterator function.

Parameters:

table: table which should be treatable as a list; defaults to an empty table

Returns: the updated input value

table.remove.

Parameters:

pos: position of the list value that will be removed; defaults to the index of the last element

Returns: the removed element

Sorts list elements in a given order, in-place. If comp is given, then it must be a function that receives two list elements and returns true when the first element must come before the second in the final order (so that, after the sort, i < j implies not comp(list[j],list[i])). If comp is not given, then the standard Lua operator < is used instead.

Note that the comp function must define a strict partial order over the elements in the list; that is, it must be asymmetric and transitive. Otherwise, no valid sort may be possible.

The sort algorithm is not stable: elements considered equal by the given order may have their relative positions changed by the sort.

table.sort.

Parameters:

comp: Comparison function as described above.

Information about the formats supported by pandoc.

extensions (format)

Returns the extension configuration for the given format. The configuration is represented as a table with all supported extensions as keys and their default status as value, with true indicating that the extension is enabled by default, while false marks a supported extension that’s disabled.

This function can be used to assign a value to the Extensions global in custom readers and writers.

Parameters:

format: format identifier (string)

Returns:

extensions config (table)

Since: 3.0

size (image[, opts])

Returns a table containing the size and resolution of an image; throws an error if the given string is not an image, or if the size of the image cannot be determined.

The resulting table has four entries: width, height, dpi_horz, and dpi_vert.

The opts parameter, when given, should be either a WriterOptions object such as PANDOC_WRITER_OPTIONS, or a table with a dpi entry. It affects the calculation for vector image formats such as SVG.

Parameters:

image: image data (string)
opts

Returns:

image size information or error message (table)

Since: 3.1.13

format (image)

Returns the format of an image as a lowercase string.

Formats recognized by pandoc include png, gif, tiff, jpeg, pdf, svg, eps, and emf.

Parameters:

image: binary image data (string)

Returns:

image format, or nil if the format cannot be determined (string|nil)

Since: 3.1.13

Inline, Block, Pandoc, Inlines, or Blocks element the function will return an object of the appropriate type. Otherwise, if the input does not represent any of the AST types, the default decoding is applied: Objects and arrays are represented as tables, the JSON null value becomes null, and JSON booleans, strings, and numbers are converted using the Lua types of the same name.

The special handling of AST elements can be disabled by setting pandoc_types to false.

Parameters:

str: JSON string (string)
pandoc_types: whether to use pandoc types when possible. (boolean)

Returns:

Since: 3.1.1

encode (object)

Encodes a Lua object as JSON string.

If the object has a metamethod with name __tojson, then the result is that of a call to that method with object passed as the sole argument. The result of that call is expected to be a valid JSON string, but this is not checked.

Parameters:

object: object to convert (any)

Returns:

JSON encoding of the given object (string)

Since: 3.1.1

silence (fn)

Applies the function to the given arguments while preventing log messages from being added to the log. The warnings and info messages reported during the function call are returned as the first return value, with the results of the function call following thereafter.

Parameters:

fn: function to be silenced (function)

Returns:

List of log messages triggered during the function call, and any value returned by the function.

Since: 3.2

exists (path[, type])

Check whether there exists a filesystem object at the given path. If type is given and either directory or file, then the function returns true if and only if the file system object has the given type, or if it’s a symlink pointing to an object of that type. Passing symlink as type requires the path itself to be a symlink. Types other than those will cause an error.

Parameters:

path: file path to check (string)
type: the required type of the filesystem object (string)

Returns:

whether a filesystem object of type type exists at path. (boolean)

Since: 3.7.1

this blog post.

Parameters:

path: path to be made relative (string)
root: root path (string)
unsafe: whether to allow .. in the result. (boolean)

Returns:

contracted filename (string)

Since: 2.12

normalize (filepath)

Normalizes a path.

// makes sense only as part of a (Windows) network drive; elsewhere, multiple slashes are reduced to a single path.separator (platform dependent).
/ becomes path.separator (platform dependent).
./ is removed.
an empty path becomes .

Parameters:

filepath: path (string)

Returns:

The normalized path. (string)

Since: 2.12

split_search_path (search_path)

Takes a string and splits it on the search_path_separator character. Blank items are ignored on Windows, and converted to . on Posix. On Windows path elements are stripped of quotes.

Parameters:

search_path: platform-specific search path (string)

Returns:

list of directories in search path ({string,...})

Since: 2.12

Blocks into a hierarchical structure: a list of sections (each a Div with class “section” and first element a Header).

The optional opts argument can be a table; two settings are recognized: If number_sections is true, a number attribute containing the section number will be added to each Header. If base_level is an integer, then Header levels will be reorganized so that there are no gaps, with numbering levels shifted by the given value. Finally, an integer slide_level value triggers the creation of slides at that heading level.

Note that a WriterOptions object can be passed as the opts table; this will set the number_section and slide_level values to those defined on the command line.

Usage:

local blocks = {
  pandoc.Header(2, pandoc.Str 'first'),
  pandoc.Header(2, pandoc.Str 'second'),
}
local opts = PANDOC_WRITER_OPTIONS
local newblocks = pandoc.structure.make_sections(blocks, opts)

Parameters:

blocks: document blocks to process (Blocks|Pandoc)
opts: options (table)

Returns:

Since: 3.0

blocks

Returns:

Since: 3.0

Pandoc document into a ChunkedDoc.

Parameters:

doc

document to split (Pandoc)

opts

Splitting options.

The following options are supported:

`path_template`
:   template used to generate the chunks' filepaths
    `%n` will be replaced with the chunk number (padded with
    leading 0s to 3 digits), `%s` with the section number of
    the heading, `%h` with the (stringified) heading text,
    `%i` with the section identifier. For example,
    `"section-%s-%i.html"` might be resolved to
    `"section-1.2-introduction.html"`.

    Default is `"chunk-%n"` (string)

`number_sections`
:   whether sections should be numbered; default is `false`
    (boolean)

`chunk_level`
:   The heading level the document should be split into
    chunks. The default is to split at the top-level, i.e.,
    `1`. (integer)

`base_heading_level`
:   The base level to be used for numbering. Default is `nil`
    (integer|nil)

(table)

Returns:

Since: 3.0

toc_source

Returns:

Table of contents as a BulletList object (Block)

Since: 3.0

unique_identifier (inlines[, used[, exts]])

Generates a unique identifier from a list of inlines, similar to what’s generated by the auto_identifiers extension.

The method used to generated identifiers can be modified through ext, which is a list of format extensions.

It can be used to generate IDs similar to what the auto_identifiers extension provides.

Example:

 local used_ids = {}
 function Header (h)
   local id =
     pandoc.structure.unique_identifier(h.content, used_ids)
   used_ids[id] = true
   h.identifier = id
   return h
 end

Parameters:

inlines

Returns:

unique identifier (string)

Since: 3.8

Access to the system’s information and file functionality.

command (command, args[, input[, opts]])

Executes a system command with the given arguments and input on stdin.

Parameters:

command: command to execute (string)
args: command arguments ({string,...})
input: input on stdin (string)
opts: process options (table)

Returns:

Since: 3.7.1

make_directory (dirname[, create_parent])

Create a new directory which is initially empty, or as near to empty as the operating system allows. The function throws an error if the directory cannot be created, e.g., if the parent directory does not exist or if a directory of the same name is already present.

If the optional second parameter is provided and truthy, then all directories, including parent directories, are created as necessary.

Parameters:

dirname: name of the new directory (string)
create_parent: create parent directory if necessary (boolean)

Since: 2.19

rename (old, new)

Change the name of an existing path from old to new.

If old is a directory and new is a directory that already exists, then new is atomically replaced by the old directory. On Win32 platforms, this function fails if new is an existing directory.

If old does not refer to a directory, then neither may new.

Renaming may not work across file system boundaries or due to other system-specific reasons. It’s generally more robust to copy the source path to its destination before deleting the source.

Parameters:

old: original path (string)
new: new path (string)

Since: 3.7.1

with_environment (environment, callback)

Run an action within a custom environment. Only the environment variables given by environment will be set, when callback is called. The original environment is restored after this function finishes, even if an error occurs while running the callback action.

Parameters:

environment: Environment variables and their values to be set before running callback (table)
callback: Action to execute in the custom environment (function)

Returns:

The results of the call to callback.

Since: 2.7.3

with_temporary_directory (parent_dir, templ, callback)

Create and use a temporary directory inside the given directory. The directory is deleted after the callback returns.

Parameters:

parent_dir: Parent directory to create the directory in. If this parameter is omitted, the system’s canonical temporary directory is used. (string)
templ: Directory name template. (string)
callback: Function which takes the name of the temporary directory as its first argument. (function)

Returns:

The results of the call to callback.

Since: 2.8

with_working_directory (directory, callback)

Run an action within a different directory. This function will change the working directory to directory, execute callback, then switch back to the original working directory, even if an error occurs while running the callback action.

Parameters:

directory: Directory in which the given callback should be executed (string)
callback: Action to execute in the given directory (function)

Returns:

The results of the call to callback.

Since: 2.7.3

XDG Base Directory Specification.

Parameters:

xdg_directory_type

The type of the XDG directory or search path. Must be one of config, data, cache, state, datadirs, or configdirs.

Matching is case-insensitive, and underscores and XDG prefixes are ignored, so a value like XDG_DATA_DIRS is also acceptable.

The state directory might not be available, depending on the version of the underlying Haskell library. (string)

filepath

relative path that is appended to the path; ignored if the result is a list of search paths. (string)

Returns:

Either a single file path, or a list of search paths. (string|{string,...})

Since: 3.7.1

Plain-text document layouting.

Doc which is conditionally included only if it comes at the beginning of a line.

An example where this is useful is for escaping line-initial . in roff man.

Parameters:

text: content to include when placed after a break (string)

Returns:

Since: 2.18

doc

Returns:

Since: 2.18

Doc)

Since: 2.18

doc

Returns:

doc enclosed by {}. (Doc)

Since: 2.18

doc

Returns:

doc enclosed by []. (Doc)

Since: 2.18

doc

Returns:

doc, aligned centered in a block with max width chars per line. (Doc)

Since: 2.18

doc

Returns:

doc without trailing blanks (Doc)

Since: 2.18

docs: list of Docs (`{Doc,...}`)
sep

Returns:

Since: 2.18

doc

Returns:

doc enclosed by " chars (Doc)

Since: 2.18

doc

Returns:

Since: 2.18

doc

Returns:

doc prefixed by start on the first line, subsequent lines indented by ind spaces. (Doc)

Since: 2.18

Doc inside a start and end Doc.

Parameters:

contents: document (Doc)
start: document (Doc)
end: document (Doc)

Returns:

Since: 2.18

doc

Returns:

doc put into block with max width chars per line. (Doc)

Since: 2.18

Doc)

Since: 2.18

doc

Returns:

doc indented by ind spaces (Doc)

Since: 2.18

doc

Returns:

doc with leading blanks removed (Doc)

Since: 2.18

doc

Returns:

same as input, but non-reflowable (Doc)

Since: 2.18

doc

Returns:

doc enclosed by (). (Doc)

Since: 2.18

doc

Returns:

Since: 2.18

doc

Returns:

Since: 2.18

doc

Returns:

doc, right aligned in a block with max width chars per line. (Doc)

Since: 2.18

Doc)

Since: 2.18

Doc. The text is reflowed on breakable spaces to match the given line length. Text is not reflowed if the line length parameter is omitted or nil.

Parameters:

doc: document (Doc)
colwidth: Maximum number of characters per line. A value of nil, the default, means that the text is not reflown. (integer)
style: Whether to generate plain text or ANSI terminal output. Must be either 'plain' or 'ansi'. Defaults to 'plain'. (string)

Returns:

Since: 2.18

doc

Returns:

true iff doc is the empty document, false otherwise. (boolean)

Since: 2.18

doc

Returns:

doc height (integer|string)

Since: 2.18

Doc when reflowed at breakable spaces.

Parameters:

doc: document (Doc)

Returns:

minimal possible width (integer|string)

Since: 2.18

Doc as number of characters.

Parameters:

doc: document (Doc)

Returns:

doc width (integer|string)

Since: 2.18

doc

Returns:

column number (integer|string)

Since: 2.18

Doc in boldface.

Parameters:

doc: document (Doc)

Returns:

Since: 3.4.1

Doc in italics.

Parameters:

doc: document (Doc)

Returns:

Since: 3.4.1

Doc.

Parameters:

doc: document (Doc)

Returns:

Since: 3.4.1

Doc.

Parameters:

doc: document (Doc)

Returns:

Since: 3.4.1

doc

Returns:

Since: 3.4.1

doc

Returns:

Since: 3.4.1

above.

Scaffolding for custom writers.

-- uppercase all regular text in a document:
function Str (s)
  s.text = pandoc.text.upper(s.text)
  return s
end

fromencoding (s[, encoding])

Converts a string to UTF-8. The encoding parameter specifies the encoding of the input string. On Windows, that parameter defaults to the current ANSI code page; on other platforms the function will try to use the file system’s encoding.

The set of known encodings is system dependent, but includes at least UTF-8, UTF-16BE, UTF-16LE, UTF-32BE, and UTF-32LE. Note that the default code page on Windows is available through CP0.

Parameters:

s: string to be converted (string)
encoding: target encoding (string)

Returns:

Since: 3.0

subscript (input)

Tries to convert the string into a Unicode subscript version of the string. Returns nil if not all characters of the input can be mapped to a subscript Unicode character. Supported characters include numbers, parentheses, and plus/minus.

Parameters:

input: string to convert to subscript characters (string)

Returns:

Subscript version of the input, or nil if not all characters could be converted. (string|nil)

Since: 3.8

superscript (input)

Tries to convert the string into a Unicode superscript version of the string. Returns nil if not all characters of the input can be mapped to a superscript Unicode character. Supported characters include numbers, parentheses, and plus/minus.

Parameters:

input: string to convert to superscript characters (string)

Returns:

Superscript version of the input, or nil if not all characters could be converted. (string|nil)

Since: 3.8

toencoding (s[, enc])

Converts a UTF-8 string to a different encoding. The encoding parameter defaults to the current ANSI code page on Windows; on other platforms it will try to guess the file system’s encoding.

Parameters:

s: UTF-8 string (string)
enc: target encoding (string)

Returns:

re-encoded string (string)

Since: 3.0

Doc, string, boolean, or table as values, where the table can be either be a list of the aforementioned types, or a nested context.

Parameters:

template: template to apply (Template)
context: variable values (table)

Returns:

Since: 3.0

Template object usable by pandoc.

If the templates_path parameter is specified, then it should be the file path associated with the template. It is used when checking for partials. Partials will be taken only from the default data files if this parameter is omitted.

An error is raised if compilation fails.

Parameters:

template: template string (string)
templates_path: parameter to determine a default path and extension for partials; uses the data files templates path by default. (string)

Returns:

Since: 2.17

get (filename)

Retrieve text for a template.

This function first checks the resource paths for a file of this name; if none is found, the templates directory in the user data directory is checked. Returns the content of the file, or throws an error if no file is found.

Parameters:

filename: name of the template (string)

Returns:

content of template file (string)

Since: 3.2.1

Meta data, using the given functions to convert Blocks and Inlines to Doc values.

Parameters:

meta: document metadata (Meta)
blocks_writer: converter from Blocks to Doc values (function)
inlines_writer: converter from Inlines to Doc values (function)

Returns:

Since: 3.0

version_specifier

Returns:

Since: 2.7.3

Source items.

Pandoc’s text readers expect the input text to be paired with information on where the text originated, e.g., a file name. This abstraction is provided via the Sources type.

Pandoc accepts a range of objects wherever a Sources list is expected:

a list of Source items;
a simple string, which becomes an unnamed source;
a list of table objects, where each table contains the fields name (the filepath) and text (the file contents)

A Sources list can be converted to a string via the default tostring Lua function. This will concatenate all source items.

Parameters:

srcs: sources (string|{string,...}|table)

Returns:

new Sources object ({Source,...})

Since: 3.9.1

self

Returns:

Returns no result, and throws an error if this version is older than reference.

Functions to create, modify, and extract files from zip archives.

The module can be called as a function, in which case it behaves like the zip function described below.

Zip options are optional; when defined, they must be a table with any of the following keys:

recursive: recurse directories when set to true;
verbose: print info messages to stdout;
destination: the value specifies the directory in which to extract;
location: value is used as path name, defining where files are placed.
preserve_symlinks: Boolean value, controlling whether symbolic links are preserved as such. This option is ignored on Windows.