';
- return out;
- };
-
- _proto.image = function image(href, title, text) {
- href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
-
- if (href === null) {
- return text;
- }
-
- var out = '
' : '>';
- return out;
- };
-
- _proto.text = function text(_text) {
- return _text;
- };
-
- return Renderer;
- }();
-
- /**
- * TextRenderer
- * returns only the textual part of the token
- */
- var TextRenderer = /*#__PURE__*/function () {
- function TextRenderer() {}
-
- var _proto = TextRenderer.prototype;
-
- // no need for block level renderers
- _proto.strong = function strong(text) {
- return text;
- };
-
- _proto.em = function em(text) {
- return text;
- };
-
- _proto.codespan = function codespan(text) {
- return text;
- };
-
- _proto.del = function del(text) {
- return text;
- };
-
- _proto.html = function html(text) {
- return text;
- };
-
- _proto.text = function text(_text) {
- return _text;
- };
-
- _proto.link = function link(href, title, text) {
- return '' + text;
- };
-
- _proto.image = function image(href, title, text) {
- return '' + text;
- };
-
- _proto.br = function br() {
- return '';
- };
-
- return TextRenderer;
- }();
-
- /**
- * Slugger generates header id
- */
- var Slugger = /*#__PURE__*/function () {
- function Slugger() {
- this.seen = {};
- }
-
- var _proto = Slugger.prototype;
-
- _proto.serialize = function serialize(value) {
- return value.toLowerCase().trim() // remove html tags
- .replace(/<[!\/a-z].*?>/ig, '') // remove unwanted chars
- .replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, '').replace(/\s/g, '-');
- }
- /**
- * Finds the next safe (unique) slug to use
- */
- ;
-
- _proto.getNextSafeSlug = function getNextSafeSlug(originalSlug, isDryRun) {
- var slug = originalSlug;
- var occurenceAccumulator = 0;
-
- if (this.seen.hasOwnProperty(slug)) {
- occurenceAccumulator = this.seen[originalSlug];
-
- do {
- occurenceAccumulator++;
- slug = originalSlug + '-' + occurenceAccumulator;
- } while (this.seen.hasOwnProperty(slug));
- }
-
- if (!isDryRun) {
- this.seen[originalSlug] = occurenceAccumulator;
- this.seen[slug] = 0;
- }
-
- return slug;
- }
- /**
- * Convert string to unique id
- * @param {object} options
- * @param {boolean} options.dryrun Generates the next unique slug without updating the internal accumulator.
- */
- ;
-
- _proto.slug = function slug(value, options) {
- if (options === void 0) {
- options = {};
- }
-
- var slug = this.serialize(value);
- return this.getNextSafeSlug(slug, options.dryrun);
- };
-
- return Slugger;
- }();
-
- /**
- * Parsing & Compiling
- */
-
- var Parser = /*#__PURE__*/function () {
- function Parser(options) {
- this.options = options || exports.defaults;
- this.options.renderer = this.options.renderer || new Renderer();
- this.renderer = this.options.renderer;
- this.renderer.options = this.options;
- this.textRenderer = new TextRenderer();
- this.slugger = new Slugger();
- }
- /**
- * Static Parse Method
- */
-
-
- Parser.parse = function parse(tokens, options) {
- var parser = new Parser(options);
- return parser.parse(tokens);
- }
- /**
- * Static Parse Inline Method
- */
- ;
-
- Parser.parseInline = function parseInline(tokens, options) {
- var parser = new Parser(options);
- return parser.parseInline(tokens);
- }
- /**
- * Parse Loop
- */
- ;
-
- var _proto = Parser.prototype;
-
- _proto.parse = function parse(tokens, top) {
- if (top === void 0) {
- top = true;
- }
-
- var out = '',
- i,
- j,
- k,
- l2,
- l3,
- row,
- cell,
- header,
- body,
- token,
- ordered,
- start,
- loose,
- itemBody,
- item,
- checked,
- task,
- checkbox,
- ret;
- var l = tokens.length;
-
- for (i = 0; i < l; i++) {
- token = tokens[i]; // Run any renderer extensions
-
- if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
- ret = this.options.extensions.renderers[token.type].call({
- parser: this
- }, token);
-
- if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'paragraph', 'text'].includes(token.type)) {
- out += ret || '';
- continue;
- }
- }
-
- switch (token.type) {
- case 'space':
- {
- continue;
- }
-
- case 'hr':
- {
- out += this.renderer.hr();
- continue;
- }
-
- case 'heading':
- {
- out += this.renderer.heading(this.parseInline(token.tokens), token.depth, unescape(this.parseInline(token.tokens, this.textRenderer)), this.slugger);
- continue;
- }
-
- case 'code':
- {
- out += this.renderer.code(token.text, token.lang, token.escaped);
- continue;
- }
-
- case 'table':
- {
- header = ''; // header
-
- cell = '';
- l2 = token.header.length;
-
- for (j = 0; j < l2; j++) {
- cell += this.renderer.tablecell(this.parseInline(token.header[j].tokens), {
- header: true,
- align: token.align[j]
- });
- }
-
- header += this.renderer.tablerow(cell);
- body = '';
- l2 = token.rows.length;
-
- for (j = 0; j < l2; j++) {
- row = token.rows[j];
- cell = '';
- l3 = row.length;
-
- for (k = 0; k < l3; k++) {
- cell += this.renderer.tablecell(this.parseInline(row[k].tokens), {
- header: false,
- align: token.align[k]
- });
- }
-
- body += this.renderer.tablerow(cell);
- }
-
- out += this.renderer.table(header, body);
- continue;
- }
-
- case 'blockquote':
- {
- body = this.parse(token.tokens);
- out += this.renderer.blockquote(body);
- continue;
- }
-
- case 'list':
- {
- ordered = token.ordered;
- start = token.start;
- loose = token.loose;
- l2 = token.items.length;
- body = '';
-
- for (j = 0; j < l2; j++) {
- item = token.items[j];
- checked = item.checked;
- task = item.task;
- itemBody = '';
-
- if (item.task) {
- checkbox = this.renderer.checkbox(checked);
-
- if (loose) {
- if (item.tokens.length > 0 && item.tokens[0].type === 'paragraph') {
- item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;
-
- if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {
- item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text;
- }
- } else {
- item.tokens.unshift({
- type: 'text',
- text: checkbox
- });
- }
- } else {
- itemBody += checkbox;
- }
- }
-
- itemBody += this.parse(item.tokens, loose);
- body += this.renderer.listitem(itemBody, task, checked);
- }
-
- out += this.renderer.list(body, ordered, start);
- continue;
- }
-
- case 'html':
- {
- // TODO parse inline content if parameter markdown=1
- out += this.renderer.html(token.text);
- continue;
- }
-
- case 'paragraph':
- {
- out += this.renderer.paragraph(this.parseInline(token.tokens));
- continue;
- }
-
- case 'text':
- {
- body = token.tokens ? this.parseInline(token.tokens) : token.text;
-
- while (i + 1 < l && tokens[i + 1].type === 'text') {
- token = tokens[++i];
- body += '\n' + (token.tokens ? this.parseInline(token.tokens) : token.text);
- }
-
- out += top ? this.renderer.paragraph(body) : body;
- continue;
- }
-
- default:
- {
- var errMsg = 'Token with "' + token.type + '" type was not found.';
-
- if (this.options.silent) {
- console.error(errMsg);
- return;
- } else {
- throw new Error(errMsg);
- }
- }
- }
- }
-
- return out;
- }
- /**
- * Parse Inline Tokens
- */
- ;
-
- _proto.parseInline = function parseInline(tokens, renderer) {
- renderer = renderer || this.renderer;
- var out = '',
- i,
- token,
- ret;
- var l = tokens.length;
-
- for (i = 0; i < l; i++) {
- token = tokens[i]; // Run any renderer extensions
-
- if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
- ret = this.options.extensions.renderers[token.type].call({
- parser: this
- }, token);
-
- if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(token.type)) {
- out += ret || '';
- continue;
- }
- }
-
- switch (token.type) {
- case 'escape':
- {
- out += renderer.text(token.text);
- break;
- }
-
- case 'html':
- {
- out += renderer.html(token.text);
- break;
- }
-
- case 'link':
- {
- out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer));
- break;
- }
-
- case 'image':
- {
- out += renderer.image(token.href, token.title, token.text);
- break;
- }
-
- case 'strong':
- {
- out += renderer.strong(this.parseInline(token.tokens, renderer));
- break;
- }
-
- case 'em':
- {
- out += renderer.em(this.parseInline(token.tokens, renderer));
- break;
- }
-
- case 'codespan':
- {
- out += renderer.codespan(token.text);
- break;
- }
-
- case 'br':
- {
- out += renderer.br();
- break;
- }
-
- case 'del':
- {
- out += renderer.del(this.parseInline(token.tokens, renderer));
- break;
- }
-
- case 'text':
- {
- out += renderer.text(token.text);
- break;
- }
-
- default:
- {
- var errMsg = 'Token with "' + token.type + '" type was not found.';
-
- if (this.options.silent) {
- console.error(errMsg);
- return;
- } else {
- throw new Error(errMsg);
- }
- }
- }
- }
-
- return out;
- };
-
- return Parser;
- }();
-
- /**
- * Marked
- */
-
- function marked(src, opt, callback) {
- // throw error in case of non string input
- if (typeof src === 'undefined' || src === null) {
- throw new Error('marked(): input parameter is undefined or null');
- }
-
- if (typeof src !== 'string') {
- throw new Error('marked(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected');
- }
-
- if (typeof opt === 'function') {
- callback = opt;
- opt = null;
- }
-
- opt = merge({}, marked.defaults, opt || {});
- checkSanitizeDeprecation(opt);
-
- if (callback) {
- var highlight = opt.highlight;
- var tokens;
-
- try {
- tokens = Lexer.lex(src, opt);
- } catch (e) {
- return callback(e);
- }
-
- var done = function done(err) {
- var out;
-
- if (!err) {
- try {
- if (opt.walkTokens) {
- marked.walkTokens(tokens, opt.walkTokens);
- }
-
- out = Parser.parse(tokens, opt);
- } catch (e) {
- err = e;
- }
- }
-
- opt.highlight = highlight;
- return err ? callback(err) : callback(null, out);
- };
-
- if (!highlight || highlight.length < 3) {
- return done();
- }
-
- delete opt.highlight;
- if (!tokens.length) return done();
- var pending = 0;
- marked.walkTokens(tokens, function (token) {
- if (token.type === 'code') {
- pending++;
- setTimeout(function () {
- highlight(token.text, token.lang, function (err, code) {
- if (err) {
- return done(err);
- }
-
- if (code != null && code !== token.text) {
- token.text = code;
- token.escaped = true;
- }
-
- pending--;
-
- if (pending === 0) {
- done();
- }
- });
- }, 0);
- }
- });
-
- if (pending === 0) {
- done();
- }
-
- return;
- }
-
- try {
- var _tokens = Lexer.lex(src, opt);
-
- if (opt.walkTokens) {
- marked.walkTokens(_tokens, opt.walkTokens);
- }
-
- return Parser.parse(_tokens, opt);
- } catch (e) {
- e.message += '\nPlease report this to https://github.com/markedjs/marked.';
-
- if (opt.silent) {
- return 'An error occurred:
' + escape(e.message + '', true) + '
';
- }
-
- throw e;
- }
- }
- /**
- * Options
- */
-
- marked.options = marked.setOptions = function (opt) {
- merge(marked.defaults, opt);
- changeDefaults(marked.defaults);
- return marked;
- };
-
- marked.getDefaults = getDefaults;
- marked.defaults = exports.defaults;
- /**
- * Use Extension
- */
-
- marked.use = function () {
- for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
- args[_key] = arguments[_key];
- }
-
- var opts = merge.apply(void 0, [{}].concat(args));
- var extensions = marked.defaults.extensions || {
- renderers: {},
- childTokens: {}
- };
- var hasExtensions;
- args.forEach(function (pack) {
- // ==-- Parse "addon" extensions --== //
- if (pack.extensions) {
- hasExtensions = true;
- pack.extensions.forEach(function (ext) {
- if (!ext.name) {
- throw new Error('extension name required');
- }
-
- if (ext.renderer) {
- // Renderer extensions
- var prevRenderer = extensions.renderers ? extensions.renderers[ext.name] : null;
-
- if (prevRenderer) {
- // Replace extension with func to run new extension but fall back if false
- extensions.renderers[ext.name] = function () {
- for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
- args[_key2] = arguments[_key2];
- }
-
- var ret = ext.renderer.apply(this, args);
-
- if (ret === false) {
- ret = prevRenderer.apply(this, args);
- }
-
- return ret;
- };
- } else {
- extensions.renderers[ext.name] = ext.renderer;
- }
- }
-
- if (ext.tokenizer) {
- // Tokenizer Extensions
- if (!ext.level || ext.level !== 'block' && ext.level !== 'inline') {
- throw new Error("extension level must be 'block' or 'inline'");
- }
-
- if (extensions[ext.level]) {
- extensions[ext.level].unshift(ext.tokenizer);
- } else {
- extensions[ext.level] = [ext.tokenizer];
- }
-
- if (ext.start) {
- // Function to check for start of token
- if (ext.level === 'block') {
- if (extensions.startBlock) {
- extensions.startBlock.push(ext.start);
- } else {
- extensions.startBlock = [ext.start];
- }
- } else if (ext.level === 'inline') {
- if (extensions.startInline) {
- extensions.startInline.push(ext.start);
- } else {
- extensions.startInline = [ext.start];
- }
- }
- }
- }
-
- if (ext.childTokens) {
- // Child tokens to be visited by walkTokens
- extensions.childTokens[ext.name] = ext.childTokens;
- }
- });
- } // ==-- Parse "overwrite" extensions --== //
-
-
- if (pack.renderer) {
- (function () {
- var renderer = marked.defaults.renderer || new Renderer();
-
- var _loop = function _loop(prop) {
- var prevRenderer = renderer[prop]; // Replace renderer with func to run extension, but fall back if false
-
- renderer[prop] = function () {
- for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
- args[_key3] = arguments[_key3];
- }
-
- var ret = pack.renderer[prop].apply(renderer, args);
-
- if (ret === false) {
- ret = prevRenderer.apply(renderer, args);
- }
-
- return ret;
- };
- };
-
- for (var prop in pack.renderer) {
- _loop(prop);
- }
-
- opts.renderer = renderer;
- })();
- }
-
- if (pack.tokenizer) {
- (function () {
- var tokenizer = marked.defaults.tokenizer || new Tokenizer();
-
- var _loop2 = function _loop2(prop) {
- var prevTokenizer = tokenizer[prop]; // Replace tokenizer with func to run extension, but fall back if false
-
- tokenizer[prop] = function () {
- for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
- args[_key4] = arguments[_key4];
- }
-
- var ret = pack.tokenizer[prop].apply(tokenizer, args);
-
- if (ret === false) {
- ret = prevTokenizer.apply(tokenizer, args);
- }
-
- return ret;
- };
- };
-
- for (var prop in pack.tokenizer) {
- _loop2(prop);
- }
-
- opts.tokenizer = tokenizer;
- })();
- } // ==-- Parse WalkTokens extensions --== //
-
-
- if (pack.walkTokens) {
- var _walkTokens = marked.defaults.walkTokens;
-
- opts.walkTokens = function (token) {
- pack.walkTokens.call(this, token);
-
- if (_walkTokens) {
- _walkTokens.call(this, token);
- }
- };
- }
-
- if (hasExtensions) {
- opts.extensions = extensions;
- }
-
- marked.setOptions(opts);
- });
- };
- /**
- * Run callback for every token
- */
-
-
- marked.walkTokens = function (tokens, callback) {
- var _loop3 = function _loop3() {
- var token = _step.value;
- callback.call(marked, token);
-
switch (token.type) {
- case 'table':
+ case 'escape':
{
- for (var _iterator2 = _createForOfIteratorHelperLoose(token.header), _step2; !(_step2 = _iterator2()).done;) {
- var cell = _step2.value;
- marked.walkTokens(cell.tokens, callback);
- }
-
- for (var _iterator3 = _createForOfIteratorHelperLoose(token.rows), _step3; !(_step3 = _iterator3()).done;) {
- var row = _step3.value;
-
- for (var _iterator4 = _createForOfIteratorHelperLoose(row), _step4; !(_step4 = _iterator4()).done;) {
- var _cell = _step4.value;
- marked.walkTokens(_cell.tokens, callback);
- }
- }
-
+ out += renderer.text(token.text);
break;
}
- case 'list':
+ case 'html':
{
- marked.walkTokens(token.items, callback);
+ out += renderer.html(token.text);
+ break;
+ }
+
+ case 'link':
+ {
+ out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer));
+ break;
+ }
+
+ case 'image':
+ {
+ out += renderer.image(token.href, token.title, token.text);
+ break;
+ }
+
+ case 'strong':
+ {
+ out += renderer.strong(this.parseInline(token.tokens, renderer));
+ break;
+ }
+
+ case 'em':
+ {
+ out += renderer.em(this.parseInline(token.tokens, renderer));
+ break;
+ }
+
+ case 'codespan':
+ {
+ out += renderer.codespan(token.text);
+ break;
+ }
+
+ case 'br':
+ {
+ out += renderer.br();
+ break;
+ }
+
+ case 'del':
+ {
+ out += renderer.del(this.parseInline(token.tokens, renderer));
+ break;
+ }
+
+ case 'text':
+ {
+ out += renderer.text(token.text);
break;
}
default:
{
- if (marked.defaults.extensions && marked.defaults.extensions.childTokens && marked.defaults.extensions.childTokens[token.type]) {
- // Walk any extensions
- marked.defaults.extensions.childTokens[token.type].forEach(function (childTokens) {
- marked.walkTokens(token[childTokens], callback);
- });
- } else if (token.tokens) {
- marked.walkTokens(token.tokens, callback);
+ var errMsg = 'Token with "' + token.type + '" type was not found.';
+
+ if (this.options.silent) {
+ console.error(errMsg);
+ return;
+ } else {
+ throw new Error(errMsg);
}
}
}
- };
-
- for (var _iterator = _createForOfIteratorHelperLoose(tokens), _step; !(_step = _iterator()).done;) {
- _loop3();
}
+
+ return out;
};
- /**
- * Parse Inline
- */
+ return Parser;
+}();
- marked.parseInline = function (src, opt) {
- // throw error in case of non string input
- if (typeof src === 'undefined' || src === null) {
- throw new Error('marked.parseInline(): input parameter is undefined or null');
- }
+/**
+ * Marked
+ */
- if (typeof src !== 'string') {
- throw new Error('marked.parseInline(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected');
- }
+function marked(src, opt, callback) {
+ // throw error in case of non string input
+ if (typeof src === 'undefined' || src === null) {
+ throw new Error('marked(): input parameter is undefined or null');
+ }
- opt = merge({}, marked.defaults, opt || {});
- checkSanitizeDeprecation(opt);
+ if (typeof src !== 'string') {
+ throw new Error('marked(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected');
+ }
+
+ if (typeof opt === 'function') {
+ callback = opt;
+ opt = null;
+ }
+
+ opt = merge({}, marked.defaults, opt || {});
+ checkSanitizeDeprecation(opt);
+
+ if (callback) {
+ var highlight = opt.highlight;
+ var tokens;
try {
- var tokens = Lexer.lexInline(src, opt);
-
- if (opt.walkTokens) {
- marked.walkTokens(tokens, opt.walkTokens);
- }
-
- return Parser.parseInline(tokens, opt);
+ tokens = Lexer.lex(src, opt);
} catch (e) {
- e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+ return callback(e);
+ }
- if (opt.silent) {
- return 'An error occurred:
' + escape(e.message + '', true) + '
';
+ var done = function done(err) {
+ var out;
+
+ if (!err) {
+ try {
+ if (opt.walkTokens) {
+ marked.walkTokens(tokens, opt.walkTokens);
+ }
+
+ out = Parser.parse(tokens, opt);
+ } catch (e) {
+ err = e;
+ }
}
- throw e;
+ opt.highlight = highlight;
+ return err ? callback(err) : callback(null, out);
+ };
+
+ if (!highlight || highlight.length < 3) {
+ return done();
+ }
+
+ delete opt.highlight;
+ if (!tokens.length) return done();
+ var pending = 0;
+ marked.walkTokens(tokens, function (token) {
+ if (token.type === 'code') {
+ pending++;
+ setTimeout(function () {
+ highlight(token.text, token.lang, function (err, code) {
+ if (err) {
+ return done(err);
+ }
+
+ if (code != null && code !== token.text) {
+ token.text = code;
+ token.escaped = true;
+ }
+
+ pending--;
+
+ if (pending === 0) {
+ done();
+ }
+ });
+ }, 0);
+ }
+ });
+
+ if (pending === 0) {
+ done();
+ }
+
+ return;
+ }
+
+ try {
+ var _tokens = Lexer.lex(src, opt);
+
+ if (opt.walkTokens) {
+ marked.walkTokens(_tokens, opt.walkTokens);
+ }
+
+ return Parser.parse(_tokens, opt);
+ } catch (e) {
+ e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+
+ if (opt.silent) {
+ return 'An error occurred:
' + escape(e.message + '', true) + '
';
+ }
+
+ throw e;
+ }
+}
+/**
+ * Options
+ */
+
+marked.options = marked.setOptions = function (opt) {
+ merge(marked.defaults, opt);
+ changeDefaults(marked.defaults);
+ return marked;
+};
+
+marked.getDefaults = getDefaults;
+marked.defaults = exports.defaults;
+/**
+ * Use Extension
+ */
+
+marked.use = function () {
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ var opts = merge.apply(void 0, [{}].concat(args));
+ var extensions = marked.defaults.extensions || {
+ renderers: {},
+ childTokens: {}
+ };
+ var hasExtensions;
+ args.forEach(function (pack) {
+ // ==-- Parse "addon" extensions --== //
+ if (pack.extensions) {
+ hasExtensions = true;
+ pack.extensions.forEach(function (ext) {
+ if (!ext.name) {
+ throw new Error('extension name required');
+ }
+
+ if (ext.renderer) {
+ // Renderer extensions
+ var prevRenderer = extensions.renderers ? extensions.renderers[ext.name] : null;
+
+ if (prevRenderer) {
+ // Replace extension with func to run new extension but fall back if false
+ extensions.renderers[ext.name] = function () {
+ for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+ args[_key2] = arguments[_key2];
+ }
+
+ var ret = ext.renderer.apply(this, args);
+
+ if (ret === false) {
+ ret = prevRenderer.apply(this, args);
+ }
+
+ return ret;
+ };
+ } else {
+ extensions.renderers[ext.name] = ext.renderer;
+ }
+ }
+
+ if (ext.tokenizer) {
+ // Tokenizer Extensions
+ if (!ext.level || ext.level !== 'block' && ext.level !== 'inline') {
+ throw new Error("extension level must be 'block' or 'inline'");
+ }
+
+ if (extensions[ext.level]) {
+ extensions[ext.level].unshift(ext.tokenizer);
+ } else {
+ extensions[ext.level] = [ext.tokenizer];
+ }
+
+ if (ext.start) {
+ // Function to check for start of token
+ if (ext.level === 'block') {
+ if (extensions.startBlock) {
+ extensions.startBlock.push(ext.start);
+ } else {
+ extensions.startBlock = [ext.start];
+ }
+ } else if (ext.level === 'inline') {
+ if (extensions.startInline) {
+ extensions.startInline.push(ext.start);
+ } else {
+ extensions.startInline = [ext.start];
+ }
+ }
+ }
+ }
+
+ if (ext.childTokens) {
+ // Child tokens to be visited by walkTokens
+ extensions.childTokens[ext.name] = ext.childTokens;
+ }
+ });
+ } // ==-- Parse "overwrite" extensions --== //
+
+
+ if (pack.renderer) {
+ (function () {
+ var renderer = marked.defaults.renderer || new Renderer();
+
+ var _loop = function _loop(prop) {
+ var prevRenderer = renderer[prop]; // Replace renderer with func to run extension, but fall back if false
+
+ renderer[prop] = function () {
+ for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+ args[_key3] = arguments[_key3];
+ }
+
+ var ret = pack.renderer[prop].apply(renderer, args);
+
+ if (ret === false) {
+ ret = prevRenderer.apply(renderer, args);
+ }
+
+ return ret;
+ };
+ };
+
+ for (var prop in pack.renderer) {
+ _loop(prop);
+ }
+
+ opts.renderer = renderer;
+ })();
+ }
+
+ if (pack.tokenizer) {
+ (function () {
+ var tokenizer = marked.defaults.tokenizer || new Tokenizer();
+
+ var _loop2 = function _loop2(prop) {
+ var prevTokenizer = tokenizer[prop]; // Replace tokenizer with func to run extension, but fall back if false
+
+ tokenizer[prop] = function () {
+ for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+ args[_key4] = arguments[_key4];
+ }
+
+ var ret = pack.tokenizer[prop].apply(tokenizer, args);
+
+ if (ret === false) {
+ ret = prevTokenizer.apply(tokenizer, args);
+ }
+
+ return ret;
+ };
+ };
+
+ for (var prop in pack.tokenizer) {
+ _loop2(prop);
+ }
+
+ opts.tokenizer = tokenizer;
+ })();
+ } // ==-- Parse WalkTokens extensions --== //
+
+
+ if (pack.walkTokens) {
+ var _walkTokens = marked.defaults.walkTokens;
+
+ opts.walkTokens = function (token) {
+ pack.walkTokens.call(this, token);
+
+ if (_walkTokens) {
+ _walkTokens.call(this, token);
+ }
+ };
+ }
+
+ if (hasExtensions) {
+ opts.extensions = extensions;
+ }
+
+ marked.setOptions(opts);
+ });
+};
+/**
+ * Run callback for every token
+ */
+
+
+marked.walkTokens = function (tokens, callback) {
+ var _loop3 = function _loop3() {
+ var token = _step.value;
+ callback.call(marked, token);
+
+ switch (token.type) {
+ case 'table':
+ {
+ for (var _iterator2 = _createForOfIteratorHelperLoose(token.header), _step2; !(_step2 = _iterator2()).done;) {
+ var cell = _step2.value;
+ marked.walkTokens(cell.tokens, callback);
+ }
+
+ for (var _iterator3 = _createForOfIteratorHelperLoose(token.rows), _step3; !(_step3 = _iterator3()).done;) {
+ var row = _step3.value;
+
+ for (var _iterator4 = _createForOfIteratorHelperLoose(row), _step4; !(_step4 = _iterator4()).done;) {
+ var _cell = _step4.value;
+ marked.walkTokens(_cell.tokens, callback);
+ }
+ }
+
+ break;
+ }
+
+ case 'list':
+ {
+ marked.walkTokens(token.items, callback);
+ break;
+ }
+
+ default:
+ {
+ if (marked.defaults.extensions && marked.defaults.extensions.childTokens && marked.defaults.extensions.childTokens[token.type]) {
+ // Walk any extensions
+ marked.defaults.extensions.childTokens[token.type].forEach(function (childTokens) {
+ marked.walkTokens(token[childTokens], callback);
+ });
+ } else if (token.tokens) {
+ marked.walkTokens(token.tokens, callback);
+ }
+ }
}
};
- /**
- * Expose
- */
+
+ for (var _iterator = _createForOfIteratorHelperLoose(tokens), _step; !(_step = _iterator()).done;) {
+ _loop3();
+ }
+};
+/**
+ * Parse Inline
+ */
- marked.Parser = Parser;
- marked.parser = Parser.parse;
- marked.Renderer = Renderer;
- marked.TextRenderer = TextRenderer;
- marked.Lexer = Lexer;
- marked.lexer = Lexer.lex;
- marked.Tokenizer = Tokenizer;
- marked.Slugger = Slugger;
- marked.parse = marked;
- var options = marked.options;
- var setOptions = marked.setOptions;
- var use = marked.use;
- var walkTokens = marked.walkTokens;
- var parseInline = marked.parseInline;
- var parse = marked;
- var parser = Parser.parse;
- var lexer = Lexer.lex;
+marked.parseInline = function (src, opt) {
+ // throw error in case of non string input
+ if (typeof src === 'undefined' || src === null) {
+ throw new Error('marked.parseInline(): input parameter is undefined or null');
+ }
- exports.Lexer = Lexer;
- exports.Parser = Parser;
- exports.Renderer = Renderer;
- exports.Slugger = Slugger;
- exports.TextRenderer = TextRenderer;
- exports.Tokenizer = Tokenizer;
- exports.getDefaults = getDefaults;
- exports.lexer = lexer;
- exports.marked = marked;
- exports.options = options;
- exports.parse = parse;
- exports.parseInline = parseInline;
- exports.parser = parser;
- exports.setOptions = setOptions;
- exports.use = use;
- exports.walkTokens = walkTokens;
+ if (typeof src !== 'string') {
+ throw new Error('marked.parseInline(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected');
+ }
- Object.defineProperty(exports, '__esModule', { value: true });
+ opt = merge({}, marked.defaults, opt || {});
+ checkSanitizeDeprecation(opt);
-}));
+ try {
+ var tokens = Lexer.lexInline(src, opt);
+
+ if (opt.walkTokens) {
+ marked.walkTokens(tokens, opt.walkTokens);
+ }
+
+ return Parser.parseInline(tokens, opt);
+ } catch (e) {
+ e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+
+ if (opt.silent) {
+ return 'An error occurred:
' + escape(e.message + '', true) + '
';
+ }
+
+ throw e;
+ }
+};
+/**
+ * Expose
+ */
+
+
+marked.Parser = Parser;
+marked.parser = Parser.parse;
+marked.Renderer = Renderer;
+marked.TextRenderer = TextRenderer;
+marked.Lexer = Lexer;
+marked.lexer = Lexer.lex;
+marked.Tokenizer = Tokenizer;
+marked.Slugger = Slugger;
+marked.parse = marked;
+var options = marked.options;
+var setOptions = marked.setOptions;
+var use = marked.use;
+var walkTokens = marked.walkTokens;
+var parseInline = marked.parseInline;
+var parse = marked;
+var parser = Parser.parse;
+var lexer = Lexer.lex;
+
+exports.Lexer = Lexer;
+exports.Parser = Parser;
+exports.Renderer = Renderer;
+exports.Slugger = Slugger;
+exports.TextRenderer = TextRenderer;
+exports.Tokenizer = Tokenizer;
+exports.getDefaults = getDefaults;
+exports.lexer = lexer;
+exports.marked = marked;
+exports.options = options;
+exports.parse = parse;
+exports.parseInline = parseInline;
+exports.parser = parser;
+exports.setOptions = setOptions;
+exports.use = use;
+exports.walkTokens = walkTokens;
diff --git a/lib/marked.umd.js b/lib/marked.umd.js
new file mode 100644
index 00000000..2f2ca9ca
--- /dev/null
+++ b/lib/marked.umd.js
@@ -0,0 +1,2913 @@
+/**
+ * marked - a markdown parser
+ * Copyright (c) 2011-2021, Christopher Jeffrey. (MIT Licensed)
+ * https://github.com/markedjs/marked
+ */
+
+/**
+ * DO NOT EDIT THIS FILE
+ * The code in this file is generated from files in ./src/
+ */
+
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+ typeof define === 'function' && define.amd ? define(['exports'], factory) :
+ (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.marked = {}));
+})(this, (function (exports) { 'use strict';
+
+ function _defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor = props[i];
+ descriptor.enumerable = descriptor.enumerable || false;
+ descriptor.configurable = true;
+ if ("value" in descriptor) descriptor.writable = true;
+ Object.defineProperty(target, descriptor.key, descriptor);
+ }
+ }
+
+ function _createClass(Constructor, protoProps, staticProps) {
+ if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+ if (staticProps) _defineProperties(Constructor, staticProps);
+ return Constructor;
+ }
+
+ function _unsupportedIterableToArray(o, minLen) {
+ if (!o) return;
+ if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor) n = o.constructor.name;
+ if (n === "Map" || n === "Set") return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+ }
+
+ function _arrayLikeToArray(arr, len) {
+ if (len == null || len > arr.length) len = arr.length;
+
+ for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+ return arr2;
+ }
+
+ function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+ var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+ if (it) return (it = it.call(o)).next.bind(it);
+
+ if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+ if (it) o = it;
+ var i = 0;
+ return function () {
+ if (i >= o.length) return {
+ done: true
+ };
+ return {
+ done: false,
+ value: o[i++]
+ };
+ };
+ }
+
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+
+ function getDefaults() {
+ return {
+ baseUrl: null,
+ breaks: false,
+ extensions: null,
+ gfm: true,
+ headerIds: true,
+ headerPrefix: '',
+ highlight: null,
+ langPrefix: 'language-',
+ mangle: true,
+ pedantic: false,
+ renderer: null,
+ sanitize: false,
+ sanitizer: null,
+ silent: false,
+ smartLists: false,
+ smartypants: false,
+ tokenizer: null,
+ walkTokens: null,
+ xhtml: false
+ };
+ }
+ exports.defaults = getDefaults();
+ function changeDefaults(newDefaults) {
+ exports.defaults = newDefaults;
+ }
+
+ /**
+ * Helpers
+ */
+ var escapeTest = /[&<>"']/;
+ var escapeReplace = /[&<>"']/g;
+ var escapeTestNoEncode = /[<>"']|&(?!#?\w+;)/;
+ var escapeReplaceNoEncode = /[<>"']|&(?!#?\w+;)/g;
+ var escapeReplacements = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": '''
+ };
+
+ var getEscapeReplacement = function getEscapeReplacement(ch) {
+ return escapeReplacements[ch];
+ };
+
+ function escape(html, encode) {
+ if (encode) {
+ if (escapeTest.test(html)) {
+ return html.replace(escapeReplace, getEscapeReplacement);
+ }
+ } else {
+ if (escapeTestNoEncode.test(html)) {
+ return html.replace(escapeReplaceNoEncode, getEscapeReplacement);
+ }
+ }
+
+ return html;
+ }
+ var unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
+ function unescape(html) {
+ // explicitly match decimal, hex, and named HTML entities
+ return html.replace(unescapeTest, function (_, n) {
+ n = n.toLowerCase();
+ if (n === 'colon') return ':';
+
+ if (n.charAt(0) === '#') {
+ return n.charAt(1) === 'x' ? String.fromCharCode(parseInt(n.substring(2), 16)) : String.fromCharCode(+n.substring(1));
+ }
+
+ return '';
+ });
+ }
+ var caret = /(^|[^\[])\^/g;
+ function edit(regex, opt) {
+ regex = regex.source || regex;
+ opt = opt || '';
+ var obj = {
+ replace: function replace(name, val) {
+ val = val.source || val;
+ val = val.replace(caret, '$1');
+ regex = regex.replace(name, val);
+ return obj;
+ },
+ getRegex: function getRegex() {
+ return new RegExp(regex, opt);
+ }
+ };
+ return obj;
+ }
+ var nonWordAndColonTest = /[^\w:]/g;
+ var originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;
+ function cleanUrl(sanitize, base, href) {
+ if (sanitize) {
+ var prot;
+
+ try {
+ prot = decodeURIComponent(unescape(href)).replace(nonWordAndColonTest, '').toLowerCase();
+ } catch (e) {
+ return null;
+ }
+
+ if (prot.indexOf('javascript:') === 0 || prot.indexOf('vbscript:') === 0 || prot.indexOf('data:') === 0) {
+ return null;
+ }
+ }
+
+ if (base && !originIndependentUrl.test(href)) {
+ href = resolveUrl(base, href);
+ }
+
+ try {
+ href = encodeURI(href).replace(/%25/g, '%');
+ } catch (e) {
+ return null;
+ }
+
+ return href;
+ }
+ var baseUrls = {};
+ var justDomain = /^[^:]+:\/*[^/]*$/;
+ var protocol = /^([^:]+:)[\s\S]*$/;
+ var domain = /^([^:]+:\/*[^/]*)[\s\S]*$/;
+ function resolveUrl(base, href) {
+ if (!baseUrls[' ' + base]) {
+ // we can ignore everything in base after the last slash of its path component,
+ // but we might need to add _that_
+ // https://tools.ietf.org/html/rfc3986#section-3
+ if (justDomain.test(base)) {
+ baseUrls[' ' + base] = base + '/';
+ } else {
+ baseUrls[' ' + base] = rtrim(base, '/', true);
+ }
+ }
+
+ base = baseUrls[' ' + base];
+ var relativeBase = base.indexOf(':') === -1;
+
+ if (href.substring(0, 2) === '//') {
+ if (relativeBase) {
+ return href;
+ }
+
+ return base.replace(protocol, '$1') + href;
+ } else if (href.charAt(0) === '/') {
+ if (relativeBase) {
+ return href;
+ }
+
+ return base.replace(domain, '$1') + href;
+ } else {
+ return base + href;
+ }
+ }
+ var noopTest = {
+ exec: function noopTest() {}
+ };
+ function merge(obj) {
+ var i = 1,
+ target,
+ key;
+
+ for (; i < arguments.length; i++) {
+ target = arguments[i];
+
+ for (key in target) {
+ if (Object.prototype.hasOwnProperty.call(target, key)) {
+ obj[key] = target[key];
+ }
+ }
+ }
+
+ return obj;
+ }
+ function splitCells(tableRow, count) {
+ // ensure that every cell-delimiting pipe has a space
+ // before it to distinguish it from an escaped pipe
+ var row = tableRow.replace(/\|/g, function (match, offset, str) {
+ var escaped = false,
+ curr = offset;
+
+ while (--curr >= 0 && str[curr] === '\\') {
+ escaped = !escaped;
+ }
+
+ if (escaped) {
+ // odd number of slashes means | is escaped
+ // so we leave it alone
+ return '|';
+ } else {
+ // add space before unescaped |
+ return ' |';
+ }
+ }),
+ cells = row.split(/ \|/);
+ var i = 0; // First/last cell in a row cannot be empty if it has no leading/trailing pipe
+
+ if (!cells[0].trim()) {
+ cells.shift();
+ }
+
+ if (!cells[cells.length - 1].trim()) {
+ cells.pop();
+ }
+
+ if (cells.length > count) {
+ cells.splice(count);
+ } else {
+ while (cells.length < count) {
+ cells.push('');
+ }
+ }
+
+ for (; i < cells.length; i++) {
+ // leading or trailing whitespace is ignored per the gfm spec
+ cells[i] = cells[i].trim().replace(/\\\|/g, '|');
+ }
+
+ return cells;
+ } // Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
+ // /c*$/ is vulnerable to REDOS.
+ // invert: Remove suffix of non-c chars instead. Default falsey.
+
+ function rtrim(str, c, invert) {
+ var l = str.length;
+
+ if (l === 0) {
+ return '';
+ } // Length of suffix matching the invert condition.
+
+
+ var suffLen = 0; // Step left until we fail to match the invert condition.
+
+ while (suffLen < l) {
+ var currChar = str.charAt(l - suffLen - 1);
+
+ if (currChar === c && !invert) {
+ suffLen++;
+ } else if (currChar !== c && invert) {
+ suffLen++;
+ } else {
+ break;
+ }
+ }
+
+ return str.substr(0, l - suffLen);
+ }
+ function findClosingBracket(str, b) {
+ if (str.indexOf(b[1]) === -1) {
+ return -1;
+ }
+
+ var l = str.length;
+ var level = 0,
+ i = 0;
+
+ for (; i < l; i++) {
+ if (str[i] === '\\') {
+ i++;
+ } else if (str[i] === b[0]) {
+ level++;
+ } else if (str[i] === b[1]) {
+ level--;
+
+ if (level < 0) {
+ return i;
+ }
+ }
+ }
+
+ return -1;
+ }
+ function checkSanitizeDeprecation(opt) {
+ if (opt && opt.sanitize && !opt.silent) {
+ 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');
+ }
+ } // copied from https://stackoverflow.com/a/5450113/806777
+
+ function repeatString(pattern, count) {
+ if (count < 1) {
+ return '';
+ }
+
+ var result = '';
+
+ while (count > 1) {
+ if (count & 1) {
+ result += pattern;
+ }
+
+ count >>= 1;
+ pattern += pattern;
+ }
+
+ return result + pattern;
+ }
+
+ function outputLink(cap, link, raw, lexer) {
+ var href = link.href;
+ var title = link.title ? escape(link.title) : null;
+ var text = cap[1].replace(/\\([\[\]])/g, '$1');
+
+ if (cap[0].charAt(0) !== '!') {
+ lexer.state.inLink = true;
+ var token = {
+ type: 'link',
+ raw: raw,
+ href: href,
+ title: title,
+ text: text,
+ tokens: lexer.inlineTokens(text, [])
+ };
+ lexer.state.inLink = false;
+ return token;
+ } else {
+ return {
+ type: 'image',
+ raw: raw,
+ href: href,
+ title: title,
+ text: escape(text)
+ };
+ }
+ }
+
+ function indentCodeCompensation(raw, text) {
+ var matchIndentToCode = raw.match(/^(\s+)(?:```)/);
+
+ if (matchIndentToCode === null) {
+ return text;
+ }
+
+ var indentToCode = matchIndentToCode[1];
+ return text.split('\n').map(function (node) {
+ var matchIndentInNode = node.match(/^\s+/);
+
+ if (matchIndentInNode === null) {
+ return node;
+ }
+
+ var indentInNode = matchIndentInNode[0];
+
+ if (indentInNode.length >= indentToCode.length) {
+ return node.slice(indentToCode.length);
+ }
+
+ return node;
+ }).join('\n');
+ }
+ /**
+ * Tokenizer
+ */
+
+
+ var Tokenizer = /*#__PURE__*/function () {
+ function Tokenizer(options) {
+ this.options = options || exports.defaults;
+ }
+
+ var _proto = Tokenizer.prototype;
+
+ _proto.space = function space(src) {
+ var cap = this.rules.block.newline.exec(src);
+
+ if (cap) {
+ if (cap[0].length > 1) {
+ return {
+ type: 'space',
+ raw: cap[0]
+ };
+ }
+
+ return {
+ raw: '\n'
+ };
+ }
+ };
+
+ _proto.code = function code(src) {
+ var cap = this.rules.block.code.exec(src);
+
+ if (cap) {
+ var text = cap[0].replace(/^ {1,4}/gm, '');
+ return {
+ type: 'code',
+ raw: cap[0],
+ codeBlockStyle: 'indented',
+ text: !this.options.pedantic ? rtrim(text, '\n') : text
+ };
+ }
+ };
+
+ _proto.fences = function fences(src) {
+ var cap = this.rules.block.fences.exec(src);
+
+ if (cap) {
+ var raw = cap[0];
+ var text = indentCodeCompensation(raw, cap[3] || '');
+ return {
+ type: 'code',
+ raw: raw,
+ lang: cap[2] ? cap[2].trim() : cap[2],
+ text: text
+ };
+ }
+ };
+
+ _proto.heading = function heading(src) {
+ var cap = this.rules.block.heading.exec(src);
+
+ if (cap) {
+ var text = cap[2].trim(); // remove trailing #s
+
+ if (/#$/.test(text)) {
+ var trimmed = rtrim(text, '#');
+
+ if (this.options.pedantic) {
+ text = trimmed.trim();
+ } else if (!trimmed || / $/.test(trimmed)) {
+ // CommonMark requires space before trailing #s
+ text = trimmed.trim();
+ }
+ }
+
+ var token = {
+ type: 'heading',
+ raw: cap[0],
+ depth: cap[1].length,
+ text: text,
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ };
+
+ _proto.hr = function hr(src) {
+ var cap = this.rules.block.hr.exec(src);
+
+ if (cap) {
+ return {
+ type: 'hr',
+ raw: cap[0]
+ };
+ }
+ };
+
+ _proto.blockquote = function blockquote(src) {
+ var cap = this.rules.block.blockquote.exec(src);
+
+ if (cap) {
+ var text = cap[0].replace(/^ *> ?/gm, '');
+ return {
+ type: 'blockquote',
+ raw: cap[0],
+ tokens: this.lexer.blockTokens(text, []),
+ text: text
+ };
+ }
+ };
+
+ _proto.list = function list(src) {
+ var cap = this.rules.block.list.exec(src);
+
+ if (cap) {
+ var raw, istask, ischecked, indent, i, blankLine, endsWithBlankLine, line, lines, itemContents;
+ var bull = cap[1].trim();
+ var isordered = bull.length > 1;
+ var list = {
+ type: 'list',
+ raw: '',
+ ordered: isordered,
+ start: isordered ? +bull.slice(0, -1) : '',
+ loose: false,
+ items: []
+ };
+ bull = isordered ? "\\d{1,9}\\" + bull.slice(-1) : "\\" + bull;
+
+ if (this.options.pedantic) {
+ bull = isordered ? bull : '[*+-]';
+ } // Get next list item
+
+
+ var itemRegex = new RegExp("^( {0,3}" + bull + ")((?: [^\\n]*| *)(?:\\n[^\\n]*)*(?:\\n|$))"); // Get each top-level item
+
+ while (src) {
+ if (this.rules.block.hr.test(src)) {
+ // End list if we encounter an HR (possibly move into itemRegex?)
+ break;
+ }
+
+ if (!(cap = itemRegex.exec(src))) {
+ break;
+ }
+
+ lines = cap[2].split('\n');
+
+ if (this.options.pedantic) {
+ indent = 2;
+ itemContents = lines[0].trimLeft();
+ } else {
+ indent = cap[2].search(/[^ ]/); // Find first non-space char
+
+ indent = cap[1].length + (indent > 4 ? 1 : indent); // intented code blocks after 4 spaces; indent is always 1
+
+ itemContents = lines[0].slice(indent - cap[1].length);
+ }
+
+ blankLine = false;
+ raw = cap[0];
+
+ if (!lines[0] && /^ *$/.test(lines[1])) {
+ // items begin with at most one blank line
+ raw = cap[1] + lines.slice(0, 2).join('\n') + '\n';
+ list.loose = true;
+ lines = [];
+ }
+
+ var nextBulletRegex = new RegExp("^ {0," + Math.min(3, indent - 1) + "}(?:[*+-]|\\d{1,9}[.)])");
+
+ for (i = 1; i < lines.length; i++) {
+ line = lines[i];
+
+ if (this.options.pedantic) {
+ // Re-align to follow commonmark nesting rules
+ line = line.replace(/^ {1,4}(?=( {4})*[^ ])/g, ' ');
+ } // End list item if found start of new bullet
+
+
+ if (nextBulletRegex.test(line)) {
+ raw = cap[1] + lines.slice(0, i).join('\n') + '\n';
+ break;
+ } // Until we encounter a blank line, item contents do not need indentation
+
+
+ if (!blankLine) {
+ if (!line.trim()) {
+ // Check if current line is empty
+ blankLine = true;
+ } // Dedent if possible
+
+
+ if (line.search(/[^ ]/) >= indent) {
+ itemContents += '\n' + line.slice(indent);
+ } else {
+ itemContents += '\n' + line;
+ }
+
+ continue;
+ } // Dedent this line
+
+
+ if (line.search(/[^ ]/) >= indent || !line.trim()) {
+ itemContents += '\n' + line.slice(indent);
+ continue;
+ } else {
+ // Line was not properly indented; end of this item
+ raw = cap[1] + lines.slice(0, i).join('\n') + '\n';
+ break;
+ }
+ }
+
+ if (!list.loose) {
+ // If the previous item ended with a blank line, the list is loose
+ if (endsWithBlankLine) {
+ list.loose = true;
+ } else if (/\n *\n *$/.test(raw)) {
+ endsWithBlankLine = true;
+ }
+ } // Check for task list items
+
+
+ if (this.options.gfm) {
+ istask = /^\[[ xX]\] /.exec(itemContents);
+
+ if (istask) {
+ ischecked = istask[0] !== '[ ] ';
+ itemContents = itemContents.replace(/^\[[ xX]\] +/, '');
+ }
+ }
+
+ list.items.push({
+ type: 'list_item',
+ raw: raw,
+ task: !!istask,
+ checked: ischecked,
+ loose: false,
+ text: itemContents
+ });
+ list.raw += raw;
+ src = src.slice(raw.length);
+ } // Do not consume newlines at end of final item. Alternatively, make itemRegex *start* with any newlines to simplify/speed up endsWithBlankLine logic
+
+
+ list.items[list.items.length - 1].raw = raw.trimRight();
+ list.items[list.items.length - 1].text = itemContents.trimRight();
+ list.raw = list.raw.trimRight();
+ var l = list.items.length; // Item child tokens handled here at end because we needed to have the final item to trim it first
+
+ for (i = 0; i < l; i++) {
+ this.lexer.state.top = false;
+ list.items[i].tokens = this.lexer.blockTokens(list.items[i].text, []);
+
+ if (list.items[i].tokens.some(function (t) {
+ return t.type === 'space';
+ })) {
+ list.loose = true;
+ list.items[i].loose = true;
+ }
+ }
+
+ return list;
+ }
+ };
+
+ _proto.html = function html(src) {
+ var cap = this.rules.block.html.exec(src);
+
+ if (cap) {
+ var token = {
+ type: 'html',
+ raw: cap[0],
+ pre: !this.options.sanitizer && (cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style'),
+ text: cap[0]
+ };
+
+ if (this.options.sanitize) {
+ token.type = 'paragraph';
+ token.text = this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]);
+ token.tokens = [];
+ this.lexer.inline(token.text, token.tokens);
+ }
+
+ return token;
+ }
+ };
+
+ _proto.def = function def(src) {
+ var cap = this.rules.block.def.exec(src);
+
+ if (cap) {
+ if (cap[3]) cap[3] = cap[3].substring(1, cap[3].length - 1);
+ var tag = cap[1].toLowerCase().replace(/\s+/g, ' ');
+ return {
+ type: 'def',
+ tag: tag,
+ raw: cap[0],
+ href: cap[2],
+ title: cap[3]
+ };
+ }
+ };
+
+ _proto.table = function table(src) {
+ var cap = this.rules.block.table.exec(src);
+
+ if (cap) {
+ var item = {
+ type: 'table',
+ header: splitCells(cap[1]).map(function (c) {
+ return {
+ text: c
+ };
+ }),
+ align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
+ rows: cap[3] ? cap[3].replace(/\n$/, '').split('\n') : []
+ };
+
+ if (item.header.length === item.align.length) {
+ item.raw = cap[0];
+ var l = item.align.length;
+ var i, j, k, row;
+
+ for (i = 0; i < l; i++) {
+ if (/^ *-+: *$/.test(item.align[i])) {
+ item.align[i] = 'right';
+ } else if (/^ *:-+: *$/.test(item.align[i])) {
+ item.align[i] = 'center';
+ } else if (/^ *:-+ *$/.test(item.align[i])) {
+ item.align[i] = 'left';
+ } else {
+ item.align[i] = null;
+ }
+ }
+
+ l = item.rows.length;
+
+ for (i = 0; i < l; i++) {
+ item.rows[i] = splitCells(item.rows[i], item.header.length).map(function (c) {
+ return {
+ text: c
+ };
+ });
+ } // parse child tokens inside headers and cells
+ // header child tokens
+
+
+ l = item.header.length;
+
+ for (j = 0; j < l; j++) {
+ item.header[j].tokens = [];
+ this.lexer.inlineTokens(item.header[j].text, item.header[j].tokens);
+ } // cell child tokens
+
+
+ l = item.rows.length;
+
+ for (j = 0; j < l; j++) {
+ row = item.rows[j];
+
+ for (k = 0; k < row.length; k++) {
+ row[k].tokens = [];
+ this.lexer.inlineTokens(row[k].text, row[k].tokens);
+ }
+ }
+
+ return item;
+ }
+ }
+ };
+
+ _proto.lheading = function lheading(src) {
+ var cap = this.rules.block.lheading.exec(src);
+
+ if (cap) {
+ var token = {
+ type: 'heading',
+ raw: cap[0],
+ depth: cap[2].charAt(0) === '=' ? 1 : 2,
+ text: cap[1],
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ };
+
+ _proto.paragraph = function paragraph(src) {
+ var cap = this.rules.block.paragraph.exec(src);
+
+ if (cap) {
+ var token = {
+ type: 'paragraph',
+ raw: cap[0],
+ text: cap[1].charAt(cap[1].length - 1) === '\n' ? cap[1].slice(0, -1) : cap[1],
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ };
+
+ _proto.text = function text(src) {
+ var cap = this.rules.block.text.exec(src);
+
+ if (cap) {
+ var token = {
+ type: 'text',
+ raw: cap[0],
+ text: cap[0],
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ };
+
+ _proto.escape = function escape$1(src) {
+ var cap = this.rules.inline.escape.exec(src);
+
+ if (cap) {
+ return {
+ type: 'escape',
+ raw: cap[0],
+ text: escape(cap[1])
+ };
+ }
+ };
+
+ _proto.tag = function tag(src) {
+ var cap = this.rules.inline.tag.exec(src);
+
+ if (cap) {
+ if (!this.lexer.state.inLink && /^