An error occurred:
' + escape(e.message + '', true) + ''; - if (async) { - return Promise.resolve(msg); - } - if (callback) { - callback(null, msg); - return; - } - return msg; - } - if (async) { - return Promise.reject(e); - } - if (callback) { - callback(e); - return; - } - throw e; - }; + class _Hooks { + options; + constructor(options) { + this.options = options || exports.defaults; + } + static passThroughHooks = new Set([ + 'preprocess', + 'postprocess', + 'processAllTokens', + ]); + /** + * Process markdown before marked + */ + preprocess(markdown) { + return markdown; + } + /** + * Process HTML after marked is finished + */ + postprocess(html) { + return html; + } + /** + * Process all tokens before walk tokens + */ + processAllTokens(tokens) { + return tokens; + } } - function parseMarkdown(lexer, parser) { - return function (src, opt, callback) { - if (typeof opt === 'function') { - callback = opt; - opt = null; - } - var origOpt = _extends({}, opt); - opt = _extends({}, marked.defaults, origOpt); - var throwError = onError(opt.silent, opt.async, callback); - // throw error in case of non string input - if (typeof src === 'undefined' || src === null) { - return throwError(new Error('marked(): input parameter is undefined or null')); - } - if (typeof src !== 'string') { - return throwError(new Error('marked(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected')); - } - checkDeprecations(opt, callback); - if (opt.hooks) { - opt.hooks.options = opt; - } - if (callback) { - var highlight = opt.highlight; - var tokens; - try { - if (opt.hooks) { - src = opt.hooks.preprocess(src); - } - tokens = lexer(src, opt); - } catch (e) { - return throwError(e); - } - var done = function done(err) { - var out; - if (!err) { - try { - if (opt.walkTokens) { - marked.walkTokens(tokens, opt.walkTokens); - } - out = parser(tokens, opt); + class Marked { + defaults = _getDefaults(); + options = this.setOptions; + parse = this.#parseMarkdown(_Lexer.lex, _Parser.parse); + parseInline = this.#parseMarkdown(_Lexer.lexInline, _Parser.parseInline); + Parser = _Parser; + Renderer = _Renderer; + TextRenderer = _TextRenderer; + Lexer = _Lexer; + Tokenizer = _Tokenizer; + Hooks = _Hooks; + constructor(...args) { + this.use(...args); + } + /** + * Run callback for every token + */ + walkTokens(tokens, callback) { + let values = []; + for (const token of tokens) { + values = values.concat(callback.call(this, token)); + switch (token.type) { + case 'table': { + const tableToken = token; + for (const cell of tableToken.header) { + values = values.concat(this.walkTokens(cell.tokens, callback)); + } + for (const row of tableToken.rows) { + for (const cell of row) { + values = values.concat(this.walkTokens(cell.tokens, callback)); + } + } + break; + } + case 'list': { + const listToken = token; + values = values.concat(this.walkTokens(listToken.items, callback)); + break; + } + default: { + const genericToken = token; + if (this.defaults.extensions?.childTokens?.[genericToken.type]) { + this.defaults.extensions.childTokens[genericToken.type].forEach((childTokens) => { + const tokens = genericToken[childTokens].flat(Infinity); + values = values.concat(this.walkTokens(tokens, callback)); + }); + } + else if (genericToken.tokens) { + values = values.concat(this.walkTokens(genericToken.tokens, callback)); + } + } + } + } + return values; + } + use(...args) { + const extensions = this.defaults.extensions || { renderers: {}, childTokens: {} }; + args.forEach((pack) => { + // copy options to new object + const opts = { ...pack }; + // set async to true if it was set to true before + opts.async = this.defaults.async || opts.async || false; + // ==-- Parse "addon" extensions --== // + if (pack.extensions) { + pack.extensions.forEach((ext) => { + if (!ext.name) { + throw new Error('extension name required'); + } + if ('renderer' in ext) { // Renderer extensions + const prevRenderer = extensions.renderers[ext.name]; + if (prevRenderer) { + // Replace extension with func to run new extension but fall back if false + extensions.renderers[ext.name] = function (...args) { + let ret = ext.renderer.apply(this, args); + if (ret === false) { + ret = prevRenderer.apply(this, args); + } + return ret; + }; + } + else { + extensions.renderers[ext.name] = ext.renderer; + } + } + if ('tokenizer' in ext) { // Tokenizer Extensions + if (!ext.level || (ext.level !== 'block' && ext.level !== 'inline')) { + throw new Error("extension level must be 'block' or 'inline'"); + } + const extLevel = extensions[ext.level]; + if (extLevel) { + extLevel.unshift(ext.tokenizer); + } + else { + extensions[ext.level] = [ext.tokenizer]; + } + if (ext.start) { // Function to check for start of token + if (ext.level === 'block') { + if (extensions.startBlock) { + extensions.startBlock.push(ext.start); + } + else { + extensions.startBlock = [ext.start]; + } + } + else if (ext.level === 'inline') { + if (extensions.startInline) { + extensions.startInline.push(ext.start); + } + else { + extensions.startInline = [ext.start]; + } + } + } + } + if ('childTokens' in ext && ext.childTokens) { // Child tokens to be visited by walkTokens + extensions.childTokens[ext.name] = ext.childTokens; + } + }); + opts.extensions = extensions; + } + // ==-- Parse "overwrite" extensions --== // + if (pack.renderer) { + const renderer = this.defaults.renderer || new _Renderer(this.defaults); + for (const prop in pack.renderer) { + if (!(prop in renderer)) { + throw new Error(`renderer '${prop}' does not exist`); + } + if (['options', 'parser'].includes(prop)) { + // ignore options property + continue; + } + const rendererProp = prop; + let rendererFunc = pack.renderer[rendererProp]; + if (!pack.useNewRenderer) { + // TODO: Remove this in next major version + rendererFunc = this.#convertRendererFunction(rendererFunc, rendererProp, renderer); + } + const prevRenderer = renderer[rendererProp]; + // Replace renderer with func to run extension, but fall back if false + renderer[rendererProp] = (...args) => { + let ret = rendererFunc.apply(renderer, args); + if (ret === false) { + ret = prevRenderer.apply(renderer, args); + } + return ret || ''; + }; + } + opts.renderer = renderer; + } + if (pack.tokenizer) { + const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults); + for (const prop in pack.tokenizer) { + if (!(prop in tokenizer)) { + throw new Error(`tokenizer '${prop}' does not exist`); + } + if (['options', 'rules', 'lexer'].includes(prop)) { + // ignore options, rules, and lexer properties + continue; + } + const tokenizerProp = prop; + const tokenizerFunc = pack.tokenizer[tokenizerProp]; + const prevTokenizer = tokenizer[tokenizerProp]; + // Replace tokenizer with func to run extension, but fall back if false + // @ts-expect-error cannot type tokenizer function dynamically + tokenizer[tokenizerProp] = (...args) => { + let ret = tokenizerFunc.apply(tokenizer, args); + if (ret === false) { + ret = prevTokenizer.apply(tokenizer, args); + } + return ret; + }; + } + opts.tokenizer = tokenizer; + } + // ==-- Parse Hooks extensions --== // + if (pack.hooks) { + const hooks = this.defaults.hooks || new _Hooks(); + for (const prop in pack.hooks) { + if (!(prop in hooks)) { + throw new Error(`hook '${prop}' does not exist`); + } + if (prop === 'options') { + // ignore options property + continue; + } + const hooksProp = prop; + const hooksFunc = pack.hooks[hooksProp]; + const prevHook = hooks[hooksProp]; + if (_Hooks.passThroughHooks.has(prop)) { + // @ts-expect-error cannot type hook function dynamically + hooks[hooksProp] = (arg) => { + if (this.defaults.async) { + return Promise.resolve(hooksFunc.call(hooks, arg)).then(ret => { + return prevHook.call(hooks, ret); + }); + } + const ret = hooksFunc.call(hooks, arg); + return prevHook.call(hooks, ret); + }; + } + else { + // @ts-expect-error cannot type hook function dynamically + hooks[hooksProp] = (...args) => { + let ret = hooksFunc.apply(hooks, args); + if (ret === false) { + ret = prevHook.apply(hooks, args); + } + return ret; + }; + } + } + opts.hooks = hooks; + } + // ==-- Parse WalkTokens extensions --== // + if (pack.walkTokens) { + const walkTokens = this.defaults.walkTokens; + const packWalktokens = pack.walkTokens; + opts.walkTokens = function (token) { + let values = []; + values.push(packWalktokens.call(this, token)); + if (walkTokens) { + values = values.concat(walkTokens.call(this, token)); + } + return values; + }; + } + this.defaults = { ...this.defaults, ...opts }; + }); + return this; + } + // TODO: Remove this in next major release + #convertRendererFunction(func, prop, renderer) { + switch (prop) { + case 'heading': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + return func.call(this, renderer.parser.parseInline(token.tokens), token.depth, unescape(renderer.parser.parseInline(token.tokens, renderer.parser.textRenderer))); + }; + case 'code': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + return func.call(this, token.text, token.lang, !!token.escaped); + }; + case 'table': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + let header = ''; + // header + let cell = ''; + for (let j = 0; j < token.header.length; j++) { + cell += this.tablecell({ + text: token.header[j].text, + tokens: token.header[j].tokens, + header: true, + align: token.align[j], + }); + } + header += this.tablerow({ text: cell }); + let body = ''; + for (let j = 0; j < token.rows.length; j++) { + const row = token.rows[j]; + cell = ''; + for (let k = 0; k < row.length; k++) { + cell += this.tablecell({ + text: row[k].text, + tokens: row[k].tokens, + header: false, + align: token.align[k], + }); + } + body += this.tablerow({ text: cell }); + } + return func.call(this, header, body); + }; + case 'blockquote': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + const body = this.parser.parse(token.tokens); + return func.call(this, body); + }; + case 'list': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + const ordered = token.ordered; + const start = token.start; + const loose = token.loose; + let body = ''; + for (let j = 0; j < token.items.length; j++) { + const item = token.items[j]; + const checked = item.checked; + const task = item.task; + let itemBody = ''; + if (item.task) { + const checkbox = this.checkbox({ checked: !!checked }); + if (loose) { + if (item.tokens.length > 0 && item.tokens[0].type === 'paragraph') { + item.tokens[0].text = checkbox + ' ' + item.tokens[0].text; + if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') { + item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text; + } + } + else { + item.tokens.unshift({ + type: 'text', + text: checkbox + ' ', + }); + } + } + else { + itemBody += checkbox + ' '; + } + } + itemBody += this.parser.parse(item.tokens, loose); + body += this.listitem({ + type: 'list_item', + raw: itemBody, + text: itemBody, + task, + checked: !!checked, + loose, + tokens: item.tokens, + }); + } + return func.call(this, body, ordered, start); + }; + case 'html': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + return func.call(this, token.text, token.block); + }; + case 'paragraph': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + return func.call(this, this.parser.parseInline(token.tokens)); + }; + case 'escape': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + return func.call(this, token.text); + }; + case 'link': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + return func.call(this, token.href, token.title, this.parser.parseInline(token.tokens)); + }; + case 'image': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + return func.call(this, token.href, token.title, token.text); + }; + case 'strong': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + return func.call(this, this.parser.parseInline(token.tokens)); + }; + case 'em': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + return func.call(this, this.parser.parseInline(token.tokens)); + }; + case 'codespan': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + return func.call(this, token.text); + }; + case 'del': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + return func.call(this, this.parser.parseInline(token.tokens)); + }; + case 'text': + return function (token) { + if (!token.type || token.type !== prop) { + // @ts-ignore + // eslint-disable-next-line prefer-rest-params + return func.apply(this, arguments); + } + return func.call(this, token.text); + }; + // do nothing + } + return func; + } + setOptions(opt) { + this.defaults = { ...this.defaults, ...opt }; + return this; + } + lexer(src, options) { + return _Lexer.lex(src, options ?? this.defaults); + } + parser(tokens, options) { + return _Parser.parse(tokens, options ?? this.defaults); + } + #parseMarkdown(lexer, parser) { + return (src, options) => { + const origOpt = { ...options }; + const opt = { ...this.defaults, ...origOpt }; + // Show warning if an extension set async to true but the parse was called with async: false + if (this.defaults.async === true && origOpt.async === false) { + if (!opt.silent) { + console.warn('marked(): The async option was set to true by an extension. The async: false option sent to parse will be ignored.'); + } + opt.async = true; + } + const throwError = this.#onError(!!opt.silent, !!opt.async); + // throw error in case of non string input + if (typeof src === 'undefined' || src === null) { + return throwError(new Error('marked(): input parameter is undefined or null')); + } + if (typeof src !== 'string') { + return throwError(new Error('marked(): input parameter is of type ' + + Object.prototype.toString.call(src) + ', string expected')); + } if (opt.hooks) { - out = opt.hooks.postprocess(out); - } - } catch (e) { - err = e; - } - } - opt.highlight = highlight; - return err ? throwError(err) : callback(null, out); - }; - if (!highlight || highlight.length < 3) { - return done(); - } - delete opt.highlight; - if (!tokens.length) return done(); - var pending = 0; - marked.walkTokens(tokens, function (token) { - if (token.type === 'code') { - pending++; - setTimeout(function () { - highlight(token.text, token.lang, function (err, code) { - if (err) { - return done(err); - } - if (code != null && code !== token.text) { - token.text = code; - token.escaped = true; - } - pending--; - if (pending === 0) { - done(); - } - }); - }, 0); - } - }); - if (pending === 0) { - done(); - } - return; - } - if (opt.async) { - return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then(function (src) { - return lexer(src, opt); - }).then(function (tokens) { - return opt.walkTokens ? Promise.all(marked.walkTokens(tokens, opt.walkTokens)).then(function () { - return tokens; - }) : tokens; - }).then(function (tokens) { - return parser(tokens, opt); - }).then(function (html) { - return opt.hooks ? opt.hooks.postprocess(html) : html; - })["catch"](throwError); + opt.hooks.options = opt; + } + if (opt.async) { + return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src) + .then(src => lexer(src, opt)) + .then(tokens => opt.hooks ? opt.hooks.processAllTokens(tokens) : tokens) + .then(tokens => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens) + .then(tokens => parser(tokens, opt)) + .then(html => opt.hooks ? opt.hooks.postprocess(html) : html) + .catch(throwError); + } + try { + if (opt.hooks) { + src = opt.hooks.preprocess(src); + } + let tokens = lexer(src, opt); + if (opt.hooks) { + tokens = opt.hooks.processAllTokens(tokens); + } + if (opt.walkTokens) { + this.walkTokens(tokens, opt.walkTokens); + } + let html = parser(tokens, opt); + if (opt.hooks) { + html = opt.hooks.postprocess(html); + } + return html; + } + catch (e) { + return throwError(e); + } + }; + } + #onError(silent, async) { + return (e) => { + e.message += '\nPlease report this to https://github.com/markedjs/marked.'; + if (silent) { + const msg = '
An error occurred:
' + + escape$1(e.message + '', true) + + ''; + if (async) { + return Promise.resolve(msg); + } + return msg; + } + if (async) { + return Promise.reject(e); + } + throw e; + }; } - try { - if (opt.hooks) { - src = opt.hooks.preprocess(src); - } - var _tokens = lexer(src, opt); - if (opt.walkTokens) { - marked.walkTokens(_tokens, opt.walkTokens); - } - var html = parser(_tokens, opt); - if (opt.hooks) { - html = opt.hooks.postprocess(html); - } - return html; - } catch (e) { - return throwError(e); - } - }; } + const markedInstance = new Marked(); + function marked(src, opt) { + return markedInstance.parse(src, opt); + } /** - * Marked + * Sets the default options. + * + * @param options Hash of options */ - function marked(src, opt, callback) { - return parseMarkdown(Lexer.lex, Parser.parse)(src, opt, callback); - } - + marked.options = + marked.setOptions = function (options) { + markedInstance.setOptions(options); + marked.defaults = markedInstance.defaults; + changeDefaults(marked.defaults); + return marked; + }; /** - * Options + * Gets the original marked default options. */ - - marked.options = marked.setOptions = function (opt) { - marked.defaults = _extends({}, marked.defaults, opt); - changeDefaults(marked.defaults); - return marked; - }; - marked.getDefaults = getDefaults; + marked.getDefaults = _getDefaults; marked.defaults = exports.defaults; - /** * Use Extension */ - - marked.use = function () { - var extensions = marked.defaults.extensions || { - renderers: {}, - childTokens: {} - }; - for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - args.forEach(function (pack) { - // copy options to new object - var opts = _extends({}, pack); - - // set async to true if it was set to true before - opts.async = marked.defaults.async || opts.async || false; - - // ==-- Parse "addon" extensions --== // - if (pack.extensions) { - pack.extensions.forEach(function (ext) { - if (!ext.name) { - throw new Error('extension name required'); - } - if (ext.renderer) { - // Renderer extensions - var prevRenderer = extensions.renderers[ext.name]; - if (prevRenderer) { - // Replace extension with func to run new extension but fall back if false - extensions.renderers[ext.name] = function () { - for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; - } - var ret = ext.renderer.apply(this, args); - if (ret === false) { - ret = prevRenderer.apply(this, args); - } - return ret; - }; - } else { - extensions.renderers[ext.name] = ext.renderer; - } - } - if (ext.tokenizer) { - // Tokenizer Extensions - if (!ext.level || ext.level !== 'block' && ext.level !== 'inline') { - throw new Error("extension level must be 'block' or 'inline'"); - } - if (extensions[ext.level]) { - extensions[ext.level].unshift(ext.tokenizer); - } else { - extensions[ext.level] = [ext.tokenizer]; - } - if (ext.start) { - // Function to check for start of token - if (ext.level === 'block') { - if (extensions.startBlock) { - extensions.startBlock.push(ext.start); - } else { - extensions.startBlock = [ext.start]; - } - } else if (ext.level === 'inline') { - if (extensions.startInline) { - extensions.startInline.push(ext.start); - } else { - extensions.startInline = [ext.start]; - } - } - } - } - if (ext.childTokens) { - // Child tokens to be visited by walkTokens - extensions.childTokens[ext.name] = ext.childTokens; - } - }); - opts.extensions = extensions; - } - - // ==-- Parse "overwrite" extensions --== // - if (pack.renderer) { - var renderer = marked.defaults.renderer || new Renderer(); - var _loop = function _loop(prop) { - var prevRenderer = renderer[prop]; - // Replace renderer with func to run extension, but fall back if false - renderer[prop] = function () { - for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { - args[_key3] = arguments[_key3]; - } - var ret = pack.renderer[prop].apply(renderer, args); - if (ret === false) { - ret = prevRenderer.apply(renderer, args); - } - return ret; - }; - }; - for (var prop in pack.renderer) { - _loop(prop); - } - opts.renderer = renderer; - } - if (pack.tokenizer) { - var tokenizer = marked.defaults.tokenizer || new Tokenizer(); - var _loop2 = function _loop2(_prop) { - var prevTokenizer = tokenizer[_prop]; - // Replace tokenizer with func to run extension, but fall back if false - tokenizer[_prop] = function () { - for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { - args[_key4] = arguments[_key4]; - } - var ret = pack.tokenizer[_prop].apply(tokenizer, args); - if (ret === false) { - ret = prevTokenizer.apply(tokenizer, args); - } - return ret; - }; - }; - for (var _prop in pack.tokenizer) { - _loop2(_prop); - } - opts.tokenizer = tokenizer; - } - - // ==-- Parse Hooks extensions --== // - if (pack.hooks) { - var hooks = marked.defaults.hooks || new Hooks(); - var _loop3 = function _loop3(_prop2) { - var prevHook = hooks[_prop2]; - if (Hooks.passThroughHooks.has(_prop2)) { - hooks[_prop2] = function (arg) { - if (marked.defaults.async) { - return Promise.resolve(pack.hooks[_prop2].call(hooks, arg)).then(function (ret) { - return prevHook.call(hooks, ret); - }); - } - var ret = pack.hooks[_prop2].call(hooks, arg); - return prevHook.call(hooks, ret); - }; - } else { - hooks[_prop2] = function () { - for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) { - args[_key5] = arguments[_key5]; - } - var ret = pack.hooks[_prop2].apply(hooks, args); - if (ret === false) { - ret = prevHook.apply(hooks, args); - } - return ret; - }; - } - }; - for (var _prop2 in pack.hooks) { - _loop3(_prop2); - } - opts.hooks = hooks; - } - - // ==-- Parse WalkTokens extensions --== // - if (pack.walkTokens) { - var _walkTokens = marked.defaults.walkTokens; - opts.walkTokens = function (token) { - var values = []; - values.push(pack.walkTokens.call(this, token)); - if (_walkTokens) { - values = values.concat(_walkTokens.call(this, token)); - } - return values; - }; - } - marked.setOptions(opts); - }); + marked.use = function (...args) { + markedInstance.use(...args); + marked.defaults = markedInstance.defaults; + changeDefaults(marked.defaults); + return marked; }; - /** * Run callback for every token */ - marked.walkTokens = function (tokens, callback) { - var values = []; - var _loop4 = function _loop4() { - var token = _step.value; - values = values.concat(callback.call(marked, token)); - switch (token.type) { - case 'table': - { - for (var _iterator2 = _createForOfIteratorHelperLoose(token.header), _step2; !(_step2 = _iterator2()).done;) { - var cell = _step2.value; - values = values.concat(marked.walkTokens(cell.tokens, callback)); - } - for (var _iterator3 = _createForOfIteratorHelperLoose(token.rows), _step3; !(_step3 = _iterator3()).done;) { - var row = _step3.value; - for (var _iterator4 = _createForOfIteratorHelperLoose(row), _step4; !(_step4 = _iterator4()).done;) { - var _cell = _step4.value; - values = values.concat(marked.walkTokens(_cell.tokens, callback)); - } - } - break; - } - case 'list': - { - values = values.concat(marked.walkTokens(token.items, callback)); - break; - } - default: - { - if (marked.defaults.extensions && marked.defaults.extensions.childTokens && marked.defaults.extensions.childTokens[token.type]) { - // Walk any extensions - marked.defaults.extensions.childTokens[token.type].forEach(function (childTokens) { - values = values.concat(marked.walkTokens(token[childTokens], callback)); - }); - } else if (token.tokens) { - values = values.concat(marked.walkTokens(token.tokens, callback)); - } - } - } - }; - for (var _iterator = _createForOfIteratorHelperLoose(tokens), _step; !(_step = _iterator()).done;) { - _loop4(); - } - return values; + return markedInstance.walkTokens(tokens, callback); }; - /** - * Parse Inline - * @param {string} src + * Compiles markdown to HTML without enclosing `p` tag. + * + * @param src String of markdown source to be compiled + * @param options Hash of options + * @return String of compiled HTML */ - marked.parseInline = parseMarkdown(Lexer.lexInline, Parser.parseInline); - + marked.parseInline = markedInstance.parseInline; /** * Expose */ - marked.Parser = Parser; - marked.parser = Parser.parse; - marked.Renderer = Renderer; - marked.TextRenderer = TextRenderer; - marked.Lexer = Lexer; - marked.lexer = Lexer.lex; - marked.Tokenizer = Tokenizer; - marked.Slugger = Slugger; - marked.Hooks = Hooks; + marked.Parser = _Parser; + marked.parser = _Parser.parse; + marked.Renderer = _Renderer; + marked.TextRenderer = _TextRenderer; + marked.Lexer = _Lexer; + marked.lexer = _Lexer.lex; + marked.Tokenizer = _Tokenizer; + marked.Hooks = _Hooks; marked.parse = marked; - var options = marked.options; - var setOptions = marked.setOptions; - var use = marked.use; - var walkTokens = marked.walkTokens; - var parseInline = marked.parseInline; - var parse = marked; - var parser = Parser.parse; - var lexer = Lexer.lex; - - exports.Hooks = Hooks; - exports.Lexer = Lexer; - exports.Parser = Parser; - exports.Renderer = Renderer; - exports.Slugger = Slugger; - exports.TextRenderer = TextRenderer; - exports.Tokenizer = Tokenizer; - exports.getDefaults = getDefaults; + const options = marked.options; + const setOptions = marked.setOptions; + const use = marked.use; + const walkTokens = marked.walkTokens; + const parseInline = marked.parseInline; + const parse = marked; + const parser = _Parser.parse; + const lexer = _Lexer.lex; + + exports.Hooks = _Hooks; + exports.Lexer = _Lexer; + exports.Marked = Marked; + exports.Parser = _Parser; + exports.Renderer = _Renderer; + exports.TextRenderer = _TextRenderer; + exports.Tokenizer = _Tokenizer; + exports.getDefaults = _getDefaults; exports.lexer = lexer; exports.marked = marked; exports.options = options;