marked 9.1.6 → 11.0.0

package/lib/marked.esm.js

@@ -1,5 +1,5 @@
 /**
- * marked v9.1.6 - a markdown parser
+ * marked v11.0.0 - a markdown parser
  * Copyright (c) 2011-2023, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
@@ -46,7 +46,7 @@ const escapeReplacements = {
     "'": '''
 };
 const getEscapeReplacement = (ch) => escapeReplacements[ch];
-function escape(html, encode) {
+function escape$1(html, encode) {
     if (encode) {
         if (escapeTest.test(html)) {
             return html.replace(escapeReplace, getEscapeReplacement);
@@ -76,17 +76,17 @@ function unescape(html) {
 }
 const caret = /(^|[^\[])\^/g;
 function edit(regex, opt) {
-    regex = typeof regex === 'string' ? regex : regex.source;
+    let source = typeof regex === 'string' ? regex : regex.source;
     opt = opt || '';
     const obj = {
         replace: (name, val) => {
-            val = typeof val === 'object' && 'source' in val ? val.source : val;
-            val = val.replace(caret, '$1');
-            regex = regex.replace(name, val);
+            let valSource = typeof val === 'string' ? val : val.source;
+            valSource = valSource.replace(caret, '$1');
+            source = source.replace(name, valSource);
             return obj;
         },
         getRegex: () => {
-            return new RegExp(regex, opt);
+            return new RegExp(source, opt);
         }
     };
     return obj;
@@ -196,7 +196,7 @@ function findClosingBracket(str, b) {
 
 function outputLink(cap, link, raw, lexer) {
     const href = link.href;
-    const title = link.title ? escape(link.title) : null;
+    const title = link.title ? escape$1(link.title) : null;
     const text = cap[1].replace(/\\([\[\]])/g, '$1');
     if (cap[0].charAt(0) !== '!') {
         lexer.state.inLink = true;
@@ -216,7 +216,7 @@ function outputLink(cap, link, raw, lexer) {
         raw,
         href,
         title,
-        text: escape(text)
+        text: escape$1(text)
     };
 }
 function indentCodeCompensation(raw, text) {
@@ -245,9 +245,8 @@ function indentCodeCompensation(raw, text) {
  */
 class _Tokenizer {
     options;
-    // TODO: Fix this rules type
-    rules;
-    lexer;
+    rules; // set by the lexer
+    lexer; // set by the lexer
     constructor(options) {
         this.options = options || _defaults;
     }
@@ -282,7 +281,7 @@ class _Tokenizer {
             return {
                 type: 'code',
                 raw,
-                lang: cap[2] ? cap[2].trim().replace(this.rules.inline._escapes, '$1') : cap[2],
+                lang: cap[2] ? cap[2].trim().replace(this.rules.inline.anyPunctuation, '$1') : cap[2],
                 text
             };
         }
@@ -480,7 +479,7 @@ class _Tokenizer {
             }
             // 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.trimEnd();
-            list.items[list.items.length - 1].text = itemContents.trimEnd();
+            (list.items[list.items.length - 1]).text = itemContents.trimEnd();
             list.raw = list.raw.trimEnd();
             // Item child tokens handled here at end because we needed to have the final item to trim it first
             for (let i = 0; i < list.items.length; i++) {
@@ -519,8 +518,8 @@ class _Tokenizer {
         const cap = this.rules.block.def.exec(src);
         if (cap) {
             const tag = cap[1].toLowerCase().replace(/\s+/g, ' ');
-            const href = cap[2] ? cap[2].replace(/^<(.*)>$/, '$1').replace(this.rules.inline._escapes, '$1') : '';
-            const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline._escapes, '$1') : cap[3];
+            const href = cap[2] ? cap[2].replace(/^<(.*)>$/, '$1').replace(this.rules.inline.anyPunctuation, '$1') : '';
+            const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline.anyPunctuation, '$1') : cap[3];
             return {
                 type: 'def',
                 tag,
@@ -532,63 +531,56 @@ class _Tokenizer {
     }
     table(src) {
         const cap = this.rules.block.table.exec(src);
-        if (cap) {
-            if (!/[:|]/.test(cap[2])) {
-                // delimiter row must have a pipe (|) or colon (:) otherwise it is a setext heading
-                return;
+        if (!cap) {
+            return;
+        }
+        if (!/[:|]/.test(cap[2])) {
+            // delimiter row must have a pipe (|) or colon (:) otherwise it is a setext heading
+            return;
+        }
+        const headers = splitCells(cap[1]);
+        const aligns = cap[2].replace(/^\||\| *$/g, '').split('|');
+        const rows = cap[3] && cap[3].trim() ? cap[3].replace(/\n[ \t]*$/, '').split('\n') : [];
+        const item = {
+            type: 'table',
+            raw: cap[0],
+            header: [],
+            align: [],
+            rows: []
+        };
+        if (headers.length !== aligns.length) {
+            // header and align columns must be equal, rows can be different.
+            return;
+        }
+        for (const align of aligns) {
+            if (/^ *-+: *$/.test(align)) {
+                item.align.push('right');
             }
-            const item = {
-                type: 'table',
-                raw: cap[0],
-                header: splitCells(cap[1]).map(c => {
-                    return { text: c, tokens: [] };
-                }),
-                align: cap[2].replace(/^\||\| *$/g, '').split('|'),
-                rows: cap[3] && cap[3].trim() ? cap[3].replace(/\n[ \t]*$/, '').split('\n') : []
-            };
-            if (item.header.length === item.align.length) {
-                let l = item.align.length;
-                let i, j, k, row;
-                for (i = 0; i < l; i++) {
-                    const align = item.align[i];
-                    if (align) {
-                        if (/^ *-+: *$/.test(align)) {
-                            item.align[i] = 'right';
-                        }
-                        else if (/^ *:-+: *$/.test(align)) {
-                            item.align[i] = 'center';
-                        }
-                        else if (/^ *:-+ *$/.test(align)) {
-                            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(c => {
-                        return { text: c, tokens: [] };
-                    });
-                }
-                // 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.inline(item.header[j].text);
-                }
-                // 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.inline(row[k].text);
-                    }
-                }
-                return item;
+            else if (/^ *:-+: *$/.test(align)) {
+                item.align.push('center');
+            }
+            else if (/^ *:-+ *$/.test(align)) {
+                item.align.push('left');
             }
+            else {
+                item.align.push(null);
+            }
+        }
+        for (const header of headers) {
+            item.header.push({
+                text: header,
+                tokens: this.lexer.inline(header)
+            });
         }
+        for (const row of rows) {
+            item.rows.push(splitCells(row, item.header.length).map(cell => {
+                return {
+                    text: cell,
+                    tokens: this.lexer.inline(cell)
+                };
+            }));
+        }
+        return item;
     }
     lheading(src) {
         const cap = this.rules.block.lheading.exec(src);
@@ -633,7 +625,7 @@ class _Tokenizer {
             return {
                 type: 'escape',
                 raw: cap[0],
-                text: escape(cap[1])
+                text: escape$1(cap[1])
             };
         }
     }
@@ -712,8 +704,8 @@ class _Tokenizer {
                 }
             }
             return outputLink(cap, {
-                href: href ? href.replace(this.rules.inline._escapes, '$1') : href,
-                title: title ? title.replace(this.rules.inline._escapes, '$1') : title
+                href: href ? href.replace(this.rules.inline.anyPunctuation, '$1') : href,
+                title: title ? title.replace(this.rules.inline.anyPunctuation, '$1') : title
             }, cap[0], this.lexer);
         }
     }
@@ -721,8 +713,8 @@ class _Tokenizer {
         let cap;
         if ((cap = this.rules.inline.reflink.exec(src))
             || (cap = this.rules.inline.nolink.exec(src))) {
-            let link = (cap[2] || cap[1]).replace(/\s+/g, ' ');
-            link = links[link.toLowerCase()];
+            const linkString = (cap[2] || cap[1]).replace(/\s+/g, ' ');
+            const link = links[linkString.toLowerCase()];
             if (!link) {
                 const text = cap[0].charAt(0);
                 return {
@@ -735,7 +727,7 @@ class _Tokenizer {
         }
     }
     emStrong(src, maskedSrc, prevChar = '') {
-        let match = this.rules.inline.emStrong.lDelim.exec(src);
+        let match = this.rules.inline.emStrongLDelim.exec(src);
         if (!match)
             return;
         // _ can't be between two alphanumerics. \p{L}\p{N} includes non-english alphabet/numbers as well
@@ -746,7 +738,7 @@ class _Tokenizer {
             // unicode Regex counts emoji as 1 char; spread into array for proper count (used multiple times below)
             const lLength = [...match[0]].length - 1;
             let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
-            const endReg = match[0][0] === '*' ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd;
+            const endReg = match[0][0] === '*' ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
             endReg.lastIndex = 0;
             // Clip maskedSrc to same section of string as src (move to lexer?)
             maskedSrc = maskedSrc.slice(-1 * src.length + lLength);
@@ -803,7 +795,7 @@ class _Tokenizer {
             if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
                 text = text.substring(1, text.length - 1);
             }
-            text = escape(text, true);
+            text = escape$1(text, true);
             return {
                 type: 'codespan',
                 raw: cap[0],
@@ -836,11 +828,11 @@ class _Tokenizer {
         if (cap) {
             let text, href;
             if (cap[2] === '@') {
-                text = escape(cap[1]);
+                text = escape$1(cap[1]);
                 href = 'mailto:' + text;
             }
             else {
-                text = escape(cap[1]);
+                text = escape$1(cap[1]);
                 href = text;
             }
             return {
@@ -863,7 +855,7 @@ class _Tokenizer {
         if (cap = this.rules.inline.url.exec(src)) {
             let text, href;
             if (cap[2] === '@') {
-                text = escape(cap[0]);
+                text = escape$1(cap[0]);
                 href = 'mailto:' + text;
             }
             else {
@@ -871,9 +863,9 @@ class _Tokenizer {
                 let prevCapZero;
                 do {
                     prevCapZero = cap[0];
-                    cap[0] = this.rules.inline._backpedal.exec(cap[0])[0];
+                    cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? '';
                 } while (prevCapZero !== cap[0]);
-                text = escape(cap[0]);
+                text = escape$1(cap[0]);
                 if (cap[1] === 'www.') {
                     href = 'http://' + cap[0];
                 }
@@ -904,7 +896,7 @@ class _Tokenizer {
                 text = cap[0];
             }
             else {
-                text = escape(cap[0]);
+                text = escape$1(cap[0]);
             }
             return {
                 type: 'text',
@@ -918,66 +910,48 @@ class _Tokenizer {
 /**
  * Block-Level Grammar
  */
-// Not all rules are defined in the object literal
-// @ts-expect-error
-const block = {
-    newline: /^(?: *(?:\n|$))+/,
-    code: /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,
-    fences: /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/,
-    hr: /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/,
-    heading: /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,
-    blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,
-    list: /^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/,
-    html: '^ {0,3}(?:' // optional indentation
-        + '<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
-        + '|comment[^\\n]*(\\n+|$)' // (2)
-        + '|<\\?[\\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
-        + ')',
-    def: /^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/,
-    table: noopTest,
-    lheading: /^(?!bull )((?:.|\n(?!\s*?\n|bull ))+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
-    // regex template, placeholders will be replaced according to different paragraph
-    // interruption rules of commonmark and the original markdown spec:
-    _paragraph: /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,
-    text: /^[^\n]+/
-};
-block._label = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
-block._title = /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/;
-block.def = edit(block.def)
-    .replace('label', block._label)
-    .replace('title', block._title)
+const newline = /^(?: *(?:\n|$))+/;
+const blockCode = /^( {4}[^\n]+(?:\n(?: *(?:\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 )((?:.|\n(?!\s*?\n|bull ))+?)\n {0,3}(=+|-+) *(?:\n+|$)/)
+    .replace(/bull/g, bullet) // lists can interrupt
     .getRegex();
-block.bullet = /(?:[*+-]|\d{1,9}[.)])/;
-block.listItemStart = edit(/^( *)(bull) */)
-    .replace('bull', block.bullet)
+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+|$)/)
+    .replace('label', _blockLabel)
+    .replace('title', /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/)
     .getRegex();
-block.list = edit(block.list)
-    .replace(/bull/g, block.bullet)
-    .replace('hr', '\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))')
-    .replace('def', '\\n+(?=' + block.def.source + ')')
+const list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/)
+    .replace(/bull/g, bullet)
     .getRegex();
-block._tag = 'address|article|aside|base|basefont|blockquote|body|caption'
+const _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';
-block._comment = /<!--(?!-?>)[\s\S]*?(?:-->|$)/;
-block.html = edit(block.html, 'i')
-    .replace('comment', block._comment)
-    .replace('tag', block._tag)
+const _comment = /<!--(?!-?>)[\s\S]*?(?:-->|$)/;
+const html = edit('^ {0,3}(?:' // optional indentation
+    + '<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
+    + '|comment[^\\n]*(\\n+|$)' // (2)
+    + '|<\\?[\\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
+    + ')', 'i')
+    .replace('comment', _comment)
+    .replace('tag', _tag)
     .replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/)
     .getRegex();
-block.lheading = edit(block.lheading)
-    .replace(/bull/g, block.bullet) // lists can interrupt
-    .getRegex();
-block.paragraph = edit(block._paragraph)
-    .replace('hr', block.hr)
+const paragraph = edit(_paragraph)
+    .replace('hr', hr)
     .replace('heading', ' {0,3}#{1,6}(?:\\s|$)')
     .replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
     .replace('|table', '')
@@ -985,54 +959,68 @@ block.paragraph = edit(block._paragraph)
     .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|!--)')
-    .replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
+    .replace('tag', _tag) // pars can be interrupted by type (6) html blocks
     .getRegex();
-block.blockquote = edit(block.blockquote)
-    .replace('paragraph', block.paragraph)
+const blockquote = edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/)
+    .replace('paragraph', paragraph)
     .getRegex();
 /**
  * Normal Block Grammar
  */
-block.normal = { ...block };
+const blockNormal = {
+    blockquote,
+    code: blockCode,
+    def,
+    fences,
+    heading,
+    hr,
+    html,
+    lheading,
+    list,
+    newline,
+    paragraph,
+    table: noopTest,
+    text: blockText
+};
 /**
  * GFM Block Grammar
  */
-block.gfm = {
-    ...block.normal,
-    table: '^ *([^\\n ].*)\\n' // Header
-        + ' {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)' // Align
-        + '(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)' // Cells
-};
-block.gfm.table = edit(block.gfm.table)
-    .replace('hr', block.hr)
+const gfmTable = edit('^ *([^\\n ].*)\\n' // Header
+    + ' {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)' // Align
+    + '(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)') // Cells
+    .replace('hr', hr)
     .replace('heading', ' {0,3}#{1,6}(?:\\s|$)')
     .replace('blockquote', ' {0,3}>')
     .replace('code', ' {4}[^\\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|!--)')
-    .replace('tag', block._tag) // tables can be interrupted by type (6) html blocks
-    .getRegex();
-block.gfm.paragraph = edit(block._paragraph)
-    .replace('hr', block.hr)
-    .replace('heading', ' {0,3}#{1,6}(?:\\s|$)')
-    .replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
-    .replace('table', block.gfm.table) // interrupt paragraphs with table
-    .replace('blockquote', ' {0,3}>')
-    .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|!--)')
-    .replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
+    .replace('tag', _tag) // tables can be interrupted by type (6) html blocks
     .getRegex();
+const blockGfm = {
+    ...blockNormal,
+    table: gfmTable,
+    paragraph: edit(_paragraph)
+        .replace('hr', hr)
+        .replace('heading', ' {0,3}#{1,6}(?:\\s|$)')
+        .replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
+        .replace('table', gfmTable) // interrupt paragraphs with table
+        .replace('blockquote', ' {0,3}>')
+        .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|!--)')
+        .replace('tag', _tag) // pars can be interrupted by type (6) html blocks
+        .getRegex()
+};
 /**
  * Pedantic grammar (original John Gruber's loose markdown specification)
  */
-block.pedantic = {
-    ...block.normal,
+const blockPedantic = {
+    ...blockNormal,
     html: edit('^ *(?:comment *(?:\\n|\\s*$)'
         + '|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)' // closed tag
         + '|<tag(?:"[^"]*"|\'[^\']*\'|\\s[^\'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))')
-        .replace('comment', block._comment)
+        .replace('comment', _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)'
@@ -1040,157 +1028,164 @@ block.pedantic = {
         .getRegex(),
     def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
     heading: /^(#{1,6})(.*)(?:\n+|$)/,
-    fences: noopTest,
+    fences: noopTest, // fences not supported
     lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
-    paragraph: edit(block.normal._paragraph)
-        .replace('hr', block.hr)
+    paragraph: edit(_paragraph)
+        .replace('hr', hr)
         .replace('heading', ' *#{1,6} *[^\n]')
-        .replace('lheading', block.lheading)
+        .replace('lheading', lheading)
+        .replace('|table', '')
         .replace('blockquote', ' {0,3}>')
         .replace('|fences', '')
         .replace('|list', '')
         .replace('|html', '')
+        .replace('|tag', '')
         .getRegex()
 };
 /**
  * Inline-Level Grammar
  */
-// Not all rules are defined in the object literal
-// @ts-expect-error
-const inline = {
-    escape: /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,
-    autolink: /^<(scheme:[^\s\x00-\x1f<>]*|email)>/,
-    url: noopTest,
-    tag: '^comment'
-        + '|^</[a-zA-Z][\\w:-]*\\s*>' // self-closing tag
-        + '|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>' // open tag
-        + '|^<\\?[\\s\\S]*?\\?>' // processing instruction, e.g. <?php ?>
-        + '|^<![a-zA-Z]+\\s[\\s\\S]*?>' // declaration, e.g. <!DOCTYPE html>
-        + '|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>',
-    link: /^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/,
-    reflink: /^!?\[(label)\]\[(ref)\]/,
-    nolink: /^!?\[(ref)\](?:\[\])?/,
-    reflinkSearch: 'reflink|nolink(?!\\()',
-    emStrong: {
-        lDelim: /^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/,
-        //         (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.
-        //         | Skip orphan inside strong      | Consume to delim | (1) #***              | (2) a***#, a***                    | (3) #***a, ***a                  | (4) ***#                 | (5) #***#                         | (6) a***a
-        rDelimAst: /^[^_*]*?__[^_*]*?\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\*)[punct](\*+)(?=[\s]|$)|[^punct\s](\*+)(?!\*)(?=[punct\s]|$)|(?!\*)[punct\s](\*+)(?=[^punct\s])|[\s](\*+)(?!\*)(?=[punct])|(?!\*)[punct](\*+)(?!\*)(?=[punct])|[^punct\s](\*+)(?=[^punct\s])/,
-        rDelimUnd: /^[^_*]*?\*\*[^_*]*?_[^_*]*?(?=\*\*)|[^_]+(?=[^_])|(?!_)[punct](_+)(?=[\s]|$)|[^punct\s](_+)(?!_)(?=[punct\s]|$)|(?!_)[punct\s](_+)(?=[^punct\s])|[\s](_+)(?!_)(?=[punct])|(?!_)[punct](_+)(?!_)(?=[punct])/ // ^- Not allowed for _
-    },
-    code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
-    br: /^( {2,}|\\)\n(?!\s*$)/,
-    del: noopTest,
-    text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/,
-    punctuation: /^((?![*_])[\spunctuation])/
-};
+const escape = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+const inlineCode = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+const br = /^( {2,}|\\)\n(?!\s*$)/;
+const inlineText = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
 // list of unicode punctuation marks, plus any missing characters from CommonMark spec
-inline._punctuation = '\\p{P}$+<=>`^|~';
-inline.punctuation = edit(inline.punctuation, 'u').replace(/punctuation/g, inline._punctuation).getRegex();
+const _punctuation = '\\p{P}$+<=>`^|~';
+const punctuation = edit(/^((?![*_])[\spunctuation])/, 'u')
+    .replace(/punctuation/g, _punctuation).getRegex();
 // sequences em should skip over [title](link), `code`, <html>
-inline.blockSkip = /\[[^[\]]*?\]\([^\(\)]*?\)|`[^`]*?`|<[^<>]*?>/g;
-inline.anyPunctuation = /\\[punct]/g;
-inline._escapes = /\\([punct])/g;
-inline._comment = edit(block._comment).replace('(?:-->|$)', '-->').getRegex();
-inline.emStrong.lDelim = edit(inline.emStrong.lDelim, 'u')
-    .replace(/punct/g, inline._punctuation)
-    .getRegex();
-inline.emStrong.rDelimAst = edit(inline.emStrong.rDelimAst, 'gu')
-    .replace(/punct/g, inline._punctuation)
+const blockSkip = /\[[^[\]]*?\]\([^\(\)]*?\)|`[^`]*?`|<[^<>]*?>/g;
+const emStrongLDelim = edit(/^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/, 'u')
+    .replace(/punct/g, _punctuation)
     .getRegex();
-inline.emStrong.rDelimUnd = edit(inline.emStrong.rDelimUnd, 'gu')
-    .replace(/punct/g, inline._punctuation)
+const emStrongRDelimAst = edit('^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)' // Skip orphan inside strong
+    + '|[^*]+(?=[^*])' // Consume to delim
+    + '|(?!\\*)[punct](\\*+)(?=[\\s]|$)' // (1) #*** can only be a Right Delimiter
+    + '|[^punct\\s](\\*+)(?!\\*)(?=[punct\\s]|$)' // (2) a***#, a*** can only be a Right Delimiter
+    + '|(?!\\*)[punct\\s](\\*+)(?=[^punct\\s])' // (3) #***a, ***a can only be Left Delimiter
+    + '|[\\s](\\*+)(?!\\*)(?=[punct])' // (4) ***# can only be Left Delimiter
+    + '|(?!\\*)[punct](\\*+)(?!\\*)(?=[punct])' // (5) #***# can be either Left or Right Delimiter
+    + '|[^punct\\s](\\*+)(?=[^punct\\s])', 'gu') // (6) a***a can be either Left or Right Delimiter
+    .replace(/punct/g, _punctuation)
     .getRegex();
-inline.anyPunctuation = edit(inline.anyPunctuation, 'gu')
-    .replace(/punct/g, inline._punctuation)
+// (6) Not allowed for _
+const emStrongRDelimUnd = edit('^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)' // Skip orphan inside strong
+    + '|[^_]+(?=[^_])' // Consume to delim
+    + '|(?!_)[punct](_+)(?=[\\s]|$)' // (1) #___ can only be a Right Delimiter
+    + '|[^punct\\s](_+)(?!_)(?=[punct\\s]|$)' // (2) a___#, a___ can only be a Right Delimiter
+    + '|(?!_)[punct\\s](_+)(?=[^punct\\s])' // (3) #___a, ___a can only be Left Delimiter
+    + '|[\\s](_+)(?!_)(?=[punct])' // (4) ___# can only be Left Delimiter
+    + '|(?!_)[punct](_+)(?!_)(?=[punct])', 'gu') // (5) #___# can be either Left or Right Delimiter
+    .replace(/punct/g, _punctuation)
     .getRegex();
-inline._escapes = edit(inline._escapes, 'gu')
-    .replace(/punct/g, inline._punctuation)
+const anyPunctuation = edit(/\\([punct])/, 'gu')
+    .replace(/punct/g, _punctuation)
     .getRegex();
-inline._scheme = /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/;
-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])?)+(?![-_])/;
-inline.autolink = edit(inline.autolink)
-    .replace('scheme', inline._scheme)
-    .replace('email', inline._email)
+const autolink = edit(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/)
+    .replace('scheme', /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/)
+    .replace('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])?)+(?![-_])/)
     .getRegex();
-inline._attribute = /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/;
-inline.tag = edit(inline.tag)
-    .replace('comment', inline._comment)
-    .replace('attribute', inline._attribute)
+const _inlineComment = edit(_comment).replace('(?:-->|$)', '-->').getRegex();
+const tag = edit('^comment'
+    + '|^</[a-zA-Z][\\w:-]*\\s*>' // self-closing tag
+    + '|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>' // open tag
+    + '|^<\\?[\\s\\S]*?\\?>' // processing instruction, e.g. <?php ?>
+    + '|^<![a-zA-Z]+\\s[\\s\\S]*?>' // declaration, e.g. <!DOCTYPE html>
+    + '|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>') // CDATA section
+    .replace('comment', _inlineComment)
+    .replace('attribute', /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/)
     .getRegex();
-inline._label = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
-inline._href = /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/;
-inline._title = /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/;
-inline.link = edit(inline.link)
-    .replace('label', inline._label)
-    .replace('href', inline._href)
-    .replace('title', inline._title)
+const _inlineLabel = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
+const link = edit(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/)
+    .replace('label', _inlineLabel)
+    .replace('href', /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/)
+    .replace('title', /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/)
     .getRegex();
-inline.reflink = edit(inline.reflink)
-    .replace('label', inline._label)
-    .replace('ref', block._label)
+const reflink = edit(/^!?\[(label)\]\[(ref)\]/)
+    .replace('label', _inlineLabel)
+    .replace('ref', _blockLabel)
     .getRegex();
-inline.nolink = edit(inline.nolink)
-    .replace('ref', block._label)
+const nolink = edit(/^!?\[(ref)\](?:\[\])?/)
+    .replace('ref', _blockLabel)
     .getRegex();
-inline.reflinkSearch = edit(inline.reflinkSearch, 'g')
-    .replace('reflink', inline.reflink)
-    .replace('nolink', inline.nolink)
+const reflinkSearch = edit('reflink|nolink(?!\\()', 'g')
+    .replace('reflink', reflink)
+    .replace('nolink', nolink)
     .getRegex();
 /**
  * Normal Inline Grammar
  */
-inline.normal = { ...inline };
+const inlineNormal = {
+    _backpedal: noopTest, // only used for GFM url
+    anyPunctuation,
+    autolink,
+    blockSkip,
+    br,
+    code: inlineCode,
+    del: noopTest,
+    emStrongLDelim,
+    emStrongRDelimAst,
+    emStrongRDelimUnd,
+    escape,
+    link,
+    nolink,
+    punctuation,
+    reflink,
+    reflinkSearch,
+    tag,
+    text: inlineText,
+    url: noopTest
+};
 /**
  * Pedantic Inline Grammar
  */
-inline.pedantic = {
-    ...inline.normal,
-    strong: {
-        start: /^__|\*\*/,
-        middle: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,
-        endAst: /\*\*(?!\*)/g,
-        endUnd: /__(?!_)/g
-    },
-    em: {
-        start: /^_|\*/,
-        middle: /^()\*(?=\S)([\s\S]*?\S)\*(?!\*)|^_(?=\S)([\s\S]*?\S)_(?!_)/,
-        endAst: /\*(?!\*)/g,
-        endUnd: /_(?!_)/g
-    },
+const inlinePedantic = {
+    ...inlineNormal,
     link: edit(/^!?\[(label)\]\((.*?)\)/)
-        .replace('label', inline._label)
+        .replace('label', _inlineLabel)
         .getRegex(),
     reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/)
-        .replace('label', inline._label)
+        .replace('label', _inlineLabel)
         .getRegex()
 };
 /**
  * GFM Inline Grammar
  */
-inline.gfm = {
-    ...inline.normal,
-    escape: edit(inline.escape).replace('])', '~|])').getRegex(),
-    _extended_email: /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,
-    url: /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,
+const inlineGfm = {
+    ...inlineNormal,
+    escape: edit(escape).replace('])', '~|])').getRegex(),
+    url: edit(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, 'i')
+        .replace('email', /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/)
+        .getRegex(),
     _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,
     del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
     text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
 };
-inline.gfm.url = edit(inline.gfm.url, 'i')
-    .replace('email', inline.gfm._extended_email)
-    .getRegex();
 /**
  * GFM + Line Breaks Inline Grammar
  */
-inline.breaks = {
-    ...inline.gfm,
-    br: edit(inline.br).replace('{2,}', '*').getRegex(),
-    text: edit(inline.gfm.text)
+const inlineBreaks = {
+    ...inlineGfm,
+    br: edit(br).replace('{2,}', '*').getRegex(),
+    text: edit(inlineGfm.text)
         .replace('\\b_', '\\b_| {2,}\\n')
         .replace(/\{2,\}/g, '*')
         .getRegex()
 };
+/**
+ * exports
+ */
+const block = {
+    normal: blockNormal,
+    gfm: blockGfm,
+    pedantic: blockPedantic
+};
+const inline = {
+    normal: inlineNormal,
+    gfm: inlineGfm,
+    breaks: inlineBreaks,
+    pedantic: inlinePedantic
+};
 
 /**
  * Block Lexer
@@ -1203,7 +1198,6 @@ class _Lexer {
     inlineQueue;
     constructor(options) {
         // TokenList cannot be created in one go
-        // @ts-expect-error
         this.tokens = [];
         this.tokens.links = Object.create(null);
         this.options = options || _defaults;
@@ -1637,13 +1631,13 @@ class _Renderer {
         code = code.replace(/\n$/, '') + '\n';
         if (!lang) {
             return '<pre><code>'
-                + (escaped ? code : escape(code, true))
+                + (escaped ? code : escape$1(code, true))
                 + '</code></pre>\n';
         }
         return '<pre><code class="language-'
-            + escape(lang)
+            + escape$1(lang)
             + '">'
-            + (escaped ? code : escape(code, true))
+            + (escaped ? code : escape$1(code, true))
             + '</code></pre>\n';
     }
     blockquote(quote) {
@@ -2167,11 +2161,14 @@ class Marked {
             if (pack.renderer) {
                 const renderer = this.defaults.renderer || new _Renderer(this.defaults);
                 for (const prop in pack.renderer) {
-                    const rendererFunc = pack.renderer[prop];
-                    const rendererKey = prop;
-                    const prevRenderer = renderer[rendererKey];
+                    if (!(prop in renderer) || prop === 'options') {
+                        throw new Error(`renderer '${prop}' does not exist`);
+                    }
+                    const rendererProp = prop;
+                    const rendererFunc = pack.renderer[rendererProp];
+                    const prevRenderer = renderer[rendererProp];
                     // Replace renderer with func to run extension, but fall back if false
-                    renderer[rendererKey] = (...args) => {
+                    renderer[rendererProp] = (...args) => {
                         let ret = rendererFunc.apply(renderer, args);
                         if (ret === false) {
                             ret = prevRenderer.apply(renderer, args);
@@ -2184,11 +2181,15 @@ class Marked {
             if (pack.tokenizer) {
                 const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);
                 for (const prop in pack.tokenizer) {
-                    const tokenizerFunc = pack.tokenizer[prop];
-                    const tokenizerKey = prop;
-                    const prevTokenizer = tokenizer[tokenizerKey];
+                    if (!(prop in tokenizer) || ['options', 'rules', 'lexer'].includes(prop)) {
+                        throw new Error(`tokenizer '${prop}' does not exist`);
+                    }
+                    const tokenizerProp = prop;
+                    const tokenizerFunc = pack.tokenizer[tokenizerProp];
+                    const prevTokenizer = tokenizer[tokenizerProp];
                     // Replace tokenizer with func to run extension, but fall back if false
-                    tokenizer[tokenizerKey] = (...args) => {
+                    // @ts-expect-error cannot type tokenizer function dynamically
+                    tokenizer[tokenizerProp] = (...args) => {
                         let ret = tokenizerFunc.apply(tokenizer, args);
                         if (ret === false) {
                             ret = prevTokenizer.apply(tokenizer, args);
@@ -2202,11 +2203,14 @@ class Marked {
             if (pack.hooks) {
                 const hooks = this.defaults.hooks || new _Hooks();
                 for (const prop in pack.hooks) {
-                    const hooksFunc = pack.hooks[prop];
-                    const hooksKey = prop;
-                    const prevHook = hooks[hooksKey];
+                    if (!(prop in hooks) || prop === 'options') {
+                        throw new Error(`hook '${prop}' does not exist`);
+                    }
+                    const hooksProp = prop;
+                    const hooksFunc = pack.hooks[hooksProp];
+                    const prevHook = hooks[hooksProp];
                     if (_Hooks.passThroughHooks.has(prop)) {
-                        hooks[hooksKey] = (arg) => {
+                        hooks[hooksProp] = (arg) => {
                             if (this.defaults.async) {
                                 return Promise.resolve(hooksFunc.call(hooks, arg)).then(ret => {
                                     return prevHook.call(hooks, ret);
@@ -2217,7 +2221,7 @@ class Marked {
                         };
                     }
                     else {
-                        hooks[hooksKey] = (...args) => {
+                        hooks[hooksProp] = (...args) => {
                             let ret = hooksFunc.apply(hooks, args);
                             if (ret === false) {
                                 ret = prevHook.apply(hooks, args);
@@ -2310,7 +2314,7 @@ class Marked {
             e.message += '\nPlease report this to https://github.com/markedjs/marked.';
             if (silent) {
                 const msg = '<p>An error occurred:</p><pre>'
-                    + escape(e.message + '', true)
+                    + escape$1(e.message + '', true)
                     + '</pre>';
                 if (async) {
                     return Promise.resolve(msg);