Testing Markdown Parser Extensions and Token Handling in marked
This test suite verifies the core functionality of the marked Markdown parser, focusing on tokenization, rendering, and extension capabilities. The tests cover parsing of various Markdown elements, custom extensions, token walking, and asynchronous operations.
Test Coverage Overview
Implementation Analysis
Technical Details
Best Practices Demonstrated
markedjs/marked
test/unit/marked.test.js
import { Marked, Renderer, lexer, parseInline, getDefaults, walkTokens, defaults, setOptions } from '../../lib/marked.esm.js';
import { timeout } from './utils.js';
import assert from 'node:assert';
import { describe, it, beforeEach, mock } from 'node:test';
describe('marked unit', () => {
let marked;
beforeEach(() => {
marked = new Marked();
setOptions(getDefaults());
});
describe('Test paragraph token type', () => {
it('should use the "paragraph" type on top level', () => {
const md = 'A Paragraph.\n\n> A blockquote\n\n- list item\n';
const tokens = lexer(md);
assert.strictEqual(tokens[0].type, 'paragraph');
assert.strictEqual(tokens[2].tokens[0].type, 'paragraph');
assert.strictEqual(tokens[4].items[0].tokens[0].type, 'text');
});
});
describe('changeDefaults', () => {
it('should change global defaults', async() => {
const { defaults, setOptions } = await import('../../lib/marked.esm.js');
assert.ok(!defaults.test);
setOptions({ test: true });
assert.ok((await import('../../lib/marked.esm.js')).defaults.test);
});
});
describe('inlineLexer', () => {
it('should send html to renderer.html', () => {
const renderer = new Renderer();
mock.method(renderer, 'html');
const md = 'HTML Image: <img alt="MY IMAGE" src="example.png" />';
marked.parse(md, { renderer });
assert.strictEqual(renderer.html.mock.calls[0].arguments[0].raw, '<img alt="MY IMAGE" src="example.png" />');
});
});
describe('task', () => {
it('space after checkbox', () => {
const html = marked.parse('- [ ] item');
assert.strictEqual(html, '<ul>\n<li><input disabled="" type="checkbox"> item</li>\n</ul>\n');
});
it('space after loose checkbox', () => {
const html = marked.parse('- [ ] item 1\n\n- [ ] item 2');
assert.strictEqual(html, '<ul>\n<li><p><input disabled="" type="checkbox"> \nitem 1</p>\n</li>\n<li><p><input disabled="" type="checkbox"> \nitem 2</p>\n</li>\n</ul>\n');
});
});
describe('parseInline', () => {
it('should parse inline tokens', () => {
const md = '**strong** _em_';
const html = parseInline(md);
assert.strictEqual(html, '<strong>strong</strong> <em>em</em>');
});
it('should not parse block tokens', () => {
const md = '# header\n\n_em_';
const html = parseInline(md);
assert.strictEqual(html, '# header\n\n<em>em</em>');
});
});
describe('use extension', () => {
it('should use custom block tokenizer + renderer extensions', () => {
const underline = {
name: 'underline',
level: 'block',
tokenizer(src) {
const rule = /^:([^\n]*)(?:\n|$)/;
const match = rule.exec(src);
if (match) {
return {
type: 'underline',
raw: match[0], // This is the text that you want your token to consume from the source
text: match[1].trim(), // You can add additional properties to your tokens to pass along to the renderer
};
}
},
renderer(token) {
return `<u>${token.text}</u>\n`;
},
};
marked.use({ extensions: [underline] });
let html = marked.parse('Not Underlined\n:Underlined\nNot Underlined');
assert.strictEqual(html, '<p>Not Underlined\n:Underlined\nNot Underlined</p>\n');
html = marked.parse('Not Underlined\n\n:Underlined\n\nNot Underlined');
assert.strictEqual(html, '<p>Not Underlined</p>\n<u>Underlined</u>\n<p>Not Underlined</p>\n');
});
it('should interrupt paragraphs if using "start" property', () => {
const underline = {
extensions: [{
name: 'underline',
level: 'block',
start(src) { return src.indexOf(':'); },
tokenizer(src) {
const rule = /^:([^\n]*):(?:\n|$)/;
const match = rule.exec(src);
if (match) {
return {
type: 'underline',
raw: match[0], // This is the text that you want your token to consume from the source
text: match[1].trim(), // You can add additional properties to your tokens to pass along to the renderer
};
}
},
renderer(token) {
return `<u>${token.text}</u>\n`;
},
}],
};
marked.use(underline);
const html = marked.parse('Not Underlined A\n:Underlined B:\nNot Underlined C\n:Not Underlined D');
assert.strictEqual(html, '<p>Not Underlined A</p>\n<u>Underlined B</u>\n<p>Not Underlined C\n:Not Underlined D</p>\n');
});
it('should not return list if no items', () => {
const noHr = {
tokenizer: {
hr() {
return undefined;
},
},
};
marked.use(noHr);
const markdown = '- - -';
const html = marked.parse(markdown);
assert.strictEqual(html, '<p>- - -</p>\n');
});
it('should use custom inline tokenizer + renderer extensions', () => {
const underline = {
name: 'underline',
level: 'inline',
start(src) { return src.indexOf('='); },
tokenizer(src) {
const rule = /^=([^=]+)=/;
const match = rule.exec(src);
if (match) {
return {
type: 'underline',
raw: match[0], // This is the text that you want your token to consume from the source
text: match[1].trim(), // You can add additional properties to your tokens to pass along to the renderer
};
}
},
renderer(token) {
return `<u>${token.text}</u>`;
},
};
marked.use({ extensions: [underline] });
const html = marked.parse('Not Underlined =Underlined= Not Underlined');
assert.strictEqual(html, '<p>Not Underlined <u>Underlined</u> Not Underlined</p>\n');
});
it('should handle interacting block and inline extensions', () => {
const descriptionlist = {
name: 'descriptionList',
level: 'block',
start(src) {
const match = src.match(/:[^:\n]/);
if (match) {
return match.index;
}
},
tokenizer(src, tokens) {
const rule = /^(?::[^:\n]+:[^:\n]*(?:\n|$))+/;
const match = rule.exec(src);
if (match) {
const token = {
type: 'descriptionList',
raw: match[0], // This is the text that you want your token to consume from the source
text: match[0].trim(), // You can add additional properties to your tokens to pass along to the renderer
tokens: [],
};
this.lexer.inlineTokens(token.text, token.tokens);
return token;
}
},
renderer(token) {
return `<dl>${this.parser.parseInline(token.tokens)}\n</dl>`;
},
};
const description = {
name: 'description',
level: 'inline',
start(src) { return src.indexOf(':'); },
tokenizer(src, tokens) {
const rule = /^:([^:\n]+):([^:\n]*)(?:\n|$)/;
const match = rule.exec(src);
if (match) {
const token = {
type: 'description',
raw: match[0],
dt: [],
dd: [],
};
this.lexer.inline(match[1].trim(), token.dt);
this.lexer.inline(match[2].trim(), token.dd);
return token;
}
},
renderer(token) {
return `\n<dt>${this.parser.parseInline(token.dt)}</dt><dd>${this.parser.parseInline(token.dd)}</dd>`;
},
};
marked.use({ extensions: [descriptionlist, description] });
const html = marked.parse('A Description List with One Description:\n'
+ ': Topic 1 : Description 1\n'
+ ': **Topic 2** : *Description 2*');
assert.strictEqual(html, '<p>A Description List with One Description:</p>\n'
+ '<dl>'
+ '\n<dt>Topic 1</dt><dd>Description 1</dd>'
+ '\n<dt><strong>Topic 2</strong></dt><dd><em>Description 2</em></dd>'
+ '\n</dl>');
});
it('should allow other options mixed into the extension', () => {
const extension = {
name: 'underline',
level: 'block',
start(src) { return src.indexOf(':'); },
tokenizer(src) {
const rule = /^:([^\n]*):(?:\n|$)/;
const match = rule.exec(src);
if (match) {
return {
type: 'underline',
raw: match[0], // This is the text that you want your token to consume from the source
text: match[1].trim(), // You can add additional properties to your tokens to pass along to the renderer
};
}
},
renderer(token) {
return `<u>${token.text}</u>\n`;
},
};
marked.use({ silent: true, extensions: [extension] });
const html = marked.parse(':test:\ntest\n<div></div>');
assert.strictEqual(html, '<u>test</u>\n<p>test</p>\n<div></div>');
});
it('should handle renderers that return false', () => {
const extension = {
name: 'test',
level: 'block',
tokenizer(src) {
const rule = /^:([^\n]*):(?:\n|$)/;
const match = rule.exec(src);
if (match) {
return {
type: 'test',
raw: match[0], // This is the text that you want your token to consume from the source
text: match[1].trim(), // You can add additional properties to your tokens to pass along to the renderer
};
}
},
renderer(token) {
if (token.text === 'test') {
return 'test';
}
return false;
},
};
const fallbackRenderer = {
name: 'test',
level: 'block',
renderer(token) {
if (token.text === 'Test') {
return 'fallback';
}
return false;
},
};
marked.use({ extensions: [fallbackRenderer, extension] });
const html = marked.parse(':Test:\n\n:test:\n\n:none:');
assert.strictEqual(html, 'fallbacktest');
});
it('should fall back when tokenizers return false', () => {
const extension = {
name: 'test',
level: 'block',
tokenizer(src) {
const rule = /^:([^\n]*):(?:\n|$)/;
const match = rule.exec(src);
if (match) {
return {
type: 'test',
raw: match[0], // This is the text that you want your token to consume from the source
text: match[1].trim(), // You can add additional properties to your tokens to pass along to the renderer
};
}
return false;
},
renderer(token) {
return token.text;
},
};
const extension2 = {
name: 'test',
level: 'block',
tokenizer(src) {
const rule = /^:([^\n]*):(?:\n|$)/;
const match = rule.exec(src);
if (match) {
if (match[1].match(/^[A-Z]/)) {
return {
type: 'test',
raw: match[0],
text: match[1].trim().toUpperCase(),
};
}
}
return false;
},
};
marked.use({ extensions: [extension, extension2] });
const html = marked.parse(':Test:\n\n:test:');
assert.strictEqual(html, 'TESTtest');
});
it('should override original tokenizer/renderer with same name, but fall back if returns false', () => {
const extension = {
extensions: [{
name: 'heading',
level: 'block',
tokenizer(src) {
return false; // fall back to default `heading` tokenizer
},
renderer(token) {
return '<h' + token.depth + '>' + token.text + ' RENDERER EXTENSION</h' + token.depth + '>\n';
},
},
{
name: 'code',
level: 'block',
tokenizer(src) {
const rule = /^:([^\n]*):(?:\n|$)/;
const match = rule.exec(src);
if (match) {
return {
type: 'code',
raw: match[0],
text: match[1].trim() + ' TOKENIZER EXTENSION',
};
}
},
renderer(token) {
return false; // fall back to default `code` renderer
},
}],
};
marked.use(extension);
const html = marked.parse('# extension1\n:extension2:');
assert.strictEqual(html, '<h1>extension1 RENDERER EXTENSION</h1>\n<pre><code>extension2 TOKENIZER EXTENSION\n</code></pre>\n');
});
it('should walk only specified child tokens', () => {
const walkableDescription = {
extensions: [{
name: 'walkableDescription',
level: 'inline',
start(src) { return src.indexOf(':'); },
tokenizer(src, tokens) {
const rule = /^:([^:\n]+):([^:\n]*)(?:\n|$)/;
const match = rule.exec(src);
if (match) {
const token = {
type: 'walkableDescription',
raw: match[0],
dt: this.lexer.inline(match[1].trim()),
dd: [],
tokens: [],
};
this.lexer.inline(match[2].trim(), token.dd);
this.lexer.inline('unwalked', token.tokens);
return token;
}
},
renderer(token) {
return `\n<dt>${this.parser.parseInline(token.dt)} - ${this.parser.parseInline(token.tokens)}</dt><dd>${this.parser.parseInline(token.dd)}</dd>`;
},
childTokens: ['dd', 'dt'],
}],
walkTokens(token) {
if (token.type === 'text') {
token.text += ' walked';
}
},
};
marked.use(walkableDescription);
const html = marked.parse(': Topic 1 : Description 1\n'
+ ': **Topic 2** : *Description 2*');
assert.strictEqual(html, '<p>\n<dt>Topic 1 walked - unwalked</dt><dd>Description 1 walked</dd>'
+ '\n<dt><strong>Topic 2 walked</strong> - unwalked</dt><dd><em>Description 2 walked</em></dd></p>\n');
});
it('should walk child token arrays', () => {
const walkableDescription = {
extensions: [{
name: 'walkableDescription',
level: 'inline',
start(src) { return src.indexOf(':'); },
tokenizer(src, tokens) {
const rule = /^:([^:\n]+):([^:\n]*)(?:\n|$)/;
const match = rule.exec(src);
if (match) {
const token = {
type: 'walkableDescription',
raw: match[0],
dt: [this.lexer.inline(match[1].trim())],
dd: [[this.lexer.inline(match[2].trim())]],
};
return token;
}
},
renderer(token) {
return `\n<dt>${this.parser.parseInline(token.dt[0])}</dt><dd>${this.parser.parseInline(token.dd[0][0])}</dd>`;
},
childTokens: ['dd', 'dt'],
}],
walkTokens(token) {
if (token.type === 'text') {
token.text += ' walked';
}
},
};
marked.use(walkableDescription);
const html = marked.parse(': Topic 1 : Description 1\n'
+ ': **Topic 2** : *Description 2*');
assert.strictEqual(html, '<p>\n<dt>Topic 1 walked</dt><dd>Description 1 walked</dd>'
+ '\n<dt><strong>Topic 2 walked</strong></dt><dd><em>Description 2 walked</em></dd></p>\n');
});
describe('multiple extensions', () => {
function createExtension(name) {
return {
extensions: [{
name: `block-${name}`,
level: 'block',
start(src) { return src.indexOf('::'); },
tokenizer(src, tokens) {
if (src.startsWith(`::${name}\n`)) {
const text = `:${name}`;
const token = {
type: `block-${name}`,
raw: `::${name}\n`,
text,
tokens: [],
};
this.lexer.inline(token.text, token.tokens);
return token;
}
},
renderer(token) {
return `<${token.type}>${this.parser.parseInline(token.tokens)}</${token.type}>\n`;
},
}, {
name: `inline-${name}`,
level: 'inline',
start(src) { return src.indexOf(':'); },
tokenizer(src, tokens) {
if (src.startsWith(`:${name}`)) {
return {
type: `inline-${name}`,
raw: `:${name}`,
text: `used ${name}`,
};
}
},
renderer(token) {
return token.text;
},
}],
tokenizer: {
heading(src) {
if (src.startsWith(`# ${name}`)) {
const token = {
type: 'heading',
raw: `# ${name}`,
text: `used ${name}`,
depth: 1,
tokens: [],
};
this.lexer.inline(token.text, token.tokens);
return token;
}
return false;
},
},
useNewRenderer: true,
renderer: {
heading({ text, depth }) {
if (text === name) {
return `<h${depth}>${text}</h${depth}>\n`;
}
return false;
},
},
walkTokens(token) {
if (token.text === `used ${name}`) {
token.text += ' walked';
}
},
};
}
function createFalseExtension(name) {
return {
extensions: [{
name: `block-${name}`,
level: 'block',
start(src) { return src.indexOf('::'); },
tokenizer(src, tokens) {
return false;
},
renderer(token) {
return false;
},
}, {
name: `inline-${name}`,
level: 'inline',
start(src) { return src.indexOf(':'); },
tokenizer(src, tokens) {
return false;
},
renderer(token) {
return false;
},
}],
};
}
function runTest() {
const html = marked.parse(`
::extension1
::extension2
:extension1
:extension2
# extension1
# extension2
# no extension
`);
assert.strictEqual(`\n${html}\n`.replace(/\n+/g, '\n'), `
<block-extension1>used extension1 walked</block-extension1>
<block-extension2>used extension2 walked</block-extension2>
<p>used extension1 walked
used extension2 walked</p>
<h1>used extension1 walked</h1>
<h1>used extension2 walked</h1>
<h1>no extension</h1>
`);
}
it('should merge extensions when calling marked.use multiple times', () => {
marked.use(createExtension('extension1'));
marked.use(createExtension('extension2'));
runTest();
});
it('should merge extensions when calling marked.use with multiple extensions', () => {
marked.use(
createExtension('extension1'),
createExtension('extension2'),
);
runTest();
});
it('should fall back to any extensions with the same name if the first returns false', () => {
marked.use(
createExtension('extension1'),
createExtension('extension2'),
createFalseExtension('extension1'),
createFalseExtension('extension2'),
);
runTest();
});
it('should merge extensions correctly', () => {
marked.use(
{},
{ tokenizer: {} },
{ renderer: {} },
{ walkTokens: () => {} },
{ extensions: [] },
);
// should not throw
marked.parse('# test');
});
});
it('should be async if any extension in use args is async', () => {
marked.use(
{ async: true },
{ async: false },
);
assert.ok(marked.defaults.async);
});
it('should be async if any extension in use is async', () => {
marked.use({ async: true });
marked.use({ async: false });
assert.ok(marked.defaults.async);
});
it('should reset async with setOptions', () => {
marked.use({ async: true });
setOptions({ async: false });
assert.ok(!defaults.async);
});
it('should return Promise if async', () => {
assert.ok(marked.parse('test', { async: true }) instanceof Promise);
});
it('should return string if not async', () => {
assert.strictEqual(typeof marked.parse('test', { async: false }), 'string');
});
it('should throw an error if async is set by extension', () => {
marked.use({ async: true });
assert.throws(() => marked.parse('test', { async: false }));
});
it('should allow deleting/editing tokens', () => {
const styleTags = {
extensions: [{
name: 'inlineStyleTag',
level: 'inline',
start(src) {
const match = src.match(/ *{[^\{]/);
if (match) {
return match.index;
}
},
tokenizer(src, tokens) {
const rule = /^ *{([^\{\}\n]+)}$/;
const match = rule.exec(src);
if (match) {
return {
type: 'inlineStyleTag',
raw: match[0], // This is the text that you want your token to consume from the source
text: match[1],
};
}
},
},
{
name: 'styled',
renderer(token) {
token.type = token.originalType;
const text = this.parser.parse([token]);
const openingTag = /(<[^\s<>]+)([^\n<>]*>.*)/s.exec(text);
if (openingTag) {
return `${openingTag[1]} ${token.style}${openingTag[2]}`;
}
return text;
},
}],
walkTokens(token) {
if (token.tokens) {
const finalChildToken = token.tokens.at(-1);
if (finalChildToken?.type === 'inlineStyleTag') {
token.originalType = token.type;
token.type = 'styled';
token.style = `style="color:${finalChildToken.text};"`;
token.tokens.pop();
}
}
},
};
marked.use(styleTags);
const html = marked.parse('This is a *paragraph* with blue text. {blue}\n'
+ '# This is a *header* with red text {red}');
assert.strictEqual(html, '<p style="color:blue;">This is a <em>paragraph</em> with blue text.</p>\n'
+ '<h1 style="color:red;">This is a <em>header</em> with red text</h1>\n');
});
it('should use renderer', () => {
const extension = {
useNewRenderer: true,
renderer: {
paragraph() {
return 'extension';
},
},
};
mock.method(extension.renderer, 'paragraph');
marked.use(extension);
const html = marked.parse('text');
assert.strictEqual(extension.renderer.paragraph.mock.calls[0].arguments[0].raw, 'text');
assert.strictEqual(html, 'extension');
});
it('should use tokenizer', () => {
const extension = {
tokenizer: {
paragraph(text) {
const token = {
type: 'paragraph',
raw: text,
text: 'extension',
tokens: [],
};
this.lexer.inline(token.text, token.tokens);
return token;
},
},
};
mock.method(extension.tokenizer, 'paragraph');
marked.use(extension);
const html = marked.parse('text');
assert.strictEqual(extension.tokenizer.paragraph.mock.calls[0].arguments[0], 'text');
assert.strictEqual(html, '<p>extension</p>\n');
});
it('should use walkTokens', () => {
let walked = 0;
const extension = {
walkTokens(token) {
walked++;
},
};
marked.use(extension);
marked.parse('text');
assert.strictEqual(walked, 2);
});
it('should use options from extension', () => {
const extension = {
breaks: true,
};
marked.use(extension);
const html = marked.parse('line1\nline2');
assert.strictEqual(html, '<p>line1<br>line2</p>\n');
});
it('should call all walkTokens in reverse order', () => {
let walkedOnce = 0;
let walkedTwice = 0;
const extension1 = {
walkTokens(token) {
if (token.walkedOnce) {
walkedTwice++;
}
},
};
const extension2 = {
walkTokens(token) {
walkedOnce++;
token.walkedOnce = true;
},
};
marked.use(extension1);
marked.use(extension2);
marked.parse('text');
assert.strictEqual(walkedOnce, 2);
assert.strictEqual(walkedTwice, 2);
});
it('should use last extension function and not override others', () => {
const extension1 = {
useNewRenderer: true,
renderer: {
paragraph() {
return 'extension1 paragraph\n';
},
html() {
return 'extension1 html\n';
},
},
};
const extension2 = {
useNewRenderer: true,
renderer: {
paragraph() {
return 'extension2 paragraph\n';
},
},
};
marked.use(extension1);
marked.use(extension2);
const html = marked.parse(`
paragraph
<html />
# heading
`);
assert.strictEqual(html, 'extension2 paragraph\nextension1 html\n<h1>heading</h1>\n');
});
it('should use previous extension when returning false', () => {
const extension1 = {
useNewRenderer: true,
renderer: {
paragraph({ text }) {
if (text !== 'original') {
return 'extension1 paragraph\n';
}
return false;
},
},
};
const extension2 = {
useNewRenderer: true,
renderer: {
paragraph({ text }) {
if (text !== 'extension1' && text !== 'original') {
return 'extension2 paragraph\n';
}
return false;
},
},
};
marked.use(extension1);
marked.use(extension2);
const html = marked.parse(`
paragraph
extension1
original
`);
assert.strictEqual(html, 'extension2 paragraph\nextension1 paragraph\n<p>original</p>\n');
});
it('should get options with this.options', () => {
const extension = {
useNewRenderer: true,
renderer: {
heading: () => {
return this && this.options ? 'arrow options\n' : 'arrow no options\n';
},
html: function() {
return this.options ? 'function options\n' : 'function no options\n';
},
paragraph() {
return this.options ? 'shorthand options\n' : 'shorthand no options\n';
},
},
};
marked.use(extension);
const html = marked.parse(`
# heading
<html />
paragraph
`);
assert.strictEqual(html, 'arrow no options\nfunction options\nshorthand options\n');
});
});
describe('walkTokens', () => {
it('should walk over every token', () => {
const markdown = `
paragraph
---
# heading
\`\`\`
code
\`\`\`
| a | b |
|---|---|
| 1 | 2 |
| 3 | 4 |
> blockquote
- list
<div>html</div>
[link](https://example.com)
**strong**
*em*
\`codespan\`
~~del~~
br
br
`;
const tokens = lexer(markdown, { ...getDefaults(), breaks: true });
const tokensSeen = [];
walkTokens(tokens, (token) => {
tokensSeen.push([token.type, (token.raw || '').replace(/\n/g, '')]);
});
assert.deepEqual(tokensSeen, [
['space', ''],
['paragraph', 'paragraph'],
['text', 'paragraph'],
['space', ''],
['hr', '---'],
['space', ''],
['heading', '# heading'],
['text', 'heading'],
['code', '```code```'],
['space', ''],
['table', '| a | b ||---|---|| 1 | 2 || 3 | 4 |'],
['text', 'a'],
['text', 'b'],
['text', '1'],
['text', '2'],
['text', '3'],
['text', '4'],
['blockquote', '> blockquote'],
['paragraph', 'blockquote'],
['text', 'blockquote'],
['space', ''],
['list', '- list'],
['list_item', '- list'],
['text', 'list'],
['text', 'list'],
['space', ''],
['html', '<div>html</div>'],
['paragraph', '[link](https://example.com)'],
['link', '[link](https://example.com)'],
['text', 'link'],
['space', ''],
['paragraph', ''],
['image', ''],
['space', ''],
['paragraph', '**strong**'],
['strong', '**strong**'],
['text', 'strong'],
['space', ''],
['paragraph', '*em*'],
['em', '*em*'],
['text', 'em'],
['space', ''],
['paragraph', '`codespan`'],
['codespan', '`codespan`'],
['space', ''],
['paragraph', '~~del~~'],
['del', '~~del~~'],
['text', 'del'],
['space', ''],
['paragraph', 'brbr'],
['text', 'br'],
['br', ''],
['text', 'br'],
]);
});
it('should assign marked to `this`', () => {
marked.use({
walkTokens(token) {
if (token.type === 'em') {
token.text += ' walked';
token.tokens = this.Lexer.lexInline(token.text);
}
},
});
assert.strictEqual(marked.parse('*text*').trim(), '<p><em>text walked</em></p>');
});
it('should wait for async `walkTokens` function', async() => {
marked.use({
async: true,
async walkTokens(token) {
if (token.type === 'em') {
await timeout();
token.text += ' walked';
token.tokens = this.Lexer.lexInline(token.text);
}
},
});
const promise = marked.parse('*text*');
assert.ok(promise instanceof Promise);
const html = await promise;
assert.strictEqual(html.trim(), '<p><em>text walked</em></p>');
});
it('should return promise if async and no walkTokens function', async() => {
marked.use({
async: true,
});
const promise = marked.parse('*text*');
assert.ok(promise instanceof Promise);
const html = await promise;
assert.strictEqual(html.trim(), '<p><em>text</em></p>');
});
});
});