laika.bundle

Builder API for block parsers.

The entry points provide access to the parsers for child blocks (recursive), child spans (withSpans) or escape sequences (withEscapedText). These are methods with decreasing power, as the parser for recursive blocks does also provide the span parsers.

If your parser implementation is completely independent from the host markup language you can use the standalone method.

Builds a block parser definition lazily by passing the recursive parsers of the host language.

Builder API for block parsers that allows to set the parser precedence.

Defines a parser for a single kind of block element, like a quoted block or a bullet list for example.

Specifies the position a block element is allowed to appear in.

RootOnly elements can only appear on the top level of the document hierarchy, while NestedOnly can only appear nested within other elements, e.g. as part of a list item or within a quoted block. Any allows block elements in any position.

Indicates whether an extension bundle is a built-in default provided by the library, a collection of extensions installed by a markup format or user-defined.

This is relevant for determining the precedence of installed bundles when merging them, as user-supplied functionality always overrides library defaults.

Responsible for providing the parsers for configuration files and configuration headers in markup documents as part of an ExtensionBundle.

Laika has a built-in implementation of this API that parses configuration as HOCON, but these can be overridden by adding an instance of this trait to a ParserBundle within an ExtensionBundle.

The default implementations for determining the document type of the input based on its path.

An extension bundle is a collection of parser extensions, rewrite rules, render overrides and other features to be applied to parse, render and transform operations. It serves as a central registry for all of Laika's extension and customization hooks.

The base trait contains empty implementations for all these features, therefore any bundle implementation only needs to override the relevant members.

If the bundle implementation is not parameterized, the most convenient choice for users would be to simply implement it as an object, like all built-in extensions do:

object MyExtensions extends ExtensionBundle {

 // override one or more members

}

This way a user can easily pass it to the operation builders:

val transformer = Transformer
 .from(Markdown)
 .to(HTML)
 .using(MyExtensions)
 .build

Provides default ExtensionBundle instances.

Bundles extensions for the text markup parsers defined for the host language to support additional syntax not recognized by the base parsers.

When extension parsers fail for a given input the built-in parsers will still be tried for the same block or span respectively.

Builds a parser definition lazily by passing the recursive parsers of the host language.

This indirection is needed when supplying parser implementations as many parsers recursively parse child elements. A list parser for example needs to be able to detect any other block or span element within a list item. But since it has no way of knowing which extensions a user might have added to the host language, those parsers are supplied from the outside by the parser engine.

Bundles a collection of all types of parsers used in a transformation.

The parsers for text markup and configuration headers are meant to complement base parsers defined by the host language. If they fail for a given input the built-in parsers will still be tried for the same block, span or configuration header respectively.

The parsers for stylesheets and templates on the other hand are meant to overwrite any previously installed parsers.

Defines a parser for a single kind of text markup, like a literal text span or a bullet list for example.

Hooks for markup parsers to control aspects beyond the individual span and block parsers defined for the host language.

Indicates whether a parser should be applied before the base parsers of the host language (high precedence) or after them (low precedence).

Collects custom render functions that adjust the rendered output of one or more AST nodes.

Builder API for span parsers.

The two entry points are either recursive if your parser implementation needs to recursively parse child spans defined by the host language or standalone if it doesn't.

Builds a span parser definition lazily by passing the recursive parsers of the host language.

Builder API for span parsers that allows to set the parser precedence.

Defines a parser for a single kind of span element, like a literal text span or a link reference for example.