Skip to main content
Module

x/gfm/mod.ts>Marked.Marked

Server-side GitHub Flavored Markdown rendering for Deno
denoland/deno-gfm
Popular
Latest
namespace Marked.Marked
import { Marked } from "https://deno.land/x/gfm@0.6.0/mod.ts";
const { Marked } = Marked;
class Marked.Marked
import { Marked } from "https://deno.land/x/gfm@0.6.0/mod.ts";
const { Marked } = Marked;

Constructors

new
Marked(...args: MarkedExtension[])

Properties

defaults: MarkedOptions
Hooks: _Hooks
Lexer: _Lexer
options: (opt: MarkedOptions) => this
parse: (src: string, options?: MarkedOptions | undefined | null) => string | Promise<string>
parseInline: (src: string, options?: MarkedOptions | undefined | null) => string | Promise<string>
Parser: _Parser
Renderer: _Renderer
TextRenderer: _TextRenderer
Tokenizer: _Tokenizer

Methods

lexer(src: string, options?: MarkedOptions): TokensList
parser(tokens: Token[], options?: MarkedOptions): string
use(...args: MarkedExtension[]): this
walkTokens(tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]): MaybePromise[]

Run callback for every token

Constructors

new
Marked(...args: MarkedExtension[])

Properties

defaults: MarkedOptions
Hooks: _Hooks
Lexer: _Lexer
options: (opt: MarkedOptions) => this
parse: (src: string, options?: MarkedOptions | undefined | null) => string | Promise<string>
parseInline: (src: string, options?: MarkedOptions | undefined | null) => string | Promise<string>
Parser: _Parser
Renderer: _Renderer
TextRenderer: _TextRenderer
Tokenizer: _Tokenizer

Methods

lexer(src: string, options?: MarkedOptions): TokensList
parser(tokens: Token[], options?: MarkedOptions): string
use(...args: MarkedExtension[]): this
walkTokens(tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]): MaybePromise[]

Run callback for every token

Constructors

new
Hooks(options?: MarkedOptions)

Methods

postprocess(html: string): string

Process HTML after marked is finished

preprocess(markdown: string): string

Process markdown before marked

processAllTokens(tokens: Token[] | TokensList): Token[] | TokensList

Process all tokens before walk tokens

Static Properties

passThroughHooks: Set<string>

Constructors

new
Lexer(options?: MarkedOptions)

Properties

private
inlineQueue
private
tokenizer
options: MarkedOptions
state: { inLink: boolean; inRawBlock: boolean; top: boolean; }
tokens: TokensList

Methods

blockTokens(src: string, tokens?: Token[]): Token[]

Lexing

blockTokens(src: string, tokens?: TokensList): TokensList
inline(src: string, tokens?: Token[]): Token[]
inlineTokens(src: string, tokens?: Token[]): Token[]

Lexing/Compiling

lex(src: string): TokensList

Preprocessing

Static Properties

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"
| "heading"
| "list"
| "paragraph"
| "def"
| "fences"
| "lheading"
| "newline"
, RegExp>; pedantic: Record<
| "code"
| "blockquote"
| "hr"
| "html"
| "table"
| "text"
| "heading"
| "list"
| "paragraph"
| "def"
| "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"
| "autolink"
| "nolink"
| "_backpedal"
| "anyPunctuation"
| "blockSkip"
| "emStrongLDelim"
| "emStrongRDelimAst"
| "emStrongRDelimUnd"
| "punctuation"
| "reflinkSearch"
, RegExp>; breaks: Record<
| "link"
| "code"
| "url"
| "br"
| "del"
| "text"
| "escape"
| "tag"
| "reflink"
| "autolink"
| "nolink"
| "_backpedal"
| "anyPunctuation"
| "blockSkip"
| "emStrongLDelim"
| "emStrongRDelimAst"
| "emStrongRDelimUnd"
| "punctuation"
| "reflinkSearch"
, RegExp>; pedantic: Record<
| "link"
| "code"
| "url"
| "br"
| "del"
| "text"
| "escape"
| "tag"
| "reflink"
| "autolink"
| "nolink"
| "_backpedal"
| "anyPunctuation"
| "blockSkip"
| "emStrongLDelim"
| "emStrongRDelimAst"
| "emStrongRDelimUnd"
| "punctuation"
| "reflinkSearch"
, RegExp>; }; }

Expose Rules

Static Methods

lex(src: string, options?: MarkedOptions): TokensList

Static Lex Method

lexInline(src: string, options?: MarkedOptions): Token[]

Static Lex Inline Method

Constructors

new
Parser(options?: MarkedOptions)

Properties

options: MarkedOptions
renderer: _Renderer
textRenderer: _TextRenderer

Methods

parse(tokens: Token[], top?: boolean): string

Parse Loop

parseInline(tokens: Token[], renderer?: _Renderer | _TextRenderer): string

Parse Inline Tokens

Static Methods

parse(tokens: Token[], options?: MarkedOptions): string

Static Parse Method

parseInline(tokens: Token[], options?: MarkedOptions): string

Static Parse Inline Method

Constructors

new
Renderer(options?: MarkedOptions)

Methods

blockquote(quote: string): string
br(): string
checkbox(checked: boolean): string
code(
code: string,
infostring: string | undefined,
escaped: boolean,
): string
codespan(text: string): string
del(text: string): string
em(text: string): string
heading(
text: string,
level: number,
raw: string,
): string
hr(): string
html(html: string, block?: boolean): string
image(
href: string,
title: string | null,
text: string,
): string
list(
body: string,
ordered: boolean,
start: number | "",
): string
listitem(
text: string,
task: boolean,
checked: boolean,
): string
paragraph(text: string): string
strong(text: string): string

span level renderer

table(header: string, body: string): string
tablecell(content: string, flags: { header: boolean; align:
| "center"
| "left"
| "right"
| null
; }): string
tablerow(content: string): string
text(text: string): string

Methods

br(): string
codespan(text: string): string
del(text: string): string
em(text: string): string
html(text: string): string
image(
href: string,
title: string | null,
text: string,
): string
strong(text: string): string
text(text: string): string

Constructors

new
Tokenizer(options?: MarkedOptions)

Properties

lexer: _Lexer
options: MarkedOptions
rules: Rules

Methods

blockquote(src: string): Tokens.Blockquote | undefined
br(src: string): Tokens.Br | undefined
code(src: string): Tokens.Code | undefined
codespan(src: string): Tokens.Codespan | undefined
def(src: string): Tokens.Def | undefined
del(src: string): Tokens.Del | undefined
emStrong(
src: string,
maskedSrc: string,
prevChar?: string,
): Tokens.Em | Tokens.Strong | undefined
escape(src: string): Tokens.Escape | undefined
fences(src: string): Tokens.Code | undefined
heading(src: string): Tokens.Heading | undefined
hr(src: string): Tokens.Hr | undefined
html(src: string): Tokens.HTML | undefined
inlineText(src: string): Tokens.Text | undefined
lheading(src: string): Tokens.Heading | undefined
list(src: string): Tokens.List | undefined
paragraph(src: string): Tokens.Paragraph | undefined
space(src: string): Tokens.Space | undefined
table(src: string): Tokens.Table | undefined
tag(src: string): Tokens.Tag | undefined
text(src: string): Tokens.Text | undefined
url(src: string): Tokens.Link | undefined
interface Marked.Marked
import { type Marked } from "https://deno.land/x/gfm@0.6.0/mod.ts";
const { Marked } = Marked;

Properties

block: Record<BlockKeys, RegExp>
inline: Record<InlineKeys, RegExp>

Properties

lexer: _Lexer

Properties

name: string
level: "block" | "inline"
optional
start: TokenizerStartFunction | undefined
optional
childTokens: string[] | undefined

Properties

parser: _Parser

Properties

optional
async: boolean

True will tell marked to await any walkTokens functions before parsing the tokens and returning an HTML string.

optional
breaks: boolean | undefined

Enable GFM line breaks. This option requires the gfm option to be true.

optional
extensions: TokenizerAndRendererExtension[] | undefined | null

Add tokenizers and renderers to marked

optional
gfm: boolean | undefined

Enable GitHub flavored markdown.

optional
hooks: HooksObject | undefined | 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.

optional
pedantic: boolean | undefined

Conform to obscure parts of markdown.pl as much as possible. Don't fix any of the original markdown bugs or poor behavior.

optional
renderer: RendererObject | undefined | null

Type: object Default: new Renderer()

An object containing functions to render tokens to HTML.

optional
silent: boolean | undefined

Shows an HTML error message when rendering fails.

optional
tokenizer: TokenizerObject | undefined | null

The tokenizer defines how to turn markdown text into tokens.

optional
walkTokens: ((token: Token) => void | Promise<void>) | undefined | 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.

Properties

optional
hooks: _Hooks | undefined | null

Hooks are methods that hook into some part of marked.

optional
renderer: _Renderer | undefined | null

Type: object Default: new Renderer()

An object containing functions to render tokens to HTML.

optional
tokenizer: _Tokenizer | undefined | null

The tokenizer defines how to turn markdown text into tokens.

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

Custom extensions

optional
walkTokens: null | ((token: Token) => void | Promise<void> | (void | Promise<void>)[])

walkTokens function returns array of values for Promise.all

type alias Marked.Marked
import { type Marked } from "https://deno.land/x/gfm@0.6.0/mod.ts";
const { Marked } = Marked;
definition: (
| Tokens.Space
| Tokens.Code
| Tokens.Heading
| Tokens.Table
| Tokens.Hr
| Tokens.Blockquote
| Tokens.List
| Tokens.ListItem
| Tokens.Paragraph
| Tokens.HTML
| Tokens.Text
| Tokens.Def
| Tokens.Escape
| Tokens.Tag
| Tokens.Image
| Tokens.Link
| Tokens.Strong
| Tokens.Em
| Tokens.Codespan
| Tokens.Br
| Tokens.Del
| Tokens.Generic
)
definition: Token[] & { links: Links; }
definition: keyof blockNormal
definition: keyof inlineNormal
definition: (
src: string,
tokens: Token[] | TokensList,
) => Tokens.Generic | undefined
definition: (this: TokenizerThis, src: string) => number | void
definition: (this: RendererThis, token: Tokens.Generic) => string | false | undefined
definition: Omit<_Hooks, "constructor" | "options">
definition: [K in keyof HooksApi]?: (...args: Parameters<HooksApi[K]>) => ReturnType<HooksApi[K]> | Promise<ReturnType<HooksApi[K]>>
definition: Omit<_Renderer, "constructor" | "options">
definition: [K in keyof RendererApi]?: (...args: Parameters<RendererApi[K]>) => ReturnType<RendererApi[K]> | false
definition: Omit<_Tokenizer,
| "constructor"
| "options"
| "rules"
| "lexer"
>
definition: [K in keyof TokenizerApi]?: (...args: Parameters<TokenizerApi[K]>) => ReturnType<TokenizerApi[K]> | false
definition: void | Promise<void>
variable Marked.Marked
import { Marked } from "https://deno.land/x/gfm@0.6.0/mod.ts";
const { Marked } = Marked;

exports

type

{ 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"
| "heading"
| "list"
| "paragraph"
| "def"
| "fences"
| "lheading"
| "newline"
, RegExp>; pedantic: Record<
| "code"
| "blockquote"
| "hr"
| "html"
| "table"
| "text"
| "heading"
| "list"
| "paragraph"
| "def"
| "fences"
| "lheading"
| "newline"
, RegExp>; }

type

{ 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"
| "autolink"
| "nolink"
| "_backpedal"
| "anyPunctuation"
| "blockSkip"
| "emStrongLDelim"
| "emStrongRDelimAst"
| "emStrongRDelimUnd"
| "punctuation"
| "reflinkSearch"
, RegExp>; breaks: Record<
| "link"
| "code"
| "url"
| "br"
| "del"
| "text"
| "escape"
| "tag"
| "reflink"
| "autolink"
| "nolink"
| "_backpedal"
| "anyPunctuation"
| "blockSkip"
| "emStrongLDelim"
| "emStrongRDelimAst"
| "emStrongRDelimUnd"
| "punctuation"
| "reflinkSearch"
, RegExp>; pedantic: Record<
| "link"
| "code"
| "url"
| "br"
| "del"
| "text"
| "escape"
| "tag"
| "reflink"
| "autolink"
| "nolink"
| "_backpedal"
| "anyPunctuation"
| "blockSkip"
| "emStrongLDelim"
| "emStrongRDelimAst"
| "emStrongRDelimUnd"
| "punctuation"
| "reflinkSearch"
, RegExp>; }

type

(options: MarkedOptions) => marked

type

(options: MarkedOptions) => marked

type

(...args: MarkedExtension[]) => marked

type

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

type

(src: string, options?: MarkedOptions | null | undefined) => string | Promise<string>

type

marked

type

_Parser.parse

type

_Lexer.lex
function Marked.Marked
import { Marked } from "https://deno.land/x/gfm@0.6.0/mod.ts";
const { Marked } = Marked;

Compiles markdown to HTML asynchronously.

Parameters

src: string

String of markdown source to be compiled

options: MarkedOptions & { async: true; }

Hash of options, having async: true

Returns

Promise<string>

Promise of string of compiled HTML

Compiles markdown to HTML.

Parameters

src: string

String of markdown source to be compiled

optional
options: MarkedOptions

Optional hash of options

Returns

string | Promise<string>

String of compiled HTML. Wil be a Promise of string if async is set to true by any extensions.