@knapsack/plugin-changelog-md 4.69.5 → 4.69.6--canary.de6a636.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/client/changelog-page.js +779 -1441
- package/package.json +7 -7
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
/**
|
|
2
|
-
* marked
|
|
2
|
+
* marked v6.0.0 - a markdown parser
|
|
3
3
|
* Copyright (c) 2011-2023, Christopher Jeffrey. (MIT Licensed)
|
|
4
4
|
* https://github.com/markedjs/marked
|
|
5
5
|
*/
|
|
@@ -9,7 +9,22 @@
|
|
|
9
9
|
* The code in this file is generated from files in ./src/
|
|
10
10
|
*/
|
|
11
11
|
|
|
12
|
-
|
|
12
|
+
var __accessCheck = (obj, member, msg) => {
|
|
13
|
+
if (!member.has(obj))
|
|
14
|
+
throw TypeError("Cannot " + msg);
|
|
15
|
+
};
|
|
16
|
+
var __privateAdd = (obj, member, value) => {
|
|
17
|
+
if (member.has(obj))
|
|
18
|
+
throw TypeError("Cannot add the same private member more than once");
|
|
19
|
+
member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
|
|
20
|
+
};
|
|
21
|
+
var __privateMethod = (obj, member, method) => {
|
|
22
|
+
__accessCheck(obj, member, "access private method");
|
|
23
|
+
return method;
|
|
24
|
+
};
|
|
25
|
+
|
|
26
|
+
// src/defaults.ts
|
|
27
|
+
function _getDefaults() {
|
|
13
28
|
return {
|
|
14
29
|
async: false,
|
|
15
30
|
baseUrl: null,
|
|
@@ -17,10 +32,10 @@ function getDefaults() {
|
|
|
17
32
|
extensions: null,
|
|
18
33
|
gfm: true,
|
|
19
34
|
headerIds: true,
|
|
20
|
-
headerPrefix:
|
|
35
|
+
headerPrefix: "",
|
|
21
36
|
highlight: null,
|
|
22
37
|
hooks: null,
|
|
23
|
-
langPrefix:
|
|
38
|
+
langPrefix: "language-",
|
|
24
39
|
mangle: true,
|
|
25
40
|
pedantic: false,
|
|
26
41
|
renderer: null,
|
|
@@ -33,28 +48,24 @@ function getDefaults() {
|
|
|
33
48
|
xhtml: false
|
|
34
49
|
};
|
|
35
50
|
}
|
|
36
|
-
|
|
37
|
-
let defaults = getDefaults();
|
|
38
|
-
|
|
51
|
+
var _defaults = _getDefaults();
|
|
39
52
|
function changeDefaults(newDefaults) {
|
|
40
|
-
|
|
53
|
+
_defaults = newDefaults;
|
|
41
54
|
}
|
|
42
55
|
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
'
|
|
53
|
-
'
|
|
54
|
-
'"': '"',
|
|
55
|
-
"'": '''
|
|
56
|
+
// src/helpers.ts
|
|
57
|
+
var escapeTest = /[&<>"']/;
|
|
58
|
+
var escapeReplace = new RegExp(escapeTest.source, "g");
|
|
59
|
+
var escapeTestNoEncode = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/;
|
|
60
|
+
var escapeReplaceNoEncode = new RegExp(escapeTestNoEncode.source, "g");
|
|
61
|
+
var escapeReplacements = {
|
|
62
|
+
"&": "&",
|
|
63
|
+
"<": "<",
|
|
64
|
+
">": ">",
|
|
65
|
+
'"': """,
|
|
66
|
+
"'": "'"
|
|
56
67
|
};
|
|
57
|
-
|
|
68
|
+
var getEscapeReplacement = (ch) => escapeReplacements[ch];
|
|
58
69
|
function escape(html, encode) {
|
|
59
70
|
if (encode) {
|
|
60
71
|
if (escapeTest.test(html)) {
|
|
@@ -65,42 +76,28 @@ function escape(html, encode) {
|
|
|
65
76
|
return html.replace(escapeReplaceNoEncode, getEscapeReplacement);
|
|
66
77
|
}
|
|
67
78
|
}
|
|
68
|
-
|
|
69
79
|
return html;
|
|
70
80
|
}
|
|
71
|
-
|
|
72
|
-
const unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
|
|
73
|
-
|
|
74
|
-
/**
|
|
75
|
-
* @param {string} html
|
|
76
|
-
*/
|
|
81
|
+
var unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
|
|
77
82
|
function unescape(html) {
|
|
78
|
-
// explicitly match decimal, hex, and named HTML entities
|
|
79
83
|
return html.replace(unescapeTest, (_, n) => {
|
|
80
84
|
n = n.toLowerCase();
|
|
81
|
-
if (n ===
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
: String.fromCharCode(+n.substring(1));
|
|
85
|
+
if (n === "colon")
|
|
86
|
+
return ":";
|
|
87
|
+
if (n.charAt(0) === "#") {
|
|
88
|
+
return n.charAt(1) === "x" ? String.fromCharCode(parseInt(n.substring(2), 16)) : String.fromCharCode(+n.substring(1));
|
|
86
89
|
}
|
|
87
|
-
return
|
|
90
|
+
return "";
|
|
88
91
|
});
|
|
89
92
|
}
|
|
90
|
-
|
|
91
|
-
const caret = /(^|[^\[])\^/g;
|
|
92
|
-
|
|
93
|
-
/**
|
|
94
|
-
* @param {string | RegExp} regex
|
|
95
|
-
* @param {string} opt
|
|
96
|
-
*/
|
|
93
|
+
var caret = /(^|[^\[])\^/g;
|
|
97
94
|
function edit(regex, opt) {
|
|
98
|
-
regex = typeof regex ===
|
|
99
|
-
opt = opt ||
|
|
95
|
+
regex = typeof regex === "string" ? regex : regex.source;
|
|
96
|
+
opt = opt || "";
|
|
100
97
|
const obj = {
|
|
101
98
|
replace: (name, val) => {
|
|
102
|
-
val = val.source
|
|
103
|
-
val = val.replace(caret,
|
|
99
|
+
val = typeof val === "object" && "source" in val ? val.source : val;
|
|
100
|
+
val = val.replace(caret, "$1");
|
|
104
101
|
regex = regex.replace(name, val);
|
|
105
102
|
return obj;
|
|
106
103
|
},
|
|
@@ -110,26 +107,17 @@ function edit(regex, opt) {
|
|
|
110
107
|
};
|
|
111
108
|
return obj;
|
|
112
109
|
}
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
const originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;
|
|
116
|
-
|
|
117
|
-
/**
|
|
118
|
-
* @param {boolean} sanitize
|
|
119
|
-
* @param {string} base
|
|
120
|
-
* @param {string} href
|
|
121
|
-
*/
|
|
110
|
+
var nonWordAndColonTest = /[^\w:]/g;
|
|
111
|
+
var originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;
|
|
122
112
|
function cleanUrl(sanitize, base, href) {
|
|
123
113
|
if (sanitize) {
|
|
124
114
|
let prot;
|
|
125
115
|
try {
|
|
126
|
-
prot = decodeURIComponent(unescape(href))
|
|
127
|
-
.replace(nonWordAndColonTest, '')
|
|
128
|
-
.toLowerCase();
|
|
116
|
+
prot = decodeURIComponent(unescape(href)).replace(nonWordAndColonTest, "").toLowerCase();
|
|
129
117
|
} catch (e) {
|
|
130
118
|
return null;
|
|
131
119
|
}
|
|
132
|
-
if (prot.indexOf(
|
|
120
|
+
if (prot.indexOf("javascript:") === 0 || prot.indexOf("vbscript:") === 0 || prot.indexOf("data:") === 0) {
|
|
133
121
|
return null;
|
|
134
122
|
}
|
|
135
123
|
}
|
|
@@ -137,107 +125,76 @@ function cleanUrl(sanitize, base, href) {
|
|
|
137
125
|
href = resolveUrl(base, href);
|
|
138
126
|
}
|
|
139
127
|
try {
|
|
140
|
-
href = encodeURI(href).replace(/%25/g,
|
|
128
|
+
href = encodeURI(href).replace(/%25/g, "%");
|
|
141
129
|
} catch (e) {
|
|
142
130
|
return null;
|
|
143
131
|
}
|
|
144
132
|
return href;
|
|
145
133
|
}
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
const domain = /^([^:]+:\/*[^/]*)[\s\S]*$/;
|
|
151
|
-
|
|
152
|
-
/**
|
|
153
|
-
* @param {string} base
|
|
154
|
-
* @param {string} href
|
|
155
|
-
*/
|
|
134
|
+
var baseUrls = {};
|
|
135
|
+
var justDomain = /^[^:]+:\/*[^/]*$/;
|
|
136
|
+
var protocol = /^([^:]+:)[\s\S]*$/;
|
|
137
|
+
var domain = /^([^:]+:\/*[^/]*)[\s\S]*$/;
|
|
156
138
|
function resolveUrl(base, href) {
|
|
157
|
-
if (!baseUrls[
|
|
158
|
-
// we can ignore everything in base after the last slash of its path component,
|
|
159
|
-
// but we might need to add _that_
|
|
160
|
-
// https://tools.ietf.org/html/rfc3986#section-3
|
|
139
|
+
if (!baseUrls[" " + base]) {
|
|
161
140
|
if (justDomain.test(base)) {
|
|
162
|
-
baseUrls[
|
|
141
|
+
baseUrls[" " + base] = base + "/";
|
|
163
142
|
} else {
|
|
164
|
-
baseUrls[
|
|
143
|
+
baseUrls[" " + base] = rtrim(base, "/", true);
|
|
165
144
|
}
|
|
166
145
|
}
|
|
167
|
-
base = baseUrls[
|
|
168
|
-
const relativeBase = base.indexOf(
|
|
169
|
-
|
|
170
|
-
if (href.substring(0, 2) === '//') {
|
|
146
|
+
base = baseUrls[" " + base];
|
|
147
|
+
const relativeBase = base.indexOf(":") === -1;
|
|
148
|
+
if (href.substring(0, 2) === "//") {
|
|
171
149
|
if (relativeBase) {
|
|
172
150
|
return href;
|
|
173
151
|
}
|
|
174
|
-
return base.replace(protocol,
|
|
175
|
-
} else if (href.charAt(0) ===
|
|
152
|
+
return base.replace(protocol, "$1") + href;
|
|
153
|
+
} else if (href.charAt(0) === "/") {
|
|
176
154
|
if (relativeBase) {
|
|
177
155
|
return href;
|
|
178
156
|
}
|
|
179
|
-
return base.replace(domain,
|
|
157
|
+
return base.replace(domain, "$1") + href;
|
|
180
158
|
} else {
|
|
181
159
|
return base + href;
|
|
182
160
|
}
|
|
183
161
|
}
|
|
184
|
-
|
|
185
|
-
const noopTest = { exec: function noopTest() {} };
|
|
186
|
-
|
|
162
|
+
var noopTest = { exec: () => null };
|
|
187
163
|
function splitCells(tableRow, count) {
|
|
188
|
-
// ensure that every cell-delimiting pipe has a space
|
|
189
|
-
// before it to distinguish it from an escaped pipe
|
|
190
164
|
const row = tableRow.replace(/\|/g, (match, offset, str) => {
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
return ' |';
|
|
201
|
-
}
|
|
202
|
-
}),
|
|
203
|
-
cells = row.split(/ \|/);
|
|
165
|
+
let escaped = false, curr = offset;
|
|
166
|
+
while (--curr >= 0 && str[curr] === "\\")
|
|
167
|
+
escaped = !escaped;
|
|
168
|
+
if (escaped) {
|
|
169
|
+
return "|";
|
|
170
|
+
} else {
|
|
171
|
+
return " |";
|
|
172
|
+
}
|
|
173
|
+
}), cells = row.split(/ \|/);
|
|
204
174
|
let i = 0;
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
if (cells.length > 0 && !cells[cells.length - 1].trim()) {
|
|
209
|
-
|
|
175
|
+
if (!cells[0].trim()) {
|
|
176
|
+
cells.shift();
|
|
177
|
+
}
|
|
178
|
+
if (cells.length > 0 && !cells[cells.length - 1].trim()) {
|
|
179
|
+
cells.pop();
|
|
180
|
+
}
|
|
210
181
|
if (cells.length > count) {
|
|
211
182
|
cells.splice(count);
|
|
212
183
|
} else {
|
|
213
|
-
while (cells.length < count)
|
|
184
|
+
while (cells.length < count)
|
|
185
|
+
cells.push("");
|
|
214
186
|
}
|
|
215
|
-
|
|
216
187
|
for (; i < cells.length; i++) {
|
|
217
|
-
|
|
218
|
-
cells[i] = cells[i].trim().replace(/\\\|/g, '|');
|
|
188
|
+
cells[i] = cells[i].trim().replace(/\\\|/g, "|");
|
|
219
189
|
}
|
|
220
190
|
return cells;
|
|
221
191
|
}
|
|
222
|
-
|
|
223
|
-
/**
|
|
224
|
-
* Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
|
|
225
|
-
* /c*$/ is vulnerable to REDOS.
|
|
226
|
-
*
|
|
227
|
-
* @param {string} str
|
|
228
|
-
* @param {string} c
|
|
229
|
-
* @param {boolean} invert Remove suffix of non-c chars instead. Default falsey.
|
|
230
|
-
*/
|
|
231
192
|
function rtrim(str, c, invert) {
|
|
232
193
|
const l = str.length;
|
|
233
194
|
if (l === 0) {
|
|
234
|
-
return
|
|
195
|
+
return "";
|
|
235
196
|
}
|
|
236
|
-
|
|
237
|
-
// Length of suffix matching the invert condition.
|
|
238
197
|
let suffLen = 0;
|
|
239
|
-
|
|
240
|
-
// Step left until we fail to match the invert condition.
|
|
241
198
|
while (suffLen < l) {
|
|
242
199
|
const currChar = str.charAt(l - suffLen - 1);
|
|
243
200
|
if (currChar === c && !invert) {
|
|
@@ -248,19 +205,16 @@ function rtrim(str, c, invert) {
|
|
|
248
205
|
break;
|
|
249
206
|
}
|
|
250
207
|
}
|
|
251
|
-
|
|
252
208
|
return str.slice(0, l - suffLen);
|
|
253
209
|
}
|
|
254
|
-
|
|
255
210
|
function findClosingBracket(str, b) {
|
|
256
211
|
if (str.indexOf(b[1]) === -1) {
|
|
257
212
|
return -1;
|
|
258
213
|
}
|
|
259
214
|
const l = str.length;
|
|
260
|
-
let level = 0,
|
|
261
|
-
i = 0;
|
|
215
|
+
let level = 0, i = 0;
|
|
262
216
|
for (; i < l; i++) {
|
|
263
|
-
if (str[i] ===
|
|
217
|
+
if (str[i] === "\\") {
|
|
264
218
|
i++;
|
|
265
219
|
} else if (str[i] === b[0]) {
|
|
266
220
|
level++;
|
|
@@ -273,154 +227,132 @@ function findClosingBracket(str, b) {
|
|
|
273
227
|
}
|
|
274
228
|
return -1;
|
|
275
229
|
}
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
console.warn('marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options');
|
|
230
|
+
function checkDeprecations(opt, callback) {
|
|
231
|
+
if (!opt || opt.silent) {
|
|
232
|
+
return;
|
|
280
233
|
}
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
// copied from https://stackoverflow.com/a/5450113/806777
|
|
284
|
-
/**
|
|
285
|
-
* @param {string} pattern
|
|
286
|
-
* @param {number} count
|
|
287
|
-
*/
|
|
288
|
-
function repeatString(pattern, count) {
|
|
289
|
-
if (count < 1) {
|
|
290
|
-
return '';
|
|
234
|
+
if (callback) {
|
|
235
|
+
console.warn("marked(): callback is deprecated since version 5.0.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/using_pro#async");
|
|
291
236
|
}
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
237
|
+
if (opt.sanitize || opt.sanitizer) {
|
|
238
|
+
console.warn("marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options");
|
|
239
|
+
}
|
|
240
|
+
if (opt.highlight || opt.langPrefix !== "language-") {
|
|
241
|
+
console.warn("marked(): highlight and langPrefix parameters are deprecated since version 5.0.0, should not be used and will be removed in the future. Instead use https://www.npmjs.com/package/marked-highlight.");
|
|
242
|
+
}
|
|
243
|
+
if (opt.mangle) {
|
|
244
|
+
console.warn("marked(): mangle parameter is enabled by default, but is deprecated since version 5.0.0, and will be removed in the future. To clear this warning, install https://www.npmjs.com/package/marked-mangle, or disable by setting `{mangle: false}`.");
|
|
245
|
+
}
|
|
246
|
+
if (opt.baseUrl) {
|
|
247
|
+
console.warn("marked(): baseUrl parameter is deprecated since version 5.0.0, should not be used and will be removed in the future. Instead use https://www.npmjs.com/package/marked-base-url.");
|
|
248
|
+
}
|
|
249
|
+
if (opt.smartypants) {
|
|
250
|
+
console.warn("marked(): smartypants parameter is deprecated since version 5.0.0, should not be used and will be removed in the future. Instead use https://www.npmjs.com/package/marked-smartypants.");
|
|
251
|
+
}
|
|
252
|
+
if (opt.xhtml) {
|
|
253
|
+
console.warn("marked(): xhtml parameter is deprecated since version 5.0.0, should not be used and will be removed in the future. Instead use https://www.npmjs.com/package/marked-xhtml.");
|
|
254
|
+
}
|
|
255
|
+
if (opt.headerIds || opt.headerPrefix) {
|
|
256
|
+
console.warn("marked(): headerIds and headerPrefix parameters enabled by default, but are deprecated since version 5.0.0, and will be removed in the future. To clear this warning, install https://www.npmjs.com/package/marked-gfm-heading-id, or disable by setting `{headerIds: false}`.");
|
|
299
257
|
}
|
|
300
|
-
return result + pattern;
|
|
301
258
|
}
|
|
302
259
|
|
|
303
|
-
|
|
260
|
+
// src/Tokenizer.ts
|
|
261
|
+
function outputLink(cap, link, raw, lexer2) {
|
|
304
262
|
const href = link.href;
|
|
305
263
|
const title = link.title ? escape(link.title) : null;
|
|
306
|
-
const text = cap[1].replace(/\\([\[\]])/g,
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
lexer.state.inLink = true;
|
|
264
|
+
const text = cap[1].replace(/\\([\[\]])/g, "$1");
|
|
265
|
+
if (cap[0].charAt(0) !== "!") {
|
|
266
|
+
lexer2.state.inLink = true;
|
|
310
267
|
const token = {
|
|
311
|
-
type:
|
|
268
|
+
type: "link",
|
|
312
269
|
raw,
|
|
313
270
|
href,
|
|
314
271
|
title,
|
|
315
272
|
text,
|
|
316
|
-
tokens:
|
|
273
|
+
tokens: lexer2.inlineTokens(text)
|
|
317
274
|
};
|
|
318
|
-
|
|
275
|
+
lexer2.state.inLink = false;
|
|
319
276
|
return token;
|
|
320
277
|
}
|
|
321
278
|
return {
|
|
322
|
-
type:
|
|
279
|
+
type: "image",
|
|
323
280
|
raw,
|
|
324
281
|
href,
|
|
325
282
|
title,
|
|
326
283
|
text: escape(text)
|
|
327
284
|
};
|
|
328
285
|
}
|
|
329
|
-
|
|
330
286
|
function indentCodeCompensation(raw, text) {
|
|
331
287
|
const matchIndentToCode = raw.match(/^(\s+)(?:```)/);
|
|
332
|
-
|
|
333
288
|
if (matchIndentToCode === null) {
|
|
334
289
|
return text;
|
|
335
290
|
}
|
|
336
|
-
|
|
337
291
|
const indentToCode = matchIndentToCode[1];
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
.map(node => {
|
|
342
|
-
const matchIndentInNode = node.match(/^\s+/);
|
|
343
|
-
if (matchIndentInNode === null) {
|
|
344
|
-
return node;
|
|
345
|
-
}
|
|
346
|
-
|
|
347
|
-
const [indentInNode] = matchIndentInNode;
|
|
348
|
-
|
|
349
|
-
if (indentInNode.length >= indentToCode.length) {
|
|
350
|
-
return node.slice(indentToCode.length);
|
|
351
|
-
}
|
|
352
|
-
|
|
292
|
+
return text.split("\n").map((node) => {
|
|
293
|
+
const matchIndentInNode = node.match(/^\s+/);
|
|
294
|
+
if (matchIndentInNode === null) {
|
|
353
295
|
return node;
|
|
354
|
-
}
|
|
355
|
-
|
|
296
|
+
}
|
|
297
|
+
const [indentInNode] = matchIndentInNode;
|
|
298
|
+
if (indentInNode.length >= indentToCode.length) {
|
|
299
|
+
return node.slice(indentToCode.length);
|
|
300
|
+
}
|
|
301
|
+
return node;
|
|
302
|
+
}).join("\n");
|
|
356
303
|
}
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
*/
|
|
361
|
-
class Tokenizer {
|
|
362
|
-
constructor(options) {
|
|
363
|
-
this.options = options || defaults;
|
|
304
|
+
var _Tokenizer = class {
|
|
305
|
+
constructor(options2) {
|
|
306
|
+
this.options = options2 || _defaults;
|
|
364
307
|
}
|
|
365
|
-
|
|
366
308
|
space(src) {
|
|
367
309
|
const cap = this.rules.block.newline.exec(src);
|
|
368
310
|
if (cap && cap[0].length > 0) {
|
|
369
311
|
return {
|
|
370
|
-
type:
|
|
312
|
+
type: "space",
|
|
371
313
|
raw: cap[0]
|
|
372
314
|
};
|
|
373
315
|
}
|
|
374
316
|
}
|
|
375
|
-
|
|
376
317
|
code(src) {
|
|
377
318
|
const cap = this.rules.block.code.exec(src);
|
|
378
319
|
if (cap) {
|
|
379
|
-
const text = cap[0].replace(/^ {1,4}/gm,
|
|
320
|
+
const text = cap[0].replace(/^ {1,4}/gm, "");
|
|
380
321
|
return {
|
|
381
|
-
type:
|
|
322
|
+
type: "code",
|
|
382
323
|
raw: cap[0],
|
|
383
|
-
codeBlockStyle:
|
|
384
|
-
text: !this.options.pedantic
|
|
385
|
-
? rtrim(text, '\n')
|
|
386
|
-
: text
|
|
324
|
+
codeBlockStyle: "indented",
|
|
325
|
+
text: !this.options.pedantic ? rtrim(text, "\n") : text
|
|
387
326
|
};
|
|
388
327
|
}
|
|
389
328
|
}
|
|
390
|
-
|
|
391
329
|
fences(src) {
|
|
392
330
|
const cap = this.rules.block.fences.exec(src);
|
|
393
331
|
if (cap) {
|
|
394
332
|
const raw = cap[0];
|
|
395
|
-
const text = indentCodeCompensation(raw, cap[3] ||
|
|
396
|
-
|
|
333
|
+
const text = indentCodeCompensation(raw, cap[3] || "");
|
|
397
334
|
return {
|
|
398
|
-
type:
|
|
335
|
+
type: "code",
|
|
399
336
|
raw,
|
|
400
|
-
lang: cap[2] ? cap[2].trim().replace(this.rules.inline._escapes,
|
|
337
|
+
lang: cap[2] ? cap[2].trim().replace(this.rules.inline._escapes, "$1") : cap[2],
|
|
401
338
|
text
|
|
402
339
|
};
|
|
403
340
|
}
|
|
404
341
|
}
|
|
405
|
-
|
|
406
342
|
heading(src) {
|
|
407
343
|
const cap = this.rules.block.heading.exec(src);
|
|
408
344
|
if (cap) {
|
|
409
345
|
let text = cap[2].trim();
|
|
410
|
-
|
|
411
|
-
// remove trailing #s
|
|
412
346
|
if (/#$/.test(text)) {
|
|
413
|
-
const trimmed = rtrim(text,
|
|
347
|
+
const trimmed = rtrim(text, "#");
|
|
414
348
|
if (this.options.pedantic) {
|
|
415
349
|
text = trimmed.trim();
|
|
416
350
|
} else if (!trimmed || / $/.test(trimmed)) {
|
|
417
|
-
// CommonMark requires space before trailing #s
|
|
418
351
|
text = trimmed.trim();
|
|
419
352
|
}
|
|
420
353
|
}
|
|
421
|
-
|
|
422
354
|
return {
|
|
423
|
-
type:
|
|
355
|
+
type: "heading",
|
|
424
356
|
raw: cap[0],
|
|
425
357
|
depth: cap[1].length,
|
|
426
358
|
text,
|
|
@@ -428,142 +360,107 @@ class Tokenizer {
|
|
|
428
360
|
};
|
|
429
361
|
}
|
|
430
362
|
}
|
|
431
|
-
|
|
432
363
|
hr(src) {
|
|
433
364
|
const cap = this.rules.block.hr.exec(src);
|
|
434
365
|
if (cap) {
|
|
435
366
|
return {
|
|
436
|
-
type:
|
|
367
|
+
type: "hr",
|
|
437
368
|
raw: cap[0]
|
|
438
369
|
};
|
|
439
370
|
}
|
|
440
371
|
}
|
|
441
|
-
|
|
442
372
|
blockquote(src) {
|
|
443
373
|
const cap = this.rules.block.blockquote.exec(src);
|
|
444
374
|
if (cap) {
|
|
445
|
-
const text = cap[0].replace(/^ *>[ \t]?/gm,
|
|
375
|
+
const text = cap[0].replace(/^ *>[ \t]?/gm, "");
|
|
446
376
|
const top = this.lexer.state.top;
|
|
447
377
|
this.lexer.state.top = true;
|
|
448
378
|
const tokens = this.lexer.blockTokens(text);
|
|
449
379
|
this.lexer.state.top = top;
|
|
450
380
|
return {
|
|
451
|
-
type:
|
|
381
|
+
type: "blockquote",
|
|
452
382
|
raw: cap[0],
|
|
453
383
|
tokens,
|
|
454
384
|
text
|
|
455
385
|
};
|
|
456
386
|
}
|
|
457
387
|
}
|
|
458
|
-
|
|
459
388
|
list(src) {
|
|
460
389
|
let cap = this.rules.block.list.exec(src);
|
|
461
390
|
if (cap) {
|
|
462
|
-
let raw, istask, ischecked, indent, i, blankLine, endsWithBlankLine,
|
|
463
|
-
line, nextLine, rawLine, itemContents, endEarly;
|
|
464
|
-
|
|
391
|
+
let raw, istask, ischecked, indent, i, blankLine, endsWithBlankLine, line, nextLine, rawLine, itemContents, endEarly;
|
|
465
392
|
let bull = cap[1].trim();
|
|
466
393
|
const isordered = bull.length > 1;
|
|
467
|
-
|
|
468
394
|
const list = {
|
|
469
|
-
type:
|
|
470
|
-
raw:
|
|
395
|
+
type: "list",
|
|
396
|
+
raw: "",
|
|
471
397
|
ordered: isordered,
|
|
472
|
-
start: isordered ? +bull.slice(0, -1) :
|
|
398
|
+
start: isordered ? +bull.slice(0, -1) : "",
|
|
473
399
|
loose: false,
|
|
474
400
|
items: []
|
|
475
401
|
};
|
|
476
|
-
|
|
477
402
|
bull = isordered ? `\\d{1,9}\\${bull.slice(-1)}` : `\\${bull}`;
|
|
478
|
-
|
|
479
403
|
if (this.options.pedantic) {
|
|
480
|
-
bull = isordered ? bull :
|
|
404
|
+
bull = isordered ? bull : "[*+-]";
|
|
481
405
|
}
|
|
482
|
-
|
|
483
|
-
// Get next list item
|
|
484
|
-
const itemRegex = new RegExp(`^( {0,3}${bull})((?:[\t ][^\\n]*)?(?:\\n|$))`);
|
|
485
|
-
|
|
486
|
-
// Check if current bullet point can start a new List Item
|
|
406
|
+
const itemRegex = new RegExp(`^( {0,3}${bull})((?:[ ][^\\n]*)?(?:\\n|$))`);
|
|
487
407
|
while (src) {
|
|
488
408
|
endEarly = false;
|
|
489
409
|
if (!(cap = itemRegex.exec(src))) {
|
|
490
410
|
break;
|
|
491
411
|
}
|
|
492
|
-
|
|
493
|
-
if (this.rules.block.hr.test(src)) { // End list if bullet was actually HR (possibly move into itemRegex?)
|
|
412
|
+
if (this.rules.block.hr.test(src)) {
|
|
494
413
|
break;
|
|
495
414
|
}
|
|
496
|
-
|
|
497
415
|
raw = cap[0];
|
|
498
416
|
src = src.substring(raw.length);
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
nextLine = src.split('\n', 1)[0];
|
|
502
|
-
|
|
417
|
+
line = cap[2].split("\n", 1)[0].replace(/^\t+/, (t) => " ".repeat(3 * t.length));
|
|
418
|
+
nextLine = src.split("\n", 1)[0];
|
|
503
419
|
if (this.options.pedantic) {
|
|
504
420
|
indent = 2;
|
|
505
421
|
itemContents = line.trimLeft();
|
|
506
422
|
} else {
|
|
507
|
-
indent = cap[2].search(/[^ ]/);
|
|
508
|
-
indent = indent > 4 ? 1 : indent;
|
|
423
|
+
indent = cap[2].search(/[^ ]/);
|
|
424
|
+
indent = indent > 4 ? 1 : indent;
|
|
509
425
|
itemContents = line.slice(indent);
|
|
510
426
|
indent += cap[1].length;
|
|
511
427
|
}
|
|
512
|
-
|
|
513
428
|
blankLine = false;
|
|
514
|
-
|
|
515
|
-
|
|
516
|
-
raw += nextLine + '\n';
|
|
429
|
+
if (!line && /^ *$/.test(nextLine)) {
|
|
430
|
+
raw += nextLine + "\n";
|
|
517
431
|
src = src.substring(nextLine.length + 1);
|
|
518
432
|
endEarly = true;
|
|
519
433
|
}
|
|
520
|
-
|
|
521
434
|
if (!endEarly) {
|
|
522
|
-
const nextBulletRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[
|
|
435
|
+
const nextBulletRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`);
|
|
523
436
|
const hrRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`);
|
|
524
437
|
const fencesBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`);
|
|
525
438
|
const headingBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`);
|
|
526
|
-
|
|
527
|
-
// Check if following lines should be included in List Item
|
|
528
439
|
while (src) {
|
|
529
|
-
rawLine = src.split(
|
|
440
|
+
rawLine = src.split("\n", 1)[0];
|
|
530
441
|
nextLine = rawLine;
|
|
531
|
-
|
|
532
|
-
// Re-align to follow commonmark nesting rules
|
|
533
442
|
if (this.options.pedantic) {
|
|
534
|
-
nextLine = nextLine.replace(/^ {1,4}(?=( {4})*[^ ])/g,
|
|
443
|
+
nextLine = nextLine.replace(/^ {1,4}(?=( {4})*[^ ])/g, " ");
|
|
535
444
|
}
|
|
536
|
-
|
|
537
|
-
// End list item if found code fences
|
|
538
445
|
if (fencesBeginRegex.test(nextLine)) {
|
|
539
446
|
break;
|
|
540
447
|
}
|
|
541
|
-
|
|
542
|
-
// End list item if found start of new heading
|
|
543
448
|
if (headingBeginRegex.test(nextLine)) {
|
|
544
449
|
break;
|
|
545
450
|
}
|
|
546
|
-
|
|
547
|
-
// End list item if found start of new bullet
|
|
548
451
|
if (nextBulletRegex.test(nextLine)) {
|
|
549
452
|
break;
|
|
550
453
|
}
|
|
551
|
-
|
|
552
|
-
// Horizontal rule found
|
|
553
454
|
if (hrRegex.test(src)) {
|
|
554
455
|
break;
|
|
555
456
|
}
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
itemContents += '\n' + nextLine.slice(indent);
|
|
457
|
+
if (nextLine.search(/[^ ]/) >= indent || !nextLine.trim()) {
|
|
458
|
+
itemContents += "\n" + nextLine.slice(indent);
|
|
559
459
|
} else {
|
|
560
|
-
// not enough indentation
|
|
561
460
|
if (blankLine) {
|
|
562
461
|
break;
|
|
563
462
|
}
|
|
564
|
-
|
|
565
|
-
// paragraph continuation unless last line was a different block level element
|
|
566
|
-
if (line.search(/[^ ]/) >= 4) { // indented code block
|
|
463
|
+
if (line.search(/[^ ]/) >= 4) {
|
|
567
464
|
break;
|
|
568
465
|
}
|
|
569
466
|
if (fencesBeginRegex.test(line)) {
|
|
@@ -575,110 +472,89 @@ class Tokenizer {
|
|
|
575
472
|
if (hrRegex.test(line)) {
|
|
576
473
|
break;
|
|
577
474
|
}
|
|
578
|
-
|
|
579
|
-
itemContents += '\n' + nextLine;
|
|
475
|
+
itemContents += "\n" + nextLine;
|
|
580
476
|
}
|
|
581
|
-
|
|
582
|
-
if (!blankLine && !nextLine.trim()) { // Check if current line is blank
|
|
477
|
+
if (!blankLine && !nextLine.trim()) {
|
|
583
478
|
blankLine = true;
|
|
584
479
|
}
|
|
585
|
-
|
|
586
|
-
raw += rawLine + '\n';
|
|
480
|
+
raw += rawLine + "\n";
|
|
587
481
|
src = src.substring(rawLine.length + 1);
|
|
588
482
|
line = nextLine.slice(indent);
|
|
589
483
|
}
|
|
590
484
|
}
|
|
591
|
-
|
|
592
485
|
if (!list.loose) {
|
|
593
|
-
// If the previous item ended with a blank line, the list is loose
|
|
594
486
|
if (endsWithBlankLine) {
|
|
595
487
|
list.loose = true;
|
|
596
488
|
} else if (/\n *\n *$/.test(raw)) {
|
|
597
489
|
endsWithBlankLine = true;
|
|
598
490
|
}
|
|
599
491
|
}
|
|
600
|
-
|
|
601
|
-
// Check for task list items
|
|
602
492
|
if (this.options.gfm) {
|
|
603
493
|
istask = /^\[[ xX]\] /.exec(itemContents);
|
|
604
494
|
if (istask) {
|
|
605
|
-
ischecked = istask[0] !==
|
|
606
|
-
itemContents = itemContents.replace(/^\[[ xX]\] +/,
|
|
495
|
+
ischecked = istask[0] !== "[ ] ";
|
|
496
|
+
itemContents = itemContents.replace(/^\[[ xX]\] +/, "");
|
|
607
497
|
}
|
|
608
498
|
}
|
|
609
|
-
|
|
610
499
|
list.items.push({
|
|
611
|
-
type:
|
|
500
|
+
type: "list_item",
|
|
612
501
|
raw,
|
|
613
502
|
task: !!istask,
|
|
614
503
|
checked: ischecked,
|
|
615
504
|
loose: false,
|
|
616
505
|
text: itemContents
|
|
617
506
|
});
|
|
618
|
-
|
|
619
507
|
list.raw += raw;
|
|
620
508
|
}
|
|
621
|
-
|
|
622
|
-
// Do not consume newlines at end of final item. Alternatively, make itemRegex *start* with any newlines to simplify/speed up endsWithBlankLine logic
|
|
623
509
|
list.items[list.items.length - 1].raw = raw.trimRight();
|
|
624
510
|
list.items[list.items.length - 1].text = itemContents.trimRight();
|
|
625
511
|
list.raw = list.raw.trimRight();
|
|
626
|
-
|
|
627
512
|
const l = list.items.length;
|
|
628
|
-
|
|
629
|
-
// Item child tokens handled here at end because we needed to have the final item to trim it first
|
|
630
513
|
for (i = 0; i < l; i++) {
|
|
631
514
|
this.lexer.state.top = false;
|
|
632
515
|
list.items[i].tokens = this.lexer.blockTokens(list.items[i].text, []);
|
|
633
|
-
|
|
634
516
|
if (!list.loose) {
|
|
635
|
-
|
|
636
|
-
const
|
|
637
|
-
const hasMultipleLineBreaks = spacers.length > 0 && spacers.some(t => /\n.*\n/.test(t.raw));
|
|
638
|
-
|
|
517
|
+
const spacers = list.items[i].tokens.filter((t) => t.type === "space");
|
|
518
|
+
const hasMultipleLineBreaks = spacers.length > 0 && spacers.some((t) => /\n.*\n/.test(t.raw));
|
|
639
519
|
list.loose = hasMultipleLineBreaks;
|
|
640
520
|
}
|
|
641
521
|
}
|
|
642
|
-
|
|
643
|
-
// Set all items to loose if list is loose
|
|
644
522
|
if (list.loose) {
|
|
645
523
|
for (i = 0; i < l; i++) {
|
|
646
524
|
list.items[i].loose = true;
|
|
647
525
|
}
|
|
648
526
|
}
|
|
649
|
-
|
|
650
527
|
return list;
|
|
651
528
|
}
|
|
652
529
|
}
|
|
653
|
-
|
|
654
530
|
html(src) {
|
|
655
531
|
const cap = this.rules.block.html.exec(src);
|
|
656
532
|
if (cap) {
|
|
657
533
|
const token = {
|
|
658
|
-
type:
|
|
534
|
+
type: "html",
|
|
535
|
+
block: true,
|
|
659
536
|
raw: cap[0],
|
|
660
|
-
pre: !this.options.sanitizer
|
|
661
|
-
&& (cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style'),
|
|
537
|
+
pre: !this.options.sanitizer && (cap[1] === "pre" || cap[1] === "script" || cap[1] === "style"),
|
|
662
538
|
text: cap[0]
|
|
663
539
|
};
|
|
664
540
|
if (this.options.sanitize) {
|
|
665
541
|
const text = this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]);
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
|
|
542
|
+
const paragraph = token;
|
|
543
|
+
paragraph.type = "paragraph";
|
|
544
|
+
paragraph.text = text;
|
|
545
|
+
paragraph.tokens = this.lexer.inline(text);
|
|
669
546
|
}
|
|
670
547
|
return token;
|
|
671
548
|
}
|
|
672
549
|
}
|
|
673
|
-
|
|
674
550
|
def(src) {
|
|
675
551
|
const cap = this.rules.block.def.exec(src);
|
|
676
552
|
if (cap) {
|
|
677
|
-
const tag = cap[1].toLowerCase().replace(/\s+/g,
|
|
678
|
-
const href = cap[2] ? cap[2].replace(/^<(.*)>$/,
|
|
679
|
-
const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline._escapes,
|
|
553
|
+
const tag = cap[1].toLowerCase().replace(/\s+/g, " ");
|
|
554
|
+
const href = cap[2] ? cap[2].replace(/^<(.*)>$/, "$1").replace(this.rules.inline._escapes, "$1") : "";
|
|
555
|
+
const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline._escapes, "$1") : cap[3];
|
|
680
556
|
return {
|
|
681
|
-
type:
|
|
557
|
+
type: "def",
|
|
682
558
|
tag,
|
|
683
559
|
raw: cap[0],
|
|
684
560
|
href,
|
|
@@ -686,48 +562,44 @@ class Tokenizer {
|
|
|
686
562
|
};
|
|
687
563
|
}
|
|
688
564
|
}
|
|
689
|
-
|
|
690
565
|
table(src) {
|
|
691
566
|
const cap = this.rules.block.table.exec(src);
|
|
692
567
|
if (cap) {
|
|
693
568
|
const item = {
|
|
694
|
-
type:
|
|
695
|
-
|
|
696
|
-
|
|
697
|
-
|
|
569
|
+
type: "table",
|
|
570
|
+
// splitCells expects a number as second argument
|
|
571
|
+
// @ts-expect-error
|
|
572
|
+
header: splitCells(cap[1]).map((c) => {
|
|
573
|
+
return { text: c };
|
|
574
|
+
}),
|
|
575
|
+
align: cap[2].replace(/^ *|\| *$/g, "").split(/ *\| */),
|
|
576
|
+
rows: cap[3] && cap[3].trim() ? cap[3].replace(/\n[ \t]*$/, "").split("\n") : []
|
|
698
577
|
};
|
|
699
|
-
|
|
700
578
|
if (item.header.length === item.align.length) {
|
|
701
579
|
item.raw = cap[0];
|
|
702
|
-
|
|
703
580
|
let l = item.align.length;
|
|
704
581
|
let i, j, k, row;
|
|
705
582
|
for (i = 0; i < l; i++) {
|
|
706
583
|
if (/^ *-+: *$/.test(item.align[i])) {
|
|
707
|
-
item.align[i] =
|
|
584
|
+
item.align[i] = "right";
|
|
708
585
|
} else if (/^ *:-+: *$/.test(item.align[i])) {
|
|
709
|
-
item.align[i] =
|
|
586
|
+
item.align[i] = "center";
|
|
710
587
|
} else if (/^ *:-+ *$/.test(item.align[i])) {
|
|
711
|
-
item.align[i] =
|
|
588
|
+
item.align[i] = "left";
|
|
712
589
|
} else {
|
|
713
590
|
item.align[i] = null;
|
|
714
591
|
}
|
|
715
592
|
}
|
|
716
|
-
|
|
717
593
|
l = item.rows.length;
|
|
718
594
|
for (i = 0; i < l; i++) {
|
|
719
|
-
item.rows[i] = splitCells(item.rows[i], item.header.length).map(c => {
|
|
595
|
+
item.rows[i] = splitCells(item.rows[i], item.header.length).map((c) => {
|
|
596
|
+
return { text: c };
|
|
597
|
+
});
|
|
720
598
|
}
|
|
721
|
-
|
|
722
|
-
// parse child tokens inside headers and cells
|
|
723
|
-
|
|
724
|
-
// header child tokens
|
|
725
599
|
l = item.header.length;
|
|
726
600
|
for (j = 0; j < l; j++) {
|
|
727
601
|
item.header[j].tokens = this.lexer.inline(item.header[j].text);
|
|
728
602
|
}
|
|
729
|
-
|
|
730
|
-
// cell child tokens
|
|
731
603
|
l = item.rows.length;
|
|
732
604
|
for (j = 0; j < l; j++) {
|
|
733
605
|
row = item.rows[j];
|
|
@@ -735,63 +607,55 @@ class Tokenizer {
|
|
|
735
607
|
row[k].tokens = this.lexer.inline(row[k].text);
|
|
736
608
|
}
|
|
737
609
|
}
|
|
738
|
-
|
|
739
610
|
return item;
|
|
740
611
|
}
|
|
741
612
|
}
|
|
742
613
|
}
|
|
743
|
-
|
|
744
614
|
lheading(src) {
|
|
745
615
|
const cap = this.rules.block.lheading.exec(src);
|
|
746
616
|
if (cap) {
|
|
747
617
|
return {
|
|
748
|
-
type:
|
|
618
|
+
type: "heading",
|
|
749
619
|
raw: cap[0],
|
|
750
|
-
depth: cap[2].charAt(0) ===
|
|
620
|
+
depth: cap[2].charAt(0) === "=" ? 1 : 2,
|
|
751
621
|
text: cap[1],
|
|
752
622
|
tokens: this.lexer.inline(cap[1])
|
|
753
623
|
};
|
|
754
624
|
}
|
|
755
625
|
}
|
|
756
|
-
|
|
757
626
|
paragraph(src) {
|
|
758
627
|
const cap = this.rules.block.paragraph.exec(src);
|
|
759
628
|
if (cap) {
|
|
760
|
-
const text = cap[1].charAt(cap[1].length - 1) ===
|
|
761
|
-
? cap[1].slice(0, -1)
|
|
762
|
-
: cap[1];
|
|
629
|
+
const text = cap[1].charAt(cap[1].length - 1) === "\n" ? cap[1].slice(0, -1) : cap[1];
|
|
763
630
|
return {
|
|
764
|
-
type:
|
|
631
|
+
type: "paragraph",
|
|
765
632
|
raw: cap[0],
|
|
766
633
|
text,
|
|
767
634
|
tokens: this.lexer.inline(text)
|
|
768
635
|
};
|
|
769
636
|
}
|
|
770
637
|
}
|
|
771
|
-
|
|
772
638
|
text(src) {
|
|
773
639
|
const cap = this.rules.block.text.exec(src);
|
|
774
640
|
if (cap) {
|
|
775
641
|
return {
|
|
776
|
-
type:
|
|
642
|
+
type: "text",
|
|
777
643
|
raw: cap[0],
|
|
778
644
|
text: cap[0],
|
|
779
645
|
tokens: this.lexer.inline(cap[0])
|
|
780
646
|
};
|
|
781
647
|
}
|
|
782
648
|
}
|
|
783
|
-
|
|
784
649
|
escape(src) {
|
|
785
650
|
const cap = this.rules.inline.escape.exec(src);
|
|
786
651
|
if (cap) {
|
|
787
652
|
return {
|
|
788
|
-
type:
|
|
653
|
+
type: "escape",
|
|
789
654
|
raw: cap[0],
|
|
790
655
|
text: escape(cap[1])
|
|
791
656
|
};
|
|
792
657
|
}
|
|
793
658
|
}
|
|
794
|
-
|
|
795
659
|
tag(src) {
|
|
796
660
|
const cap = this.rules.inline.tag.exec(src);
|
|
797
661
|
if (cap) {
|
|
@@ -805,89 +669,72 @@ class Tokenizer {
|
|
|
805
669
|
} else if (this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
|
|
806
670
|
this.lexer.state.inRawBlock = false;
|
|
807
671
|
}
|
|
808
|
-
|
|
809
672
|
return {
|
|
810
|
-
type: this.options.sanitize
|
|
811
|
-
? 'text'
|
|
812
|
-
: 'html',
|
|
673
|
+
type: this.options.sanitize ? "text" : "html",
|
|
813
674
|
raw: cap[0],
|
|
814
675
|
inLink: this.lexer.state.inLink,
|
|
815
676
|
inRawBlock: this.lexer.state.inRawBlock,
|
|
816
|
-
|
|
817
|
-
|
|
818
|
-
? this.options.sanitizer(cap[0])
|
|
819
|
-
: escape(cap[0]))
|
|
820
|
-
: cap[0]
|
|
677
|
+
block: false,
|
|
678
|
+
text: this.options.sanitize ? this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]) : cap[0]
|
|
821
679
|
};
|
|
822
680
|
}
|
|
823
681
|
}
|
|
824
|
-
|
|
825
682
|
link(src) {
|
|
826
683
|
const cap = this.rules.inline.link.exec(src);
|
|
827
684
|
if (cap) {
|
|
828
685
|
const trimmedUrl = cap[2].trim();
|
|
829
686
|
if (!this.options.pedantic && /^</.test(trimmedUrl)) {
|
|
830
|
-
|
|
831
|
-
if (!(/>$/.test(trimmedUrl))) {
|
|
687
|
+
if (!/>$/.test(trimmedUrl)) {
|
|
832
688
|
return;
|
|
833
689
|
}
|
|
834
|
-
|
|
835
|
-
// ending angle bracket cannot be escaped
|
|
836
|
-
const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), '\\');
|
|
690
|
+
const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), "\\");
|
|
837
691
|
if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {
|
|
838
692
|
return;
|
|
839
693
|
}
|
|
840
694
|
} else {
|
|
841
|
-
|
|
842
|
-
const lastParenIndex = findClosingBracket(cap[2], '()');
|
|
695
|
+
const lastParenIndex = findClosingBracket(cap[2], "()");
|
|
843
696
|
if (lastParenIndex > -1) {
|
|
844
|
-
const start = cap[0].indexOf(
|
|
697
|
+
const start = cap[0].indexOf("!") === 0 ? 5 : 4;
|
|
845
698
|
const linkLen = start + cap[1].length + lastParenIndex;
|
|
846
699
|
cap[2] = cap[2].substring(0, lastParenIndex);
|
|
847
700
|
cap[0] = cap[0].substring(0, linkLen).trim();
|
|
848
|
-
cap[3] =
|
|
701
|
+
cap[3] = "";
|
|
849
702
|
}
|
|
850
703
|
}
|
|
851
704
|
let href = cap[2];
|
|
852
|
-
let title =
|
|
705
|
+
let title = "";
|
|
853
706
|
if (this.options.pedantic) {
|
|
854
|
-
// split pedantic href and title
|
|
855
707
|
const link = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);
|
|
856
|
-
|
|
857
708
|
if (link) {
|
|
858
709
|
href = link[1];
|
|
859
710
|
title = link[3];
|
|
860
711
|
}
|
|
861
712
|
} else {
|
|
862
|
-
title = cap[3] ? cap[3].slice(1, -1) :
|
|
713
|
+
title = cap[3] ? cap[3].slice(1, -1) : "";
|
|
863
714
|
}
|
|
864
|
-
|
|
865
715
|
href = href.trim();
|
|
866
716
|
if (/^</.test(href)) {
|
|
867
|
-
if (this.options.pedantic &&
|
|
868
|
-
// pedantic allows starting angle bracket without ending angle bracket
|
|
717
|
+
if (this.options.pedantic && !/>$/.test(trimmedUrl)) {
|
|
869
718
|
href = href.slice(1);
|
|
870
719
|
} else {
|
|
871
720
|
href = href.slice(1, -1);
|
|
872
721
|
}
|
|
873
722
|
}
|
|
874
723
|
return outputLink(cap, {
|
|
875
|
-
href: href ? href.replace(this.rules.inline._escapes,
|
|
876
|
-
title: title ? title.replace(this.rules.inline._escapes,
|
|
724
|
+
href: href ? href.replace(this.rules.inline._escapes, "$1") : href,
|
|
725
|
+
title: title ? title.replace(this.rules.inline._escapes, "$1") : title
|
|
877
726
|
}, cap[0], this.lexer);
|
|
878
727
|
}
|
|
879
728
|
}
|
|
880
|
-
|
|
881
729
|
reflink(src, links) {
|
|
882
730
|
let cap;
|
|
883
|
-
if ((cap = this.rules.inline.reflink.exec(src))
|
|
884
|
-
|
|
885
|
-
let link = (cap[2] || cap[1]).replace(/\s+/g, ' ');
|
|
731
|
+
if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) {
|
|
732
|
+
let link = (cap[2] || cap[1]).replace(/\s+/g, " ");
|
|
886
733
|
link = links[link.toLowerCase()];
|
|
887
734
|
if (!link) {
|
|
888
735
|
const text = cap[0].charAt(0);
|
|
889
736
|
return {
|
|
890
|
-
type:
|
|
737
|
+
type: "text",
|
|
891
738
|
raw: text,
|
|
892
739
|
text
|
|
893
740
|
};
|
|
@@ -895,67 +742,50 @@ class Tokenizer {
|
|
|
895
742
|
return outputLink(cap, link, cap[0], this.lexer);
|
|
896
743
|
}
|
|
897
744
|
}
|
|
898
|
-
|
|
899
|
-
emStrong(src, maskedSrc, prevChar = '') {
|
|
745
|
+
emStrong(src, maskedSrc, prevChar = "") {
|
|
900
746
|
let match = this.rules.inline.emStrong.lDelim.exec(src);
|
|
901
|
-
if (!match)
|
|
902
|
-
|
|
903
|
-
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
if (!nextChar || (nextChar && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar)))) {
|
|
747
|
+
if (!match)
|
|
748
|
+
return;
|
|
749
|
+
if (match[3] && prevChar.match(/[\p{L}\p{N}]/u))
|
|
750
|
+
return;
|
|
751
|
+
const nextChar = match[1] || match[2] || "";
|
|
752
|
+
if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {
|
|
909
753
|
const lLength = match[0].length - 1;
|
|
910
754
|
let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
|
|
911
|
-
|
|
912
|
-
const endReg = match[0][0] === '*' ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd;
|
|
755
|
+
const endReg = match[0][0] === "*" ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd;
|
|
913
756
|
endReg.lastIndex = 0;
|
|
914
|
-
|
|
915
|
-
// Clip maskedSrc to same section of string as src (move to lexer?)
|
|
916
757
|
maskedSrc = maskedSrc.slice(-1 * src.length + lLength);
|
|
917
|
-
|
|
918
758
|
while ((match = endReg.exec(maskedSrc)) != null) {
|
|
919
759
|
rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
|
|
920
|
-
|
|
921
|
-
|
|
922
|
-
|
|
760
|
+
if (!rDelim)
|
|
761
|
+
continue;
|
|
923
762
|
rLength = rDelim.length;
|
|
924
|
-
|
|
925
|
-
if (match[3] || match[4]) { // found another Left Delim
|
|
763
|
+
if (match[3] || match[4]) {
|
|
926
764
|
delimTotal += rLength;
|
|
927
765
|
continue;
|
|
928
|
-
} else if (match[5] || match[6]) {
|
|
766
|
+
} else if (match[5] || match[6]) {
|
|
929
767
|
if (lLength % 3 && !((lLength + rLength) % 3)) {
|
|
930
768
|
midDelimTotal += rLength;
|
|
931
|
-
continue;
|
|
769
|
+
continue;
|
|
932
770
|
}
|
|
933
771
|
}
|
|
934
|
-
|
|
935
772
|
delimTotal -= rLength;
|
|
936
|
-
|
|
937
|
-
|
|
938
|
-
|
|
939
|
-
// Remove extra characters. *a*** -> *a*
|
|
773
|
+
if (delimTotal > 0)
|
|
774
|
+
continue;
|
|
940
775
|
rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
|
|
941
|
-
|
|
942
|
-
const raw = src.slice(0, lLength + match.index + (match[0].length - rDelim.length) + rLength);
|
|
943
|
-
|
|
944
|
-
// Create `em` if smallest delimiter has odd char count. *a***
|
|
776
|
+
const raw = src.slice(0, lLength + match.index + rLength + 1);
|
|
945
777
|
if (Math.min(lLength, rLength) % 2) {
|
|
946
|
-
const
|
|
778
|
+
const text2 = raw.slice(1, -1);
|
|
947
779
|
return {
|
|
948
|
-
type:
|
|
780
|
+
type: "em",
|
|
949
781
|
raw,
|
|
950
|
-
text,
|
|
951
|
-
tokens: this.lexer.inlineTokens(
|
|
782
|
+
text: text2,
|
|
783
|
+
tokens: this.lexer.inlineTokens(text2)
|
|
952
784
|
};
|
|
953
785
|
}
|
|
954
|
-
|
|
955
|
-
// Create 'strong' if smallest delimiter has even char count. **a***
|
|
956
786
|
const text = raw.slice(2, -2);
|
|
957
787
|
return {
|
|
958
|
-
type:
|
|
788
|
+
type: "strong",
|
|
959
789
|
raw,
|
|
960
790
|
text,
|
|
961
791
|
tokens: this.lexer.inlineTokens(text)
|
|
@@ -963,11 +793,10 @@ class Tokenizer {
|
|
|
963
793
|
}
|
|
964
794
|
}
|
|
965
795
|
}
|
|
966
|
-
|
|
967
796
|
codespan(src) {
|
|
968
797
|
const cap = this.rules.inline.code.exec(src);
|
|
969
798
|
if (cap) {
|
|
970
|
-
let text = cap[2].replace(/\n/g,
|
|
799
|
+
let text = cap[2].replace(/\n/g, " ");
|
|
971
800
|
const hasNonSpaceChars = /[^ ]/.test(text);
|
|
972
801
|
const hasSpaceCharsOnBothEnds = /^ /.test(text) && / $/.test(text);
|
|
973
802
|
if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
|
|
@@ -975,55 +804,51 @@ class Tokenizer {
|
|
|
975
804
|
}
|
|
976
805
|
text = escape(text, true);
|
|
977
806
|
return {
|
|
978
|
-
type:
|
|
807
|
+
type: "codespan",
|
|
979
808
|
raw: cap[0],
|
|
980
809
|
text
|
|
981
810
|
};
|
|
982
811
|
}
|
|
983
812
|
}
|
|
984
|
-
|
|
985
813
|
br(src) {
|
|
986
814
|
const cap = this.rules.inline.br.exec(src);
|
|
987
815
|
if (cap) {
|
|
988
816
|
return {
|
|
989
|
-
type:
|
|
817
|
+
type: "br",
|
|
990
818
|
raw: cap[0]
|
|
991
819
|
};
|
|
992
820
|
}
|
|
993
821
|
}
|
|
994
|
-
|
|
995
822
|
del(src) {
|
|
996
823
|
const cap = this.rules.inline.del.exec(src);
|
|
997
824
|
if (cap) {
|
|
998
825
|
return {
|
|
999
|
-
type:
|
|
826
|
+
type: "del",
|
|
1000
827
|
raw: cap[0],
|
|
1001
828
|
text: cap[2],
|
|
1002
829
|
tokens: this.lexer.inlineTokens(cap[2])
|
|
1003
830
|
};
|
|
1004
831
|
}
|
|
1005
832
|
}
|
|
1006
|
-
|
|
1007
|
-
autolink(src, mangle) {
|
|
833
|
+
autolink(src, mangle2) {
|
|
1008
834
|
const cap = this.rules.inline.autolink.exec(src);
|
|
1009
835
|
if (cap) {
|
|
1010
836
|
let text, href;
|
|
1011
|
-
if (cap[2] ===
|
|
1012
|
-
text = escape(this.options.mangle ?
|
|
1013
|
-
href =
|
|
837
|
+
if (cap[2] === "@") {
|
|
838
|
+
text = escape(this.options.mangle ? mangle2(cap[1]) : cap[1]);
|
|
839
|
+
href = "mailto:" + text;
|
|
1014
840
|
} else {
|
|
1015
841
|
text = escape(cap[1]);
|
|
1016
842
|
href = text;
|
|
1017
843
|
}
|
|
1018
|
-
|
|
1019
844
|
return {
|
|
1020
|
-
type:
|
|
845
|
+
type: "link",
|
|
1021
846
|
raw: cap[0],
|
|
1022
847
|
text,
|
|
1023
848
|
href,
|
|
1024
849
|
tokens: [
|
|
1025
850
|
{
|
|
1026
|
-
type:
|
|
851
|
+
type: "text",
|
|
1027
852
|
raw: text,
|
|
1028
853
|
text
|
|
1029
854
|
}
|
|
@@ -1031,36 +856,34 @@ class Tokenizer {
|
|
|
1031
856
|
};
|
|
1032
857
|
}
|
|
1033
858
|
}
|
|
1034
|
-
|
|
1035
|
-
url(src, mangle) {
|
|
859
|
+
url(src, mangle2) {
|
|
1036
860
|
let cap;
|
|
1037
861
|
if (cap = this.rules.inline.url.exec(src)) {
|
|
1038
862
|
let text, href;
|
|
1039
|
-
if (cap[2] ===
|
|
1040
|
-
text = escape(this.options.mangle ?
|
|
1041
|
-
href =
|
|
863
|
+
if (cap[2] === "@") {
|
|
864
|
+
text = escape(this.options.mangle ? mangle2(cap[0]) : cap[0]);
|
|
865
|
+
href = "mailto:" + text;
|
|
1042
866
|
} else {
|
|
1043
|
-
// do extended autolink path validation
|
|
1044
867
|
let prevCapZero;
|
|
1045
868
|
do {
|
|
1046
869
|
prevCapZero = cap[0];
|
|
1047
870
|
cap[0] = this.rules.inline._backpedal.exec(cap[0])[0];
|
|
1048
871
|
} while (prevCapZero !== cap[0]);
|
|
1049
872
|
text = escape(cap[0]);
|
|
1050
|
-
if (cap[1] ===
|
|
1051
|
-
href =
|
|
873
|
+
if (cap[1] === "www.") {
|
|
874
|
+
href = "http://" + cap[0];
|
|
1052
875
|
} else {
|
|
1053
876
|
href = cap[0];
|
|
1054
877
|
}
|
|
1055
878
|
}
|
|
1056
879
|
return {
|
|
1057
|
-
type:
|
|
880
|
+
type: "link",
|
|
1058
881
|
raw: cap[0],
|
|
1059
882
|
text,
|
|
1060
883
|
href,
|
|
1061
884
|
tokens: [
|
|
1062
885
|
{
|
|
1063
|
-
type:
|
|
886
|
+
type: "text",
|
|
1064
887
|
raw: text,
|
|
1065
888
|
text
|
|
1066
889
|
}
|
|
@@ -1068,29 +891,26 @@ class Tokenizer {
|
|
|
1068
891
|
};
|
|
1069
892
|
}
|
|
1070
893
|
}
|
|
1071
|
-
|
|
1072
|
-
inlineText(src, smartypants) {
|
|
894
|
+
inlineText(src, smartypants2) {
|
|
1073
895
|
const cap = this.rules.inline.text.exec(src);
|
|
1074
896
|
if (cap) {
|
|
1075
897
|
let text;
|
|
1076
898
|
if (this.lexer.state.inRawBlock) {
|
|
1077
|
-
text = this.options.sanitize ?
|
|
899
|
+
text = this.options.sanitize ? this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]) : cap[0];
|
|
1078
900
|
} else {
|
|
1079
|
-
text = escape(this.options.smartypants ?
|
|
901
|
+
text = escape(this.options.smartypants ? smartypants2(cap[0]) : cap[0]);
|
|
1080
902
|
}
|
|
1081
903
|
return {
|
|
1082
|
-
type:
|
|
904
|
+
type: "text",
|
|
1083
905
|
raw: cap[0],
|
|
1084
906
|
text
|
|
1085
907
|
};
|
|
1086
908
|
}
|
|
1087
909
|
}
|
|
1088
|
-
}
|
|
910
|
+
};
|
|
1089
911
|
|
|
1090
|
-
|
|
1091
|
-
|
|
1092
|
-
*/
|
|
1093
|
-
const block = {
|
|
912
|
+
// src/rules.ts
|
|
913
|
+
var block = {
|
|
1094
914
|
newline: /^(?: *(?:\n|$))+/,
|
|
1095
915
|
code: /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,
|
|
1096
916
|
fences: /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/,
|
|
@@ -1098,248 +918,95 @@ const block = {
|
|
|
1098
918
|
heading: /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,
|
|
1099
919
|
blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,
|
|
1100
920
|
list: /^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/,
|
|
1101
|
-
html:
|
|
1102
|
-
+ '<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
|
|
1103
|
-
+ '|comment[^\\n]*(\\n+|$)' // (2)
|
|
1104
|
-
+ '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
|
|
1105
|
-
+ '|<![A-Z][\\s\\S]*?(?:>\\n*|$)' // (4)
|
|
1106
|
-
+ '|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)' // (5)
|
|
1107
|
-
+ '|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (6)
|
|
1108
|
-
+ '|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) open tag
|
|
1109
|
-
+ '|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) closing tag
|
|
1110
|
-
+ ')',
|
|
921
|
+
html: "^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n *)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$))",
|
|
1111
922
|
def: /^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/,
|
|
1112
923
|
table: noopTest,
|
|
1113
|
-
lheading: /^((
|
|
924
|
+
lheading: /^((?:(?!^bull ).|\n(?!\n|bull ))+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
|
|
1114
925
|
// regex template, placeholders will be replaced according to different paragraph
|
|
1115
926
|
// interruption rules of commonmark and the original markdown spec:
|
|
1116
927
|
_paragraph: /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,
|
|
1117
928
|
text: /^[^\n]+/
|
|
1118
929
|
};
|
|
1119
|
-
|
|
1120
930
|
block._label = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
|
|
1121
931
|
block._title = /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/;
|
|
1122
|
-
block.def = edit(block.def)
|
|
1123
|
-
.replace('label', block._label)
|
|
1124
|
-
.replace('title', block._title)
|
|
1125
|
-
.getRegex();
|
|
1126
|
-
|
|
932
|
+
block.def = edit(block.def).replace("label", block._label).replace("title", block._title).getRegex();
|
|
1127
933
|
block.bullet = /(?:[*+-]|\d{1,9}[.)])/;
|
|
1128
|
-
block.listItemStart = edit(/^( *)(bull) */)
|
|
1129
|
-
|
|
1130
|
-
|
|
1131
|
-
|
|
1132
|
-
block.list = edit(block.list)
|
|
1133
|
-
.replace(/bull/g, block.bullet)
|
|
1134
|
-
.replace('hr', '\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))')
|
|
1135
|
-
.replace('def', '\\n+(?=' + block.def.source + ')')
|
|
1136
|
-
.getRegex();
|
|
1137
|
-
|
|
1138
|
-
block._tag = 'address|article|aside|base|basefont|blockquote|body|caption'
|
|
1139
|
-
+ '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption'
|
|
1140
|
-
+ '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe'
|
|
1141
|
-
+ '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option'
|
|
1142
|
-
+ '|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr'
|
|
1143
|
-
+ '|track|ul';
|
|
934
|
+
block.listItemStart = edit(/^( *)(bull) */).replace("bull", block.bullet).getRegex();
|
|
935
|
+
block.list = edit(block.list).replace(/bull/g, block.bullet).replace("hr", "\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))").replace("def", "\\n+(?=" + block.def.source + ")").getRegex();
|
|
936
|
+
block._tag = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
|
|
1144
937
|
block._comment = /<!--(?!-?>)[\s\S]*?(?:-->|$)/;
|
|
1145
|
-
block.html = edit(block.html,
|
|
1146
|
-
|
|
1147
|
-
|
|
1148
|
-
|
|
1149
|
-
.getRegex();
|
|
1150
|
-
|
|
1151
|
-
block.paragraph = edit(block._paragraph)
|
|
1152
|
-
.replace('hr', block.hr)
|
|
1153
|
-
.replace('heading', ' {0,3}#{1,6} ')
|
|
1154
|
-
.replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
|
|
1155
|
-
.replace('|table', '')
|
|
1156
|
-
.replace('blockquote', ' {0,3}>')
|
|
1157
|
-
.replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
|
|
1158
|
-
.replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
|
|
1159
|
-
.replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)')
|
|
1160
|
-
.replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
|
|
1161
|
-
.getRegex();
|
|
1162
|
-
|
|
1163
|
-
block.blockquote = edit(block.blockquote)
|
|
1164
|
-
.replace('paragraph', block.paragraph)
|
|
1165
|
-
.getRegex();
|
|
1166
|
-
|
|
1167
|
-
/**
|
|
1168
|
-
* Normal Block Grammar
|
|
1169
|
-
*/
|
|
1170
|
-
|
|
938
|
+
block.html = edit(block.html, "i").replace("comment", block._comment).replace("tag", block._tag).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
|
|
939
|
+
block.lheading = edit(block.lheading).replace(/bull/g, block.bullet).getRegex();
|
|
940
|
+
block.paragraph = edit(block._paragraph).replace("hr", block.hr).replace("heading", " {0,3}#{1,6} ").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", block._tag).getRegex();
|
|
941
|
+
block.blockquote = edit(block.blockquote).replace("paragraph", block.paragraph).getRegex();
|
|
1171
942
|
block.normal = { ...block };
|
|
1172
|
-
|
|
1173
|
-
/**
|
|
1174
|
-
* GFM Block Grammar
|
|
1175
|
-
*/
|
|
1176
|
-
|
|
1177
943
|
block.gfm = {
|
|
1178
944
|
...block.normal,
|
|
1179
|
-
table:
|
|
1180
|
-
|
|
1181
|
-
+ '(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)' // Cells
|
|
945
|
+
table: "^ *([^\\n ].*\\|.*)\\n {0,3}(?:\\| *)?(:?-+:? *(?:\\| *:?-+:? *)*)(?:\\| *)?(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)"
|
|
946
|
+
// Cells
|
|
1182
947
|
};
|
|
1183
|
-
|
|
1184
|
-
block.gfm.
|
|
1185
|
-
.replace('hr', block.hr)
|
|
1186
|
-
.replace('heading', ' {0,3}#{1,6} ')
|
|
1187
|
-
.replace('blockquote', ' {0,3}>')
|
|
1188
|
-
.replace('code', ' {4}[^\\n]')
|
|
1189
|
-
.replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
|
|
1190
|
-
.replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
|
|
1191
|
-
.replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)')
|
|
1192
|
-
.replace('tag', block._tag) // tables can be interrupted by type (6) html blocks
|
|
1193
|
-
.getRegex();
|
|
1194
|
-
|
|
1195
|
-
block.gfm.paragraph = edit(block._paragraph)
|
|
1196
|
-
.replace('hr', block.hr)
|
|
1197
|
-
.replace('heading', ' {0,3}#{1,6} ')
|
|
1198
|
-
.replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
|
|
1199
|
-
.replace('table', block.gfm.table) // interrupt paragraphs with table
|
|
1200
|
-
.replace('blockquote', ' {0,3}>')
|
|
1201
|
-
.replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
|
|
1202
|
-
.replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
|
|
1203
|
-
.replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)')
|
|
1204
|
-
.replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
|
|
1205
|
-
.getRegex();
|
|
1206
|
-
/**
|
|
1207
|
-
* Pedantic grammar (original John Gruber's loose markdown specification)
|
|
1208
|
-
*/
|
|
1209
|
-
|
|
948
|
+
block.gfm.table = edit(block.gfm.table).replace("hr", block.hr).replace("heading", " {0,3}#{1,6} ").replace("blockquote", " {0,3}>").replace("code", " {4}[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", block._tag).getRegex();
|
|
949
|
+
block.gfm.paragraph = edit(block._paragraph).replace("hr", block.hr).replace("heading", " {0,3}#{1,6} ").replace("|lheading", "").replace("table", block.gfm.table).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", block._tag).getRegex();
|
|
1210
950
|
block.pedantic = {
|
|
1211
951
|
...block.normal,
|
|
1212
952
|
html: edit(
|
|
1213
|
-
|
|
1214
|
-
|
|
1215
|
-
+ '|<tag(?:"[^"]*"|\'[^\']*\'|\\s[^\'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))')
|
|
1216
|
-
.replace('comment', block._comment)
|
|
1217
|
-
.replace(/tag/g, '(?!(?:'
|
|
1218
|
-
+ 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub'
|
|
1219
|
-
+ '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)'
|
|
1220
|
-
+ '\\b)\\w+(?!:|[^\\w\\s@]*@)\\b')
|
|
1221
|
-
.getRegex(),
|
|
953
|
+
`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`
|
|
954
|
+
).replace("comment", block._comment).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),
|
|
1222
955
|
def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
|
|
1223
956
|
heading: /^(#{1,6})(.*)(?:\n+|$)/,
|
|
1224
|
-
fences: noopTest,
|
|
957
|
+
fences: noopTest,
|
|
958
|
+
// fences not supported
|
|
1225
959
|
lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
|
|
1226
|
-
paragraph: edit(block.normal._paragraph)
|
|
1227
|
-
.replace('hr', block.hr)
|
|
1228
|
-
.replace('heading', ' *#{1,6} *[^\n]')
|
|
1229
|
-
.replace('lheading', block.lheading)
|
|
1230
|
-
.replace('blockquote', ' {0,3}>')
|
|
1231
|
-
.replace('|fences', '')
|
|
1232
|
-
.replace('|list', '')
|
|
1233
|
-
.replace('|html', '')
|
|
1234
|
-
.getRegex()
|
|
960
|
+
paragraph: edit(block.normal._paragraph).replace("hr", block.hr).replace("heading", " *#{1,6} *[^\n]").replace("lheading", block.lheading).replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").getRegex()
|
|
1235
961
|
};
|
|
1236
|
-
|
|
1237
|
-
/**
|
|
1238
|
-
* Inline-Level Grammar
|
|
1239
|
-
*/
|
|
1240
|
-
const inline = {
|
|
962
|
+
var inline = {
|
|
1241
963
|
escape: /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,
|
|
1242
964
|
autolink: /^<(scheme:[^\s\x00-\x1f<>]*|email)>/,
|
|
1243
965
|
url: noopTest,
|
|
1244
|
-
tag:
|
|
1245
|
-
|
|
1246
|
-
+ '|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>' // open tag
|
|
1247
|
-
+ '|^<\\?[\\s\\S]*?\\?>' // processing instruction, e.g. <?php ?>
|
|
1248
|
-
+ '|^<![a-zA-Z]+\\s[\\s\\S]*?>' // declaration, e.g. <!DOCTYPE html>
|
|
1249
|
-
+ '|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>', // CDATA section
|
|
966
|
+
tag: "^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>",
|
|
967
|
+
// CDATA section
|
|
1250
968
|
link: /^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/,
|
|
1251
969
|
reflink: /^!?\[(label)\]\[(ref)\]/,
|
|
1252
970
|
nolink: /^!?\[(ref)\](?:\[\])?/,
|
|
1253
|
-
reflinkSearch:
|
|
971
|
+
reflinkSearch: "reflink|nolink(?!\\()",
|
|
1254
972
|
emStrong: {
|
|
1255
|
-
lDelim: /^(?:\*+(?:([
|
|
1256
|
-
//
|
|
1257
|
-
//
|
|
1258
|
-
rDelimAst: /^
|
|
1259
|
-
rDelimUnd: /^
|
|
973
|
+
lDelim: /^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/,
|
|
974
|
+
// (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left. (5) and (6) can be either Left or Right.
|
|
975
|
+
// | Skip orphan inside strong | Consume to delim | (1) #*** | (2) a***#, a*** | (3) #***a, ***a | (4) ***# | (5) #***# | (6) a***a
|
|
976
|
+
rDelimAst: /^[^_*]*?__[^_*]*?\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\*)[punct](\*+)(?=[\s]|$)|[^punct\s](\*+)(?!\*)(?=[punct\s]|$)|(?!\*)[punct\s](\*+)(?=[^punct\s])|[\s](\*+)(?!\*)(?=[punct])|(?!\*)[punct](\*+)(?!\*)(?=[punct])|[^punct\s](\*+)(?=[^punct\s])/,
|
|
977
|
+
rDelimUnd: /^[^_*]*?\*\*[^_*]*?_[^_*]*?(?=\*\*)|[^_]+(?=[^_])|(?!_)[punct](_+)(?=[\s]|$)|[^punct\s](_+)(?!_)(?=[punct\s]|$)|(?!_)[punct\s](_+)(?=[^punct\s])|[\s](_+)(?!_)(?=[punct])|(?!_)[punct](_+)(?!_)(?=[punct])/
|
|
978
|
+
// ^- Not allowed for _
|
|
1260
979
|
},
|
|
1261
980
|
code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
|
|
1262
981
|
br: /^( {2,}|\\)\n(?!\s*$)/,
|
|
1263
982
|
del: noopTest,
|
|
1264
983
|
text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/,
|
|
1265
|
-
punctuation: /^([\spunctuation])/
|
|
984
|
+
punctuation: /^((?![*_])[\spunctuation])/
|
|
1266
985
|
};
|
|
1267
|
-
|
|
1268
|
-
|
|
1269
|
-
|
|
1270
|
-
inline.
|
|
1271
|
-
inline.
|
|
1272
|
-
|
|
1273
|
-
|
|
1274
|
-
inline.
|
|
1275
|
-
|
|
1276
|
-
|
|
1277
|
-
inline.
|
|
1278
|
-
|
|
1279
|
-
inline._comment = edit(block._comment).replace('(?:-->|$)', '-->').getRegex();
|
|
1280
|
-
|
|
1281
|
-
inline.emStrong.lDelim = edit(inline.emStrong.lDelim)
|
|
1282
|
-
.replace(/punct/g, inline._punctuation)
|
|
1283
|
-
.getRegex();
|
|
1284
|
-
|
|
1285
|
-
inline.emStrong.rDelimAst = edit(inline.emStrong.rDelimAst, 'g')
|
|
1286
|
-
.replace(/punct/g, inline._punctuation)
|
|
1287
|
-
.getRegex();
|
|
1288
|
-
|
|
1289
|
-
inline.emStrong.rDelimUnd = edit(inline.emStrong.rDelimUnd, 'g')
|
|
1290
|
-
.replace(/punct/g, inline._punctuation)
|
|
1291
|
-
.getRegex();
|
|
1292
|
-
|
|
1293
|
-
inline._escapes = /\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g;
|
|
1294
|
-
|
|
986
|
+
inline._punctuation = "\\p{P}$+<=>`^|~";
|
|
987
|
+
inline.punctuation = edit(inline.punctuation, "u").replace(/punctuation/g, inline._punctuation).getRegex();
|
|
988
|
+
inline.blockSkip = /\[[^[\]]*?\]\([^\(\)]*?\)|`[^`]*?`|<[^<>]*?>/g;
|
|
989
|
+
inline.anyPunctuation = /\\[punct]/g;
|
|
990
|
+
inline._escapes = /\\([punct])/g;
|
|
991
|
+
inline._comment = edit(block._comment).replace("(?:-->|$)", "-->").getRegex();
|
|
992
|
+
inline.emStrong.lDelim = edit(inline.emStrong.lDelim, "u").replace(/punct/g, inline._punctuation).getRegex();
|
|
993
|
+
inline.emStrong.rDelimAst = edit(inline.emStrong.rDelimAst, "gu").replace(/punct/g, inline._punctuation).getRegex();
|
|
994
|
+
inline.emStrong.rDelimUnd = edit(inline.emStrong.rDelimUnd, "gu").replace(/punct/g, inline._punctuation).getRegex();
|
|
995
|
+
inline.anyPunctuation = edit(inline.anyPunctuation, "gu").replace(/punct/g, inline._punctuation).getRegex();
|
|
996
|
+
inline._escapes = edit(inline._escapes, "gu").replace(/punct/g, inline._punctuation).getRegex();
|
|
1295
997
|
inline._scheme = /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/;
|
|
1296
998
|
inline._email = /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/;
|
|
1297
|
-
inline.autolink = edit(inline.autolink)
|
|
1298
|
-
.replace('scheme', inline._scheme)
|
|
1299
|
-
.replace('email', inline._email)
|
|
1300
|
-
.getRegex();
|
|
1301
|
-
|
|
999
|
+
inline.autolink = edit(inline.autolink).replace("scheme", inline._scheme).replace("email", inline._email).getRegex();
|
|
1302
1000
|
inline._attribute = /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/;
|
|
1303
|
-
|
|
1304
|
-
inline.tag = edit(inline.tag)
|
|
1305
|
-
.replace('comment', inline._comment)
|
|
1306
|
-
.replace('attribute', inline._attribute)
|
|
1307
|
-
.getRegex();
|
|
1308
|
-
|
|
1001
|
+
inline.tag = edit(inline.tag).replace("comment", inline._comment).replace("attribute", inline._attribute).getRegex();
|
|
1309
1002
|
inline._label = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
|
|
1310
1003
|
inline._href = /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/;
|
|
1311
1004
|
inline._title = /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/;
|
|
1312
|
-
|
|
1313
|
-
inline.
|
|
1314
|
-
|
|
1315
|
-
|
|
1316
|
-
.replace('title', inline._title)
|
|
1317
|
-
.getRegex();
|
|
1318
|
-
|
|
1319
|
-
inline.reflink = edit(inline.reflink)
|
|
1320
|
-
.replace('label', inline._label)
|
|
1321
|
-
.replace('ref', block._label)
|
|
1322
|
-
.getRegex();
|
|
1323
|
-
|
|
1324
|
-
inline.nolink = edit(inline.nolink)
|
|
1325
|
-
.replace('ref', block._label)
|
|
1326
|
-
.getRegex();
|
|
1327
|
-
|
|
1328
|
-
inline.reflinkSearch = edit(inline.reflinkSearch, 'g')
|
|
1329
|
-
.replace('reflink', inline.reflink)
|
|
1330
|
-
.replace('nolink', inline.nolink)
|
|
1331
|
-
.getRegex();
|
|
1332
|
-
|
|
1333
|
-
/**
|
|
1334
|
-
* Normal Inline Grammar
|
|
1335
|
-
*/
|
|
1336
|
-
|
|
1005
|
+
inline.link = edit(inline.link).replace("label", inline._label).replace("href", inline._href).replace("title", inline._title).getRegex();
|
|
1006
|
+
inline.reflink = edit(inline.reflink).replace("label", inline._label).replace("ref", block._label).getRegex();
|
|
1007
|
+
inline.nolink = edit(inline.nolink).replace("ref", block._label).getRegex();
|
|
1008
|
+
inline.reflinkSearch = edit(inline.reflinkSearch, "g").replace("reflink", inline.reflink).replace("nolink", inline.nolink).getRegex();
|
|
1337
1009
|
inline.normal = { ...inline };
|
|
1338
|
-
|
|
1339
|
-
/**
|
|
1340
|
-
* Pedantic Inline Grammar
|
|
1341
|
-
*/
|
|
1342
|
-
|
|
1343
1010
|
inline.pedantic = {
|
|
1344
1011
|
...inline.normal,
|
|
1345
1012
|
strong: {
|
|
@@ -1354,96 +1021,47 @@ inline.pedantic = {
|
|
|
1354
1021
|
endAst: /\*(?!\*)/g,
|
|
1355
1022
|
endUnd: /_(?!_)/g
|
|
1356
1023
|
},
|
|
1357
|
-
link: edit(/^!?\[(label)\]\((.*?)\)/)
|
|
1358
|
-
|
|
1359
|
-
.getRegex(),
|
|
1360
|
-
reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/)
|
|
1361
|
-
.replace('label', inline._label)
|
|
1362
|
-
.getRegex()
|
|
1024
|
+
link: edit(/^!?\[(label)\]\((.*?)\)/).replace("label", inline._label).getRegex(),
|
|
1025
|
+
reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", inline._label).getRegex()
|
|
1363
1026
|
};
|
|
1364
|
-
|
|
1365
|
-
/**
|
|
1366
|
-
* GFM Inline Grammar
|
|
1367
|
-
*/
|
|
1368
|
-
|
|
1369
1027
|
inline.gfm = {
|
|
1370
1028
|
...inline.normal,
|
|
1371
|
-
escape: edit(inline.escape).replace(
|
|
1029
|
+
escape: edit(inline.escape).replace("])", "~|])").getRegex(),
|
|
1372
1030
|
_extended_email: /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,
|
|
1373
1031
|
url: /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,
|
|
1374
1032
|
_backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,
|
|
1375
1033
|
del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
|
|
1376
1034
|
text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
|
|
1377
1035
|
};
|
|
1378
|
-
|
|
1379
|
-
inline.gfm.url = edit(inline.gfm.url, 'i')
|
|
1380
|
-
.replace('email', inline.gfm._extended_email)
|
|
1381
|
-
.getRegex();
|
|
1382
|
-
/**
|
|
1383
|
-
* GFM + Line Breaks Inline Grammar
|
|
1384
|
-
*/
|
|
1385
|
-
|
|
1036
|
+
inline.gfm.url = edit(inline.gfm.url, "i").replace("email", inline.gfm._extended_email).getRegex();
|
|
1386
1037
|
inline.breaks = {
|
|
1387
1038
|
...inline.gfm,
|
|
1388
|
-
br: edit(inline.br).replace(
|
|
1389
|
-
text: edit(inline.gfm.text)
|
|
1390
|
-
.replace('\\b_', '\\b_| {2,}\\n')
|
|
1391
|
-
.replace(/\{2,\}/g, '*')
|
|
1392
|
-
.getRegex()
|
|
1039
|
+
br: edit(inline.br).replace("{2,}", "*").getRegex(),
|
|
1040
|
+
text: edit(inline.gfm.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex()
|
|
1393
1041
|
};
|
|
1394
1042
|
|
|
1395
|
-
|
|
1396
|
-
* smartypants text replacement
|
|
1397
|
-
* @param {string} text
|
|
1398
|
-
*/
|
|
1043
|
+
// src/Lexer.ts
|
|
1399
1044
|
function smartypants(text) {
|
|
1400
|
-
return text
|
|
1401
|
-
// em-dashes
|
|
1402
|
-
.replace(/---/g, '\u2014')
|
|
1403
|
-
// en-dashes
|
|
1404
|
-
.replace(/--/g, '\u2013')
|
|
1405
|
-
// opening singles
|
|
1406
|
-
.replace(/(^|[-\u2014/(\[{"\s])'/g, '$1\u2018')
|
|
1407
|
-
// closing singles & apostrophes
|
|
1408
|
-
.replace(/'/g, '\u2019')
|
|
1409
|
-
// opening doubles
|
|
1410
|
-
.replace(/(^|[-\u2014/(\[{\u2018\s])"/g, '$1\u201c')
|
|
1411
|
-
// closing doubles
|
|
1412
|
-
.replace(/"/g, '\u201d')
|
|
1413
|
-
// ellipses
|
|
1414
|
-
.replace(/\.{3}/g, '\u2026');
|
|
1045
|
+
return text.replace(/---/g, "\u2014").replace(/--/g, "\u2013").replace(/(^|[-\u2014/(\[{"\s])'/g, "$1\u2018").replace(/'/g, "\u2019").replace(/(^|[-\u2014/(\[{\u2018\s])"/g, "$1\u201C").replace(/"/g, "\u201D").replace(/\.{3}/g, "\u2026");
|
|
1415
1046
|
}
|
|
1416
|
-
|
|
1417
|
-
/**
|
|
1418
|
-
* mangle email addresses
|
|
1419
|
-
* @param {string} text
|
|
1420
|
-
*/
|
|
1421
1047
|
function mangle(text) {
|
|
1422
|
-
let out =
|
|
1423
|
-
i,
|
|
1424
|
-
ch;
|
|
1425
|
-
|
|
1048
|
+
let out = "", i, ch;
|
|
1426
1049
|
const l = text.length;
|
|
1427
1050
|
for (i = 0; i < l; i++) {
|
|
1428
1051
|
ch = text.charCodeAt(i);
|
|
1429
1052
|
if (Math.random() > 0.5) {
|
|
1430
|
-
ch =
|
|
1053
|
+
ch = "x" + ch.toString(16);
|
|
1431
1054
|
}
|
|
1432
|
-
out +=
|
|
1055
|
+
out += "&#" + ch + ";";
|
|
1433
1056
|
}
|
|
1434
|
-
|
|
1435
1057
|
return out;
|
|
1436
1058
|
}
|
|
1437
|
-
|
|
1438
|
-
|
|
1439
|
-
* Block Lexer
|
|
1440
|
-
*/
|
|
1441
|
-
class Lexer {
|
|
1442
|
-
constructor(options) {
|
|
1059
|
+
var _Lexer = class {
|
|
1060
|
+
constructor(options2) {
|
|
1443
1061
|
this.tokens = [];
|
|
1444
|
-
this.tokens.links = Object.create(null);
|
|
1445
|
-
this.options =
|
|
1446
|
-
this.options.tokenizer = this.options.tokenizer || new
|
|
1062
|
+
this.tokens.links = /* @__PURE__ */ Object.create(null);
|
|
1063
|
+
this.options = options2 || _defaults;
|
|
1064
|
+
this.options.tokenizer = this.options.tokenizer || new _Tokenizer();
|
|
1447
1065
|
this.tokenizer = this.options.tokenizer;
|
|
1448
1066
|
this.tokenizer.options = this.options;
|
|
1449
1067
|
this.tokenizer.lexer = this;
|
|
@@ -1453,12 +1071,10 @@ class Lexer {
|
|
|
1453
1071
|
inRawBlock: false,
|
|
1454
1072
|
top: true
|
|
1455
1073
|
};
|
|
1456
|
-
|
|
1457
1074
|
const rules = {
|
|
1458
1075
|
block: block.normal,
|
|
1459
1076
|
inline: inline.normal
|
|
1460
1077
|
};
|
|
1461
|
-
|
|
1462
1078
|
if (this.options.pedantic) {
|
|
1463
1079
|
rules.block = block.pedantic;
|
|
1464
1080
|
rules.inline = inline.pedantic;
|
|
@@ -1472,7 +1088,6 @@ class Lexer {
|
|
|
1472
1088
|
}
|
|
1473
1089
|
this.tokenizer.rules = rules;
|
|
1474
1090
|
}
|
|
1475
|
-
|
|
1476
1091
|
/**
|
|
1477
1092
|
* Expose Rules
|
|
1478
1093
|
*/
|
|
@@ -1482,145 +1097,109 @@ class Lexer {
|
|
|
1482
1097
|
inline
|
|
1483
1098
|
};
|
|
1484
1099
|
}
|
|
1485
|
-
|
|
1486
1100
|
/**
|
|
1487
1101
|
* Static Lex Method
|
|
1488
1102
|
*/
|
|
1489
|
-
static lex(src,
|
|
1490
|
-
const
|
|
1491
|
-
return
|
|
1103
|
+
static lex(src, options2) {
|
|
1104
|
+
const lexer2 = new _Lexer(options2);
|
|
1105
|
+
return lexer2.lex(src);
|
|
1492
1106
|
}
|
|
1493
|
-
|
|
1494
1107
|
/**
|
|
1495
1108
|
* Static Lex Inline Method
|
|
1496
1109
|
*/
|
|
1497
|
-
static lexInline(src,
|
|
1498
|
-
const
|
|
1499
|
-
return
|
|
1110
|
+
static lexInline(src, options2) {
|
|
1111
|
+
const lexer2 = new _Lexer(options2);
|
|
1112
|
+
return lexer2.inlineTokens(src);
|
|
1500
1113
|
}
|
|
1501
|
-
|
|
1502
1114
|
/**
|
|
1503
1115
|
* Preprocessing
|
|
1504
1116
|
*/
|
|
1505
1117
|
lex(src) {
|
|
1506
|
-
src = src
|
|
1507
|
-
.replace(/\r\n|\r/g, '\n');
|
|
1508
|
-
|
|
1118
|
+
src = src.replace(/\r\n|\r/g, "\n");
|
|
1509
1119
|
this.blockTokens(src, this.tokens);
|
|
1510
|
-
|
|
1511
1120
|
let next;
|
|
1512
1121
|
while (next = this.inlineQueue.shift()) {
|
|
1513
1122
|
this.inlineTokens(next.src, next.tokens);
|
|
1514
1123
|
}
|
|
1515
|
-
|
|
1516
1124
|
return this.tokens;
|
|
1517
1125
|
}
|
|
1518
|
-
|
|
1519
|
-
/**
|
|
1520
|
-
* Lexing
|
|
1521
|
-
*/
|
|
1522
1126
|
blockTokens(src, tokens = []) {
|
|
1523
1127
|
if (this.options.pedantic) {
|
|
1524
|
-
src = src.replace(/\t/g,
|
|
1128
|
+
src = src.replace(/\t/g, " ").replace(/^ +$/gm, "");
|
|
1525
1129
|
} else {
|
|
1526
1130
|
src = src.replace(/^( *)(\t+)/gm, (_, leading, tabs) => {
|
|
1527
|
-
return leading +
|
|
1131
|
+
return leading + " ".repeat(tabs.length);
|
|
1528
1132
|
});
|
|
1529
1133
|
}
|
|
1530
|
-
|
|
1531
1134
|
let token, lastToken, cutSrc, lastParagraphClipped;
|
|
1532
|
-
|
|
1533
1135
|
while (src) {
|
|
1534
|
-
if (this.options.extensions
|
|
1535
|
-
|
|
1536
|
-
|
|
1537
|
-
|
|
1538
|
-
|
|
1539
|
-
|
|
1540
|
-
|
|
1541
|
-
|
|
1542
|
-
return false;
|
|
1543
|
-
})) {
|
|
1136
|
+
if (this.options.extensions && this.options.extensions.block && this.options.extensions.block.some((extTokenizer) => {
|
|
1137
|
+
if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
|
|
1138
|
+
src = src.substring(token.raw.length);
|
|
1139
|
+
tokens.push(token);
|
|
1140
|
+
return true;
|
|
1141
|
+
}
|
|
1142
|
+
return false;
|
|
1143
|
+
})) {
|
|
1544
1144
|
continue;
|
|
1545
1145
|
}
|
|
1546
|
-
|
|
1547
|
-
// newline
|
|
1548
1146
|
if (token = this.tokenizer.space(src)) {
|
|
1549
1147
|
src = src.substring(token.raw.length);
|
|
1550
1148
|
if (token.raw.length === 1 && tokens.length > 0) {
|
|
1551
|
-
|
|
1552
|
-
// so move it there so that we don't get unecessary paragraph tags
|
|
1553
|
-
tokens[tokens.length - 1].raw += '\n';
|
|
1149
|
+
tokens[tokens.length - 1].raw += "\n";
|
|
1554
1150
|
} else {
|
|
1555
1151
|
tokens.push(token);
|
|
1556
1152
|
}
|
|
1557
1153
|
continue;
|
|
1558
1154
|
}
|
|
1559
|
-
|
|
1560
|
-
// code
|
|
1561
1155
|
if (token = this.tokenizer.code(src)) {
|
|
1562
1156
|
src = src.substring(token.raw.length);
|
|
1563
1157
|
lastToken = tokens[tokens.length - 1];
|
|
1564
|
-
|
|
1565
|
-
|
|
1566
|
-
lastToken.
|
|
1567
|
-
lastToken.text += '\n' + token.text;
|
|
1158
|
+
if (lastToken && (lastToken.type === "paragraph" || lastToken.type === "text")) {
|
|
1159
|
+
lastToken.raw += "\n" + token.raw;
|
|
1160
|
+
lastToken.text += "\n" + token.text;
|
|
1568
1161
|
this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
|
|
1569
1162
|
} else {
|
|
1570
1163
|
tokens.push(token);
|
|
1571
1164
|
}
|
|
1572
1165
|
continue;
|
|
1573
1166
|
}
|
|
1574
|
-
|
|
1575
|
-
// fences
|
|
1576
1167
|
if (token = this.tokenizer.fences(src)) {
|
|
1577
1168
|
src = src.substring(token.raw.length);
|
|
1578
1169
|
tokens.push(token);
|
|
1579
1170
|
continue;
|
|
1580
1171
|
}
|
|
1581
|
-
|
|
1582
|
-
// heading
|
|
1583
1172
|
if (token = this.tokenizer.heading(src)) {
|
|
1584
1173
|
src = src.substring(token.raw.length);
|
|
1585
1174
|
tokens.push(token);
|
|
1586
1175
|
continue;
|
|
1587
1176
|
}
|
|
1588
|
-
|
|
1589
|
-
// hr
|
|
1590
1177
|
if (token = this.tokenizer.hr(src)) {
|
|
1591
1178
|
src = src.substring(token.raw.length);
|
|
1592
1179
|
tokens.push(token);
|
|
1593
1180
|
continue;
|
|
1594
1181
|
}
|
|
1595
|
-
|
|
1596
|
-
// blockquote
|
|
1597
1182
|
if (token = this.tokenizer.blockquote(src)) {
|
|
1598
1183
|
src = src.substring(token.raw.length);
|
|
1599
1184
|
tokens.push(token);
|
|
1600
1185
|
continue;
|
|
1601
1186
|
}
|
|
1602
|
-
|
|
1603
|
-
// list
|
|
1604
1187
|
if (token = this.tokenizer.list(src)) {
|
|
1605
1188
|
src = src.substring(token.raw.length);
|
|
1606
1189
|
tokens.push(token);
|
|
1607
1190
|
continue;
|
|
1608
1191
|
}
|
|
1609
|
-
|
|
1610
|
-
// html
|
|
1611
1192
|
if (token = this.tokenizer.html(src)) {
|
|
1612
1193
|
src = src.substring(token.raw.length);
|
|
1613
1194
|
tokens.push(token);
|
|
1614
1195
|
continue;
|
|
1615
1196
|
}
|
|
1616
|
-
|
|
1617
|
-
// def
|
|
1618
1197
|
if (token = this.tokenizer.def(src)) {
|
|
1619
1198
|
src = src.substring(token.raw.length);
|
|
1620
1199
|
lastToken = tokens[tokens.length - 1];
|
|
1621
|
-
if (lastToken && (lastToken.type ===
|
|
1622
|
-
lastToken.raw +=
|
|
1623
|
-
lastToken.text +=
|
|
1200
|
+
if (lastToken && (lastToken.type === "paragraph" || lastToken.type === "text")) {
|
|
1201
|
+
lastToken.raw += "\n" + token.raw;
|
|
1202
|
+
lastToken.text += "\n" + token.raw;
|
|
1624
1203
|
this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
|
|
1625
1204
|
} else if (!this.tokens.links[token.tag]) {
|
|
1626
1205
|
this.tokens.links[token.tag] = {
|
|
@@ -1630,31 +1209,26 @@ class Lexer {
|
|
|
1630
1209
|
}
|
|
1631
1210
|
continue;
|
|
1632
1211
|
}
|
|
1633
|
-
|
|
1634
|
-
// table (gfm)
|
|
1635
1212
|
if (token = this.tokenizer.table(src)) {
|
|
1636
1213
|
src = src.substring(token.raw.length);
|
|
1637
1214
|
tokens.push(token);
|
|
1638
1215
|
continue;
|
|
1639
1216
|
}
|
|
1640
|
-
|
|
1641
|
-
// lheading
|
|
1642
1217
|
if (token = this.tokenizer.lheading(src)) {
|
|
1643
1218
|
src = src.substring(token.raw.length);
|
|
1644
1219
|
tokens.push(token);
|
|
1645
1220
|
continue;
|
|
1646
1221
|
}
|
|
1647
|
-
|
|
1648
|
-
// top-level paragraph
|
|
1649
|
-
// prevent paragraph consuming extensions by clipping 'src' to extension start
|
|
1650
1222
|
cutSrc = src;
|
|
1651
1223
|
if (this.options.extensions && this.options.extensions.startBlock) {
|
|
1652
1224
|
let startIndex = Infinity;
|
|
1653
1225
|
const tempSrc = src.slice(1);
|
|
1654
1226
|
let tempStart;
|
|
1655
|
-
this.options.extensions.startBlock.forEach(
|
|
1227
|
+
this.options.extensions.startBlock.forEach((getStartIndex) => {
|
|
1656
1228
|
tempStart = getStartIndex.call({ lexer: this }, tempSrc);
|
|
1657
|
-
if (typeof tempStart ===
|
|
1229
|
+
if (typeof tempStart === "number" && tempStart >= 0) {
|
|
1230
|
+
startIndex = Math.min(startIndex, tempStart);
|
|
1231
|
+
}
|
|
1658
1232
|
});
|
|
1659
1233
|
if (startIndex < Infinity && startIndex >= 0) {
|
|
1660
1234
|
cutSrc = src.substring(0, startIndex + 1);
|
|
@@ -1662,26 +1236,24 @@ class Lexer {
|
|
|
1662
1236
|
}
|
|
1663
1237
|
if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {
|
|
1664
1238
|
lastToken = tokens[tokens.length - 1];
|
|
1665
|
-
if (lastParagraphClipped && lastToken.type ===
|
|
1666
|
-
lastToken.raw +=
|
|
1667
|
-
lastToken.text +=
|
|
1239
|
+
if (lastParagraphClipped && lastToken.type === "paragraph") {
|
|
1240
|
+
lastToken.raw += "\n" + token.raw;
|
|
1241
|
+
lastToken.text += "\n" + token.text;
|
|
1668
1242
|
this.inlineQueue.pop();
|
|
1669
1243
|
this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
|
|
1670
1244
|
} else {
|
|
1671
1245
|
tokens.push(token);
|
|
1672
1246
|
}
|
|
1673
|
-
lastParagraphClipped =
|
|
1247
|
+
lastParagraphClipped = cutSrc.length !== src.length;
|
|
1674
1248
|
src = src.substring(token.raw.length);
|
|
1675
1249
|
continue;
|
|
1676
1250
|
}
|
|
1677
|
-
|
|
1678
|
-
// text
|
|
1679
1251
|
if (token = this.tokenizer.text(src)) {
|
|
1680
1252
|
src = src.substring(token.raw.length);
|
|
1681
1253
|
lastToken = tokens[tokens.length - 1];
|
|
1682
|
-
if (lastToken && lastToken.type ===
|
|
1683
|
-
lastToken.raw +=
|
|
1684
|
-
lastToken.text +=
|
|
1254
|
+
if (lastToken && lastToken.type === "text") {
|
|
1255
|
+
lastToken.raw += "\n" + token.raw;
|
|
1256
|
+
lastToken.text += "\n" + token.text;
|
|
1685
1257
|
this.inlineQueue.pop();
|
|
1686
1258
|
this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
|
|
1687
1259
|
} else {
|
|
@@ -1689,9 +1261,8 @@ class Lexer {
|
|
|
1689
1261
|
}
|
|
1690
1262
|
continue;
|
|
1691
1263
|
}
|
|
1692
|
-
|
|
1693
1264
|
if (src) {
|
|
1694
|
-
const errMsg =
|
|
1265
|
+
const errMsg = "Infinite loop on byte: " + src.charCodeAt(0);
|
|
1695
1266
|
if (this.options.silent) {
|
|
1696
1267
|
console.error(errMsg);
|
|
1697
1268
|
break;
|
|
@@ -1700,81 +1271,61 @@ class Lexer {
|
|
|
1700
1271
|
}
|
|
1701
1272
|
}
|
|
1702
1273
|
}
|
|
1703
|
-
|
|
1704
1274
|
this.state.top = true;
|
|
1705
1275
|
return tokens;
|
|
1706
1276
|
}
|
|
1707
|
-
|
|
1708
1277
|
inline(src, tokens = []) {
|
|
1709
1278
|
this.inlineQueue.push({ src, tokens });
|
|
1710
1279
|
return tokens;
|
|
1711
1280
|
}
|
|
1712
|
-
|
|
1713
1281
|
/**
|
|
1714
1282
|
* Lexing/Compiling
|
|
1715
1283
|
*/
|
|
1716
1284
|
inlineTokens(src, tokens = []) {
|
|
1717
1285
|
let token, lastToken, cutSrc;
|
|
1718
|
-
|
|
1719
|
-
// String with links masked to avoid interference with em and strong
|
|
1720
1286
|
let maskedSrc = src;
|
|
1721
1287
|
let match;
|
|
1722
1288
|
let keepPrevChar, prevChar;
|
|
1723
|
-
|
|
1724
|
-
// Mask out reflinks
|
|
1725
1289
|
if (this.tokens.links) {
|
|
1726
1290
|
const links = Object.keys(this.tokens.links);
|
|
1727
1291
|
if (links.length > 0) {
|
|
1728
1292
|
while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {
|
|
1729
|
-
if (links.includes(match[0].slice(match[0].lastIndexOf(
|
|
1730
|
-
maskedSrc = maskedSrc.slice(0, match.index) +
|
|
1293
|
+
if (links.includes(match[0].slice(match[0].lastIndexOf("[") + 1, -1))) {
|
|
1294
|
+
maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
|
|
1731
1295
|
}
|
|
1732
1296
|
}
|
|
1733
1297
|
}
|
|
1734
1298
|
}
|
|
1735
|
-
// Mask out other blocks
|
|
1736
1299
|
while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {
|
|
1737
|
-
maskedSrc = maskedSrc.slice(0, match.index) +
|
|
1300
|
+
maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
|
|
1738
1301
|
}
|
|
1739
|
-
|
|
1740
|
-
|
|
1741
|
-
while ((match = this.tokenizer.rules.inline.escapedEmSt.exec(maskedSrc)) != null) {
|
|
1742
|
-
maskedSrc = maskedSrc.slice(0, match.index + match[0].length - 2) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.escapedEmSt.lastIndex);
|
|
1743
|
-
this.tokenizer.rules.inline.escapedEmSt.lastIndex--;
|
|
1302
|
+
while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) != null) {
|
|
1303
|
+
maskedSrc = maskedSrc.slice(0, match.index) + "++" + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
|
|
1744
1304
|
}
|
|
1745
|
-
|
|
1746
1305
|
while (src) {
|
|
1747
1306
|
if (!keepPrevChar) {
|
|
1748
|
-
prevChar =
|
|
1307
|
+
prevChar = "";
|
|
1749
1308
|
}
|
|
1750
1309
|
keepPrevChar = false;
|
|
1751
|
-
|
|
1752
|
-
|
|
1753
|
-
|
|
1754
|
-
|
|
1755
|
-
|
|
1756
|
-
|
|
1757
|
-
|
|
1758
|
-
|
|
1759
|
-
return true;
|
|
1760
|
-
}
|
|
1761
|
-
return false;
|
|
1762
|
-
})) {
|
|
1310
|
+
if (this.options.extensions && this.options.extensions.inline && this.options.extensions.inline.some((extTokenizer) => {
|
|
1311
|
+
if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
|
|
1312
|
+
src = src.substring(token.raw.length);
|
|
1313
|
+
tokens.push(token);
|
|
1314
|
+
return true;
|
|
1315
|
+
}
|
|
1316
|
+
return false;
|
|
1317
|
+
})) {
|
|
1763
1318
|
continue;
|
|
1764
1319
|
}
|
|
1765
|
-
|
|
1766
|
-
// escape
|
|
1767
1320
|
if (token = this.tokenizer.escape(src)) {
|
|
1768
1321
|
src = src.substring(token.raw.length);
|
|
1769
1322
|
tokens.push(token);
|
|
1770
1323
|
continue;
|
|
1771
1324
|
}
|
|
1772
|
-
|
|
1773
|
-
// tag
|
|
1774
1325
|
if (token = this.tokenizer.tag(src)) {
|
|
1775
1326
|
src = src.substring(token.raw.length);
|
|
1776
1327
|
lastToken = tokens[tokens.length - 1];
|
|
1777
|
-
if (lastToken && token.type ===
|
|
1328
|
+
if (lastToken && token.type === "text" && lastToken.type === "text") {
|
|
1778
1329
|
lastToken.raw += token.raw;
|
|
1779
1330
|
lastToken.text += token.text;
|
|
1780
1331
|
} else {
|
|
@@ -1782,19 +1333,15 @@ class Lexer {
|
|
|
1782
1333
|
}
|
|
1783
1334
|
continue;
|
|
1784
1335
|
}
|
|
1785
|
-
|
|
1786
|
-
// link
|
|
1787
1336
|
if (token = this.tokenizer.link(src)) {
|
|
1788
1337
|
src = src.substring(token.raw.length);
|
|
1789
1338
|
tokens.push(token);
|
|
1790
1339
|
continue;
|
|
1791
1340
|
}
|
|
1792
|
-
|
|
1793
|
-
// reflink, nolink
|
|
1794
1341
|
if (token = this.tokenizer.reflink(src, this.tokens.links)) {
|
|
1795
1342
|
src = src.substring(token.raw.length);
|
|
1796
1343
|
lastToken = tokens[tokens.length - 1];
|
|
1797
|
-
if (lastToken && token.type ===
|
|
1344
|
+
if (lastToken && token.type === "text" && lastToken.type === "text") {
|
|
1798
1345
|
lastToken.raw += token.raw;
|
|
1799
1346
|
lastToken.text += token.text;
|
|
1800
1347
|
} else {
|
|
@@ -1802,59 +1349,46 @@ class Lexer {
|
|
|
1802
1349
|
}
|
|
1803
1350
|
continue;
|
|
1804
1351
|
}
|
|
1805
|
-
|
|
1806
|
-
// em & strong
|
|
1807
1352
|
if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {
|
|
1808
1353
|
src = src.substring(token.raw.length);
|
|
1809
1354
|
tokens.push(token);
|
|
1810
1355
|
continue;
|
|
1811
1356
|
}
|
|
1812
|
-
|
|
1813
|
-
// code
|
|
1814
1357
|
if (token = this.tokenizer.codespan(src)) {
|
|
1815
1358
|
src = src.substring(token.raw.length);
|
|
1816
1359
|
tokens.push(token);
|
|
1817
1360
|
continue;
|
|
1818
1361
|
}
|
|
1819
|
-
|
|
1820
|
-
// br
|
|
1821
1362
|
if (token = this.tokenizer.br(src)) {
|
|
1822
1363
|
src = src.substring(token.raw.length);
|
|
1823
1364
|
tokens.push(token);
|
|
1824
1365
|
continue;
|
|
1825
1366
|
}
|
|
1826
|
-
|
|
1827
|
-
// del (gfm)
|
|
1828
1367
|
if (token = this.tokenizer.del(src)) {
|
|
1829
1368
|
src = src.substring(token.raw.length);
|
|
1830
1369
|
tokens.push(token);
|
|
1831
1370
|
continue;
|
|
1832
1371
|
}
|
|
1833
|
-
|
|
1834
|
-
// autolink
|
|
1835
1372
|
if (token = this.tokenizer.autolink(src, mangle)) {
|
|
1836
1373
|
src = src.substring(token.raw.length);
|
|
1837
1374
|
tokens.push(token);
|
|
1838
1375
|
continue;
|
|
1839
1376
|
}
|
|
1840
|
-
|
|
1841
|
-
// url (gfm)
|
|
1842
1377
|
if (!this.state.inLink && (token = this.tokenizer.url(src, mangle))) {
|
|
1843
1378
|
src = src.substring(token.raw.length);
|
|
1844
1379
|
tokens.push(token);
|
|
1845
1380
|
continue;
|
|
1846
1381
|
}
|
|
1847
|
-
|
|
1848
|
-
// text
|
|
1849
|
-
// prevent inlineText consuming extensions by clipping 'src' to extension start
|
|
1850
1382
|
cutSrc = src;
|
|
1851
1383
|
if (this.options.extensions && this.options.extensions.startInline) {
|
|
1852
1384
|
let startIndex = Infinity;
|
|
1853
1385
|
const tempSrc = src.slice(1);
|
|
1854
1386
|
let tempStart;
|
|
1855
|
-
this.options.extensions.startInline.forEach(
|
|
1387
|
+
this.options.extensions.startInline.forEach((getStartIndex) => {
|
|
1856
1388
|
tempStart = getStartIndex.call({ lexer: this }, tempSrc);
|
|
1857
|
-
if (typeof tempStart ===
|
|
1389
|
+
if (typeof tempStart === "number" && tempStart >= 0) {
|
|
1390
|
+
startIndex = Math.min(startIndex, tempStart);
|
|
1391
|
+
}
|
|
1858
1392
|
});
|
|
1859
1393
|
if (startIndex < Infinity && startIndex >= 0) {
|
|
1860
1394
|
cutSrc = src.substring(0, startIndex + 1);
|
|
@@ -1862,12 +1396,12 @@ class Lexer {
|
|
|
1862
1396
|
}
|
|
1863
1397
|
if (token = this.tokenizer.inlineText(cutSrc, smartypants)) {
|
|
1864
1398
|
src = src.substring(token.raw.length);
|
|
1865
|
-
if (token.raw.slice(-1) !==
|
|
1399
|
+
if (token.raw.slice(-1) !== "_") {
|
|
1866
1400
|
prevChar = token.raw.slice(-1);
|
|
1867
1401
|
}
|
|
1868
1402
|
keepPrevChar = true;
|
|
1869
1403
|
lastToken = tokens[tokens.length - 1];
|
|
1870
|
-
if (lastToken && lastToken.type ===
|
|
1404
|
+
if (lastToken && lastToken.type === "text") {
|
|
1871
1405
|
lastToken.raw += token.raw;
|
|
1872
1406
|
lastToken.text += token.text;
|
|
1873
1407
|
} else {
|
|
@@ -1875,9 +1409,8 @@ class Lexer {
|
|
|
1875
1409
|
}
|
|
1876
1410
|
continue;
|
|
1877
1411
|
}
|
|
1878
|
-
|
|
1879
1412
|
if (src) {
|
|
1880
|
-
const errMsg =
|
|
1413
|
+
const errMsg = "Infinite loop on byte: " + src.charCodeAt(0);
|
|
1881
1414
|
if (this.options.silent) {
|
|
1882
1415
|
console.error(errMsg);
|
|
1883
1416
|
break;
|
|
@@ -1886,21 +1419,17 @@ class Lexer {
|
|
|
1886
1419
|
}
|
|
1887
1420
|
}
|
|
1888
1421
|
}
|
|
1889
|
-
|
|
1890
1422
|
return tokens;
|
|
1891
1423
|
}
|
|
1892
|
-
}
|
|
1424
|
+
};
|
|
1893
1425
|
|
|
1894
|
-
|
|
1895
|
-
|
|
1896
|
-
|
|
1897
|
-
|
|
1898
|
-
constructor(options) {
|
|
1899
|
-
this.options = options || defaults;
|
|
1426
|
+
// src/Renderer.ts
|
|
1427
|
+
var _Renderer = class {
|
|
1428
|
+
constructor(options2) {
|
|
1429
|
+
this.options = options2 || _defaults;
|
|
1900
1430
|
}
|
|
1901
|
-
|
|
1902
1431
|
code(code, infostring, escaped) {
|
|
1903
|
-
const lang = (infostring ||
|
|
1432
|
+
const lang = (infostring || "").match(/\S*/)[0];
|
|
1904
1433
|
if (this.options.highlight) {
|
|
1905
1434
|
const out = this.options.highlight(code, lang);
|
|
1906
1435
|
if (out != null && out !== code) {
|
|
@@ -1908,150 +1437,81 @@ class Renderer {
|
|
|
1908
1437
|
code = out;
|
|
1909
1438
|
}
|
|
1910
1439
|
}
|
|
1911
|
-
|
|
1912
|
-
code = code.replace(/\n$/, '') + '\n';
|
|
1913
|
-
|
|
1440
|
+
code = code.replace(/\n$/, "") + "\n";
|
|
1914
1441
|
if (!lang) {
|
|
1915
|
-
return
|
|
1916
|
-
+ (escaped ? code : escape(code, true))
|
|
1917
|
-
+ '</code></pre>\n';
|
|
1442
|
+
return "<pre><code>" + (escaped ? code : escape(code, true)) + "</code></pre>\n";
|
|
1918
1443
|
}
|
|
1919
|
-
|
|
1920
|
-
return '<pre><code class="'
|
|
1921
|
-
+ this.options.langPrefix
|
|
1922
|
-
+ escape(lang)
|
|
1923
|
-
+ '">'
|
|
1924
|
-
+ (escaped ? code : escape(code, true))
|
|
1925
|
-
+ '</code></pre>\n';
|
|
1444
|
+
return '<pre><code class="' + this.options.langPrefix + escape(lang) + '">' + (escaped ? code : escape(code, true)) + "</code></pre>\n";
|
|
1926
1445
|
}
|
|
1927
|
-
|
|
1928
|
-
/**
|
|
1929
|
-
* @param {string} quote
|
|
1930
|
-
*/
|
|
1931
1446
|
blockquote(quote) {
|
|
1932
|
-
return `<blockquote
|
|
1447
|
+
return `<blockquote>
|
|
1448
|
+
${quote}</blockquote>
|
|
1449
|
+
`;
|
|
1933
1450
|
}
|
|
1934
|
-
|
|
1935
|
-
html(html) {
|
|
1451
|
+
html(html, block2) {
|
|
1936
1452
|
return html;
|
|
1937
1453
|
}
|
|
1938
|
-
|
|
1939
|
-
/**
|
|
1940
|
-
* @param {string} text
|
|
1941
|
-
* @param {string} level
|
|
1942
|
-
* @param {string} raw
|
|
1943
|
-
* @param {any} slugger
|
|
1944
|
-
*/
|
|
1945
1454
|
heading(text, level, raw, slugger) {
|
|
1946
1455
|
if (this.options.headerIds) {
|
|
1947
1456
|
const id = this.options.headerPrefix + slugger.slug(raw);
|
|
1948
|
-
return `<h${level} id="${id}">${text}</h${level}
|
|
1457
|
+
return `<h${level} id="${id}">${text}</h${level}>
|
|
1458
|
+
`;
|
|
1949
1459
|
}
|
|
1950
|
-
|
|
1951
|
-
|
|
1952
|
-
return `<h${level}>${text}</h${level}>\n`;
|
|
1460
|
+
return `<h${level}>${text}</h${level}>
|
|
1461
|
+
`;
|
|
1953
1462
|
}
|
|
1954
|
-
|
|
1955
1463
|
hr() {
|
|
1956
|
-
return this.options.xhtml ?
|
|
1464
|
+
return this.options.xhtml ? "<hr/>\n" : "<hr>\n";
|
|
1957
1465
|
}
|
|
1958
|
-
|
|
1959
1466
|
list(body, ordered, start) {
|
|
1960
|
-
const type = ordered ?
|
|
1961
|
-
|
|
1962
|
-
return '<' + type + startatt + '>\n' + body + '</' + type + '>\n';
|
|
1467
|
+
const type = ordered ? "ol" : "ul", startatt = ordered && start !== 1 ? ' start="' + start + '"' : "";
|
|
1468
|
+
return "<" + type + startatt + ">\n" + body + "</" + type + ">\n";
|
|
1963
1469
|
}
|
|
1964
|
-
|
|
1965
|
-
|
|
1966
|
-
|
|
1967
|
-
*/
|
|
1968
|
-
listitem(text) {
|
|
1969
|
-
return `<li>${text}</li>\n`;
|
|
1470
|
+
listitem(text, task, checked) {
|
|
1471
|
+
return `<li>${text}</li>
|
|
1472
|
+
`;
|
|
1970
1473
|
}
|
|
1971
|
-
|
|
1972
1474
|
checkbox(checked) {
|
|
1973
|
-
return
|
|
1974
|
-
+ (checked ? 'checked="" ' : '')
|
|
1975
|
-
+ 'disabled="" type="checkbox"'
|
|
1976
|
-
+ (this.options.xhtml ? ' /' : '')
|
|
1977
|
-
+ '> ';
|
|
1475
|
+
return "<input " + (checked ? 'checked="" ' : "") + 'disabled="" type="checkbox"' + (this.options.xhtml ? " /" : "") + "> ";
|
|
1978
1476
|
}
|
|
1979
|
-
|
|
1980
|
-
/**
|
|
1981
|
-
* @param {string} text
|
|
1982
|
-
*/
|
|
1983
1477
|
paragraph(text) {
|
|
1984
|
-
return `<p>${text}</p
|
|
1478
|
+
return `<p>${text}</p>
|
|
1479
|
+
`;
|
|
1985
1480
|
}
|
|
1986
|
-
|
|
1987
|
-
/**
|
|
1988
|
-
* @param {string} header
|
|
1989
|
-
* @param {string} body
|
|
1990
|
-
*/
|
|
1991
1481
|
table(header, body) {
|
|
1992
|
-
if (body)
|
|
1993
|
-
|
|
1994
|
-
return
|
|
1995
|
-
+ '<thead>\n'
|
|
1996
|
-
+ header
|
|
1997
|
-
+ '</thead>\n'
|
|
1998
|
-
+ body
|
|
1999
|
-
+ '</table>\n';
|
|
1482
|
+
if (body)
|
|
1483
|
+
body = `<tbody>${body}</tbody>`;
|
|
1484
|
+
return "<table>\n<thead>\n" + header + "</thead>\n" + body + "</table>\n";
|
|
2000
1485
|
}
|
|
2001
|
-
|
|
2002
|
-
/**
|
|
2003
|
-
* @param {string} content
|
|
2004
|
-
*/
|
|
2005
1486
|
tablerow(content) {
|
|
2006
|
-
return `<tr
|
|
1487
|
+
return `<tr>
|
|
1488
|
+
${content}</tr>
|
|
1489
|
+
`;
|
|
2007
1490
|
}
|
|
2008
|
-
|
|
2009
1491
|
tablecell(content, flags) {
|
|
2010
|
-
const type = flags.header ?
|
|
2011
|
-
const tag = flags.align
|
|
2012
|
-
|
|
2013
|
-
|
|
2014
|
-
return tag + content + `</${type}>\n`;
|
|
1492
|
+
const type = flags.header ? "th" : "td";
|
|
1493
|
+
const tag = flags.align ? `<${type} align="${flags.align}">` : `<${type}>`;
|
|
1494
|
+
return tag + content + `</${type}>
|
|
1495
|
+
`;
|
|
2015
1496
|
}
|
|
2016
|
-
|
|
2017
1497
|
/**
|
|
2018
1498
|
* span level renderer
|
|
2019
|
-
* @param {string} text
|
|
2020
1499
|
*/
|
|
2021
1500
|
strong(text) {
|
|
2022
1501
|
return `<strong>${text}</strong>`;
|
|
2023
1502
|
}
|
|
2024
|
-
|
|
2025
|
-
/**
|
|
2026
|
-
* @param {string} text
|
|
2027
|
-
*/
|
|
2028
1503
|
em(text) {
|
|
2029
1504
|
return `<em>${text}</em>`;
|
|
2030
1505
|
}
|
|
2031
|
-
|
|
2032
|
-
/**
|
|
2033
|
-
* @param {string} text
|
|
2034
|
-
*/
|
|
2035
1506
|
codespan(text) {
|
|
2036
1507
|
return `<code>${text}</code>`;
|
|
2037
1508
|
}
|
|
2038
|
-
|
|
2039
1509
|
br() {
|
|
2040
|
-
return this.options.xhtml ?
|
|
1510
|
+
return this.options.xhtml ? "<br/>" : "<br>";
|
|
2041
1511
|
}
|
|
2042
|
-
|
|
2043
|
-
/**
|
|
2044
|
-
* @param {string} text
|
|
2045
|
-
*/
|
|
2046
1512
|
del(text) {
|
|
2047
1513
|
return `<del>${text}</del>`;
|
|
2048
1514
|
}
|
|
2049
|
-
|
|
2050
|
-
/**
|
|
2051
|
-
* @param {string} href
|
|
2052
|
-
* @param {string} title
|
|
2053
|
-
* @param {string} text
|
|
2054
|
-
*/
|
|
2055
1515
|
link(href, title, text) {
|
|
2056
1516
|
href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
|
|
2057
1517
|
if (href === null) {
|
|
@@ -2061,103 +1521,68 @@ class Renderer {
|
|
|
2061
1521
|
if (title) {
|
|
2062
1522
|
out += ' title="' + title + '"';
|
|
2063
1523
|
}
|
|
2064
|
-
out +=
|
|
1524
|
+
out += ">" + text + "</a>";
|
|
2065
1525
|
return out;
|
|
2066
1526
|
}
|
|
2067
|
-
|
|
2068
|
-
/**
|
|
2069
|
-
* @param {string} href
|
|
2070
|
-
* @param {string} title
|
|
2071
|
-
* @param {string} text
|
|
2072
|
-
*/
|
|
2073
1527
|
image(href, title, text) {
|
|
2074
1528
|
href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
|
|
2075
1529
|
if (href === null) {
|
|
2076
1530
|
return text;
|
|
2077
1531
|
}
|
|
2078
|
-
|
|
2079
1532
|
let out = `<img src="${href}" alt="${text}"`;
|
|
2080
1533
|
if (title) {
|
|
2081
1534
|
out += ` title="${title}"`;
|
|
2082
1535
|
}
|
|
2083
|
-
out += this.options.xhtml ?
|
|
1536
|
+
out += this.options.xhtml ? "/>" : ">";
|
|
2084
1537
|
return out;
|
|
2085
1538
|
}
|
|
2086
|
-
|
|
2087
1539
|
text(text) {
|
|
2088
1540
|
return text;
|
|
2089
1541
|
}
|
|
2090
|
-
}
|
|
1542
|
+
};
|
|
2091
1543
|
|
|
2092
|
-
|
|
2093
|
-
|
|
2094
|
-
* returns only the textual part of the token
|
|
2095
|
-
*/
|
|
2096
|
-
class TextRenderer {
|
|
1544
|
+
// src/TextRenderer.ts
|
|
1545
|
+
var _TextRenderer = class {
|
|
2097
1546
|
// no need for block level renderers
|
|
2098
1547
|
strong(text) {
|
|
2099
1548
|
return text;
|
|
2100
1549
|
}
|
|
2101
|
-
|
|
2102
1550
|
em(text) {
|
|
2103
1551
|
return text;
|
|
2104
1552
|
}
|
|
2105
|
-
|
|
2106
1553
|
codespan(text) {
|
|
2107
1554
|
return text;
|
|
2108
1555
|
}
|
|
2109
|
-
|
|
2110
1556
|
del(text) {
|
|
2111
1557
|
return text;
|
|
2112
1558
|
}
|
|
2113
|
-
|
|
2114
1559
|
html(text) {
|
|
2115
1560
|
return text;
|
|
2116
1561
|
}
|
|
2117
|
-
|
|
2118
1562
|
text(text) {
|
|
2119
1563
|
return text;
|
|
2120
1564
|
}
|
|
2121
|
-
|
|
2122
1565
|
link(href, title, text) {
|
|
2123
|
-
return
|
|
1566
|
+
return "" + text;
|
|
2124
1567
|
}
|
|
2125
|
-
|
|
2126
1568
|
image(href, title, text) {
|
|
2127
|
-
return
|
|
1569
|
+
return "" + text;
|
|
2128
1570
|
}
|
|
2129
|
-
|
|
2130
1571
|
br() {
|
|
2131
|
-
return
|
|
1572
|
+
return "";
|
|
2132
1573
|
}
|
|
2133
|
-
}
|
|
1574
|
+
};
|
|
2134
1575
|
|
|
2135
|
-
|
|
2136
|
-
|
|
2137
|
-
*/
|
|
2138
|
-
class Slugger {
|
|
1576
|
+
// src/Slugger.ts
|
|
1577
|
+
var _Slugger = class {
|
|
2139
1578
|
constructor() {
|
|
2140
1579
|
this.seen = {};
|
|
2141
1580
|
}
|
|
2142
|
-
|
|
2143
|
-
/**
|
|
2144
|
-
* @param {string} value
|
|
2145
|
-
*/
|
|
2146
1581
|
serialize(value) {
|
|
2147
|
-
return value
|
|
2148
|
-
.toLowerCase()
|
|
2149
|
-
.trim()
|
|
2150
|
-
// remove html tags
|
|
2151
|
-
.replace(/<[!\/a-z].*?>/ig, '')
|
|
2152
|
-
// remove unwanted chars
|
|
2153
|
-
.replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, '')
|
|
2154
|
-
.replace(/\s/g, '-');
|
|
1582
|
+
return value.toLowerCase().trim().replace(/<[!\/a-z].*?>/ig, "").replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, "").replace(/\s/g, "-");
|
|
2155
1583
|
}
|
|
2156
|
-
|
|
2157
1584
|
/**
|
|
2158
1585
|
* Finds the next safe (unique) slug to use
|
|
2159
|
-
* @param {string} originalSlug
|
|
2160
|
-
* @param {boolean} isDryRun
|
|
2161
1586
|
*/
|
|
2162
1587
|
getNextSafeSlug(originalSlug, isDryRun) {
|
|
2163
1588
|
let slug = originalSlug;
|
|
@@ -2166,7 +1591,7 @@ class Slugger {
|
|
|
2166
1591
|
occurenceAccumulator = this.seen[originalSlug];
|
|
2167
1592
|
do {
|
|
2168
1593
|
occurenceAccumulator++;
|
|
2169
|
-
slug = originalSlug +
|
|
1594
|
+
slug = originalSlug + "-" + occurenceAccumulator;
|
|
2170
1595
|
} while (this.seen.hasOwnProperty(slug));
|
|
2171
1596
|
}
|
|
2172
1597
|
if (!isDryRun) {
|
|
@@ -2175,113 +1600,82 @@ class Slugger {
|
|
|
2175
1600
|
}
|
|
2176
1601
|
return slug;
|
|
2177
1602
|
}
|
|
2178
|
-
|
|
2179
1603
|
/**
|
|
2180
1604
|
* Convert string to unique id
|
|
2181
|
-
* @param {object} [options]
|
|
2182
|
-
* @param {boolean} [options.dryrun] Generates the next unique slug without
|
|
2183
|
-
* updating the internal accumulator.
|
|
2184
1605
|
*/
|
|
2185
|
-
slug(value,
|
|
1606
|
+
slug(value, options2 = {}) {
|
|
2186
1607
|
const slug = this.serialize(value);
|
|
2187
|
-
return this.getNextSafeSlug(slug,
|
|
1608
|
+
return this.getNextSafeSlug(slug, options2.dryrun);
|
|
2188
1609
|
}
|
|
2189
|
-
}
|
|
1610
|
+
};
|
|
2190
1611
|
|
|
2191
|
-
|
|
2192
|
-
|
|
2193
|
-
|
|
2194
|
-
|
|
2195
|
-
|
|
2196
|
-
this.options = options || defaults;
|
|
2197
|
-
this.options.renderer = this.options.renderer || new Renderer();
|
|
1612
|
+
// src/Parser.ts
|
|
1613
|
+
var _Parser = class {
|
|
1614
|
+
constructor(options2) {
|
|
1615
|
+
this.options = options2 || _defaults;
|
|
1616
|
+
this.options.renderer = this.options.renderer || new _Renderer();
|
|
2198
1617
|
this.renderer = this.options.renderer;
|
|
2199
1618
|
this.renderer.options = this.options;
|
|
2200
|
-
this.textRenderer = new
|
|
2201
|
-
this.slugger = new
|
|
1619
|
+
this.textRenderer = new _TextRenderer();
|
|
1620
|
+
this.slugger = new _Slugger();
|
|
2202
1621
|
}
|
|
2203
|
-
|
|
2204
1622
|
/**
|
|
2205
1623
|
* Static Parse Method
|
|
2206
1624
|
*/
|
|
2207
|
-
static parse(tokens,
|
|
2208
|
-
const
|
|
2209
|
-
return
|
|
1625
|
+
static parse(tokens, options2) {
|
|
1626
|
+
const parser2 = new _Parser(options2);
|
|
1627
|
+
return parser2.parse(tokens);
|
|
2210
1628
|
}
|
|
2211
|
-
|
|
2212
1629
|
/**
|
|
2213
1630
|
* Static Parse Inline Method
|
|
2214
1631
|
*/
|
|
2215
|
-
static parseInline(tokens,
|
|
2216
|
-
const
|
|
2217
|
-
return
|
|
1632
|
+
static parseInline(tokens, options2) {
|
|
1633
|
+
const parser2 = new _Parser(options2);
|
|
1634
|
+
return parser2.parseInline(tokens);
|
|
2218
1635
|
}
|
|
2219
|
-
|
|
2220
1636
|
/**
|
|
2221
1637
|
* Parse Loop
|
|
2222
1638
|
*/
|
|
2223
1639
|
parse(tokens, top = true) {
|
|
2224
|
-
let out =
|
|
2225
|
-
i,
|
|
2226
|
-
j,
|
|
2227
|
-
k,
|
|
2228
|
-
l2,
|
|
2229
|
-
l3,
|
|
2230
|
-
row,
|
|
2231
|
-
cell,
|
|
2232
|
-
header,
|
|
2233
|
-
body,
|
|
2234
|
-
token,
|
|
2235
|
-
ordered,
|
|
2236
|
-
start,
|
|
2237
|
-
loose,
|
|
2238
|
-
itemBody,
|
|
2239
|
-
item,
|
|
2240
|
-
checked,
|
|
2241
|
-
task,
|
|
2242
|
-
checkbox,
|
|
2243
|
-
ret;
|
|
2244
|
-
|
|
1640
|
+
let out = "", i, j, k, l2, l3, row, cell, header, body, token, ordered, start, loose, itemBody, item, checked, task, checkbox, ret;
|
|
2245
1641
|
const l = tokens.length;
|
|
2246
1642
|
for (i = 0; i < l; i++) {
|
|
2247
1643
|
token = tokens[i];
|
|
2248
|
-
|
|
2249
|
-
// Run any renderer extensions
|
|
2250
1644
|
if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
|
|
2251
1645
|
ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
|
|
2252
|
-
if (ret !== false || ![
|
|
2253
|
-
out += ret ||
|
|
1646
|
+
if (ret !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(token.type)) {
|
|
1647
|
+
out += ret || "";
|
|
2254
1648
|
continue;
|
|
2255
1649
|
}
|
|
2256
1650
|
}
|
|
2257
|
-
|
|
2258
1651
|
switch (token.type) {
|
|
2259
|
-
case
|
|
1652
|
+
case "space": {
|
|
2260
1653
|
continue;
|
|
2261
1654
|
}
|
|
2262
|
-
case
|
|
1655
|
+
case "hr": {
|
|
2263
1656
|
out += this.renderer.hr();
|
|
2264
1657
|
continue;
|
|
2265
1658
|
}
|
|
2266
|
-
case
|
|
1659
|
+
case "heading": {
|
|
2267
1660
|
out += this.renderer.heading(
|
|
2268
1661
|
this.parseInline(token.tokens),
|
|
2269
1662
|
token.depth,
|
|
2270
1663
|
unescape(this.parseInline(token.tokens, this.textRenderer)),
|
|
2271
|
-
this.slugger
|
|
1664
|
+
this.slugger
|
|
1665
|
+
);
|
|
2272
1666
|
continue;
|
|
2273
1667
|
}
|
|
2274
|
-
case
|
|
2275
|
-
out += this.renderer.code(
|
|
1668
|
+
case "code": {
|
|
1669
|
+
out += this.renderer.code(
|
|
1670
|
+
token.text,
|
|
2276
1671
|
token.lang,
|
|
2277
|
-
token.escaped
|
|
1672
|
+
!!token.escaped
|
|
1673
|
+
);
|
|
2278
1674
|
continue;
|
|
2279
1675
|
}
|
|
2280
|
-
case
|
|
2281
|
-
header =
|
|
2282
|
-
|
|
2283
|
-
// header
|
|
2284
|
-
cell = '';
|
|
1676
|
+
case "table": {
|
|
1677
|
+
header = "";
|
|
1678
|
+
cell = "";
|
|
2285
1679
|
l2 = token.header.length;
|
|
2286
1680
|
for (j = 0; j < l2; j++) {
|
|
2287
1681
|
cell += this.renderer.tablecell(
|
|
@@ -2290,13 +1684,11 @@ class Parser {
|
|
|
2290
1684
|
);
|
|
2291
1685
|
}
|
|
2292
1686
|
header += this.renderer.tablerow(cell);
|
|
2293
|
-
|
|
2294
|
-
body = '';
|
|
1687
|
+
body = "";
|
|
2295
1688
|
l2 = token.rows.length;
|
|
2296
1689
|
for (j = 0; j < l2; j++) {
|
|
2297
1690
|
row = token.rows[j];
|
|
2298
|
-
|
|
2299
|
-
cell = '';
|
|
1691
|
+
cell = "";
|
|
2300
1692
|
l3 = row.length;
|
|
2301
1693
|
for (k = 0; k < l3; k++) {
|
|
2302
1694
|
cell += this.renderer.tablecell(
|
|
@@ -2304,41 +1696,38 @@ class Parser {
|
|
|
2304
1696
|
{ header: false, align: token.align[k] }
|
|
2305
1697
|
);
|
|
2306
1698
|
}
|
|
2307
|
-
|
|
2308
1699
|
body += this.renderer.tablerow(cell);
|
|
2309
1700
|
}
|
|
2310
1701
|
out += this.renderer.table(header, body);
|
|
2311
1702
|
continue;
|
|
2312
1703
|
}
|
|
2313
|
-
case
|
|
1704
|
+
case "blockquote": {
|
|
2314
1705
|
body = this.parse(token.tokens);
|
|
2315
1706
|
out += this.renderer.blockquote(body);
|
|
2316
1707
|
continue;
|
|
2317
1708
|
}
|
|
2318
|
-
case
|
|
1709
|
+
case "list": {
|
|
2319
1710
|
ordered = token.ordered;
|
|
2320
1711
|
start = token.start;
|
|
2321
1712
|
loose = token.loose;
|
|
2322
1713
|
l2 = token.items.length;
|
|
2323
|
-
|
|
2324
|
-
body = '';
|
|
1714
|
+
body = "";
|
|
2325
1715
|
for (j = 0; j < l2; j++) {
|
|
2326
1716
|
item = token.items[j];
|
|
2327
1717
|
checked = item.checked;
|
|
2328
1718
|
task = item.task;
|
|
2329
|
-
|
|
2330
|
-
itemBody = '';
|
|
1719
|
+
itemBody = "";
|
|
2331
1720
|
if (item.task) {
|
|
2332
|
-
checkbox = this.renderer.checkbox(checked);
|
|
1721
|
+
checkbox = this.renderer.checkbox(!!checked);
|
|
2333
1722
|
if (loose) {
|
|
2334
|
-
if (item.tokens.length > 0 && item.tokens[0].type ===
|
|
2335
|
-
item.tokens[0].text = checkbox +
|
|
2336
|
-
if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type ===
|
|
2337
|
-
item.tokens[0].tokens[0].text = checkbox +
|
|
1723
|
+
if (item.tokens.length > 0 && item.tokens[0].type === "paragraph") {
|
|
1724
|
+
item.tokens[0].text = checkbox + " " + item.tokens[0].text;
|
|
1725
|
+
if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === "text") {
|
|
1726
|
+
item.tokens[0].tokens[0].text = checkbox + " " + item.tokens[0].tokens[0].text;
|
|
2338
1727
|
}
|
|
2339
1728
|
} else {
|
|
2340
1729
|
item.tokens.unshift({
|
|
2341
|
-
type:
|
|
1730
|
+
type: "text",
|
|
2342
1731
|
text: checkbox
|
|
2343
1732
|
});
|
|
2344
1733
|
}
|
|
@@ -2346,109 +1735,96 @@ class Parser {
|
|
|
2346
1735
|
itemBody += checkbox;
|
|
2347
1736
|
}
|
|
2348
1737
|
}
|
|
2349
|
-
|
|
2350
1738
|
itemBody += this.parse(item.tokens, loose);
|
|
2351
|
-
body += this.renderer.listitem(itemBody, task, checked);
|
|
1739
|
+
body += this.renderer.listitem(itemBody, task, !!checked);
|
|
2352
1740
|
}
|
|
2353
|
-
|
|
2354
1741
|
out += this.renderer.list(body, ordered, start);
|
|
2355
1742
|
continue;
|
|
2356
1743
|
}
|
|
2357
|
-
case
|
|
2358
|
-
|
|
2359
|
-
out += this.renderer.html(token.text);
|
|
1744
|
+
case "html": {
|
|
1745
|
+
out += this.renderer.html(token.text, token.block);
|
|
2360
1746
|
continue;
|
|
2361
1747
|
}
|
|
2362
|
-
case
|
|
1748
|
+
case "paragraph": {
|
|
2363
1749
|
out += this.renderer.paragraph(this.parseInline(token.tokens));
|
|
2364
1750
|
continue;
|
|
2365
1751
|
}
|
|
2366
|
-
case
|
|
1752
|
+
case "text": {
|
|
2367
1753
|
body = token.tokens ? this.parseInline(token.tokens) : token.text;
|
|
2368
|
-
while (i + 1 < l && tokens[i + 1].type ===
|
|
1754
|
+
while (i + 1 < l && tokens[i + 1].type === "text") {
|
|
2369
1755
|
token = tokens[++i];
|
|
2370
|
-
body +=
|
|
1756
|
+
body += "\n" + (token.tokens ? this.parseInline(token.tokens) : token.text);
|
|
2371
1757
|
}
|
|
2372
1758
|
out += top ? this.renderer.paragraph(body) : body;
|
|
2373
1759
|
continue;
|
|
2374
1760
|
}
|
|
2375
|
-
|
|
2376
1761
|
default: {
|
|
2377
1762
|
const errMsg = 'Token with "' + token.type + '" type was not found.';
|
|
2378
1763
|
if (this.options.silent) {
|
|
2379
1764
|
console.error(errMsg);
|
|
2380
|
-
return;
|
|
1765
|
+
return "";
|
|
2381
1766
|
} else {
|
|
2382
1767
|
throw new Error(errMsg);
|
|
2383
1768
|
}
|
|
2384
1769
|
}
|
|
2385
1770
|
}
|
|
2386
1771
|
}
|
|
2387
|
-
|
|
2388
1772
|
return out;
|
|
2389
1773
|
}
|
|
2390
|
-
|
|
2391
1774
|
/**
|
|
2392
1775
|
* Parse Inline Tokens
|
|
2393
1776
|
*/
|
|
2394
1777
|
parseInline(tokens, renderer) {
|
|
2395
1778
|
renderer = renderer || this.renderer;
|
|
2396
|
-
let out =
|
|
2397
|
-
i,
|
|
2398
|
-
token,
|
|
2399
|
-
ret;
|
|
2400
|
-
|
|
1779
|
+
let out = "", i, token, ret;
|
|
2401
1780
|
const l = tokens.length;
|
|
2402
1781
|
for (i = 0; i < l; i++) {
|
|
2403
1782
|
token = tokens[i];
|
|
2404
|
-
|
|
2405
|
-
// Run any renderer extensions
|
|
2406
1783
|
if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
|
|
2407
1784
|
ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
|
|
2408
|
-
if (ret !== false || ![
|
|
2409
|
-
out += ret ||
|
|
1785
|
+
if (ret !== false || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(token.type)) {
|
|
1786
|
+
out += ret || "";
|
|
2410
1787
|
continue;
|
|
2411
1788
|
}
|
|
2412
1789
|
}
|
|
2413
|
-
|
|
2414
1790
|
switch (token.type) {
|
|
2415
|
-
case
|
|
1791
|
+
case "escape": {
|
|
2416
1792
|
out += renderer.text(token.text);
|
|
2417
1793
|
break;
|
|
2418
1794
|
}
|
|
2419
|
-
case
|
|
1795
|
+
case "html": {
|
|
2420
1796
|
out += renderer.html(token.text);
|
|
2421
1797
|
break;
|
|
2422
1798
|
}
|
|
2423
|
-
case
|
|
1799
|
+
case "link": {
|
|
2424
1800
|
out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer));
|
|
2425
1801
|
break;
|
|
2426
1802
|
}
|
|
2427
|
-
case
|
|
1803
|
+
case "image": {
|
|
2428
1804
|
out += renderer.image(token.href, token.title, token.text);
|
|
2429
1805
|
break;
|
|
2430
1806
|
}
|
|
2431
|
-
case
|
|
1807
|
+
case "strong": {
|
|
2432
1808
|
out += renderer.strong(this.parseInline(token.tokens, renderer));
|
|
2433
1809
|
break;
|
|
2434
1810
|
}
|
|
2435
|
-
case
|
|
1811
|
+
case "em": {
|
|
2436
1812
|
out += renderer.em(this.parseInline(token.tokens, renderer));
|
|
2437
1813
|
break;
|
|
2438
1814
|
}
|
|
2439
|
-
case
|
|
1815
|
+
case "codespan": {
|
|
2440
1816
|
out += renderer.codespan(token.text);
|
|
2441
1817
|
break;
|
|
2442
1818
|
}
|
|
2443
|
-
case
|
|
1819
|
+
case "br": {
|
|
2444
1820
|
out += renderer.br();
|
|
2445
1821
|
break;
|
|
2446
1822
|
}
|
|
2447
|
-
case
|
|
1823
|
+
case "del": {
|
|
2448
1824
|
out += renderer.del(this.parseInline(token.tokens, renderer));
|
|
2449
1825
|
break;
|
|
2450
1826
|
}
|
|
2451
|
-
case
|
|
1827
|
+
case "text": {
|
|
2452
1828
|
out += renderer.text(token.text);
|
|
2453
1829
|
break;
|
|
2454
1830
|
}
|
|
@@ -2456,7 +1832,7 @@ class Parser {
|
|
|
2456
1832
|
const errMsg = 'Token with "' + token.type + '" type was not found.';
|
|
2457
1833
|
if (this.options.silent) {
|
|
2458
1834
|
console.error(errMsg);
|
|
2459
|
-
return;
|
|
1835
|
+
return "";
|
|
2460
1836
|
} else {
|
|
2461
1837
|
throw new Error(errMsg);
|
|
2462
1838
|
}
|
|
@@ -2465,110 +1841,256 @@ class Parser {
|
|
|
2465
1841
|
}
|
|
2466
1842
|
return out;
|
|
2467
1843
|
}
|
|
2468
|
-
}
|
|
1844
|
+
};
|
|
2469
1845
|
|
|
2470
|
-
|
|
2471
|
-
|
|
2472
|
-
|
|
1846
|
+
// src/Hooks.ts
|
|
1847
|
+
var _Hooks = class {
|
|
1848
|
+
constructor(options2) {
|
|
1849
|
+
this.options = options2 || _defaults;
|
|
2473
1850
|
}
|
|
2474
|
-
|
|
2475
|
-
static passThroughHooks = new Set([
|
|
2476
|
-
'preprocess',
|
|
2477
|
-
'postprocess'
|
|
2478
|
-
]);
|
|
2479
|
-
|
|
2480
1851
|
/**
|
|
2481
1852
|
* Process markdown before marked
|
|
2482
1853
|
*/
|
|
2483
1854
|
preprocess(markdown) {
|
|
2484
1855
|
return markdown;
|
|
2485
1856
|
}
|
|
2486
|
-
|
|
2487
1857
|
/**
|
|
2488
1858
|
* Process HTML after marked is finished
|
|
2489
1859
|
*/
|
|
2490
1860
|
postprocess(html) {
|
|
2491
1861
|
return html;
|
|
2492
1862
|
}
|
|
2493
|
-
}
|
|
2494
|
-
|
|
2495
|
-
|
|
2496
|
-
|
|
2497
|
-
|
|
2498
|
-
|
|
2499
|
-
|
|
2500
|
-
|
|
2501
|
-
|
|
2502
|
-
|
|
2503
|
-
|
|
2504
|
-
|
|
2505
|
-
|
|
2506
|
-
|
|
2507
|
-
|
|
2508
|
-
|
|
1863
|
+
};
|
|
1864
|
+
_Hooks.passThroughHooks = /* @__PURE__ */ new Set([
|
|
1865
|
+
"preprocess",
|
|
1866
|
+
"postprocess"
|
|
1867
|
+
]);
|
|
1868
|
+
|
|
1869
|
+
// src/Instance.ts
|
|
1870
|
+
var _parseMarkdown, parseMarkdown_fn, _onError, onError_fn;
|
|
1871
|
+
var Marked = class {
|
|
1872
|
+
constructor(...args) {
|
|
1873
|
+
__privateAdd(this, _parseMarkdown);
|
|
1874
|
+
__privateAdd(this, _onError);
|
|
1875
|
+
this.defaults = _getDefaults();
|
|
1876
|
+
this.options = this.setOptions;
|
|
1877
|
+
this.parse = __privateMethod(this, _parseMarkdown, parseMarkdown_fn).call(this, _Lexer.lex, _Parser.parse);
|
|
1878
|
+
this.parseInline = __privateMethod(this, _parseMarkdown, parseMarkdown_fn).call(this, _Lexer.lexInline, _Parser.parseInline);
|
|
1879
|
+
this.Parser = _Parser;
|
|
1880
|
+
this.parser = _Parser.parse;
|
|
1881
|
+
this.Renderer = _Renderer;
|
|
1882
|
+
this.TextRenderer = _TextRenderer;
|
|
1883
|
+
this.Lexer = _Lexer;
|
|
1884
|
+
this.lexer = _Lexer.lex;
|
|
1885
|
+
this.Tokenizer = _Tokenizer;
|
|
1886
|
+
this.Slugger = _Slugger;
|
|
1887
|
+
this.Hooks = _Hooks;
|
|
1888
|
+
this.use(...args);
|
|
1889
|
+
}
|
|
1890
|
+
/**
|
|
1891
|
+
* Run callback for every token
|
|
1892
|
+
*/
|
|
1893
|
+
walkTokens(tokens, callback) {
|
|
1894
|
+
let values = [];
|
|
1895
|
+
for (const token of tokens) {
|
|
1896
|
+
values = values.concat(callback.call(this, token));
|
|
1897
|
+
switch (token.type) {
|
|
1898
|
+
case "table": {
|
|
1899
|
+
for (const cell of token.header) {
|
|
1900
|
+
values = values.concat(this.walkTokens(cell.tokens, callback));
|
|
1901
|
+
}
|
|
1902
|
+
for (const row of token.rows) {
|
|
1903
|
+
for (const cell of row) {
|
|
1904
|
+
values = values.concat(this.walkTokens(cell.tokens, callback));
|
|
1905
|
+
}
|
|
1906
|
+
}
|
|
1907
|
+
break;
|
|
1908
|
+
}
|
|
1909
|
+
case "list": {
|
|
1910
|
+
values = values.concat(this.walkTokens(token.items, callback));
|
|
1911
|
+
break;
|
|
1912
|
+
}
|
|
1913
|
+
default: {
|
|
1914
|
+
if (this.defaults.extensions && this.defaults.extensions.childTokens && this.defaults.extensions.childTokens[token.type]) {
|
|
1915
|
+
this.defaults.extensions.childTokens[token.type].forEach((childTokens) => {
|
|
1916
|
+
values = values.concat(this.walkTokens(token[childTokens], callback));
|
|
1917
|
+
});
|
|
1918
|
+
} else if (token.tokens) {
|
|
1919
|
+
values = values.concat(this.walkTokens(token.tokens, callback));
|
|
1920
|
+
}
|
|
1921
|
+
}
|
|
2509
1922
|
}
|
|
2510
|
-
return msg;
|
|
2511
|
-
}
|
|
2512
|
-
|
|
2513
|
-
if (async) {
|
|
2514
|
-
return Promise.reject(e);
|
|
2515
|
-
}
|
|
2516
|
-
if (callback) {
|
|
2517
|
-
callback(e);
|
|
2518
|
-
return;
|
|
2519
|
-
}
|
|
2520
|
-
throw e;
|
|
2521
|
-
};
|
|
2522
|
-
}
|
|
2523
|
-
|
|
2524
|
-
function parseMarkdown(lexer, parser) {
|
|
2525
|
-
return (src, opt, callback) => {
|
|
2526
|
-
if (typeof opt === 'function') {
|
|
2527
|
-
callback = opt;
|
|
2528
|
-
opt = null;
|
|
2529
|
-
}
|
|
2530
|
-
|
|
2531
|
-
const origOpt = { ...opt };
|
|
2532
|
-
opt = { ...marked.defaults, ...origOpt };
|
|
2533
|
-
const throwError = onError(opt.silent, opt.async, callback);
|
|
2534
|
-
|
|
2535
|
-
// throw error in case of non string input
|
|
2536
|
-
if (typeof src === 'undefined' || src === null) {
|
|
2537
|
-
return throwError(new Error('marked(): input parameter is undefined or null'));
|
|
2538
|
-
}
|
|
2539
|
-
if (typeof src !== 'string') {
|
|
2540
|
-
return throwError(new Error('marked(): input parameter is of type '
|
|
2541
|
-
+ Object.prototype.toString.call(src) + ', string expected'));
|
|
2542
1923
|
}
|
|
2543
|
-
|
|
2544
|
-
|
|
2545
|
-
|
|
1924
|
+
return values;
|
|
1925
|
+
}
|
|
1926
|
+
use(...args) {
|
|
1927
|
+
const extensions = this.defaults.extensions || { renderers: {}, childTokens: {} };
|
|
1928
|
+
args.forEach((pack) => {
|
|
1929
|
+
const opts = { ...pack };
|
|
1930
|
+
opts.async = this.defaults.async || opts.async || false;
|
|
1931
|
+
if (pack.extensions) {
|
|
1932
|
+
pack.extensions.forEach((ext) => {
|
|
1933
|
+
if (!ext.name) {
|
|
1934
|
+
throw new Error("extension name required");
|
|
1935
|
+
}
|
|
1936
|
+
if ("renderer" in ext) {
|
|
1937
|
+
const prevRenderer = extensions.renderers[ext.name];
|
|
1938
|
+
if (prevRenderer) {
|
|
1939
|
+
extensions.renderers[ext.name] = function(...args2) {
|
|
1940
|
+
let ret = ext.renderer.apply(this, args2);
|
|
1941
|
+
if (ret === false) {
|
|
1942
|
+
ret = prevRenderer.apply(this, args2);
|
|
1943
|
+
}
|
|
1944
|
+
return ret;
|
|
1945
|
+
};
|
|
1946
|
+
} else {
|
|
1947
|
+
extensions.renderers[ext.name] = ext.renderer;
|
|
1948
|
+
}
|
|
1949
|
+
}
|
|
1950
|
+
if ("tokenizer" in ext) {
|
|
1951
|
+
if (!ext.level || ext.level !== "block" && ext.level !== "inline") {
|
|
1952
|
+
throw new Error("extension level must be 'block' or 'inline'");
|
|
1953
|
+
}
|
|
1954
|
+
if (extensions[ext.level]) {
|
|
1955
|
+
extensions[ext.level].unshift(ext.tokenizer);
|
|
1956
|
+
} else {
|
|
1957
|
+
extensions[ext.level] = [ext.tokenizer];
|
|
1958
|
+
}
|
|
1959
|
+
if (ext.start) {
|
|
1960
|
+
if (ext.level === "block") {
|
|
1961
|
+
if (extensions.startBlock) {
|
|
1962
|
+
extensions.startBlock.push(ext.start);
|
|
1963
|
+
} else {
|
|
1964
|
+
extensions.startBlock = [ext.start];
|
|
1965
|
+
}
|
|
1966
|
+
} else if (ext.level === "inline") {
|
|
1967
|
+
if (extensions.startInline) {
|
|
1968
|
+
extensions.startInline.push(ext.start);
|
|
1969
|
+
} else {
|
|
1970
|
+
extensions.startInline = [ext.start];
|
|
1971
|
+
}
|
|
1972
|
+
}
|
|
1973
|
+
}
|
|
1974
|
+
}
|
|
1975
|
+
if ("childTokens" in ext && ext.childTokens) {
|
|
1976
|
+
extensions.childTokens[ext.name] = ext.childTokens;
|
|
1977
|
+
}
|
|
1978
|
+
});
|
|
1979
|
+
opts.extensions = extensions;
|
|
1980
|
+
}
|
|
1981
|
+
if (pack.renderer) {
|
|
1982
|
+
const renderer = this.defaults.renderer || new _Renderer(this.defaults);
|
|
1983
|
+
for (const prop in pack.renderer) {
|
|
1984
|
+
const prevRenderer = renderer[prop];
|
|
1985
|
+
renderer[prop] = (...args2) => {
|
|
1986
|
+
let ret = pack.renderer[prop].apply(renderer, args2);
|
|
1987
|
+
if (ret === false) {
|
|
1988
|
+
ret = prevRenderer.apply(renderer, args2);
|
|
1989
|
+
}
|
|
1990
|
+
return ret;
|
|
1991
|
+
};
|
|
1992
|
+
}
|
|
1993
|
+
opts.renderer = renderer;
|
|
1994
|
+
}
|
|
1995
|
+
if (pack.tokenizer) {
|
|
1996
|
+
const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);
|
|
1997
|
+
for (const prop in pack.tokenizer) {
|
|
1998
|
+
const prevTokenizer = tokenizer[prop];
|
|
1999
|
+
tokenizer[prop] = (...args2) => {
|
|
2000
|
+
let ret = pack.tokenizer[prop].apply(tokenizer, args2);
|
|
2001
|
+
if (ret === false) {
|
|
2002
|
+
ret = prevTokenizer.apply(tokenizer, args2);
|
|
2003
|
+
}
|
|
2004
|
+
return ret;
|
|
2005
|
+
};
|
|
2006
|
+
}
|
|
2007
|
+
opts.tokenizer = tokenizer;
|
|
2008
|
+
}
|
|
2009
|
+
if (pack.hooks) {
|
|
2010
|
+
const hooks = this.defaults.hooks || new _Hooks();
|
|
2011
|
+
for (const prop in pack.hooks) {
|
|
2012
|
+
const prevHook = hooks[prop];
|
|
2013
|
+
if (_Hooks.passThroughHooks.has(prop)) {
|
|
2014
|
+
hooks[prop] = (arg) => {
|
|
2015
|
+
if (this.defaults.async) {
|
|
2016
|
+
return Promise.resolve(pack.hooks[prop].call(hooks, arg)).then((ret2) => {
|
|
2017
|
+
return prevHook.call(hooks, ret2);
|
|
2018
|
+
});
|
|
2019
|
+
}
|
|
2020
|
+
const ret = pack.hooks[prop].call(hooks, arg);
|
|
2021
|
+
return prevHook.call(hooks, ret);
|
|
2022
|
+
};
|
|
2023
|
+
} else {
|
|
2024
|
+
hooks[prop] = (...args2) => {
|
|
2025
|
+
let ret = pack.hooks[prop].apply(hooks, args2);
|
|
2026
|
+
if (ret === false) {
|
|
2027
|
+
ret = prevHook.apply(hooks, args2);
|
|
2028
|
+
}
|
|
2029
|
+
return ret;
|
|
2030
|
+
};
|
|
2031
|
+
}
|
|
2032
|
+
}
|
|
2033
|
+
opts.hooks = hooks;
|
|
2034
|
+
}
|
|
2035
|
+
if (pack.walkTokens) {
|
|
2036
|
+
const walkTokens2 = this.defaults.walkTokens;
|
|
2037
|
+
opts.walkTokens = function(token) {
|
|
2038
|
+
let values = [];
|
|
2039
|
+
values.push(pack.walkTokens.call(this, token));
|
|
2040
|
+
if (walkTokens2) {
|
|
2041
|
+
values = values.concat(walkTokens2.call(this, token));
|
|
2042
|
+
}
|
|
2043
|
+
return values;
|
|
2044
|
+
};
|
|
2045
|
+
}
|
|
2046
|
+
this.defaults = { ...this.defaults, ...opts };
|
|
2047
|
+
});
|
|
2048
|
+
return this;
|
|
2049
|
+
}
|
|
2050
|
+
setOptions(opt) {
|
|
2051
|
+
this.defaults = { ...this.defaults, ...opt };
|
|
2052
|
+
return this;
|
|
2053
|
+
}
|
|
2054
|
+
};
|
|
2055
|
+
_parseMarkdown = new WeakSet();
|
|
2056
|
+
parseMarkdown_fn = function(lexer2, parser2) {
|
|
2057
|
+
return (src, optOrCallback, callback) => {
|
|
2058
|
+
if (typeof optOrCallback === "function") {
|
|
2059
|
+
callback = optOrCallback;
|
|
2060
|
+
optOrCallback = null;
|
|
2061
|
+
}
|
|
2062
|
+
const origOpt = { ...optOrCallback };
|
|
2063
|
+
const opt = { ...this.defaults, ...origOpt };
|
|
2064
|
+
const throwError = __privateMethod(this, _onError, onError_fn).call(this, !!opt.silent, !!opt.async, callback);
|
|
2065
|
+
if (typeof src === "undefined" || src === null) {
|
|
2066
|
+
return throwError(new Error("marked(): input parameter is undefined or null"));
|
|
2067
|
+
}
|
|
2068
|
+
if (typeof src !== "string") {
|
|
2069
|
+
return throwError(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(src) + ", string expected"));
|
|
2070
|
+
}
|
|
2071
|
+
checkDeprecations(opt, callback);
|
|
2546
2072
|
if (opt.hooks) {
|
|
2547
2073
|
opt.hooks.options = opt;
|
|
2548
2074
|
}
|
|
2549
|
-
|
|
2550
2075
|
if (callback) {
|
|
2551
2076
|
const highlight = opt.highlight;
|
|
2552
2077
|
let tokens;
|
|
2553
|
-
|
|
2554
2078
|
try {
|
|
2555
2079
|
if (opt.hooks) {
|
|
2556
2080
|
src = opt.hooks.preprocess(src);
|
|
2557
2081
|
}
|
|
2558
|
-
tokens =
|
|
2082
|
+
tokens = lexer2(src, opt);
|
|
2559
2083
|
} catch (e) {
|
|
2560
2084
|
return throwError(e);
|
|
2561
2085
|
}
|
|
2562
|
-
|
|
2563
|
-
const done = function(err) {
|
|
2086
|
+
const done = (err) => {
|
|
2564
2087
|
let out;
|
|
2565
|
-
|
|
2566
2088
|
if (!err) {
|
|
2567
2089
|
try {
|
|
2568
2090
|
if (opt.walkTokens) {
|
|
2569
|
-
|
|
2091
|
+
this.walkTokens(tokens, opt.walkTokens);
|
|
2570
2092
|
}
|
|
2571
|
-
out =
|
|
2093
|
+
out = parser2(tokens, opt);
|
|
2572
2094
|
if (opt.hooks) {
|
|
2573
2095
|
out = opt.hooks.postprocess(out);
|
|
2574
2096
|
}
|
|
@@ -2576,28 +2098,21 @@ function parseMarkdown(lexer, parser) {
|
|
|
2576
2098
|
err = e;
|
|
2577
2099
|
}
|
|
2578
2100
|
}
|
|
2579
|
-
|
|
2580
2101
|
opt.highlight = highlight;
|
|
2581
|
-
|
|
2582
|
-
return err
|
|
2583
|
-
? throwError(err)
|
|
2584
|
-
: callback(null, out);
|
|
2102
|
+
return err ? throwError(err) : callback(null, out);
|
|
2585
2103
|
};
|
|
2586
|
-
|
|
2587
2104
|
if (!highlight || highlight.length < 3) {
|
|
2588
2105
|
return done();
|
|
2589
2106
|
}
|
|
2590
|
-
|
|
2591
2107
|
delete opt.highlight;
|
|
2592
|
-
|
|
2593
|
-
|
|
2594
|
-
|
|
2108
|
+
if (!tokens.length)
|
|
2109
|
+
return done();
|
|
2595
2110
|
let pending = 0;
|
|
2596
|
-
|
|
2597
|
-
if (token.type ===
|
|
2111
|
+
this.walkTokens(tokens, (token) => {
|
|
2112
|
+
if (token.type === "code") {
|
|
2598
2113
|
pending++;
|
|
2599
2114
|
setTimeout(() => {
|
|
2600
|
-
highlight(token.text, token.lang,
|
|
2115
|
+
highlight(token.text, token.lang, (err, code) => {
|
|
2601
2116
|
if (err) {
|
|
2602
2117
|
return done(err);
|
|
2603
2118
|
}
|
|
@@ -2605,7 +2120,6 @@ function parseMarkdown(lexer, parser) {
|
|
|
2605
2120
|
token.text = code;
|
|
2606
2121
|
token.escaped = true;
|
|
2607
2122
|
}
|
|
2608
|
-
|
|
2609
2123
|
pending--;
|
|
2610
2124
|
if (pending === 0) {
|
|
2611
2125
|
done();
|
|
@@ -2614,32 +2128,23 @@ function parseMarkdown(lexer, parser) {
|
|
|
2614
2128
|
}, 0);
|
|
2615
2129
|
}
|
|
2616
2130
|
});
|
|
2617
|
-
|
|
2618
2131
|
if (pending === 0) {
|
|
2619
2132
|
done();
|
|
2620
2133
|
}
|
|
2621
|
-
|
|
2622
2134
|
return;
|
|
2623
2135
|
}
|
|
2624
|
-
|
|
2625
2136
|
if (opt.async) {
|
|
2626
|
-
return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src)
|
|
2627
|
-
.then(src => lexer(src, opt))
|
|
2628
|
-
.then(tokens => opt.walkTokens ? Promise.all(marked.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens)
|
|
2629
|
-
.then(tokens => parser(tokens, opt))
|
|
2630
|
-
.then(html => opt.hooks ? opt.hooks.postprocess(html) : html)
|
|
2631
|
-
.catch(throwError);
|
|
2137
|
+
return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then((src2) => lexer2(src2, opt)).then((tokens) => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens).then((tokens) => parser2(tokens, opt)).then((html) => opt.hooks ? opt.hooks.postprocess(html) : html).catch(throwError);
|
|
2632
2138
|
}
|
|
2633
|
-
|
|
2634
2139
|
try {
|
|
2635
2140
|
if (opt.hooks) {
|
|
2636
2141
|
src = opt.hooks.preprocess(src);
|
|
2637
2142
|
}
|
|
2638
|
-
const tokens =
|
|
2143
|
+
const tokens = lexer2(src, opt);
|
|
2639
2144
|
if (opt.walkTokens) {
|
|
2640
|
-
|
|
2145
|
+
this.walkTokens(tokens, opt.walkTokens);
|
|
2641
2146
|
}
|
|
2642
|
-
let html =
|
|
2147
|
+
let html = parser2(tokens, opt);
|
|
2643
2148
|
if (opt.hooks) {
|
|
2644
2149
|
html = opt.hooks.postprocess(html);
|
|
2645
2150
|
}
|
|
@@ -2648,240 +2153,73 @@ function parseMarkdown(lexer, parser) {
|
|
|
2648
2153
|
return throwError(e);
|
|
2649
2154
|
}
|
|
2650
2155
|
};
|
|
2651
|
-
}
|
|
2652
|
-
|
|
2653
|
-
/**
|
|
2654
|
-
* Marked
|
|
2655
|
-
*/
|
|
2656
|
-
function marked(src, opt, callback) {
|
|
2657
|
-
return parseMarkdown(Lexer.lex, Parser.parse)(src, opt, callback);
|
|
2658
|
-
}
|
|
2659
|
-
|
|
2660
|
-
/**
|
|
2661
|
-
* Options
|
|
2662
|
-
*/
|
|
2663
|
-
|
|
2664
|
-
marked.options =
|
|
2665
|
-
marked.setOptions = function(opt) {
|
|
2666
|
-
marked.defaults = { ...marked.defaults, ...opt };
|
|
2667
|
-
changeDefaults(marked.defaults);
|
|
2668
|
-
return marked;
|
|
2669
2156
|
};
|
|
2670
|
-
|
|
2671
|
-
|
|
2672
|
-
|
|
2673
|
-
|
|
2674
|
-
|
|
2675
|
-
|
|
2676
|
-
|
|
2677
|
-
|
|
2678
|
-
|
|
2679
|
-
marked.use = function(...args) {
|
|
2680
|
-
const extensions = marked.defaults.extensions || { renderers: {}, childTokens: {} };
|
|
2681
|
-
|
|
2682
|
-
args.forEach((pack) => {
|
|
2683
|
-
// copy options to new object
|
|
2684
|
-
const opts = { ...pack };
|
|
2685
|
-
|
|
2686
|
-
// set async to true if it was set to true before
|
|
2687
|
-
opts.async = marked.defaults.async || opts.async || false;
|
|
2688
|
-
|
|
2689
|
-
// ==-- Parse "addon" extensions --== //
|
|
2690
|
-
if (pack.extensions) {
|
|
2691
|
-
pack.extensions.forEach((ext) => {
|
|
2692
|
-
if (!ext.name) {
|
|
2693
|
-
throw new Error('extension name required');
|
|
2694
|
-
}
|
|
2695
|
-
if (ext.renderer) { // Renderer extensions
|
|
2696
|
-
const prevRenderer = extensions.renderers[ext.name];
|
|
2697
|
-
if (prevRenderer) {
|
|
2698
|
-
// Replace extension with func to run new extension but fall back if false
|
|
2699
|
-
extensions.renderers[ext.name] = function(...args) {
|
|
2700
|
-
let ret = ext.renderer.apply(this, args);
|
|
2701
|
-
if (ret === false) {
|
|
2702
|
-
ret = prevRenderer.apply(this, args);
|
|
2703
|
-
}
|
|
2704
|
-
return ret;
|
|
2705
|
-
};
|
|
2706
|
-
} else {
|
|
2707
|
-
extensions.renderers[ext.name] = ext.renderer;
|
|
2708
|
-
}
|
|
2709
|
-
}
|
|
2710
|
-
if (ext.tokenizer) { // Tokenizer Extensions
|
|
2711
|
-
if (!ext.level || (ext.level !== 'block' && ext.level !== 'inline')) {
|
|
2712
|
-
throw new Error("extension level must be 'block' or 'inline'");
|
|
2713
|
-
}
|
|
2714
|
-
if (extensions[ext.level]) {
|
|
2715
|
-
extensions[ext.level].unshift(ext.tokenizer);
|
|
2716
|
-
} else {
|
|
2717
|
-
extensions[ext.level] = [ext.tokenizer];
|
|
2718
|
-
}
|
|
2719
|
-
if (ext.start) { // Function to check for start of token
|
|
2720
|
-
if (ext.level === 'block') {
|
|
2721
|
-
if (extensions.startBlock) {
|
|
2722
|
-
extensions.startBlock.push(ext.start);
|
|
2723
|
-
} else {
|
|
2724
|
-
extensions.startBlock = [ext.start];
|
|
2725
|
-
}
|
|
2726
|
-
} else if (ext.level === 'inline') {
|
|
2727
|
-
if (extensions.startInline) {
|
|
2728
|
-
extensions.startInline.push(ext.start);
|
|
2729
|
-
} else {
|
|
2730
|
-
extensions.startInline = [ext.start];
|
|
2731
|
-
}
|
|
2732
|
-
}
|
|
2733
|
-
}
|
|
2734
|
-
}
|
|
2735
|
-
if (ext.childTokens) { // Child tokens to be visited by walkTokens
|
|
2736
|
-
extensions.childTokens[ext.name] = ext.childTokens;
|
|
2737
|
-
}
|
|
2738
|
-
});
|
|
2739
|
-
opts.extensions = extensions;
|
|
2740
|
-
}
|
|
2741
|
-
|
|
2742
|
-
// ==-- Parse "overwrite" extensions --== //
|
|
2743
|
-
if (pack.renderer) {
|
|
2744
|
-
const renderer = marked.defaults.renderer || new Renderer();
|
|
2745
|
-
for (const prop in pack.renderer) {
|
|
2746
|
-
const prevRenderer = renderer[prop];
|
|
2747
|
-
// Replace renderer with func to run extension, but fall back if false
|
|
2748
|
-
renderer[prop] = (...args) => {
|
|
2749
|
-
let ret = pack.renderer[prop].apply(renderer, args);
|
|
2750
|
-
if (ret === false) {
|
|
2751
|
-
ret = prevRenderer.apply(renderer, args);
|
|
2752
|
-
}
|
|
2753
|
-
return ret;
|
|
2754
|
-
};
|
|
2157
|
+
_onError = new WeakSet();
|
|
2158
|
+
onError_fn = function(silent, async, callback) {
|
|
2159
|
+
return (e) => {
|
|
2160
|
+
e.message += "\nPlease report this to https://github.com/markedjs/marked.";
|
|
2161
|
+
if (silent) {
|
|
2162
|
+
const msg = "<p>An error occurred:</p><pre>" + escape(e.message + "", true) + "</pre>";
|
|
2163
|
+
if (async) {
|
|
2164
|
+
return Promise.resolve(msg);
|
|
2755
2165
|
}
|
|
2756
|
-
|
|
2757
|
-
|
|
2758
|
-
|
|
2759
|
-
const tokenizer = marked.defaults.tokenizer || new Tokenizer();
|
|
2760
|
-
for (const prop in pack.tokenizer) {
|
|
2761
|
-
const prevTokenizer = tokenizer[prop];
|
|
2762
|
-
// Replace tokenizer with func to run extension, but fall back if false
|
|
2763
|
-
tokenizer[prop] = (...args) => {
|
|
2764
|
-
let ret = pack.tokenizer[prop].apply(tokenizer, args);
|
|
2765
|
-
if (ret === false) {
|
|
2766
|
-
ret = prevTokenizer.apply(tokenizer, args);
|
|
2767
|
-
}
|
|
2768
|
-
return ret;
|
|
2769
|
-
};
|
|
2166
|
+
if (callback) {
|
|
2167
|
+
callback(null, msg);
|
|
2168
|
+
return;
|
|
2770
2169
|
}
|
|
2771
|
-
|
|
2170
|
+
return msg;
|
|
2772
2171
|
}
|
|
2773
|
-
|
|
2774
|
-
|
|
2775
|
-
if (pack.hooks) {
|
|
2776
|
-
const hooks = marked.defaults.hooks || new Hooks();
|
|
2777
|
-
for (const prop in pack.hooks) {
|
|
2778
|
-
const prevHook = hooks[prop];
|
|
2779
|
-
if (Hooks.passThroughHooks.has(prop)) {
|
|
2780
|
-
hooks[prop] = (arg) => {
|
|
2781
|
-
if (marked.defaults.async) {
|
|
2782
|
-
return Promise.resolve(pack.hooks[prop].call(hooks, arg)).then(ret => {
|
|
2783
|
-
return prevHook.call(hooks, ret);
|
|
2784
|
-
});
|
|
2785
|
-
}
|
|
2786
|
-
|
|
2787
|
-
const ret = pack.hooks[prop].call(hooks, arg);
|
|
2788
|
-
return prevHook.call(hooks, ret);
|
|
2789
|
-
};
|
|
2790
|
-
} else {
|
|
2791
|
-
hooks[prop] = (...args) => {
|
|
2792
|
-
let ret = pack.hooks[prop].apply(hooks, args);
|
|
2793
|
-
if (ret === false) {
|
|
2794
|
-
ret = prevHook.apply(hooks, args);
|
|
2795
|
-
}
|
|
2796
|
-
return ret;
|
|
2797
|
-
};
|
|
2798
|
-
}
|
|
2799
|
-
}
|
|
2800
|
-
opts.hooks = hooks;
|
|
2172
|
+
if (async) {
|
|
2173
|
+
return Promise.reject(e);
|
|
2801
2174
|
}
|
|
2802
|
-
|
|
2803
|
-
|
|
2804
|
-
|
|
2805
|
-
const walkTokens = marked.defaults.walkTokens;
|
|
2806
|
-
opts.walkTokens = function(token) {
|
|
2807
|
-
let values = [];
|
|
2808
|
-
values.push(pack.walkTokens.call(this, token));
|
|
2809
|
-
if (walkTokens) {
|
|
2810
|
-
values = values.concat(walkTokens.call(this, token));
|
|
2811
|
-
}
|
|
2812
|
-
return values;
|
|
2813
|
-
};
|
|
2175
|
+
if (callback) {
|
|
2176
|
+
callback(e);
|
|
2177
|
+
return;
|
|
2814
2178
|
}
|
|
2815
|
-
|
|
2816
|
-
|
|
2817
|
-
});
|
|
2179
|
+
throw e;
|
|
2180
|
+
};
|
|
2818
2181
|
};
|
|
2819
2182
|
|
|
2820
|
-
|
|
2821
|
-
|
|
2822
|
-
|
|
2823
|
-
|
|
2183
|
+
// src/marked.ts
|
|
2184
|
+
var markedInstance = new Marked();
|
|
2185
|
+
function marked(src, opt, callback) {
|
|
2186
|
+
return markedInstance.parse(src, opt, callback);
|
|
2187
|
+
}
|
|
2188
|
+
marked.options = marked.setOptions = function(options2) {
|
|
2189
|
+
markedInstance.setOptions(options2);
|
|
2190
|
+
marked.defaults = markedInstance.defaults;
|
|
2191
|
+
changeDefaults(marked.defaults);
|
|
2192
|
+
return marked;
|
|
2193
|
+
};
|
|
2194
|
+
marked.getDefaults = _getDefaults;
|
|
2195
|
+
marked.defaults = _defaults;
|
|
2196
|
+
marked.use = function(...args) {
|
|
2197
|
+
markedInstance.use(...args);
|
|
2198
|
+
marked.defaults = markedInstance.defaults;
|
|
2199
|
+
changeDefaults(marked.defaults);
|
|
2200
|
+
return marked;
|
|
2201
|
+
};
|
|
2824
2202
|
marked.walkTokens = function(tokens, callback) {
|
|
2825
|
-
|
|
2826
|
-
for (const token of tokens) {
|
|
2827
|
-
values = values.concat(callback.call(marked, token));
|
|
2828
|
-
switch (token.type) {
|
|
2829
|
-
case 'table': {
|
|
2830
|
-
for (const cell of token.header) {
|
|
2831
|
-
values = values.concat(marked.walkTokens(cell.tokens, callback));
|
|
2832
|
-
}
|
|
2833
|
-
for (const row of token.rows) {
|
|
2834
|
-
for (const cell of row) {
|
|
2835
|
-
values = values.concat(marked.walkTokens(cell.tokens, callback));
|
|
2836
|
-
}
|
|
2837
|
-
}
|
|
2838
|
-
break;
|
|
2839
|
-
}
|
|
2840
|
-
case 'list': {
|
|
2841
|
-
values = values.concat(marked.walkTokens(token.items, callback));
|
|
2842
|
-
break;
|
|
2843
|
-
}
|
|
2844
|
-
default: {
|
|
2845
|
-
if (marked.defaults.extensions && marked.defaults.extensions.childTokens && marked.defaults.extensions.childTokens[token.type]) { // Walk any extensions
|
|
2846
|
-
marked.defaults.extensions.childTokens[token.type].forEach(function(childTokens) {
|
|
2847
|
-
values = values.concat(marked.walkTokens(token[childTokens], callback));
|
|
2848
|
-
});
|
|
2849
|
-
} else if (token.tokens) {
|
|
2850
|
-
values = values.concat(marked.walkTokens(token.tokens, callback));
|
|
2851
|
-
}
|
|
2852
|
-
}
|
|
2853
|
-
}
|
|
2854
|
-
}
|
|
2855
|
-
return values;
|
|
2203
|
+
return markedInstance.walkTokens(tokens, callback);
|
|
2856
2204
|
};
|
|
2857
|
-
|
|
2858
|
-
|
|
2859
|
-
|
|
2860
|
-
|
|
2861
|
-
|
|
2862
|
-
marked.
|
|
2863
|
-
|
|
2864
|
-
|
|
2865
|
-
|
|
2866
|
-
|
|
2867
|
-
marked.Parser = Parser;
|
|
2868
|
-
marked.parser = Parser.parse;
|
|
2869
|
-
marked.Renderer = Renderer;
|
|
2870
|
-
marked.TextRenderer = TextRenderer;
|
|
2871
|
-
marked.Lexer = Lexer;
|
|
2872
|
-
marked.lexer = Lexer.lex;
|
|
2873
|
-
marked.Tokenizer = Tokenizer;
|
|
2874
|
-
marked.Slugger = Slugger;
|
|
2875
|
-
marked.Hooks = Hooks;
|
|
2205
|
+
marked.parseInline = markedInstance.parseInline;
|
|
2206
|
+
marked.Parser = _Parser;
|
|
2207
|
+
marked.parser = _Parser.parse;
|
|
2208
|
+
marked.Renderer = _Renderer;
|
|
2209
|
+
marked.TextRenderer = _TextRenderer;
|
|
2210
|
+
marked.Lexer = _Lexer;
|
|
2211
|
+
marked.lexer = _Lexer.lex;
|
|
2212
|
+
marked.Tokenizer = _Tokenizer;
|
|
2213
|
+
marked.Slugger = _Slugger;
|
|
2214
|
+
marked.Hooks = _Hooks;
|
|
2876
2215
|
marked.parse = marked;
|
|
2877
|
-
|
|
2878
2216
|
marked.options;
|
|
2879
2217
|
marked.setOptions;
|
|
2880
2218
|
marked.use;
|
|
2881
2219
|
marked.walkTokens;
|
|
2882
2220
|
marked.parseInline;
|
|
2883
|
-
|
|
2884
|
-
|
|
2221
|
+
_Parser.parse;
|
|
2222
|
+
_Lexer.lex;
|
|
2885
2223
|
|
|
2886
2224
|
var _jsxFileName = "/home/runner/work/app-monorepo/app-monorepo/plugins/plugin-changelog-md/src/client/changelog-page.tsx";
|
|
2887
2225
|
var ChangelogPage = props => {
|