marked 14.0.0 → 14.1.1

package/lib/marked.cjs

@@ -1,5 +1,5 @@
 /**
- * marked v14.0.0 - a markdown parser
+ * marked v14.1.1 - a markdown parser
  * Copyright (c) 2011-2024, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
@@ -249,7 +249,7 @@ class _Tokenizer {
     code(src) {
         const cap = this.rules.block.code.exec(src);
         if (cap) {
-            const text = cap[0].replace(/^ {1,4}/gm, '');
+            const text = cap[0].replace(/^(?: {1,4}| {0,3}\t)/gm, '');
             return {
                 type: 'code',
                 raw: cap[0],
@@ -433,7 +433,7 @@ class _Tokenizer {
                     itemContents = line.slice(indent);
                     indent += cap[1].length;
                 }
-                if (blankLine && /^ *$/.test(nextLine)) { // Items begin with at most one blank line
+                if (blankLine && /^[ \t]*$/.test(nextLine)) { // Items begin with at most one blank line
                     raw += nextLine + '\n';
                     src = src.substring(nextLine.length + 1);
                     endEarly = true;
@@ -446,10 +446,15 @@ class _Tokenizer {
                     // Check if following lines should be included in List Item
                     while (src) {
                         const rawLine = src.split('\n', 1)[0];
+                        let nextLineWithoutTabs;
                         nextLine = rawLine;
                         // Re-align to follow commonmark nesting rules
                         if (this.options.pedantic) {
                             nextLine = nextLine.replace(/^ {1,4}(?=( {4})*[^ ])/g, '  ');
+                            nextLineWithoutTabs = nextLine;
+                        }
+                        else {
+                            nextLineWithoutTabs = nextLine.replace(/\t/g, '    ');
                         }
                         // End list item if found code fences
                         if (fencesBeginRegex.test(nextLine)) {
@@ -464,11 +469,11 @@ class _Tokenizer {
                             break;
                         }
                         // Horizontal rule found
-                        if (hrRegex.test(src)) {
+                        if (hrRegex.test(nextLine)) {
                             break;
                         }
-                        if (nextLine.search(/[^ ]/) >= indent || !nextLine.trim()) { // Dedent if possible
-                            itemContents += '\n' + nextLine.slice(indent);
+                        if (nextLineWithoutTabs.search(/[^ ]/) >= indent || !nextLine.trim()) { // Dedent if possible
+                            itemContents += '\n' + nextLineWithoutTabs.slice(indent);
                         }
                         else {
                             // not enough indentation
@@ -476,7 +481,7 @@ class _Tokenizer {
                                 break;
                             }
                             // paragraph continuation unless last line was a different block level element
-                            if (line.search(/[^ ]/) >= 4) { // indented code block
+                            if (line.replace(/\t/g, '    ').search(/[^ ]/) >= 4) { // indented code block
                                 break;
                             }
                             if (fencesBeginRegex.test(line)) {
@@ -495,7 +500,7 @@ class _Tokenizer {
                         }
                         raw += rawLine + '\n';
                         src = src.substring(rawLine.length + 1);
-                        line = nextLine.slice(indent);
+                        line = nextLineWithoutTabs.slice(indent);
                     }
                 }
                 if (!list.loose) {
@@ -503,7 +508,7 @@ class _Tokenizer {
                     if (endsWithBlankLine) {
                         list.loose = true;
                     }
-                    else if (/\n *\n *$/.test(raw)) {
+                    else if (/\n[ \t]*\n[ \t]*$/.test(raw)) {
                         endsWithBlankLine = true;
                     }
                 }
@@ -965,15 +970,15 @@ class _Tokenizer {
 /**
  * Block-Level Grammar
  */
-const newline = /^(?: *(?:\n|$))+/;
-const blockCode = /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/;
+const newline = /^(?:[ \t]*(?:\n|$))+/;
+const blockCode = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
 const fences = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
 const hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
 const heading = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
 const bullet = /(?:[*+-]|\d{1,9}[.)])/;
 const lheading = edit(/^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html))+?)\n {0,3}(=+|-+) *(?:\n+|$)/)
     .replace(/bull/g, bullet) // lists can interrupt
-    .replace(/blockCode/g, / {4}/) // indented code blocks can interrupt
+    .replace(/blockCode/g, /(?: {4}| {0,3}\t)/) // indented code blocks can interrupt
     .replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/) // fenced code blocks can interrupt
     .replace(/blockquote/g, / {0,3}>/) // blockquote can interrupt
     .replace(/heading/g, / {0,3}#{1,6}/) // ATX heading can interrupt
@@ -982,7 +987,7 @@ const lheading = edit(/^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|
 const _paragraph = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
 const blockText = /^[^\n]+/;
 const _blockLabel = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
-const def = edit(/^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/)
+const def = edit(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/)
     .replace('label', _blockLabel)
     .replace('title', /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/)
     .getRegex();
@@ -1002,9 +1007,9 @@ const html = edit('^ {0,3}(?:' // optional indentation
     + '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
     + '|<![A-Z][\\s\\S]*?(?:>\\n*|$)' // (4)
     + '|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)' // (5)
-    + '|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (6)
-    + '|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) open tag
-    + '|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) closing tag
+    + '|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)' // (6)
+    + '|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)' // (7) open tag
+    + '|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)' // (7) closing tag
     + ')', 'i')
     .replace('comment', _comment)
     .replace('tag', _tag)
@@ -1051,7 +1056,7 @@ const gfmTable = edit('^ *([^\\n ].*)\\n' // Header
     .replace('hr', hr)
     .replace('heading', ' {0,3}#{1,6}(?:\\s|$)')
     .replace('blockquote', ' {0,3}>')
-    .replace('code', ' {4}[^\\n]')
+    .replace('code', '(?: {4}| {0,3}\t)[^\\n]')
     .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
     .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
     .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)')
@@ -1331,11 +1336,6 @@ class _Lexer {
         if (this.options.pedantic) {
             src = src.replace(/\t/g, '    ').replace(/^ +$/gm, '');
         }
-        else {
-            src = src.replace(/^( *)(\t+)/gm, (_, leading, tabs) => {
-                return leading + '    '.repeat(tabs.length);
-            });
-        }
         let token;
         let lastToken;
         let cutSrc;
@@ -2078,6 +2078,7 @@ class _Parser {
 
 class _Hooks {
     options;
+    block;
     constructor(options) {
         this.options = options || exports.defaults;
     }
@@ -2104,13 +2105,25 @@ class _Hooks {
     processAllTokens(tokens) {
         return tokens;
     }
+    /**
+     * Provide function to tokenize markdown
+     */
+    provideLexer() {
+        return this.block ? _Lexer.lex : _Lexer.lexInline;
+    }
+    /**
+     * Provide function to parse tokens
+     */
+    provideParser() {
+        return this.block ? _Parser.parse : _Parser.parseInline;
+    }
 }
 
 class Marked {
     defaults = _getDefaults();
     options = this.setOptions;
-    parse = this.parseMarkdown(_Lexer.lex, _Parser.parse);
-    parseInline = this.parseMarkdown(_Lexer.lexInline, _Parser.parseInline);
+    parse = this.parseMarkdown(true);
+    parseInline = this.parseMarkdown(false);
     Parser = _Parser;
     Renderer = _Renderer;
     TextRenderer = _TextRenderer;
@@ -2283,8 +2296,8 @@ class Marked {
                     if (!(prop in hooks)) {
                         throw new Error(`hook '${prop}' does not exist`);
                     }
-                    if (prop === 'options') {
-                        // ignore options property
+                    if (['options', 'block'].includes(prop)) {
+                        // ignore options and block properties
                         continue;
                     }
                     const hooksProp = prop;
@@ -2342,7 +2355,7 @@ class Marked {
     parser(tokens, options) {
         return _Parser.parse(tokens, options ?? this.defaults);
     }
-    parseMarkdown(lexer, parser) {
+    parseMarkdown(blockType) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const parse = (src, options) => {
             const origOpt = { ...options };
@@ -2362,7 +2375,10 @@ class Marked {
             }
             if (opt.hooks) {
                 opt.hooks.options = opt;
+                opt.hooks.block = blockType;
             }
+            const lexer = opt.hooks ? opt.hooks.provideLexer() : (blockType ? _Lexer.lex : _Lexer.lexInline);
+            const parser = opt.hooks ? opt.hooks.provideParser() : (blockType ? _Parser.parse : _Parser.parseInline);
             if (opt.async) {
                 return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src)
                     .then(src => lexer(src, opt))