Skip to content

Commit 9b452bc

Browse files
UziTechUziTech
authoredMar 22, 2023
feat: add preprocess and postprocess hooks (#2730)
·
v15.0.7v4.3.0
1 parent 042dcc5 commit 9b452bc

File tree

8 files changed

+418
-167
lines changed

8 files changed

+418
-167
lines changed
 

‎docs/USING_PRO.md

+78-1
Original file line numberDiff line numberDiff line change
@@ -262,7 +262,7 @@ smartypants('"this ... string"')
262262

263263
<h2 id="walk-tokens">Walk Tokens : <code>walkTokens</code></h2>
264264

265-
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. When [`async`](#async) mode is enabled, the return value is awaited. Otherwise the return value is ignored.
265+
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. When [`async`](#async) mode is enabled, the return value is awaited. Otherwise the return value is ignored.
266266

267267
`marked.use()` can be called multiple times with different `walkTokens` functions. Each function will be called in order, starting with the function that was assigned *last*.
268268

@@ -293,6 +293,83 @@ console.log(marked.parse('# heading 2\n\n## heading 3'));
293293

294294
***
295295

296+
<h2 id="hooks">Hooks : <code>hooks</code></h2>
297+
298+
Hooks are methods that hook into some part of marked. The following hooks are available:
299+
300+
| signature | description |
301+
|-----------|-------------|
302+
| `preprocess(markdown: string): string` | Process markdown before sending it to marked. |
303+
| `postprocess(html: string): string` | Process html after marked has finished parsing. |
304+
305+
`marked.use()` can be called multiple times with different `hooks` functions. Each function will be called in order, starting with the function that was assigned *last*.
306+
307+
**Example:** Set options based on [front-matter](https://www.npmjs.com/package/front-matter)
308+
309+
```js
310+
import { marked } from 'marked';
311+
import fm from 'front-matter';
312+
313+
// Override function
314+
const hooks = {
315+
preprocess(markdown) {
316+
const { attributes, body } = fm(markdown);
317+
for (const prop in attributes) {
318+
if (prop in this.options) {
319+
this.options[prop] = attributes[prop];
320+
}
321+
}
322+
return body;
323+
}
324+
};
325+
326+
marked.use({ hooks });
327+
328+
// Run marked
329+
console.log(marked.parse(`
330+
---
331+
headerIds: false
332+
---
333+
334+
## test
335+
`.trim()));
336+
```
337+
338+
**Output:**
339+
340+
```html
341+
<h2>test</h2>
342+
```
343+
344+
**Example:** Sanitize HTML with [isomorphic-dompurify](https://www.npmjs.com/package/isomorphic-dompurify)
345+
346+
```js
347+
import { marked } from 'marked';
348+
import DOMPurify from 'isomorphic-dompurify';
349+
350+
// Override function
351+
const hooks = {
352+
postprocess(html) {
353+
return DOMPurify.sanitize(html);
354+
}
355+
};
356+
357+
marked.use({ hooks });
358+
359+
// Run marked
360+
console.log(marked.parse(`
361+
<img src=x onerror=alert(1)//>
362+
`));
363+
```
364+
365+
**Output:**
366+
367+
```html
368+
<img src="x">
369+
```
370+
371+
***
372+
296373
<h2 id="extensions">Custom Extensions : <code>extensions</code></h2>
297374

298375
You may supply an `extensions` array to the `options` object. This array can contain any number of `extension` objects, using the following properties:

‎docs/_document.html

+1
Original file line numberDiff line numberDiff line change
@@ -53,6 +53,7 @@ <h1>Marked Documentation</h1>
5353
<li><a href="/using_pro#renderer">Renderer</a></li>
5454
<li><a href="/using_pro#tokenizer">Tokenizer</a></li>
5555
<li><a href="/using_pro#walk-tokens">Walk Tokens</a></li>
56+
<li><a href="/using_pro#hooks">Hooks</a></li>
5657
<li><a href="/using_pro#extensions">Custom Extensions</a></li>
5758
<li><a href="/using_pro#async">Async Marked</a></li>
5859
<li><a href="/using_pro#lexer">Lexer</a></li>

‎src/Hooks.js

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
import { defaults } from './defaults.js';
2+
3+
export class Hooks {
4+
constructor(options) {
5+
this.options = options || defaults;
6+
}
7+
8+
static passThroughHooks = new Set([
9+
'preprocess',
10+
'postprocess'
11+
]);
12+
13+
/**
14+
* Process markdown before marked
15+
*/
16+
preprocess(markdown) {
17+
return markdown;
18+
}
19+
20+
/**
21+
* Process HTML after marked is finished
22+
*/
23+
postprocess(html) {
24+
return html;
25+
}
26+
}

‎src/defaults.js

+1
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@ export function getDefaults() {
88
headerIds: true,
99
headerPrefix: '',
1010
highlight: null,
11+
hooks: null,
1112
langPrefix: 'language-',
1213
mangle: true,
1314
pedantic: false,

‎src/helpers.js

-17
Original file line numberDiff line numberDiff line change
@@ -142,23 +142,6 @@ export function resolveUrl(base, href) {
142142

143143
export const noopTest = { exec: function noopTest() {} };
144144

145-
export function merge(obj) {
146-
let i = 1,
147-
target,
148-
key;
149-
150-
for (; i < arguments.length; i++) {
151-
target = arguments[i];
152-
for (key in target) {
153-
if (Object.prototype.hasOwnProperty.call(target, key)) {
154-
obj[key] = target[key];
155-
}
156-
}
157-
}
158-
159-
return obj;
160-
}
161-
162145
export function splitCells(tableRow, count) {
163146
// ensure that every cell-delimiting pipe has a space
164147
// before it to distinguish it from an escaped pipe

‎src/marked.js

+171-131
Original file line numberDiff line numberDiff line change
@@ -4,8 +4,8 @@ import { Tokenizer } from './Tokenizer.js';
44
import { Renderer } from './Renderer.js';
55
import { TextRenderer } from './TextRenderer.js';
66
import { Slugger } from './Slugger.js';
7+
import { Hooks } from './Hooks.js';
78
import {
8-
merge,
99
checkSanitizeDeprecation,
1010
escape
1111
} from './helpers.js';
@@ -15,132 +15,169 @@ import {
1515
defaults
1616
} from './defaults.js';
1717

18-
/**
19-
* Marked
20-
*/
21-
export function marked(src, opt, callback) {
22-
// throw error in case of non string input
23-
if (typeof src === 'undefined' || src === null) {
24-
throw new Error('marked(): input parameter is undefined or null');
25-
}
26-
if (typeof src !== 'string') {
27-
throw new Error('marked(): input parameter is of type '
28-
+ Object.prototype.toString.call(src) + ', string expected');
29-
}
30-
31-
if (typeof opt === 'function') {
32-
callback = opt;
33-
opt = null;
34-
}
35-
36-
opt = merge({}, marked.defaults, opt || {});
37-
checkSanitizeDeprecation(opt);
18+
function onError(silent, async, callback) {
19+
return (e) => {
20+
e.message += '\nPlease report this to https://github.com/markedjs/marked.';
3821

39-
if (callback) {
40-
const highlight = opt.highlight;
41-
let tokens;
22+
if (silent) {
23+
const msg = '<p>An error occurred:</p><pre>'
24+
+ escape(e.message + '', true)
25+
+ '</pre>';
26+
if (async) {
27+
return Promise.resolve(msg);
28+
}
29+
if (callback) {
30+
callback(null, msg);
31+
return;
32+
}
33+
return msg;
34+
}
4235

43-
try {
44-
tokens = Lexer.lex(src, opt);
45-
} catch (e) {
46-
return callback(e);
36+
if (async) {
37+
return Promise.reject(e);
4738
}
39+
if (callback) {
40+
callback(e);
41+
return;
42+
}
43+
throw e;
44+
};
45+
}
4846

49-
const done = function(err) {
50-
let out;
47+
function parseMarkdown(lexer, parser) {
48+
return (src, opt, callback) => {
49+
if (typeof opt === 'function') {
50+
callback = opt;
51+
opt = null;
52+
}
5153

52-
if (!err) {
53-
try {
54-
if (opt.walkTokens) {
55-
marked.walkTokens(tokens, opt.walkTokens);
56-
}
57-
out = Parser.parse(tokens, opt);
58-
} catch (e) {
59-
err = e;
60-
}
61-
}
54+
const origOpt = { ...opt };
55+
opt = { ...marked.defaults, ...origOpt };
56+
const throwError = onError(opt.silent, opt.async, callback);
6257

63-
opt.highlight = highlight;
58+
// throw error in case of non string input
59+
if (typeof src === 'undefined' || src === null) {
60+
return throwError(new Error('marked(): input parameter is undefined or null'));
61+
}
62+
if (typeof src !== 'string') {
63+
return throwError(new Error('marked(): input parameter is of type '
64+
+ Object.prototype.toString.call(src) + ', string expected'));
65+
}
6466

65-
return err
66-
? callback(err)
67-
: callback(null, out);
68-
};
67+
checkSanitizeDeprecation(opt);
6968

70-
if (!highlight || highlight.length < 3) {
71-
return done();
69+
if (opt.hooks) {
70+
opt.hooks.options = opt;
7271
}
7372

74-
delete opt.highlight;
73+
if (callback) {
74+
const highlight = opt.highlight;
75+
let tokens;
76+
77+
try {
78+
if (opt.hooks) {
79+
src = opt.hooks.preprocess(src);
80+
}
81+
tokens = lexer(src, opt);
82+
} catch (e) {
83+
return throwError(e);
84+
}
7585

76-
if (!tokens.length) return done();
86+
const done = function(err) {
87+
let out;
7788

78-
let pending = 0;
79-
marked.walkTokens(tokens, function(token) {
80-
if (token.type === 'code') {
81-
pending++;
82-
setTimeout(() => {
83-
highlight(token.text, token.lang, function(err, code) {
84-
if (err) {
85-
return done(err);
89+
if (!err) {
90+
try {
91+
if (opt.walkTokens) {
92+
marked.walkTokens(tokens, opt.walkTokens);
8693
}
87-
if (code != null && code !== token.text) {
88-
token.text = code;
89-
token.escaped = true;
94+
out = parser(tokens, opt);
95+
if (opt.hooks) {
96+
out = opt.hooks.postprocess(out);
9097
}
98+
} catch (e) {
99+
err = e;
100+
}
101+
}
91102

92-
pending--;
93-
if (pending === 0) {
94-
done();
95-
}
96-
});
97-
}, 0);
103+
opt.highlight = highlight;
104+
105+
return err
106+
? throwError(err)
107+
: callback(null, out);
108+
};
109+
110+
if (!highlight || highlight.length < 3) {
111+
return done();
98112
}
99-
});
100113

101-
if (pending === 0) {
102-
done();
103-
}
114+
delete opt.highlight;
104115

105-
return;
106-
}
116+
if (!tokens.length) return done();
107117

108-
function onError(e) {
109-
e.message += '\nPlease report this to https://github.com/markedjs/marked.';
110-
if (opt.silent) {
111-
const msg = '<p>An error occurred:</p><pre>'
112-
+ escape(e.message + '', true)
113-
+ '</pre>';
114-
if (opt.async) {
115-
return Promise.resolve(msg);
118+
let pending = 0;
119+
marked.walkTokens(tokens, function(token) {
120+
if (token.type === 'code') {
121+
pending++;
122+
setTimeout(() => {
123+
highlight(token.text, token.lang, function(err, code) {
124+
if (err) {
125+
return done(err);
126+
}
127+
if (code != null && code !== token.text) {
128+
token.text = code;
129+
token.escaped = true;
130+
}
131+
132+
pending--;
133+
if (pending === 0) {
134+
done();
135+
}
136+
});
137+
}, 0);
138+
}
139+
});
140+
141+
if (pending === 0) {
142+
done();
116143
}
117-
return msg;
144+
145+
return;
118146
}
147+
119148
if (opt.async) {
120-
return Promise.reject(e);
149+
return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src)
150+
.then(src => lexer(src, opt))
151+
.then(tokens => opt.walkTokens ? Promise.all(marked.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens)
152+
.then(tokens => parser(tokens, opt))
153+
.then(html => opt.hooks ? opt.hooks.postprocess(html) : html)
154+
.catch(throwError);
121155
}
122-
throw e;
123-
}
124156

125-
try {
126-
if (opt.async) {
127-
let promise = Promise.resolve(Lexer.lex(src, opt));
157+
try {
158+
if (opt.hooks) {
159+
src = opt.hooks.preprocess(src);
160+
}
161+
const tokens = lexer(src, opt);
128162
if (opt.walkTokens) {
129-
promise = promise.then((tokens) =>
130-
Promise.all(marked.walkTokens(tokens, opt.walkTokens)).then(() => tokens)
131-
);
163+
marked.walkTokens(tokens, opt.walkTokens);
164+
}
165+
let html = parser(tokens, opt);
166+
if (opt.hooks) {
167+
html = opt.hooks.postprocess(html);
132168
}
133-
return promise.then((tokens) => Parser.parse(tokens, opt)).catch(onError);
169+
return html;
170+
} catch (e) {
171+
return throwError(e);
134172
}
173+
};
174+
}
135175

136-
const tokens = Lexer.lex(src, opt);
137-
if (opt.walkTokens) {
138-
marked.walkTokens(tokens, opt.walkTokens);
139-
}
140-
return Parser.parse(tokens, opt);
141-
} catch (e) {
142-
return onError(e);
143-
}
176+
/**
177+
* Marked
178+
*/
179+
export function marked(src, opt, callback) {
180+
return parseMarkdown(Lexer.lex, Parser.parse)(src, opt, callback);
144181
}
145182

146183
/**
@@ -149,7 +186,7 @@ export function marked(src, opt, callback) {
149186

150187
marked.options =
151188
marked.setOptions = function(opt) {
152-
merge(marked.defaults, opt);
189+
marked.defaults = { ...marked.defaults, ...opt };
153190
changeDefaults(marked.defaults);
154191
return marked;
155192
};
@@ -167,10 +204,10 @@ marked.use = function(...args) {
167204

168205
args.forEach((pack) => {
169206
// copy options to new object
170-
const opts = merge({}, pack);
207+
const opts = { ...pack };
171208

172209
// set async to true if it was set to true before
173-
opts.async = marked.defaults.async || opts.async;
210+
opts.async = marked.defaults.async || opts.async || false;
174211

175212
// ==-- Parse "addon" extensions --== //
176213
if (pack.extensions) {
@@ -257,6 +294,35 @@ marked.use = function(...args) {
257294
opts.tokenizer = tokenizer;
258295
}
259296

297+
// ==-- Parse Hooks extensions --== //
298+
if (pack.hooks) {
299+
const hooks = marked.defaults.hooks || new Hooks();
300+
for (const prop in pack.hooks) {
301+
const prevHook = hooks[prop];
302+
if (Hooks.passThroughHooks.has(prop)) {
303+
hooks[prop] = (arg) => {
304+
if (marked.defaults.async) {
305+
return Promise.resolve(pack.hooks[prop].call(hooks, arg)).then(ret => {
306+
return prevHook.call(hooks, ret);
307+
});
308+
}
309+
310+
const ret = pack.hooks[prop].call(hooks, arg);
311+
return prevHook.call(hooks, ret);
312+
};
313+
} else {
314+
hooks[prop] = (...args) => {
315+
let ret = pack.hooks[prop].apply(hooks, args);
316+
if (ret === false) {
317+
ret = prevHook.apply(hooks, args);
318+
}
319+
return ret;
320+
};
321+
}
322+
}
323+
opts.hooks = hooks;
324+
}
325+
260326
// ==-- Parse WalkTokens extensions --== //
261327
if (pack.walkTokens) {
262328
const walkTokens = marked.defaults.walkTokens;
@@ -316,35 +382,7 @@ marked.walkTokens = function(tokens, callback) {
316382
* Parse Inline
317383
* @param {string} src
318384
*/
319-
marked.parseInline = function(src, opt) {
320-
// throw error in case of non string input
321-
if (typeof src === 'undefined' || src === null) {
322-
throw new Error('marked.parseInline(): input parameter is undefined or null');
323-
}
324-
if (typeof src !== 'string') {
325-
throw new Error('marked.parseInline(): input parameter is of type '
326-
+ Object.prototype.toString.call(src) + ', string expected');
327-
}
328-
329-
opt = merge({}, marked.defaults, opt || {});
330-
checkSanitizeDeprecation(opt);
331-
332-
try {
333-
const tokens = Lexer.lexInline(src, opt);
334-
if (opt.walkTokens) {
335-
marked.walkTokens(tokens, opt.walkTokens);
336-
}
337-
return Parser.parseInline(tokens, opt);
338-
} catch (e) {
339-
e.message += '\nPlease report this to https://github.com/markedjs/marked.';
340-
if (opt.silent) {
341-
return '<p>An error occurred:</p><pre>'
342-
+ escape(e.message + '', true)
343-
+ '</pre>';
344-
}
345-
throw e;
346-
}
347-
};
385+
marked.parseInline = parseMarkdown(Lexer.lexInline, Parser.parseInline);
348386

349387
/**
350388
* Expose
@@ -357,6 +395,7 @@ marked.Lexer = Lexer;
357395
marked.lexer = Lexer.lex;
358396
marked.Tokenizer = Tokenizer;
359397
marked.Slugger = Slugger;
398+
marked.Hooks = Hooks;
360399
marked.parse = marked;
361400

362401
export const options = marked.options;
@@ -374,3 +413,4 @@ export { Tokenizer } from './Tokenizer.js';
374413
export { Renderer } from './Renderer.js';
375414
export { TextRenderer } from './TextRenderer.js';
376415
export { Slugger } from './Slugger.js';
416+
export { Hooks } from './Hooks.js';

‎src/rules.js

+18-14
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,6 @@
11
import {
22
noopTest,
3-
edit,
4-
merge
3+
edit
54
} from './helpers.js';
65

76
/**
@@ -85,17 +84,18 @@ block.blockquote = edit(block.blockquote)
8584
* Normal Block Grammar
8685
*/
8786

88-
block.normal = merge({}, block);
87+
block.normal = { ...block };
8988

9089
/**
9190
* GFM Block Grammar
9291
*/
9392

94-
block.gfm = merge({}, block.normal, {
93+
block.gfm = {
94+
...block.normal,
9595
table: '^ *([^\\n ].*\\|.*)\\n' // Header
9696
+ ' {0,3}(?:\\| *)?(:?-+:? *(?:\\| *:?-+:? *)*)(?:\\| *)?' // Align
9797
+ '(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)' // Cells
98-
});
98+
};
9999

100100
block.gfm.table = edit(block.gfm.table)
101101
.replace('hr', block.hr)
@@ -123,7 +123,8 @@ block.gfm.paragraph = edit(block._paragraph)
123123
* Pedantic grammar (original John Gruber's loose markdown specification)
124124
*/
125125

126-
block.pedantic = merge({}, block.normal, {
126+
block.pedantic = {
127+
...block.normal,
127128
html: edit(
128129
'^ *(?:comment *(?:\\n|\\s*$)'
129130
+ '|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)' // closed tag
@@ -147,7 +148,7 @@ block.pedantic = merge({}, block.normal, {
147148
.replace('|list', '')
148149
.replace('|html', '')
149150
.getRegex()
150-
});
151+
};
151152

152153
/**
153154
* Inline-Level Grammar
@@ -249,13 +250,14 @@ inline.reflinkSearch = edit(inline.reflinkSearch, 'g')
249250
* Normal Inline Grammar
250251
*/
251252

252-
inline.normal = merge({}, inline);
253+
inline.normal = { ...inline };
253254

254255
/**
255256
* Pedantic Inline Grammar
256257
*/
257258

258-
inline.pedantic = merge({}, inline.normal, {
259+
inline.pedantic = {
260+
...inline.normal,
259261
strong: {
260262
start: /^__|\*\*/,
261263
middle: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,
@@ -274,20 +276,21 @@ inline.pedantic = merge({}, inline.normal, {
274276
reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/)
275277
.replace('label', inline._label)
276278
.getRegex()
277-
});
279+
};
278280

279281
/**
280282
* GFM Inline Grammar
281283
*/
282284

283-
inline.gfm = merge({}, inline.normal, {
285+
inline.gfm = {
286+
...inline.normal,
284287
escape: edit(inline.escape).replace('])', '~|])').getRegex(),
285288
_extended_email: /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,
286289
url: /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,
287290
_backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,
288291
del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
289292
text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
290-
});
293+
};
291294

292295
inline.gfm.url = edit(inline.gfm.url, 'i')
293296
.replace('email', inline.gfm._extended_email)
@@ -296,10 +299,11 @@ inline.gfm.url = edit(inline.gfm.url, 'i')
296299
* GFM + Line Breaks Inline Grammar
297300
*/
298301

299-
inline.breaks = merge({}, inline.gfm, {
302+
inline.breaks = {
303+
...inline.gfm,
300304
br: edit(inline.br).replace('{2,}', '*').getRegex(),
301305
text: edit(inline.gfm.text)
302306
.replace('\\b_', '\\b_| {2,}\\n')
303307
.replace(/\{2,\}/g, '*')
304308
.getRegex()
305-
});
309+
};

‎test/unit/marked-spec.js

+123-4
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,11 @@
11
import { marked, Renderer, Slugger, lexer, parseInline, use, getDefaults, walkTokens as _walkTokens, defaults, setOptions } from '../../src/marked.js';
22

3+
async function timeout(ms = 1) {
4+
return new Promise(resolve => {
5+
setTimeout(resolve, ms);
6+
});
7+
}
8+
39
describe('Test heading ID functionality', () => {
410
it('should add id attribute by default', () => {
511
const renderer = new Renderer();
@@ -1099,9 +1105,7 @@ br
10991105
async: true,
11001106
async walkTokens(token) {
11011107
if (token.type === 'em') {
1102-
await new Promise((resolve) => {
1103-
setTimeout(resolve, 100);
1104-
});
1108+
await timeout();
11051109
token.text += ' walked';
11061110
token.tokens = this.Lexer.lexInline(token.text);
11071111
}
@@ -1113,7 +1117,7 @@ br
11131117
expect(html.trim()).toBe('<p><em>text walked</em></p>');
11141118
});
11151119

1116-
it('should return promise if async', async() => {
1120+
it('should return promise if async and no walkTokens function', async() => {
11171121
marked.use({
11181122
async: true
11191123
});
@@ -1123,3 +1127,118 @@ br
11231127
expect(html.trim()).toBe('<p><em>text</em></p>');
11241128
});
11251129
});
1130+
1131+
describe('Hooks', () => {
1132+
it('should preprocess markdown', () => {
1133+
marked.use({
1134+
hooks: {
1135+
preprocess(markdown) {
1136+
return `# preprocess\n\n${markdown}`;
1137+
}
1138+
}
1139+
});
1140+
const html = marked('*text*');
1141+
expect(html.trim()).toBe('<h1 id="preprocess">preprocess</h1>\n<p><em>text</em></p>');
1142+
});
1143+
1144+
it('should preprocess async', async() => {
1145+
marked.use({
1146+
async: true,
1147+
hooks: {
1148+
async preprocess(markdown) {
1149+
await timeout();
1150+
return `# preprocess async\n\n${markdown}`;
1151+
}
1152+
}
1153+
});
1154+
const promise = marked('*text*');
1155+
expect(promise).toBeInstanceOf(Promise);
1156+
const html = await promise;
1157+
expect(html.trim()).toBe('<h1 id="preprocess-async">preprocess async</h1>\n<p><em>text</em></p>');
1158+
});
1159+
1160+
it('should preprocess options', () => {
1161+
marked.use({
1162+
hooks: {
1163+
preprocess(markdown) {
1164+
this.options.headerIds = false;
1165+
return markdown;
1166+
}
1167+
}
1168+
});
1169+
const html = marked('# test');
1170+
expect(html.trim()).toBe('<h1>test</h1>');
1171+
});
1172+
1173+
it('should preprocess options async', async() => {
1174+
marked.use({
1175+
async: true,
1176+
hooks: {
1177+
async preprocess(markdown) {
1178+
await timeout();
1179+
this.options.headerIds = false;
1180+
return markdown;
1181+
}
1182+
}
1183+
});
1184+
const html = await marked('# test');
1185+
expect(html.trim()).toBe('<h1>test</h1>');
1186+
});
1187+
1188+
it('should postprocess html', () => {
1189+
marked.use({
1190+
hooks: {
1191+
postprocess(html) {
1192+
return html + '<h1>postprocess</h1>';
1193+
}
1194+
}
1195+
});
1196+
const html = marked('*text*');
1197+
expect(html.trim()).toBe('<p><em>text</em></p>\n<h1>postprocess</h1>');
1198+
});
1199+
1200+
it('should postprocess async', async() => {
1201+
marked.use({
1202+
async: true,
1203+
hooks: {
1204+
async postprocess(html) {
1205+
await timeout();
1206+
return html + '<h1>postprocess async</h1>\n';
1207+
}
1208+
}
1209+
});
1210+
const promise = marked('*text*');
1211+
expect(promise).toBeInstanceOf(Promise);
1212+
const html = await promise;
1213+
expect(html.trim()).toBe('<p><em>text</em></p>\n<h1>postprocess async</h1>');
1214+
});
1215+
1216+
it('should process all hooks in reverse', async() => {
1217+
marked.use({
1218+
hooks: {
1219+
preprocess(markdown) {
1220+
return `# preprocess1\n\n${markdown}`;
1221+
},
1222+
postprocess(html) {
1223+
return html + '<h1>postprocess1</h1>\n';
1224+
}
1225+
}
1226+
});
1227+
marked.use({
1228+
async: true,
1229+
hooks: {
1230+
preprocess(markdown) {
1231+
return `# preprocess2\n\n${markdown}`;
1232+
},
1233+
async postprocess(html) {
1234+
await timeout();
1235+
return html + '<h1>postprocess2 async</h1>\n';
1236+
}
1237+
}
1238+
});
1239+
const promise = marked('*text*');
1240+
expect(promise).toBeInstanceOf(Promise);
1241+
const html = await promise;
1242+
expect(html.trim()).toBe('<h1 id="preprocess1">preprocess1</h1>\n<h1 id="preprocess2">preprocess2</h1>\n<p><em>text</em></p>\n<h1>postprocess2 async</h1>\n<h1>postprocess1</h1>');
1243+
});
1244+
});

1 commit comments

Comments
 (1)

vercel[bot] commented on Mar 22, 2023

@vercel[bot]
vercel[bot]
on Mar 22, 2023

Successfully deployed to the following URLs:

marked-website – ./

marked-website-markedjs.vercel.app
markedjs.vercel.app
marked-website-git-master-markedjs.vercel.app
marked.js.org

Please sign in to comment.