/**
 * marked v15.0.2 - a markdown parser
 * Copyright (c) 2011-2024, Christopher Jeffrey. (MIT Licensed)
 * https://github.com/markedjs/marked
 */
!function (e, t) {
    "object" == typeof exports && "undefined" != typeof module ? t(exports) : "function" == typeof define && define.amd ? define(["exports"], t) : t((e = "undefined" != typeof globalThis ? globalThis : e || self).marked = {})
}(this, (function (e) {
    "use strict";

    function t() {
        return {
            async: !1,
            breaks: !1,
            extensions: null,
            gfm: !0,
            hooks: null,
            pedantic: !1,
            renderer: null,
            silent: !1,
            tokenizer: null,
            walkTokens: null
        }
    }

    function n(t) {
        e.defaults = t
    }

    e.defaults = {
        async: !1,
        breaks: !1,
        extensions: null,
        gfm: !0,
        hooks: null,
        pedantic: !1,
        renderer: null,
        silent: !1,
        tokenizer: null,
        walkTokens: null
    };
    const s = {exec: () => null};

    function r(e, t = "") {
        let n = "string" == typeof e ? e : e.source;
        const s = {
            replace: (e, t) => {
                let r = "string" == typeof t ? t : t.source;
                return r = r.replace(i.caret, "$1"), n = n.replace(e, r), s
            }, getRegex: () => new RegExp(n, t)
        };
        return s
    }

    const i = {
            codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm,
            outputLinkReplace: /\\([\[\]])/g,
            indentCodeCompensation: /^(\s+)(?:```)/,
            beginningSpace: /^\s+/,
            endingHash: /#$/,
            startingSpaceChar: /^ /,
            endingSpaceChar: / $/,
            nonSpaceChar: /[^ ]/,
            newLineCharGlobal: /\n/g,
            tabCharGlobal: /\t/g,
            multipleSpaceGlobal: /\s+/g,
            blankLine: /^[ \t]*$/,
            doubleBlankLine: /\n[ \t]*\n[ \t]*$/,
            blockquoteStart: /^ {0,3}>/,
            blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g,
            blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm,
            listReplaceTabs: /^\t+/,
            listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g,
            listIsTask: /^\[[ xX]\] /,
            listReplaceTask: /^\[[ xX]\] +/,
            anyLine: /\n.*\n/,
            hrefBrackets: /^<(.*)>$/,
            tableDelimiter: /[:|]/,
            tableAlignChars: /^\||\| *$/g,
            tableRowBlankLine: /\n[ \t]*$/,
            tableAlignRight: /^ *-+: *$/,
            tableAlignCenter: /^ *:-+: *$/,
            tableAlignLeft: /^ *:-+ *$/,
            startATag: /^<a /i,
            endATag: /^<\/a>/i,
            startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i,
            endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i,
            startAngleBracket: /^</,
            endAngleBracket: />$/,
            pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/,
            unicodeAlphaNumeric: /[\p{L}\p{N}]/u,
            escapeTest: /[&<>"']/,
            escapeReplace: /[&<>"']/g,
            escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/,
            escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g,
            unescapeTest: /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/gi,
            caret: /(^|[^\[])\^/g,
            percentDecode: /%25/g,
            findPipe: /\|/g,
            splitPipe: / \|/,
            slashPipe: /\\\|/g,
            carriageReturn: /\r\n|\r/g,
            spaceLine: /^ +$/gm,
            notSpaceStart: /^\S*/,
            endingNewline: /\n$/,
            listItemRegex: e => new RegExp(`^( {0,3}${e})((?:[\t ][^\\n]*)?(?:\\n|$))`),
            nextBulletRegex: e => new RegExp(`^ {0,${Math.min(3,e-1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ \t][^\\n]*)?(?:\\n|$))`),
            hrRegex: e => new RegExp(`^ {0,${Math.min(3,e-1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),
            fencesBeginRegex: e => new RegExp(`^ {0,${Math.min(3,e-1)}}(?:\`\`\`|~~~)`),
            headingBeginRegex: e => new RegExp(`^ {0,${Math.min(3,e-1)}}#`),
            htmlBeginRegex: e => new RegExp(`^ {0,${Math.min(3,e-1)}}<(?:[a-z].*>|!--)`, "i")
        }, l = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/, o = /(?:[*+-]|\d{1,9}[.)])/,
        a = r(/^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html))+?)\n {0,3}(=+|-+) *(?:\n+|$)/).replace(/bull/g, o).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).getRegex(),
        c = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,
        h = /(?!\s*\])(?:\\.|[^\[\]\\])+/,
        p = r(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", h).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(),
        u = r(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, o).getRegex(),
        k = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul",
        g = /<!--(?:-?>|[\s\S]*?(?:-->|$))/,
        d = r("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$))", "i").replace("comment", g).replace("tag", k).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(),
        f = r(c).replace("hr", l).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", k).getRegex(),
        x = {
            blockquote: r(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", f).getRegex(),
            code: /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/,
            def: p,
            fences: /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/,
            heading: /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,
            hr: l,
            html: d,
            lheading: a,
            list: u,
            newline: /^(?:[ \t]*(?:\n|$))+/,
            paragraph: f,
            table: s,
            text: /^[^\n]+/
        },
        b = r("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", l).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}\t)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", k).getRegex(),
        w = {
            ...x,
            table: b,
            paragraph: r(c).replace("hr", l).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", b).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", k).getRegex()
        }, m = {
            ...x,
            html: r("^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:\"[^\"]*\"|'[^']*'|\\s[^'\"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))").replace("comment", g).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),
            def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
            heading: /^(#{1,6})(.*)(?:\n+|$)/,
            fences: s,
            lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
            paragraph: r(c).replace("hr", l).replace("heading", " *#{1,6} *[^\n]").replace("lheading", a).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex()
        }, y = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/, $ = /^( {2,}|\\)\n(?!\s*$)/, R = /\p{P}\p{S}/u,
        T = r(/^((?![*_])[\spunctuation])/, "u").replace(/punctuation/g, R).getRegex(),
        z = r(/^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/, "u").replace(/punct/g, R).getRegex(),
        A = r("^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)[punct](\\*+)(?=[\\s]|$)|[^punct\\s](\\*+)(?!\\*)(?=[punct\\s]|$)|(?!\\*)[punct\\s](\\*+)(?=[^punct\\s])|[\\s](\\*+)(?!\\*)(?=[punct])|(?!\\*)[punct](\\*+)(?!\\*)(?=[punct])|[^punct\\s](\\*+)(?=[^punct\\s])", "gu").replace(/punct/g, R).getRegex(),
        S = r("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)[punct](_+)(?=[\\s]|$)|[^punct\\s](_+)(?!_)(?=[punct\\s]|$)|(?!_)[punct\\s](_+)(?=[^punct\\s])|[\\s](_+)(?!_)(?=[punct])|(?!_)[punct](_+)(?!_)(?=[punct])", "gu").replace(/punct/g, R).getRegex(),
        _ = r(/\\([punct])/, "gu").replace(/punct/g, R).getRegex(),
        I = r(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex(),
        L = r(g).replace("(?:--\x3e|$)", "--\x3e").getRegex(),
        B = r("^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", L).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(),
        C = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/,
        E = r(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/).replace("label", C).replace("href", /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(),
        q = r(/^!?\[(label)\]\[(ref)\]/).replace("label", C).replace("ref", h).getRegex(),
        P = r(/^!?\[(ref)\](?:\[\])?/).replace("ref", h).getRegex(), Z = {
            _backpedal: s,
            anyPunctuation: _,
            autolink: I,
            blockSkip: /\[[^[\]]*?\]\((?:\\.|[^\\\(\)]|\((?:\\.|[^\\\(\)])*\))*\)|`[^`]*?`|<[^<>]*?>/g,
            br: $,
            code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
            del: s,
            emStrongLDelim: z,
            emStrongRDelimAst: A,
            emStrongRDelimUnd: S,
            escape: y,
            link: E,
            nolink: P,
            punctuation: T,
            reflink: q,
            reflinkSearch: r("reflink|nolink(?!\\()", "g").replace("reflink", q).replace("nolink", P).getRegex(),
            tag: B,
            text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/,
            url: s
        }, v = {
            ...Z,
            link: r(/^!?\[(label)\]\((.*?)\)/).replace("label", C).getRegex(),
            reflink: r(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", C).getRegex()
        }, D = {
            ...Z,
            escape: r(y).replace("])", "~|])").getRegex(),
            url: r(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, "i").replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),
            _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,
            del: /^(~~?)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/,
            text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
        }, M = {
            ...D,
            br: r($).replace("{2,}", "*").getRegex(),
            text: r(D.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex()
        }, O = {normal: x, gfm: w, pedantic: m}, Q = {normal: Z, gfm: D, breaks: M, pedantic: v},
        j = {"&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;"}, N = e => j[e];

    function G(e, t) {
        if (t) {
            if (i.escapeTest.test(e)) return e.replace(i.escapeReplace, N)
        } else if (i.escapeTestNoEncode.test(e)) return e.replace(i.escapeReplaceNoEncode, N);
        return e
    }

    function H(e) {
        try {
            e = encodeURI(e).replace(i.percentDecode, "%")
        } catch {
            return null
        }
        return e
    }

    function X(e, t) {
        const n = e.replace(i.findPipe, ((e, t, n) => {
            let s = !1, r = t;
            for (; --r >= 0 && "\\" === n[r];) s = !s;
            return s ? "|" : " |"
        })).split(i.splitPipe);
        let s = 0;
        if (n[0].trim() || n.shift(), n.length > 0 && !n.at(-1)?.trim() && n.pop(), t) if (n.length > t) n.splice(t); else for (; n.length < t;) n.push("");
        for (; s < n.length; s++) n[s] = n[s].trim().replace(i.slashPipe, "|");
        return n
    }

    function F(e, t, n) {
        const s = e.length;
        if (0 === s) return "";
        let r = 0;
        for (; r < s;) {
            const i = e.charAt(s - r - 1);
            if (i !== t || n) {
                if (i === t || !n) break;
                r++
            } else r++
        }
        return e.slice(0, s - r)
    }

    function U(e, t, n, s, r) {
        const i = t.href, l = t.title || null, o = e[1].replace(r.other.outputLinkReplace, "$1");
        if ("!" !== e[0].charAt(0)) {
            s.state.inLink = !0;
            const e = {type: "link", raw: n, href: i, title: l, text: o, tokens: s.inlineTokens(o)};
            return s.state.inLink = !1, e
        }
        return {type: "image", raw: n, href: i, title: l, text: o}
    }

    class J {
        options;
        rules;
        lexer;

        constructor(t) {
            this.options = t || e.defaults
        }

        space(e) {
            const t = this.rules.block.newline.exec(e);
            if (t && t[0].length > 0) return {type: "space", raw: t[0]}
        }

        code(e) {
            const t = this.rules.block.code.exec(e);
            if (t) {
                const e = t[0].replace(this.rules.other.codeRemoveIndent, "");
                return {
                    type: "code",
                    raw: t[0],
                    codeBlockStyle: "indented",
                    text: this.options.pedantic ? e : F(e, "\n")
                }
            }
        }

        fences(e) {
            const t = this.rules.block.fences.exec(e);
            if (t) {
                const e = t[0], n = function (e, t, n) {
                    const s = e.match(n.other.indentCodeCompensation);
                    if (null === s) return t;
                    const r = s[1];
                    return t.split("\n").map((e => {
                        const t = e.match(n.other.beginningSpace);
                        if (null === t) return e;
                        const [s] = t;
                        return s.length >= r.length ? e.slice(r.length) : e
                    })).join("\n")
                }(e, t[3] || "", this.rules);
                return {
                    type: "code",
                    raw: e,
                    lang: t[2] ? t[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : t[2],
                    text: n
                }
            }
        }

        heading(e) {
            const t = this.rules.block.heading.exec(e);
            if (t) {
                let e = t[2].trim();
                if (this.rules.other.endingHash.test(e)) {
                    const t = F(e, "#");
                    this.options.pedantic ? e = t.trim() : t && !this.rules.other.endingSpaceChar.test(t) || (e = t.trim())
                }
                return {type: "heading", raw: t[0], depth: t[1].length, text: e, tokens: this.lexer.inline(e)}
            }
        }

        hr(e) {
            const t = this.rules.block.hr.exec(e);
            if (t) return {type: "hr", raw: F(t[0], "\n")}
        }

        blockquote(e) {
            const t = this.rules.block.blockquote.exec(e);
            if (t) {
                let e = F(t[0], "\n").split("\n"), n = "", s = "";
                const r = [];
                for (; e.length > 0;) {
                    let t = !1;
                    const i = [];
                    let l;
                    for (l = 0; l < e.length; l++) if (this.rules.other.blockquoteStart.test(e[l])) i.push(e[l]), t = !0; else {
                        if (t) break;
                        i.push(e[l])
                    }
                    e = e.slice(l);
                    const o = i.join("\n"),
                        a = o.replace(this.rules.other.blockquoteSetextReplace, "\n    $1").replace(this.rules.other.blockquoteSetextReplace2, "");
                    n = n ? `${n}\n${o}` : o, s = s ? `${s}\n${a}` : a;
                    const c = this.lexer.state.top;
                    if (this.lexer.state.top = !0, this.lexer.blockTokens(a, r, !0), this.lexer.state.top = c, 0 === e.length) break;
                    const h = r.at(-1);
                    if ("code" === h?.type) break;
                    if ("blockquote" === h?.type) {
                        const t = h, i = t.raw + "\n" + e.join("\n"), l = this.blockquote(i);
                        r[r.length - 1] = l, n = n.substring(0, n.length - t.raw.length) + l.raw, s = s.substring(0, s.length - t.text.length) + l.text;
                        break
                    }
                    if ("list" !== h?.type) ; else {
                        const t = h, i = t.raw + "\n" + e.join("\n"), l = this.list(i);
                        r[r.length - 1] = l, n = n.substring(0, n.length - h.raw.length) + l.raw, s = s.substring(0, s.length - t.raw.length) + l.raw, e = i.substring(r.at(-1).raw.length).split("\n")
                    }
                }
                return {type: "blockquote", raw: n, tokens: r, text: s}
            }
        }

        list(e) {
            let t = this.rules.block.list.exec(e);
            if (t) {
                let n = t[1].trim();
                const s = n.length > 1,
                    r = {type: "list", raw: "", ordered: s, start: s ? +n.slice(0, -1) : "", loose: !1, items: []};
                n = s ? `\\d{1,9}\\${n.slice(-1)}` : `\\${n}`, this.options.pedantic && (n = s ? n : "[*+-]");
                const i = this.rules.other.listItemRegex(n);
                let l = !1;
                for (; e;) {
                    let n = !1, s = "", o = "";
                    if (!(t = i.exec(e))) break;
                    if (this.rules.block.hr.test(e)) break;
                    s = t[0], e = e.substring(s.length);
                    let a = t[2].split("\n", 1)[0].replace(this.rules.other.listReplaceTabs, (e => " ".repeat(3 * e.length))),
                        c = e.split("\n", 1)[0], h = !a.trim(), p = 0;
                    if (this.options.pedantic ? (p = 2, o = a.trimStart()) : h ? p = t[1].length + 1 : (p = t[2].search(this.rules.other.nonSpaceChar), p = p > 4 ? 1 : p, o = a.slice(p), p += t[1].length), h && this.rules.other.blankLine.test(c) && (s += c + "\n", e = e.substring(c.length + 1), n = !0), !n) {
                        const t = this.rules.other.nextBulletRegex(p), n = this.rules.other.hrRegex(p),
                            r = this.rules.other.fencesBeginRegex(p), i = this.rules.other.headingBeginRegex(p),
                            l = this.rules.other.htmlBeginRegex(p);
                        for (; e;) {
                            const u = e.split("\n", 1)[0];
                            let k;
                            if (c = u, this.options.pedantic ? (c = c.replace(this.rules.other.listReplaceNesting, "  "), k = c) : k = c.replace(this.rules.other.tabCharGlobal, "    "), r.test(c)) break;
                            if (i.test(c)) break;
                            if (l.test(c)) break;
                            if (t.test(c)) break;
                            if (n.test(c)) break;
                            if (k.search(this.rules.other.nonSpaceChar) >= p || !c.trim()) o += "\n" + k.slice(p); else {
                                if (h) break;
                                if (a.replace(this.rules.other.tabCharGlobal, "    ").search(this.rules.other.nonSpaceChar) >= 4) break;
                                if (r.test(a)) break;
                                if (i.test(a)) break;
                                if (n.test(a)) break;
                                o += "\n" + c
                            }
                            h || c.trim() || (h = !0), s += u + "\n", e = e.substring(u.length + 1), a = k.slice(p)
                        }
                    }
                    r.loose || (l ? r.loose = !0 : this.rules.other.doubleBlankLine.test(s) && (l = !0));
                    let u, k = null;
                    this.options.gfm && (k = this.rules.other.listIsTask.exec(o), k && (u = "[ ] " !== k[0], o = o.replace(this.rules.other.listReplaceTask, ""))), r.items.push({
                        type: "list_item",
                        raw: s,
                        task: !!k,
                        checked: u,
                        loose: !1,
                        text: o,
                        tokens: []
                    }), r.raw += s
                }
                const o = r.items.at(-1);
                o && (o.raw = o.raw.trimEnd(), o.text = o.text.trimEnd()), r.raw = r.raw.trimEnd();
                for (let e = 0; e < r.items.length; e++) if (this.lexer.state.top = !1, r.items[e].tokens = this.lexer.blockTokens(r.items[e].text, []), !r.loose) {
                    const t = r.items[e].tokens.filter((e => "space" === e.type)),
                        n = t.length > 0 && t.some((e => this.rules.other.anyLine.test(e.raw)));
                    r.loose = n
                }
                if (r.loose) for (let e = 0; e < r.items.length; e++) r.items[e].loose = !0;
                return r
            }
        }

        html(e) {
            const t = this.rules.block.html.exec(e);
            if (t) {
                return {
                    type: "html",
                    block: !0,
                    raw: t[0],
                    pre: "pre" === t[1] || "script" === t[1] || "style" === t[1],
                    text: t[0]
                }
            }
        }

        def(e) {
            const t = this.rules.block.def.exec(e);
            if (t) {
                const e = t[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, " "),
                    n = t[2] ? t[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "",
                    s = t[3] ? t[3].substring(1, t[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : t[3];
                return {type: "def", tag: e, raw: t[0], href: n, title: s}
            }
        }

        table(e) {
            const t = this.rules.block.table.exec(e);
            if (!t) return;
            if (!this.rules.other.tableDelimiter.test(t[2])) return;
            const n = X(t[1]), s = t[2].replace(this.rules.other.tableAlignChars, "").split("|"),
                r = t[3]?.trim() ? t[3].replace(this.rules.other.tableRowBlankLine, "").split("\n") : [],
                i = {type: "table", raw: t[0], header: [], align: [], rows: []};
            if (n.length === s.length) {
                for (const e of s) this.rules.other.tableAlignRight.test(e) ? i.align.push("right") : this.rules.other.tableAlignCenter.test(e) ? i.align.push("center") : this.rules.other.tableAlignLeft.test(e) ? i.align.push("left") : i.align.push(null);
                for (let e = 0; e < n.length; e++) i.header.push({
                    text: n[e],
                    tokens: this.lexer.inline(n[e]),
                    header: !0,
                    align: i.align[e]
                });
                for (const e of r) i.rows.push(X(e, i.header.length).map(((e, t) => ({
                    text: e,
                    tokens: this.lexer.inline(e),
                    header: !1,
                    align: i.align[t]
                }))));
                return i
            }
        }

        lheading(e) {
            const t = this.rules.block.lheading.exec(e);
            if (t) return {
                type: "heading",
                raw: t[0],
                depth: "=" === t[2].charAt(0) ? 1 : 2,
                text: t[1],
                tokens: this.lexer.inline(t[1])
            }
        }

        paragraph(e) {
            const t = this.rules.block.paragraph.exec(e);
            if (t) {
                const e = "\n" === t[1].charAt(t[1].length - 1) ? t[1].slice(0, -1) : t[1];
                return {type: "paragraph", raw: t[0], text: e, tokens: this.lexer.inline(e)}
            }
        }

        text(e) {
            const t = this.rules.block.text.exec(e);
            if (t) return {type: "text", raw: t[0], text: t[0], tokens: this.lexer.inline(t[0])}
        }

        escape(e) {
            const t = this.rules.inline.escape.exec(e);
            if (t) return {type: "escape", raw: t[0], text: t[1]}
        }

        tag(e) {
            const t = this.rules.inline.tag.exec(e);
            if (t) return !this.lexer.state.inLink && this.rules.other.startATag.test(t[0]) ? this.lexer.state.inLink = !0 : this.lexer.state.inLink && this.rules.other.endATag.test(t[0]) && (this.lexer.state.inLink = !1), !this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(t[0]) ? this.lexer.state.inRawBlock = !0 : this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(t[0]) && (this.lexer.state.inRawBlock = !1), {
                type: "html",
                raw: t[0],
                inLink: this.lexer.state.inLink,
                inRawBlock: this.lexer.state.inRawBlock,
                block: !1,
                text: t[0]
            }
        }

        link(e) {
            const t = this.rules.inline.link.exec(e);
            if (t) {
                const e = t[2].trim();
                if (!this.options.pedantic && this.rules.other.startAngleBracket.test(e)) {
                    if (!this.rules.other.endAngleBracket.test(e)) return;
                    const t = F(e.slice(0, -1), "\\");
                    if ((e.length - t.length) % 2 == 0) return
                } else {
                    const e = function (e, t) {
                        if (-1 === e.indexOf(t[1])) return -1;
                        let n = 0;
                        for (let s = 0; s < e.length; s++) if ("\\" === e[s]) s++; else if (e[s] === t[0]) n++; else if (e[s] === t[1] && (n--, n < 0)) return s;
                        return -1
                    }(t[2], "()");
                    if (e > -1) {
                        const n = (0 === t[0].indexOf("!") ? 5 : 4) + t[1].length + e;
                        t[2] = t[2].substring(0, e), t[0] = t[0].substring(0, n).trim(), t[3] = ""
                    }
                }
                let n = t[2], s = "";
                if (this.options.pedantic) {
                    const e = this.rules.other.pedanticHrefTitle.exec(n);
                    e && (n = e[1], s = e[3])
                } else s = t[3] ? t[3].slice(1, -1) : "";
                return n = n.trim(), this.rules.other.startAngleBracket.test(n) && (n = this.options.pedantic && !this.rules.other.endAngleBracket.test(e) ? n.slice(1) : n.slice(1, -1)), U(t, {
                    href: n ? n.replace(this.rules.inline.anyPunctuation, "$1") : n,
                    title: s ? s.replace(this.rules.inline.anyPunctuation, "$1") : s
                }, t[0], this.lexer, this.rules)
            }
        }

        reflink(e, t) {
            let n;
            if ((n = this.rules.inline.reflink.exec(e)) || (n = this.rules.inline.nolink.exec(e))) {
                const e = t[(n[2] || n[1]).replace(this.rules.other.multipleSpaceGlobal, " ").toLowerCase()];
                if (!e) {
                    const e = n[0].charAt(0);
                    return {type: "text", raw: e, text: e}
                }
                return U(n, e, n[0], this.lexer, this.rules)
            }
        }

        emStrong(e, t, n = "") {
            let s = this.rules.inline.emStrongLDelim.exec(e);
            if (!s) return;
            if (s[3] && n.match(this.rules.other.unicodeAlphaNumeric)) return;
            if (!(s[1] || s[2] || "") || !n || this.rules.inline.punctuation.exec(n)) {
                const n = [...s[0]].length - 1;
                let r, i, l = n, o = 0;
                const a = "*" === s[0][0] ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
                for (a.lastIndex = 0, t = t.slice(-1 * e.length + n); null != (s = a.exec(t));) {
                    if (r = s[1] || s[2] || s[3] || s[4] || s[5] || s[6], !r) continue;
                    if (i = [...r].length, s[3] || s[4]) {
                        l += i;
                        continue
                    }
                    if ((s[5] || s[6]) && n % 3 && !((n + i) % 3)) {
                        o += i;
                        continue
                    }
                    if (l -= i, l > 0) continue;
                    i = Math.min(i, i + l + o);
                    const t = [...s[0]][0].length, a = e.slice(0, n + s.index + t + i);
                    if (Math.min(n, i) % 2) {
                        const e = a.slice(1, -1);
                        return {type: "em", raw: a, text: e, tokens: this.lexer.inlineTokens(e)}
                    }
                    const c = a.slice(2, -2);
                    return {type: "strong", raw: a, text: c, tokens: this.lexer.inlineTokens(c)}
                }
            }
        }

        codespan(e) {
            const t = this.rules.inline.code.exec(e);
            if (t) {
                let e = t[2].replace(this.rules.other.newLineCharGlobal, " ");
                const n = this.rules.other.nonSpaceChar.test(e),
                    s = this.rules.other.startingSpaceChar.test(e) && this.rules.other.endingSpaceChar.test(e);
                return n && s && (e = e.substring(1, e.length - 1)), {type: "codespan", raw: t[0], text: e}
            }
        }

        br(e) {
            const t = this.rules.inline.br.exec(e);
            if (t) return {type: "br", raw: t[0]}
        }

        del(e) {
            const t = this.rules.inline.del.exec(e);
            if (t) return {type: "del", raw: t[0], text: t[2], tokens: this.lexer.inlineTokens(t[2])}
        }

        autolink(e) {
            const t = this.rules.inline.autolink.exec(e);
            if (t) {
                let e, n;
                return "@" === t[2] ? (e = t[1], n = "mailto:" + e) : (e = t[1], n = e), {
                    type: "link",
                    raw: t[0],
                    text: e,
                    href: n,
                    tokens: [{type: "text", raw: e, text: e}]
                }
            }
        }

        url(e) {
            let t;
            if (t = this.rules.inline.url.exec(e)) {
                let e, n;
                if ("@" === t[2]) e = t[0], n = "mailto:" + e; else {
                    let s;
                    do {
                        s = t[0], t[0] = this.rules.inline._backpedal.exec(t[0])?.[0] ?? ""
                    } while (s !== t[0]);
                    e = t[0], n = "www." === t[1] ? "http://" + t[0] : t[0]
                }
                return {type: "link", raw: t[0], text: e, href: n, tokens: [{type: "text", raw: e, text: e}]}
            }
        }

        inlineText(e) {
            const t = this.rules.inline.text.exec(e);
            if (t) {
                const e = this.lexer.state.inRawBlock;
                return {type: "text", raw: t[0], text: t[0], escaped: e}
            }
        }
    }

    class K {
        tokens;
        options;
        state;
        tokenizer;
        inlineQueue;

        constructor(t) {
            this.tokens = [], this.tokens.links = Object.create(null), this.options = t || e.defaults, this.options.tokenizer = this.options.tokenizer || new J, this.tokenizer = this.options.tokenizer, this.tokenizer.options = this.options, this.tokenizer.lexer = this, this.inlineQueue = [], this.state = {
                inLink: !1,
                inRawBlock: !1,
                top: !0
            };
            const n = {other: i, block: O.normal, inline: Q.normal};
            this.options.pedantic ? (n.block = O.pedantic, n.inline = Q.pedantic) : this.options.gfm && (n.block = O.gfm, this.options.breaks ? n.inline = Q.breaks : n.inline = Q.gfm), this.tokenizer.rules = n
        }

        static get rules() {
            return {block: O, inline: Q}
        }

        static lex(e, t) {
            return new K(t).lex(e)
        }

        static lexInline(e, t) {
            return new K(t).inlineTokens(e)
        }

        lex(e) {
            e = e.replace(i.carriageReturn, "\n"), this.blockTokens(e, this.tokens);
            for (let e = 0; e < this.inlineQueue.length; e++) {
                const t = this.inlineQueue[e];
                this.inlineTokens(t.src, t.tokens)
            }
            return this.inlineQueue = [], this.tokens
        }

        blockTokens(e, t = [], n = !1) {
            for (this.options.pedantic && (e = e.replace(i.tabCharGlobal, "    ").replace(i.spaceLine, "")); e;) {
                let s;
                if (this.options.extensions?.block?.some((n => !!(s = n.call({lexer: this}, e, t)) && (e = e.substring(s.raw.length), t.push(s), !0)))) continue;
                if (s = this.tokenizer.space(e)) {
                    e = e.substring(s.raw.length);
                    const n = t.at(-1);
                    1 === s.raw.length && void 0 !== n ? n.raw += "\n" : t.push(s);
                    continue
                }
                if (s = this.tokenizer.code(e)) {
                    e = e.substring(s.raw.length);
                    const n = t.at(-1);
                    "paragraph" === n?.type || "text" === n?.type ? (n.raw += "\n" + s.raw, n.text += "\n" + s.text, this.inlineQueue.at(-1).src = n.text) : t.push(s);
                    continue
                }
                if (s = this.tokenizer.fences(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.heading(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.hr(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.blockquote(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.list(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.html(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.def(e)) {
                    e = e.substring(s.raw.length);
                    const n = t.at(-1);
                    "paragraph" === n?.type || "text" === n?.type ? (n.raw += "\n" + s.raw, n.text += "\n" + s.raw, this.inlineQueue.at(-1).src = n.text) : this.tokens.links[s.tag] || (this.tokens.links[s.tag] = {
                        href: s.href,
                        title: s.title
                    });
                    continue
                }
                if (s = this.tokenizer.table(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.lheading(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                let r = e;
                if (this.options.extensions?.startBlock) {
                    let t = 1 / 0;
                    const n = e.slice(1);
                    let s;
                    this.options.extensions.startBlock.forEach((e => {
                        s = e.call({lexer: this}, n), "number" == typeof s && s >= 0 && (t = Math.min(t, s))
                    })), t < 1 / 0 && t >= 0 && (r = e.substring(0, t + 1))
                }
                if (this.state.top && (s = this.tokenizer.paragraph(r))) {
                    const i = t.at(-1);
                    n && "paragraph" === i?.type ? (i.raw += "\n" + s.raw, i.text += "\n" + s.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = i.text) : t.push(s), n = r.length !== e.length, e = e.substring(s.raw.length)
                } else if (s = this.tokenizer.text(e)) {
                    e = e.substring(s.raw.length);
                    const n = t.at(-1);
                    "text" === n?.type ? (n.raw += "\n" + s.raw, n.text += "\n" + s.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = n.text) : t.push(s)
                } else if (e) {
                    const t = "Infinite loop on byte: " + e.charCodeAt(0);
                    if (this.options.silent) {
                        console.error(t);
                        break
                    }
                    throw new Error(t)
                }
            }
            return this.state.top = !0, t
        }

        inline(e, t = []) {
            return this.inlineQueue.push({src: e, tokens: t}), t
        }

        inlineTokens(e, t = []) {
            let n = e, s = null;
            if (this.tokens.links) {
                const e = Object.keys(this.tokens.links);
                if (e.length > 0) for (; null != (s = this.tokenizer.rules.inline.reflinkSearch.exec(n));) e.includes(s[0].slice(s[0].lastIndexOf("[") + 1, -1)) && (n = n.slice(0, s.index) + "[" + "a".repeat(s[0].length - 2) + "]" + n.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex))
            }
            for (; null != (s = this.tokenizer.rules.inline.blockSkip.exec(n));) n = n.slice(0, s.index) + "[" + "a".repeat(s[0].length - 2) + "]" + n.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
            for (; null != (s = this.tokenizer.rules.inline.anyPunctuation.exec(n));) n = n.slice(0, s.index) + "++" + n.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
            let r = !1, i = "";
            for (; e;) {
                let s;
                if (r || (i = ""), r = !1, this.options.extensions?.inline?.some((n => !!(s = n.call({lexer: this}, e, t)) && (e = e.substring(s.raw.length), t.push(s), !0)))) continue;
                if (s = this.tokenizer.escape(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.tag(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.link(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.reflink(e, this.tokens.links)) {
                    e = e.substring(s.raw.length);
                    const n = t.at(-1);
                    "text" === s.type && "text" === n?.type ? (n.raw += s.raw, n.text += s.text) : t.push(s);
                    continue
                }
                if (s = this.tokenizer.emStrong(e, n, i)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.codespan(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.br(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.del(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (s = this.tokenizer.autolink(e)) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                if (!this.state.inLink && (s = this.tokenizer.url(e))) {
                    e = e.substring(s.raw.length), t.push(s);
                    continue
                }
                let l = e;
                if (this.options.extensions?.startInline) {
                    let t = 1 / 0;
                    const n = e.slice(1);
                    let s;
                    this.options.extensions.startInline.forEach((e => {
                        s = e.call({lexer: this}, n), "number" == typeof s && s >= 0 && (t = Math.min(t, s))
                    })), t < 1 / 0 && t >= 0 && (l = e.substring(0, t + 1))
                }
                if (s = this.tokenizer.inlineText(l)) {
                    e = e.substring(s.raw.length), "_" !== s.raw.slice(-1) && (i = s.raw.slice(-1)), r = !0;
                    const n = t.at(-1);
                    "text" === n?.type ? (n.raw += s.raw, n.text += s.text) : t.push(s)
                } else if (e) {
                    const t = "Infinite loop on byte: " + e.charCodeAt(0);
                    if (this.options.silent) {
                        console.error(t);
                        break
                    }
                    throw new Error(t)
                }
            }
            return t
        }
    }

    class V {
        options;
        parser;

        constructor(t) {
            this.options = t || e.defaults
        }

        space(e) {
            return ""
        }

        code({text: e, lang: t, escaped: n}) {
            const s = (t || "").match(i.notSpaceStart)?.[0], r = e.replace(i.endingNewline, "") + "\n";
            return s ? '<pre><code class="language-' + G(s) + '">' + (n ? r : G(r, !0)) + "</code></pre>\n" : "<pre><code>" + (n ? r : G(r, !0)) + "</code></pre>\n"
        }

        blockquote({tokens: e}) {
            return `<blockquote>\n${this.parser.parse(e)}</blockquote>\n`
        }

        html({text: e}) {
            return e
        }

        heading({tokens: e, depth: t}) {
            return `<h${t}>${this.parser.parseInline(e)}</h${t}>\n`
        }

        hr(e) {
            return "<hr>\n"
        }

        list(e) {
            const t = e.ordered, n = e.start;
            let s = "";
            for (let t = 0; t < e.items.length; t++) {
                const n = e.items[t];
                s += this.listitem(n)
            }
            const r = t ? "ol" : "ul";
            return "<" + r + (t && 1 !== n ? ' start="' + n + '"' : "") + ">\n" + s + "</" + r + ">\n"
        }

        listitem(e) {
            let t = "";
            if (e.task) {
                const n = this.checkbox({checked: !!e.checked});
                e.loose ? "paragraph" === e.tokens[0]?.type ? (e.tokens[0].text = n + " " + e.tokens[0].text, e.tokens[0].tokens && e.tokens[0].tokens.length > 0 && "text" === e.tokens[0].tokens[0].type && (e.tokens[0].tokens[0].text = n + " " + G(e.tokens[0].tokens[0].text), e.tokens[0].tokens[0].escaped = !0)) : e.tokens.unshift({
                    type: "text",
                    raw: n + " ",
                    text: n + " ",
                    escaped: !0
                }) : t += n + " "
            }
            return t += this.parser.parse(e.tokens, !!e.loose), `<li>${t}</li>\n`
        }

        checkbox({checked: e}) {
            return "<input " + (e ? 'checked="" ' : "") + 'disabled="" type="checkbox">'
        }

        paragraph({tokens: e}) {
            return `<p>${this.parser.parseInline(e)}</p>\n`
        }

        table(e) {
            let t = "", n = "";
            for (let t = 0; t < e.header.length; t++) n += this.tablecell(e.header[t]);
            t += this.tablerow({text: n});
            let s = "";
            for (let t = 0; t < e.rows.length; t++) {
                const r = e.rows[t];
                n = "";
                for (let e = 0; e < r.length; e++) n += this.tablecell(r[e]);
                s += this.tablerow({text: n})
            }
            return s && (s = `<tbody>${s}</tbody>`), "<table>\n<thead>\n" + t + "</thead>\n" + s + "</table>\n"
        }

        tablerow({text: e}) {
            return `<tr>\n${e}</tr>\n`
        }

        tablecell(e) {
            const t = this.parser.parseInline(e.tokens), n = e.header ? "th" : "td";
            return (e.align ? `<${n} align="${e.align}">` : `<${n}>`) + t + `</${n}>\n`
        }

        strong({tokens: e}) {
            return `<strong>${this.parser.parseInline(e)}</strong>`
        }

        em({tokens: e}) {
            return `<em>${this.parser.parseInline(e)}</em>`
        }

        codespan({text: e}) {
            return `<code>${G(e, !0)}</code>`
        }

        br(e) {
            return "<br>"
        }

        del({tokens: e}) {
            return `<del>${this.parser.parseInline(e)}</del>`
        }

        link({href: e, title: t, tokens: n}) {
            const s = this.parser.parseInline(n), r = H(e);
            if (null === r) return s;
            let i = '<a href="' + (e = r) + '"';
            return t && (i += ' title="' + G(t) + '"'), i += ">" + s + "</a>", i
        }

        image({href: e, title: t, text: n}) {
            const s = H(e);
            if (null === s) return G(n);
            let r = `<img src="${e = s}" alt="${n}"`;
            return t && (r += ` title="${G(t)}"`), r += ">", r
        }

        text(e) {
            return "tokens" in e && e.tokens ? this.parser.parseInline(e.tokens) : "escaped" in e && e.escaped ? e.text : G(e.text)
        }
    }

    class W {
        strong({text: e}) {
            return e
        }

        em({text: e}) {
            return e
        }

        codespan({text: e}) {
            return e
        }

        del({text: e}) {
            return e
        }

        html({text: e}) {
            return e
        }

        text({text: e}) {
            return e
        }

        link({text: e}) {
            return "" + e
        }

        image({text: e}) {
            return "" + e
        }

        br() {
            return ""
        }
    }

    class Y {
        options;
        renderer;
        textRenderer;

        constructor(t) {
            this.options = t || e.defaults, this.options.renderer = this.options.renderer || new V, this.renderer = this.options.renderer, this.renderer.options = this.options, this.renderer.parser = this, this.textRenderer = new W
        }

        static parse(e, t) {
            return new Y(t).parse(e)
        }

        static parseInline(e, t) {
            return new Y(t).parseInline(e)
        }

        parse(e, t = !0) {
            let n = "";
            for (let s = 0; s < e.length; s++) {
                const r = e[s];
                if (this.options.extensions?.renderers?.[r.type]) {
                    const e = r, t = this.options.extensions.renderers[e.type].call({parser: this}, e);
                    if (!1 !== t || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(e.type)) {
                        n += t || "";
                        continue
                    }
                }
                const i = r;
                switch (i.type) {
                    case"space":
                        n += this.renderer.space(i);
                        continue;
                    case"hr":
                        n += this.renderer.hr(i);
                        continue;
                    case"heading":
                        n += this.renderer.heading(i);
                        continue;
                    case"code":
                        n += this.renderer.code(i);
                        continue;
                    case"table":
                        n += this.renderer.table(i);
                        continue;
                    case"blockquote":
                        n += this.renderer.blockquote(i);
                        continue;
                    case"list":
                        n += this.renderer.list(i);
                        continue;
                    case"html":
                        n += this.renderer.html(i);
                        continue;
                    case"paragraph":
                        n += this.renderer.paragraph(i);
                        continue;
                    case"text": {
                        let r = i, l = this.renderer.text(r);
                        for (; s + 1 < e.length && "text" === e[s + 1].type;) r = e[++s], l += "\n" + this.renderer.text(r);
                        n += t ? this.renderer.paragraph({
                            type: "paragraph",
                            raw: l,
                            text: l,
                            tokens: [{type: "text", raw: l, text: l, escaped: !0}]
                        }) : l;
                        continue
                    }
                    default: {
                        const e = 'Token with "' + i.type + '" type was not found.';
                        if (this.options.silent) return console.error(e), "";
                        throw new Error(e)
                    }
                }
            }
            return n
        }

        parseInline(e, t = this.renderer) {
            let n = "";
            for (let s = 0; s < e.length; s++) {
                const r = e[s];
                if (this.options.extensions?.renderers?.[r.type]) {
                    const e = this.options.extensions.renderers[r.type].call({parser: this}, r);
                    if (!1 !== e || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(r.type)) {
                        n += e || "";
                        continue
                    }
                }
                const i = r;
                switch (i.type) {
                    case"escape":
                    case"text":
                        n += t.text(i);
                        break;
                    case"html":
                        n += t.html(i);
                        break;
                    case"link":
                        n += t.link(i);
                        break;
                    case"image":
                        n += t.image(i);
                        break;
                    case"strong":
                        n += t.strong(i);
                        break;
                    case"em":
                        n += t.em(i);
                        break;
                    case"codespan":
                        n += t.codespan(i);
                        break;
                    case"br":
                        n += t.br(i);
                        break;
                    case"del":
                        n += t.del(i);
                        break;
                    default: {
                        const e = 'Token with "' + i.type + '" type was not found.';
                        if (this.options.silent) return console.error(e), "";
                        throw new Error(e)
                    }
                }
            }
            return n
        }
    }

    class ee {
        static passThroughHooks = new Set(["preprocess", "postprocess", "processAllTokens"]);
        options;
        block;

        constructor(t) {
            this.options = t || e.defaults
        }

        preprocess(e) {
            return e
        }

        postprocess(e) {
            return e
        }

        processAllTokens(e) {
            return e
        }

        provideLexer() {
            return this.block ? K.lex : K.lexInline
        }

        provideParser() {
            return this.block ? Y.parse : Y.parseInline
        }
    }

    class te {
        defaults = {
            async: !1,
            breaks: !1,
            extensions: null,
            gfm: !0,
            hooks: null,
            pedantic: !1,
            renderer: null,
            silent: !1,
            tokenizer: null,
            walkTokens: null
        };
        options = this.setOptions;
        parse = this.parseMarkdown(!0);
        parseInline = this.parseMarkdown(!1);
        Parser = Y;
        Renderer = V;
        TextRenderer = W;
        Lexer = K;
        Tokenizer = J;
        Hooks = ee;

        constructor(...e) {
            this.use(...e)
        }

        walkTokens(e, t) {
            let n = [];
            for (const s of e) switch (n = n.concat(t.call(this, s)), s.type) {
                case"table": {
                    const e = s;
                    for (const s of e.header) n = n.concat(this.walkTokens(s.tokens, t));
                    for (const s of e.rows) for (const e of s) n = n.concat(this.walkTokens(e.tokens, t));
                    break
                }
                case"list": {
                    const e = s;
                    n = n.concat(this.walkTokens(e.items, t));
                    break
                }
                default: {
                    const e = s;
                    this.defaults.extensions?.childTokens?.[e.type] ? this.defaults.extensions.childTokens[e.type].forEach((s => {
                        const r = e[s].flat(1 / 0);
                        n = n.concat(this.walkTokens(r, t))
                    })) : e.tokens && (n = n.concat(this.walkTokens(e.tokens, t)))
                }
            }
            return n
        }

        use(...e) {
            const t = this.defaults.extensions || {renderers: {}, childTokens: {}};
            return e.forEach((e => {
                const n = {...e};
                if (n.async = this.defaults.async || n.async || !1, e.extensions && (e.extensions.forEach((e => {
                    if (!e.name) throw new Error("extension name required");
                    if ("renderer" in e) {
                        const n = t.renderers[e.name];
                        t.renderers[e.name] = n ? function (...t) {
                            let s = e.renderer.apply(this, t);
                            return !1 === s && (s = n.apply(this, t)), s
                        } : e.renderer
                    }
                    if ("tokenizer" in e) {
                        if (!e.level || "block" !== e.level && "inline" !== e.level) throw new Error("extension level must be 'block' or 'inline'");
                        const n = t[e.level];
                        n ? n.unshift(e.tokenizer) : t[e.level] = [e.tokenizer], e.start && ("block" === e.level ? t.startBlock ? t.startBlock.push(e.start) : t.startBlock = [e.start] : "inline" === e.level && (t.startInline ? t.startInline.push(e.start) : t.startInline = [e.start]))
                    }
                    "childTokens" in e && e.childTokens && (t.childTokens[e.name] = e.childTokens)
                })), n.extensions = t), e.renderer) {
                    const t = this.defaults.renderer || new V(this.defaults);
                    for (const n in e.renderer) {
                        if (!(n in t)) throw new Error(`renderer '${n}' does not exist`);
                        if (["options", "parser"].includes(n)) continue;
                        const s = n, r = e.renderer[s], i = t[s];
                        t[s] = (...e) => {
                            let n = r.apply(t, e);
                            return !1 === n && (n = i.apply(t, e)), n || ""
                        }
                    }
                    n.renderer = t
                }
                if (e.tokenizer) {
                    const t = this.defaults.tokenizer || new J(this.defaults);
                    for (const n in e.tokenizer) {
                        if (!(n in t)) throw new Error(`tokenizer '${n}' does not exist`);
                        if (["options", "rules", "lexer"].includes(n)) continue;
                        const s = n, r = e.tokenizer[s], i = t[s];
                        t[s] = (...e) => {
                            let n = r.apply(t, e);
                            return !1 === n && (n = i.apply(t, e)), n
                        }
                    }
                    n.tokenizer = t
                }
                if (e.hooks) {
                    const t = this.defaults.hooks || new ee;
                    for (const n in e.hooks) {
                        if (!(n in t)) throw new Error(`hook '${n}' does not exist`);
                        if (["options", "block"].includes(n)) continue;
                        const s = n, r = e.hooks[s], i = t[s];
                        ee.passThroughHooks.has(n) ? t[s] = e => {
                            if (this.defaults.async) return Promise.resolve(r.call(t, e)).then((e => i.call(t, e)));
                            const n = r.call(t, e);
                            return i.call(t, n)
                        } : t[s] = (...e) => {
                            let n = r.apply(t, e);
                            return !1 === n && (n = i.apply(t, e)), n
                        }
                    }
                    n.hooks = t
                }
                if (e.walkTokens) {
                    const t = this.defaults.walkTokens, s = e.walkTokens;
                    n.walkTokens = function (e) {
                        let n = [];
                        return n.push(s.call(this, e)), t && (n = n.concat(t.call(this, e))), n
                    }
                }
                this.defaults = {...this.defaults, ...n}
            })), this
        }

        setOptions(e) {
            return this.defaults = {...this.defaults, ...e}, this
        }

        lexer(e, t) {
            return K.lex(e, t ?? this.defaults)
        }

        parser(e, t) {
            return Y.parse(e, t ?? this.defaults)
        }

        parseMarkdown(e) {
            return (t, n) => {
                const s = {...n}, r = {...this.defaults, ...s}, i = this.onError(!!r.silent, !!r.async);
                if (!0 === this.defaults.async && !1 === s.async) return i(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."));
                if (null == t) return i(new Error("marked(): input parameter is undefined or null"));
                if ("string" != typeof t) return i(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(t) + ", string expected"));
                r.hooks && (r.hooks.options = r, r.hooks.block = e);
                const l = r.hooks ? r.hooks.provideLexer() : e ? K.lex : K.lexInline,
                    o = r.hooks ? r.hooks.provideParser() : e ? Y.parse : Y.parseInline;
                if (r.async) return Promise.resolve(r.hooks ? r.hooks.preprocess(t) : t).then((e => l(e, r))).then((e => r.hooks ? r.hooks.processAllTokens(e) : e)).then((e => r.walkTokens ? Promise.all(this.walkTokens(e, r.walkTokens)).then((() => e)) : e)).then((e => o(e, r))).then((e => r.hooks ? r.hooks.postprocess(e) : e)).catch(i);
                try {
                    r.hooks && (t = r.hooks.preprocess(t));
                    let e = l(t, r);
                    r.hooks && (e = r.hooks.processAllTokens(e)), r.walkTokens && this.walkTokens(e, r.walkTokens);
                    let n = o(e, r);
                    return r.hooks && (n = r.hooks.postprocess(n)), n
                } catch (e) {
                    return i(e)
                }
            }
        }

        onError(e, t) {
            return n => {
                if (n.message += "\nPlease report this to https://github.com/markedjs/marked.", e) {
                    const e = "<p>An error occurred:</p><pre>" + G(n.message + "", !0) + "</pre>";
                    return t ? Promise.resolve(e) : e
                }
                if (t) return Promise.reject(n);
                throw n
            }
        }
    }

    const ne = new te;

    function se(e, t) {
        return ne.parse(e, t)
    }

    se.options = se.setOptions = function (e) {
        return ne.setOptions(e), se.defaults = ne.defaults, n(se.defaults), se
    }, se.getDefaults = t, se.defaults = e.defaults, se.use = function (...e) {
        return ne.use(...e), se.defaults = ne.defaults, n(se.defaults), se
    }, se.walkTokens = function (e, t) {
        return ne.walkTokens(e, t)
    }, se.parseInline = ne.parseInline, se.Parser = Y, se.parser = Y.parse, se.Renderer = V, se.TextRenderer = W, se.Lexer = K, se.lexer = K.lex, se.Tokenizer = J, se.Hooks = ee, se.parse = se;
    const re = se.options, ie = se.setOptions, le = se.use, oe = se.walkTokens, ae = se.parseInline, ce = se,
        he = Y.parse, pe = K.lex;
    e.Hooks = ee, e.Lexer = K, e.Marked = te, e.Parser = Y, e.Renderer = V, e.TextRenderer = W, e.Tokenizer = J, e.getDefaults = t, e.lexer = pe, e.marked = se, e.options = re, e.parse = ce, e.parseInline = ae, e.parser = he, e.setOptions = ie, e.use = le, e.walkTokens = oe
}));