{"version":3,"sources":["jsdelivr-header.js","/npm/marked@14.0.0/src/defaults.ts","/npm/marked@14.0.0/src/helpers.ts","/npm/marked@14.0.0/src/Tokenizer.ts","/npm/marked@14.0.0/src/rules.ts","/npm/marked@14.0.0/src/Lexer.ts","/npm/marked@14.0.0/src/Renderer.ts","/npm/marked@14.0.0/src/TextRenderer.ts","/npm/marked@14.0.0/src/Parser.ts","/npm/marked@14.0.0/src/Hooks.ts","/npm/marked@14.0.0/src/Instance.ts","/npm/marked@14.0.0/src/marked.ts"],"names":[],"mappings":"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","file":"/npm/marked@14.0.0/lib/marked.umd.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.37.0.\n * Original file: /npm/marked@14.0.0/lib/marked.umd.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/**\n * Gets the original marked default options.\n */\nexport function _getDefaults() {\n    return {\n        async: false,\n        breaks: false,\n        extensions: null,\n        gfm: true,\n        hooks: null,\n        pedantic: false,\n        renderer: null,\n        silent: false,\n        tokenizer: null,\n        walkTokens: null,\n    };\n}\nexport let _defaults = _getDefaults();\nexport function changeDefaults(newDefaults) {\n    _defaults = newDefaults;\n}\n","/**\n * Helpers\n */\nconst escapeTest = /[&<>\"']/;\nconst escapeReplace = new RegExp(escapeTest.source, 'g');\nconst escapeTestNoEncode = /[<>\"']|&(?!(#\\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\\w+);)/;\nconst escapeReplaceNoEncode = new RegExp(escapeTestNoEncode.source, 'g');\nconst escapeReplacements = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;',\n};\nconst getEscapeReplacement = (ch) => escapeReplacements[ch];\nexport function escape(html, encode) {\n    if (encode) {\n        if (escapeTest.test(html)) {\n            return html.replace(escapeReplace, getEscapeReplacement);\n        }\n    }\n    else {\n        if (escapeTestNoEncode.test(html)) {\n            return html.replace(escapeReplaceNoEncode, getEscapeReplacement);\n        }\n    }\n    return html;\n}\nconst unescapeTest = /&(#(?:\\d+)|(?:#x[0-9A-Fa-f]+)|(?:\\w+));?/ig;\nexport function unescape(html) {\n    // explicitly match decimal, hex, and named HTML entities\n    return html.replace(unescapeTest, (_, n) => {\n        n = n.toLowerCase();\n        if (n === 'colon')\n            return ':';\n        if (n.charAt(0) === '#') {\n            return n.charAt(1) === 'x'\n                ? String.fromCharCode(parseInt(n.substring(2), 16))\n                : String.fromCharCode(+n.substring(1));\n        }\n        return '';\n    });\n}\nconst caret = /(^|[^\\[])\\^/g;\nexport function edit(regex, opt) {\n    let source = typeof regex === 'string' ? regex : regex.source;\n    opt = opt || '';\n    const obj = {\n        replace: (name, val) => {\n            let valSource = typeof val === 'string' ? val : val.source;\n            valSource = valSource.replace(caret, '$1');\n            source = source.replace(name, valSource);\n            return obj;\n        },\n        getRegex: () => {\n            return new RegExp(source, opt);\n        },\n    };\n    return obj;\n}\nexport function cleanUrl(href) {\n    try {\n        href = encodeURI(href).replace(/%25/g, '%');\n    }\n    catch {\n        return null;\n    }\n    return href;\n}\nexport const noopTest = { exec: () => null };\nexport function splitCells(tableRow, count) {\n    // ensure that every cell-delimiting pipe has a space\n    // before it to distinguish it from an escaped pipe\n    const row = tableRow.replace(/\\|/g, (match, offset, str) => {\n        let escaped = false;\n        let curr = offset;\n        while (--curr >= 0 && str[curr] === '\\\\')\n            escaped = !escaped;\n        if (escaped) {\n            // odd number of slashes means | is escaped\n            // so we leave it alone\n            return '|';\n        }\n        else {\n            // add space before unescaped |\n            return ' |';\n        }\n    }), cells = row.split(/ \\|/);\n    let i = 0;\n    // First/last cell in a row cannot be empty if it has no leading/trailing pipe\n    if (!cells[0].trim()) {\n        cells.shift();\n    }\n    if (cells.length > 0 && !cells[cells.length - 1].trim()) {\n        cells.pop();\n    }\n    if (count) {\n        if (cells.length > count) {\n            cells.splice(count);\n        }\n        else {\n            while (cells.length < count)\n                cells.push('');\n        }\n    }\n    for (; i < cells.length; i++) {\n        // leading or trailing whitespace is ignored per the gfm spec\n        cells[i] = cells[i].trim().replace(/\\\\\\|/g, '|');\n    }\n    return cells;\n}\n/**\n * Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').\n * /c*$/ is vulnerable to REDOS.\n *\n * @param str\n * @param c\n * @param invert Remove suffix of non-c chars instead. Default falsey.\n */\nexport function rtrim(str, c, invert) {\n    const l = str.length;\n    if (l === 0) {\n        return '';\n    }\n    // Length of suffix matching the invert condition.\n    let suffLen = 0;\n    // Step left until we fail to match the invert condition.\n    while (suffLen < l) {\n        const currChar = str.charAt(l - suffLen - 1);\n        if (currChar === c && !invert) {\n            suffLen++;\n        }\n        else if (currChar !== c && invert) {\n            suffLen++;\n        }\n        else {\n            break;\n        }\n    }\n    return str.slice(0, l - suffLen);\n}\nexport function findClosingBracket(str, b) {\n    if (str.indexOf(b[1]) === -1) {\n        return -1;\n    }\n    let level = 0;\n    for (let i = 0; i < str.length; i++) {\n        if (str[i] === '\\\\') {\n            i++;\n        }\n        else if (str[i] === b[0]) {\n            level++;\n        }\n        else if (str[i] === b[1]) {\n            level--;\n            if (level < 0) {\n                return i;\n            }\n        }\n    }\n    return -1;\n}\n","import { _defaults } from './defaults.ts';\nimport { rtrim, splitCells, escape, findClosingBracket, } from './helpers.ts';\nfunction outputLink(cap, link, raw, lexer) {\n    const href = link.href;\n    const title = link.title ? escape(link.title) : null;\n    const text = cap[1].replace(/\\\\([\\[\\]])/g, '$1');\n    if (cap[0].charAt(0) !== '!') {\n        lexer.state.inLink = true;\n        const token = {\n            type: 'link',\n            raw,\n            href,\n            title,\n            text,\n            tokens: lexer.inlineTokens(text),\n        };\n        lexer.state.inLink = false;\n        return token;\n    }\n    return {\n        type: 'image',\n        raw,\n        href,\n        title,\n        text: escape(text),\n    };\n}\nfunction indentCodeCompensation(raw, text) {\n    const matchIndentToCode = raw.match(/^(\\s+)(?:```)/);\n    if (matchIndentToCode === null) {\n        return text;\n    }\n    const indentToCode = matchIndentToCode[1];\n    return text\n        .split('\\n')\n        .map(node => {\n        const matchIndentInNode = node.match(/^\\s+/);\n        if (matchIndentInNode === null) {\n            return node;\n        }\n        const [indentInNode] = matchIndentInNode;\n        if (indentInNode.length >= indentToCode.length) {\n            return node.slice(indentToCode.length);\n        }\n        return node;\n    })\n        .join('\\n');\n}\n/**\n * Tokenizer\n */\nexport class _Tokenizer {\n    options;\n    rules; // set by the lexer\n    lexer; // set by the lexer\n    constructor(options) {\n        this.options = options || _defaults;\n    }\n    space(src) {\n        const cap = this.rules.block.newline.exec(src);\n        if (cap && cap[0].length > 0) {\n            return {\n                type: 'space',\n                raw: cap[0],\n            };\n        }\n    }\n    code(src) {\n        const cap = this.rules.block.code.exec(src);\n        if (cap) {\n            const text = cap[0].replace(/^ {1,4}/gm, '');\n            return {\n                type: 'code',\n                raw: cap[0],\n                codeBlockStyle: 'indented',\n                text: !this.options.pedantic\n                    ? rtrim(text, '\\n')\n                    : text,\n            };\n        }\n    }\n    fences(src) {\n        const cap = this.rules.block.fences.exec(src);\n        if (cap) {\n            const raw = cap[0];\n            const text = indentCodeCompensation(raw, cap[3] || '');\n            return {\n                type: 'code',\n                raw,\n                lang: cap[2] ? cap[2].trim().replace(this.rules.inline.anyPunctuation, '$1') : cap[2],\n                text,\n            };\n        }\n    }\n    heading(src) {\n        const cap = this.rules.block.heading.exec(src);\n        if (cap) {\n            let text = cap[2].trim();\n            // remove trailing #s\n            if (/#$/.test(text)) {\n                const trimmed = rtrim(text, '#');\n                if (this.options.pedantic) {\n                    text = trimmed.trim();\n                }\n                else if (!trimmed || / $/.test(trimmed)) {\n                    // CommonMark requires space before trailing #s\n                    text = trimmed.trim();\n                }\n            }\n            return {\n                type: 'heading',\n                raw: cap[0],\n                depth: cap[1].length,\n                text,\n                tokens: this.lexer.inline(text),\n            };\n        }\n    }\n    hr(src) {\n        const cap = this.rules.block.hr.exec(src);\n        if (cap) {\n            return {\n                type: 'hr',\n                raw: rtrim(cap[0], '\\n'),\n            };\n        }\n    }\n    blockquote(src) {\n        const cap = this.rules.block.blockquote.exec(src);\n        if (cap) {\n            let lines = rtrim(cap[0], '\\n').split('\\n');\n            let raw = '';\n            let text = '';\n            const tokens = [];\n            while (lines.length > 0) {\n                let inBlockquote = false;\n                const currentLines = [];\n                let i;\n                for (i = 0; i < lines.length; i++) {\n                    // get lines up to a continuation\n                    if (/^ {0,3}>/.test(lines[i])) {\n                        currentLines.push(lines[i]);\n                        inBlockquote = true;\n                    }\n                    else if (!inBlockquote) {\n                        currentLines.push(lines[i]);\n                    }\n                    else {\n                        break;\n                    }\n                }\n                lines = lines.slice(i);\n                const currentRaw = currentLines.join('\\n');\n                const currentText = currentRaw\n                    // precede setext continuation with 4 spaces so it isn't a setext\n                    .replace(/\\n {0,3}((?:=+|-+) *)(?=\\n|$)/g, '\\n    $1')\n                    .replace(/^ {0,3}>[ \\t]?/gm, '');\n                raw = raw ? `${raw}\\n${currentRaw}` : currentRaw;\n                text = text ? `${text}\\n${currentText}` : currentText;\n                // parse blockquote lines as top level tokens\n                // merge paragraphs if this is a continuation\n                const top = this.lexer.state.top;\n                this.lexer.state.top = true;\n                this.lexer.blockTokens(currentText, tokens, true);\n                this.lexer.state.top = top;\n                // if there is no continuation then we are done\n                if (lines.length === 0) {\n                    break;\n                }\n                const lastToken = tokens[tokens.length - 1];\n                if (lastToken?.type === 'code') {\n                    // blockquote continuation cannot be preceded by a code block\n                    break;\n                }\n                else if (lastToken?.type === 'blockquote') {\n                    // include continuation in nested blockquote\n                    const oldToken = lastToken;\n                    const newText = oldToken.raw + '\\n' + lines.join('\\n');\n                    const newToken = this.blockquote(newText);\n                    tokens[tokens.length - 1] = newToken;\n                    raw = raw.substring(0, raw.length - oldToken.raw.length) + newToken.raw;\n                    text = text.substring(0, text.length - oldToken.text.length) + newToken.text;\n                    break;\n                }\n                else if (lastToken?.type === 'list') {\n                    // include continuation in nested list\n                    const oldToken = lastToken;\n                    const newText = oldToken.raw + '\\n' + lines.join('\\n');\n                    const newToken = this.list(newText);\n                    tokens[tokens.length - 1] = newToken;\n                    raw = raw.substring(0, raw.length - lastToken.raw.length) + newToken.raw;\n                    text = text.substring(0, text.length - oldToken.raw.length) + newToken.raw;\n                    lines = newText.substring(tokens[tokens.length - 1].raw.length).split('\\n');\n                    continue;\n                }\n            }\n            return {\n                type: 'blockquote',\n                raw,\n                tokens,\n                text,\n            };\n        }\n    }\n    list(src) {\n        let cap = this.rules.block.list.exec(src);\n        if (cap) {\n            let bull = cap[1].trim();\n            const isordered = bull.length > 1;\n            const list = {\n                type: 'list',\n                raw: '',\n                ordered: isordered,\n                start: isordered ? +bull.slice(0, -1) : '',\n                loose: false,\n                items: [],\n            };\n            bull = isordered ? `\\\\d{1,9}\\\\${bull.slice(-1)}` : `\\\\${bull}`;\n            if (this.options.pedantic) {\n                bull = isordered ? bull : '[*+-]';\n            }\n            // Get next list item\n            const itemRegex = new RegExp(`^( {0,3}${bull})((?:[\\t ][^\\\\n]*)?(?:\\\\n|$))`);\n            let endsWithBlankLine = false;\n            // Check if current bullet point can start a new List Item\n            while (src) {\n                let endEarly = false;\n                let raw = '';\n                let itemContents = '';\n                if (!(cap = itemRegex.exec(src))) {\n                    break;\n                }\n                if (this.rules.block.hr.test(src)) { // End list if bullet was actually HR (possibly move into itemRegex?)\n                    break;\n                }\n                raw = cap[0];\n                src = src.substring(raw.length);\n                let line = cap[2].split('\\n', 1)[0].replace(/^\\t+/, (t) => ' '.repeat(3 * t.length));\n                let nextLine = src.split('\\n', 1)[0];\n                let blankLine = !line.trim();\n                let indent = 0;\n                if (this.options.pedantic) {\n                    indent = 2;\n                    itemContents = line.trimStart();\n                }\n                else if (blankLine) {\n                    indent = cap[1].length + 1;\n                }\n                else {\n                    indent = cap[2].search(/[^ ]/); // Find first non-space char\n                    indent = indent > 4 ? 1 : indent; // Treat indented code blocks (> 4 spaces) as having only 1 indent\n                    itemContents = line.slice(indent);\n                    indent += cap[1].length;\n                }\n                if (blankLine && /^ *$/.test(nextLine)) { // Items begin with at most one blank line\n                    raw += nextLine + '\\n';\n                    src = src.substring(nextLine.length + 1);\n                    endEarly = true;\n                }\n                if (!endEarly) {\n                    const nextBulletRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\\\d{1,9}[.)])((?:[ \\t][^\\\\n]*)?(?:\\\\n|$))`);\n                    const hrRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\\\* *){3,})(?:\\\\n+|$)`);\n                    const fencesBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\\`\\`\\`|~~~)`);\n                    const headingBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`);\n                    // Check if following lines should be included in List Item\n                    while (src) {\n                        const rawLine = src.split('\\n', 1)[0];\n                        nextLine = rawLine;\n                        // Re-align to follow commonmark nesting rules\n                        if (this.options.pedantic) {\n                            nextLine = nextLine.replace(/^ {1,4}(?=( {4})*[^ ])/g, '  ');\n                        }\n                        // End list item if found code fences\n                        if (fencesBeginRegex.test(nextLine)) {\n                            break;\n                        }\n                        // End list item if found start of new heading\n                        if (headingBeginRegex.test(nextLine)) {\n                            break;\n                        }\n                        // End list item if found start of new bullet\n                        if (nextBulletRegex.test(nextLine)) {\n                            break;\n                        }\n                        // Horizontal rule found\n                        if (hrRegex.test(src)) {\n                            break;\n                        }\n                        if (nextLine.search(/[^ ]/) >= indent || !nextLine.trim()) { // Dedent if possible\n                            itemContents += '\\n' + nextLine.slice(indent);\n                        }\n                        else {\n                            // not enough indentation\n                            if (blankLine) {\n                                break;\n                            }\n                            // paragraph continuation unless last line was a different block level element\n                            if (line.search(/[^ ]/) >= 4) { // indented code block\n                                break;\n                            }\n                            if (fencesBeginRegex.test(line)) {\n                                break;\n                            }\n                            if (headingBeginRegex.test(line)) {\n                                break;\n                            }\n                            if (hrRegex.test(line)) {\n                                break;\n                            }\n                            itemContents += '\\n' + nextLine;\n                        }\n                        if (!blankLine && !nextLine.trim()) { // Check if current line is blank\n                            blankLine = true;\n                        }\n                        raw += rawLine + '\\n';\n                        src = src.substring(rawLine.length + 1);\n                        line = nextLine.slice(indent);\n                    }\n                }\n                if (!list.loose) {\n                    // If the previous item ended with a blank line, the list is loose\n                    if (endsWithBlankLine) {\n                        list.loose = true;\n                    }\n                    else if (/\\n *\\n *$/.test(raw)) {\n                        endsWithBlankLine = true;\n                    }\n                }\n                let istask = null;\n                let ischecked;\n                // Check for task list items\n                if (this.options.gfm) {\n                    istask = /^\\[[ xX]\\] /.exec(itemContents);\n                    if (istask) {\n                        ischecked = istask[0] !== '[ ] ';\n                        itemContents = itemContents.replace(/^\\[[ xX]\\] +/, '');\n                    }\n                }\n                list.items.push({\n                    type: 'list_item',\n                    raw,\n                    task: !!istask,\n                    checked: ischecked,\n                    loose: false,\n                    text: itemContents,\n                    tokens: [],\n                });\n                list.raw += raw;\n            }\n            // Do not consume newlines at end of final item. Alternatively, make itemRegex *start* with any newlines to simplify/speed up endsWithBlankLine logic\n            list.items[list.items.length - 1].raw = list.items[list.items.length - 1].raw.trimEnd();\n            list.items[list.items.length - 1].text = list.items[list.items.length - 1].text.trimEnd();\n            list.raw = list.raw.trimEnd();\n            // Item child tokens handled here at end because we needed to have the final item to trim it first\n            for (let i = 0; i < list.items.length; i++) {\n                this.lexer.state.top = false;\n                list.items[i].tokens = this.lexer.blockTokens(list.items[i].text, []);\n                if (!list.loose) {\n                    // Check if list should be loose\n                    const spacers = list.items[i].tokens.filter(t => t.type === 'space');\n                    const hasMultipleLineBreaks = spacers.length > 0 && spacers.some(t => /\\n.*\\n/.test(t.raw));\n                    list.loose = hasMultipleLineBreaks;\n                }\n            }\n            // Set all items to loose if list is loose\n            if (list.loose) {\n                for (let i = 0; i < list.items.length; i++) {\n                    list.items[i].loose = true;\n                }\n            }\n            return list;\n        }\n    }\n    html(src) {\n        const cap = this.rules.block.html.exec(src);\n        if (cap) {\n            const token = {\n                type: 'html',\n                block: true,\n                raw: cap[0],\n                pre: cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style',\n                text: cap[0],\n            };\n            return token;\n        }\n    }\n    def(src) {\n        const cap = this.rules.block.def.exec(src);\n        if (cap) {\n            const tag = cap[1].toLowerCase().replace(/\\s+/g, ' ');\n            const href = cap[2] ? cap[2].replace(/^<(.*)>$/, '$1').replace(this.rules.inline.anyPunctuation, '$1') : '';\n            const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline.anyPunctuation, '$1') : cap[3];\n            return {\n                type: 'def',\n                tag,\n                raw: cap[0],\n                href,\n                title,\n            };\n        }\n    }\n    table(src) {\n        const cap = this.rules.block.table.exec(src);\n        if (!cap) {\n            return;\n        }\n        if (!/[:|]/.test(cap[2])) {\n            // delimiter row must have a pipe (|) or colon (:) otherwise it is a setext heading\n            return;\n        }\n        const headers = splitCells(cap[1]);\n        const aligns = cap[2].replace(/^\\||\\| *$/g, '').split('|');\n        const rows = cap[3] && cap[3].trim() ? cap[3].replace(/\\n[ \\t]*$/, '').split('\\n') : [];\n        const item = {\n            type: 'table',\n            raw: cap[0],\n            header: [],\n            align: [],\n            rows: [],\n        };\n        if (headers.length !== aligns.length) {\n            // header and align columns must be equal, rows can be different.\n            return;\n        }\n        for (const align of aligns) {\n            if (/^ *-+: *$/.test(align)) {\n                item.align.push('right');\n            }\n            else if (/^ *:-+: *$/.test(align)) {\n                item.align.push('center');\n            }\n            else if (/^ *:-+ *$/.test(align)) {\n                item.align.push('left');\n            }\n            else {\n                item.align.push(null);\n            }\n        }\n        for (let i = 0; i < headers.length; i++) {\n            item.header.push({\n                text: headers[i],\n                tokens: this.lexer.inline(headers[i]),\n                header: true,\n                align: item.align[i],\n            });\n        }\n        for (const row of rows) {\n            item.rows.push(splitCells(row, item.header.length).map((cell, i) => {\n                return {\n                    text: cell,\n                    tokens: this.lexer.inline(cell),\n                    header: false,\n                    align: item.align[i],\n                };\n            }));\n        }\n        return item;\n    }\n    lheading(src) {\n        const cap = this.rules.block.lheading.exec(src);\n        if (cap) {\n            return {\n                type: 'heading',\n                raw: cap[0],\n                depth: cap[2].charAt(0) === '=' ? 1 : 2,\n                text: cap[1],\n                tokens: this.lexer.inline(cap[1]),\n            };\n        }\n    }\n    paragraph(src) {\n        const cap = this.rules.block.paragraph.exec(src);\n        if (cap) {\n            const text = cap[1].charAt(cap[1].length - 1) === '\\n'\n                ? cap[1].slice(0, -1)\n                : cap[1];\n            return {\n                type: 'paragraph',\n                raw: cap[0],\n                text,\n                tokens: this.lexer.inline(text),\n            };\n        }\n    }\n    text(src) {\n        const cap = this.rules.block.text.exec(src);\n        if (cap) {\n            return {\n                type: 'text',\n                raw: cap[0],\n                text: cap[0],\n                tokens: this.lexer.inline(cap[0]),\n            };\n        }\n    }\n    escape(src) {\n        const cap = this.rules.inline.escape.exec(src);\n        if (cap) {\n            return {\n                type: 'escape',\n                raw: cap[0],\n                text: escape(cap[1]),\n            };\n        }\n    }\n    tag(src) {\n        const cap = this.rules.inline.tag.exec(src);\n        if (cap) {\n            if (!this.lexer.state.inLink && /^<a /i.test(cap[0])) {\n                this.lexer.state.inLink = true;\n            }\n            else if (this.lexer.state.inLink && /^<\\/a>/i.test(cap[0])) {\n                this.lexer.state.inLink = false;\n            }\n            if (!this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\\s|>)/i.test(cap[0])) {\n                this.lexer.state.inRawBlock = true;\n            }\n            else if (this.lexer.state.inRawBlock && /^<\\/(pre|code|kbd|script)(\\s|>)/i.test(cap[0])) {\n                this.lexer.state.inRawBlock = false;\n            }\n            return {\n                type: 'html',\n                raw: cap[0],\n                inLink: this.lexer.state.inLink,\n                inRawBlock: this.lexer.state.inRawBlock,\n                block: false,\n                text: cap[0],\n            };\n        }\n    }\n    link(src) {\n        const cap = this.rules.inline.link.exec(src);\n        if (cap) {\n            const trimmedUrl = cap[2].trim();\n            if (!this.options.pedantic && /^</.test(trimmedUrl)) {\n                // commonmark requires matching angle brackets\n                if (!(/>$/.test(trimmedUrl))) {\n                    return;\n                }\n                // ending angle bracket cannot be escaped\n                const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), '\\\\');\n                if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {\n                    return;\n                }\n            }\n            else {\n                // find closing parenthesis\n                const lastParenIndex = findClosingBracket(cap[2], '()');\n                if (lastParenIndex > -1) {\n                    const start = cap[0].indexOf('!') === 0 ? 5 : 4;\n                    const linkLen = start + cap[1].length + lastParenIndex;\n                    cap[2] = cap[2].substring(0, lastParenIndex);\n                    cap[0] = cap[0].substring(0, linkLen).trim();\n                    cap[3] = '';\n                }\n            }\n            let href = cap[2];\n            let title = '';\n            if (this.options.pedantic) {\n                // split pedantic href and title\n                const link = /^([^'\"]*[^\\s])\\s+(['\"])(.*)\\2/.exec(href);\n                if (link) {\n                    href = link[1];\n                    title = link[3];\n                }\n            }\n            else {\n                title = cap[3] ? cap[3].slice(1, -1) : '';\n            }\n            href = href.trim();\n            if (/^</.test(href)) {\n                if (this.options.pedantic && !(/>$/.test(trimmedUrl))) {\n                    // pedantic allows starting angle bracket without ending angle bracket\n                    href = href.slice(1);\n                }\n                else {\n                    href = href.slice(1, -1);\n                }\n            }\n            return outputLink(cap, {\n                href: href ? href.replace(this.rules.inline.anyPunctuation, '$1') : href,\n                title: title ? title.replace(this.rules.inline.anyPunctuation, '$1') : title,\n            }, cap[0], this.lexer);\n        }\n    }\n    reflink(src, links) {\n        let cap;\n        if ((cap = this.rules.inline.reflink.exec(src))\n            || (cap = this.rules.inline.nolink.exec(src))) {\n            const linkString = (cap[2] || cap[1]).replace(/\\s+/g, ' ');\n            const link = links[linkString.toLowerCase()];\n            if (!link) {\n                const text = cap[0].charAt(0);\n                return {\n                    type: 'text',\n                    raw: text,\n                    text,\n                };\n            }\n            return outputLink(cap, link, cap[0], this.lexer);\n        }\n    }\n    emStrong(src, maskedSrc, prevChar = '') {\n        let match = this.rules.inline.emStrongLDelim.exec(src);\n        if (!match)\n            return;\n        // _ can't be between two alphanumerics. \\p{L}\\p{N} includes non-english alphabet/numbers as well\n        if (match[3] && prevChar.match(/[\\p{L}\\p{N}]/u))\n            return;\n        const nextChar = match[1] || match[2] || '';\n        if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {\n            // unicode Regex counts emoji as 1 char; spread into array for proper count (used multiple times below)\n            const lLength = [...match[0]].length - 1;\n            let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;\n            const endReg = match[0][0] === '*' ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;\n            endReg.lastIndex = 0;\n            // Clip maskedSrc to same section of string as src (move to lexer?)\n            maskedSrc = maskedSrc.slice(-1 * src.length + lLength);\n            while ((match = endReg.exec(maskedSrc)) != null) {\n                rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];\n                if (!rDelim)\n                    continue; // skip single * in __abc*abc__\n                rLength = [...rDelim].length;\n                if (match[3] || match[4]) { // found another Left Delim\n                    delimTotal += rLength;\n                    continue;\n                }\n                else if (match[5] || match[6]) { // either Left or Right Delim\n                    if (lLength % 3 && !((lLength + rLength) % 3)) {\n                        midDelimTotal += rLength;\n                        continue; // CommonMark Emphasis Rules 9-10\n                    }\n                }\n                delimTotal -= rLength;\n                if (delimTotal > 0)\n                    continue; // Haven't found enough closing delimiters\n                // Remove extra characters. *a*** -> *a*\n                rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);\n                // char length can be >1 for unicode characters;\n                const lastCharLength = [...match[0]][0].length;\n                const raw = src.slice(0, lLength + match.index + lastCharLength + rLength);\n                // Create `em` if smallest delimiter has odd char count. *a***\n                if (Math.min(lLength, rLength) % 2) {\n                    const text = raw.slice(1, -1);\n                    return {\n                        type: 'em',\n                        raw,\n                        text,\n                        tokens: this.lexer.inlineTokens(text),\n                    };\n                }\n                // Create 'strong' if smallest delimiter has even char count. **a***\n                const text = raw.slice(2, -2);\n                return {\n                    type: 'strong',\n                    raw,\n                    text,\n                    tokens: this.lexer.inlineTokens(text),\n                };\n            }\n        }\n    }\n    codespan(src) {\n        const cap = this.rules.inline.code.exec(src);\n        if (cap) {\n            let text = cap[2].replace(/\\n/g, ' ');\n            const hasNonSpaceChars = /[^ ]/.test(text);\n            const hasSpaceCharsOnBothEnds = /^ /.test(text) && / $/.test(text);\n            if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {\n                text = text.substring(1, text.length - 1);\n            }\n            text = escape(text, true);\n            return {\n                type: 'codespan',\n                raw: cap[0],\n                text,\n            };\n        }\n    }\n    br(src) {\n        const cap = this.rules.inline.br.exec(src);\n        if (cap) {\n            return {\n                type: 'br',\n                raw: cap[0],\n            };\n        }\n    }\n    del(src) {\n        const cap = this.rules.inline.del.exec(src);\n        if (cap) {\n            return {\n                type: 'del',\n                raw: cap[0],\n                text: cap[2],\n                tokens: this.lexer.inlineTokens(cap[2]),\n            };\n        }\n    }\n    autolink(src) {\n        const cap = this.rules.inline.autolink.exec(src);\n        if (cap) {\n            let text, href;\n            if (cap[2] === '@') {\n                text = escape(cap[1]);\n                href = 'mailto:' + text;\n            }\n            else {\n                text = escape(cap[1]);\n                href = text;\n            }\n            return {\n                type: 'link',\n                raw: cap[0],\n                text,\n                href,\n                tokens: [\n                    {\n                        type: 'text',\n                        raw: text,\n                        text,\n                    },\n                ],\n            };\n        }\n    }\n    url(src) {\n        let cap;\n        if (cap = this.rules.inline.url.exec(src)) {\n            let text, href;\n            if (cap[2] === '@') {\n                text = escape(cap[0]);\n                href = 'mailto:' + text;\n            }\n            else {\n                // do extended autolink path validation\n                let prevCapZero;\n                do {\n                    prevCapZero = cap[0];\n                    cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? '';\n                } while (prevCapZero !== cap[0]);\n                text = escape(cap[0]);\n                if (cap[1] === 'www.') {\n                    href = 'http://' + cap[0];\n                }\n                else {\n                    href = cap[0];\n                }\n            }\n            return {\n                type: 'link',\n                raw: cap[0],\n                text,\n                href,\n                tokens: [\n                    {\n                        type: 'text',\n                        raw: text,\n                        text,\n                    },\n                ],\n            };\n        }\n    }\n    inlineText(src) {\n        const cap = this.rules.inline.text.exec(src);\n        if (cap) {\n            let text;\n            if (this.lexer.state.inRawBlock) {\n                text = cap[0];\n            }\n            else {\n                text = escape(cap[0]);\n            }\n            return {\n                type: 'text',\n                raw: cap[0],\n                text,\n            };\n        }\n    }\n}\n","import { edit, noopTest, } from './helpers.ts';\n/**\n * Block-Level Grammar\n */\nconst newline = /^(?: *(?:\\n|$))+/;\nconst blockCode = /^( {4}[^\\n]+(?:\\n(?: *(?:\\n|$))*)?)+/;\nconst fences = /^ {0,3}(`{3,}(?=[^`\\n]*(?:\\n|$))|~{3,})([^\\n]*)(?:\\n|$)(?:|([\\s\\S]*?)(?:\\n|$))(?: {0,3}\\1[~`]* *(?=\\n|$)|$)/;\nconst hr = /^ {0,3}((?:-[\\t ]*){3,}|(?:_[ \\t]*){3,}|(?:\\*[ \\t]*){3,})(?:\\n+|$)/;\nconst heading = /^ {0,3}(#{1,6})(?=\\s|$)(.*)(?:\\n+|$)/;\nconst bullet = /(?:[*+-]|\\d{1,9}[.)])/;\nconst lheading = edit(/^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|\\n(?!\\s*?\\n|bull |blockCode|fences|blockquote|heading|html))+?)\\n {0,3}(=+|-+) *(?:\\n+|$)/)\n    .replace(/bull/g, bullet) // lists can interrupt\n    .replace(/blockCode/g, / {4}/) // indented code blocks can interrupt\n    .replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/) // fenced code blocks can interrupt\n    .replace(/blockquote/g, / {0,3}>/) // blockquote can interrupt\n    .replace(/heading/g, / {0,3}#{1,6}/) // ATX heading can interrupt\n    .replace(/html/g, / {0,3}<[^\\n>]+>\\n/) // block html can interrupt\n    .getRegex();\nconst _paragraph = /^([^\\n]+(?:\\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\\n)[^\\n]+)*)/;\nconst blockText = /^[^\\n]+/;\nconst _blockLabel = /(?!\\s*\\])(?:\\\\.|[^\\[\\]\\\\])+/;\nconst def = edit(/^ {0,3}\\[(label)\\]: *(?:\\n *)?([^<\\s][^\\s]*|<.*?>)(?:(?: +(?:\\n *)?| *\\n *)(title))? *(?:\\n+|$)/)\n    .replace('label', _blockLabel)\n    .replace('title', /(?:\"(?:\\\\\"?|[^\"\\\\])*\"|'[^'\\n]*(?:\\n[^'\\n]+)*\\n?'|\\([^()]*\\))/)\n    .getRegex();\nconst list = edit(/^( {0,3}bull)([ \\t][^\\n]+?)?(?:\\n|$)/)\n    .replace(/bull/g, bullet)\n    .getRegex();\nconst _tag = 'address|article|aside|base|basefont|blockquote|body|caption'\n    + '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption'\n    + '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe'\n    + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option'\n    + '|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title'\n    + '|tr|track|ul';\nconst _comment = /<!--(?:-?>|[\\s\\S]*?(?:-->|$))/;\nconst html = edit('^ {0,3}(?:' // optional indentation\n    + '<(script|pre|style|textarea)[\\\\s>][\\\\s\\\\S]*?(?:</\\\\1>[^\\\\n]*\\\\n+|$)' // (1)\n    + '|comment[^\\\\n]*(\\\\n+|$)' // (2)\n    + '|<\\\\?[\\\\s\\\\S]*?(?:\\\\?>\\\\n*|$)' // (3)\n    + '|<![A-Z][\\\\s\\\\S]*?(?:>\\\\n*|$)' // (4)\n    + '|<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?(?:\\\\]\\\\]>\\\\n*|$)' // (5)\n    + '|</?(tag)(?: +|\\\\n|/?>)[\\\\s\\\\S]*?(?:(?:\\\\n *)+\\\\n|$)' // (6)\n    + '|<(?!script|pre|style|textarea)([a-z][\\\\w-]*)(?:attribute)*? */?>(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n *)+\\\\n|$)' // (7) open tag\n    + '|</(?!script|pre|style|textarea)[a-z][\\\\w-]*\\\\s*>(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n *)+\\\\n|$)' // (7) closing tag\n    + ')', 'i')\n    .replace('comment', _comment)\n    .replace('tag', _tag)\n    .replace('attribute', / +[a-zA-Z:_][\\w.:-]*(?: *= *\"[^\"\\n]*\"| *= *'[^'\\n]*'| *= *[^\\s\"'=<>`]+)?/)\n    .getRegex();\nconst paragraph = edit(_paragraph)\n    .replace('hr', hr)\n    .replace('heading', ' {0,3}#{1,6}(?:\\\\s|$)')\n    .replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs\n    .replace('|table', '')\n    .replace('blockquote', ' {0,3}>')\n    .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n')\n    .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt\n    .replace('html', '</?(?:tag)(?: +|\\\\n|/?>)|<(?:script|pre|style|textarea|!--)')\n    .replace('tag', _tag) // pars can be interrupted by type (6) html blocks\n    .getRegex();\nconst blockquote = edit(/^( {0,3}> ?(paragraph|[^\\n]*)(?:\\n|$))+/)\n    .replace('paragraph', paragraph)\n    .getRegex();\n/**\n * Normal Block Grammar\n */\nconst blockNormal = {\n    blockquote,\n    code: blockCode,\n    def,\n    fences,\n    heading,\n    hr,\n    html,\n    lheading,\n    list,\n    newline,\n    paragraph,\n    table: noopTest,\n    text: blockText,\n};\n/**\n * GFM Block Grammar\n */\nconst gfmTable = edit('^ *([^\\\\n ].*)\\\\n' // Header\n    + ' {0,3}((?:\\\\| *)?:?-+:? *(?:\\\\| *:?-+:? *)*(?:\\\\| *)?)' // Align\n    + '(?:\\\\n((?:(?! *\\\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\\\n|$))*)\\\\n*|$)') // Cells\n    .replace('hr', hr)\n    .replace('heading', ' {0,3}#{1,6}(?:\\\\s|$)')\n    .replace('blockquote', ' {0,3}>')\n    .replace('code', ' {4}[^\\\\n]')\n    .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n')\n    .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt\n    .replace('html', '</?(?:tag)(?: +|\\\\n|/?>)|<(?:script|pre|style|textarea|!--)')\n    .replace('tag', _tag) // tables can be interrupted by type (6) html blocks\n    .getRegex();\nconst blockGfm = {\n    ...blockNormal,\n    table: gfmTable,\n    paragraph: edit(_paragraph)\n        .replace('hr', hr)\n        .replace('heading', ' {0,3}#{1,6}(?:\\\\s|$)')\n        .replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs\n        .replace('table', gfmTable) // interrupt paragraphs with table\n        .replace('blockquote', ' {0,3}>')\n        .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n')\n        .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt\n        .replace('html', '</?(?:tag)(?: +|\\\\n|/?>)|<(?:script|pre|style|textarea|!--)')\n        .replace('tag', _tag) // pars can be interrupted by type (6) html blocks\n        .getRegex(),\n};\n/**\n * Pedantic grammar (original John Gruber's loose markdown specification)\n */\nconst blockPedantic = {\n    ...blockNormal,\n    html: edit('^ *(?:comment *(?:\\\\n|\\\\s*$)'\n        + '|<(tag)[\\\\s\\\\S]+?</\\\\1> *(?:\\\\n{2,}|\\\\s*$)' // closed tag\n        + '|<tag(?:\"[^\"]*\"|\\'[^\\']*\\'|\\\\s[^\\'\"/>\\\\s]*)*?/?> *(?:\\\\n{2,}|\\\\s*$))')\n        .replace('comment', _comment)\n        .replace(/tag/g, '(?!(?:'\n        + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub'\n        + '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)'\n        + '\\\\b)\\\\w+(?!:|[^\\\\w\\\\s@]*@)\\\\b')\n        .getRegex(),\n    def: /^ *\\[([^\\]]+)\\]: *<?([^\\s>]+)>?(?: +([\"(][^\\n]+[\")]))? *(?:\\n+|$)/,\n    heading: /^(#{1,6})(.*)(?:\\n+|$)/,\n    fences: noopTest, // fences not supported\n    lheading: /^(.+?)\\n {0,3}(=+|-+) *(?:\\n+|$)/,\n    paragraph: edit(_paragraph)\n        .replace('hr', hr)\n        .replace('heading', ' *#{1,6} *[^\\n]')\n        .replace('lheading', lheading)\n        .replace('|table', '')\n        .replace('blockquote', ' {0,3}>')\n        .replace('|fences', '')\n        .replace('|list', '')\n        .replace('|html', '')\n        .replace('|tag', '')\n        .getRegex(),\n};\n/**\n * Inline-Level Grammar\n */\nconst escape = /^\\\\([!\"#$%&'()*+,\\-./:;<=>?@\\[\\]\\\\^_`{|}~])/;\nconst inlineCode = /^(`+)([^`]|[^`][\\s\\S]*?[^`])\\1(?!`)/;\nconst br = /^( {2,}|\\\\)\\n(?!\\s*$)/;\nconst inlineText = /^(`+|[^`])(?:(?= {2,}\\n)|[\\s\\S]*?(?:(?=[\\\\<!\\[`*_]|\\b_|$)|[^ ](?= {2,}\\n)))/;\n// list of unicode punctuation marks, plus any missing characters from CommonMark spec\nconst _punctuation = '\\\\p{P}\\\\p{S}';\nconst punctuation = edit(/^((?![*_])[\\spunctuation])/, 'u')\n    .replace(/punctuation/g, _punctuation).getRegex();\n// sequences em should skip over [title](link), `code`, <html>\nconst blockSkip = /\\[[^[\\]]*?\\]\\([^\\(\\)]*?\\)|`[^`]*?`|<[^<>]*?>/g;\nconst emStrongLDelim = edit(/^(?:\\*+(?:((?!\\*)[punct])|[^\\s*]))|^_+(?:((?!_)[punct])|([^\\s_]))/, 'u')\n    .replace(/punct/g, _punctuation)\n    .getRegex();\nconst emStrongRDelimAst = edit('^[^_*]*?__[^_*]*?\\\\*[^_*]*?(?=__)' // Skip orphan inside strong\n    + '|[^*]+(?=[^*])' // Consume to delim\n    + '|(?!\\\\*)[punct](\\\\*+)(?=[\\\\s]|$)' // (1) #*** can only be a Right Delimiter\n    + '|[^punct\\\\s](\\\\*+)(?!\\\\*)(?=[punct\\\\s]|$)' // (2) a***#, a*** can only be a Right Delimiter\n    + '|(?!\\\\*)[punct\\\\s](\\\\*+)(?=[^punct\\\\s])' // (3) #***a, ***a can only be Left Delimiter\n    + '|[\\\\s](\\\\*+)(?!\\\\*)(?=[punct])' // (4) ***# can only be Left Delimiter\n    + '|(?!\\\\*)[punct](\\\\*+)(?!\\\\*)(?=[punct])' // (5) #***# can be either Left or Right Delimiter\n    + '|[^punct\\\\s](\\\\*+)(?=[^punct\\\\s])', 'gu') // (6) a***a can be either Left or Right Delimiter\n    .replace(/punct/g, _punctuation)\n    .getRegex();\n// (6) Not allowed for _\nconst emStrongRDelimUnd = edit('^[^_*]*?\\\\*\\\\*[^_*]*?_[^_*]*?(?=\\\\*\\\\*)' // Skip orphan inside strong\n    + '|[^_]+(?=[^_])' // Consume to delim\n    + '|(?!_)[punct](_+)(?=[\\\\s]|$)' // (1) #___ can only be a Right Delimiter\n    + '|[^punct\\\\s](_+)(?!_)(?=[punct\\\\s]|$)' // (2) a___#, a___ can only be a Right Delimiter\n    + '|(?!_)[punct\\\\s](_+)(?=[^punct\\\\s])' // (3) #___a, ___a can only be Left Delimiter\n    + '|[\\\\s](_+)(?!_)(?=[punct])' // (4) ___# can only be Left Delimiter\n    + '|(?!_)[punct](_+)(?!_)(?=[punct])', 'gu') // (5) #___# can be either Left or Right Delimiter\n    .replace(/punct/g, _punctuation)\n    .getRegex();\nconst anyPunctuation = edit(/\\\\([punct])/, 'gu')\n    .replace(/punct/g, _punctuation)\n    .getRegex();\nconst autolink = edit(/^<(scheme:[^\\s\\x00-\\x1f<>]*|email)>/)\n    .replace('scheme', /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/)\n    .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])?)+(?![-_])/)\n    .getRegex();\nconst _inlineComment = edit(_comment).replace('(?:-->|$)', '-->').getRegex();\nconst tag = edit('^comment'\n    + '|^</[a-zA-Z][\\\\w:-]*\\\\s*>' // self-closing tag\n    + '|^<[a-zA-Z][\\\\w-]*(?:attribute)*?\\\\s*/?>' // open tag\n    + '|^<\\\\?[\\\\s\\\\S]*?\\\\?>' // processing instruction, e.g. <?php ?>\n    + '|^<![a-zA-Z]+\\\\s[\\\\s\\\\S]*?>' // declaration, e.g. <!DOCTYPE html>\n    + '|^<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>') // CDATA section\n    .replace('comment', _inlineComment)\n    .replace('attribute', /\\s+[a-zA-Z:_][\\w.:-]*(?:\\s*=\\s*\"[^\"]*\"|\\s*=\\s*'[^']*'|\\s*=\\s*[^\\s\"'=<>`]+)?/)\n    .getRegex();\nconst _inlineLabel = /(?:\\[(?:\\\\.|[^\\[\\]\\\\])*\\]|\\\\.|`[^`]*`|[^\\[\\]\\\\`])*?/;\nconst link = edit(/^!?\\[(label)\\]\\(\\s*(href)(?:\\s+(title))?\\s*\\)/)\n    .replace('label', _inlineLabel)\n    .replace('href', /<(?:\\\\.|[^\\n<>\\\\])+>|[^\\s\\x00-\\x1f]*/)\n    .replace('title', /\"(?:\\\\\"?|[^\"\\\\])*\"|'(?:\\\\'?|[^'\\\\])*'|\\((?:\\\\\\)?|[^)\\\\])*\\)/)\n    .getRegex();\nconst reflink = edit(/^!?\\[(label)\\]\\[(ref)\\]/)\n    .replace('label', _inlineLabel)\n    .replace('ref', _blockLabel)\n    .getRegex();\nconst nolink = edit(/^!?\\[(ref)\\](?:\\[\\])?/)\n    .replace('ref', _blockLabel)\n    .getRegex();\nconst reflinkSearch = edit('reflink|nolink(?!\\\\()', 'g')\n    .replace('reflink', reflink)\n    .replace('nolink', nolink)\n    .getRegex();\n/**\n * Normal Inline Grammar\n */\nconst inlineNormal = {\n    _backpedal: noopTest, // only used for GFM url\n    anyPunctuation,\n    autolink,\n    blockSkip,\n    br,\n    code: inlineCode,\n    del: noopTest,\n    emStrongLDelim,\n    emStrongRDelimAst,\n    emStrongRDelimUnd,\n    escape,\n    link,\n    nolink,\n    punctuation,\n    reflink,\n    reflinkSearch,\n    tag,\n    text: inlineText,\n    url: noopTest,\n};\n/**\n * Pedantic Inline Grammar\n */\nconst inlinePedantic = {\n    ...inlineNormal,\n    link: edit(/^!?\\[(label)\\]\\((.*?)\\)/)\n        .replace('label', _inlineLabel)\n        .getRegex(),\n    reflink: edit(/^!?\\[(label)\\]\\s*\\[([^\\]]*)\\]/)\n        .replace('label', _inlineLabel)\n        .getRegex(),\n};\n/**\n * GFM Inline Grammar\n */\nconst inlineGfm = {\n    ...inlineNormal,\n    escape: edit(escape).replace('])', '~|])').getRegex(),\n    url: edit(/^((?:ftp|https?):\\/\\/|www\\.)(?:[a-zA-Z0-9\\-]+\\.?)+[^\\s<]*|^email/, 'i')\n        .replace('email', /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/)\n        .getRegex(),\n    _backpedal: /(?:[^?!.,:;*_'\"~()&]+|\\([^)]*\\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'\"~)]+(?!$))+/,\n    del: /^(~~?)(?=[^\\s~])([\\s\\S]*?[^\\s~])\\1(?=[^~]|$)/,\n    text: /^([`~]+|[^`~])(?:(?= {2,}\\n)|(?=[a-zA-Z0-9.!#$%&'*+\\/=?_`{\\|}~-]+@)|[\\s\\S]*?(?:(?=[\\\\<!\\[`*~_]|\\b_|https?:\\/\\/|ftp:\\/\\/|www\\.|$)|[^ ](?= {2,}\\n)|[^a-zA-Z0-9.!#$%&'*+\\/=?_`{\\|}~-](?=[a-zA-Z0-9.!#$%&'*+\\/=?_`{\\|}~-]+@)))/,\n};\n/**\n * GFM + Line Breaks Inline Grammar\n */\nconst inlineBreaks = {\n    ...inlineGfm,\n    br: edit(br).replace('{2,}', '*').getRegex(),\n    text: edit(inlineGfm.text)\n        .replace('\\\\b_', '\\\\b_| {2,}\\\\n')\n        .replace(/\\{2,\\}/g, '*')\n        .getRegex(),\n};\n/**\n * exports\n */\nexport const block = {\n    normal: blockNormal,\n    gfm: blockGfm,\n    pedantic: blockPedantic,\n};\nexport const inline = {\n    normal: inlineNormal,\n    gfm: inlineGfm,\n    breaks: inlineBreaks,\n    pedantic: inlinePedantic,\n};\n","import { _Tokenizer } from './Tokenizer.ts';\nimport { _defaults } from './defaults.ts';\nimport { block, inline } from './rules.ts';\n/**\n * Block Lexer\n */\nexport class _Lexer {\n    tokens;\n    options;\n    state;\n    tokenizer;\n    inlineQueue;\n    constructor(options) {\n        // TokenList cannot be created in one go\n        this.tokens = [];\n        this.tokens.links = Object.create(null);\n        this.options = options || _defaults;\n        this.options.tokenizer = this.options.tokenizer || new _Tokenizer();\n        this.tokenizer = this.options.tokenizer;\n        this.tokenizer.options = this.options;\n        this.tokenizer.lexer = this;\n        this.inlineQueue = [];\n        this.state = {\n            inLink: false,\n            inRawBlock: false,\n            top: true,\n        };\n        const rules = {\n            block: block.normal,\n            inline: inline.normal,\n        };\n        if (this.options.pedantic) {\n            rules.block = block.pedantic;\n            rules.inline = inline.pedantic;\n        }\n        else if (this.options.gfm) {\n            rules.block = block.gfm;\n            if (this.options.breaks) {\n                rules.inline = inline.breaks;\n            }\n            else {\n                rules.inline = inline.gfm;\n            }\n        }\n        this.tokenizer.rules = rules;\n    }\n    /**\n     * Expose Rules\n     */\n    static get rules() {\n        return {\n            block,\n            inline,\n        };\n    }\n    /**\n     * Static Lex Method\n     */\n    static lex(src, options) {\n        const lexer = new _Lexer(options);\n        return lexer.lex(src);\n    }\n    /**\n     * Static Lex Inline Method\n     */\n    static lexInline(src, options) {\n        const lexer = new _Lexer(options);\n        return lexer.inlineTokens(src);\n    }\n    /**\n     * Preprocessing\n     */\n    lex(src) {\n        src = src\n            .replace(/\\r\\n|\\r/g, '\\n');\n        this.blockTokens(src, this.tokens);\n        for (let i = 0; i < this.inlineQueue.length; i++) {\n            const next = this.inlineQueue[i];\n            this.inlineTokens(next.src, next.tokens);\n        }\n        this.inlineQueue = [];\n        return this.tokens;\n    }\n    blockTokens(src, tokens = [], lastParagraphClipped = false) {\n        if (this.options.pedantic) {\n            src = src.replace(/\\t/g, '    ').replace(/^ +$/gm, '');\n        }\n        else {\n            src = src.replace(/^( *)(\\t+)/gm, (_, leading, tabs) => {\n                return leading + '    '.repeat(tabs.length);\n            });\n        }\n        let token;\n        let lastToken;\n        let cutSrc;\n        while (src) {\n            if (this.options.extensions\n                && this.options.extensions.block\n                && this.options.extensions.block.some((extTokenizer) => {\n                    if (token = extTokenizer.call({ lexer: this }, src, tokens)) {\n                        src = src.substring(token.raw.length);\n                        tokens.push(token);\n                        return true;\n                    }\n                    return false;\n                })) {\n                continue;\n            }\n            // newline\n            if (token = this.tokenizer.space(src)) {\n                src = src.substring(token.raw.length);\n                if (token.raw.length === 1 && tokens.length > 0) {\n                    // if there's a single \\n as a spacer, it's terminating the last line,\n                    // so move it there so that we don't get unnecessary paragraph tags\n                    tokens[tokens.length - 1].raw += '\\n';\n                }\n                else {\n                    tokens.push(token);\n                }\n                continue;\n            }\n            // code\n            if (token = this.tokenizer.code(src)) {\n                src = src.substring(token.raw.length);\n                lastToken = tokens[tokens.length - 1];\n                // An indented code block cannot interrupt a paragraph.\n                if (lastToken && (lastToken.type === 'paragraph' || lastToken.type === 'text')) {\n                    lastToken.raw += '\\n' + token.raw;\n                    lastToken.text += '\\n' + token.text;\n                    this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;\n                }\n                else {\n                    tokens.push(token);\n                }\n                continue;\n            }\n            // fences\n            if (token = this.tokenizer.fences(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // heading\n            if (token = this.tokenizer.heading(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // hr\n            if (token = this.tokenizer.hr(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // blockquote\n            if (token = this.tokenizer.blockquote(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // list\n            if (token = this.tokenizer.list(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // html\n            if (token = this.tokenizer.html(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // def\n            if (token = this.tokenizer.def(src)) {\n                src = src.substring(token.raw.length);\n                lastToken = tokens[tokens.length - 1];\n                if (lastToken && (lastToken.type === 'paragraph' || lastToken.type === 'text')) {\n                    lastToken.raw += '\\n' + token.raw;\n                    lastToken.text += '\\n' + token.raw;\n                    this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;\n                }\n                else if (!this.tokens.links[token.tag]) {\n                    this.tokens.links[token.tag] = {\n                        href: token.href,\n                        title: token.title,\n                    };\n                }\n                continue;\n            }\n            // table (gfm)\n            if (token = this.tokenizer.table(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // lheading\n            if (token = this.tokenizer.lheading(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // top-level paragraph\n            // prevent paragraph consuming extensions by clipping 'src' to extension start\n            cutSrc = src;\n            if (this.options.extensions && this.options.extensions.startBlock) {\n                let startIndex = Infinity;\n                const tempSrc = src.slice(1);\n                let tempStart;\n                this.options.extensions.startBlock.forEach((getStartIndex) => {\n                    tempStart = getStartIndex.call({ lexer: this }, tempSrc);\n                    if (typeof tempStart === 'number' && tempStart >= 0) {\n                        startIndex = Math.min(startIndex, tempStart);\n                    }\n                });\n                if (startIndex < Infinity && startIndex >= 0) {\n                    cutSrc = src.substring(0, startIndex + 1);\n                }\n            }\n            if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {\n                lastToken = tokens[tokens.length - 1];\n                if (lastParagraphClipped && lastToken?.type === 'paragraph') {\n                    lastToken.raw += '\\n' + token.raw;\n                    lastToken.text += '\\n' + token.text;\n                    this.inlineQueue.pop();\n                    this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;\n                }\n                else {\n                    tokens.push(token);\n                }\n                lastParagraphClipped = (cutSrc.length !== src.length);\n                src = src.substring(token.raw.length);\n                continue;\n            }\n            // text\n            if (token = this.tokenizer.text(src)) {\n                src = src.substring(token.raw.length);\n                lastToken = tokens[tokens.length - 1];\n                if (lastToken && lastToken.type === 'text') {\n                    lastToken.raw += '\\n' + token.raw;\n                    lastToken.text += '\\n' + token.text;\n                    this.inlineQueue.pop();\n                    this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;\n                }\n                else {\n                    tokens.push(token);\n                }\n                continue;\n            }\n            if (src) {\n                const errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);\n                if (this.options.silent) {\n                    console.error(errMsg);\n                    break;\n                }\n                else {\n                    throw new Error(errMsg);\n                }\n            }\n        }\n        this.state.top = true;\n        return tokens;\n    }\n    inline(src, tokens = []) {\n        this.inlineQueue.push({ src, tokens });\n        return tokens;\n    }\n    /**\n     * Lexing/Compiling\n     */\n    inlineTokens(src, tokens = []) {\n        let token, lastToken, cutSrc;\n        // String with links masked to avoid interference with em and strong\n        let maskedSrc = src;\n        let match;\n        let keepPrevChar, prevChar;\n        // Mask out reflinks\n        if (this.tokens.links) {\n            const links = Object.keys(this.tokens.links);\n            if (links.length > 0) {\n                while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {\n                    if (links.includes(match[0].slice(match[0].lastIndexOf('[') + 1, -1))) {\n                        maskedSrc = maskedSrc.slice(0, match.index) + '[' + 'a'.repeat(match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);\n                    }\n                }\n            }\n        }\n        // Mask out other blocks\n        while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {\n            maskedSrc = maskedSrc.slice(0, match.index) + '[' + 'a'.repeat(match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);\n        }\n        // Mask out escaped characters\n        while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) != null) {\n            maskedSrc = maskedSrc.slice(0, match.index) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);\n        }\n        while (src) {\n            if (!keepPrevChar) {\n                prevChar = '';\n            }\n            keepPrevChar = false;\n            // extensions\n            if (this.options.extensions\n                && this.options.extensions.inline\n                && this.options.extensions.inline.some((extTokenizer) => {\n                    if (token = extTokenizer.call({ lexer: this }, src, tokens)) {\n                        src = src.substring(token.raw.length);\n                        tokens.push(token);\n                        return true;\n                    }\n                    return false;\n                })) {\n                continue;\n            }\n            // escape\n            if (token = this.tokenizer.escape(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // tag\n            if (token = this.tokenizer.tag(src)) {\n                src = src.substring(token.raw.length);\n                lastToken = tokens[tokens.length - 1];\n                if (lastToken && token.type === 'text' && lastToken.type === 'text') {\n                    lastToken.raw += token.raw;\n                    lastToken.text += token.text;\n                }\n                else {\n                    tokens.push(token);\n                }\n                continue;\n            }\n            // link\n            if (token = this.tokenizer.link(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // reflink, nolink\n            if (token = this.tokenizer.reflink(src, this.tokens.links)) {\n                src = src.substring(token.raw.length);\n                lastToken = tokens[tokens.length - 1];\n                if (lastToken && token.type === 'text' && lastToken.type === 'text') {\n                    lastToken.raw += token.raw;\n                    lastToken.text += token.text;\n                }\n                else {\n                    tokens.push(token);\n                }\n                continue;\n            }\n            // em & strong\n            if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // code\n            if (token = this.tokenizer.codespan(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // br\n            if (token = this.tokenizer.br(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // del (gfm)\n            if (token = this.tokenizer.del(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // autolink\n            if (token = this.tokenizer.autolink(src)) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // url (gfm)\n            if (!this.state.inLink && (token = this.tokenizer.url(src))) {\n                src = src.substring(token.raw.length);\n                tokens.push(token);\n                continue;\n            }\n            // text\n            // prevent inlineText consuming extensions by clipping 'src' to extension start\n            cutSrc = src;\n            if (this.options.extensions && this.options.extensions.startInline) {\n                let startIndex = Infinity;\n                const tempSrc = src.slice(1);\n                let tempStart;\n                this.options.extensions.startInline.forEach((getStartIndex) => {\n                    tempStart = getStartIndex.call({ lexer: this }, tempSrc);\n                    if (typeof tempStart === 'number' && tempStart >= 0) {\n                        startIndex = Math.min(startIndex, tempStart);\n                    }\n                });\n                if (startIndex < Infinity && startIndex >= 0) {\n                    cutSrc = src.substring(0, startIndex + 1);\n                }\n            }\n            if (token = this.tokenizer.inlineText(cutSrc)) {\n                src = src.substring(token.raw.length);\n                if (token.raw.slice(-1) !== '_') { // Track prevChar before string of ____ started\n                    prevChar = token.raw.slice(-1);\n                }\n                keepPrevChar = true;\n                lastToken = tokens[tokens.length - 1];\n                if (lastToken && lastToken.type === 'text') {\n                    lastToken.raw += token.raw;\n                    lastToken.text += token.text;\n                }\n                else {\n                    tokens.push(token);\n                }\n                continue;\n            }\n            if (src) {\n                const errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);\n                if (this.options.silent) {\n                    console.error(errMsg);\n                    break;\n                }\n                else {\n                    throw new Error(errMsg);\n                }\n            }\n        }\n        return tokens;\n    }\n}\n","import { _defaults } from './defaults.ts';\nimport { cleanUrl, escape, } from './helpers.ts';\n/**\n * Renderer\n */\nexport class _Renderer {\n    options;\n    parser; // set by the parser\n    constructor(options) {\n        this.options = options || _defaults;\n    }\n    space(token) {\n        return '';\n    }\n    code({ text, lang, escaped }) {\n        const langString = (lang || '').match(/^\\S*/)?.[0];\n        const code = text.replace(/\\n$/, '') + '\\n';\n        if (!langString) {\n            return '<pre><code>'\n                + (escaped ? code : escape(code, true))\n                + '</code></pre>\\n';\n        }\n        return '<pre><code class=\"language-'\n            + escape(langString)\n            + '\">'\n            + (escaped ? code : escape(code, true))\n            + '</code></pre>\\n';\n    }\n    blockquote({ tokens }) {\n        const body = this.parser.parse(tokens);\n        return `<blockquote>\\n${body}</blockquote>\\n`;\n    }\n    html({ text }) {\n        return text;\n    }\n    heading({ tokens, depth }) {\n        return `<h${depth}>${this.parser.parseInline(tokens)}</h${depth}>\\n`;\n    }\n    hr(token) {\n        return '<hr>\\n';\n    }\n    list(token) {\n        const ordered = token.ordered;\n        const start = token.start;\n        let body = '';\n        for (let j = 0; j < token.items.length; j++) {\n            const item = token.items[j];\n            body += this.listitem(item);\n        }\n        const type = ordered ? 'ol' : 'ul';\n        const startAttr = (ordered && start !== 1) ? (' start=\"' + start + '\"') : '';\n        return '<' + type + startAttr + '>\\n' + body + '</' + type + '>\\n';\n    }\n    listitem(item) {\n        let itemBody = '';\n        if (item.task) {\n            const checkbox = this.checkbox({ checked: !!item.checked });\n            if (item.loose) {\n                if (item.tokens.length > 0 && item.tokens[0].type === 'paragraph') {\n                    item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;\n                    if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {\n                        item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text;\n                    }\n                }\n                else {\n                    item.tokens.unshift({\n                        type: 'text',\n                        raw: checkbox + ' ',\n                        text: checkbox + ' ',\n                    });\n                }\n            }\n            else {\n                itemBody += checkbox + ' ';\n            }\n        }\n        itemBody += this.parser.parse(item.tokens, !!item.loose);\n        return `<li>${itemBody}</li>\\n`;\n    }\n    checkbox({ checked }) {\n        return '<input '\n            + (checked ? 'checked=\"\" ' : '')\n            + 'disabled=\"\" type=\"checkbox\">';\n    }\n    paragraph({ tokens }) {\n        return `<p>${this.parser.parseInline(tokens)}</p>\\n`;\n    }\n    table(token) {\n        let header = '';\n        // header\n        let cell = '';\n        for (let j = 0; j < token.header.length; j++) {\n            cell += this.tablecell(token.header[j]);\n        }\n        header += this.tablerow({ text: cell });\n        let body = '';\n        for (let j = 0; j < token.rows.length; j++) {\n            const row = token.rows[j];\n            cell = '';\n            for (let k = 0; k < row.length; k++) {\n                cell += this.tablecell(row[k]);\n            }\n            body += this.tablerow({ text: cell });\n        }\n        if (body)\n            body = `<tbody>${body}</tbody>`;\n        return '<table>\\n'\n            + '<thead>\\n'\n            + header\n            + '</thead>\\n'\n            + body\n            + '</table>\\n';\n    }\n    tablerow({ text }) {\n        return `<tr>\\n${text}</tr>\\n`;\n    }\n    tablecell(token) {\n        const content = this.parser.parseInline(token.tokens);\n        const type = token.header ? 'th' : 'td';\n        const tag = token.align\n            ? `<${type} align=\"${token.align}\">`\n            : `<${type}>`;\n        return tag + content + `</${type}>\\n`;\n    }\n    /**\n     * span level renderer\n     */\n    strong({ tokens }) {\n        return `<strong>${this.parser.parseInline(tokens)}</strong>`;\n    }\n    em({ tokens }) {\n        return `<em>${this.parser.parseInline(tokens)}</em>`;\n    }\n    codespan({ text }) {\n        return `<code>${text}</code>`;\n    }\n    br(token) {\n        return '<br>';\n    }\n    del({ tokens }) {\n        return `<del>${this.parser.parseInline(tokens)}</del>`;\n    }\n    link({ href, title, tokens }) {\n        const text = this.parser.parseInline(tokens);\n        const cleanHref = cleanUrl(href);\n        if (cleanHref === null) {\n            return text;\n        }\n        href = cleanHref;\n        let out = '<a href=\"' + href + '\"';\n        if (title) {\n            out += ' title=\"' + title + '\"';\n        }\n        out += '>' + text + '</a>';\n        return out;\n    }\n    image({ href, title, text }) {\n        const cleanHref = cleanUrl(href);\n        if (cleanHref === null) {\n            return text;\n        }\n        href = cleanHref;\n        let out = `<img src=\"${href}\" alt=\"${text}\"`;\n        if (title) {\n            out += ` title=\"${title}\"`;\n        }\n        out += '>';\n        return out;\n    }\n    text(token) {\n        return 'tokens' in token && token.tokens ? this.parser.parseInline(token.tokens) : token.text;\n    }\n}\n","/**\n * TextRenderer\n * returns only the textual part of the token\n */\nexport class _TextRenderer {\n    // no need for block level renderers\n    strong({ text }) {\n        return text;\n    }\n    em({ text }) {\n        return text;\n    }\n    codespan({ text }) {\n        return text;\n    }\n    del({ text }) {\n        return text;\n    }\n    html({ text }) {\n        return text;\n    }\n    text({ text }) {\n        return text;\n    }\n    link({ text }) {\n        return '' + text;\n    }\n    image({ text }) {\n        return '' + text;\n    }\n    br() {\n        return '';\n    }\n}\n","import { _Renderer } from './Renderer.ts';\nimport { _TextRenderer } from './TextRenderer.ts';\nimport { _defaults } from './defaults.ts';\n/**\n * Parsing & Compiling\n */\nexport class _Parser {\n    options;\n    renderer;\n    textRenderer;\n    constructor(options) {\n        this.options = options || _defaults;\n        this.options.renderer = this.options.renderer || new _Renderer();\n        this.renderer = this.options.renderer;\n        this.renderer.options = this.options;\n        this.renderer.parser = this;\n        this.textRenderer = new _TextRenderer();\n    }\n    /**\n     * Static Parse Method\n     */\n    static parse(tokens, options) {\n        const parser = new _Parser(options);\n        return parser.parse(tokens);\n    }\n    /**\n     * Static Parse Inline Method\n     */\n    static parseInline(tokens, options) {\n        const parser = new _Parser(options);\n        return parser.parseInline(tokens);\n    }\n    /**\n     * Parse Loop\n     */\n    parse(tokens, top = true) {\n        let out = '';\n        for (let i = 0; i < tokens.length; i++) {\n            const anyToken = tokens[i];\n            // Run any renderer extensions\n            if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[anyToken.type]) {\n                const genericToken = anyToken;\n                const ret = this.options.extensions.renderers[genericToken.type].call({ parser: this }, genericToken);\n                if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'paragraph', 'text'].includes(genericToken.type)) {\n                    out += ret || '';\n                    continue;\n                }\n            }\n            const token = anyToken;\n            switch (token.type) {\n                case 'space': {\n                    out += this.renderer.space(token);\n                    continue;\n                }\n                case 'hr': {\n                    out += this.renderer.hr(token);\n                    continue;\n                }\n                case 'heading': {\n                    out += this.renderer.heading(token);\n                    continue;\n                }\n                case 'code': {\n                    out += this.renderer.code(token);\n                    continue;\n                }\n                case 'table': {\n                    out += this.renderer.table(token);\n                    continue;\n                }\n                case 'blockquote': {\n                    out += this.renderer.blockquote(token);\n                    continue;\n                }\n                case 'list': {\n                    out += this.renderer.list(token);\n                    continue;\n                }\n                case 'html': {\n                    out += this.renderer.html(token);\n                    continue;\n                }\n                case 'paragraph': {\n                    out += this.renderer.paragraph(token);\n                    continue;\n                }\n                case 'text': {\n                    let textToken = token;\n                    let body = this.renderer.text(textToken);\n                    while (i + 1 < tokens.length && tokens[i + 1].type === 'text') {\n                        textToken = tokens[++i];\n                        body += '\\n' + this.renderer.text(textToken);\n                    }\n                    if (top) {\n                        out += this.renderer.paragraph({\n                            type: 'paragraph',\n                            raw: body,\n                            text: body,\n                            tokens: [{ type: 'text', raw: body, text: body }],\n                        });\n                    }\n                    else {\n                        out += body;\n                    }\n                    continue;\n                }\n                default: {\n                    const errMsg = 'Token with \"' + token.type + '\" type was not found.';\n                    if (this.options.silent) {\n                        console.error(errMsg);\n                        return '';\n                    }\n                    else {\n                        throw new Error(errMsg);\n                    }\n                }\n            }\n        }\n        return out;\n    }\n    /**\n     * Parse Inline Tokens\n     */\n    parseInline(tokens, renderer) {\n        renderer = renderer || this.renderer;\n        let out = '';\n        for (let i = 0; i < tokens.length; i++) {\n            const anyToken = tokens[i];\n            // Run any renderer extensions\n            if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[anyToken.type]) {\n                const ret = this.options.extensions.renderers[anyToken.type].call({ parser: this }, anyToken);\n                if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(anyToken.type)) {\n                    out += ret || '';\n                    continue;\n                }\n            }\n            const token = anyToken;\n            switch (token.type) {\n                case 'escape': {\n                    out += renderer.text(token);\n                    break;\n                }\n                case 'html': {\n                    out += renderer.html(token);\n                    break;\n                }\n                case 'link': {\n                    out += renderer.link(token);\n                    break;\n                }\n                case 'image': {\n                    out += renderer.image(token);\n                    break;\n                }\n                case 'strong': {\n                    out += renderer.strong(token);\n                    break;\n                }\n                case 'em': {\n                    out += renderer.em(token);\n                    break;\n                }\n                case 'codespan': {\n                    out += renderer.codespan(token);\n                    break;\n                }\n                case 'br': {\n                    out += renderer.br(token);\n                    break;\n                }\n                case 'del': {\n                    out += renderer.del(token);\n                    break;\n                }\n                case 'text': {\n                    out += renderer.text(token);\n                    break;\n                }\n                default: {\n                    const errMsg = 'Token with \"' + token.type + '\" type was not found.';\n                    if (this.options.silent) {\n                        console.error(errMsg);\n                        return '';\n                    }\n                    else {\n                        throw new Error(errMsg);\n                    }\n                }\n            }\n        }\n        return out;\n    }\n}\n","import { _defaults } from './defaults.ts';\nexport class _Hooks {\n    options;\n    constructor(options) {\n        this.options = options || _defaults;\n    }\n    static passThroughHooks = new Set([\n        'preprocess',\n        'postprocess',\n        'processAllTokens',\n    ]);\n    /**\n     * Process markdown before marked\n     */\n    preprocess(markdown) {\n        return markdown;\n    }\n    /**\n     * Process HTML after marked is finished\n     */\n    postprocess(html) {\n        return html;\n    }\n    /**\n     * Process all tokens before walk tokens\n     */\n    processAllTokens(tokens) {\n        return tokens;\n    }\n}\n","import { _getDefaults } from './defaults.ts';\nimport { _Lexer } from './Lexer.ts';\nimport { _Parser } from './Parser.ts';\nimport { _Hooks } from './Hooks.ts';\nimport { _Renderer } from './Renderer.ts';\nimport { _Tokenizer } from './Tokenizer.ts';\nimport { _TextRenderer } from './TextRenderer.ts';\nimport { escape } from './helpers.ts';\nexport class Marked {\n    defaults = _getDefaults();\n    options = this.setOptions;\n    parse = this.parseMarkdown(_Lexer.lex, _Parser.parse);\n    parseInline = this.parseMarkdown(_Lexer.lexInline, _Parser.parseInline);\n    Parser = _Parser;\n    Renderer = _Renderer;\n    TextRenderer = _TextRenderer;\n    Lexer = _Lexer;\n    Tokenizer = _Tokenizer;\n    Hooks = _Hooks;\n    constructor(...args) {\n        this.use(...args);\n    }\n    /**\n     * Run callback for every token\n     */\n    walkTokens(tokens, callback) {\n        let values = [];\n        for (const token of tokens) {\n            values = values.concat(callback.call(this, token));\n            switch (token.type) {\n                case 'table': {\n                    const tableToken = token;\n                    for (const cell of tableToken.header) {\n                        values = values.concat(this.walkTokens(cell.tokens, callback));\n                    }\n                    for (const row of tableToken.rows) {\n                        for (const cell of row) {\n                            values = values.concat(this.walkTokens(cell.tokens, callback));\n                        }\n                    }\n                    break;\n                }\n                case 'list': {\n                    const listToken = token;\n                    values = values.concat(this.walkTokens(listToken.items, callback));\n                    break;\n                }\n                default: {\n                    const genericToken = token;\n                    if (this.defaults.extensions?.childTokens?.[genericToken.type]) {\n                        this.defaults.extensions.childTokens[genericToken.type].forEach((childTokens) => {\n                            const tokens = genericToken[childTokens].flat(Infinity);\n                            values = values.concat(this.walkTokens(tokens, callback));\n                        });\n                    }\n                    else if (genericToken.tokens) {\n                        values = values.concat(this.walkTokens(genericToken.tokens, callback));\n                    }\n                }\n            }\n        }\n        return values;\n    }\n    use(...args) {\n        const extensions = this.defaults.extensions || { renderers: {}, childTokens: {} };\n        args.forEach((pack) => {\n            // copy options to new object\n            const opts = { ...pack };\n            // set async to true if it was set to true before\n            opts.async = this.defaults.async || opts.async || false;\n            // ==-- Parse \"addon\" extensions --== //\n            if (pack.extensions) {\n                pack.extensions.forEach((ext) => {\n                    if (!ext.name) {\n                        throw new Error('extension name required');\n                    }\n                    if ('renderer' in ext) { // Renderer extensions\n                        const prevRenderer = extensions.renderers[ext.name];\n                        if (prevRenderer) {\n                            // Replace extension with func to run new extension but fall back if false\n                            extensions.renderers[ext.name] = function (...args) {\n                                let ret = ext.renderer.apply(this, args);\n                                if (ret === false) {\n                                    ret = prevRenderer.apply(this, args);\n                                }\n                                return ret;\n                            };\n                        }\n                        else {\n                            extensions.renderers[ext.name] = ext.renderer;\n                        }\n                    }\n                    if ('tokenizer' in ext) { // Tokenizer Extensions\n                        if (!ext.level || (ext.level !== 'block' && ext.level !== 'inline')) {\n                            throw new Error(\"extension level must be 'block' or 'inline'\");\n                        }\n                        const extLevel = extensions[ext.level];\n                        if (extLevel) {\n                            extLevel.unshift(ext.tokenizer);\n                        }\n                        else {\n                            extensions[ext.level] = [ext.tokenizer];\n                        }\n                        if (ext.start) { // Function to check for start of token\n                            if (ext.level === 'block') {\n                                if (extensions.startBlock) {\n                                    extensions.startBlock.push(ext.start);\n                                }\n                                else {\n                                    extensions.startBlock = [ext.start];\n                                }\n                            }\n                            else if (ext.level === 'inline') {\n                                if (extensions.startInline) {\n                                    extensions.startInline.push(ext.start);\n                                }\n                                else {\n                                    extensions.startInline = [ext.start];\n                                }\n                            }\n                        }\n                    }\n                    if ('childTokens' in ext && ext.childTokens) { // Child tokens to be visited by walkTokens\n                        extensions.childTokens[ext.name] = ext.childTokens;\n                    }\n                });\n                opts.extensions = extensions;\n            }\n            // ==-- Parse \"overwrite\" extensions --== //\n            if (pack.renderer) {\n                const renderer = this.defaults.renderer || new _Renderer(this.defaults);\n                for (const prop in pack.renderer) {\n                    if (!(prop in renderer)) {\n                        throw new Error(`renderer '${prop}' does not exist`);\n                    }\n                    if (['options', 'parser'].includes(prop)) {\n                        // ignore options property\n                        continue;\n                    }\n                    const rendererProp = prop;\n                    const rendererFunc = pack.renderer[rendererProp];\n                    const prevRenderer = renderer[rendererProp];\n                    // Replace renderer with func to run extension, but fall back if false\n                    renderer[rendererProp] = (...args) => {\n                        let ret = rendererFunc.apply(renderer, args);\n                        if (ret === false) {\n                            ret = prevRenderer.apply(renderer, args);\n                        }\n                        return ret || '';\n                    };\n                }\n                opts.renderer = renderer;\n            }\n            if (pack.tokenizer) {\n                const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);\n                for (const prop in pack.tokenizer) {\n                    if (!(prop in tokenizer)) {\n                        throw new Error(`tokenizer '${prop}' does not exist`);\n                    }\n                    if (['options', 'rules', 'lexer'].includes(prop)) {\n                        // ignore options, rules, and lexer properties\n                        continue;\n                    }\n                    const tokenizerProp = prop;\n                    const tokenizerFunc = pack.tokenizer[tokenizerProp];\n                    const prevTokenizer = tokenizer[tokenizerProp];\n                    // Replace tokenizer with func to run extension, but fall back if false\n                    // @ts-expect-error cannot type tokenizer function dynamically\n                    tokenizer[tokenizerProp] = (...args) => {\n                        let ret = tokenizerFunc.apply(tokenizer, args);\n                        if (ret === false) {\n                            ret = prevTokenizer.apply(tokenizer, args);\n                        }\n                        return ret;\n                    };\n                }\n                opts.tokenizer = tokenizer;\n            }\n            // ==-- Parse Hooks extensions --== //\n            if (pack.hooks) {\n                const hooks = this.defaults.hooks || new _Hooks();\n                for (const prop in pack.hooks) {\n                    if (!(prop in hooks)) {\n                        throw new Error(`hook '${prop}' does not exist`);\n                    }\n                    if (prop === 'options') {\n                        // ignore options property\n                        continue;\n                    }\n                    const hooksProp = prop;\n                    const hooksFunc = pack.hooks[hooksProp];\n                    const prevHook = hooks[hooksProp];\n                    if (_Hooks.passThroughHooks.has(prop)) {\n                        // @ts-expect-error cannot type hook function dynamically\n                        hooks[hooksProp] = (arg) => {\n                            if (this.defaults.async) {\n                                return Promise.resolve(hooksFunc.call(hooks, arg)).then(ret => {\n                                    return prevHook.call(hooks, ret);\n                                });\n                            }\n                            const ret = hooksFunc.call(hooks, arg);\n                            return prevHook.call(hooks, ret);\n                        };\n                    }\n                    else {\n                        // @ts-expect-error cannot type hook function dynamically\n                        hooks[hooksProp] = (...args) => {\n                            let ret = hooksFunc.apply(hooks, args);\n                            if (ret === false) {\n                                ret = prevHook.apply(hooks, args);\n                            }\n                            return ret;\n                        };\n                    }\n                }\n                opts.hooks = hooks;\n            }\n            // ==-- Parse WalkTokens extensions --== //\n            if (pack.walkTokens) {\n                const walkTokens = this.defaults.walkTokens;\n                const packWalktokens = pack.walkTokens;\n                opts.walkTokens = function (token) {\n                    let values = [];\n                    values.push(packWalktokens.call(this, token));\n                    if (walkTokens) {\n                        values = values.concat(walkTokens.call(this, token));\n                    }\n                    return values;\n                };\n            }\n            this.defaults = { ...this.defaults, ...opts };\n        });\n        return this;\n    }\n    setOptions(opt) {\n        this.defaults = { ...this.defaults, ...opt };\n        return this;\n    }\n    lexer(src, options) {\n        return _Lexer.lex(src, options ?? this.defaults);\n    }\n    parser(tokens, options) {\n        return _Parser.parse(tokens, options ?? this.defaults);\n    }\n    parseMarkdown(lexer, parser) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const parse = (src, options) => {\n            const origOpt = { ...options };\n            const opt = { ...this.defaults, ...origOpt };\n            const throwError = this.onError(!!opt.silent, !!opt.async);\n            // throw error if an extension set async to true but parse was called with async: false\n            if (this.defaults.async === true && origOpt.async === false) {\n                return throwError(new Error('marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise.'));\n            }\n            // throw error in case of non string input\n            if (typeof src === 'undefined' || src === null) {\n                return throwError(new Error('marked(): input parameter is undefined or null'));\n            }\n            if (typeof src !== 'string') {\n                return throwError(new Error('marked(): input parameter is of type '\n                    + Object.prototype.toString.call(src) + ', string expected'));\n            }\n            if (opt.hooks) {\n                opt.hooks.options = opt;\n            }\n            if (opt.async) {\n                return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src)\n                    .then(src => lexer(src, opt))\n                    .then(tokens => opt.hooks ? opt.hooks.processAllTokens(tokens) : tokens)\n                    .then(tokens => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens)\n                    .then(tokens => parser(tokens, opt))\n                    .then(html => opt.hooks ? opt.hooks.postprocess(html) : html)\n                    .catch(throwError);\n            }\n            try {\n                if (opt.hooks) {\n                    src = opt.hooks.preprocess(src);\n                }\n                let tokens = lexer(src, opt);\n                if (opt.hooks) {\n                    tokens = opt.hooks.processAllTokens(tokens);\n                }\n                if (opt.walkTokens) {\n                    this.walkTokens(tokens, opt.walkTokens);\n                }\n                let html = parser(tokens, opt);\n                if (opt.hooks) {\n                    html = opt.hooks.postprocess(html);\n                }\n                return html;\n            }\n            catch (e) {\n                return throwError(e);\n            }\n        };\n        return parse;\n    }\n    onError(silent, async) {\n        return (e) => {\n            e.message += '\\nPlease report this to https://github.com/markedjs/marked.';\n            if (silent) {\n                const msg = '<p>An error occurred:</p><pre>'\n                    + escape(e.message + '', true)\n                    + '</pre>';\n                if (async) {\n                    return Promise.resolve(msg);\n                }\n                return msg;\n            }\n            if (async) {\n                return Promise.reject(e);\n            }\n            throw e;\n        };\n    }\n}\n","import { _Lexer } from './Lexer.ts';\nimport { _Parser } from './Parser.ts';\nimport { _Tokenizer } from './Tokenizer.ts';\nimport { _Renderer } from './Renderer.ts';\nimport { _TextRenderer } from './TextRenderer.ts';\nimport { _Hooks } from './Hooks.ts';\nimport { Marked } from './Instance.ts';\nimport { _getDefaults, changeDefaults, _defaults, } from './defaults.ts';\nconst markedInstance = new Marked();\nexport function marked(src, opt) {\n    return markedInstance.parse(src, opt);\n}\n/**\n * Sets the default options.\n *\n * @param options Hash of options\n */\nmarked.options =\n    marked.setOptions = function (options) {\n        markedInstance.setOptions(options);\n        marked.defaults = markedInstance.defaults;\n        changeDefaults(marked.defaults);\n        return marked;\n    };\n/**\n * Gets the original marked default options.\n */\nmarked.getDefaults = _getDefaults;\nmarked.defaults = _defaults;\n/**\n * Use Extension\n */\nmarked.use = function (...args) {\n    markedInstance.use(...args);\n    marked.defaults = markedInstance.defaults;\n    changeDefaults(marked.defaults);\n    return marked;\n};\n/**\n * Run callback for every token\n */\nmarked.walkTokens = function (tokens, callback) {\n    return markedInstance.walkTokens(tokens, callback);\n};\n/**\n * Compiles markdown to HTML without enclosing `p` tag.\n *\n * @param src String of markdown source to be compiled\n * @param options Hash of options\n * @return String of compiled HTML\n */\nmarked.parseInline = markedInstance.parseInline;\n/**\n * Expose\n */\nmarked.Parser = _Parser;\nmarked.parser = _Parser.parse;\nmarked.Renderer = _Renderer;\nmarked.TextRenderer = _TextRenderer;\nmarked.Lexer = _Lexer;\nmarked.lexer = _Lexer.lex;\nmarked.Tokenizer = _Tokenizer;\nmarked.Hooks = _Hooks;\nmarked.parse = marked;\nexport const options = marked.options;\nexport const setOptions = marked.setOptions;\nexport const use = marked.use;\nexport const walkTokens = marked.walkTokens;\nexport const parseInline = marked.parseInline;\nexport const parse = marked;\nexport const parser = _Parser.parse;\nexport const lexer = _Lexer.lex;\nexport { _defaults as defaults, _getDefaults as getDefaults } from './defaults.ts';\nexport { _Lexer as Lexer } from './Lexer.ts';\nexport { _Parser as Parser } from './Parser.ts';\nexport { _Tokenizer as Tokenizer } from './Tokenizer.ts';\nexport { _Renderer as Renderer } from './Renderer.ts';\nexport { _TextRenderer as TextRenderer } from './TextRenderer.ts';\nexport { _Hooks as Hooks } from './Hooks.ts';\nexport { Marked } from './Instance.ts';\n"]}