@types/markdown-it

method parseLinkDestination

parseLinkDestination: (str: string, pos: number, max: number) => ParseResult;

• Parse link destination

method parseLinkLabel

parseLinkLabel: (
    state: StateInline,
    start: number,
    disableNested?: boolean
) => number;

• Parse link label

  This function assumes that first character ("[") already matches; returns the end of the label

method parseLinkTitle

parseLinkTitle: (str: string, pos: number, max: number) => ParseResult;

• Parse link title

property block

readonly block: ParserBlock;

• Instance of [[ParserBlock]]. You may need it to add new rules when writing plugins. For simple rules control use [[MarkdownIt.disable]] and [[MarkdownIt.enable]].

property core

readonly core: Core;

• Instance of [[Core]] chain executor. You may need it to add new rules when writing plugins. For simple rules control use [[MarkdownIt.disable]] and [[MarkdownIt.enable]].

property helpers

readonly helpers: MarkdownIt.Helpers;

• Link components parser functions, useful to write plugins. See details [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).

property inline

readonly inline: ParserInline;

• Instance of [[ParserInline]]. You may need it to add new rules when writing plugins. For simple rules control use [[MarkdownIt.disable]] and [[MarkdownIt.enable]].

property linkify

readonly linkify: LinkifyIt.LinkifyIt;

• [linkify-it](https://github.com/markdown-it/linkify-it) instance. Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js) rule.

property options

readonly options: MarkdownIt.Options;

property renderer

readonly renderer: Renderer;

• Instance of [[Renderer]]. Use it to modify output look. Or to add rendering rules for new token types, generated by plugins.

  ##### Example

  var md = require('markdown-it')();
  
  function myToken(tokens, idx, options, env, self) {
    //...
    return result;
  };
  
  md.renderer.rules['my_token'] = myToken

  See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js).

property utils

readonly utils: MarkdownIt.Utils;

• Assorted utility functions, useful to write plugins. See details [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.mjs).

method configure

configure: (presets: MarkdownIt.PresetName) => this;

• *chainable*, *internal*

  Batch load of all options and compenent settings. This is internal method, and you probably will not need it. But if you with - see available presets and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)

  We strongly recommend to use presets instead of direct config loads. That will give better compatibility with next versions.

method disable

disable: (list: string | string[], ignoreInvalid?: boolean) => this;

• *chainable*

  The same as [[MarkdownIt.enable]], but turn specified rules off.

  Parameter list

  rule name or list of rule names to disable.

  Parameter ignoreInvalid

  set true to ignore errors when rule not found.

method enable

enable: (list: string | string[], ignoreInvalid?: boolean) => this;

• *chainable*

  Enable list or rules. It will automatically find appropriate components, containing rules with given names. If rule not found, and ignoreInvalid not set - throws exception.

  ##### Example

  var md = require('markdown-it')()
              .enable(['sub', 'sup'])
              .disable('smartquotes');

  Parameter list

  rule name or list of rule names to enable

  Parameter ignoreInvalid

  set true to ignore errors when rule not found.

method normalizeLink

normalizeLink: (url: string) => string;

• Function used to encode link url to a machine-readable format, which includes url-encoding, punycode, etc.

method normalizeLinkText

normalizeLinkText: (url: string) => string;

• Function used to decode link url to a human-readable format`

method parse

parse: (src: string, env: any) => Token[];

• *internal*

  Parse input string and returns list of block tokens (special token type "inline" will contain list of inline tokens). You should not call this method directly, until you write custom renderer (for example, to produce AST).

  env is used to pass data between "distributed" rules and return additional metadata like reference info, needed for the renderer. It also can be used to inject data in specific cases. Usually, you will be ok to pass {}, and then pass updated object to renderer.

  Parameter src

  source string

  Parameter env

  environment sandbox

method parseInline

parseInline: (src: string, env: any) => Token[];

• *internal*

  The same as [[MarkdownIt.parse]] but skip all block rules. It returns the block tokens list with the single inline element, containing parsed inline tokens in children property. Also updates env object.

  Parameter src

  source string

  Parameter env

  environment sandbox

method render

render: (src: string, env?: any) => string;

• Render markdown string into html. It does all magic for you :).

  env can be used to inject additional metadata ({} by default). But you will not need it with high probability. See also comment in [[MarkdownIt.parse]].

  Parameter src

  source string

  Parameter env

  environment sandbox

method renderInline

renderInline: (src: string, env?: any) => string;

• Similar to [[MarkdownIt.render]] but for single paragraph content. Result will NOT be wrapped into <p> tags.

  Parameter src

  source string

  Parameter env

  environment sandbox

method set

set: (options: MarkdownIt.Options) => this;

• *chainable*

  Set parser options (in the same format as in constructor). Probably, you will never need it, but you can change options after constructor call.

  ##### Example

  var md = require('markdown-it')()
              .set({ html: true, breaks: true })
              .set({ typographer: true });

  __Note:__ To achieve the best possible performance, don't modify a markdown-it instance options on the fly. If you need multiple configurations it's best to create multiple instances and initialize each with separate config.

method use

use: {
    (plugin: MarkdownIt.PluginSimple): this;
    <T = any>(plugin: MarkdownIt.PluginWithOptions<T>, options?: T): this;
    (plugin: MarkdownIt.PluginWithParams, ...params: any[]): this;
};

• *chainable*

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

  ##### Example

  var iterator = require('markdown-it-for-inline');
  var md = require('markdown-it')()
              .use(iterator, 'foo_replace', 'text', function (tokens, idx) {
                tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');
              });

method validateLink

validateLink: (url: string) => boolean;

• Link validation function. CommonMark allows too much in links. By default we disable javascript:, vbscript:, file: schemas, and almost all data:... schemas except some embedded image types.

  You can change this behaviour:

  var md = require('markdown-it')();
  // enable everything
  md.validateLink = function () { return true; }

property breaks

breaks?: boolean | undefined;

• Set true to convert \n in paragraphs into <br>. false

property highlight

highlight?:
    | ((str: string, lang: string, attrs: string) => string)
    | null
    | undefined;

• Highlighter function for fenced code blocks. Highlighter function (str, lang, attrs) should return escaped HTML. It can also return empty string if the source was not changed and should be escaped externally. If result starts with <pre... internal wrapper is skipped. null

property html

html?: boolean | undefined;

• Set true to enable HTML tags in source. Be careful! That's not safe! You may need external sanitizer to protect output from XSS. It's better to extend features via plugins, instead of enabling HTML. false

property langPrefix

langPrefix?: string | undefined;

• CSS language class prefix for fenced blocks. Can be useful for external highlighters. 'language-'

property linkify

linkify?: boolean | undefined;

• Set true to autoconvert URL-like text to links. false

property quotes

quotes?: string | string[];

• Double + single quotes replacement pairs, when typographer enabled and smartquotes on. For example, you can use '«»„“' for Russian, '„“‚‘' for German, and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp). '“”‘’'

property typographer

typographer?: boolean | undefined;

• Set true to enable [some language-neutral replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js) + quotes beautification (smartquotes). false

property xhtmlOut

xhtmlOut?: boolean | undefined;

• Set true to add '/' when closing single tags (<br />). This is needed only for full CommonMark compatibility. In real world you will need HTML output. false

property lines

lines: number;

property ok

ok: boolean;

property pos

pos: number;

property str

str: string;

property lib

lib: {
    mdurl: typeof mdurl;
    // ucmicro: typeof ucmicro;
};

method arrayReplaceAt

arrayReplaceAt: <T>(src: T[], pos: number, newElements: T[]) => T[];

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

method assign

assign: (target: any, ...sources: any[]) => any;

• Merge objects

method escapeHtml

escapeHtml: (str: string) => string;

method escapeRE

escapeRE: (str: string) => string;

method fromCodePoint

fromCodePoint: (code: number) => string;

method has

has: (obj: any, key: keyof any) => boolean;

• has own property

method isMdAsciiPunct

isMdAsciiPunct: (code: number) => boolean;

• Markdown ASCII punctuation characters.

  !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, , ], ^, _, `, {, |, }, or ~ http://spec.commonmark.org/0.15/#ascii-punctuation-character

  Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.

method isPunctChar

isPunctChar: (ch: string) => boolean;

• Currently without astral characters support.

method isSpace

isSpace: (code: number) => boolean;

method isString

isString: (obj: any) => obj is string;

• Check if the type is string or not

method isValidEntityCode

isValidEntityCode: (code: number) => boolean;

method isWhiteSpace

isWhiteSpace: (code: number) => boolean;

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

method normalizeReference

normalizeReference: (str: string) => string;

• Hepler to unify [reference labels].

method unescapeAll

unescapeAll: (str: string) => string;

method unescapeMd

unescapeMd: (str: string) => string;

type RuleCore

type RuleCore = (state: StateCore) => void;

type RuleBlock

type RuleBlock = (
    state: StateBlock,
    startLine: number,
    endLine: number,
    silent: boolean
) => boolean;

type RuleInline

type RuleInline = (state: StateInline, silent: boolean) => boolean;

type RuleInline2

type RuleInline2 = (state: StateInline) => boolean;

type RenderRule

type RenderRule = (
    tokens: Token[],
    idx: number,
    options: MarkdownIt.Options,
    env: any,
    self: Renderer
) => string;

type ParentType

type ParentType = 'blockquote' | 'list' | 'root' | 'paragraph' | 'reference';

type Nesting

type Nesting = 1 | 0 | -1;