@orangelogic/design-system 2.19.0-ci.5

package/library/components/markdown.js

@@ -0,0 +1,2706 @@
+import { C as tt, x as nt, n as G, c as rt } from "../chunks/custom-element.fmLrnDZr.js";
+import { w as ge } from "../chunks/watch.BCJD77bD.js";
+import { r as st } from "../chunks/state.Dt9F_SuS.js";
+import { o as it } from "../chunks/unsafe-html.BpqikVtf.js";
+import { c as ze } from "../chunks/_commonjsHelpers.ByX85dGu.js";
+class at extends tt {
+  constructor() {
+    super(), this.#e();
+  }
+  createRenderRoot() {
+    return this;
+  }
+  /**
+   * LitElement applies the styles of a component to the Shadow DOM.
+   * CortexLightElement applies the styles of a component to the Light DOM.
+   */
+  #e() {
+    if (!lt(this.constructor))
+      return;
+    const n = `${this.constructor.name}-styles`;
+    if (!document.getElementById(n)) {
+      const e = document.createElement("style");
+      e.id = n, e.textContent = this.constructor.styles, e.textContent = e.textContent.replace(
+        /:host/g,
+        `${this.tagName.toLowerCase()}`
+      ), document.head.appendChild(e);
+    }
+  }
+}
+function lt(u) {
+  return u.styles !== void 0;
+}
+function xe() {
+  return {
+    async: !1,
+    breaks: !1,
+    extensions: null,
+    gfm: !0,
+    hooks: null,
+    pedantic: !1,
+    renderer: null,
+    silent: !1,
+    tokenizer: null,
+    walkTokens: null
+  };
+}
+let D = xe();
+function Oe(u) {
+  D = u;
+}
+const Ze = /[&<>"']/, ot = new RegExp(Ze.source, "g"), Be = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, ct = new RegExp(Be.source, "g"), ut = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+}, Ee = (u) => ut[u];
+function R(u, n) {
+  if (n) {
+    if (Ze.test(u))
+      return u.replace(ot, Ee);
+  } else if (Be.test(u))
+    return u.replace(ct, Ee);
+  return u;
+}
+const pt = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
+function ht(u) {
+  return u.replace(pt, (n, e) => (e = e.toLowerCase(), e === "colon" ? ":" : e.charAt(0) === "#" ? e.charAt(1) === "x" ? String.fromCharCode(parseInt(e.substring(2), 16)) : String.fromCharCode(+e.substring(1)) : ""));
+}
+const gt = /(^|[^\[])\^/g;
+function T(u, n) {
+  let e = typeof u == "string" ? u : u.source;
+  n = n || "";
+  const t = {
+    replace: (s, i) => {
+      let r = typeof i == "string" ? i : i.source;
+      return r = r.replace(gt, "$1"), e = e.replace(s, r), t;
+    },
+    getRegex: () => new RegExp(e, n)
+  };
+  return t;
+}
+function Re(u) {
+  try {
+    u = encodeURI(u).replace(/%25/g, "%");
+  } catch {
+    return null;
+  }
+  return u;
+}
+const W = { exec: () => null };
+function Ce(u, n) {
+  const e = u.replace(/\|/g, (i, r, a) => {
+    let c = !1, m = r;
+    for (; --m >= 0 && a[m] === "\\"; )
+      c = !c;
+    return c ? "|" : " |";
+  }), t = e.split(/ \|/);
+  let s = 0;
+  if (t[0].trim() || t.shift(), t.length > 0 && !t[t.length - 1].trim() && t.pop(), n)
+    if (t.length > n)
+      t.splice(n);
+    else
+      for (; t.length < n; )
+        t.push("");
+  for (; s < t.length; s++)
+    t[s] = t[s].trim().replace(/\\\|/g, "|");
+  return t;
+}
+function ee(u, n, e) {
+  const t = u.length;
+  if (t === 0)
+    return "";
+  let s = 0;
+  for (; s < t && u.charAt(t - s - 1) === n; )
+    s++;
+  return u.slice(0, t - s);
+}
+function ft(u, n) {
+  if (u.indexOf(n[1]) === -1)
+    return -1;
+  let e = 0;
+  for (let t = 0; t < u.length; t++)
+    if (u[t] === "\\")
+      t++;
+    else if (u[t] === n[0])
+      e++;
+    else if (u[t] === n[1] && (e--, e < 0))
+      return t;
+  return -1;
+}
+function Ie(u, n, e, t) {
+  const s = n.href, i = n.title ? R(n.title) : null, r = u[1].replace(/\\([\[\]])/g, "$1");
+  if (u[0].charAt(0) !== "!") {
+    t.state.inLink = !0;
+    const a = {
+      type: "link",
+      raw: e,
+      href: s,
+      title: i,
+      text: r,
+      tokens: t.inlineTokens(r)
+    };
+    return t.state.inLink = !1, a;
+  }
+  return {
+    type: "image",
+    raw: e,
+    href: s,
+    title: i,
+    text: R(r)
+  };
+}
+function dt(u, n) {
+  const e = u.match(/^(\s+)(?:```)/);
+  if (e === null)
+    return n;
+  const t = e[1];
+  return n.split(`
+`).map((s) => {
+    const i = s.match(/^\s+/);
+    if (i === null)
+      return s;
+    const [r] = i;
+    return r.length >= t.length ? s.slice(t.length) : s;
+  }).join(`
+`);
+}
+class se {
+  options;
+  rules;
+  // set by the lexer
+  lexer;
+  // set by the lexer
+  constructor(n) {
+    this.options = n || D;
+  }
+  space(n) {
+    const e = this.rules.block.newline.exec(n);
+    if (e && e[0].length > 0)
+      return {
+        type: "space",
+        raw: e[0]
+      };
+  }
+  code(n) {
+    const e = this.rules.block.code.exec(n);
+    if (e) {
+      const t = e[0].replace(/^ {1,4}/gm, "");
+      return {
+        type: "code",
+        raw: e[0],
+        codeBlockStyle: "indented",
+        text: this.options.pedantic ? t : ee(t, `
+`)
+      };
+    }
+  }
+  fences(n) {
+    const e = this.rules.block.fences.exec(n);
+    if (e) {
+      const t = e[0], s = dt(t, e[3] || "");
+      return {
+        type: "code",
+        raw: t,
+        lang: e[2] ? e[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : e[2],
+        text: s
+      };
+    }
+  }
+  heading(n) {
+    const e = this.rules.block.heading.exec(n);
+    if (e) {
+      let t = e[2].trim();
+      if (/#$/.test(t)) {
+        const s = ee(t, "#");
+        (this.options.pedantic || !s || / $/.test(s)) && (t = s.trim());
+      }
+      return {
+        type: "heading",
+        raw: e[0],
+        depth: e[1].length,
+        text: t,
+        tokens: this.lexer.inline(t)
+      };
+    }
+  }
+  hr(n) {
+    const e = this.rules.block.hr.exec(n);
+    if (e)
+      return {
+        type: "hr",
+        raw: e[0]
+      };
+  }
+  blockquote(n) {
+    const e = this.rules.block.blockquote.exec(n);
+    if (e) {
+      const t = ee(e[0].replace(/^ *>[ \t]?/gm, ""), `
+`), s = this.lexer.state.top;
+      this.lexer.state.top = !0;
+      const i = this.lexer.blockTokens(t);
+      return this.lexer.state.top = s, {
+        type: "blockquote",
+        raw: e[0],
+        tokens: i,
+        text: t
+      };
+    }
+  }
+  list(n) {
+    let e = this.rules.block.list.exec(n);
+    if (e) {
+      let t = e[1].trim();
+      const s = t.length > 1, i = {
+        type: "list",
+        raw: "",
+        ordered: s,
+        start: s ? +t.slice(0, -1) : "",
+        loose: !1,
+        items: []
+      };
+      t = s ? `\\d{1,9}\\${t.slice(-1)}` : `\\${t}`, this.options.pedantic && (t = s ? t : "[*+-]");
+      const r = new RegExp(`^( {0,3}${t})((?:[	 ][^\\n]*)?(?:\\n|$))`);
+      let a = "", c = "", m = !1;
+      for (; n; ) {
+        let f = !1;
+        if (!(e = r.exec(n)) || this.rules.block.hr.test(n))
+          break;
+        a = e[0], n = n.substring(a.length);
+        let b = e[2].split(`
+`, 1)[0].replace(/^\t+/, (S) => " ".repeat(3 * S.length)), d = n.split(`
+`, 1)[0], v = 0;
+        this.options.pedantic ? (v = 2, c = b.trimStart()) : (v = e[2].search(/[^ ]/), v = v > 4 ? 1 : v, c = b.slice(v), v += e[1].length);
+        let E = !1;
+        if (!b && /^ *$/.test(d) && (a += d + `
+`, n = n.substring(d.length + 1), f = !0), !f) {
+          const S = new RegExp(`^ {0,${Math.min(3, v - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`), o = new RegExp(`^ {0,${Math.min(3, v - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`), l = new RegExp(`^ {0,${Math.min(3, v - 1)}}(?:\`\`\`|~~~)`), p = new RegExp(`^ {0,${Math.min(3, v - 1)}}#`);
+          for (; n; ) {
+            const h = n.split(`
+`, 1)[0];
+            if (d = h, this.options.pedantic && (d = d.replace(/^ {1,4}(?=( {4})*[^ ])/g, "  ")), l.test(d) || p.test(d) || S.test(d) || o.test(n))
+              break;
+            if (d.search(/[^ ]/) >= v || !d.trim())
+              c += `
+` + d.slice(v);
+            else {
+              if (E || b.search(/[^ ]/) >= 4 || l.test(b) || p.test(b) || o.test(b))
+                break;
+              c += `
+` + d;
+            }
+            !E && !d.trim() && (E = !0), a += h + `
+`, n = n.substring(h.length + 1), b = d.slice(v);
+          }
+        }
+        i.loose || (m ? i.loose = !0 : /\n *\n *$/.test(a) && (m = !0));
+        let $ = null, w;
+        this.options.gfm && ($ = /^\[[ xX]\] /.exec(c), $ && (w = $[0] !== "[ ] ", c = c.replace(/^\[[ xX]\] +/, ""))), i.items.push({
+          type: "list_item",
+          raw: a,
+          task: !!$,
+          checked: w,
+          loose: !1,
+          text: c,
+          tokens: []
+        }), i.raw += a;
+      }
+      i.items[i.items.length - 1].raw = a.trimEnd(), i.items[i.items.length - 1].text = c.trimEnd(), i.raw = i.raw.trimEnd();
+      for (let f = 0; f < i.items.length; f++)
+        if (this.lexer.state.top = !1, i.items[f].tokens = this.lexer.blockTokens(i.items[f].text, []), !i.loose) {
+          const b = i.items[f].tokens.filter((v) => v.type === "space"), d = b.length > 0 && b.some((v) => /\n.*\n/.test(v.raw));
+          i.loose = d;
+        }
+      if (i.loose)
+        for (let f = 0; f < i.items.length; f++)
+          i.items[f].loose = !0;
+      return i;
+    }
+  }
+  html(n) {
+    const e = this.rules.block.html.exec(n);
+    if (e)
+      return {
+        type: "html",
+        block: !0,
+        raw: e[0],
+        pre: e[1] === "pre" || e[1] === "script" || e[1] === "style",
+        text: e[0]
+      };
+  }
+  def(n) {
+    const e = this.rules.block.def.exec(n);
+    if (e) {
+      const t = e[1].toLowerCase().replace(/\s+/g, " "), s = e[2] ? e[2].replace(/^<(.*)>$/, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", i = e[3] ? e[3].substring(1, e[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : e[3];
+      return {
+        type: "def",
+        tag: t,
+        raw: e[0],
+        href: s,
+        title: i
+      };
+    }
+  }
+  table(n) {
+    const e = this.rules.block.table.exec(n);
+    if (!e || !/[:|]/.test(e[2]))
+      return;
+    const t = Ce(e[1]), s = e[2].replace(/^\||\| *$/g, "").split("|"), i = e[3] && e[3].trim() ? e[3].replace(/\n[ \t]*$/, "").split(`
+`) : [], r = {
+      type: "table",
+      raw: e[0],
+      header: [],
+      align: [],
+      rows: []
+    };
+    if (t.length === s.length) {
+      for (const a of s)
+        /^ *-+: *$/.test(a) ? r.align.push("right") : /^ *:-+: *$/.test(a) ? r.align.push("center") : /^ *:-+ *$/.test(a) ? r.align.push("left") : r.align.push(null);
+      for (const a of t)
+        r.header.push({
+          text: a,
+          tokens: this.lexer.inline(a)
+        });
+      for (const a of i)
+        r.rows.push(Ce(a, r.header.length).map((c) => ({
+          text: c,
+          tokens: this.lexer.inline(c)
+        })));
+      return r;
+    }
+  }
+  lheading(n) {
+    const e = this.rules.block.lheading.exec(n);
+    if (e)
+      return {
+        type: "heading",
+        raw: e[0],
+        depth: e[2].charAt(0) === "=" ? 1 : 2,
+        text: e[1],
+        tokens: this.lexer.inline(e[1])
+      };
+  }
+  paragraph(n) {
+    const e = this.rules.block.paragraph.exec(n);
+    if (e) {
+      const t = e[1].charAt(e[1].length - 1) === `
+` ? e[1].slice(0, -1) : e[1];
+      return {
+        type: "paragraph",
+        raw: e[0],
+        text: t,
+        tokens: this.lexer.inline(t)
+      };
+    }
+  }
+  text(n) {
+    const e = this.rules.block.text.exec(n);
+    if (e)
+      return {
+        type: "text",
+        raw: e[0],
+        text: e[0],
+        tokens: this.lexer.inline(e[0])
+      };
+  }
+  escape(n) {
+    const e = this.rules.inline.escape.exec(n);
+    if (e)
+      return {
+        type: "escape",
+        raw: e[0],
+        text: R(e[1])
+      };
+  }
+  tag(n) {
+    const e = this.rules.inline.tag.exec(n);
+    if (e)
+      return !this.lexer.state.inLink && /^<a /i.test(e[0]) ? this.lexer.state.inLink = !0 : this.lexer.state.inLink && /^<\/a>/i.test(e[0]) && (this.lexer.state.inLink = !1), !this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(e[0]) ? this.lexer.state.inRawBlock = !0 : this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(e[0]) && (this.lexer.state.inRawBlock = !1), {
+        type: "html",
+        raw: e[0],
+        inLink: this.lexer.state.inLink,
+        inRawBlock: this.lexer.state.inRawBlock,
+        block: !1,
+        text: e[0]
+      };
+  }
+  link(n) {
+    const e = this.rules.inline.link.exec(n);
+    if (e) {
+      const t = e[2].trim();
+      if (!this.options.pedantic && /^</.test(t)) {
+        if (!/>$/.test(t))
+          return;
+        const r = ee(t.slice(0, -1), "\\");
+        if ((t.length - r.length) % 2 === 0)
+          return;
+      } else {
+        const r = ft(e[2], "()");
+        if (r > -1) {
+          const c = (e[0].indexOf("!") === 0 ? 5 : 4) + e[1].length + r;
+          e[2] = e[2].substring(0, r), e[0] = e[0].substring(0, c).trim(), e[3] = "";
+        }
+      }
+      let s = e[2], i = "";
+      if (this.options.pedantic) {
+        const r = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(s);
+        r && (s = r[1], i = r[3]);
+      } else
+        i = e[3] ? e[3].slice(1, -1) : "";
+      return s = s.trim(), /^</.test(s) && (this.options.pedantic && !/>$/.test(t) ? s = s.slice(1) : s = s.slice(1, -1)), Ie(e, {
+        href: s && s.replace(this.rules.inline.anyPunctuation, "$1"),
+        title: i && i.replace(this.rules.inline.anyPunctuation, "$1")
+      }, e[0], this.lexer);
+    }
+  }
+  reflink(n, e) {
+    let t;
+    if ((t = this.rules.inline.reflink.exec(n)) || (t = this.rules.inline.nolink.exec(n))) {
+      const s = (t[2] || t[1]).replace(/\s+/g, " "), i = e[s.toLowerCase()];
+      if (!i) {
+        const r = t[0].charAt(0);
+        return {
+          type: "text",
+          raw: r,
+          text: r
+        };
+      }
+      return Ie(t, i, t[0], this.lexer);
+    }
+  }
+  emStrong(n, e, t = "") {
+    let s = this.rules.inline.emStrongLDelim.exec(n);
+    if (!s || s[3] && t.match(/[\p{L}\p{N}]/u))
+      return;
+    if (!(s[1] || s[2] || "") || !t || this.rules.inline.punctuation.exec(t)) {
+      const r = [...s[0]].length - 1;
+      let a, c, m = r, f = 0;
+      const b = s[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+      for (b.lastIndex = 0, e = e.slice(-1 * n.length + r); (s = b.exec(e)) != null; ) {
+        if (a = s[1] || s[2] || s[3] || s[4] || s[5] || s[6], !a)
+          continue;
+        if (c = [...a].length, s[3] || s[4]) {
+          m += c;
+          continue;
+        } else if ((s[5] || s[6]) && r % 3 && !((r + c) % 3)) {
+          f += c;
+          continue;
+        }
+        if (m -= c, m > 0)
+          continue;
+        c = Math.min(c, c + m + f);
+        const d = [...s[0]][0].length, v = n.slice(0, r + s.index + d + c);
+        if (Math.min(r, c) % 2) {
+          const $ = v.slice(1, -1);
+          return {
+            type: "em",
+            raw: v,
+            text: $,
+            tokens: this.lexer.inlineTokens($)
+          };
+        }
+        const E = v.slice(2, -2);
+        return {
+          type: "strong",
+          raw: v,
+          text: E,
+          tokens: this.lexer.inlineTokens(E)
+        };
+      }
+    }
+  }
+  codespan(n) {
+    const e = this.rules.inline.code.exec(n);
+    if (e) {
+      let t = e[2].replace(/\n/g, " ");
+      const s = /[^ ]/.test(t), i = /^ /.test(t) && / $/.test(t);
+      return s && i && (t = t.substring(1, t.length - 1)), t = R(t, !0), {
+        type: "codespan",
+        raw: e[0],
+        text: t
+      };
+    }
+  }
+  br(n) {
+    const e = this.rules.inline.br.exec(n);
+    if (e)
+      return {
+        type: "br",
+        raw: e[0]
+      };
+  }
+  del(n) {
+    const e = this.rules.inline.del.exec(n);
+    if (e)
+      return {
+        type: "del",
+        raw: e[0],
+        text: e[2],
+        tokens: this.lexer.inlineTokens(e[2])
+      };
+  }
+  autolink(n) {
+    const e = this.rules.inline.autolink.exec(n);
+    if (e) {
+      let t, s;
+      return e[2] === "@" ? (t = R(e[1]), s = "mailto:" + t) : (t = R(e[1]), s = t), {
+        type: "link",
+        raw: e[0],
+        text: t,
+        href: s,
+        tokens: [
+          {
+            type: "text",
+            raw: t,
+            text: t
+          }
+        ]
+      };
+    }
+  }
+  url(n) {
+    let e;
+    if (e = this.rules.inline.url.exec(n)) {
+      let t, s;
+      if (e[2] === "@")
+        t = R(e[0]), s = "mailto:" + t;
+      else {
+        let i;
+        do
+          i = e[0], e[0] = this.rules.inline._backpedal.exec(e[0])?.[0] ?? "";
+        while (i !== e[0]);
+        t = R(e[0]), e[1] === "www." ? s = "http://" + e[0] : s = e[0];
+      }
+      return {
+        type: "link",
+        raw: e[0],
+        text: t,
+        href: s,
+        tokens: [
+          {
+            type: "text",
+            raw: t,
+            text: t
+          }
+        ]
+      };
+    }
+  }
+  inlineText(n) {
+    const e = this.rules.inline.text.exec(n);
+    if (e) {
+      let t;
+      return this.lexer.state.inRawBlock ? t = e[0] : t = R(e[0]), {
+        type: "text",
+        raw: e[0],
+        text: t
+      };
+    }
+  }
+}
+const kt = /^(?: *(?:\n|$))+/, xt = /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/, mt = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/, N = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/, bt = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/, De = /(?:[*+-]|\d{1,9}[.)])/, je = T(/^(?!bull )((?:.|\n(?!\s*?\n|bull ))+?)\n {0,3}(=+|-+) *(?:\n+|$)/).replace(/bull/g, De).getRegex(), me = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/, wt = /^[^\n]+/, be = /(?!\s*\])(?:\\.|[^\[\]\\])+/, yt = T(/^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/).replace("label", be).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(), vt = T(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, De).getRegex(), le = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul", we = /<!--(?!-?>)[\s\S]*?(?:-->|$)/, $t = T("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n *)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$))", "i").replace("comment", we).replace("tag", le).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(), He = T(me).replace("hr", N).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", le).getRegex(), At = T(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", He).getRegex(), ye = {
+  blockquote: At,
+  code: xt,
+  def: yt,
+  fences: mt,
+  heading: bt,
+  hr: N,
+  html: $t,
+  lheading: je,
+  list: vt,
+  newline: kt,
+  paragraph: He,
+  table: W,
+  text: wt
+}, Le = T("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", N).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", " {4}[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", le).getRegex(), Tt = {
+  ...ye,
+  table: Le,
+  paragraph: T(me).replace("hr", N).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", Le).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", le).getRegex()
+}, St = {
+  ...ye,
+  html: T(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", we).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),
+  def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
+  heading: /^(#{1,6})(.*)(?:\n+|$)/,
+  fences: W,
+  // fences not supported
+  lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
+  paragraph: T(me).replace("hr", N).replace("heading", ` *#{1,6} *[^
+]`).replace("lheading", je).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex()
+}, Ue = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/, Ft = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/, Qe = /^( {2,}|\\)\n(?!\s*$)/, _t = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/, X = "\\p{P}$+<=>`^|~", zt = T(/^((?![*_])[\spunctuation])/, "u").replace(/punctuation/g, X).getRegex(), Et = /\[[^[\]]*?\]\([^\(\)]*?\)|`[^`]*?`|<[^<>]*?>/g, Rt = T(/^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/, "u").replace(/punct/g, X).getRegex(), Ct = T("^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)[punct](\\*+)(?=[\\s]|$)|[^punct\\s](\\*+)(?!\\*)(?=[punct\\s]|$)|(?!\\*)[punct\\s](\\*+)(?=[^punct\\s])|[\\s](\\*+)(?!\\*)(?=[punct])|(?!\\*)[punct](\\*+)(?!\\*)(?=[punct])|[^punct\\s](\\*+)(?=[^punct\\s])", "gu").replace(/punct/g, X).getRegex(), It = T("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)[punct](_+)(?=[\\s]|$)|[^punct\\s](_+)(?!_)(?=[punct\\s]|$)|(?!_)[punct\\s](_+)(?=[^punct\\s])|[\\s](_+)(?!_)(?=[punct])|(?!_)[punct](_+)(?!_)(?=[punct])", "gu").replace(/punct/g, X).getRegex(), Lt = T(/\\([punct])/, "gu").replace(/punct/g, X).getRegex(), Pt = T(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex(), Mt = T(we).replace("(?:-->|$)", "-->").getRegex(), qt = T("^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", Mt).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(), ie = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/, Ot = T(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/).replace("label", ie).replace("href", /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(), We = T(/^!?\[(label)\]\[(ref)\]/).replace("label", ie).replace("ref", be).getRegex(), Ge = T(/^!?\[(ref)\](?:\[\])?/).replace("ref", be).getRegex(), Zt = T("reflink|nolink(?!\\()", "g").replace("reflink", We).replace("nolink", Ge).getRegex(), ve = {
+  _backpedal: W,
+  // only used for GFM url
+  anyPunctuation: Lt,
+  autolink: Pt,
+  blockSkip: Et,
+  br: Qe,
+  code: Ft,
+  del: W,
+  emStrongLDelim: Rt,
+  emStrongRDelimAst: Ct,
+  emStrongRDelimUnd: It,
+  escape: Ue,
+  link: Ot,
+  nolink: Ge,
+  punctuation: zt,
+  reflink: We,
+  reflinkSearch: Zt,
+  tag: qt,
+  text: _t,
+  url: W
+}, Bt = {
+  ...ve,
+  link: T(/^!?\[(label)\]\((.*?)\)/).replace("label", ie).getRegex(),
+  reflink: T(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", ie).getRegex()
+}, fe = {
+  ...ve,
+  escape: T(Ue).replace("])", "~|])").getRegex(),
+  url: T(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, "i").replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),
+  _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,
+  del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
+  text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
+}, Dt = {
+  ...fe,
+  br: T(Qe).replace("{2,}", "*").getRegex(),
+  text: T(fe.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex()
+}, te = {
+  normal: ye,
+  gfm: Tt,
+  pedantic: St
+}, Q = {
+  normal: ve,
+  gfm: fe,
+  breaks: Dt,
+  pedantic: Bt
+};
+class L {
+  tokens;
+  options;
+  state;
+  tokenizer;
+  inlineQueue;
+  constructor(n) {
+    this.tokens = [], this.tokens.links = /* @__PURE__ */ Object.create(null), this.options = n || D, this.options.tokenizer = this.options.tokenizer || new se(), this.tokenizer = this.options.tokenizer, this.tokenizer.options = this.options, this.tokenizer.lexer = this, this.inlineQueue = [], this.state = {
+      inLink: !1,
+      inRawBlock: !1,
+      top: !0
+    };
+    const e = {
+      block: te.normal,
+      inline: Q.normal
+    };
+    this.options.pedantic ? (e.block = te.pedantic, e.inline = Q.pedantic) : this.options.gfm && (e.block = te.gfm, this.options.breaks ? e.inline = Q.breaks : e.inline = Q.gfm), this.tokenizer.rules = e;
+  }
+  /**
+   * Expose Rules
+   */
+  static get rules() {
+    return {
+      block: te,
+      inline: Q
+    };
+  }
+  /**
+   * Static Lex Method
+   */
+  static lex(n, e) {
+    return new L(e).lex(n);
+  }
+  /**
+   * Static Lex Inline Method
+   */
+  static lexInline(n, e) {
+    return new L(e).inlineTokens(n);
+  }
+  /**
+   * Preprocessing
+   */
+  lex(n) {
+    n = n.replace(/\r\n|\r/g, `
+`), this.blockTokens(n, this.tokens);
+    for (let e = 0; e < this.inlineQueue.length; e++) {
+      const t = this.inlineQueue[e];
+      this.inlineTokens(t.src, t.tokens);
+    }
+    return this.inlineQueue = [], this.tokens;
+  }
+  blockTokens(n, e = []) {
+    this.options.pedantic ? n = n.replace(/\t/g, "    ").replace(/^ +$/gm, "") : n = n.replace(/^( *)(\t+)/gm, (a, c, m) => c + "    ".repeat(m.length));
+    let t, s, i, r;
+    for (; n; )
+      if (!(this.options.extensions && this.options.extensions.block && this.options.extensions.block.some((a) => (t = a.call({ lexer: this }, n, e)) ? (n = n.substring(t.raw.length), e.push(t), !0) : !1))) {
+        if (t = this.tokenizer.space(n)) {
+          n = n.substring(t.raw.length), t.raw.length === 1 && e.length > 0 ? e[e.length - 1].raw += `
+` : e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.code(n)) {
+          n = n.substring(t.raw.length), s = e[e.length - 1], s && (s.type === "paragraph" || s.type === "text") ? (s.raw += `
+` + t.raw, s.text += `
+` + t.text, this.inlineQueue[this.inlineQueue.length - 1].src = s.text) : e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.fences(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.heading(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.hr(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.blockquote(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.list(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.html(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.def(n)) {
+          n = n.substring(t.raw.length), s = e[e.length - 1], s && (s.type === "paragraph" || s.type === "text") ? (s.raw += `
+` + t.raw, s.text += `
+` + t.raw, this.inlineQueue[this.inlineQueue.length - 1].src = s.text) : this.tokens.links[t.tag] || (this.tokens.links[t.tag] = {
+            href: t.href,
+            title: t.title
+          });
+          continue;
+        }
+        if (t = this.tokenizer.table(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.lheading(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (i = n, this.options.extensions && this.options.extensions.startBlock) {
+          let a = 1 / 0;
+          const c = n.slice(1);
+          let m;
+          this.options.extensions.startBlock.forEach((f) => {
+            m = f.call({ lexer: this }, c), typeof m == "number" && m >= 0 && (a = Math.min(a, m));
+          }), a < 1 / 0 && a >= 0 && (i = n.substring(0, a + 1));
+        }
+        if (this.state.top && (t = this.tokenizer.paragraph(i))) {
+          s = e[e.length - 1], r && s.type === "paragraph" ? (s.raw += `
+` + t.raw, s.text += `
+` + t.text, this.inlineQueue.pop(), this.inlineQueue[this.inlineQueue.length - 1].src = s.text) : e.push(t), r = i.length !== n.length, n = n.substring(t.raw.length);
+          continue;
+        }
+        if (t = this.tokenizer.text(n)) {
+          n = n.substring(t.raw.length), s = e[e.length - 1], s && s.type === "text" ? (s.raw += `
+` + t.raw, s.text += `
+` + t.text, this.inlineQueue.pop(), this.inlineQueue[this.inlineQueue.length - 1].src = s.text) : e.push(t);
+          continue;
+        }
+        if (n) {
+          const a = "Infinite loop on byte: " + n.charCodeAt(0);
+          if (this.options.silent) {
+            console.error(a);
+            break;
+          } else
+            throw new Error(a);
+        }
+      }
+    return this.state.top = !0, e;
+  }
+  inline(n, e = []) {
+    return this.inlineQueue.push({ src: n, tokens: e }), e;
+  }
+  /**
+   * Lexing/Compiling
+   */
+  inlineTokens(n, e = []) {
+    let t, s, i, r = n, a, c, m;
+    if (this.tokens.links) {
+      const f = Object.keys(this.tokens.links);
+      if (f.length > 0)
+        for (; (a = this.tokenizer.rules.inline.reflinkSearch.exec(r)) != null; )
+          f.includes(a[0].slice(a[0].lastIndexOf("[") + 1, -1)) && (r = r.slice(0, a.index) + "[" + "a".repeat(a[0].length - 2) + "]" + r.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex));
+    }
+    for (; (a = this.tokenizer.rules.inline.blockSkip.exec(r)) != null; )
+      r = r.slice(0, a.index) + "[" + "a".repeat(a[0].length - 2) + "]" + r.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+    for (; (a = this.tokenizer.rules.inline.anyPunctuation.exec(r)) != null; )
+      r = r.slice(0, a.index) + "++" + r.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
+    for (; n; )
+      if (c || (m = ""), c = !1, !(this.options.extensions && this.options.extensions.inline && this.options.extensions.inline.some((f) => (t = f.call({ lexer: this }, n, e)) ? (n = n.substring(t.raw.length), e.push(t), !0) : !1))) {
+        if (t = this.tokenizer.escape(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.tag(n)) {
+          n = n.substring(t.raw.length), s = e[e.length - 1], s && t.type === "text" && s.type === "text" ? (s.raw += t.raw, s.text += t.text) : e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.link(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.reflink(n, this.tokens.links)) {
+          n = n.substring(t.raw.length), s = e[e.length - 1], s && t.type === "text" && s.type === "text" ? (s.raw += t.raw, s.text += t.text) : e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.emStrong(n, r, m)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.codespan(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.br(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.del(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (t = this.tokenizer.autolink(n)) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (!this.state.inLink && (t = this.tokenizer.url(n))) {
+          n = n.substring(t.raw.length), e.push(t);
+          continue;
+        }
+        if (i = n, this.options.extensions && this.options.extensions.startInline) {
+          let f = 1 / 0;
+          const b = n.slice(1);
+          let d;
+          this.options.extensions.startInline.forEach((v) => {
+            d = v.call({ lexer: this }, b), typeof d == "number" && d >= 0 && (f = Math.min(f, d));
+          }), f < 1 / 0 && f >= 0 && (i = n.substring(0, f + 1));
+        }
+        if (t = this.tokenizer.inlineText(i)) {
+          n = n.substring(t.raw.length), t.raw.slice(-1) !== "_" && (m = t.raw.slice(-1)), c = !0, s = e[e.length - 1], s && s.type === "text" ? (s.raw += t.raw, s.text += t.text) : e.push(t);
+          continue;
+        }
+        if (n) {
+          const f = "Infinite loop on byte: " + n.charCodeAt(0);
+          if (this.options.silent) {
+            console.error(f);
+            break;
+          } else
+            throw new Error(f);
+        }
+      }
+    return e;
+  }
+}
+class ae {
+  options;
+  constructor(n) {
+    this.options = n || D;
+  }
+  code(n, e, t) {
+    const s = (e || "").match(/^\S*/)?.[0];
+    return n = n.replace(/\n$/, "") + `
+`, s ? '<pre><code class="language-' + R(s) + '">' + (t ? n : R(n, !0)) + `</code></pre>
+` : "<pre><code>" + (t ? n : R(n, !0)) + `</code></pre>
+`;
+  }
+  blockquote(n) {
+    return `<blockquote>
+${n}</blockquote>
+`;
+  }
+  html(n, e) {
+    return n;
+  }
+  heading(n, e, t) {
+    return `<h${e}>${n}</h${e}>
+`;
+  }
+  hr() {
+    return `<hr>
+`;
+  }
+  list(n, e, t) {
+    const s = e ? "ol" : "ul", i = e && t !== 1 ? ' start="' + t + '"' : "";
+    return "<" + s + i + `>
+` + n + "</" + s + `>
+`;
+  }
+  listitem(n, e, t) {
+    return `<li>${n}</li>
+`;
+  }
+  checkbox(n) {
+    return "<input " + (n ? 'checked="" ' : "") + 'disabled="" type="checkbox">';
+  }
+  paragraph(n) {
+    return `<p>${n}</p>
+`;
+  }
+  table(n, e) {
+    return e && (e = `<tbody>${e}</tbody>`), `<table>
+<thead>
+` + n + `</thead>
+` + e + `</table>
+`;
+  }
+  tablerow(n) {
+    return `<tr>
+${n}</tr>
+`;
+  }
+  tablecell(n, e) {
+    const t = e.header ? "th" : "td";
+    return (e.align ? `<${t} align="${e.align}">` : `<${t}>`) + n + `</${t}>
+`;
+  }
+  /**
+   * span level renderer
+   */
+  strong(n) {
+    return `<strong>${n}</strong>`;
+  }
+  em(n) {
+    return `<em>${n}</em>`;
+  }
+  codespan(n) {
+    return `<code>${n}</code>`;
+  }
+  br() {
+    return "<br>";
+  }
+  del(n) {
+    return `<del>${n}</del>`;
+  }
+  link(n, e, t) {
+    const s = Re(n);
+    if (s === null)
+      return t;
+    n = s;
+    let i = '<a href="' + n + '"';
+    return e && (i += ' title="' + e + '"'), i += ">" + t + "</a>", i;
+  }
+  image(n, e, t) {
+    const s = Re(n);
+    if (s === null)
+      return t;
+    n = s;
+    let i = `<img src="${n}" alt="${t}"`;
+    return e && (i += ` title="${e}"`), i += ">", i;
+  }
+  text(n) {
+    return n;
+  }
+}
+class $e {
+  // no need for block level renderers
+  strong(n) {
+    return n;
+  }
+  em(n) {
+    return n;
+  }
+  codespan(n) {
+    return n;
+  }
+  del(n) {
+    return n;
+  }
+  html(n) {
+    return n;
+  }
+  text(n) {
+    return n;
+  }
+  link(n, e, t) {
+    return "" + t;
+  }
+  image(n, e, t) {
+    return "" + t;
+  }
+  br() {
+    return "";
+  }
+}
+class P {
+  options;
+  renderer;
+  textRenderer;
+  constructor(n) {
+    this.options = n || D, this.options.renderer = this.options.renderer || new ae(), this.renderer = this.options.renderer, this.renderer.options = this.options, this.textRenderer = new $e();
+  }
+  /**
+   * Static Parse Method
+   */
+  static parse(n, e) {
+    return new P(e).parse(n);
+  }
+  /**
+   * Static Parse Inline Method
+   */
+  static parseInline(n, e) {
+    return new P(e).parseInline(n);
+  }
+  /**
+   * Parse Loop
+   */
+  parse(n, e = !0) {
+    let t = "";
+    for (let s = 0; s < n.length; s++) {
+      const i = n[s];
+      if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[i.type]) {
+        const r = i, a = this.options.extensions.renderers[r.type].call({ parser: this }, r);
+        if (a !== !1 || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(r.type)) {
+          t += a || "";
+          continue;
+        }
+      }
+      switch (i.type) {
+        case "space":
+          continue;
+        case "hr": {
+          t += this.renderer.hr();
+          continue;
+        }
+        case "heading": {
+          const r = i;
+          t += this.renderer.heading(this.parseInline(r.tokens), r.depth, ht(this.parseInline(r.tokens, this.textRenderer)));
+          continue;
+        }
+        case "code": {
+          const r = i;
+          t += this.renderer.code(r.text, r.lang, !!r.escaped);
+          continue;
+        }
+        case "table": {
+          const r = i;
+          let a = "", c = "";
+          for (let f = 0; f < r.header.length; f++)
+            c += this.renderer.tablecell(this.parseInline(r.header[f].tokens), { header: !0, align: r.align[f] });
+          a += this.renderer.tablerow(c);
+          let m = "";
+          for (let f = 0; f < r.rows.length; f++) {
+            const b = r.rows[f];
+            c = "";
+            for (let d = 0; d < b.length; d++)
+              c += this.renderer.tablecell(this.parseInline(b[d].tokens), { header: !1, align: r.align[d] });
+            m += this.renderer.tablerow(c);
+          }
+          t += this.renderer.table(a, m);
+          continue;
+        }
+        case "blockquote": {
+          const r = i, a = this.parse(r.tokens);
+          t += this.renderer.blockquote(a);
+          continue;
+        }
+        case "list": {
+          const r = i, a = r.ordered, c = r.start, m = r.loose;
+          let f = "";
+          for (let b = 0; b < r.items.length; b++) {
+            const d = r.items[b], v = d.checked, E = d.task;
+            let $ = "";
+            if (d.task) {
+              const w = this.renderer.checkbox(!!v);
+              m ? d.tokens.length > 0 && d.tokens[0].type === "paragraph" ? (d.tokens[0].text = w + " " + d.tokens[0].text, d.tokens[0].tokens && d.tokens[0].tokens.length > 0 && d.tokens[0].tokens[0].type === "text" && (d.tokens[0].tokens[0].text = w + " " + d.tokens[0].tokens[0].text)) : d.tokens.unshift({
+                type: "text",
+                text: w + " "
+              }) : $ += w + " ";
+            }
+            $ += this.parse(d.tokens, m), f += this.renderer.listitem($, E, !!v);
+          }
+          t += this.renderer.list(f, a, c);
+          continue;
+        }
+        case "html": {
+          const r = i;
+          t += this.renderer.html(r.text, r.block);
+          continue;
+        }
+        case "paragraph": {
+          const r = i;
+          t += this.renderer.paragraph(this.parseInline(r.tokens));
+          continue;
+        }
+        case "text": {
+          let r = i, a = r.tokens ? this.parseInline(r.tokens) : r.text;
+          for (; s + 1 < n.length && n[s + 1].type === "text"; )
+            r = n[++s], a += `
+` + (r.tokens ? this.parseInline(r.tokens) : r.text);
+          t += e ? this.renderer.paragraph(a) : a;
+          continue;
+        }
+        default: {
+          const r = 'Token with "' + i.type + '" type was not found.';
+          if (this.options.silent)
+            return console.error(r), "";
+          throw new Error(r);
+        }
+      }
+    }
+    return t;
+  }
+  /**
+   * Parse Inline Tokens
+   */
+  parseInline(n, e) {
+    e = e || this.renderer;
+    let t = "";
+    for (let s = 0; s < n.length; s++) {
+      const i = n[s];
+      if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[i.type]) {
+        const r = this.options.extensions.renderers[i.type].call({ parser: this }, i);
+        if (r !== !1 || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(i.type)) {
+          t += r || "";
+          continue;
+        }
+      }
+      switch (i.type) {
+        case "escape": {
+          const r = i;
+          t += e.text(r.text);
+          break;
+        }
+        case "html": {
+          const r = i;
+          t += e.html(r.text);
+          break;
+        }
+        case "link": {
+          const r = i;
+          t += e.link(r.href, r.title, this.parseInline(r.tokens, e));
+          break;
+        }
+        case "image": {
+          const r = i;
+          t += e.image(r.href, r.title, r.text);
+          break;
+        }
+        case "strong": {
+          const r = i;
+          t += e.strong(this.parseInline(r.tokens, e));
+          break;
+        }
+        case "em": {
+          const r = i;
+          t += e.em(this.parseInline(r.tokens, e));
+          break;
+        }
+        case "codespan": {
+          const r = i;
+          t += e.codespan(r.text);
+          break;
+        }
+        case "br": {
+          t += e.br();
+          break;
+        }
+        case "del": {
+          const r = i;
+          t += e.del(this.parseInline(r.tokens, e));
+          break;
+        }
+        case "text": {
+          const r = i;
+          t += e.text(r.text);
+          break;
+        }
+        default: {
+          const r = 'Token with "' + i.type + '" type was not found.';
+          if (this.options.silent)
+            return console.error(r), "";
+          throw new Error(r);
+        }
+      }
+    }
+    return t;
+  }
+}
+class ne {
+  options;
+  constructor(n) {
+    this.options = n || D;
+  }
+  static passThroughHooks = /* @__PURE__ */ new Set([
+    "preprocess",
+    "postprocess",
+    "processAllTokens"
+  ]);
+  /**
+   * Process markdown before marked
+   */
+  preprocess(n) {
+    return n;
+  }
+  /**
+   * Process HTML after marked is finished
+   */
+  postprocess(n) {
+    return n;
+  }
+  /**
+   * Process all tokens before walk tokens
+   */
+  processAllTokens(n) {
+    return n;
+  }
+}
+class Ne {
+  defaults = xe();
+  options = this.setOptions;
+  parse = this.#e(L.lex, P.parse);
+  parseInline = this.#e(L.lexInline, P.parseInline);
+  Parser = P;
+  Renderer = ae;
+  TextRenderer = $e;
+  Lexer = L;
+  Tokenizer = se;
+  Hooks = ne;
+  constructor(...n) {
+    this.use(...n);
+  }
+  /**
+   * Run callback for every token
+   */
+  walkTokens(n, e) {
+    let t = [];
+    for (const s of n)
+      switch (t = t.concat(e.call(this, s)), s.type) {
+        case "table": {
+          const i = s;
+          for (const r of i.header)
+            t = t.concat(this.walkTokens(r.tokens, e));
+          for (const r of i.rows)
+            for (const a of r)
+              t = t.concat(this.walkTokens(a.tokens, e));
+          break;
+        }
+        case "list": {
+          const i = s;
+          t = t.concat(this.walkTokens(i.items, e));
+          break;
+        }
+        default: {
+          const i = s;
+          this.defaults.extensions?.childTokens?.[i.type] ? this.defaults.extensions.childTokens[i.type].forEach((r) => {
+            const a = i[r].flat(1 / 0);
+            t = t.concat(this.walkTokens(a, e));
+          }) : i.tokens && (t = t.concat(this.walkTokens(i.tokens, e)));
+        }
+      }
+    return t;
+  }
+  use(...n) {
+    const e = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    return n.forEach((t) => {
+      const s = { ...t };
+      if (s.async = this.defaults.async || s.async || !1, t.extensions && (t.extensions.forEach((i) => {
+        if (!i.name)
+          throw new Error("extension name required");
+        if ("renderer" in i) {
+          const r = e.renderers[i.name];
+          r ? e.renderers[i.name] = function(...a) {
+            let c = i.renderer.apply(this, a);
+            return c === !1 && (c = r.apply(this, a)), c;
+          } : e.renderers[i.name] = i.renderer;
+        }
+        if ("tokenizer" in i) {
+          if (!i.level || i.level !== "block" && i.level !== "inline")
+            throw new Error("extension level must be 'block' or 'inline'");
+          const r = e[i.level];
+          r ? r.unshift(i.tokenizer) : e[i.level] = [i.tokenizer], i.start && (i.level === "block" ? e.startBlock ? e.startBlock.push(i.start) : e.startBlock = [i.start] : i.level === "inline" && (e.startInline ? e.startInline.push(i.start) : e.startInline = [i.start]));
+        }
+        "childTokens" in i && i.childTokens && (e.childTokens[i.name] = i.childTokens);
+      }), s.extensions = e), t.renderer) {
+        const i = this.defaults.renderer || new ae(this.defaults);
+        for (const r in t.renderer) {
+          if (!(r in i))
+            throw new Error(`renderer '${r}' does not exist`);
+          if (r === "options")
+            continue;
+          const a = r, c = t.renderer[a], m = i[a];
+          i[a] = (...f) => {
+            let b = c.apply(i, f);
+            return b === !1 && (b = m.apply(i, f)), b || "";
+          };
+        }
+        s.renderer = i;
+      }
+      if (t.tokenizer) {
+        const i = this.defaults.tokenizer || new se(this.defaults);
+        for (const r in t.tokenizer) {
+          if (!(r in i))
+            throw new Error(`tokenizer '${r}' does not exist`);
+          if (["options", "rules", "lexer"].includes(r))
+            continue;
+          const a = r, c = t.tokenizer[a], m = i[a];
+          i[a] = (...f) => {
+            let b = c.apply(i, f);
+            return b === !1 && (b = m.apply(i, f)), b;
+          };
+        }
+        s.tokenizer = i;
+      }
+      if (t.hooks) {
+        const i = this.defaults.hooks || new ne();
+        for (const r in t.hooks) {
+          if (!(r in i))
+            throw new Error(`hook '${r}' does not exist`);
+          if (r === "options")
+            continue;
+          const a = r, c = t.hooks[a], m = i[a];
+          ne.passThroughHooks.has(r) ? i[a] = (f) => {
+            if (this.defaults.async)
+              return Promise.resolve(c.call(i, f)).then((d) => m.call(i, d));
+            const b = c.call(i, f);
+            return m.call(i, b);
+          } : i[a] = (...f) => {
+            let b = c.apply(i, f);
+            return b === !1 && (b = m.apply(i, f)), b;
+          };
+        }
+        s.hooks = i;
+      }
+      if (t.walkTokens) {
+        const i = this.defaults.walkTokens, r = t.walkTokens;
+        s.walkTokens = function(a) {
+          let c = [];
+          return c.push(r.call(this, a)), i && (c = c.concat(i.call(this, a))), c;
+        };
+      }
+      this.defaults = { ...this.defaults, ...s };
+    }), this;
+  }
+  setOptions(n) {
+    return this.defaults = { ...this.defaults, ...n }, this;
+  }
+  lexer(n, e) {
+    return L.lex(n, e ?? this.defaults);
+  }
+  parser(n, e) {
+    return P.parse(n, e ?? this.defaults);
+  }
+  #e(n, e) {
+    return (t, s) => {
+      const i = { ...s }, r = { ...this.defaults, ...i };
+      this.defaults.async === !0 && i.async === !1 && (r.silent || console.warn("marked(): The async option was set to true by an extension. The async: false option sent to parse will be ignored."), r.async = !0);
+      const a = this.#t(!!r.silent, !!r.async);
+      if (typeof t > "u" || t === null)
+        return a(new Error("marked(): input parameter is undefined or null"));
+      if (typeof t != "string")
+        return a(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(t) + ", string expected"));
+      if (r.hooks && (r.hooks.options = r), r.async)
+        return Promise.resolve(r.hooks ? r.hooks.preprocess(t) : t).then((c) => n(c, r)).then((c) => r.hooks ? r.hooks.processAllTokens(c) : c).then((c) => r.walkTokens ? Promise.all(this.walkTokens(c, r.walkTokens)).then(() => c) : c).then((c) => e(c, r)).then((c) => r.hooks ? r.hooks.postprocess(c) : c).catch(a);
+      try {
+        r.hooks && (t = r.hooks.preprocess(t));
+        let c = n(t, r);
+        r.hooks && (c = r.hooks.processAllTokens(c)), r.walkTokens && this.walkTokens(c, r.walkTokens);
+        let m = e(c, r);
+        return r.hooks && (m = r.hooks.postprocess(m)), m;
+      } catch (c) {
+        return a(c);
+      }
+    };
+  }
+  #t(n, e) {
+    return (t) => {
+      if (t.message += `
+Please report this to https://github.com/markedjs/marked.`, n) {
+        const s = "<p>An error occurred:</p><pre>" + R(t.message + "", !0) + "</pre>";
+        return e ? Promise.resolve(s) : s;
+      }
+      if (e)
+        return Promise.reject(t);
+      throw t;
+    };
+  }
+}
+const B = new Ne();
+function A(u, n) {
+  return B.parse(u, n);
+}
+A.options = A.setOptions = function(u) {
+  return B.setOptions(u), A.defaults = B.defaults, Oe(A.defaults), A;
+};
+A.getDefaults = xe;
+A.defaults = D;
+A.use = function(...u) {
+  return B.use(...u), A.defaults = B.defaults, Oe(A.defaults), A;
+};
+A.walkTokens = function(u, n) {
+  return B.walkTokens(u, n);
+};
+A.parseInline = B.parseInline;
+A.Parser = P;
+A.parser = P.parse;
+A.Renderer = ae;
+A.TextRenderer = $e;
+A.Lexer = L;
+A.lexer = L.lex;
+A.Tokenizer = se;
+A.Hooks = ne;
+A.parse = A;
+A.options;
+A.setOptions;
+A.use;
+A.walkTokens;
+A.parseInline;
+P.parse;
+L.lex;
+var pe = { exports: {} }, Pe;
+function jt() {
+  return Pe || (Pe = 1, function(u) {
+    var n = typeof window < "u" ? window : typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? self : {};
+    /**
+     * Prism: Lightweight, robust, elegant syntax highlighting
+     *
+     * @license MIT <https://opensource.org/licenses/MIT>
+     * @author Lea Verou <https://lea.verou.me>
+     * @namespace
+     * @public
+     */
+    var e = function(t) {
+      var s = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, i = 0, r = {}, a = {
+        /**
+         * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the
+         * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load
+         * additional languages or plugins yourself.
+         *
+         * By setting this value to `true`, Prism will not automatically highlight all code elements on the page.
+         *
+         * You obviously have to change this value before the automatic highlighting started. To do this, you can add an
+         * empty Prism object into the global scope before loading the Prism script like this:
+         *
+         * ```js
+         * window.Prism = window.Prism || {};
+         * Prism.manual = true;
+         * // add a new <script> to load Prism's script
+         * ```
+         *
+         * @default false
+         * @type {boolean}
+         * @memberof Prism
+         * @public
+         */
+        manual: t.Prism && t.Prism.manual,
+        /**
+         * By default, if Prism is in a web worker, it assumes that it is in a worker it created itself, so it uses
+         * `addEventListener` to communicate with its parent instance. However, if you're using Prism manually in your
+         * own worker, you don't want it to do this.
+         *
+         * By setting this value to `true`, Prism will not add its own listeners to the worker.
+         *
+         * You obviously have to change this value before Prism executes. To do this, you can add an
+         * empty Prism object into the global scope before loading the Prism script like this:
+         *
+         * ```js
+         * window.Prism = window.Prism || {};
+         * Prism.disableWorkerMessageHandler = true;
+         * // Load Prism's script
+         * ```
+         *
+         * @default false
+         * @type {boolean}
+         * @memberof Prism
+         * @public
+         */
+        disableWorkerMessageHandler: t.Prism && t.Prism.disableWorkerMessageHandler,
+        /**
+         * A namespace for utility methods.
+         *
+         * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
+         * change or disappear at any time.
+         *
+         * @namespace
+         * @memberof Prism
+         */
+        util: {
+          encode: function o(l) {
+            return l instanceof c ? new c(l.type, o(l.content), l.alias) : Array.isArray(l) ? l.map(o) : l.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\u00a0/g, " ");
+          },
+          /**
+           * Returns the name of the type of the given value.
+           *
+           * @param {any} o
+           * @returns {string}
+           * @example
+           * type(null)      === 'Null'
+           * type(undefined) === 'Undefined'
+           * type(123)       === 'Number'
+           * type('foo')     === 'String'
+           * type(true)      === 'Boolean'
+           * type([1, 2])    === 'Array'
+           * type({})        === 'Object'
+           * type(String)    === 'Function'
+           * type(/abc+/)    === 'RegExp'
+           */
+          type: function(o) {
+            return Object.prototype.toString.call(o).slice(8, -1);
+          },
+          /**
+           * Returns a unique number for the given object. Later calls will still return the same number.
+           *
+           * @param {Object} obj
+           * @returns {number}
+           */
+          objId: function(o) {
+            return o.__id || Object.defineProperty(o, "__id", { value: ++i }), o.__id;
+          },
+          /**
+           * Creates a deep clone of the given object.
+           *
+           * The main intended use of this function is to clone language definitions.
+           *
+           * @param {T} o
+           * @param {Record<number, any>} [visited]
+           * @returns {T}
+           * @template T
+           */
+          clone: function o(l, p) {
+            p = p || {};
+            var h, g;
+            switch (a.util.type(l)) {
+              case "Object":
+                if (g = a.util.objId(l), p[g])
+                  return p[g];
+                h = /** @type {Record<string, any>} */
+                {}, p[g] = h;
+                for (var x in l)
+                  l.hasOwnProperty(x) && (h[x] = o(l[x], p));
+                return (
+                  /** @type {any} */
+                  h
+                );
+              case "Array":
+                return g = a.util.objId(l), p[g] ? p[g] : (h = [], p[g] = h, /** @type {Array} */
+                /** @type {any} */
+                l.forEach(function(y, k) {
+                  h[k] = o(y, p);
+                }), /** @type {any} */
+                h);
+              default:
+                return l;
+            }
+          },
+          /**
+           * Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.
+           *
+           * If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.
+           *
+           * @param {Element} element
+           * @returns {string}
+           */
+          getLanguage: function(o) {
+            for (; o; ) {
+              var l = s.exec(o.className);
+              if (l)
+                return l[1].toLowerCase();
+              o = o.parentElement;
+            }
+            return "none";
+          },
+          /**
+           * Sets the Prism `language-xxxx` class of the given element.
+           *
+           * @param {Element} element
+           * @param {string} language
+           * @returns {void}
+           */
+          setLanguage: function(o, l) {
+            o.className = o.className.replace(RegExp(s, "gi"), ""), o.classList.add("language-" + l);
+          },
+          /**
+           * Returns the script element that is currently executing.
+           *
+           * This does __not__ work for line script element.
+           *
+           * @returns {HTMLScriptElement | null}
+           */
+          currentScript: function() {
+            if (typeof document > "u")
+              return null;
+            if (document.currentScript && document.currentScript.tagName === "SCRIPT")
+              return (
+                /** @type {any} */
+                document.currentScript
+              );
+            try {
+              throw new Error();
+            } catch (h) {
+              var o = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(h.stack) || [])[1];
+              if (o) {
+                var l = document.getElementsByTagName("script");
+                for (var p in l)
+                  if (l[p].src == o)
+                    return l[p];
+              }
+              return null;
+            }
+          },
+          /**
+           * Returns whether a given class is active for `element`.
+           *
+           * The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated
+           * if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the
+           * given class is just the given class with a `no-` prefix.
+           *
+           * Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is
+           * closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its
+           * ancestors have the given class or the negated version of it, then the default activation will be returned.
+           *
+           * In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated
+           * version of it, the class is considered active.
+           *
+           * @param {Element} element
+           * @param {string} className
+           * @param {boolean} [defaultActivation=false]
+           * @returns {boolean}
+           */
+          isActive: function(o, l, p) {
+            for (var h = "no-" + l; o; ) {
+              var g = o.classList;
+              if (g.contains(l))
+                return !0;
+              if (g.contains(h))
+                return !1;
+              o = o.parentElement;
+            }
+            return !!p;
+          }
+        },
+        /**
+         * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
+         *
+         * @namespace
+         * @memberof Prism
+         * @public
+         */
+        languages: {
+          /**
+           * The grammar for plain, unformatted text.
+           */
+          plain: r,
+          plaintext: r,
+          text: r,
+          txt: r,
+          /**
+           * Creates a deep copy of the language with the given id and appends the given tokens.
+           *
+           * If a token in `redef` also appears in the copied language, then the existing token in the copied language
+           * will be overwritten at its original position.
+           *
+           * ## Best practices
+           *
+           * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
+           * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
+           * understand the language definition because, normally, the order of tokens matters in Prism grammars.
+           *
+           * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
+           * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
+           *
+           * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
+           * @param {Grammar} redef The new tokens to append.
+           * @returns {Grammar} The new language created.
+           * @public
+           * @example
+           * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
+           *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
+           *     // at its original position
+           *     'comment': { ... },
+           *     // CSS doesn't have a 'color' token, so this token will be appended
+           *     'color': /\b(?:red|green|blue)\b/
+           * });
+           */
+          extend: function(o, l) {
+            var p = a.util.clone(a.languages[o]);
+            for (var h in l)
+              p[h] = l[h];
+            return p;
+          },
+          /**
+           * Inserts tokens _before_ another token in a language definition or any other grammar.
+           *
+           * ## Usage
+           *
+           * This helper method makes it easy to modify existing languages. For example, the CSS language definition
+           * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
+           * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
+           * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
+           * this:
+           *
+           * ```js
+           * Prism.languages.markup.style = {
+           *     // token
+           * };
+           * ```
+           *
+           * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
+           * before existing tokens. For the CSS example above, you would use it like this:
+           *
+           * ```js
+           * Prism.languages.insertBefore('markup', 'cdata', {
+           *     'style': {
+           *         // token
+           *     }
+           * });
+           * ```
+           *
+           * ## Special cases
+           *
+           * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
+           * will be ignored.
+           *
+           * This behavior can be used to insert tokens after `before`:
+           *
+           * ```js
+           * Prism.languages.insertBefore('markup', 'comment', {
+           *     'comment': Prism.languages.markup.comment,
+           *     // tokens after 'comment'
+           * });
+           * ```
+           *
+           * ## Limitations
+           *
+           * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
+           * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
+           * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
+           * deleting properties which is necessary to insert at arbitrary positions.
+           *
+           * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
+           * Instead, it will create a new object and replace all references to the target object with the new one. This
+           * can be done without temporarily deleting properties, so the iteration order is well-defined.
+           *
+           * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
+           * you hold the target object in a variable, then the value of the variable will not change.
+           *
+           * ```js
+           * var oldMarkup = Prism.languages.markup;
+           * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
+           *
+           * assert(oldMarkup !== Prism.languages.markup);
+           * assert(newMarkup === Prism.languages.markup);
+           * ```
+           *
+           * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
+           * object to be modified.
+           * @param {string} before The key to insert before.
+           * @param {Grammar} insert An object containing the key-value pairs to be inserted.
+           * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
+           * object to be modified.
+           *
+           * Defaults to `Prism.languages`.
+           * @returns {Grammar} The new grammar object.
+           * @public
+           */
+          insertBefore: function(o, l, p, h) {
+            h = h || /** @type {any} */
+            a.languages;
+            var g = h[o], x = {};
+            for (var y in g)
+              if (g.hasOwnProperty(y)) {
+                if (y == l)
+                  for (var k in p)
+                    p.hasOwnProperty(k) && (x[k] = p[k]);
+                p.hasOwnProperty(y) || (x[y] = g[y]);
+              }
+            var F = h[o];
+            return h[o] = x, a.languages.DFS(a.languages, function(_, O) {
+              O === F && _ != o && (this[_] = x);
+            }), x;
+          },
+          // Traverse a language definition with Depth First Search
+          DFS: function o(l, p, h, g) {
+            g = g || {};
+            var x = a.util.objId;
+            for (var y in l)
+              if (l.hasOwnProperty(y)) {
+                p.call(l, y, l[y], h || y);
+                var k = l[y], F = a.util.type(k);
+                F === "Object" && !g[x(k)] ? (g[x(k)] = !0, o(k, p, null, g)) : F === "Array" && !g[x(k)] && (g[x(k)] = !0, o(k, p, y, g));
+              }
+          }
+        },
+        plugins: {},
+        /**
+         * This is the most high-level function in Prism’s API.
+         * It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on
+         * each one of them.
+         *
+         * This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.
+         *
+         * @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.
+         * @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.
+         * @memberof Prism
+         * @public
+         */
+        highlightAll: function(o, l) {
+          a.highlightAllUnder(document, o, l);
+        },
+        /**
+         * Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls
+         * {@link Prism.highlightElement} on each one of them.
+         *
+         * The following hooks will be run:
+         * 1. `before-highlightall`
+         * 2. `before-all-elements-highlight`
+         * 3. All hooks of {@link Prism.highlightElement} for each element.
+         *
+         * @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted.
+         * @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers.
+         * @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done.
+         * @memberof Prism
+         * @public
+         */
+        highlightAllUnder: function(o, l, p) {
+          var h = {
+            callback: p,
+            container: o,
+            selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
+          };
+          a.hooks.run("before-highlightall", h), h.elements = Array.prototype.slice.apply(h.container.querySelectorAll(h.selector)), a.hooks.run("before-all-elements-highlight", h);
+          for (var g = 0, x; x = h.elements[g++]; )
+            a.highlightElement(x, l === !0, h.callback);
+        },
+        /**
+         * Highlights the code inside a single element.
+         *
+         * The following hooks will be run:
+         * 1. `before-sanity-check`
+         * 2. `before-highlight`
+         * 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.
+         * 4. `before-insert`
+         * 5. `after-highlight`
+         * 6. `complete`
+         *
+         * Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for
+         * the element's language.
+         *
+         * @param {Element} element The element containing the code.
+         * It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.
+         * @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers
+         * to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is
+         * [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default).
+         *
+         * Note: All language definitions required to highlight the code must be included in the main `prism.js` file for
+         * asynchronous highlighting to work. You can build your own bundle on the
+         * [Download page](https://prismjs.com/download.html).
+         * @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done.
+         * Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.
+         * @memberof Prism
+         * @public
+         */
+        highlightElement: function(o, l, p) {
+          var h = a.util.getLanguage(o), g = a.languages[h];
+          a.util.setLanguage(o, h);
+          var x = o.parentElement;
+          x && x.nodeName.toLowerCase() === "pre" && a.util.setLanguage(x, h);
+          var y = o.textContent, k = {
+            element: o,
+            language: h,
+            grammar: g,
+            code: y
+          };
+          function F(O) {
+            k.highlightedCode = O, a.hooks.run("before-insert", k), k.element.innerHTML = k.highlightedCode, a.hooks.run("after-highlight", k), a.hooks.run("complete", k), p && p.call(k.element);
+          }
+          if (a.hooks.run("before-sanity-check", k), x = k.element.parentElement, x && x.nodeName.toLowerCase() === "pre" && !x.hasAttribute("tabindex") && x.setAttribute("tabindex", "0"), !k.code) {
+            a.hooks.run("complete", k), p && p.call(k.element);
+            return;
+          }
+          if (a.hooks.run("before-highlight", k), !k.grammar) {
+            F(a.util.encode(k.code));
+            return;
+          }
+          if (l && t.Worker) {
+            var _ = new Worker(a.filename);
+            _.onmessage = function(O) {
+              F(O.data);
+            }, _.postMessage(JSON.stringify({
+              language: k.language,
+              code: k.code,
+              immediateClose: !0
+            }));
+          } else
+            F(a.highlight(k.code, k.grammar, k.language));
+        },
+        /**
+         * Low-level function, only use if you know what you’re doing. It accepts a string of text as input
+         * and the language definitions to use, and returns a string with the HTML produced.
+         *
+         * The following hooks will be run:
+         * 1. `before-tokenize`
+         * 2. `after-tokenize`
+         * 3. `wrap`: On each {@link Token}.
+         *
+         * @param {string} text A string with the code to be highlighted.
+         * @param {Grammar} grammar An object containing the tokens to use.
+         *
+         * Usually a language definition like `Prism.languages.markup`.
+         * @param {string} language The name of the language definition passed to `grammar`.
+         * @returns {string} The highlighted HTML.
+         * @memberof Prism
+         * @public
+         * @example
+         * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
+         */
+        highlight: function(o, l, p) {
+          var h = {
+            code: o,
+            grammar: l,
+            language: p
+          };
+          if (a.hooks.run("before-tokenize", h), !h.grammar)
+            throw new Error('The language "' + h.language + '" has no grammar.');
+          return h.tokens = a.tokenize(h.code, h.grammar), a.hooks.run("after-tokenize", h), c.stringify(a.util.encode(h.tokens), h.language);
+        },
+        /**
+         * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
+         * and the language definitions to use, and returns an array with the tokenized code.
+         *
+         * When the language definition includes nested tokens, the function is called recursively on each of these tokens.
+         *
+         * This method could be useful in other contexts as well, as a very crude parser.
+         *
+         * @param {string} text A string with the code to be highlighted.
+         * @param {Grammar} grammar An object containing the tokens to use.
+         *
+         * Usually a language definition like `Prism.languages.markup`.
+         * @returns {TokenStream} An array of strings and tokens, a token stream.
+         * @memberof Prism
+         * @public
+         * @example
+         * let code = `var foo = 0;`;
+         * let tokens = Prism.tokenize(code, Prism.languages.javascript);
+         * tokens.forEach(token => {
+         *     if (token instanceof Prism.Token && token.type === 'number') {
+         *         console.log(`Found numeric literal: ${token.content}`);
+         *     }
+         * });
+         */
+        tokenize: function(o, l) {
+          var p = l.rest;
+          if (p) {
+            for (var h in p)
+              l[h] = p[h];
+            delete l.rest;
+          }
+          var g = new b();
+          return d(g, g.head, o), f(o, g, l, g.head, 0), E(g);
+        },
+        /**
+         * @namespace
+         * @memberof Prism
+         * @public
+         */
+        hooks: {
+          all: {},
+          /**
+           * Adds the given callback to the list of callbacks for the given hook.
+           *
+           * The callback will be invoked when the hook it is registered for is run.
+           * Hooks are usually directly run by a highlight function but you can also run hooks yourself.
+           *
+           * One callback function can be registered to multiple hooks and the same hook multiple times.
+           *
+           * @param {string} name The name of the hook.
+           * @param {HookCallback} callback The callback function which is given environment variables.
+           * @public
+           */
+          add: function(o, l) {
+            var p = a.hooks.all;
+            p[o] = p[o] || [], p[o].push(l);
+          },
+          /**
+           * Runs a hook invoking all registered callbacks with the given environment variables.
+           *
+           * Callbacks will be invoked synchronously and in the order in which they were registered.
+           *
+           * @param {string} name The name of the hook.
+           * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+           * @public
+           */
+          run: function(o, l) {
+            var p = a.hooks.all[o];
+            if (!(!p || !p.length))
+              for (var h = 0, g; g = p[h++]; )
+                g(l);
+          }
+        },
+        Token: c
+      };
+      t.Prism = a;
+      function c(o, l, p, h) {
+        this.type = o, this.content = l, this.alias = p, this.length = (h || "").length | 0;
+      }
+      c.stringify = function o(l, p) {
+        if (typeof l == "string")
+          return l;
+        if (Array.isArray(l)) {
+          var h = "";
+          return l.forEach(function(F) {
+            h += o(F, p);
+          }), h;
+        }
+        var g = {
+          type: l.type,
+          content: o(l.content, p),
+          tag: "span",
+          classes: ["token", l.type],
+          attributes: {},
+          language: p
+        }, x = l.alias;
+        x && (Array.isArray(x) ? Array.prototype.push.apply(g.classes, x) : g.classes.push(x)), a.hooks.run("wrap", g);
+        var y = "";
+        for (var k in g.attributes)
+          y += " " + k + '="' + (g.attributes[k] || "").replace(/"/g, "&quot;") + '"';
+        return "<" + g.tag + ' class="' + g.classes.join(" ") + '"' + y + ">" + g.content + "</" + g.tag + ">";
+      };
+      function m(o, l, p, h) {
+        o.lastIndex = l;
+        var g = o.exec(p);
+        if (g && h && g[1]) {
+          var x = g[1].length;
+          g.index += x, g[0] = g[0].slice(x);
+        }
+        return g;
+      }
+      function f(o, l, p, h, g, x) {
+        for (var y in p)
+          if (!(!p.hasOwnProperty(y) || !p[y])) {
+            var k = p[y];
+            k = Array.isArray(k) ? k : [k];
+            for (var F = 0; F < k.length; ++F) {
+              if (x && x.cause == y + "," + F)
+                return;
+              var _ = k[F], O = _.inside, Te = !!_.lookbehind, Se = !!_.greedy, Je = _.alias;
+              if (Se && !_.pattern.global) {
+                var Ke = _.pattern.toString().match(/[imsuy]*$/)[0];
+                _.pattern = RegExp(_.pattern.source, Ke + "g");
+              }
+              for (var Fe = _.pattern || _, z = h.next, I = g; z !== l.tail && !(x && I >= x.reach); I += z.value.length, z = z.next) {
+                var j = z.value;
+                if (l.length > o.length)
+                  return;
+                if (!(j instanceof c)) {
+                  var Y = 1, C;
+                  if (Se) {
+                    if (C = m(Fe, I, o, Te), !C || C.index >= o.length)
+                      break;
+                    var J = C.index, Ve = C.index + C[0].length, Z = I;
+                    for (Z += z.value.length; J >= Z; )
+                      z = z.next, Z += z.value.length;
+                    if (Z -= z.value.length, I = Z, z.value instanceof c)
+                      continue;
+                    for (var U = z; U !== l.tail && (Z < Ve || typeof U.value == "string"); U = U.next)
+                      Y++, Z += U.value.length;
+                    Y--, j = o.slice(I, Z), C.index -= I;
+                  } else if (C = m(Fe, 0, j, Te), !C)
+                    continue;
+                  var J = C.index, K = C[0], oe = j.slice(0, J), _e = j.slice(J + K.length), ce = I + j.length;
+                  x && ce > x.reach && (x.reach = ce);
+                  var V = z.prev;
+                  oe && (V = d(l, V, oe), I += oe.length), v(l, V, Y);
+                  var et = new c(y, O ? a.tokenize(K, O) : K, Je, K);
+                  if (z = d(l, V, et), _e && d(l, z, _e), Y > 1) {
+                    var ue = {
+                      cause: y + "," + F,
+                      reach: ce
+                    };
+                    f(o, l, p, z.prev, I, ue), x && ue.reach > x.reach && (x.reach = ue.reach);
+                  }
+                }
+              }
+            }
+          }
+      }
+      function b() {
+        var o = { value: null, prev: null, next: null }, l = { value: null, prev: o, next: null };
+        o.next = l, this.head = o, this.tail = l, this.length = 0;
+      }
+      function d(o, l, p) {
+        var h = l.next, g = { value: p, prev: l, next: h };
+        return l.next = g, h.prev = g, o.length++, g;
+      }
+      function v(o, l, p) {
+        for (var h = l.next, g = 0; g < p && h !== o.tail; g++)
+          h = h.next;
+        l.next = h, h.prev = l, o.length -= g;
+      }
+      function E(o) {
+        for (var l = [], p = o.head.next; p !== o.tail; )
+          l.push(p.value), p = p.next;
+        return l;
+      }
+      if (!t.document)
+        return t.addEventListener && (a.disableWorkerMessageHandler || t.addEventListener("message", function(o) {
+          var l = JSON.parse(o.data), p = l.language, h = l.code, g = l.immediateClose;
+          t.postMessage(a.highlight(h, a.languages[p], p)), g && t.close();
+        }, !1)), a;
+      var $ = a.util.currentScript();
+      $ && (a.filename = $.src, $.hasAttribute("data-manual") && (a.manual = !0));
+      function w() {
+        a.manual || a.highlightAll();
+      }
+      if (!a.manual) {
+        var S = document.readyState;
+        S === "loading" || S === "interactive" && $ && $.defer ? document.addEventListener("DOMContentLoaded", w) : window.requestAnimationFrame ? window.requestAnimationFrame(w) : window.setTimeout(w, 16);
+      }
+      return a;
+    }(n);
+    u.exports && (u.exports = e), typeof ze < "u" && (ze.Prism = e), e.languages.markup = {
+      comment: {
+        pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+        greedy: !0
+      },
+      prolog: {
+        pattern: /<\?[\s\S]+?\?>/,
+        greedy: !0
+      },
+      doctype: {
+        // https://www.w3.org/TR/xml/#NT-doctypedecl
+        pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+        greedy: !0,
+        inside: {
+          "internal-subset": {
+            pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+            lookbehind: !0,
+            greedy: !0,
+            inside: null
+            // see below
+          },
+          string: {
+            pattern: /"[^"]*"|'[^']*'/,
+            greedy: !0
+          },
+          punctuation: /^<!|>$|[[\]]/,
+          "doctype-tag": /^DOCTYPE/i,
+          name: /[^\s<>'"]+/
+        }
+      },
+      cdata: {
+        pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+        greedy: !0
+      },
+      tag: {
+        pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+        greedy: !0,
+        inside: {
+          tag: {
+            pattern: /^<\/?[^\s>\/]+/,
+            inside: {
+              punctuation: /^<\/?/,
+              namespace: /^[^\s>\/:]+:/
+            }
+          },
+          "special-attr": [],
+          "attr-value": {
+            pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+            inside: {
+              punctuation: [
+                {
+                  pattern: /^=/,
+                  alias: "attr-equals"
+                },
+                {
+                  pattern: /^(\s*)["']|["']$/,
+                  lookbehind: !0
+                }
+              ]
+            }
+          },
+          punctuation: /\/?>/,
+          "attr-name": {
+            pattern: /[^\s>\/]+/,
+            inside: {
+              namespace: /^[^\s>\/:]+:/
+            }
+          }
+        }
+      },
+      entity: [
+        {
+          pattern: /&[\da-z]{1,8};/i,
+          alias: "named-entity"
+        },
+        /&#x?[\da-f]{1,8};/i
+      ]
+    }, e.languages.markup.tag.inside["attr-value"].inside.entity = e.languages.markup.entity, e.languages.markup.doctype.inside["internal-subset"].inside = e.languages.markup, e.hooks.add("wrap", function(t) {
+      t.type === "entity" && (t.attributes.title = t.content.replace(/&amp;/, "&"));
+    }), Object.defineProperty(e.languages.markup.tag, "addInlined", {
+      /**
+       * Adds an inlined language to markup.
+       *
+       * An example of an inlined language is CSS with `<style>` tags.
+       *
+       * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+       * case insensitive.
+       * @param {string} lang The language key.
+       * @example
+       * addInlined('style', 'css');
+       */
+      value: function(s, i) {
+        var r = {};
+        r["language-" + i] = {
+          pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+          lookbehind: !0,
+          inside: e.languages[i]
+        }, r.cdata = /^<!\[CDATA\[|\]\]>$/i;
+        var a = {
+          "included-cdata": {
+            pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+            inside: r
+          }
+        };
+        a["language-" + i] = {
+          pattern: /[\s\S]+/,
+          inside: e.languages[i]
+        };
+        var c = {};
+        c[s] = {
+          pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
+            return s;
+          }), "i"),
+          lookbehind: !0,
+          greedy: !0,
+          inside: a
+        }, e.languages.insertBefore("markup", "cdata", c);
+      }
+    }), Object.defineProperty(e.languages.markup.tag, "addAttribute", {
+      /**
+       * Adds an pattern to highlight languages embedded in HTML attributes.
+       *
+       * An example of an inlined language is CSS with `style` attributes.
+       *
+       * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
+       * case insensitive.
+       * @param {string} lang The language key.
+       * @example
+       * addAttribute('style', 'css');
+       */
+      value: function(t, s) {
+        e.languages.markup.tag.inside["special-attr"].push({
+          pattern: RegExp(
+            /(^|["'\s])/.source + "(?:" + t + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
+            "i"
+          ),
+          lookbehind: !0,
+          inside: {
+            "attr-name": /^[^\s=]+/,
+            "attr-value": {
+              pattern: /=[\s\S]+/,
+              inside: {
+                value: {
+                  pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+                  lookbehind: !0,
+                  alias: [s, "language-" + s],
+                  inside: e.languages[s]
+                },
+                punctuation: [
+                  {
+                    pattern: /^=/,
+                    alias: "attr-equals"
+                  },
+                  /"|'/
+                ]
+              }
+            }
+          }
+        });
+      }
+    }), e.languages.html = e.languages.markup, e.languages.mathml = e.languages.markup, e.languages.svg = e.languages.markup, e.languages.xml = e.languages.extend("markup", {}), e.languages.ssml = e.languages.xml, e.languages.atom = e.languages.xml, e.languages.rss = e.languages.xml, function(t) {
+      var s = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+      t.languages.css = {
+        comment: /\/\*[\s\S]*?\*\//,
+        atrule: {
+          pattern: RegExp("@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + s.source + ")*?" + /(?:;|(?=\s*\{))/.source),
+          inside: {
+            rule: /^@[\w-]+/,
+            "selector-function-argument": {
+              pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+              lookbehind: !0,
+              alias: "selector"
+            },
+            keyword: {
+              pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+              lookbehind: !0
+            }
+            // See rest below
+          }
+        },
+        url: {
+          // https://drafts.csswg.org/css-values-3/#urls
+          pattern: RegExp("\\burl\\((?:" + s.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"),
+          greedy: !0,
+          inside: {
+            function: /^url/i,
+            punctuation: /^\(|\)$/,
+            string: {
+              pattern: RegExp("^" + s.source + "$"),
+              alias: "url"
+            }
+          }
+        },
+        selector: {
+          pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + s.source + ")*(?=\\s*\\{)"),
+          lookbehind: !0
+        },
+        string: {
+          pattern: s,
+          greedy: !0
+        },
+        property: {
+          pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+          lookbehind: !0
+        },
+        important: /!important\b/i,
+        function: {
+          pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+          lookbehind: !0
+        },
+        punctuation: /[(){};:,]/
+      }, t.languages.css.atrule.inside.rest = t.languages.css;
+      var i = t.languages.markup;
+      i && (i.tag.addInlined("style", "css"), i.tag.addAttribute("style", "css"));
+    }(e), e.languages.clike = {
+      comment: [
+        {
+          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      string: {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      "class-name": {
+        pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
+        lookbehind: !0,
+        inside: {
+          punctuation: /[.\\]/
+        }
+      },
+      keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
+      boolean: /\b(?:false|true)\b/,
+      function: /\b\w+(?=\()/,
+      number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+      operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
+      punctuation: /[{}[\];(),.:]/
+    }, e.languages.javascript = e.languages.extend("clike", {
+      "class-name": [
+        e.languages.clike["class-name"],
+        {
+          pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
+          lookbehind: !0
+        }
+      ],
+      keyword: [
+        {
+          pattern: /((?:^|\})\s*)catch\b/,
+          lookbehind: !0
+        },
+        {
+          pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
+          lookbehind: !0
+        }
+      ],
+      // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
+      function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+      number: {
+        pattern: RegExp(
+          /(^|[^\w$])/.source + "(?:" + // constant
+          (/NaN|Infinity/.source + "|" + // binary integer
+          /0[bB][01]+(?:_[01]+)*n?/.source + "|" + // octal integer
+          /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + // hexadecimal integer
+          /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + // decimal bigint
+          /\d+(?:_\d+)*n/.source + "|" + // decimal number (integer or float) but no bigint
+          /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source
+        ),
+        lookbehind: !0
+      },
+      operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
+    }), e.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, e.languages.insertBefore("javascript", "keyword", {
+      regex: {
+        pattern: RegExp(
+          // lookbehind
+          // eslint-disable-next-line regexp/no-dupe-characters-character-class
+          /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + // Regex pattern:
+          // There are 2 regex patterns here. The RegExp set notation proposal added support for nested character
+          // classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible
+          // with the only syntax, so we have to define 2 different regex patterns.
+          /\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + // `v` flag syntax. This supports 3 levels of nested character classes.
+          /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + // lookahead
+          /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source
+        ),
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          "regex-source": {
+            pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+            lookbehind: !0,
+            alias: "language-regex",
+            inside: e.languages.regex
+          },
+          "regex-delimiter": /^\/|\/$/,
+          "regex-flags": /^[a-z]+$/
+        }
+      },
+      // This must be declared before keyword because we use "function" inside the look-forward
+      "function-variable": {
+        pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
+        alias: "function"
+      },
+      parameter: [
+        {
+          pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
+          lookbehind: !0,
+          inside: e.languages.javascript
+        },
+        {
+          pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+          lookbehind: !0,
+          inside: e.languages.javascript
+        },
+        {
+          pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+          lookbehind: !0,
+          inside: e.languages.javascript
+        },
+        {
+          pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
+          lookbehind: !0,
+          inside: e.languages.javascript
+        }
+      ],
+      constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
+    }), e.languages.insertBefore("javascript", "string", {
+      hashbang: {
+        pattern: /^#!.*/,
+        greedy: !0,
+        alias: "comment"
+      },
+      "template-string": {
+        pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+        greedy: !0,
+        inside: {
+          "template-punctuation": {
+            pattern: /^`|`$/,
+            alias: "string"
+          },
+          interpolation: {
+            pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+            lookbehind: !0,
+            inside: {
+              "interpolation-punctuation": {
+                pattern: /^\$\{|\}$/,
+                alias: "punctuation"
+              },
+              rest: e.languages.javascript
+            }
+          },
+          string: /[\s\S]+/
+        }
+      },
+      "string-property": {
+        pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
+        lookbehind: !0,
+        greedy: !0,
+        alias: "property"
+      }
+    }), e.languages.insertBefore("javascript", "operator", {
+      "literal-property": {
+        pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
+        lookbehind: !0,
+        alias: "property"
+      }
+    }), e.languages.markup && (e.languages.markup.tag.addInlined("script", "javascript"), e.languages.markup.tag.addAttribute(
+      /on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source,
+      "javascript"
+    )), e.languages.js = e.languages.javascript, function() {
+      if (typeof e > "u" || typeof document > "u")
+        return;
+      Element.prototype.matches || (Element.prototype.matches = Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector);
+      var t = "Loading…", s = function($, w) {
+        return "✖ Error " + $ + " while fetching file: " + w;
+      }, i = "✖ Error: File does not exist or is empty", r = {
+        js: "javascript",
+        py: "python",
+        rb: "ruby",
+        ps1: "powershell",
+        psm1: "powershell",
+        sh: "bash",
+        bat: "batch",
+        h: "c",
+        tex: "latex"
+      }, a = "data-src-status", c = "loading", m = "loaded", f = "failed", b = "pre[data-src]:not([" + a + '="' + m + '"]):not([' + a + '="' + c + '"])';
+      function d($, w, S) {
+        var o = new XMLHttpRequest();
+        o.open("GET", $, !0), o.onreadystatechange = function() {
+          o.readyState == 4 && (o.status < 400 && o.responseText ? w(o.responseText) : o.status >= 400 ? S(s(o.status, o.statusText)) : S(i));
+        }, o.send(null);
+      }
+      function v($) {
+        var w = /^\s*(\d+)\s*(?:(,)\s*(?:(\d+)\s*)?)?$/.exec($ || "");
+        if (w) {
+          var S = Number(w[1]), o = w[2], l = w[3];
+          return o ? l ? [S, Number(l)] : [S, void 0] : [S, S];
+        }
+      }
+      e.hooks.add("before-highlightall", function($) {
+        $.selector += ", " + b;
+      }), e.hooks.add("before-sanity-check", function($) {
+        var w = (
+          /** @type {HTMLPreElement} */
+          $.element
+        );
+        if (w.matches(b)) {
+          $.code = "", w.setAttribute(a, c);
+          var S = w.appendChild(document.createElement("CODE"));
+          S.textContent = t;
+          var o = w.getAttribute("data-src"), l = $.language;
+          if (l === "none") {
+            var p = (/\.(\w+)$/.exec(o) || [, "none"])[1];
+            l = r[p] || p;
+          }
+          e.util.setLanguage(S, l), e.util.setLanguage(w, l);
+          var h = e.plugins.autoloader;
+          h && h.loadLanguages(l), d(
+            o,
+            function(g) {
+              w.setAttribute(a, m);
+              var x = v(w.getAttribute("data-range"));
+              if (x) {
+                var y = g.split(/\r\n?|\n/g), k = x[0], F = x[1] == null ? y.length : x[1];
+                k < 0 && (k += y.length), k = Math.max(0, Math.min(k - 1, y.length)), F < 0 && (F += y.length), F = Math.max(0, Math.min(F, y.length)), g = y.slice(k, F).join(`
+`), w.hasAttribute("data-start") || w.setAttribute("data-start", String(k + 1));
+              }
+              S.textContent = g, e.highlightElement(S);
+            },
+            function(g) {
+              w.setAttribute(a, f), S.textContent = g;
+            }
+          );
+        }
+      }), e.plugins.fileHighlight = {
+        /**
+         * Executes the File Highlight plugin for all matching `pre` elements under the given container.
+         *
+         * Note: Elements which are already loaded or currently loading will not be touched by this method.
+         *
+         * @param {ParentNode} [container=document]
+         */
+        highlight: function(w) {
+          for (var S = (w || document).querySelectorAll(b), o = 0, l; l = S[o++]; )
+            e.highlightElement(l);
+        }
+      };
+      var E = !1;
+      e.fileHighlight = function() {
+        E || (console.warn("Prism.fileHighlight is deprecated. Use `Prism.plugins.fileHighlight.highlight` instead."), E = !0), e.plugins.fileHighlight.highlight.apply(this, arguments);
+      };
+    }();
+  }(pe)), pe.exports;
+}
+var he = jt();
+const Ht = {
+  code(u, n) {
+    const e = (n || "").match(/\S*/)?.[0], t = ["ts", "typescript", "js", "javascript"].includes(
+      e ?? ""
+    ) ? "javascript" : e;
+    if (!t || !he.languages[t])
+      return `<pre class="language-"><code>${u}</code></pre>`;
+    const s = he.highlight(u, he.languages[t], t);
+    return `<pre class="language-${t}"><code>${s}</code></pre>`;
+  }
+};
+function Xe() {
+  const u = new Ne();
+  return u.use({ renderer: Ht }), u;
+}
+var Ut = Object.defineProperty, Qt = Object.getOwnPropertyDescriptor, Ye = (u) => {
+  throw TypeError(u);
+}, q = (u, n, e, t) => {
+  for (var s = t > 1 ? void 0 : t ? Qt(n, e) : n, i = u.length - 1, r; i >= 0; i--)
+    (r = u[i]) && (s = (t ? r(n, e, s) : r(s)) || s);
+  return t && s && Ut(n, e, s), s;
+}, Ae = (u, n, e) => n.has(u) || Ye("Cannot " + e), de = (u, n, e) => (Ae(u, n, "read from private field"), e ? e.call(u) : n.get(u)), Me = (u, n, e) => n.has(u) ? Ye("Cannot add the same private member more than once") : n instanceof WeakSet ? n.add(u) : n.set(u, e), Wt = (u, n, e, t) => (Ae(u, n, "write to private field"), n.set(u, e), e), qe = (u, n, e) => (Ae(u, n, "access private method"), e), H, re, ke;
+let M = class extends at {
+  constructor() {
+    super(...arguments), Me(this, re), Me(this, H, Xe()), this.classname = "", this.liveScript = !1, this.renderer = {}, this.extensions = [];
+  }
+  connectedCallback() {
+    super.connectedCallback(), qe(this, re, ke).call(this);
+  }
+  updateRendered() {
+    this.rendered = de(this, H).parse(this.markdown);
+  }
+  handleRenderedWithNewMarkdown() {
+    qe(this, re, ke).call(this), this.markdown && (this.rendered = de(this, H).parse(this.markdown));
+  }
+  render() {
+    return nt`
+      <div class=${this.classname}>${it(this.rendered)}</div>
+    `;
+  }
+  updated() {
+    this.liveScript && Gt(this), this.emit("cx-ready");
+  }
+};
+H = /* @__PURE__ */ new WeakMap();
+re = /* @__PURE__ */ new WeakSet();
+ke = function() {
+  Wt(this, H, Xe()), de(this, H).use({
+    extensions: this.extensions,
+    renderer: this.renderer
+  });
+};
+q([
+  G({ type: String })
+], M.prototype, "classname", 2);
+q([
+  G({ attribute: "live-script", reflect: !0, type: Boolean })
+], M.prototype, "liveScript", 2);
+q([
+  G({ type: String })
+], M.prototype, "markdown", 2);
+q([
+  G({ type: Object })
+], M.prototype, "renderer", 2);
+q([
+  G({ type: Object })
+], M.prototype, "extensions", 2);
+q([
+  st()
+], M.prototype, "rendered", 2);
+q([
+  ge("markdown")
+], M.prototype, "updateRendered", 1);
+q([
+  ge("renderer", { waitUntilFirstUpdate: !0 }),
+  ge("extensions", { waitUntilFirstUpdate: !0 })
+], M.prototype, "handleRenderedWithNewMarkdown", 1);
+M = q([
+  rt("cx-markdown")
+], M);
+function Gt(u) {
+  u.querySelectorAll("script").forEach((e) => {
+    const t = document.createElement("script");
+    e.src ? t.src = e.src : t.text = `(function() {
+${e.text}
+})();`, Array.from(e.attributes).forEach((s) => {
+      s.name !== "src" && t.setAttribute(s.name, s.value);
+    }), document.body.appendChild(t);
+  });
+}
+export {
+  M as default
+};