marked 10.0.0 → 11.0.1

package/lib/marked.umd.js

@@ -1,5 +1,5 @@
 /**
- * marked v10.0.0 - a markdown parser
+ * marked v11.0.1 - a markdown parser
  * Copyright (c) 2011-2023, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
@@ -52,7 +52,7 @@
         "'": '''
     };
     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);
@@ -82,17 +82,17 @@
     }
     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;
@@ -202,7 +202,7 @@
 
     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;
@@ -222,7 +222,7 @@
             raw,
             href,
             title,
-            text: escape(text)
+            text: escape$1(text)
         };
     }
     function indentCodeCompensation(raw, text) {
@@ -251,9 +251,8 @@
      */
     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 || exports.defaults;
         }
@@ -288,7 +287,7 @@
                 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
                 };
             }
@@ -486,7 +485,7 @@
                 }
                 // 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++) {
@@ -525,8 +524,8 @@
             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,
@@ -538,63 +537,56 @@
         }
         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);
@@ -639,7 +631,7 @@
                 return {
                     type: 'escape',
                     raw: cap[0],
-                    text: escape(cap[1])
+                    text: escape$1(cap[1])
                 };
             }
         }
@@ -718,8 +710,8 @@
                     }
                 }
                 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);
             }
         }
@@ -727,8 +719,8 @@
             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 {
@@ -741,7 +733,7 @@
             }
         }
         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
@@ -752,7 +744,7 @@
                 // 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);
@@ -809,7 +801,7 @@
                 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],
@@ -842,11 +834,11 @@
             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 {
@@ -869,7 +861,7 @@
             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 {
@@ -877,9 +869,9 @@
                     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];
                     }
@@ -910,7 +902,7 @@
                     text = cap[0];
                 }
                 else {
-                    text = escape(cap[0]);
+                    text = escape$1(cap[0]);
                 }
                 return {
                     type: 'text',
@@ -924,66 +916,48 @@
     /**
      * 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', '')
@@ -991,54 +965,68 @@
         .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)'
@@ -1046,157 +1034,164 @@
             .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
@@ -1209,7 +1204,6 @@
         inlineQueue;
         constructor(options) {
             // TokenList cannot be created in one go
-            // @ts-expect-error
             this.tokens = [];
             this.tokens.links = Object.create(null);
             this.options = options || exports.defaults;
@@ -1643,13 +1637,13 @@
             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) {
@@ -2173,11 +2167,18 @@
                 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)) {
+                            throw new Error(`renderer '${prop}' does not exist`);
+                        }
+                        if (prop === 'options') {
+                            // ignore options property
+                            continue;
+                        }
+                        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);
@@ -2190,11 +2191,19 @@
                 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)) {
+                            throw new Error(`tokenizer '${prop}' does not exist`);
+                        }
+                        if (['options', 'rules', 'lexer'].includes(prop)) {
+                            // ignore options, rules, and lexer properties
+                            continue;
+                        }
+                        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);
@@ -2208,11 +2217,18 @@
                 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)) {
+                            throw new Error(`hook '${prop}' does not exist`);
+                        }
+                        if (prop === 'options') {
+                            // ignore options property
+                            continue;
+                        }
+                        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);
@@ -2223,7 +2239,7 @@
                             };
                         }
                         else {
-                            hooks[hooksKey] = (...args) => {
+                            hooks[hooksProp] = (...args) => {
                                 let ret = hooksFunc.apply(hooks, args);
                                 if (ret === false) {
                                     ret = prevHook.apply(hooks, args);
@@ -2316,7 +2332,7 @@
                 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);