marked

  • Version 15.0.3
  • Published
  • 956 kB
  • No dependencies
  • MIT license

Install

npm i marked
yarn add marked
pnpm add marked

Overview

A markdown parser built for speed

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable blockNormal

const blockNormal: {
blockquote: RegExp;
code: RegExp;
def: RegExp;
fences: RegExp;
heading: RegExp;
hr: RegExp;
html: RegExp;
lheading: RegExp;
list: RegExp;
newline: RegExp;
paragraph: RegExp;
table: RegExp;
text: RegExp;
};

    variable defaults

    let defaults: MarkedOptions;

      variable inlineNormal

      const inlineNormal: {
      _backpedal: RegExp;
      anyPunctuation: RegExp;
      autolink: RegExp;
      blockSkip: RegExp;
      br: RegExp;
      code: RegExp;
      del: RegExp;
      emStrongLDelim: RegExp;
      emStrongRDelimAst: RegExp;
      emStrongRDelimUnd: RegExp;
      escape: RegExp;
      link: RegExp;
      nolink: RegExp;
      punctuation: RegExp;
      reflink: RegExp;
      reflinkSearch: RegExp;
      tag: RegExp;
      text: RegExp;
      url: RegExp;
      };

        variable lexer

        const lexer: (src: string, options?: MarkedOptions) => TokensList;

          variable other

          const other: {
          codeRemoveIndent: RegExp;
          outputLinkReplace: RegExp;
          indentCodeCompensation: RegExp;
          beginningSpace: RegExp;
          endingHash: RegExp;
          startingSpaceChar: RegExp;
          endingSpaceChar: RegExp;
          nonSpaceChar: RegExp;
          newLineCharGlobal: RegExp;
          tabCharGlobal: RegExp;
          multipleSpaceGlobal: RegExp;
          blankLine: RegExp;
          doubleBlankLine: RegExp;
          blockquoteStart: RegExp;
          blockquoteSetextReplace: RegExp;
          blockquoteSetextReplace2: RegExp;
          listReplaceTabs: RegExp;
          listReplaceNesting: RegExp;
          listIsTask: RegExp;
          listReplaceTask: RegExp;
          anyLine: RegExp;
          hrefBrackets: RegExp;
          tableDelimiter: RegExp;
          tableAlignChars: RegExp;
          tableRowBlankLine: RegExp;
          tableAlignRight: RegExp;
          tableAlignCenter: RegExp;
          tableAlignLeft: RegExp;
          startATag: RegExp;
          endATag: RegExp;
          startPreScriptTag: RegExp;
          endPreScriptTag: RegExp;
          startAngleBracket: RegExp;
          endAngleBracket: RegExp;
          pedanticHrefTitle: RegExp;
          unicodeAlphaNumeric: RegExp;
          escapeTest: RegExp;
          escapeReplace: RegExp;
          escapeTestNoEncode: RegExp;
          escapeReplaceNoEncode: RegExp;
          unescapeTest: RegExp;
          caret: RegExp;
          percentDecode: RegExp;
          findPipe: RegExp;
          splitPipe: RegExp;
          slashPipe: RegExp;
          carriageReturn: RegExp;
          spaceLine: RegExp;
          notSpaceStart: RegExp;
          endingNewline: RegExp;
          listItemRegex: (bull: string) => RegExp;
          nextBulletRegex: (indent: number) => RegExp;
          hrRegex: (indent: number) => RegExp;
          fencesBeginRegex: (indent: number) => RegExp;
          headingBeginRegex: (indent: number) => RegExp;
          htmlBeginRegex: (indent: number) => RegExp;
          };

            variable parse

            const parse: typeof marked;

              variable parseInline

              const parseInline: {
              (src: string, options: MarkedOptions & { async: true }): Promise<string>;
              (src: string, options: MarkedOptions & { async: false }): string;
              (src: string, options?: MarkedOptions | null): string | Promise<string>;
              };

                variable parser

                const parser: (tokens: Token[], options?: MarkedOptions) => string;

                  Functions

                  function getDefaults

                  getDefaults: () => MarkedOptions;
                  • Gets the original marked default options.

                  function marked

                  marked: typeof marked;
                  • Compiles markdown to HTML asynchronously.

                    Parameter src

                    String of markdown source to be compiled

                    Parameter options

                    Hash of options, having async: true Promise of string of compiled HTML

                  • Compiles markdown to HTML.

                    Parameter src

                    String of markdown source to be compiled

                    Parameter options

                    Optional hash of options String of compiled HTML. Will be a Promise of string if async is set to true by any extensions.

                  function options

                  options: (options: MarkedOptions) => typeof marked;

                    function setOptions

                    setOptions: (options: MarkedOptions) => typeof marked;

                      function use

                      use: (...args: MarkedExtension[]) => typeof marked;

                        function walkTokens

                        walkTokens: (
                        tokens: Token[] | TokensList,
                        callback: (token: Token) => MaybePromise | MaybePromise[]
                        ) => MaybePromise[];

                          Classes

                          class Hooks

                          class _Hooks {}

                            constructor

                            constructor(options?: MarkedOptions);

                              property block

                              block?: boolean;

                                property options

                                options: MarkedOptions;

                                  property passThroughHooks

                                  static passThroughHooks: Set<string>;

                                    method postprocess

                                    postprocess: (html: string) => string;
                                    • Process HTML after marked is finished

                                    method preprocess

                                    preprocess: (markdown: string) => string;
                                    • Process markdown before marked

                                    method processAllTokens

                                    processAllTokens: (tokens: Token[] | TokensList) => Token[] | TokensList;
                                    • Process all tokens before walk tokens

                                    method provideLexer

                                    provideLexer: () => typeof _Lexer.lexInline;
                                    • Provide function to tokenize markdown

                                    method provideParser

                                    provideParser: () => typeof _Parser.parse;
                                    • Provide function to parse tokens

                                    class Lexer

                                    class _Lexer {}
                                    • Block Lexer

                                    constructor

                                    constructor(options?: MarkedOptions);

                                      property options

                                      options: MarkedOptions;

                                        property rules

                                        static readonly rules: {
                                        block: {
                                        normal: {
                                        blockquote: RegExp;
                                        code: RegExp;
                                        def: RegExp;
                                        fences: RegExp;
                                        heading: RegExp;
                                        hr: RegExp;
                                        html: RegExp;
                                        lheading: RegExp;
                                        list: RegExp;
                                        newline: RegExp;
                                        paragraph: RegExp;
                                        table: RegExp;
                                        text: RegExp;
                                        };
                                        gfm: Record<
                                        | 'code'
                                        | 'blockquote'
                                        | 'hr'
                                        | 'html'
                                        | 'table'
                                        | 'text'
                                        | 'def'
                                        | 'heading'
                                        | 'list'
                                        | 'paragraph'
                                        | 'fences'
                                        | 'lheading'
                                        | 'newline',
                                        RegExp
                                        >;
                                        pedantic: Record<
                                        | 'code'
                                        | 'blockquote'
                                        | 'hr'
                                        | 'html'
                                        | 'table'
                                        | 'text'
                                        | 'def'
                                        | 'heading'
                                        | 'list'
                                        | 'paragraph'
                                        | 'fences'
                                        | 'lheading'
                                        | 'newline',
                                        RegExp
                                        >;
                                        };
                                        inline: {
                                        normal: {
                                        _backpedal: RegExp;
                                        anyPunctuation: RegExp;
                                        autolink: RegExp;
                                        blockSkip: RegExp;
                                        br: RegExp;
                                        code: RegExp;
                                        del: RegExp;
                                        emStrongLDelim: RegExp;
                                        emStrongRDelimAst: RegExp;
                                        emStrongRDelimUnd: RegExp;
                                        escape: RegExp;
                                        link: RegExp;
                                        nolink: RegExp;
                                        punctuation: RegExp;
                                        reflink: RegExp;
                                        reflinkSearch: RegExp;
                                        tag: RegExp;
                                        text: RegExp;
                                        url: RegExp;
                                        };
                                        gfm: Record<
                                        | 'link'
                                        | 'code'
                                        | 'url'
                                        | 'br'
                                        | 'del'
                                        | 'text'
                                        | 'escape'
                                        | 'tag'
                                        | 'reflink'
                                        | 'nolink'
                                        | '_backpedal'
                                        | 'anyPunctuation'
                                        | 'autolink'
                                        | 'blockSkip'
                                        | 'emStrongLDelim'
                                        | 'emStrongRDelimAst'
                                        | 'emStrongRDelimUnd'
                                        | 'punctuation'
                                        | 'reflinkSearch',
                                        RegExp
                                        >;
                                        breaks: Record<
                                        | 'link'
                                        | 'code'
                                        | 'url'
                                        | 'br'
                                        | 'del'
                                        | 'text'
                                        | 'escape'
                                        | 'tag'
                                        | 'reflink'
                                        | 'nolink'
                                        | '_backpedal'
                                        | 'anyPunctuation'
                                        | 'autolink'
                                        | 'blockSkip'
                                        | 'emStrongLDelim'
                                        | 'emStrongRDelimAst'
                                        | 'emStrongRDelimUnd'
                                        | 'punctuation'
                                        | 'reflinkSearch',
                                        RegExp
                                        >;
                                        pedantic: Record<
                                        | 'link'
                                        | 'code'
                                        | 'url'
                                        | 'br'
                                        | 'del'
                                        | 'text'
                                        | 'escape'
                                        | 'tag'
                                        | 'reflink'
                                        | 'nolink'
                                        | '_backpedal'
                                        | 'anyPunctuation'
                                        | 'autolink'
                                        | 'blockSkip'
                                        | 'emStrongLDelim'
                                        | 'emStrongRDelimAst'
                                        | 'emStrongRDelimUnd'
                                        | 'punctuation'
                                        | 'reflinkSearch',
                                        RegExp
                                        >;
                                        };
                                        };
                                        • Expose Rules

                                        property state

                                        state: { inLink: boolean; inRawBlock: boolean; top: boolean };

                                          property tokens

                                          tokens: Token[] & { links: Links };

                                            method blockTokens

                                            blockTokens: {
                                            (src: string, tokens?: Token[], lastParagraphClipped?: boolean): Token[];
                                            (
                                            src: string,
                                            tokens?: TokensList,
                                            lastParagraphClipped?: boolean
                                            ): TokensList;
                                            };
                                            • Lexing

                                            method inline

                                            inline: (src: string, tokens?: Token[]) => Token[];

                                              method inlineTokens

                                              inlineTokens: (src: string, tokens?: Token[]) => Token[];
                                              • Lexing/Compiling

                                              method lex

                                              static lex: (src: string, options?: MarkedOptions) => TokensList;
                                              • Static Lex Method

                                              • Preprocessing

                                              method lexInline

                                              static lexInline: (src: string, options?: MarkedOptions) => Token[];
                                              • Static Lex Inline Method

                                              class Marked

                                              class Marked {}

                                                constructor

                                                constructor(...args: MarkedExtension[]);

                                                  property defaults

                                                  defaults: MarkedOptions;

                                                    property Hooks

                                                    Hooks: typeof _Hooks;

                                                      property Lexer

                                                      Lexer: typeof _Lexer;

                                                        property options

                                                        options: (opt: MarkedOptions) => this;

                                                          property parse

                                                          parse: {
                                                          (src: string, options: MarkedOptions & { async: true }): Promise<string>;
                                                          (src: string, options: MarkedOptions & { async: false }): string;
                                                          (src: string, options?: MarkedOptions | null): string | Promise<string>;
                                                          };

                                                            property parseInline

                                                            parseInline: {
                                                            (src: string, options: MarkedOptions & { async: true }): Promise<string>;
                                                            (src: string, options: MarkedOptions & { async: false }): string;
                                                            (src: string, options?: MarkedOptions | null): string | Promise<string>;
                                                            };

                                                              property Parser

                                                              Parser: typeof _Parser;

                                                                property Renderer

                                                                Renderer: typeof _Renderer;

                                                                  property TextRenderer

                                                                  TextRenderer: typeof _TextRenderer;

                                                                    property Tokenizer

                                                                    Tokenizer: typeof _Tokenizer;

                                                                      method lexer

                                                                      lexer: (src: string, options?: MarkedOptions) => TokensList;

                                                                        method parser

                                                                        parser: (tokens: Token[], options?: MarkedOptions) => string;

                                                                          method setOptions

                                                                          setOptions: (opt: MarkedOptions) => this;

                                                                            method use

                                                                            use: (...args: MarkedExtension[]) => this;

                                                                              method walkTokens

                                                                              walkTokens: (
                                                                              tokens: Token[] | TokensList,
                                                                              callback: (token: Token) => MaybePromise | MaybePromise[]
                                                                              ) => MaybePromise[];
                                                                              • Run callback for every token

                                                                              class Parser

                                                                              class _Parser {}
                                                                              • Parsing & Compiling

                                                                              constructor

                                                                              constructor(options?: MarkedOptions);

                                                                                property options

                                                                                options: MarkedOptions;

                                                                                  property renderer

                                                                                  renderer: _Renderer;

                                                                                    property textRenderer

                                                                                    textRenderer: _TextRenderer;

                                                                                      method parse

                                                                                      static parse: (tokens: Token[], options?: MarkedOptions) => string;
                                                                                      • Static Parse Method

                                                                                      • Parse Loop

                                                                                      method parseInline

                                                                                      static parseInline: (tokens: Token[], options?: MarkedOptions) => string;
                                                                                      • Static Parse Inline Method

                                                                                      • Parse Inline Tokens

                                                                                      class Renderer

                                                                                      class _Renderer {}
                                                                                      • Renderer

                                                                                      constructor

                                                                                      constructor(options?: MarkedOptions);

                                                                                        property options

                                                                                        options: MarkedOptions;

                                                                                          property parser

                                                                                          parser: _Parser;

                                                                                            method blockquote

                                                                                            blockquote: ({ tokens }: Tokens.Blockquote) => string;

                                                                                              method br

                                                                                              br: (token: Tokens.Br) => string;

                                                                                                method checkbox

                                                                                                checkbox: ({ checked }: Tokens.Checkbox) => string;

                                                                                                  method code

                                                                                                  code: ({ text, lang, escaped }: Tokens.Code) => string;

                                                                                                    method codespan

                                                                                                    codespan: ({ text }: Tokens.Codespan) => string;

                                                                                                      method del

                                                                                                      del: ({ tokens }: Tokens.Del) => string;

                                                                                                        method em

                                                                                                        em: ({ tokens }: Tokens.Em) => string;

                                                                                                          method heading

                                                                                                          heading: ({ tokens, depth }: Tokens.Heading) => string;

                                                                                                            method hr

                                                                                                            hr: (token: Tokens.Hr) => string;

                                                                                                              method html

                                                                                                              html: ({ text }: Tokens.HTML | Tokens.Tag) => string;

                                                                                                                method image

                                                                                                                image: ({ href, title, text }: Tokens.Image) => string;
                                                                                                                  link: ({ href, title, tokens }: Tokens.Link) => string;

                                                                                                                    method list

                                                                                                                    list: (token: Tokens.List) => string;

                                                                                                                      method listitem

                                                                                                                      listitem: (item: Tokens.ListItem) => string;

                                                                                                                        method paragraph

                                                                                                                        paragraph: ({ tokens }: Tokens.Paragraph) => string;

                                                                                                                          method space

                                                                                                                          space: (token: Tokens.Space) => string;

                                                                                                                            method strong

                                                                                                                            strong: ({ tokens }: Tokens.Strong) => string;
                                                                                                                            • span level renderer

                                                                                                                            method table

                                                                                                                            table: (token: Tokens.Table) => string;

                                                                                                                              method tablecell

                                                                                                                              tablecell: (token: Tokens.TableCell) => string;

                                                                                                                                method tablerow

                                                                                                                                tablerow: ({ text }: Tokens.TableRow) => string;

                                                                                                                                  method text

                                                                                                                                  text: (token: Tokens.Text | Tokens.Escape) => string;

                                                                                                                                    class TextRenderer

                                                                                                                                    class _TextRenderer {}
                                                                                                                                    • TextRenderer returns only the textual part of the token

                                                                                                                                    method br

                                                                                                                                    br: () => string;

                                                                                                                                      method codespan

                                                                                                                                      codespan: ({ text }: Tokens.Codespan) => string;

                                                                                                                                        method del

                                                                                                                                        del: ({ text }: Tokens.Del) => string;

                                                                                                                                          method em

                                                                                                                                          em: ({ text }: Tokens.Em) => string;

                                                                                                                                            method html

                                                                                                                                            html: ({ text }: Tokens.HTML | Tokens.Tag) => string;

                                                                                                                                              method image

                                                                                                                                              image: ({ text }: Tokens.Image) => string;
                                                                                                                                                link: ({ text }: Tokens.Link) => string;

                                                                                                                                                  method strong

                                                                                                                                                  strong: ({ text }: Tokens.Strong) => string;

                                                                                                                                                    method text

                                                                                                                                                    text: ({ text }: Tokens.Text | Tokens.Escape | Tokens.Tag) => string;

                                                                                                                                                      class Tokenizer

                                                                                                                                                      class _Tokenizer {}
                                                                                                                                                      • Tokenizer

                                                                                                                                                      constructor

                                                                                                                                                      constructor(options?: MarkedOptions);

                                                                                                                                                        property lexer

                                                                                                                                                        lexer: _Lexer;

                                                                                                                                                          property options

                                                                                                                                                          options: MarkedOptions;

                                                                                                                                                            property rules

                                                                                                                                                            rules: Rules;
                                                                                                                                                              autolink: (src: string) => Tokens.Link | undefined;

                                                                                                                                                                method blockquote

                                                                                                                                                                blockquote: (src: string) => Tokens.Blockquote | undefined;

                                                                                                                                                                  method br

                                                                                                                                                                  br: (src: string) => Tokens.Br | undefined;

                                                                                                                                                                    method code

                                                                                                                                                                    code: (src: string) => Tokens.Code | undefined;

                                                                                                                                                                      method codespan

                                                                                                                                                                      codespan: (src: string) => Tokens.Codespan | undefined;

                                                                                                                                                                        method def

                                                                                                                                                                        def: (src: string) => Tokens.Def | undefined;

                                                                                                                                                                          method del

                                                                                                                                                                          del: (src: string) => Tokens.Del | undefined;

                                                                                                                                                                            method emStrong

                                                                                                                                                                            emStrong: (
                                                                                                                                                                            src: string,
                                                                                                                                                                            maskedSrc: string,
                                                                                                                                                                            prevChar?: string
                                                                                                                                                                            ) => Tokens.Em | Tokens.Strong | undefined;

                                                                                                                                                                              method escape

                                                                                                                                                                              escape: (src: string) => Tokens.Escape | undefined;

                                                                                                                                                                                method fences

                                                                                                                                                                                fences: (src: string) => Tokens.Code | undefined;

                                                                                                                                                                                  method heading

                                                                                                                                                                                  heading: (src: string) => Tokens.Heading | undefined;

                                                                                                                                                                                    method hr

                                                                                                                                                                                    hr: (src: string) => Tokens.Hr | undefined;

                                                                                                                                                                                      method html

                                                                                                                                                                                      html: (src: string) => Tokens.HTML | undefined;

                                                                                                                                                                                        method inlineText

                                                                                                                                                                                        inlineText: (src: string) => Tokens.Text | undefined;

                                                                                                                                                                                          method lheading

                                                                                                                                                                                          lheading: (src: string) => Tokens.Heading | undefined;
                                                                                                                                                                                            link: (src: string) => Tokens.Link | Tokens.Image | undefined;

                                                                                                                                                                                              method list

                                                                                                                                                                                              list: (src: string) => Tokens.List | undefined;

                                                                                                                                                                                                method paragraph

                                                                                                                                                                                                paragraph: (src: string) => Tokens.Paragraph | undefined;
                                                                                                                                                                                                  reflink: (
                                                                                                                                                                                                  src: string,
                                                                                                                                                                                                  links: Links
                                                                                                                                                                                                  ) => Tokens.Link | Tokens.Image | Tokens.Text | undefined;

                                                                                                                                                                                                    method space

                                                                                                                                                                                                    space: (src: string) => Tokens.Space | undefined;

                                                                                                                                                                                                      method table

                                                                                                                                                                                                      table: (src: string) => Tokens.Table | undefined;

                                                                                                                                                                                                        method tag

                                                                                                                                                                                                        tag: (src: string) => Tokens.Tag | undefined;

                                                                                                                                                                                                          method text

                                                                                                                                                                                                          text: (src: string) => Tokens.Text | undefined;

                                                                                                                                                                                                            method url

                                                                                                                                                                                                            url: (src: string) => Tokens.Link | undefined;

                                                                                                                                                                                                              Interfaces

                                                                                                                                                                                                              interface MarkedExtension

                                                                                                                                                                                                              interface MarkedExtension {}

                                                                                                                                                                                                                property async

                                                                                                                                                                                                                async?: boolean;
                                                                                                                                                                                                                • True will tell marked to await any walkTokens functions before parsing the tokens and returning an HTML string.

                                                                                                                                                                                                                property breaks

                                                                                                                                                                                                                breaks?: boolean;
                                                                                                                                                                                                                • Enable GFM line breaks. This option requires the gfm option to be true.

                                                                                                                                                                                                                property extensions

                                                                                                                                                                                                                extensions?: TokenizerAndRendererExtension[] | null;
                                                                                                                                                                                                                • Add tokenizers and renderers to marked

                                                                                                                                                                                                                property gfm

                                                                                                                                                                                                                gfm?: boolean;
                                                                                                                                                                                                                • Enable GitHub flavored markdown.

                                                                                                                                                                                                                property hooks

                                                                                                                                                                                                                hooks?: HooksObject | null;
                                                                                                                                                                                                                • Hooks are methods that hook into some part of marked. preprocess is called to process markdown before sending it to marked. processAllTokens is called with the TokensList before walkTokens. postprocess is called to process html after marked has finished parsing. provideLexer is called to provide a function to tokenize markdown. provideParser is called to provide a function to parse tokens.

                                                                                                                                                                                                                property pedantic

                                                                                                                                                                                                                pedantic?: boolean;
                                                                                                                                                                                                                • Conform to obscure parts of markdown.pl as much as possible. Don't fix any of the original markdown bugs or poor behavior.

                                                                                                                                                                                                                property renderer

                                                                                                                                                                                                                renderer?: RendererObject | null;
                                                                                                                                                                                                                • Type: object Default: new Renderer()

                                                                                                                                                                                                                  An object containing functions to render tokens to HTML.

                                                                                                                                                                                                                property silent

                                                                                                                                                                                                                silent?: boolean;
                                                                                                                                                                                                                • Shows an HTML error message when rendering fails.

                                                                                                                                                                                                                property tokenizer

                                                                                                                                                                                                                tokenizer?: TokenizerObject | null;
                                                                                                                                                                                                                • The tokenizer defines how to turn markdown text into tokens.

                                                                                                                                                                                                                property walkTokens

                                                                                                                                                                                                                walkTokens?: ((token: Token) => void | Promise<void>) | null;
                                                                                                                                                                                                                • The walkTokens function gets called with every token. Child tokens are called before moving on to sibling tokens. Each token is passed by reference so updates are persisted when passed to the parser. The return value of the function is ignored.

                                                                                                                                                                                                                interface MarkedOptions

                                                                                                                                                                                                                interface MarkedOptions
                                                                                                                                                                                                                extends Omit<
                                                                                                                                                                                                                MarkedExtension,
                                                                                                                                                                                                                'hooks' | 'renderer' | 'tokenizer' | 'extensions' | 'walkTokens'
                                                                                                                                                                                                                > {}

                                                                                                                                                                                                                  property extensions

                                                                                                                                                                                                                  extensions?: null | {
                                                                                                                                                                                                                  renderers: {
                                                                                                                                                                                                                  [name: string]: RendererExtensionFunction;
                                                                                                                                                                                                                  };
                                                                                                                                                                                                                  childTokens: {
                                                                                                                                                                                                                  [name: string]: string[];
                                                                                                                                                                                                                  };
                                                                                                                                                                                                                  inline?: TokenizerExtensionFunction[];
                                                                                                                                                                                                                  block?: TokenizerExtensionFunction[];
                                                                                                                                                                                                                  startInline?: TokenizerStartFunction[];
                                                                                                                                                                                                                  startBlock?: TokenizerStartFunction[];
                                                                                                                                                                                                                  };
                                                                                                                                                                                                                  • Custom extensions

                                                                                                                                                                                                                  property hooks

                                                                                                                                                                                                                  hooks?: _Hooks | null;
                                                                                                                                                                                                                  • Hooks are methods that hook into some part of marked.

                                                                                                                                                                                                                  property renderer

                                                                                                                                                                                                                  renderer?: _Renderer | null;
                                                                                                                                                                                                                  • Type: object Default: new Renderer()

                                                                                                                                                                                                                    An object containing functions to render tokens to HTML.

                                                                                                                                                                                                                  property tokenizer

                                                                                                                                                                                                                  tokenizer?: _Tokenizer | null;
                                                                                                                                                                                                                  • The tokenizer defines how to turn markdown text into tokens.

                                                                                                                                                                                                                  property walkTokens

                                                                                                                                                                                                                  walkTokens?:
                                                                                                                                                                                                                  | null
                                                                                                                                                                                                                  | ((token: Token) => void | Promise<void> | (void | Promise<void>)[]);
                                                                                                                                                                                                                  • walkTokens function returns array of values for Promise.all

                                                                                                                                                                                                                  interface RendererExtension

                                                                                                                                                                                                                  interface RendererExtension {}

                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                      property renderer

                                                                                                                                                                                                                      renderer: RendererExtensionFunction;

                                                                                                                                                                                                                        interface RendererThis

                                                                                                                                                                                                                        interface RendererThis {}

                                                                                                                                                                                                                          property parser

                                                                                                                                                                                                                          parser: _Parser;

                                                                                                                                                                                                                            interface Rules

                                                                                                                                                                                                                            interface Rules {}

                                                                                                                                                                                                                              property block

                                                                                                                                                                                                                              block: Record<BlockKeys, RegExp>;

                                                                                                                                                                                                                                property inline

                                                                                                                                                                                                                                inline: Record<InlineKeys, RegExp>;

                                                                                                                                                                                                                                  property other

                                                                                                                                                                                                                                  other: typeof other;

                                                                                                                                                                                                                                    interface TokenizerExtension

                                                                                                                                                                                                                                    interface TokenizerExtension {}

                                                                                                                                                                                                                                      property childTokens

                                                                                                                                                                                                                                      childTokens?: string[];

                                                                                                                                                                                                                                        property level

                                                                                                                                                                                                                                        level: 'block' | 'inline';

                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                            property start

                                                                                                                                                                                                                                            start?: TokenizerStartFunction;

                                                                                                                                                                                                                                              property tokenizer

                                                                                                                                                                                                                                              tokenizer: TokenizerExtensionFunction;

                                                                                                                                                                                                                                                interface TokenizerThis

                                                                                                                                                                                                                                                interface TokenizerThis {}

                                                                                                                                                                                                                                                  property lexer

                                                                                                                                                                                                                                                  lexer: _Lexer;

                                                                                                                                                                                                                                                    Type Aliases

                                                                                                                                                                                                                                                    type BlockKeys

                                                                                                                                                                                                                                                    type BlockKeys = keyof typeof blockNormal;

                                                                                                                                                                                                                                                      type HooksApi

                                                                                                                                                                                                                                                      type HooksApi = Omit<_Hooks, 'constructor' | 'options' | 'block'>;

                                                                                                                                                                                                                                                        type HooksObject

                                                                                                                                                                                                                                                        type HooksObject = {
                                                                                                                                                                                                                                                        [K in keyof HooksApi]?: (
                                                                                                                                                                                                                                                        this: _Hooks,
                                                                                                                                                                                                                                                        ...args: Parameters<HooksApi[K]>
                                                                                                                                                                                                                                                        ) => ReturnType<HooksApi[K]> | Promise<ReturnType<HooksApi[K]>>;
                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                          type InlineKeys

                                                                                                                                                                                                                                                          type InlineKeys = keyof typeof inlineNormal;
                                                                                                                                                                                                                                                            type Links = Record<string, Pick<Tokens.Link | Tokens.Image, 'href' | 'title'>>;

                                                                                                                                                                                                                                                              type MarkedToken

                                                                                                                                                                                                                                                              type MarkedToken =
                                                                                                                                                                                                                                                              | Tokens.Blockquote
                                                                                                                                                                                                                                                              | Tokens.Br
                                                                                                                                                                                                                                                              | Tokens.Code
                                                                                                                                                                                                                                                              | Tokens.Codespan
                                                                                                                                                                                                                                                              | Tokens.Def
                                                                                                                                                                                                                                                              | Tokens.Del
                                                                                                                                                                                                                                                              | Tokens.Em
                                                                                                                                                                                                                                                              | Tokens.Escape
                                                                                                                                                                                                                                                              | Tokens.Heading
                                                                                                                                                                                                                                                              | Tokens.Hr
                                                                                                                                                                                                                                                              | Tokens.HTML
                                                                                                                                                                                                                                                              | Tokens.Image
                                                                                                                                                                                                                                                              | Tokens.Link
                                                                                                                                                                                                                                                              | Tokens.List
                                                                                                                                                                                                                                                              | Tokens.ListItem
                                                                                                                                                                                                                                                              | Tokens.Paragraph
                                                                                                                                                                                                                                                              | Tokens.Space
                                                                                                                                                                                                                                                              | Tokens.Strong
                                                                                                                                                                                                                                                              | Tokens.Table
                                                                                                                                                                                                                                                              | Tokens.Tag
                                                                                                                                                                                                                                                              | Tokens.Text;

                                                                                                                                                                                                                                                                type MaybePromise

                                                                                                                                                                                                                                                                type MaybePromise = void | Promise<void>;

                                                                                                                                                                                                                                                                  type RendererApi

                                                                                                                                                                                                                                                                  type RendererApi = Omit<_Renderer, 'constructor' | 'options' | 'parser'>;

                                                                                                                                                                                                                                                                    type RendererExtensionFunction

                                                                                                                                                                                                                                                                    type RendererExtensionFunction = (
                                                                                                                                                                                                                                                                    this: RendererThis,
                                                                                                                                                                                                                                                                    token: Tokens.Generic
                                                                                                                                                                                                                                                                    ) => string | false | undefined;

                                                                                                                                                                                                                                                                      type RendererObject

                                                                                                                                                                                                                                                                      type RendererObject = {
                                                                                                                                                                                                                                                                      [K in keyof RendererApi]?: (
                                                                                                                                                                                                                                                                      this: _Renderer,
                                                                                                                                                                                                                                                                      ...args: Parameters<RendererApi[K]>
                                                                                                                                                                                                                                                                      ) => ReturnType<RendererApi[K]> | false;
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        type Token

                                                                                                                                                                                                                                                                        type Token = MarkedToken | Tokens.Generic;

                                                                                                                                                                                                                                                                          type TokenizerAndRendererExtension

                                                                                                                                                                                                                                                                          type TokenizerAndRendererExtension =
                                                                                                                                                                                                                                                                          | TokenizerExtension
                                                                                                                                                                                                                                                                          | RendererExtension
                                                                                                                                                                                                                                                                          | (TokenizerExtension & RendererExtension);

                                                                                                                                                                                                                                                                            type TokenizerApi

                                                                                                                                                                                                                                                                            type TokenizerApi = Omit<_Tokenizer, 'constructor' | 'options' | 'rules' | 'lexer'>;

                                                                                                                                                                                                                                                                              type TokenizerExtensionFunction

                                                                                                                                                                                                                                                                              type TokenizerExtensionFunction = (
                                                                                                                                                                                                                                                                              this: TokenizerThis,
                                                                                                                                                                                                                                                                              src: string,
                                                                                                                                                                                                                                                                              tokens: Token[] | TokensList
                                                                                                                                                                                                                                                                              ) => Tokens.Generic | undefined;

                                                                                                                                                                                                                                                                                type TokenizerObject

                                                                                                                                                                                                                                                                                type TokenizerObject = {
                                                                                                                                                                                                                                                                                [K in keyof TokenizerApi]?: (
                                                                                                                                                                                                                                                                                this: _Tokenizer,
                                                                                                                                                                                                                                                                                ...args: Parameters<TokenizerApi[K]>
                                                                                                                                                                                                                                                                                ) => ReturnType<TokenizerApi[K]> | false;
                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                  type TokenizerStartFunction

                                                                                                                                                                                                                                                                                  type TokenizerStartFunction = (this: TokenizerThis, src: string) => number | void;

                                                                                                                                                                                                                                                                                    type TokensList

                                                                                                                                                                                                                                                                                    type TokensList = Token[] & {
                                                                                                                                                                                                                                                                                    links: Links;
                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                      Namespaces

                                                                                                                                                                                                                                                                                      namespace marked

                                                                                                                                                                                                                                                                                      namespace marked {}

                                                                                                                                                                                                                                                                                        variable defaults

                                                                                                                                                                                                                                                                                        var defaults: MarkedOptions;

                                                                                                                                                                                                                                                                                          variable getDefaults

                                                                                                                                                                                                                                                                                          var getDefaults: () => MarkedOptions;

                                                                                                                                                                                                                                                                                            variable Hooks

                                                                                                                                                                                                                                                                                            var Hooks: typeof _Hooks;

                                                                                                                                                                                                                                                                                              variable lexer

                                                                                                                                                                                                                                                                                              var lexer: (src: string, options?: MarkedOptions) => TokensList;

                                                                                                                                                                                                                                                                                                variable Lexer

                                                                                                                                                                                                                                                                                                var Lexer: typeof _Lexer;

                                                                                                                                                                                                                                                                                                  variable parse

                                                                                                                                                                                                                                                                                                  var parse: typeof marked;

                                                                                                                                                                                                                                                                                                    variable parseInline

                                                                                                                                                                                                                                                                                                    var parseInline: {
                                                                                                                                                                                                                                                                                                    (src: string, options: MarkedOptions & { async: true }): Promise<string>;
                                                                                                                                                                                                                                                                                                    (src: string, options: MarkedOptions & { async: false }): string;
                                                                                                                                                                                                                                                                                                    (src: string, options?: MarkedOptions | null): string | Promise<string>;
                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                      variable parser

                                                                                                                                                                                                                                                                                                      var parser: (tokens: Token[], options?: MarkedOptions) => string;

                                                                                                                                                                                                                                                                                                        variable Parser

                                                                                                                                                                                                                                                                                                        var Parser: typeof _Parser;

                                                                                                                                                                                                                                                                                                          variable Renderer

                                                                                                                                                                                                                                                                                                          var Renderer: typeof _Renderer;

                                                                                                                                                                                                                                                                                                            variable TextRenderer

                                                                                                                                                                                                                                                                                                            var TextRenderer: typeof _TextRenderer;

                                                                                                                                                                                                                                                                                                              variable Tokenizer

                                                                                                                                                                                                                                                                                                              var Tokenizer: typeof _Tokenizer;

                                                                                                                                                                                                                                                                                                                function options

                                                                                                                                                                                                                                                                                                                options: (options: MarkedOptions) => typeof marked;

                                                                                                                                                                                                                                                                                                                  function setOptions

                                                                                                                                                                                                                                                                                                                  setOptions: (options: MarkedOptions) => typeof marked;

                                                                                                                                                                                                                                                                                                                    function use

                                                                                                                                                                                                                                                                                                                    use: (...args: MarkedExtension[]) => typeof marked;

                                                                                                                                                                                                                                                                                                                      function walkTokens

                                                                                                                                                                                                                                                                                                                      walkTokens: (
                                                                                                                                                                                                                                                                                                                      tokens: Token[] | TokensList,
                                                                                                                                                                                                                                                                                                                      callback: (token: Token) => MaybePromise | MaybePromise[]
                                                                                                                                                                                                                                                                                                                      ) => MaybePromise[];

                                                                                                                                                                                                                                                                                                                        namespace Tokens

                                                                                                                                                                                                                                                                                                                        namespace Tokens {}

                                                                                                                                                                                                                                                                                                                          interface Blockquote

                                                                                                                                                                                                                                                                                                                          interface Blockquote {}

                                                                                                                                                                                                                                                                                                                            property raw

                                                                                                                                                                                                                                                                                                                            raw: string;

                                                                                                                                                                                                                                                                                                                              property text

                                                                                                                                                                                                                                                                                                                              text: string;

                                                                                                                                                                                                                                                                                                                                property tokens

                                                                                                                                                                                                                                                                                                                                tokens: Token[];

                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                  type: 'blockquote';

                                                                                                                                                                                                                                                                                                                                    interface Br

                                                                                                                                                                                                                                                                                                                                    interface Br {}

                                                                                                                                                                                                                                                                                                                                      property raw

                                                                                                                                                                                                                                                                                                                                      raw: string;

                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                        type: 'br';

                                                                                                                                                                                                                                                                                                                                          interface Checkbox

                                                                                                                                                                                                                                                                                                                                          interface Checkbox {}

                                                                                                                                                                                                                                                                                                                                            property checked

                                                                                                                                                                                                                                                                                                                                            checked: boolean;

                                                                                                                                                                                                                                                                                                                                              interface Code

                                                                                                                                                                                                                                                                                                                                              interface Code {}

                                                                                                                                                                                                                                                                                                                                                property codeBlockStyle

                                                                                                                                                                                                                                                                                                                                                codeBlockStyle?: 'indented';

                                                                                                                                                                                                                                                                                                                                                  property escaped

                                                                                                                                                                                                                                                                                                                                                  escaped?: boolean;

                                                                                                                                                                                                                                                                                                                                                    property lang

                                                                                                                                                                                                                                                                                                                                                    lang?: string;

                                                                                                                                                                                                                                                                                                                                                      property raw

                                                                                                                                                                                                                                                                                                                                                      raw: string;

                                                                                                                                                                                                                                                                                                                                                        property text

                                                                                                                                                                                                                                                                                                                                                        text: string;

                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                          type: 'code';

                                                                                                                                                                                                                                                                                                                                                            interface Codespan

                                                                                                                                                                                                                                                                                                                                                            interface Codespan {}

                                                                                                                                                                                                                                                                                                                                                              property raw

                                                                                                                                                                                                                                                                                                                                                              raw: string;

                                                                                                                                                                                                                                                                                                                                                                property text

                                                                                                                                                                                                                                                                                                                                                                text: string;

                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                  type: 'codespan';

                                                                                                                                                                                                                                                                                                                                                                    interface Def

                                                                                                                                                                                                                                                                                                                                                                    interface Def {}

                                                                                                                                                                                                                                                                                                                                                                      property href

                                                                                                                                                                                                                                                                                                                                                                      href: string;

                                                                                                                                                                                                                                                                                                                                                                        property raw

                                                                                                                                                                                                                                                                                                                                                                        raw: string;

                                                                                                                                                                                                                                                                                                                                                                          property tag

                                                                                                                                                                                                                                                                                                                                                                          tag: string;

                                                                                                                                                                                                                                                                                                                                                                            property title

                                                                                                                                                                                                                                                                                                                                                                            title: string;

                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                              type: 'def';

                                                                                                                                                                                                                                                                                                                                                                                interface Del

                                                                                                                                                                                                                                                                                                                                                                                interface Del {}

                                                                                                                                                                                                                                                                                                                                                                                  property raw

                                                                                                                                                                                                                                                                                                                                                                                  raw: string;

                                                                                                                                                                                                                                                                                                                                                                                    property text

                                                                                                                                                                                                                                                                                                                                                                                    text: string;

                                                                                                                                                                                                                                                                                                                                                                                      property tokens

                                                                                                                                                                                                                                                                                                                                                                                      tokens: Token[];

                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                        type: 'del';

                                                                                                                                                                                                                                                                                                                                                                                          interface Em

                                                                                                                                                                                                                                                                                                                                                                                          interface Em {}

                                                                                                                                                                                                                                                                                                                                                                                            property raw

                                                                                                                                                                                                                                                                                                                                                                                            raw: string;

                                                                                                                                                                                                                                                                                                                                                                                              property text

                                                                                                                                                                                                                                                                                                                                                                                              text: string;

                                                                                                                                                                                                                                                                                                                                                                                                property tokens

                                                                                                                                                                                                                                                                                                                                                                                                tokens: Token[];

                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                  type: 'em';

                                                                                                                                                                                                                                                                                                                                                                                                    interface Escape

                                                                                                                                                                                                                                                                                                                                                                                                    interface Escape {}

                                                                                                                                                                                                                                                                                                                                                                                                      property raw

                                                                                                                                                                                                                                                                                                                                                                                                      raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                        property text

                                                                                                                                                                                                                                                                                                                                                                                                        text: string;

                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                          type: 'escape';

                                                                                                                                                                                                                                                                                                                                                                                                            interface Generic

                                                                                                                                                                                                                                                                                                                                                                                                            interface Generic {}

                                                                                                                                                                                                                                                                                                                                                                                                              property raw

                                                                                                                                                                                                                                                                                                                                                                                                              raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                property tokens

                                                                                                                                                                                                                                                                                                                                                                                                                tokens?: Token[];

                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                  type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                                                    [index: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                      interface Heading

                                                                                                                                                                                                                                                                                                                                                                                                                      interface Heading {}

                                                                                                                                                                                                                                                                                                                                                                                                                        property depth

                                                                                                                                                                                                                                                                                                                                                                                                                        depth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                          property raw

                                                                                                                                                                                                                                                                                                                                                                                                                          raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                            property text

                                                                                                                                                                                                                                                                                                                                                                                                                            text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                              property tokens

                                                                                                                                                                                                                                                                                                                                                                                                                              tokens: Token[];

                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'heading';

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Hr

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Hr {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                    raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'hr';

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HTML

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HTML {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          property block

                                                                                                                                                                                                                                                                                                                                                                                                                                          block: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property pre

                                                                                                                                                                                                                                                                                                                                                                                                                                            pre: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                              raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'html';

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Image

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Image {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property href

                                                                                                                                                                                                                                                                                                                                                                                                                                                      href: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                        raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                          text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                            title: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'image';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Link {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property href

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  href: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        title?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tokens

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tokens: Token[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'link';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface List {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property items

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                items: ListItem[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property loose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  loose: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ordered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ordered: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        start: number | '';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'list';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ListItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ListItem {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property checked

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              checked?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property loose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                loose: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property task

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    task: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tokens

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tokens: Token[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'list_item';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Paragraph

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Paragraph {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property pre

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pre?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tokens

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tokens: Token[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'paragraph';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Space

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Space {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'space';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Strong

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Strong {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tokens

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tokens: Token[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'strong';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Table {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property align

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          align: Array<'center' | 'left' | 'right' | null>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property header

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            header: TableCell[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property rows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rows: TableCell[][];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'table';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TableCell {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property align

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      align: 'center' | 'left' | 'right' | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property header

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        header: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tokens

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tokens: Token[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TableRow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TableRow {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Tag {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    block: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      inLink: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property inRawBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        inRawBlock: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'html';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Text {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property escaped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  escaped?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    raw: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tokens

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tokens?: Token[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'text';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (25)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/marked.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/marked)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/marked"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>