Lezer Markdown Parser

Delimiters are used during inline parsing to store positions of potential delimiters. They are identified by the DelimiterType interface.

There are two ways to handle delimiters:

1. Automatic Matching: Provide a resolve property. When a piece of inline content finishes, the system automatically matches delimiters of the same type (based on their open and close properties). The content between them is wrapped in a node named by the resolve value.
2. Manual Matching: If resolve is not provided, you must match the delimiter eagerly using findOpeningDelimiter and takeContent methods on the InlineContext.

When defining a block parser, you can control its position in the parsing hierarchy using the before or after options. This allows you to insert custom parsers relative to existing standard Markdown parsers.

Available standard parser names for positioning include:

• LinkReference
• IndentedCode
• FencedCode
• Blockquote
• HorizontalRule
• BulletList
• OrderedList
• ATXHeading
• HTMLBlock
• SetextHeading

The MarkdownConfig interface is used to customize the behavior of the MarkdownParser via the configure method. You can provide a single MarkdownConfig object or a nested array of them (a MarkdownExtension).

Available configuration keys:

• props?: Readonly NodePropSource[] to add node properties to the parser's node set.
• defineNodes?: Readonly (string | NodeSpec)[] to define new syntax node types.
• parseBlock?: Readonly BlockParser[] to define additional block parsing logic.
• parseInline?: Readonly InlineParser[] to define new inline parsing logic.
• remove?: Readonly string[] to remove named parsers from the configuration.
• wrap?: A ParseWrapper to add a parse wrapper (e.g., for mixed-language parsing).

To define new node types, use the NodeSpec interface, which requires a name (string) and can optionally include a block (boolean) property.

The GFM constant is an extension bundle containing several GFM-style features. You can pass this directly to MarkdownParser.configure().

Included extensions:

• Table: Supports GFM-style tables.
• TaskList: Supports task list items with [ ] or [x] prefixes.
• Strikethrough: Supports ~~ delimiters.
• Autolink: Supports autolinking for www., http://, https://, mailto:, and xmpp: URLs and email addresses.

const gfmParser = parser.configure(GFM);

Use parseCode to create a MarkdownExtension that enables nested parsing within code blocks or embedded HTML.

Configuration options for parseCode:

• codeParser?: A function (info: string) => Parser | null. The info argument is the string following the opening ``` marker (or an empty string for indented code blocks). If a parser is available, this function should return a parser that can construct a PartialParse.
• htmlParser?: A Parser used to parse HTML tags (both block and inline).

const codeExtension = parseCode({
  codeParser: (info) => {
    if (info === 'javascript') return javascriptParser;
    return null;
  },
  htmlParser: htmlParser
});

The MarkdownParser is the default CommonMark parser. It extends the base Lezer Parser and provides methods for reconfiguration and inline parsing.

Key methods:

• configure(spec: MarkdownExtension): Returns a new MarkdownParser instance configured with the provided extension(s).
• parseInline(text: string, offset: number): Parses inline text at a specific offset, returning an array of Element objects representing the inline content.

// Note: The exact instantiation depends on the exported 'parser' instance
// which is the default CommonMark parser.
const newParser = parser.configure(someExtension);

If a line does not match any regular block parsers, its content is typically accumulated into a paragraph-style block. To override this behavior, you can provide a leaf function in your parser configuration that returns a LeafBlockParser object.

An object conforming to the LeafBlockParser interface must implement:

• nextLine(cx: BlockContext, line: Line, leaf: LeafBlock) => boolean: Updates the parser state for the next line. Returning true finishes the block. This is called for all lines after the first.
• finish(cx: BlockContext, leaf: LeafBlock) => boolean: Called when the block is finished by external circumstances (like a blank line). If the parser can handle the block up to its current position, it should finish the block and return true.

The style property in a NodeSpec allows you to assign highlighting information to a node. It accepts:

• A single Tag.
• An array of Tags.
• An object following the styleTags pattern (similar to CodeMirror's styleTags argument) for complex rules.

style?: Tag | readonly Tag[] | { [key: string]: Tag | readonly Tag[] }