Parse the source string to a token stream :param src: source string :param env: environment sandbox Parse input string and r

Push new token to "stream".

Render markdown string into html. It does all magic for you :). :param src: source string :param env: environment sandbox :re

Push new token to "stream". If pending text exists - flush it as text token

Check if character is a whitespace.

Returns the Unicode value of the character at the specified location. @param - index The zero-based index of the desired character. If t

Check if line is a code block, i.e. the code block rule is enabled and text is indented by more than 3 spaces.

Enable rules with given names. :param names: name or list of rule names to enable. :param ignoreInvalid: ignore errors when rule not

Return the `Token` that is used as the data source for the properties defined below.

Return array of active functions (rules) for given chain name. It analyzes rules configuration, compiles caches if not exists and returns resu

Load specified plugin with given params into current parser instance. (chainable) It's just a sugar to call `plugin(md, params)` with curring

Replace rule by name with new function & options. :param ruleName: rule name to replace. :param fn: new rule function. :param

Create a fence parsing rule with configurable options. :param markers: Tuple of single characters that can be used as fence markers. :param t

Set `name` attribute to `value`. Override old value if exists.

Returns the Unicode value of the character at the specified location. @param - index The zero-based index of the desired character. If t

.

Normalize destination URLs in links :: [label]: destination 'title' ^^^^^^^^^^^

The same as [[MarkdownIt.parse]] but skip all block rules. :param src: source string :param env: environment sandbox It retu

Validate if the URL link is allowed in output. This validator can prohibit more than really needed to prevent XSS. It's a tradeoff to

Create a MarkdownIt instance with a colon fence rule (like colon_fence plugin).

Replace special characters "&", "<", ">" and '"' to HTML-safe sequences.

Normalize autolink content :: <destination> ~~~~~~~~~~~

Return the token as a dictionary. :param children: Also convert children to dicts :param as_upstream: Ensure the output dictionary is

Add new rule to chain before one with given name. :param beforeName: new rule will be added before this one. :param ruleName: new rul

The same as [[MarkdownIt.enable]], but turn specified rules off. (chainable) :param names: rule name or list of rule names to disable.

Find rule index by name

Create MarkdownIt with exact-match colon fence.

Cut lines range from source.

Return the active rule names.

Return the names of all active rules.

Render token attributes to string.

Generate tokens for input range.

Join value to existing attribute via space. Or create new attribute if not exists. Useful to operate with token classes.

Enable rules with given names, and disable everything else. :param names: name or list of rule names to enable. :param ignoreInvalid:

Markdown ASCII punctuation characters. :: !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, },

Check if character is a punctuation character.

Check if character code is a whitespace.

r"""Zs (unicode class) || [\t\f\v\r\n]

Push new rule to the end of chain. :param ruleName: new rule will be added to the end of chain. :param fn: new rule function.

Default token renderer. Can be overridden by custom function :param idx: token index to render :param options: params of par

Convert the token stream to a tree structure and set the resulting nodes as children of `self`.

Register a character that stops the ``text`` rule, allowing inline rules to fire. This lets plugins declare which characters their inline rul

Add new rule to chain after one with given name. :param afterName: new rule will be added after this one. :param ruleName: new rule w

Get the value of attribute `name`, or null if it does not exist.

Disable rules with given names. :param names: name or list of rule names to enable. :param ignoreInvalid: ignore errors when rule not

Convert ordinal to unicode. Note, in the original Javascript two string characters were required, for codepoints larger than `0xFFFF`. Bu

Helper to unify [reference labels].

Skip character string from given position.

Skip spaces from given position.

Make a child node for `self`.

Batch load of all options and component settings. This is an internal method, and you probably will not need it. But if you will - see

Create an XML style string of the tree.

Executes core chain rules.

For each opening emphasis-like marker find a matching closing one.

Similar to [[MarkdownIt.render]] but for single paragraph content. :param src: source string :param env: environment sandbox

Scan a sequence of emphasis-like markers, and determine whether it can start an emphasis sequence or end an emphasis sequence.

Build rules lookup cache

Detect ``[!TYPE]`` on *startLine* (after ``>`` prefix has been stripped). Returns the alert type string (e.g. ``"NOTE"``) or ``None``.

Detect ``[ ]``, ``[x]``, or ``[X]`` at *pos*, followed by whitespace. Returns ``True`` (checked), ``False`` (unchecked), or ``None`` (no match).

Remove element from array and put another array at those position. Useful for some operations with tokens

Get (key, value) list of attrs.

Add `[ name, value ]` attribute to list. Init attrs if necessary.

Convert Token.attrs set as ``None`` or ``[[key, value], ...]`` to a dict. This improves compatibility with upstream markdown-it.

Parse a Markdown file and dump the output to stdout.

Parse a Markdown file and dump the output to stdout.

Return a shallow copy of the instance.

Enable list or rules. (chainable) :param names: rule name or list of rule names to enable. :param ignoreInvalid: set `true` to ignore

Convert a dict to a Token.

Return the names of all active rules.

Highlighter function: (content, langName, langAttrs) -> escaped HTML.

fence infostring

Parse user input, dump to stdout, rinse and repeat. Python REPL style.

Build fuzzers idempotently in a given folder.