{"version":3,"names":["async","fetchFooterData","language","caasBaseUrl","cmsCountryId","url","URL","toUpperCase","searchParams","append","fetch","href","then","res","json","data","_embedded","err","console","error","catch","fetchNewestBlogPostData","date","Date","setMinutes","setSeconds","toISOString","replace","substring","fetchLabels","_getDefaults","breaks","extensions","gfm","hooks","pedantic","renderer","silent","tokenizer","walkTokens","_defaults","changeDefaults","newDefaults","escapeTest","escapeReplace","RegExp","source","escapeTestNoEncode","escapeReplaceNoEncode","escapeReplacements","getEscapeReplacement","ch","escape$1","html","encode","test","caret","edit","regex","opt","obj","name","val","valSource","getRegex","cleanUrl","encodeURI","noopTest","exec","splitCells","tableRow","count","row","match","offset","str","escaped","curr","cells","split","i","trim","shift","length","pop","splice","push","rtrim","c","invert","l","suffLen","currChar","charAt","slice","findClosingBracket","b","indexOf","level","outputLink","cap","link","raw","lexer","title","text","state","inLink","token","type","tokens","inlineTokens","indentCodeCompensation","matchIndentToCode","indentToCode","map","node","matchIndentInNode","indentInNode","join","_Tokenizer","options","rules","constructor","this","space","src","block","newline","code","codeBlockStyle","fences","lang","inline","anyPunctuation","heading","trimmed","depth","hr","blockquote","lines","inBlockquote","currentLines","currentRaw","currentText","top","blockTokens","lastToken","oldToken","newText","newToken","list","bull","isordered","ordered","start","loose","items","itemRegex","endsWithBlankLine","endEarly","itemContents","line","t","repeat","nextLine","blankLine","indent","trimStart","search","nextBulletRegex","Math","min","hrRegex","fencesBeginRegex","headingBeginRegex","htmlBeginRegex","rawLine","nextLineWithoutTabs","istask","ischecked","task","checked","trimEnd","spacers","filter","hasMultipleLineBreaks","some","pre","def","tag","toLowerCase","table","headers","aligns","rows","item","header","align","cell","lheading","paragraph","escape","inRawBlock","trimmedUrl","rtrimSlash","lastParenIndex","linkLen","reflink","links","nolink","linkString","emStrong","maskedSrc","prevChar","emStrongLDelim","nextChar","punctuation","lLength","rDelim","rLength","delimTotal","midDelimTotal","endReg","emStrongRDelimAst","emStrongRDelimUnd","lastIndex","lastCharLength","index","codespan","hasNonSpaceChars","hasSpaceCharsOnBothEnds","br","del","autolink","prevCapZero","_backpedal","inlineText","blockCode","bullet","_paragraph","blockText","_blockLabel","_tag","_comment","blockNormal","gfmTable","blockGfm","blockPedantic","inlineCode","_punctuation","blockSkip","_inlineComment","_inlineLabel","reflinkSearch","inlineNormal","inlinePedantic","inlineGfm","inlineBreaks","normal","_Lexer","inlineQueue","Object","create","lex","lexInline","next","lastParagraphClipped","cutSrc","extTokenizer","call","startBlock","startIndex","Infinity","tempSrc","tempStart","forEach","getStartIndex","errMsg","charCodeAt","Error","keepPrevChar","keys","includes","lastIndexOf","startInline","_Renderer","parser","langString","body","parse","parseInline","j","listitem","startAttr","itemBody","checkbox","unshift","tablecell","tablerow","k","content","strong","em","cleanHref","out","image","_TextRenderer","_Parser","textRenderer","anyToken","renderers","genericToken","ret","textToken","_Hooks","static","Set","preprocess","markdown","postprocess","processAllTokens","provideLexer","provideParser","Marked","defaults","setOptions","parseMarkdown","Parser","Renderer","TextRenderer","Lexer","Tokenizer","Hooks","args","use","callback","values","concat","tableToken","listToken","childTokens","flat","pack","opts","ext","prevRenderer","apply","extLevel","prop","rendererProp","rendererFunc","tokenizerProp","tokenizerFunc","prevTokenizer","hooksProp","hooksFunc","prevHook","passThroughHooks","has","arg","Promise","resolve","packWalktokens","blockType","origOpt","throwError","onError","prototype","toString","all","e","message","msg","reject","markedInstance","marked","getDefaults","removeHtmlTags","convertToPlaintext","renderedText","truncateWholeWords","charLength","tail","biggestWordLength","truncatedText","lastSpace","sewWsFooterApiCss","SewWsFooterApi","hostRef","displayNewestBlogPost","getLogoMarkup","footerData","logo","svg","svgMarkup","renderFourthColumn","h","slot","headline","footerSectionFourthColumn","alt","description","renderFourthColumnWithBlogPost","blogPostData","class","preview_picture","mq1","hero_picture_alt","hero_picture_title","srcSet","mq1r","innerHTML","labelParser","getLabel","updateLanguage","getFooterData","updateCaasBaseUrl","allRequiredDataIsSet","countryCode","getBlogPostData","post","labelResponse","dictionary","labels","LabelParser","undefined","setFooterMargin","gsapElement","document","querySelector","gsapChildren","children","lastElementInGsap","classList","contains","matches","host","style","setProperty","componentWillLoad","copyright","getFullYear","render","Host","key","legalOnly","noMargin","noLogo","Fragment","footerSectionFirstColumn","footerSectionSecondColumn","contact","phone","footerSectionThirdColumn","bottomLinks","col","noSocial","socialLinks","icon"],"sources":["src/components/website-components/sew-ws-footer-api/sew-ws-footer-api.service.tsx","../../node_modules/marked/lib/marked.esm.js","src/components/website-components/sew-ws-footer-api/sew-ws-footer.helper.ts","src/components/website-components/sew-ws-footer-api/sew-ws-footer-api.scss?tag=sew-ws-footer-api&encapsulation=shadow","src/components/website-components/sew-ws-footer-api/sew-ws-footer-api.tsx"],"sourcesContent":["import { LabelsRhdoc } from '../sew-ws-header/types/labels.types';\nimport { BlogPostResponse, FooterData } from './sew-ws-footer-api.types';\n\nexport async function fetchFooterData(\n    language: string,\n    caasBaseUrl: string,\n    cmsCountryId: string\n): Promise<FooterData | null> {\n    const url = new URL(`${caasBaseUrl}/direct/SEW${cmsCountryId.toUpperCase()}/main-footer`);\n\n    url.searchParams.append('filter', `{'fs_language':'${language}'}`);\n\n    return await fetch(url.href)\n        .then(res => res.json())\n        .then(\n            data => {\n                if (typeof data._embedded !== 'undefined') {\n                    return data._embedded['rh:doc'][0];\n                }\n\n                return null;\n            },\n            err => console.error(err)\n        )\n        .catch(err => console.error(err));\n}\n\nexport async function fetchNewestBlogPostData(\n    language: string,\n    caasBaseUrl: string,\n    cmsCountryId: string\n): Promise<BlogPostResponse | null> {\n    const url = new URL(`${caasBaseUrl}/direct/Blog-${cmsCountryId.toUpperCase()}/blog_posts`);\n    const date = new Date();\n    date.setMinutes(0);\n    date.setSeconds(0);\n\n    url.searchParams.append('filter', `{'fs_language':'${language}'}`);\n    url.searchParams.append(\n        'filter',\n        `{'date': {'$lt': '${date.toISOString().replace('T', ' ').substring(0, 19)}'}}`\n    );\n    url.searchParams.append('page', '1');\n    url.searchParams.append('pagesize', '1');\n    url.searchParams.append('sort', '-date');\n\n    return await fetch(url.href)\n        .then(res => res.json())\n        .then(\n            data => {\n                if (typeof data._embedded !== 'undefined') {\n                    return data._embedded['rh:doc'][0];\n                }\n\n                return null;\n            },\n            err => console.error(err)\n        )\n        .catch(err => console.error(err));\n}\n\nexport async function fetchLabels(\n    language: string,\n    caasBaseUrl: string,\n    cmsCountryId: string\n): Promise<LabelsRhdoc | null> {\n    const url = new URL(`${caasBaseUrl}/direct/SEW${cmsCountryId.toUpperCase()}/dictionary`);\n\n    url.searchParams.append('filter', `{'fs_language':'${language}'}`);\n    url.searchParams.append('keys', '{\"dictionary.CMS_FOOTER_READ_BLOG_POST\":1}');\n\n    return await fetch(url.href)\n        .then(res => res.json())\n        .then(\n            data => {\n                if (typeof data._embedded !== 'undefined') {\n                    return data._embedded['rh:doc'][0];\n                }\n\n                return null;\n            },\n            err => console.error(err)\n        )\n        .catch(err => console.error(err));\n}\n","/**\n * marked v14.1.4 - a markdown parser\n * Copyright (c) 2011-2024, Christopher Jeffrey. (MIT Licensed)\n * https://github.com/markedjs/marked\n */\n\n/**\n * DO NOT EDIT THIS FILE\n * The code in this file is generated from files in ./src/\n */\n\n/**\n * Gets the original marked default options.\n */\nfunction _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}\nlet _defaults = _getDefaults();\nfunction changeDefaults(newDefaults) {\n    _defaults = newDefaults;\n}\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];\nfunction escape$1(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 caret = /(^|[^\\[])\\^/g;\nfunction 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}\nfunction cleanUrl(href) {\n    try {\n        href = encodeURI(href).replace(/%25/g, '%');\n    }\n    catch {\n        return null;\n    }\n    return href;\n}\nconst noopTest = { exec: () => null };\nfunction 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 */\nfunction 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}\nfunction 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\nfunction outputLink(cap, link, raw, lexer) {\n    const href = link.href;\n    const title = link.title ? escape$1(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$1(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 */\nclass _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}| {0,3}\\t)/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 && /^[ \\t]*$/.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                    const htmlBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}<(?:[a-z].*>|!--)`, 'i');\n                    // Check if following lines should be included in List Item\n                    while (src) {\n                        const rawLine = src.split('\\n', 1)[0];\n                        let nextLineWithoutTabs;\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                            nextLineWithoutTabs = nextLine;\n                        }\n                        else {\n                            nextLineWithoutTabs = nextLine.replace(/\\t/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 html block\n                        if (htmlBeginRegex.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(nextLine)) {\n                            break;\n                        }\n                        if (nextLineWithoutTabs.search(/[^ ]/) >= indent || !nextLine.trim()) { // Dedent if possible\n                            itemContents += '\\n' + nextLineWithoutTabs.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.replace(/\\t/g, '    ').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 = nextLineWithoutTabs.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[ \\t]*\\n[ \\t]*$/.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$1(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$1(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$1(cap[1]);\n                href = 'mailto:' + text;\n            }\n            else {\n                text = escape$1(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$1(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$1(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$1(cap[0]);\n            }\n            return {\n                type: 'text',\n                raw: cap[0],\n                text,\n            };\n        }\n    }\n}\n\n/**\n * Block-Level Grammar\n */\nconst newline = /^(?:[ \\t]*(?:\\n|$))+/;\nconst blockCode = /^((?: {4}| {0,3}\\t)[^\\n]+(?:\\n(?:[ \\t]*(?:\\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}| {0,3}\\t)/) // 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[ \\t]*)?([^<\\s][^\\s]*|<.*?>)(?:(?: +(?:\\n[ \\t]*)?| *\\n[ \\t]*)(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[ \\t]*)+\\\\n|$)' // (6)\n    + '|<(?!script|pre|style|textarea)([a-z][\\\\w-]*)(?:attribute)*? */?>(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n[ \\t]*)+\\\\n|$)' // (7) open tag\n    + '|</(?!script|pre|style|textarea)[a-z][\\\\w-]*\\\\s*>(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n[ \\t]*)+\\\\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}| {0,3}\\t)[^\\\\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~\\\\]))\\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 */\nconst block = {\n    normal: blockNormal,\n    gfm: blockGfm,\n    pedantic: blockPedantic,\n};\nconst inline = {\n    normal: inlineNormal,\n    gfm: inlineGfm,\n    breaks: inlineBreaks,\n    pedantic: inlinePedantic,\n};\n\n/**\n * Block Lexer\n */\nclass _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        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\n/**\n * Renderer\n */\nclass _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$1(code, true))\n                + '</code></pre>\\n';\n        }\n        return '<pre><code class=\"language-'\n            + escape$1(langString)\n            + '\">'\n            + (escaped ? code : escape$1(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/**\n * TextRenderer\n * returns only the textual part of the token\n */\nclass _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\n/**\n * Parsing & Compiling\n */\nclass _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\nclass _Hooks {\n    options;\n    block;\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     * Provide function to tokenize markdown\n     */\n    provideLexer() {\n        return this.block ? _Lexer.lex : _Lexer.lexInline;\n    }\n    /**\n     * Provide function to parse tokens\n     */\n    provideParser() {\n        return this.block ? _Parser.parse : _Parser.parseInline;\n    }\n}\n\nclass Marked {\n    defaults = _getDefaults();\n    options = this.setOptions;\n    parse = this.parseMarkdown(true);\n    parseInline = this.parseMarkdown(false);\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 (['options', 'block'].includes(prop)) {\n                        // ignore options and block properties\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(blockType) {\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                opt.hooks.block = blockType;\n            }\n            const lexer = opt.hooks ? opt.hooks.provideLexer() : (blockType ? _Lexer.lex : _Lexer.lexInline);\n            const parser = opt.hooks ? opt.hooks.provideParser() : (blockType ? _Parser.parse : _Parser.parseInline);\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$1(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\nconst markedInstance = new Marked();\nfunction 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;\nconst options = marked.options;\nconst setOptions = marked.setOptions;\nconst use = marked.use;\nconst walkTokens = marked.walkTokens;\nconst parseInline = marked.parseInline;\nconst parse = marked;\nconst parser = _Parser.parse;\nconst lexer = _Lexer.lex;\n\nexport { _Hooks as Hooks, _Lexer as Lexer, Marked, _Parser as Parser, _Renderer as Renderer, _TextRenderer as TextRenderer, _Tokenizer as Tokenizer, _defaults as defaults, _getDefaults as getDefaults, lexer, marked, options, parse, parseInline, parser, setOptions, use, walkTokens };\n//# sourceMappingURL=marked.esm.js.map\n","import { marked } from 'marked';\n\nconst removeHtmlTags = (text: string): string => {\n    return text.replace(/<\\/?[^>]+(>|$)/g, '');\n};\n\nexport const convertToPlaintext = (text: string): string => {\n    const renderer = new marked.Renderer();\n    const renderedText = (text ? marked(text, { renderer }) : '') as string;\n\n    return removeHtmlTags(renderedText);\n};\n\nexport const truncateWholeWords = (text: string, charLength: number, tail: string): string => {\n    const biggestWordLength = 50;\n    if (typeof text === 'undefined') return text;\n    if (text.length <= charLength) return text;\n    //.. truncate to about correct lenght\n    let truncatedText = text.slice(0, charLength + biggestWordLength);\n    //.. now nibble ends till correct length\n    while (truncatedText.length > charLength - tail.length) {\n        const lastSpace = truncatedText.lastIndexOf(' ');\n        if (lastSpace === -1) break;\n        truncatedText = truncatedText.slice(0, lastSpace).replace(/[!,.?;:]$/, '');\n    }\n    return truncatedText + tail;\n};\n","a[slot='logo'] {\n    width: 83px;\n    height: 40px;\n    display: block;\n\n    svg {\n        width: 100%;\n        height: auto;\n\n        .claim {\n            display: none;\n        }\n    }\n\n    &.swiss {\n        width: 56px;\n        height: 57px;\n\n        svg {\n            transform: scale(2.1) translate3d(0, 0, 0);\n            transform-origin: center top;\n        }\n    }\n\n    &.brasil {\n        width: 73px;\n        height: 48px;\n    }\n\n    &.france {\n        width: 83px;\n        height: 44px;\n    }\n}\n\n@include mq-2 {\n    a[slot='logo'] {\n        width: 87px;\n        height: 40px;\n\n        &.swiss {\n            width: 48px;\n            height: 48px;\n        }\n\n        &.brasil {\n            width: 73px;\n            height: 48px;\n        }\n\n        &.france {\n            width: 83px;\n            height: 40px;\n        }\n    }\n}\n\n@include mq-1 {\n    a[slot='logo'] {\n        width: 69px;\n        height: 32px;\n\n        &.swiss {\n            width: 40px;\n            height: 40px;\n\n            svg {\n                transform: scale(2.1);\n            }\n        }\n\n        &.brasil {\n            width: 60px;\n            height: 40px;\n        }\n\n        &.france {\n            width: 67px;\n            height: 32px;\n        }\n    }\n}\n","import { Component, Fragment, h, Host, Prop, State, Watch, Element } from '@stencil/core';\nimport { LabelParser } from '../sew-ws-header/helpers/labels.helpers';\nimport { Labels } from '../sew-ws-header/types/labels.types';\nimport { fetchFooterData, fetchLabels, fetchNewestBlogPostData } from './sew-ws-footer-api.service';\nimport { BlogPostResponse, FooterData } from './sew-ws-footer-api.types';\nimport { convertToPlaintext, truncateWholeWords } from './sew-ws-footer.helper';\n\n@Component({\n    tag: 'sew-ws-footer-api',\n    styleUrl: 'sew-ws-footer-api.scss',\n    shadow: true,\n})\nexport class SewWsFooterApi {\n    @Element() host: HTMLSewWsFooterApiElement;\n    @Prop() language: string;\n    @Prop() legalOnly?: boolean;\n    @Prop() noSocial?: boolean;\n    @Prop() noMargin?: boolean;\n    @Prop() noLogo?: boolean;\n\n    /**\n     * ID of the CMS Blog Project.\n     * This value is the same for blog and country cms project (de for SEWDE and Blog-DE).\n     *\n     * @example de\n     * @example uk\n     */\n    @Prop() countryCode?: string;\n\n    /**\n     * Base url for caas requests.\n     * This value is needed to fetch data from CaaS.\n     *\n     * @example https://caas.sew-eurodrive.com\n     */\n    @Prop() caasBaseUrl?: string;\n\n    /**\n     * Determines if the latest blog post is displayed or not\n     *\n     * @default false\n     */\n    @Prop() displayNewestBlogPost = false;\n\n    @State() footerData: FooterData | null;\n    @State() blogPostData: BlogPostResponse | null;\n    @State() svgMarkup: string;\n    @State() labels: Labels;\n\n    private labelParser: LabelParser;\n\n    @Watch('language')\n    updateLanguage(): void {\n        this.getFooterData();\n    }\n\n    @Watch('caasBaseUrl')\n    updateCaasBaseUrl(): void {\n        this.getFooterData();\n    }\n\n    private copyright: string;\n\n    private getFooterData(): void {\n        if (this.allRequiredDataIsSet()) {\n            fetchFooterData(this.language, this.caasBaseUrl, this.countryCode)\n                .then(res => (this.footerData = res))\n                .then(this.getLogoMarkup);\n\n            this.displayNewestBlogPost && this.getBlogPostData();\n        }\n    }\n\n    private getBlogPostData(): void {\n        fetchNewestBlogPostData(this.language, this.caasBaseUrl, this.countryCode).then(post => {\n            this.blogPostData = post;\n        });\n\n        fetchLabels(this.language, this.caasBaseUrl, this.countryCode)\n            .then(labelResponse => {\n                if (labelResponse === null) {\n                    return null;\n                }\n                return labelResponse.dictionary;\n            })\n            .then(labels => (this.labelParser = new LabelParser(labels)));\n    }\n\n    private getLogoMarkup = async (): Promise<void> => {\n        if (this.footerData === null) {\n            return;\n        }\n\n        await fetch(this.footerData.logo.logo + '?SEWNoSSO=true')\n            .then(\n                svg => svg.text(),\n                err => console.error(err)\n            )\n            .then(text => (this.svgMarkup = text as string))\n            .catch(err => console.error(err));\n    };\n\n    private allRequiredDataIsSet(): boolean {\n        return (\n            this.countryCode !== undefined &&\n            this.countryCode.length > 0 &&\n            this.caasBaseUrl !== undefined &&\n            this.caasBaseUrl.length > 0\n        );\n    }\n\n    private renderFourthColumn = () => {\n        return (\n            <sew-ws-footer-teaser\n                slot=\"column4\"\n                headline={this.footerData.footerSectionFourthColumn.headline}\n            >\n                <sew-picture\n                    img-src={this.footerData.footerSectionFourthColumn.image.src}\n                    img-alt={this.footerData.footerSectionFourthColumn.image.alt}\n                    img-title={this.footerData.footerSectionFourthColumn.image.title}\n                ></sew-picture>\n                <p>{this.footerData.footerSectionFourthColumn.description}</p>\n                <sew-ws-link>\n                    <a href={this.footerData.footerSectionFourthColumn.link.href}>\n                        {this.footerData.footerSectionFourthColumn.link.text}\n                    </a>\n                </sew-ws-link>\n            </sew-ws-footer-teaser>\n        );\n    };\n\n    private renderFourthColumnWithBlogPost = () => {\n        return (\n            <sew-ws-footer-teaser slot=\"column4\" headline={this.blogPostData.headline}>\n                <a href={this.blogPostData.url} class=\"blog-post\">\n                    <sew-picture\n                        img-src={this.blogPostData.preview_picture.mq1}\n                        img-alt={this.blogPostData.hero_picture_alt}\n                        img-title={this.blogPostData.hero_picture_title}\n                    >\n                        <source\n                            srcSet={\n                                this.blogPostData.preview_picture.mq1 +\n                                ' 1x, ' +\n                                this.blogPostData.preview_picture.mq1r +\n                                ' 2x'\n                            }\n                        />\n                    </sew-picture>\n                </a>\n                <p\n                    innerHTML={truncateWholeWords(\n                        convertToPlaintext(this.blogPostData.content[0].text),\n                        120,\n                        '...'\n                    )}\n                ></p>\n                <sew-ws-link>\n                    <a href={this.blogPostData.url}>\n                        {this.labelParser && this.labelParser.getLabel('CMS_FOOTER_READ_BLOG_POST')}\n                    </a>\n                </sew-ws-link>\n            </sew-ws-footer-teaser>\n        );\n    };\n\n    private setFooterMargin() {\n        const gsapElement = document.querySelector('sew-ws-gsap');\n\n        if (!gsapElement) return;\n\n        const gsapChildren = gsapElement.children;\n\n        if (gsapChildren.length === 0) return;\n\n        let lastElementInGsap = gsapChildren[gsapChildren.length - 1];\n\n        if (lastElementInGsap.classList.contains('pin-spacer')) {\n            lastElementInGsap = lastElementInGsap.children[0];\n        }\n\n        if (\n            lastElementInGsap.matches(\n                'sew-ws-report-pre-registration, sew-ws-outro, sew-ws-fullscreen-teaser, sew-ws-image-text[underlay], sew-ws-circle-teaser2'\n            )\n        ) {\n            this.host.style.setProperty('--footer-margin-top', '1px');\n        }\n    }\n\n    componentWillLoad(): void {\n        this.setFooterMargin();\n        this.copyright = `© ${new Date().getFullYear()} SEW-EURODRIVE`;\n        this.getFooterData();\n    }\n\n    render() {\n        return (\n            <Host>\n                <sew-ws-footer\n                    class={{ 'legal-only': this.legalOnly }}\n                    noMargin={this.noMargin}\n                    copyright={this.copyright}\n                    logo={!this.noLogo && this.legalOnly}\n                >\n                    {!this.legalOnly && (\n                        <Fragment>\n                            {this.footerData && this.footerData.footerSectionFirstColumn.length > 0 && (\n                                <sew-ws-footer-linklist\n                                    slot=\"column1\"\n                                    headline={this.footerData.footerSectionFirstColumn[0].headline}\n                                >\n                                    {this.footerData.footerSectionFirstColumn.map(row => (\n                                        <sew-ws-footer-link>\n                                            <a href={row.link.href}>{row.link.text}</a>\n                                        </sew-ws-footer-link>\n                                    ))}\n                                </sew-ws-footer-linklist>\n                            )}\n                            {this.footerData && this.footerData.footerSectionSecondColumn.length > 0 && (\n                                <sew-ws-footer-linklist\n                                    slot=\"column2\"\n                                    headline={this.footerData.footerSectionSecondColumn[0].headline}\n                                >\n                                    {this.footerData.footerSectionSecondColumn.map(row => (\n                                        <sew-ws-footer-link>\n                                            <a href={row.link.href}>{row.link.text}</a>\n                                        </sew-ws-footer-link>\n                                    ))}\n                                </sew-ws-footer-linklist>\n                            )}\n                            {this.footerData && this.footerData.contact && (\n                                <sew-ws-footer-phone\n                                    slot=\"column2\"\n                                    headline={this.footerData.contact.headline}\n                                >\n                                    <a href={'tel:' + this.footerData.contact.phone}>\n                                        {this.footerData.contact.phone}\n                                    </a>\n                                </sew-ws-footer-phone>\n                            )}\n                            {this.footerData && this.footerData.footerSectionThirdColumn.length > 0 && (\n                                <sew-ws-footer-linklist\n                                    slot=\"column3\"\n                                    headline={this.footerData.footerSectionThirdColumn[0].headline}\n                                >\n                                    {this.footerData.footerSectionThirdColumn.map(row => (\n                                        <sew-ws-footer-link>\n                                            <a href={row.link.href}>{row.link.text}</a>\n                                        </sew-ws-footer-link>\n                                    ))}\n                                </sew-ws-footer-linklist>\n                            )}\n                            {this.blogPostData && this.renderFourthColumnWithBlogPost()}\n                            {!this.blogPostData &&\n                                this.footerData &&\n                                this.footerData.footerSectionFourthColumn &&\n                                this.renderFourthColumn()}\n                        </Fragment>\n                    )}\n\n                    {!this.noLogo &&\n                        this.legalOnly &&\n                        this.footerData &&\n                        this.footerData.logo &&\n                        this.svgMarkup && (\n                            <a\n                                slot=\"logo\"\n                                href={this.footerData.logo.link.href}\n                                class={this.footerData.logo.class}\n                                title={this.footerData.logo.title}\n                                innerHTML={this.svgMarkup}\n                            />\n                        )}\n\n                    {this.footerData && this.footerData.bottomLinks.length > 0 && (\n                        <sew-ws-footer-linklist-legal slot=\"legal\">\n                            {this.footerData.bottomLinks.map(col => (\n                                <a href={col.link.href}>{col.link.text}</a>\n                            ))}\n                            <slot name=\"additional-legal-links\"></slot>\n                        </sew-ws-footer-linklist-legal>\n                    )}\n                    {!this.noSocial && this.footerData && this.footerData.socialLinks.length > 0 && (\n                        <sew-ws-footer-linklist-social slot=\"social\">\n                            {this.footerData.socialLinks.map(link => (\n                                <a href={link.href} aria-label={link.text}>\n                                    <sew-icon icon={'logo-' + link.type.toLowerCase()}></sew-icon>\n                                </a>\n                            ))}\n                        </sew-ws-footer-linklist-social>\n                    )}\n                </sew-ws-footer>\n            </Host>\n        );\n    }\n}\n"],"mappings":"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","ignoreList":[]}