parser: MarkdownParserThe default CommonMark parser.
\nclass\n MarkdownParser extends ParserA Markdown parser configuration.
\nnodeSet: NodeSetThe parser's syntax node\ntypes.
\nconfigure(spec: MarkdownExtension) → MarkdownParserReconfigure the parser.
\nparseInline(text: string, offset: number) → Element[]Parse the given piece of inline text at the given offset,\nreturning an array of Element objects representing\nthe inline content.
interface\n MarkdownConfigObjects of this type are used to\nconfigure the Markdown parser.
\nprops?: readonly NodePropSource[]Node props to add to the parser's node set.
\ndefineNodes?: readonly (string | NodeSpec)[]Define new node types for use in parser extensions.
\nparseBlock?: readonly BlockParser[]Define additional block parsing logic.
\nparseInline?: readonly InlineParser[]Define new inline parsing logic.
\nremove?: readonly string[]Remove the named parsers from the configuration.
\nwrap?: ParseWrapperAdd a parse wrapper (such as a mixed-language\nparser) to this parser.
\ntype\n MarkdownExtension = MarkdownConfig | readonly MarkdownExtension[]\nTo make it possible to group extensions together into bigger\nextensions (such as the Github-flavored Markdown\nextension), reconfiguration accepts\nnested arrays of config objects.
\nparseCode(config: Object) → MarkdownExtensionCreate a Markdown extension to enable nested parsing on code\nblocks and/or embedded HTML.
\nconfigcodeParser?: fn(info: string) → Parser | nullWhen provided, this will be used to parse the content of code\nblocks. info is the string after the opening ``` marker,\nor the empty string if there is no such info or this is an\nindented code block. If there is a parser available for the\ncode, it should return a function that can construct the\nparse.
htmlParser?: ParserThe parser used to parse HTML tags (both block and inline).
\nGFM: MarkdownConfig[]Extension bundle containing Table,\nTaskList, Strikethrough, and\nAutolink.
Table: MarkdownConfigThis extension provides\nGFM-style\ntables, using syntax like this:
\n| head 1 | head 2 |\n| --- | --- |\n| cell 1 | cell 2 |\nTaskList: MarkdownConfigExtension providing\nGFM-style\ntask list items, where list items can be prefixed with [ ] or\n[x] to add a checkbox.
Strikethrough: MarkdownConfigAn extension that implements\nGFM-style\nStrikethrough syntax using ~~ delimiters.
Autolink: MarkdownConfigExtension that implements autolinking for\nwww./http:///https:///mailto:/xmpp: URLs and email\naddresses.
Subscript: MarkdownConfigExtension providing\nPandoc-style\nsubscript using ~ markers.
Superscript: MarkdownConfigExtension providing\nPandoc-style\nsuperscript using ^ markers.
Emoji: MarkdownConfigExtension that parses two colons with only letters, underscores,\nand numbers between them as Emoji nodes.
interface\n NodeSpecUsed in the configuration to define\nnew syntax node\ntypes.
\nname: stringThe node's name.
\nblock?: booleanShould be set to true if this type represents a block node.
\ncomposite?: fn(cx: BlockContext, line: Line, value: number) → booleanIf this is a composite block, this should hold a function that,\nat the start of a new line where that block is active, checks\nwhether the composite block should continue (return value) and\noptionally adjusts the line's base position\nand registers nodes for any markers involved\nin the block's syntax.
\nstyle?: Tag | readonly Tag[] | Object<Tag | readonly Tag[]>Add highlighting tag information for this node. The value of\nthis property may either by a tag or array of tags to assign\ndirectly to this node, or an object in the style of\nstyleTags's\nargument to assign more complicated rules.
class\n BlockContext implements PartialParseBlock-level parsing functions get access to this context object.
\nlineStart: numberThe start of the current line.
\nparser: MarkdownParserThe parser configuration used.
\ndepth: numberThe number of parent blocks surrounding the current block.
\nparentType(depth?: number = this.depth - 1) → NodeTypeGet the type of the parent block at the given depth. When no\ndepth is passed, return the type of the innermost parent.
\nnextLine() → booleanMove to the next input line. This should only be called by\n(non-composite) block parsers that consume\nthe line directly, or leaf block parser\nnextLine methods when they\nconsume the current line (and return true).
peekLine() → stringRetrieve the text of the line after the current one, without\nactually moving the context's current line forward.
\nprevLineEnd() → numberThe end position of the previous line.
\nstartComposite(type: string, start: number, value?: number = 0)Start a composite block. Should only be called from block\nparser functions that return null.
\naddElement(elt: Element)Add a block element. Can be called by block\nparsers.
\naddLeafElement(leaf: LeafBlock, elt: Element)Add a block element from a leaf parser. This\nmakes sure any extra composite block markup (such as blockquote\nmarkers) inside the block are also added to the syntax tree.
\nelt(type: string, from: number, to: number, children?: readonly Element[]) → ElementCreate an Element object to represent some syntax\nnode.
interface\n BlockParserBlock parsers handle block-level structure. There are three\ngeneral types of block parsers:
\nComposite block parsers, which handle things like lists and\nblockquotes. These define a parse method\nthat starts a composite block\nand returns null when it recognizes its syntax.
Eager leaf block parsers, used for things like code or HTML\nblocks. These can unambiguously recognize their content from its\nfirst line. They define a parse method\nthat, if it recognizes the construct,\nmoves the current line forward to the\nline beyond the end of the block,\nadd a syntax node for the block, and\nreturn true.
Leaf block parsers that observe a paragraph-like construct as it\ncomes in, and optionally decide to handle it at some point. This\nis used for "setext" (underlined) headings and link references.\nThese define a leaf method that checks\nthe first line of the block and returns a\nLeafBlockParser object if it wants to\nobserve that block.
name: stringThe name of the parser. Can be used by other block parsers to\nspecify precedence.
\nparse?: fn(cx: BlockContext, line: Line) → boolean | nullThe eager parse function, which can look at the block's first\nline and return false to do nothing, true if it has parsed\n(and moved past a block), or null if\nit has started a composite block.
leaf?: fn(cx: BlockContext, leaf: LeafBlock) → LeafBlockParser | nullA leaf parse function. If no regular parse\nfunctions match for a given line, its content will be\naccumulated for a paragraph-style block. This method can return\nan object that overrides that style of\nparsing in some situations.
\nendLeaf?: fn(cx: BlockContext, line: Line, leaf: LeafBlock) → booleanSome constructs, such as code blocks or newly started\nblockquotes, can interrupt paragraphs even without a blank line.\nIf your construct can do this, provide a predicate here that\nrecognizes lines that should end a paragraph (or other non-eager\nleaf block).
\nbefore?: stringWhen given, this parser will be installed directly before the\nblock parser with the given name. The default configuration\ndefines block parsers with names LinkReference, IndentedCode,\nFencedCode, Blockquote, HorizontalRule, BulletList, OrderedList,\nATXHeading, HTMLBlock, and SetextHeading.
\nafter?: stringWhen given, the parser will be installed directly after the\nparser with the given name.
\ninterface\n LeafBlockParserObjects that are used to override\nparagraph-style blocks should conform to this interface.
\nnextLine(cx: BlockContext, line: Line, leaf: LeafBlock) → booleanUpdate the parser's state for the next line, and optionally\nfinish the block. This is not called for the first line (the\nobject is constructed at that line), but for any further lines.\nWhen it returns true, the block is finished. It is okay for\nthe function to consume the current\nline or any subsequent lines when returning true.
finish(cx: BlockContext, leaf: LeafBlock) → booleanCalled when the block is finished by external circumstances\n(such as a blank line or the start of\nanother construct). If this parser can handle the block up to\nits current position, it should\nfinish the block and return\ntrue.
\nclass\n LineData structure used during block-level per-line parsing.
\ntext: stringThe line's full text.
\nbaseIndent: numberThe base indent provided by the composite contexts (that have\nbeen handled so far).
\nbasePos: numberThe string position corresponding to the base indent.
\npos: numberThe position of the next non-whitespace character beyond any\nlist, blockquote, or other composite block markers.
\nindent: numberThe column of the next non-whitespace character.
\nnext: numberThe character code of the character after pos.
skipSpace(from: number) → numberSkip whitespace after the given position, return the position of\nthe next non-space character or the end of the line if there's\nonly space after from.
moveBase(to: number)Move the line's base position forward to the given position.\nThis should only be called by composite block\nparsers or markup skipping\nfunctions.
\nmoveBaseColumn(indent: number)Move the line's base position forward to the given column.
\naddMarker(elt: Element)Store a composite-block-level marker. Should be called from\nmarkup skipping functions when they\nconsume any non-whitespace characters.
\ncountIndent(to: number, from?: number = 0, indent?: number = 0) → numberFind the column position at to, optionally starting at a given\nposition and column.
findColumn(goal: number) → numberFind the position corresponding to the given column.
\nclass\n LeafBlockData structure used to accumulate a block's content during leaf\nblock parsing.
\n\n\nclass\n InlineContextInline parsing functions get access to this context, and use it to\nread the content and emit syntax nodes.
\nparser: MarkdownParserThe parser that is being used.
\ntext: stringThe text of this inline section.
\noffset: numberThe starting offset of the section in the document.
\nchar(pos: number) → numberGet the character code at the given (document-relative)\nposition.
\nend: numberThe position of the end of this inline section.
\nslice(from: number, to: number) → stringGet a substring of this inline section. Again uses\ndocument-relative positions.
\naddDelimiter(type: DelimiterType, from: number, to: number, open: boolean, close: boolean) → numberAdd a delimiter at this given position. open\nand close indicate whether this delimiter is opening, closing,\nor both. Returns the end of the delimiter, for convenient\nreturning from parse functions.
hasOpenLink: booleanReturns true when there is an unmatched link or image opening\ntoken before the current position.
\naddElement(elt: Element) → numberAdd an inline element. Returns the end of the element.
\nfindOpeningDelimiter(type: DelimiterType) → number | nullFind an opening delimiter of the given type. Returns null if\nno delimiter is found, or an index that can be passed to\ntakeContent otherwise.
takeContent(startIndex: number) → Element[]Remove all inline elements and delimiters starting from the\ngiven index (which you should get from\nfindOpeningDelimiter,\nresolve delimiters inside of them, and return them as an array\nof elements.
getDelimiterAt(index: number) → {from: number, to: number, type: DelimiterType} | nullReturn the delimiter at the given index. Mostly useful to get\nadditional info out of a delimiter index returned by\nfindOpeningDelimiter.\nReturns null if there is no delimiter at this index.
skipSpace(from: number) → numberSkip space after the given (document) position, returning either\nthe position of the next non-space character or the end of the\nsection.
\nelt(type: string, from: number, to: number, children?: readonly Element[]) → ElementCreate an Element for a syntax node.
static linkStart: DelimiterTypeThe opening delimiter type used by the standard link parser.
\nstatic imageStart: DelimiterTypeOpening delimiter type used for standard images.
\ninterface\n InlineParserInline parsers are called for every character of parts of the\ndocument that are parsed as inline content.
\nname: stringThis parser's name, which can be used by other parsers to\nindicate a relative precedence.
\nparse(cx: InlineContext, next: number, pos: number) → numberThe parse function. Gets the next character and its position as\narguments. Should return -1 if it doesn't handle the character,\nor add some element or\ndelimiter and return the end\nposition of the content it parsed if it can.
\nbefore?: stringWhen given, this parser will be installed directly before the\nparser with the given name. The default configuration defines\ninline parsers with names Escape, Entity, InlineCode, HTMLTag,\nEmphasis, HardBreak, Link, and Image. When no before or\nafter property is given, the parser is added to the end of the\nlist.
after?: stringWhen given, the parser will be installed directly after the\nparser with the given name.
\ninterface\n DelimiterTypeDelimiters are used during inline parsing to store the positions\nof things that might be delimiters, if another matching\ndelimiter is found. They are identified by objects with these\nproperties.
\nresolve?: stringIf this is given, the delimiter should be matched automatically\nwhen a piece of inline content is finished. Such delimiters will\nbe matched with delimiters of the same type according to their\nopen and close properties. When a\nmatch is found, the content between the delimiters is wrapped in\na node whose name is given by the value of this property.
\nWhen this isn't given, you need to match the delimiter eagerly\nusing the findOpeningDelimiter\nand takeContent methods.
mark?: stringIf the delimiter itself should, when matched, create a syntax\nnode, set this to the name of the syntax node.
\n