Pandoc Lua Filters

Introduction

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)returnpandoc.SmallCaps(elem.content)end,}

or equivalently,

function Strong(elem)returnpandoc.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, saysmallcaps.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 filter structure

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 filecurrent-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 list of filters. The filters in that list are called sequentially, each on the result of the previous 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, orPandoc). (That is why the two examples above are equivalent.)

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 andBlock. Each matches elements of the respective type.

Elements without matching functions are left untouched.

Seemodule documentation for a list of pandoc elements.

Filters on element sequences

For some filtering tasks, it is necessary to know the order in which elements occur in the document. It is not enough then to inspect a single element at a time.

There are two special function names, which can be used to define filters on lists of blocks or lists of inlines.

Inlines (inlines): If present in a filter, this function will be called on all lists of inline elements, like the content of aPara (paragraph) block, or the description of anImage. Theinlines argument passed to the function will be aList ofInline elements for each call.
Blocks (blocks): If present in a filter, this function will be called on all lists of block elements, like the content of aMetaBlocks meta element block, on each item of a list, and the main content of thePandoc document. Theblocks argument passed to the function will be aList ofBlock elements for each call.

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 arenot 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.

Traversal order

The traversal order of filters can be selected by setting the keytraverse to either'topdown' or'typewise'; the default is'typewise'.

Example:

localfilter={traverse='topdown',-- ... filter functions ...}returnfilter

Support for this was added in pandoc 2.17; previous versions ignore thetraverse setting.

Typewise traversal

Element filter functions within a filter set are called in a fixed order, skipping any which are not present:

functions forInline elements,
theInlines filter function,
functions forBlock elements ,
theBlocks filter function,
theMeta filter function, and last
thePandoc filter function.

It is still possible to force a different order by explicitly returning multiple filter sets. For example, if the filter forMeta is to be run before that forStr, one can write

-- ... filter definitions ...return{{Meta=Meta},-- (1){Str=Str}-- (2)}

Filter sets are applied in the order in which they are returned. All functions in set (1) are thus run before those in (2), causing the filter function forMeta to be run before the filtering ofStr elements is started.

Topdown traversal

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 returningfalse 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)returnn,falseend

Global variables

Pandoc passes additional data to Lua filters by setting global variables.

FORMAT

The globalFORMAT 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

Table of the options which were provided to the parser. (ReaderOptions)

PANDOC_WRITER_OPTIONS

Table of the options that will be passed to the writer. While the object can be modified, the changes willnot be picked up by pandoc. (WriterOptions)

Accessing this variable incustom writers isdeprecated. Starting with pandoc 3.0, it is set to a placeholder value (the default options) in custom writers. Access to the actual writer options is provided via theWriter orByteStringWriter function, to which the options are passed as the second function argument.

Since: pandoc 2.17

PANDOC_VERSION

Contains the pandoc version as aVersion object which behaves like a numerically indexed table, most significant number first. E.g., for pandoc 2.7.3, the value of the variable is equivalent to a table{2, 7, 3}. Usetostring(PANDOC_VERSION) to produce a version string. This variable is also set in custom writers.

PANDOC_API_VERSION

Contains the version of the pandoc-types API against which pandoc was compiled. It is given as a numerically indexed table, most significant number first. E.g., if pandoc was compiled against pandoc-types 1.17.3, then the value of the variable will behave like the table{1, 17, 3}. Usetostring(PANDOC_API_VERSION) to produce a version string. This variable is also set in custom writers.

PANDOC_SCRIPT_FILE

The name used to involve the filter. This value can be used to find files relative to the script file. This variable is also set in custom writers.

PANDOC_STATE

The state shared by all readers and writers. It is used by pandoc to collect and pass information. The value of this variable is of typeCommonState and is read-only.

pandoc

Thepandoc module, described in the next section, is available through the globalpandoc. The other modules described herein are loaded as subfields under their respective name.

lpeg

This variable holds thelpeg module, a package based on Parsing Expression Grammars (PEG). It provides excellent parsing utilities and is documented on the officialLPeg homepage. Pandoc uses a built-in version of the library, unless it has been configured by the package maintainer to rely on a system-wide installation.

Note that the result ofrequire 'lpeg' is not necessarily equal to this value; therequire mechanism prefers the system’s lpeg library over the built-in version.

re

Contains the LPeg.re module, which is built on top of LPeg and offers an implementation of aregex engine. Pandoc uses a built-in version of the library, unless it has been configured by the package maintainer to rely on a system-wide installation.

Note that the result ofrequire 're is not necessarily equal to this value; therequire mechanism prefers the system’s lpeg library over the built-in version.

Pandoc Module

Thepandoc 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 variablepandoc 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 creation

Element creator functions likeStr,Para, andPandoc 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.

Exposed pandoc functionality

Some pandoc functions have been made available in Lua:

walk_block andwalk_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;
thepandoc.mediabag module allows access to the “mediabag,” which stores binary content such as images that may be included in the final document;
thepandoc.utils module contains various utility functions.

Lua interpreter initialization

Initialization of pandoc’s Lua interpreter can be controlled by placing a fileinit.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 toinit.lua. The snippet adds all Unicode-aware functions defined in thetext module to the defaultstring module, prefixed with the stringuc_.

forname,fninpairs(require'text')dostring['uc_'..name]=fnend

This makes it possible to apply these functions on strings using colon syntax (mystring:uc_upper()).

Debugging Lua filters

Many errors can be avoided by performing static analysis.luacheck may be used for this purpose. A Luacheck configuration file for pandoc filters is available athttps://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 athttps://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 packagemobdebug. 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 addmobdebug and its dependencyluasocket usingluarocks. ZeroBrane can use your Lua 5.4 install by addingpath.lua = "/path/to/your/lua" in your ZeroBrane settings file. Next, open your Lua filter in ZeroBrane, and addrequire('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.

Common pitfalls

AST elements not updated

A filtered element will only be updated if the filter function returns a new element to replace it. A function like the below has no effect, as the function returns no value:

function Str(str)str.text=string.upper(str.text)end

The correct version would be

function Str(str)str.text=string.upper(str.text)returnstrend

Pattern behavior is locale dependent

The character classes in Lua’s pattern library depend on the current locale: E.g., the character© will be treated as punctuation, and matched by the pattern%p, on CP-1252 locales, but not on systems using a UTF-8 locale.

A reliable way to ensure unified handling of patterns and character classes is to use the “C” locale by addingos.setlocale 'C' to the top of the Lua script.

String library is not Unicode aware

Lua’sstring library treats each byte as a single character. A function likestring.upper will not have the intended effect when applied to words with non-ASCII characters. Similarly, a pattern like[☃] will matchany of the bytes\240,\159,\154, and\178, butwon’t match the “snowman” Unicode character.

Use thepandoc.text module for Unicode-aware transformation, and consider using using the lpeg or re library for pattern matching.

Examples

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

Macro substitution

The following filter converts the string{{helloworld}} into emphasized text “Hello, World”.

return{{Str=function(elem)ifelem.text=="{{helloworld}}"thenreturnpandoc.Emph{pandoc.Str"Hello, World"}elsereturnelemendend,}}

Center images in LaTeX and HTML output

For LaTeX, wrap an image in LaTeX snippets which cause the image to be centered horizontally. In HTML, the image element’s style attribute is used to achieve centering.

-- Filter images with this function if the target format is LaTeX.ifFORMAT:match'latex'thenfunction Image(elem)-- Surround all images with image-centering raw LaTeX.return{pandoc.RawInline('latex','\\hfill\\break{\\centering'),elem,pandoc.RawInline('latex','\\par}')}endend-- Filter images with this function if the target format is HTMLifFORMAT:match'html'thenfunction Image(elem)-- Use CSS style to center imageelem.attributes.style='margin:auto; display: block;'returnelemendend

Setting the date in the metadata

This filter sets the date in the document’s metadata to the current date, if a date isn’t already set:

function Meta(m)ifm.date==nilthenm.date=os.date("%B %e, %Y")returnmendend

Remove spaces before citations

This filter removes all spaces preceding an “author-in-text” citation. In Markdown, author-in-text citations (e.g.,@citekey), must be preceded by a space. If these spaces are undesired, they must be removed with a filter.

localfunction is_space_before_author_in_text(spc,cite)returnspcandspc.t=='Space'andciteandcite.t=='Cite'-- there must be only a single citation, and it must have-- mode 'AuthorInText'and#cite.citations==1andcite.citations[1].mode=='AuthorInText'endfunction Inlines(inlines)-- Go from end to start to avoid problems with shifting indices.fori=#inlines-1,1,-1doif is_space_before_author_in_text(inlines[i],inlines[i+1])theninlines:remove(i)endendreturninlinesend

Replacing placeholders with their metadata value

Lua filter functions are run in the order

Inlines → Blocks → Meta → Pandoc.

Passing information from a higher level (e.g., metadata) to a lower level (e.g., inlines) is still possible by using two filters living in the same file:

localvars={}function get_vars(meta)fork,vinpairs(meta)doifpandoc.utils.type(v)=='Inlines'thenvars["%"..k.."%"]={table.unpack(v)}endendendfunction replace(el)ifvars[el.text]thenreturnpandoc.Span(vars[el.text])elsereturnelendendreturn{{Meta=get_vars},{Str=replace}}

If the contents of fileoccupations.md is

---name: Samuel Q. Smithoccupation: Professor of Oenology---Name:   %name%Occupation:   %occupation%

then runningpandoc --lua-filter=meta-vars.lua occupations.md will output:

<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>

Modifying pandoc’s`MANUAL.txt` for man pages

This is the filter we use when convertingMANUAL.txt to man pages. It converts level-1 headers to uppercase (usingwalk 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' functionlocaltext=pandoc.textfunction Header(el)ifel.level==1thenreturnel:walk{Str=function(el)returnpandoc.Str(text.upper(el.text))end}endendfunction Link(el)returnel.contentendfunction Note(el)return{}end

Creating a handout from a paper

This filter extracts all the numbered examples, section headers, block quotes, and figures from a document, in addition to any divs with classhandout. (Note that only blocks at the “outer level” are included; this ignores blocks inside nested constructs, like list items.)

-- creates a handout from an article, using its headings,-- blockquotes, numbered examples, figures, and any-- Divs with class "handout"function Pandoc(doc)localhblocks={}fori,elinpairs(doc.blocks)doif(el.t=="Div"andel.classes[1]=="handout")or(el.t=="BlockQuote")or(el.t=="OrderedList"andel.style=="Example")or(el.t=="Para"and#el.c==1andel.c[1].t=="Image")or(el.t=="Header")thentable.insert(hblocks,el)endendreturnpandoc.Pandoc(hblocks,doc.meta)end

Counting words in a document

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 thanwc -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 documentwords=0wordcount={Str=function(el)-- we don't count a word if it's entirely punctuation:ifel.text:match("%P")thenwords=words+1endend,Code=function(el)_,n=el.text:gsub("%S+","")words=words+nend,CodeBlock=function(el)_,n=el.text:gsub("%S+","")words=words+nend}function Pandoc(el)-- skip metadata, just count body:el.blocks:walk(wordcount)print(words.." words in body")os.exit(0)end

Converting ABC code to music notation

This filter replaces code blocks with classabc with images created by running their contents throughabcm2ps and ImageMagick’sconvert. (For more on ABC notation, seehttps://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-resourceslocalfiletypes={html={"png","image/png"},latex={"pdf","application/pdf"}}localfiletype=filetypes[FORMAT][1]or"png"localmimetype=filetypes[FORMAT][2]or"image/png"localfunction abc2eps(abc,filetype)localeps=pandoc.pipe("abcm2ps",{"-q","-O","-","-"},abc)localfinal=pandoc.pipe("convert",{"-",filetype..":-"},eps)returnfinalendfunction CodeBlock(block)ifblock.classes[1]=="abc"thenlocalimg= abc2eps(block.text,filetype)localfname=pandoc.sha1(img).."."..filetypepandoc.mediabag.insert(fname,mimetype,img)returnpandoc.Para{pandoc.Image({pandoc.Str("abc tune")},fname)}endend

Building images with TikZ

This filter converts raw LaTeX TikZ environments into images. It works with both PDF and HTML output. The TikZ code is compiled to an image usingpdflatex, and the image is converted from pdf to svg format usingpdf2svg, 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.)

localsystem=require'pandoc.system'localtikz_doc_template=[[\documentclass{standalone}\usepackage{xcolor}\usepackage{tikz}\begin{document}\nopagecolor%s\end{document}]]localfunction tikz2image(src,filetype,outfile)system.with_temporary_directory('tikz2image',function(tmpdir)system.with_working_directory(tmpdir,function()localf=io.open('tikz.tex','w')f:write(tikz_doc_template:format(src))f:close()os.execute('pdflatex tikz.tex')iffiletype=='pdf'thenos.rename('tikz.pdf',outfile)elseos.execute('pdf2svg tikz.pdf '..outfile)endend)end)endextension_for={html='svg',html4='svg',html5='svg',latex='pdf',beamer='pdf'}localfunction file_exists(name)localf=io.open(name,'r')iff~=nilthenio.close(f)returntrueelsereturnfalseendendlocalfunction starts_with(start,str)returnstr:sub(1,#start)==startendfunction RawBlock(el)if starts_with('\\begin{tikzpicture}',el.text)thenlocalfiletype=extension_for[FORMAT]or'svg'localfbasename=pandoc.sha1(el.text)..'.'..filetypelocalfname=system.get_working_directory()..'/'..fbasenameifnot file_exists(fname)then      tikz2image(el.text,filetype,fname)endreturnpandoc.Para({pandoc.Image({},fbasename)})elsereturnelendend

Example of use:

pandoc --lua-filter tikz.lua -s -o cycle.html <<EOFHere 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

Lua type reference

This section describes the types of objects available to Lua filters. See thepandoc module for functions to create these objects.

Shared Properties

`clone`

clone ()

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

Usage:

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

Pandoc

Pandoc document

Values of this type can be created with thepandoc.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)

walk

walk(self, lua_filter)

Applies a Lua filter to the Pandoc element. Just as for full-document filters, the order in which elements are traversed can be controlled by setting thetraverse field of the filter; see the section ontraversal 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:

filtered document (Pandoc)

Usage:

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

MetaValue

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

The corresponding constructorspandoc.MetaBool,pandoc.MetaString,pandoc.MetaInlines,pandoc.MetaBlocks,pandoc.MetaList, andpandoc.MetaMap can be used to ensure that a value is treated in the intended way. E.g., an empty table is normally treated as aMetaMap, but can be made into an emptyMetaList by callingpandoc.MetaList{}. However, the same can be accomplished by using the generic functions likepandoc.List,pandoc.Inlines, orpandoc.Blocks.

Use the functionpandoc.utils.type to get the type of a metadata value.

Block

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

Common methods

walk

walk(self, lua_filter)

Applies a Lua filter to the block element. Just as for full-document filters, the order in which elements are traversed can be controlled by setting thetraverse field of the filter; see the section ontraversal 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 theself 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:

filtered block (Block)

Usage:

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

BlockQuote

A block quote element.

Values of this type can be created with thepandoc.BlockQuote constructor.

Fields:

content: block content (Blocks)
tag,t: the literalBlockQuote (string)

BulletList

A bullet list.

Values of this type can be created with thepandoc.BulletList constructor.

Fields:

content: list items (List of items, i.e.,List ofBlocks)
tag,t: the literalBulletList (string)

CodeBlock

Block of code.

Values of this type can be created with thepandoc.CodeBlock constructor.

Fields:

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

DefinitionList

Definition list, containing terms and their explanation.

Values of this type can be created with thepandoc.DefinitionList constructor.

Fields:

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

Div

Generic block container with attributes.

Values of this type can be created with thepandoc.Div constructor.

Fields:

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

Figure

Figure with caption and arbitrary block contents.

Values of this type can be created with thepandoc.Figure constructor.

Fields:

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

Header

Creates a header element.

Values of this type can be created with thepandoc.Header constructor.

Fields:

level: header level (integer)
content: inline content (Inlines)
attr: element attributes (Attr)
identifier: alias forattr.identifier (string)
classes: alias forattr.classes (List of strings)
attributes: alias forattr.attributes (Attributes)
tag,t: the literalHeader (string)

HorizontalRule

A horizontal rule.

Values of this type can be created with thepandoc.HorizontalRule constructor.

Fields:

tag,t: the literalHorizontalRule (string)

LineBlock

A line block, i.e. a list of lines, each separated from the next by a newline.

Values of this type can be created with thepandoc.LineBlock constructor.

Fields:

content: inline content (List of lines, i.e. List ofInlines)
tag,t: the literalLineBlock (string)

OrderedList

An ordered list.

Values of this type can be created with thepandoc.OrderedList constructor.

Fields:

content: list items (List of items, i.e.,List ofBlocks)
listAttributes: list parameters (ListAttributes)
start: alias forlistAttributes.start (integer)
style: alias forlistAttributes.style (string)
delimiter: alias forlistAttributes.delimiter (string)
tag,t: the literalOrderedList (string)

Para

A paragraph.

Values of this type can be created with thepandoc.Para constructor.

Fields:

content: inline content (Inlines)
tag,t: the literalPara (string)

Plain

Plain text, not a paragraph.

Values of this type can be created with thepandoc.Plain constructor.

Fields:

content: inline content (Inlines)
tag,t: the literalPlain (string)

RawBlock

Raw content of a specified format.

Values of this type can be created with thepandoc.RawBlock constructor.

Fields:

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

Table

A table.

Values of this type can be created with thepandoc.Table constructor.

Fields:

attr: table attributes (Attr)
caption: table caption (Caption)
colspecs: column specifications, i.e., alignments and widths (List ofColSpecs)
head: table head (TableHead)
bodies: table bodies (List ofTableBodys)
foot: table foot (TableFoot)
identifier: alias forattr.identifier (string)
classes: alias forattr.classes (List of strings)
attributes: alias forattr.attributes (Attributes)
tag,t: the literalTable (string)

Atable cell is a list of blocks.

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

Blocks

List ofBlock elements, with the same methods as a genericList. 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 ofBlock (or Block-like) values is used directly;
a singleInlines value is wrapped into aPlain element;
string values are turned into anInlines value by splitting the string into words (seeInlines), and then wrapping the result into a Plain singleton.

Methods

Lists of typeBlocks share all methods available in generic lists, see thepandoc.List module.

Additionally, the following methods are available on Blocks values:

walk

walk(self, lua_filter)

Applies a Lua filter to the Blocks list. Just as for full-document filters, the order in which elements are traversed can be controlled by setting thetraverse field of the filter; see the section ontraversal 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:

filtered list (Blocks)

Usage:

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

Inline

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

Common methods

walk

walk(self, lua_filter)

Applies a Lua filter to the Inline element. Just as for full-document filters, the order in which elements are traversed can be controlled by setting thetraverse field of the filter; see the section ontraversal 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 theself 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,}

Cite

Citation.

Values of this type can be created with thepandoc.Cite constructor.

Fields:

content: (Inlines)
citations: citation entries (List ofCitations)
tag,t: the literalCite (string)

Code

Inline code

Values of this type can be created with thepandoc.Code constructor.

Fields:

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

Emph

Emphasized text

Values of this type can be created with thepandoc.Emph constructor.

Fields:

content: inline content (Inlines)
tag,t: the literalEmph (string)

Image

Image: alt text (list of inlines), target

Values of this type can be created with thepandoc.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 forattr.identifier (string)
classes: alias forattr.classes (List of strings)
attributes: alias forattr.attributes (Attributes)
tag,t: the literalImage (string)

LineBreak

Hard line break

Values of this type can be created with thepandoc.LineBreak constructor.

Fields:

tag,t: the literalLineBreak (string)

Link

Hyperlink: alt text (list of inlines), target

Values of this type can be created with thepandoc.Link constructor.

Fields:

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

Math

TeX math (literal)

Values of this type can be created with thepandoc.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 literalMath (string)

Note

Footnote or endnote

Values of this type can be created with thepandoc.Note constructor.

Fields:

content: (Blocks)
tag,t: the literalNote (string)

Quoted

Quoted text

Values of this type can be created with thepandoc.Quoted constructor.

Fields:

quotetype: type of quotes to be used; one ofSingleQuote orDoubleQuote (string)
content: quoted text (Inlines)
tag,t: the literalQuoted (string)

RawInline

Raw inline

Values of this type can be created with thepandoc.RawInline constructor.

Fields:

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

SmallCaps

Small caps text

Values of this type can be created with thepandoc.SmallCaps constructor.

Fields:

content: (Inlines)
tag,t: the literalSmallCaps (string)

SoftBreak

Soft line break

Values of this type can be created with thepandoc.SoftBreak constructor.

Fields:

tag,t: the literalSoftBreak (string)

Space

Inter-word space

Values of this type can be created with thepandoc.Space constructor.

Fields:

tag,t: the literalSpace (string)

Span

Generic inline container with attributes

Values of this type can be created with thepandoc.Span constructor.

Fields:

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

Str

Text

Values of this type can be created with thepandoc.Str constructor.

Fields:

text: content (string)
tag,t: the literalStr (string)

Strikeout

Strikeout text

Values of this type can be created with thepandoc.Strikeout constructor.

Fields:

content: inline content (Inlines)
tag,t: the literalStrikeout (string)

Strong

Strongly emphasized text

Values of this type can be created with thepandoc.Strong constructor.

Fields:

content: inline content (Inlines)
tag,t: the literalStrong (string)

Subscript

Subscripted text

Values of this type can be created with thepandoc.Subscript constructor.

Fields:

content: inline content (Inlines)
tag,t: the literalSubscript (string)

Superscript

Superscripted text

Values of this type can be created with thepandoc.Superscript constructor.

Fields:

content: inline content (Inlines)
tag,t: the literalSuperscript (string)

Underline

Underlined text

Values of this type can be created with thepandoc.Underline constructor.

Fields:

content: inline content (Inlines)
tag,t: the literalUnderline (string)

Inlines

List ofInline elements, with the same methods as a genericList. 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 ofInline (or Inline-like) values are used directly;
singleInline values are converted into a list containing just that element;
String values are split into words, converting line breaks intoSoftBreak elements, and other whitespace characters intoSpaces.

Methods

Lists of typeInlines share all methods available in generic lists, see thepandoc.List module.

Additionally, the following methods are available onInlines values:

walk

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 itemsand to the list itself. Returns a (deep) copy on which the filter has been applied: the original list is left untouched.

Parameters:

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

Result:

filtered list (Inlines)

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,}

Element components

Attr

A set of element attributes. Values of this type can be created with thepandoc.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 theattr 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)

Attributes

List of key/value pairs. Values can be accessed by using keys as indices to the list table.

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

Caption

The caption of a table, with an optional short caption.

Fields:

long: long caption (Blocks)
short: short caption (Inlines)

Cell

A table cell.

Fields:

attr: cell attributes
alignment: individual cell alignment (Alignment).
contents: cell contents (Blocks).
col_span: number of columns spanned by the cell; the width of the cell in columns (integer).
row_span: number of rows spanned by the cell; the height of the cell in rows (integer).
identifier: alias forattr.identifier (string)
classes: alias forattr.classes (List of strings)
attributes: alias forattr.attributes (Attributes)

Citation

Single citation entry

Values of this type can be created with thepandoc.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 ofAuthorInText,SuppressAuthor, orNormalCitation (string)
prefix: citation prefix (Inlines)
suffix: citation suffix (Inlines)
note_num: note number (integer)
hash: hash (integer)

ColSpec

Column alignment and width specification for a single table column.

This is a pair, i.e., a plain table, with the following components:

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

ListAttributes

List attributes

Values of this type can be created with thepandoc.ListAttributes constructor.

Fields:

start: number of the first list item (integer)
style: style used for list numbers; possible values areDefaultStyle,Example,Decimal,LowerRoman,UpperRoman,LowerAlpha, andUpperAlpha (string)
delimiter: delimiter of list numbers; one ofDefaultDelim,Period,OneParen, andTwoParens (string)

Row

A table row.

Fields:

attr: element attributes (Attr)
cells: list of table cells (List ofCells)

TableBody

A body of a table, with an intermediate head and the specified number of row header columns.

Fields:

attr: table body attributes (Attr)
body: table body rows (List ofRows)
head: intermediate head (List ofRows)
row_head_columns: number of columns taken up by the row head of each row of aTableBody. The row body takes up the remaining columns.

TableFoot

The foot of a table.

Fields:

attr: element attributes (Attr)
rows: list of rows (List ofRows)
identifier: alias forattr.identifier (string)
classes: alias forattr.classes (List of strings)
attributes: alias forattr.attributes (Attributes)

TableHead

The head of a table.

Fields:

attr: element attributes (Attr)
rows: list of rows (List ofRows)
identifier: alias forattr.identifier (string)
classes: alias forattr.classes (List of strings)
attributes: alias forattr.attributes (Attributes)

ReaderOptions

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 ofaccept-changes,reject-changes, andall-changes (string)

WriterOptions

Pandoc writer options

Fields:

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 ofpandoc --print-highlight-style=... for an example structure. The valuenil 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 keysmethod andurl. (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: Template to use (Template|nil)
toc_depth: Number of levels to include in TOC (integer)
top_level_division: Type of top-level divisions; one of ‘top-level-part’, ‘top-level-chapter’, ‘top-level-section’, or ‘top-level-default’. The prefixtop-level may be omitted when setting this value. (string)
variables: Variables to set in template; string-indexed table (table)
wrap_text: Option for wrapping text; one of ‘wrap-auto’, ‘wrap-none’, or ‘wrap-preserve’. Thewrap- prefix may be omitted when setting this value. (string)

CommonState

The state used by pandoc to collect information and make it available to readers and writers.

Fields:

input_files: List of input files from command line (List of strings)
output_file: Output file from command line (string or nil)
log: A list of log messages in reverse order (List ofLogMessages)
request_headers: Headers to add for HTTP requests; table with header names as keys and header contents as value (table)
resource_path: Path to search for resources like included images (List of strings)
source_url: Absolute URL or directory of first source file (string or nil)
user_data_dir: Directory to search for data files (string or nil)
trace: Whether tracing messages are issued (boolean)
verbosity: Verbosity level; one ofINFO,WARNING,ERROR (string)

Doc

Reflowable plain-text document. A Doc value can be rendered and reflown to fit a given column width.

Thepandoc.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')

Operators

`..`

Concatenate twoDoc elements.

`+`

Concatenate twoDocs, inserting a reflowable space between them.

`/`

Ifa andb areDoc elements, thena / b putsa aboveb.

`//`

Ifa andb areDoc elements, thena // b putsa aboveb, inserting a blank line between them.

List

A list is any Lua table with integer indices. Indices start at one, so ifalist = {'value'} thenalist[1] == 'value'.

Lists, when part of an element, or when generated during marshaling, are made instances of thepandoc.List type for convenience. Thepandoc.List type is defined in thepandoc.List module. See there for available methods.

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

LogMessage

A pandoc log message. Objects have no fields, but can be converted to a string viatostring.

SimpleTable

A simple table is a table structure which resembles the old (pre pandoc 2.10) Table type. Bi-directional conversion from and toTables is possible with thepandoc.utils.to_simple_table andpandoc.utils.from_simple_table function, respectively. Instances of this type can also be created directly with thepandoc.SimpleTable constructor.

Fields:

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

Template

Opaque type holding a compiled template.

Version

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

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

Comparisons are performed element-wise, i.e.

Version '1.12' > Version '1.9'

Values of this type can be created with thepandoc.types.Version constructor.

`must_be_at_least`

must_be_at_least(actual, expected [, error_message])

Raise an error message if the actual version is older than the expected version; does nothing ifactual is equal to or newer than the expected version.

Parameters:

actual: actual version specifier (Version)
expected: minimum expected version (Version)
error_message: optional error message template. The string is used as format string, with the expected and actual versions as arguments. Defaults to"expected version %s or newer, got %s".

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')

Chunk

Part of a document; usually chunks are each written to a separate file.

Fields:

heading: heading text (Inlines)
id: identifier (string)
level: level of topmost heading in chunk (integer)
number: chunk number (integer)
section_number: hierarchical section number (string)
path: target filepath for this chunk (string)
up: link to the enclosing section, if any (Chunk|nil)
prev: link to the previous section, if any (Chunk|nil)
next: link to the next section, if any (Chunk|nil)
unlisted: whether the section in this chunk should be listed in the TOC even if the chunk has no section number. (boolean)
contents: the chunk’s block contents (Blocks)

ChunkedDoc

A Pandoc document divided intoChunks.

The table of contents info in fieldtoc is rose-tree structure represented as a list. The node item is always placed at index0; subentries make up the rest of the list. Each node item contains the fieldstitle (Inlines),number (string|nil),id (string),path (string), andlevel (integer).

Fields:

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

Module pandoc

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.

Fields

readers

Set of formats that pandoc can parse. All keys in this table can be used as theformat value inpandoc.read. (table)

writers

Set of formats that pandoc can generate. All keys in this table can be used as theformat value inpandoc.write. (table)

Functions

Pandoc

Pandoc (blocks[, meta])

Parameters:

blocks: document contents (Blocks)
meta: document metadata (Meta)

Returns:

new Pandoc document (Pandoc)

MetaBlocks

MetaBlocks (content)

Creates a value to be used as a MetaBlocks value in meta data; creates a copy of the input list viapandoc.Blocks, discarding all non-list keys.

Parameters:

content: block content (Blocks)

Returns:

list of Block elements (Blocks)

MetaBool

MetaBool (bool)

Parameters:

bool: true or false (boolean)

Returns:

input, unchanged (boolean)

MetaInlines

MetaInlines (inlines)

Creates a value to be used as a MetaInlines value in meta data; creates a copy of the input list viapandoc.Inlines, discarding all non-list keys.

Parameters:

inlines: inline elements (Inlines)

Returns:

list of Inline elements (Inlines)

MetaList

MetaList (values)

Creates a value to be used as a MetaList in meta data; creates a copy of the input list viapandoc.List, discarding all non-list keys.

Parameters:

values: value, or list of values (MetaValue|{MetaValue,...})

Returns:

list of meta values (List)

MetaMap

MetaMap (key_value_map)

Creates a value to be used as a MetaMap in meta data; creates a copy of the input table, keeping only pairs with string keys and discards all other keys.

Parameters:

key_value_map: a string-indexed map of meta values (table)

Returns:

map of meta values (table)

MetaString

MetaString (s)

Creates a value to be used as a MetaString in meta data; this is the identity function for boolean values and exists only for completeness.

Parameters:

s: string value (string)

Returns:

unchanged input (string)

BlockQuote

BlockQuote (content)

Creates a block quote element

Parameters:

content: block content (Blocks)

Returns:

BlockQuote element (Block)

BulletList

BulletList (items)

Creates a bullet list.

Parameters:

items: list items ({Blocks,...})

Returns:

BulletList element (Block)

CodeBlock

CodeBlock (text[, attr])

Creates a code block element.

Parameters:

text: code string (string)
attr: element attributes (Attr)

Returns:

CodeBlock element (Block)

DefinitionList

DefinitionList (content)

Creates a definition list, containing terms and their explanation.

Parameters:

content: definition items ({{Inlines, {Blocks,...}},...})

Returns:

DefinitionList element (Block)

Div

Div (content[, attr])

Creates a div element

Parameters:

content: block content (Blocks)
attr: element attributes (Attr)

Returns:

Div element (Block)

Figure

Figure (content[, caption[, attr]])

Creates aFigure element.

Parameters:

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

Returns:

Figure object (Block)

Header

Header (level, content[, attr])

Creates a header element.

Parameters:

level: heading level (integer)
content: inline content (Inlines)
attr: element attributes (Attr)

Returns:

Header element (Block)

HorizontalRule

HorizontalRule ()

Creates a horizontal rule.

Returns:

HorizontalRule element (Block)

LineBlock

LineBlock (content)

Creates a line block element.

Parameters:

content: lines ({Inlines,...})

Returns:

LineBlock element (Block)

OrderedList

OrderedList (items[, listAttributes])

Creates an ordered list.

Parameters:

items: list items ({Blocks,...})
listAttributes: list parameters (ListAttributes)

Returns:

OrderedList element (Block)

Para

Para (content)

Creates a para element.

Parameters:

content: inline content (Inlines)

Returns:

Para element (Block)

Plain

Plain (content)

Creates a plain element.

Parameters:

content: inline content (Inlines)

Returns:

Plain element (Block)

RawBlock

RawBlock (format, text)

Creates a raw content block of the specified format.

Parameters:

format: format of content (string)
text: raw content (string)

Returns:

RawBlock element (Block)

Table

Table (caption, colspecs, head, bodies, foot[, attr])

Creates a table element.

Parameters:

caption: table caption (Caption)
colspecs: column alignments and widths ({ColSpec,...})
head: table head (TableHead)
bodies: table bodies ({TableBody,...})
foot: table foot (TableFoot)
attr: element attributes (Attr)

Returns:

Table element (Block)

Blocks

Blocks (block_like_elements)

Creates aBlocks list.

Parameters:

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

Returns:

list of block elements (Blocks)

Cite

Cite (Inlines, citations)

Creates a Cite inline element

Parameters:

Inlines: placeholder content (content)
citations: List of Citations ({Citation,...})

Returns:

cite element (Inline)

Code

Code (code[, attr])

Creates a Code inline element

Parameters:

code: code string (string)
attr: additional attributes (Attr)

Returns:

code element (Inline)

Emph

Emph (content)

Creates an inline element representing emphasized text.

Parameters:

content: inline content (Inlines)

Returns:

new object (Inline)

Image

Image (caption, src[, title[, attr]])

Creates an Image element

Parameters:

caption: text used to describe the image (Inlines)
src: path to the image file (string)
title: brief image description (string)
attr: image attributes (Attr)

Returns:

Image element (Inline)

LineBreak

LineBreak ()

Create a LineBreak inline element

Returns:

line break (Inline)

Link

Link (content, target[, title[, attr]])

Creates a link inline element, usually a hyperlink.

Parameters:

content: text for this link (Inlines)
target: the link target (string)
title: brief link description (string)
attr: link attributes (Attr)

Returns:

link element (Inline)

Math

Math (mathtype, text)

Creates a Math element, either inline or displayed.

Parameters:

mathtype: rendering specifier (MathType)
text: math content (string)

Returns:

math element (Inline)

Note

Note (content)

Creates a Note inline element

Parameters:

content: footnote block content (Blocks)

Returns:

note (Inline)

Quoted

Quoted (quotetype, content)

Creates a Quoted inline element given the quote type and quoted content.

Parameters:

quotetype: type of quotes (QuoteType)
content: inlines in quotes (Inlines)

Returns:

quoted element (Inline)

RawInline

RawInline (format, text)

Creates a raw inline element

Parameters:

format: format of content (string)
text: string content (string)

Returns:

raw inline element (Inline)

SmallCaps

SmallCaps (content)

Creates text rendered in small caps

Parameters:

content: inline content (Inlines)

Returns:

new object (Inline)

SoftBreak

SoftBreak ()

Creates a SoftBreak inline element.

Returns:

soft break (Inline)

Space

Space ()

Create a Space inline element

Returns:

new space (Inline)

Span

Span (content[, attr])

Creates a Span inline element

Parameters:

content: inline content (Inlines)
attr: additional attributes (Attr)

Returns:

Span object (Inline)

Str

Str (text)

Creates a Str inline element

Parameters:

text: (string)

Returns:

Str object (Inline)

Strikeout

Strikeout (content)

Creates text which is struck out.

Parameters:

content: inline content (Inlines)

Returns:

new object (Inline)

Strong

Strong (content)

Creates a Strong element, whose text is usually displayed in a bold font.

Parameters:

content: inline content (Inlines)

Returns:

new object (Inline)

Subscript

Subscript (content)

Creates a Subscript inline element

Parameters:

content: inline content (Inlines)

Returns:

new object (Inline)

Superscript

Superscript (content)

Creates a Superscript inline element

Parameters:

content: inline content (Inlines)

Returns:

new object (Inline)

Underline

Underline (content)

Creates an Underline inline element

Parameters:

content: inline content (Inlines)

Returns:

new object (Inline)

Inlines

Inlines (inline_like_elements)

Converts its argument into anInlines list:

copies a list ofInline elements into a fresh list; any strings within the list is treated aspandoc.Str(s);
turns a singleInline into a singleton list;
splits a string intoStr-wrapped words, treating interword spaces asSpaces orSoftBreaks.

Parameters:

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

Returns:

list of inline elements (Inlines)

Attr

Attr ([identifier[, classes[, attributes]]])

Create a new set of attributes

Parameters:

identifier: element identifier (string|table|Attr)
classes: element classes ({string,...})
attributes: table containing string keys and values (table|AttributeList)

Returns:

new Attr object (Attr)

Cell

Cell (blocks[, align[, rowspan[, colspan[, attr]]]])

Create a new table cell.

Parameters:

blocks: cell contents (Blocks)
align: text alignment; defaults toAlignDefault (Alignment)
rowspan: number of rows occupied by the cell; defaults to1 (integer)
colspan: number of columns occupied by the cell; defaults to1 (integer)
attr: cell attributes (Attr)

Returns:

new Cell object (Cell)

AttributeList

AttributeList (attribs)

Parameters:

attribs: an attribute list (table|AttributeList)

Returns:

new AttributeList object (AttributeList)

Citation

Citation (id, mode[, prefix[, suffix[, note_num[, hash]]]])

Creates a single citation.

Parameters:

id: citation ID (e.g. BibTeX key) (string)
mode: citation rendering mode (CitationMode)
prefix: (Inlines)
suffix: (Inlines)
note_num: note number (integer)
hash: hash number (integer)

Returns:

new citation object (Citation)

ListAttributes

ListAttributes ([start[, style[, delimiter]]])

Creates a new ListAttributes object.

Parameters:

start: number of the first list item (integer)
style: style used for list numbering (string)
delimiter: delimiter of list numbers (string)

Returns:

new ListAttributes object (ListAttributes)

Row

Row ([cells[, attr]])

Creates a table row.

Parameters:

cells: list of table cells in this row ({Cell,...})
attr: row attributes (Attr)

Returns:

new Row object (Row)

TableFoot

TableFoot ([rows[, attr]])

Creates a table foot.

Parameters:

rows: list of table rows ({Row,...})
attr: table foot attributes (Attr)

Returns:

new TableFoot object (TableFoot)

TableHead

TableHead ([rows[, attr]])

Creates a table head.

Parameters:

rows: list of table rows ({Row,...})
attr: table head attributes (Attr)

Returns:

new TableHead object (TableHead)

SimpleTable

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

Usage:

local caption = "Overview"local aligns = {pandoc.AlignDefault, pandoc.AlignDefault}local widths = {0, 0} -- let pandoc determine col widthslocal 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: table caption (Inlines)
align: column alignments ({Alignment,...})
widths: relative column widths ({number,...})
header: table header row ({Blocks,...})
rows: table rows ({{Blocks,...},...})

Returns:

new SimpleTable object (SimpleTable)

Constants

AuthorInText

Author name is mentioned in the text.

See also:Table

AlignRight

Table cells right-aligned.

See also:Table

AlignCenter

Table cell content is centered.

See also:Table

AlignDefault

Table cells are alignment is unaltered.

See also:Table

DefaultDelim

Default list number delimiters are used.

See also:ListAttributes

Period

List numbers are delimited by a period.

See also:ListAttributes

OneParen

List numbers are delimited by a single parenthesis.

See also:ListAttributes

TwoParens

List numbers are delimited by a double parentheses.

See also:ListAttributes

DefaultStyle

List are numbered in the default style

See also:ListAttributes

Example

List items are numbered as examples.

See also:ListAttributes

Decimal

List are numbered using decimal integers.

See also:ListAttributes

LowerRoman

List are numbered using lower-case roman numerals.

See also:ListAttributes

UpperRoman

List are numbered using upper-case roman numerals

See also:ListAttributes

LowerAlpha

List are numbered using lower-case alphabetic characters.

See also:ListAttributes

UpperAlpha

List are numbered using upper-case alphabetic characters.

See also:ListAttributes

sha1

Alias forpandoc.utils.sha1 (DEPRECATED, usepandoc.utils.sha1 instead).

Other constructors

`ReaderOptions (opts)`

Creates a newReaderOptions value.

Parameters

opts: Either a table with a subset of the properties of aReaderOptions 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: newReaderOptions 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 (opts)`

Creates a newWriterOptions value.

Parameters

opts: Either a table with a subset of the properties of aWriterOptions 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: newWriterOptions 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}

Helper functions

`pipe (command, args, input)`

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 keyscommand,error_code, andoutput is thrown if the command exits with a non-zero error code.

Usage:

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

`walk_block (element, filter)`

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

`walk_inline (element, filter)`

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

`read (markup[, format[, reader_options]])`

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.

Theformat 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 fieldsformat (string) andextensions (table). Theextensions 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 inreader_options is ignored, as the function will always use the format extensions specified via theformat 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: options passed to the reader; may be a ReaderOptions object or a table with a subset of the keys and values of a ReaderOptions object; defaults to the default values documented in the manual. (ReaderOptions|table)

Returns: pandoc document (Pandoc)

Usage:

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

`write (doc[, format[, writer_options]])`

Converts a document to the given target format.

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

Parameters:

doc: document to convert (Pandoc)
format: format specification; defaults to"html". See the documentation ofpandoc.read for a complete description of this parameter. (string|table)
writer_options: options passed to the writer; may be a WriterOptions object or a table with a subset of the keys and values of a WriterOptions object; defaults to the default values documented in the manual. (WriterOptions|table)

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>")

`write_classic (doc[, writer_options])`

Runs a classic custom Lua writer, using the functions defined in the current environment.

Parameters:

doc: document to convert (Pandoc)
writer_options: options passed to the writer; may be aWriterOptions object or a table with a subset of the keys and values of a WriterOptions object; defaults to the default values documented in the manual. (WriterOptions|table)

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

Module pandoc.cli

Command line options and argument parsing.

Fields

default_options

Default CLI options, using a JSON-like representation. (table)

Functions

parse_options

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 globalarg.

Parameters:

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

Returns:

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

Since: 3.0

repl

repl ([env])

Starts a read-eval-print loop (REPL). The function returns all values of the last evaluated input. Exit the REPL by pressingctrl-d orctrl-c; pressF1 to get a list of all key bindings.

The REPL is started in the global namespace, unless theenv 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 variablescannot be accessed, unless they are explicitly passed via theenv 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

Module pandoc.utils

This module exposes internal pandoc functions and utility functions.

Functions

blocks_to_inlines

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: List ofBlock elements to be flattened. (Blocks)
sep: List ofInline elements inserted as separator between two consecutive blocks; defaults to{pandoc.LineBreak()}. (Inlines)

Returns:

(Inlines)

Since: 2.2.3

citeproc

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: document (Pandoc)

Returns:

processed document (Pandoc)

Since: 2.19.1

equals

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

from_simple_table

from_simple_table (simple_tbl)

Creates aTable block element from aSimpleTable. 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 methodssimple.caption = pandoc.SmallCaps(simple.caption)-- create normal table block againtable = pandoc.utils.from_simple_table(simple)

Parameters:

simple_tbl: (SimpleTable)

Returns:

table block element (Block)

Since: 2.11

make_sections

make_sections (number_sections, baselevel, blocks)

Converts a list ofBlock elements into sections.Divs will be created beginning at eachHeader and containing following content until the nextHeader of comparable level. Ifnumber_sections is true, anumber attribute will be added to eachHeader containing the section number. Ifbase_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 additionalnumber attribute containing the section number. (boolean)
baselevel: shift top-level headings to this level (integer|nil)
blocks: list of blocks to process (Blocks)

Returns:

blocks with sections (Blocks)

Since: 2.8

normalize_date

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 or nil)

Since: 2.0.6

references

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 withnocite) 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 asreferences metadata, which is one of the values used by pandoc and citeproc when generating bibliographies.

Usage:

-- Include all cited references in documentfunction Pandoc (doc)  doc.meta.references = pandoc.utils.references(doc)  doc.meta.bibliography = nil  return docend

Parameters:

doc: document (Pandoc)

Returns:

lift of references. (table)

Since: 2.17

run_json_filter

run_json_filter (doc, filter[, args])

Filter the given doc by passing it through a JSON filter.

Parameters:

doc: the Pandoc document to filter (Pandoc)
filter: filter to run (string)
args: list of arguments passed to the filter. Defaults to{FORMAT}. ({string,...})

Returns:

filtered document (Pandoc)

Since: 2.1.1

run_lua_filter

run_lua_filter (doc, filter[, env])

Filter the given doc by passing it through a Lua filter.

The filter will be run in the current Lua process.

Parameters:

doc: the Pandoc document to filter (Pandoc)
filter: filepath of the filter to run (string)
env: environment to load and run the filter in (table)

Returns:

filtered document (Pandoc)

Since: 3.2.1

sha1

sha1 (input)

Computes the SHA1 hash of the given string input.

Parameters:

input: (string)

Returns:

hexadecimal hash value (string)

Since: 2.0.6

stringify

stringify (element)

Converts the given element (Pandoc, Meta, Block, or Inline) into a string with all formatting removed.

Parameters:

element: some pandoc AST element (AST element)

Returns:

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

Since: 2.0.6

to_roman_numeral

to_roman_numeral (n)

Converts an integer < 4000 to uppercase roman numeral.

Usage:

local to_roman_numeral = pandoc.utils.to_roman_numerallocal 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

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 methodssimple.caption = pandoc.SmallCaps(simple.caption)-- create normal table block againtable = pandoc.utils.from_simple_table(simple)

Parameters:

tbl: a table (Block)

Returns:

SimpleTable object (SimpleTable)

Since: 2.11

type

type (value)

Pandoc-friendly version of Lua’s defaulttype 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 normaltype 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

Version

Version (v)

Creates a Version object.

Parameters:

v: version description (version string, list of integers, or integer)

Returns:

new Version object (Version)

Module pandoc.mediabag

Thepandoc.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 modulepandoc and can either be accessed via thepandoc.mediabag field, or explicitly required, e.g.:

local mb = require 'pandoc.mediabag'

Functions

delete

delete (filepath)

Removes a single entry from the media bag.

Parameters:

filepath: Filename of the item to deleted. The media bag will be left unchanged if no entry with the given filename exists. (string)

Since: 2.7.3

empty

empty ()

Clear-out the media bag, deleting all items.

Since: 2.7.3

fetch

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 retrievesource 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, ornil if the file was not found. (string)
Contents of the file, ornil if the file was not found. (string)

Since: 2.0

fill

fill (doc)

Fills the mediabag with the images in the given document. An image that cannot be retrieved will be replaced with a Span of class “image” that contains the image description.

Images for which the mediabag already contains an item will not be processed again.

Parameters:

doc: document from which to fill the mediabag (Pandoc)

Returns:

modified document (Pandoc)

Since: 2.19

insert

insert (filepath, mimetype, contents)

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

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; omit if unknown or unavailable. (string)
contents: the binary contents of the file. (string)

Since: 2.0

items

items ()

Returns an iterator triple to be used with Lua’s genericfor statement. The iterator returns the filepath, MIME type, and content of a media bag item on each invocation. Items are processed one-by-one to avoid excessive memory use.

This function should be used only when full access to all items, including their contents, is required. For all other cases,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

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 = 0for i = 1, #mb_items do    sum = sum + mb_items[i].lengthendprint(sum)

Returns:

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

Since: 2.0

lookup

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

write

write (dir[, fp])

Writes the contents of mediabag to the given target directory. Iffp 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 iffp 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

Module pandoc.List

This module defines pandoc’s list type. It comes with useful methods and convenience functions.

Constructor

pandoc.List([table]): Create a new List. If the optional argumenttable is given, set the metatable of that value topandoc.List. This is an alias forpandoc.List:new([table]).

Metamethods

`pandoc.List:__concat (list)`

Concatenates two lists.

Parameters:

list: second list concatenated to the first

Returns: a new list containing all elements from list1 and list2

`pandoc.List:__eq (a, b)`

Compares two lists for equality. The lists are taken as equal if and only if they are of the same type (i.e., have the same non-nil metatable), have the same length, and if all elements are equal.

Parameters:

a,b: any Lua object

Returns:

true if the two lists are equal,false otherwise.

Methods

`pandoc.List:at`

:at (index[, default])

Returns the element at the given index, ordefault 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 atindex, ordefault.

`pandoc.List:clone ()`

Returns a (shallow) copy of the list. (To get a deep copy of the list, usewalk with an empty filter.)

`pandoc.List:extend (list)`

Adds the given list to the end of this list.

Parameters:

list: list to appended

`pandoc.List:find (needle, init)`

Returns the value and index of the first occurrence of the given item.

Parameters:

needle: item to search for
init: index at which the search is started

Returns: first item equal to the needle, or nil if no such item exists.

`pandoc.List:find_if (pred, init)`

Returns the value and index of the first element for which the predicate holds true.

Parameters:

pred: the predicate function
init: index at which the search is started

Returns: first item for which `test` succeeds, or nil if no such item exists.

`pandoc.List:filter (pred)`

Returns a new list containing all items satisfying a given condition.

Parameters:

pred: condition items must satisfy.

Returns: a new list containing all items for which `test` was true.

`pandoc.List:includes (needle, init)`

Checks if the list has an item equal to the given needle.

Parameters:

needle: item to search for
init: index at which the search is started

Returns: true if a list item is equal to the needle, false otherwise

`pandoc.List:insert ([pos], value)`

Inserts elementvalue at positionpos in list, shifting elements to the next-greater index if necessary.

This function is identical totable.insert.

Parameters:

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

`pandoc.List:iter ([step])`

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 itemend

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:

iterator (function)

`pandoc.List:map (fn)`

Returns a copy of the current list by applying the given function to all elements.

Parameters:

fn: function which is applied to all list items.

`pandoc.List:new([table])`

Create a new List. If the optional argumenttable is given, set the metatable of that value topandoc.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

`pandoc.List:remove ([pos])`

Removes the element at positionpos, returning the value of the removed element.

This function is identical totable.remove.

Parameters:

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

Returns: the removed element

`pandoc.List:sort ([comp])`

Sorts list elements in a given order, in-place. Ifcomp 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 impliesnot 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.

This function is identical totable.sort.

Parameters:

comp: Comparison function as described above.

Module pandoc.format

Information about the formats supported by pandoc.

Functions

all_extensions

all_extensions (format)

Returns the list of all valid extensions for a format. No distinction is made between input and output; an extension can have an effect when reading a format but not when writing it, orvice versa.

Parameters:

format: format name (string)

Returns:

all extensions supported forformat (FormatExtensions)

Since: 3.0

default_extensions

default_extensions (format)

Returns the list of default extensions of the given format; this function does not check if the format is supported, it will return a fallback list of extensions even for unknown formats.

Parameters:

format: format name (string)

Returns:

default extensions enabled forformat (FormatExtensions)

Since: 3.0

extensions

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, withtrue indicating that the extension is enabled by default, whilefalse marks a supported extension that’s disabled.

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

Parameters:

format: format identifier (string)

Returns:

extensions config (table)

Since: 3.0

from_path

from_path (path)

Parameters:

path: file path, or list of paths (string|{string,...})

Returns:

format determined by heuristic (string|nil)

Since: 3.1.2

Module pandoc.image

Basic image querying functions.

Functions

size

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, anddpi_vert.

Theopts parameter, when given, should be either a WriterOptions object such asPANDOC_WRITER_OPTIONS, or a table with adpi entry. It affects the calculation for vector image formats such as SVG.

Parameters:

image: image data (string)
opts: writer options (WriterOptions|table)

Returns:

image size information or error message (table)

Since: 3.1.13

format

format (image)

Returns the format of an image as a lowercase string.

Formats recognized by pandoc includepng,gif,tiff,jpeg,pdf,svg,eps, andemf.

Parameters:

image: binary image data (string)

Returns:

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

Since: 3.1.13

Module pandoc.json

JSON module to work with JSON; based on the Aeson Haskell package.

Fields

null

Value used to represent thenull JSON value. (light userdata)

Functions

decode

decode (str[, pandoc_types])

Creates a Lua object from a JSON string. If the input can be decoded as representing anInline,Block,Pandoc,Inlines, orBlocks 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 JSONnull value becomesnull, 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 settingpandoc_types tofalse.

Parameters:

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

Returns:

decoded object (any)

Since: 3.1.1

encode

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 withobject 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 givenobject (string)

Since: 3.1.1

Module pandoc.log

Access to pandoc’s logging system.

Functions

info

info (message)

Reports a ScriptingInfo message to pandoc’s logging system.

Parameters:

message: the info message (string)

Since: 3.2

silence

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

warn

warn (message)

Reports a ScriptingWarning to pandoc’s logging system. The warning will be printed to stderr unless logging verbosity has been set toERROR.

Parameters:

message: the warning message (string)

Since: 3.2

Module pandoc.path

Module for file path manipulations.

Fields

separator

The character that separates directories. (string)

search_path_separator

The character that is used to separate the entries in thePATH environment variable. (string)

Functions

filename

filename (filepath)

Get the file name.

Parameters:

filepath: path (string)

Returns:

File name part of the input path. (string)

Since: 2.12

is_absolute

is_absolute (filepath)

Checks whether a path is absolute, i.e. not fixed to a root.

Parameters:

filepath: path (string)

Returns:

true ifffilepath is an absolute path,false otherwise. (boolean)

Since: 2.12

is_relative

is_relative (filepath)

Checks whether a path is relative or fixed to a root.

Parameters:

filepath: path (string)

Returns:

true ifffilepath is a relative path,false otherwise. (boolean)

Since: 2.12

join

join (filepaths)

Join path elements back together by the directory separator.

Parameters:

filepaths: path components ({string,...})

Returns:

The joined path. (string)

Since: 2.12

make_relative

make_relative (path, root[, unsafe])

Contract a filename, based on a relative path. Note that the resulting path will never introduce.. paths, as the presence of symlinks means../b may not reacha/b if it starts froma/c. For a worked example seethis 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

normalize (filepath)

Normalizes a path.

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

Parameters:

filepath: path (string)

Returns:

The normalized path. (string)

Since: 2.12

split

split (filepath)

Splits a path by the directory separator.

Parameters:

filepath: path (string)

Returns:

List of all path components. ({string,...})

Since: 2.12

split_extension

split_extension (filepath)

Splits the last extension from a file path and returns the parts. The extension, if present, includes the leading separator; if the path has no extension, then the empty string is returned as the extension.

Parameters:

filepath: path (string)

Returns:

filepath without extension (string)
extension or empty string (string)

Since: 2.12

split_search_path

split_search_path (search_path)

Takes a string and splits it on thesearch_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

treat_strings_as_paths

treat_strings_as_paths ()

Augment the string module such that strings can be used as path objects.

Since: 2.12

Module pandoc.structure

Access to the higher-level document structure, including hierarchical sections and the table of contents.

Functions

make_sections

make_sections (blocks[, opts])

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

The optionalopts argument can be a table; two settings are recognized: Ifnumber_sections is true, anumber attribute containing the section number will be added to eachHeader. Ifbase_level is an integer, thenHeader levels will be reorganized so that there are no gaps, with numbering levels shifted by the given value. Finally, an integerslide_level value triggers the creation of slides at that heading level.

Note that aWriterOptions object can be passed as the opts table; this will set thenumber_section andslide_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_OPTIONSlocal newblocks = pandoc.structure.make_sections(blocks, opts)

Parameters:

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

Returns:

processed blocks (Blocks)

Since: 3.0

slide_level

slide_level (blocks)

Find level of header that starts slides (defined as the least header level that occurs before a non-header/non-hrule in the blocks).

Parameters:

blocks: document body (Blocks|Pandoc)

Returns:

slide level (integer)

Since: 3.0

split_into_chunks

split_into_chunks (doc[, opts])

Converts aPandoc document into aChunkedDoc.

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:

(ChunkedDoc)

Since: 3.0

table_of_contents

table_of_contents (toc_source[, opts])

Generates a table of contents for the given object.

Parameters:

toc_source: list of command line arguments (Blocks|Pandoc|ChunkedDoc)
opts: options (WriterOptions)

Returns:

Table of contents as a BulletList object (Block)

Since: 3.0

Module pandoc.system

Access to the system’s information and file functionality.

Fields

arch

The machine architecture on which the program is running. (string)

os

The operating system on which the program is running. (string) The most common values aredarwin (macOS),freebsd,linux,linux-android,mingw32 (Windows),netbsd,openbsd.

Functions

cputime

cputime ()

Returns the number of picoseconds CPU time used by the current program. The precision of this result may vary in different versions and on different platforms.

Returns:

CPU time in picoseconds (integer)

Since: 3.1.1

environment

environment ()

Retrieves the entire environment as a string-indexed table.

Returns:

A table mapping environment variable names to their value. (table)

Since: 2.7.3

get_working_directory

get_working_directory ()

Obtain the current working directory as an absolute path.

Returns:

The current working directory. (string)

Since: 2.8

list_directory

list_directory ([directory])

List the contents of a directory.

Parameters:

directory: Path of the directory whose contents should be listed. Defaults to.. (string)

Returns:

A table of all entries indirectory, except for the special entries (. and..). (table)

Since: 2.19

make_directory

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

remove_directory

remove_directory (dirname[, recursive])

Remove an existing, empty directory. Ifrecursive is given, then delete the directory and its contents recursively.

Parameters:

dirname: name of the directory to delete (string)
recursive: delete content recursively (boolean)

Since: 2.19

with_environment

with_environment (environment, callback)

Run an action within a custom environment. Only the environment variables given byenvironment will be set, whencallback 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 runningcallback (table)
callback: Action to execute in the custom environment (function)

Returns:

The results of the call tocallback.

Since: 2.7.3

with_temporary_directory

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 tocallback.

Since: 2.8

with_working_directory

with_working_directory (directory, callback)

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

Parameters:

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

Returns:

The results of the call tocallback.

Since: 2.7.3

Module pandoc.layout

Plain-text document layouting.

Fields

blankline

Inserts a blank line unless one exists already. (Doc)

cr

A carriage return. Does nothing if we’re at the beginning of a line; otherwise inserts a newline. (Doc)

empty

The empty document. (Doc)

space

A breaking (reflowable) space. (Doc)

Functions

after_break

after_break (text)

Creates aDoc 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:

new doc (Doc)

Since: 2.18

before_non_blank

before_non_blank (doc)

Conditionally includes the givendoc unless it is followed by a blank space.

Parameters:

doc: document (Doc)

Returns:

conditional doc (Doc)

Since: 2.18

blanklines

blanklines (n)

Inserts blank lines unless they exist already.

Parameters:

n: number of blank lines (integer)

Returns:

conditional blank lines (Doc)

Since: 2.18

braces

braces (doc)

Puts thedoc in curly braces.

Parameters:

doc: document (Doc)

Returns:

doc enclosed by {}. (Doc)

Since: 2.18

brackets

brackets (doc)

Puts thedoc in square brackets

Parameters:

doc: document (Doc)

Returns:

doc enclosed by []. (Doc)

Since: 2.18

cblock

cblock (doc, width)

Creates a block with the given width and content, aligned centered.

Parameters:

doc: document (Doc)
width: block width in chars (integer)

Returns:

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

Since: 2.18

chomp

chomp (doc)

Chomps trailing blank space off of thedoc.

Parameters:

doc: document (Doc)

Returns:

doc without trailing blanks (Doc)

Since: 2.18

concat

concat (docs[, sep])

Concatenates a list ofDocs.

Parameters:

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

Returns:

concatenated doc (Doc)

Since: 2.18

double_quotes

double_quotes (doc)

Wraps aDoc in double quotes.

Parameters:

doc: document (Doc)

Returns:

doc enclosed by" chars (Doc)

Since: 2.18

flush

flush (doc)

Makes aDoc flush against the left margin.

Parameters:

doc: document (Doc)

Returns:

flusheddoc (Doc)

Since: 2.18

hang

hang (doc, ind, start)

Creates a hanging indent.

Parameters:

doc: document (Doc)
ind: indentation width (integer)
start: document (Doc)

Returns:

doc prefixed bystart on the first line, subsequent lines indented byind spaces. (Doc)

Since: 2.18

inside

inside (contents, start, end)

Encloses aDoc inside a start and endDoc.

Parameters:

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

Returns:

enclosed contents (Doc)

Since: 2.18

lblock

lblock (doc, width)

Creates a block with the given width and content, aligned to the left.

Parameters:

doc: document (Doc)
width: block width in chars (integer)

Returns:

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

Since: 2.18

literal

literal (text)

Creates aDoc from a string.

Parameters:

text: literal value (string)

Returns:

doc containing just the literal string (Doc)

Since: 2.18

nest

nest (doc, ind)

Indents aDoc by the specified number of spaces.

Parameters:

doc: document (Doc)
ind: indentation size (integer)

Returns:

doc indented byind spaces (Doc)

Since: 2.18

nestle

nestle (doc)

Removes leading blank lines from aDoc.

Parameters:

doc: document (Doc)

Returns:

doc with leading blanks removed (Doc)

Since: 2.18

nowrap

nowrap (doc)

Makes aDoc non-reflowable.

Parameters:

doc: document (Doc)

Returns:

same as input, but non-reflowable (Doc)

Since: 2.18

parens

parens (doc)

Puts thedoc in parentheses.

Parameters:

doc: document (Doc)

Returns:

doc enclosed by (). (Doc)

Since: 2.18

prefixed

prefixed (doc, prefix)

Uses the specified string as a prefix for every line of the inside document (except the first, if not at the beginning of the line).

Parameters:

doc: document (Doc)
prefix: prefix for each line (string)

Returns:

prefixeddoc (Doc)

Since: 2.18

quotes

quotes (doc)

Wraps aDoc in single quotes.

Parameters:

doc: document (Doc)

Returns:

doc enclosed in'. (Doc)

Since: 2.18

rblock

rblock (doc, width)

Creates a block with the given width and content, aligned to the right.

Parameters:

doc: document (Doc)
width: block width in chars (integer)

Returns:

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

Since: 2.18

vfill

vfill (border)

An expandable border that, when placed next to a box, expands to the height of the box. Strings cycle through the list provided.

Parameters:

border: vertically expanded characters (string)

Returns:

automatically expanding border Doc (Doc)

Since: 2.18

render

render (doc[, colwidth[, style]])

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

Parameters:

doc: document (Doc)
colwidth: Maximum number of characters per line. A value ofnil, 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:

rendered doc (string)

Since: 2.18

is_empty

is_empty (doc)

Checks whether a doc is empty.

Parameters:

doc: document (Doc)

Returns:

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

Since: 2.18

height

height (doc)

Returns the height of a block or other Doc.

Parameters:

doc: document (Doc)

Returns:

doc height (integer|string)

Since: 2.18

min_offset

min_offset (doc)

Returns the minimal width of aDoc when reflowed at breakable spaces.

Parameters:

doc: document (Doc)

Returns:

minimal possible width (integer|string)

Since: 2.18

offset

offset (doc)

Returns the width of aDoc as number of characters.

Parameters:

doc: document (Doc)

Returns:

doc width (integer|string)

Since: 2.18

real_length

real_length (str)

Returns the real length of a string in a monospace font: 0 for a combining character, 1 for a regular character, 2 for an East Asian wide character.

Parameters:

str: UTF-8 string to measure (string)

Returns:

text length (integer|string)

Since: 2.18

update_column

update_column (doc, i)

Returns the column that would be occupied by the last laid out character.

Parameters:

doc: document (Doc)
i: start column (integer)

Returns:

column number (integer|string)

Since: 2.18

bold

bold (doc)

Puts aDoc in boldface.

Parameters:

doc: document (Doc)

Returns:

bolded Doc (Doc)

Since: 3.4.1

italic

italic (doc)

Puts aDoc in italics.

Parameters:

doc: document (Doc)

Returns:

styled Doc (Doc)

Since: 3.4.1

underlined

underlined (doc)

Underlines aDoc.

Parameters:

doc: document (Doc)

Returns:

styled Doc (Doc)

Since: 3.4.1

strikeout

strikeout (doc)

Puts a line through theDoc.

Parameters:

doc: document (Doc)

Returns:

styled Doc (Doc)

Since: 3.4.1

fg

fg (doc, color)

Set the foreground color.

Parameters:

doc: document (Doc)
color: One of ‘black’, ‘red’, ‘green’, ‘yellow’, ‘blue’, ‘magenta’ ‘cyan’, or ‘white’. (string)

Returns:

styled Doc (Doc)

Since: 3.4.1

bg

bg (doc, color)

Set the background color.

Parameters:

doc: document (Doc)
color: One of ‘black’, ‘red’, ‘green’, ‘yellow’, ‘blue’, ‘magenta’ ‘cyan’, or ‘white’. (string)

Returns:

styled Doc (Doc)

Since: 3.4.1

Types

Doc

See the descriptionabove.

Module pandoc.scaffolding

Scaffolding for custom writers.

Fields

Writer

An object to be used as aWriter function; the construct handles most of the boilerplate, expecting only render functions for all AST elements (table)

Module pandoc.text

UTF-8 aware text manipulation functions, implemented in Haskell.

The text module can also be loaded under the nametext, although this is discouraged and deprecated.

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

Functions

fromencoding

fromencoding (s[, encoding])

Converts a string to UTF-8. Theencoding 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 leastUTF-8,UTF-16BE,UTF-16LE,UTF-32BE, andUTF-32LE. Note that the default code page on Windows is available throughCP0.

Parameters:

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

Returns:

UTF-8 string (string)

Since: 3.0

len

len (s)

Returns the length of a UTF-8 string, i.e., the number of characters.

Parameters:

s: UTF-8 encoded string (string)

Returns:

length (integer|string)

Since: 2.0.3

lower

lower (s)

Returns a copy of a UTF-8 string, converted to lowercase.

Parameters:

s: UTF-8 string to convert to lowercase (string)

Returns:

Lowercase copy ofs (string)

Since: 2.0.3

reverse

reverse (s)

Returns a copy of a UTF-8 string, with characters reversed.

Parameters:

s: UTF-8 string to revert (string)

Returns:

Reverseds (string)

Since: 2.0.3

sub

sub (s, i[, j])

Returns a substring of a UTF-8 string, using Lua’s string indexing rules.

Parameters:

s: UTF-8 string (string)
i: substring start position (integer)
j: substring end position (integer)

Returns:

text substring (string)

Since: 2.0.3

toencoding

toencoding (s[, enc])

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

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

Parameters:

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

Returns:

re-encoded string (string)

Since: 3.0

upper

upper (s)

Returns a copy of a UTF-8 string, converted to uppercase.

Parameters:

s: UTF-8 string to convert to uppercase (string)

Returns:

Uppercase copy ofs (string)

Since: 2.0.3

Module pandoc.template

Handle pandoc templates.

Functions

apply

apply (template, context)

Applies a context with variable assignments to a template, returning the rendered template. Thecontext parameter must be a table with variable names as keys andDoc, 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:

rendered template (Doc)

Since: 3.0

compile

compile (template[, templates_path])

Compiles a template string into aTemplate object usable by pandoc.

If thetemplates_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:

compiled template (Template)

Since: 2.17

default

default ([writer])

Returns the default template for a given writer as a string. An error is thrown if no such template can be found.

Parameters:

writer: name of the writer for which the template should be retrieved; defaults to the globalFORMAT. (string)

Returns:

raw template (string)

Since: 2.17

get

get (filename)

Retrieve text for a template.

This function first checks the resource paths for a file of this name; if none is found, thetemplates 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_to_context

meta_to_context (meta, blocks_writer, inlines_writer)

Creates template context from the document’sMeta data, using the given functions to convertBlocks andInlines toDoc values.

Parameters:

meta: document metadata (Meta)
blocks_writer: converter fromBlocks toDoc values (function)
inlines_writer: converter fromInlines toDoc values (function)

Returns:

template context (table)

Since: 3.0

Module pandoc.types

Constructors for types that are not part of the pandoc AST.

Functions

Version

Version (version_specifier)

Parameters:

version_specifier: A version string like'2.7.3', a Lua number like2.0, a list of integers like{2,7,3}, or a Version object. (string|number|{integer,...}|Version)

Returns:

New Version object. (Version)

Since: 2.7.3

Module pandoc.zip

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

The module can be called as a function, in which case it behaves like thezip 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 totrue;
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.

Functions

Entry

Entry (path, contents[, modtime])

Generates a ZipEntry from a filepath, uncompressed content, and the file’s modification time.

Parameters:

path: file path in archive (string)
contents: uncompressed contents (string)
modtime: modification time (integer)

Returns:

a new zip archive entry (zip.Entry)

Since: 3.0

read_entry

read_entry (filepath[, opts])

Generates a ZipEntry from a file or directory.

Parameters:

filepath: (string)
opts: zip options (table)

Returns:

a new zip archive entry (zip.Entry)

Since: 3.0

zip

zip (filepaths[, opts])

Package and compress the given files into a new Archive.

Parameters:

filepaths: list of files from which the archive is created. ({string,...})
opts: zip options (table)

Returns:

a new archive (zip.Archive)

Since: 3.0

Types

zip.Archive

Properties

entries

Files in this zip archive ({zip.Entry,...})

Methods

bytestring

bytestring (self)

Returns the raw binary string representation of the archive.

Parameters:

self: (zip.Archive)

Returns:

bytes of the archive (string)

extract

extract (self[, opts])

Extract all files from this archive, creating directories as needed. Note that the last-modified time is set correctly only in POSIX, not in Windows. This function fails if encrypted entries are present.

Parameters:

self: (zip.Archive)
opts: zip options (table)

zip.Entry

Properties

modtime

Modification time (seconds since unix epoch) (integer)

path

Relative path, using/ as separator (zip.Entry)

Methods

contents (self[, password])

Get the uncompressed contents of a zip entry. Ifpassword is given, then that password is used to decrypt the contents. An error is throws if decrypting fails.

Parameters:

self: (zip.Entry)
password: password for entry (string)

Returns:

binary contents (string)

symlink

symlink (self)

Returns the target if the Entry represents a symbolic link, andnil otherwise. Always returnsnil on Windows.

Parameters:

self: (zip.Entry)

Returns:

link target if entry represents a symbolic link (string|nil)

Movatterモバイル変換

Pandoc Lua Filters

Introduction

Lua filter structure

Filters on element sequences

Traversal order

Typewise traversal

Topdown traversal

Global variables

Pandoc Module

Element creation

Exposed pandoc functionality

Lua interpreter initialization

Debugging Lua filters

Common pitfalls

Examples

Macro substitution

Center images in LaTeX and HTML output

Setting the date in the metadata

Remove spaces before citations

Replacing placeholders with their metadata value

Modifying pandoc’sMANUAL.txt for man pages

Creating a handout from a paper

Counting words in a document

Converting ABC code to music notation

Building images with TikZ

Lua type reference

Shared Properties

clone

Pandoc

walk

Meta

MetaValue

Block

Common methods

walk

BlockQuote

BulletList

CodeBlock

DefinitionList

Div

Figure

Header

HorizontalRule

LineBlock

OrderedList

Para

Plain

RawBlock

Table

Blocks

Methods

walk

Inline

Common methods

walk

Cite

Code

Emph

Image

LineBreak

Link

Math

Note

Quoted

RawInline

SmallCaps

SoftBreak

Space

Span

Str

Strikeout

Strong

Subscript

Superscript

Underline

Inlines

Methods

walk

Element components

Modifying pandoc’s`MANUAL.txt` for man pages

`clone`

`..`

`+`

`/`

`//`

`must_be_at_least`