jude-cehua/static/js/highlight.min.js

/*!
  Highlight.js v11.11.1 (git: 08cb242e7d)
  (c) 2006-2025 Josh Goebel <hello@joshgoebel.com> and other contributors
  License: BSD-3-Clause
 */
var hljs = function () {
  "use strict"; function e (t) {
    return t instanceof Map ? t.clear = t.delete = t.set = () => {
      throw Error("map is read-only")
    } : t instanceof Set && (t.add = t.clear = t.delete = () => {
      throw Error("set is read-only")
    }), Object.freeze(t), Object.getOwnPropertyNames(t).forEach((n => {
      const i = t[n], s = typeof i; "object" !== s && "function" !== s || Object.isFrozen(i) || e(i)
    })), t
  } class t {
    constructor(e) {
      void 0 === e.data && (e.data = {}), this.data = e.data, this.isMatchIgnored = !1
    }
    ignoreMatch () { this.isMatchIgnored = !0 }
  } function n (e) {
    return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;")
  } function i (e, ...t) {
    const n = Object.create(null); for (const t in e) n[t] = e[t]
      ; return t.forEach((e => { for (const t in e) n[t] = e[t] })), n
  } const s = e => !!e.scope
    ; class r {
      constructor(e, t) {
        this.buffer = "", this.classPrefix = t.classPrefix, e.walk(this)
      } addText (e) {
        this.buffer += n(e)
      } openNode (e) {
        if (!s(e)) return; const t = ((e, { prefix: t }) => {
          if (e.startsWith("language:")) return e.replace("language:", "language-")
            ; if (e.includes(".")) {
              const n = e.split(".")
              ; return [`${t}${n.shift()}`, ...n.map(((e, t) => `${e}${"_".repeat(t + 1)}`))].join(" ")
            } return `${t}${e}`
        })(e.scope, { prefix: this.classPrefix }); this.span(t)
      }
    closeNode (e) { s(e) && (this.buffer += "</span>") } value () { return this.buffer } span (e) {
      this.buffer += `<span class="${e}">`
    }
  } const o = (e = {}) => {
    const t = { children: [] }
    ; return Object.assign(t, e), t
  }; class a {
    constructor() {
      this.rootNode = o(), this.stack = [this.rootNode]
    } get top () {
      return this.stack[this.stack.length - 1]
    } get root () { return this.rootNode } add (e) {
      this.top.children.push(e)
    } openNode (e) {
      const t = o({ scope: e })
      ; this.add(t), this.stack.push(t)
    } closeNode () {
      if (this.stack.length > 1) return this.stack.pop()
    } closeAllNodes () {
      for (; this.closeNode(););
    } toJSON () { return JSON.stringify(this.rootNode, null, 4) }
    walk (e) { return this.constructor._walk(e, this.rootNode) } static _walk (e, t) {
      return "string" == typeof t ? e.addText(t) : t.children && (e.openNode(t),
        t.children.forEach((t => this._walk(e, t))), e.closeNode(t)), e
    } static _collapse (e) {
      "string" != typeof e && e.children && (e.children.every((e => "string" == typeof e)) ? e.children = [e.children.join("")] : e.children.forEach((e => {
        a._collapse(e)
      })))
    }
  } class c extends a {
    constructor(e) { super(), this.options = e }
    addText (e) { "" !== e && this.add(e) } startScope (e) { this.openNode(e) } endScope () {
      this.closeNode()
    } __addSublanguage (e, t) {
      const n = e.root
      ; t && (n.scope = "language:" + t), this.add(n)
    } toHTML () {
      return new r(this, this.options).value()
    } finalize () {
      return this.closeAllNodes(), !0
    }
  } function l (e) {
    return e ? "string" == typeof e ? e : e.source : null
  } function g (e) { return h("(?=", e, ")") }
  function u (e) { return h("(?:", e, ")*") } function d (e) { return h("(?:", e, ")?") }
  function h (...e) { return e.map((e => l(e))).join("") } function f (...e) {
    const t = (e => {
      const t = e[e.length - 1]
        ; return "object" == typeof t && t.constructor === Object ? (e.splice(e.length - 1, 1), t) : {}
    })(e); return "(" + (t.capture ? "" : "?:") + e.map((e => l(e))).join("|") + ")"
  }
  function p (e) { return RegExp(e.toString() + "|").exec("").length - 1 }
  const b = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./
    ; function m (e, { joinWith: t }) {
      let n = 0; return e.map((e => {
        n += 1; const t = n
          ; let i = l(e), s = ""; for (; i.length > 0;) {
            const e = b.exec(i); if (!e) { s += i; break }
            s += i.substring(0, e.index),
              i = i.substring(e.index + e[0].length), "\\" === e[0][0] && e[1] ? s += "\\" + (Number(e[1]) + t) : (s += e[0],
                "(" === e[0] && n++)
          } return s
      })).map((e => `(${e})`)).join(t)
    }
  const E = "[a-zA-Z]\\w*", x = "[a-zA-Z_]\\w*", y = "\\b\\d+(\\.\\d+)?", _ = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", w = "\\b(0b[01]+)", O = {
    begin: "\\\\[\\s\\S]", relevance: 0
  }, v = {
    scope: "string", begin: "'", end: "'",
    illegal: "\\n", contains: [O]
  }, k = {
    scope: "string", begin: '"', end: '"', illegal: "\\n",
    contains: [O]
  }, N = (e, t, n = {}) => {
    const s = i({
      scope: "comment", begin: e, end: t,
      contains: []
    }, n); s.contains.push({
      scope: "doctag",
      begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
      end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/, excludeBegin: !0, relevance: 0
    })
      ; const r = f("I", "a", "is", "so", "us", "to", "at", "if", "in", "it", "on", /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, /[A-Za-z]+[-][a-z]+/, /[A-Za-z][a-z]{2,}/)
      ; return s.contains.push({ begin: h(/[ ]+/, "(", r, /[.]?[:]?([.][ ]|[ ])/, "){3}") }), s
  }, S = N("//", "$"), M = N("/\\*", "\\*/"), R = N("#", "$"); var j = Object.freeze({
    __proto__: null, APOS_STRING_MODE: v, BACKSLASH_ESCAPE: O, BINARY_NUMBER_MODE: {
      scope: "number", begin: w, relevance: 0
    }, BINARY_NUMBER_RE: w, COMMENT: N,
    C_BLOCK_COMMENT_MODE: M, C_LINE_COMMENT_MODE: S, C_NUMBER_MODE: {
      scope: "number",
      begin: _, relevance: 0
    }, C_NUMBER_RE: _, END_SAME_AS_BEGIN: e => Object.assign(e, {
      "on:begin": (e, t) => { t.data._beginMatch = e[1] }, "on:end": (e, t) => {
        t.data._beginMatch !== e[1] && t.ignoreMatch()
      }
    }), HASH_COMMENT_MODE: R, IDENT_RE: E,
    MATCH_NOTHING_RE: /\b\B/, METHOD_GUARD: { begin: "\\.\\s*" + x, relevance: 0 },
    NUMBER_MODE: { scope: "number", begin: y, relevance: 0 }, NUMBER_RE: y,
    PHRASAL_WORDS_MODE: {
      begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
    }, QUOTE_STRING_MODE: k, REGEXP_MODE: {
      scope: "regexp", begin: /\/(?=[^/\n]*\/)/,
      end: /\/[gimuy]*/, contains: [O, { begin: /\[/, end: /\]/, relevance: 0, contains: [O] }]
    },
    RE_STARTERS_RE: "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",
    SHEBANG: (e = {}) => {
      const t = /^#![ ]*\//
      ; return e.binary && (e.begin = h(t, /.*\b/, e.binary, /\b.*/)), i({
        scope: "meta", begin: t,
        end: /$/, relevance: 0, "on:begin": (e, t) => { 0 !== e.index && t.ignoreMatch() }
      }, e)
    },
    TITLE_MODE: { scope: "title", begin: E, relevance: 0 }, UNDERSCORE_IDENT_RE: x,
    UNDERSCORE_TITLE_MODE: { scope: "title", begin: x, relevance: 0 }
  }); function A (e, t) {
    "." === e.input[e.index - 1] && t.ignoreMatch()
  } function I (e, t) {
    void 0 !== e.className && (e.scope = e.className, delete e.className)
  } function T (e, t) {
    t && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)",
      e.__beforeBegin = A, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords,
      void 0 === e.relevance && (e.relevance = 0))
  } function L (e, t) {
    Array.isArray(e.illegal) && (e.illegal = f(...e.illegal))
  } function B (e, t) {
    if (e.match) {
      if (e.begin || e.end) throw Error("begin & end are not supported with match")
        ; e.begin = e.match, delete e.match
    }
  } function P (e, t) {
    void 0 === e.relevance && (e.relevance = 1)
  } const D = (e, t) => {
    if (!e.beforeMatch) return
      ; if (e.starts) throw Error("beforeMatch cannot be used with starts")
        ; const n = Object.assign({}, e); Object.keys(e).forEach((t => {
          delete e[t]
        })), e.keywords = n.keywords, e.begin = h(n.beforeMatch, g(n.begin)), e.starts = {
          relevance: 0, contains: [Object.assign(n, { endsParent: !0 })]
        }, e.relevance = 0, delete n.beforeMatch
  }, H = ["of", "and", "for", "in", "not", "or", "if", "then", "parent", "list", "value"]
    ; function C (e, t, n = "keyword") {
      const i = Object.create(null)
      ; return "string" == typeof e ? s(n, e.split(" ")) : Array.isArray(e) ? s(n, e) : Object.keys(e).forEach((n => {
        Object.assign(i, C(e[n], t, n))
      })), i; function s (e, n) {
        t && (n = n.map((e => e.toLowerCase()))), n.forEach((t => {
          const n = t.split("|")
          ; i[n[0]] = [e, $(n[0], n[1])]
        }))
      }
    } function $ (e, t) {
      return t ? Number(t) : (e => H.includes(e.toLowerCase()))(e) ? 0 : 1
    } const U = {}, z = e => {
      console.error(e)
    }, W = (e, ...t) => { console.log("WARN: " + e, ...t) }, X = (e, t) => {
      U[`${e}/${t}`] || (console.log(`Deprecated as of ${e}. ${t}`), U[`${e}/${t}`] = !0)
    }, G = Error(); function K (e, t, { key: n }) {
      let i = 0; const s = e[n], r = {}, o = {}
        ; for (let e = 1; e <= t.length; e++)o[e + i] = s[e], r[e + i] = !0, i += p(t[e - 1])
          ; e[n] = o, e[n]._emit = r, e[n]._multi = !0
    } function F (e) {
      (e => {
        e.scope && "object" == typeof e.scope && null !== e.scope && (e.beginScope = e.scope,
          delete e.scope)
      })(e), "string" == typeof e.beginScope && (e.beginScope = {
        _wrap: e.beginScope
      }), "string" == typeof e.endScope && (e.endScope = {
        _wrap: e.endScope
      }), (e => {
        if (Array.isArray(e.begin)) {
          if (e.skip || e.excludeBegin || e.returnBegin) throw z("skip, excludeBegin, returnBegin not compatible with beginScope: {}"),
            G
            ; if ("object" != typeof e.beginScope || null === e.beginScope) throw z("beginScope must be object"),
              G; K(e, e.begin, { key: "beginScope" }), e.begin = m(e.begin, { joinWith: "" })
        }
      })(e), (e => {
        if (Array.isArray(e.end)) {
          if (e.skip || e.excludeEnd || e.returnEnd) throw z("skip, excludeEnd, returnEnd not compatible with endScope: {}"),
            G
            ; if ("object" != typeof e.endScope || null === e.endScope) throw z("endScope must be object"),
              G; K(e, e.end, { key: "endScope" }), e.end = m(e.end, { joinWith: "" })
        }
      })(e)
    } function Z (e) {
      function t (t, n) {
        return RegExp(l(t), "m" + (e.case_insensitive ? "i" : "") + (e.unicodeRegex ? "u" : "") + (n ? "g" : ""))
      } class n {
        constructor() {
          this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0
        }
        addRule (e, t) {
          t.position = this.position++, this.matchIndexes[this.matchAt] = t, this.regexes.push([t, e]),
            this.matchAt += p(e) + 1
        } compile () {
          0 === this.regexes.length && (this.exec = () => null)
          ; const e = this.regexes.map((e => e[1])); this.matcherRe = t(m(e, {
            joinWith: "|"
          }), !0), this.lastIndex = 0
        } exec (e) {
          this.matcherRe.lastIndex = this.lastIndex
          ; const t = this.matcherRe.exec(e); if (!t) return null
            ; const n = t.findIndex(((e, t) => t > 0 && void 0 !== e)), i = this.matchIndexes[n]
            ; return t.splice(0, n), Object.assign(t, i)
        }
      } class s {
        constructor() {
          this.rules = [], this.multiRegexes = [],
            this.count = 0, this.lastIndex = 0, this.regexIndex = 0
        } getMatcher (e) {
          if (this.multiRegexes[e]) return this.multiRegexes[e]; const t = new n
            ; return this.rules.slice(e).forEach((([e, n]) => t.addRule(e, n))),
              t.compile(), this.multiRegexes[e] = t, t
        } resumingScanAtSamePosition () {
          return 0 !== this.regexIndex
        } considerAll () { this.regexIndex = 0 } addRule (e, t) {
          this.rules.push([e, t]), "begin" === t.type && this.count++
        } exec (e) {
          const t = this.getMatcher(this.regexIndex); t.lastIndex = this.lastIndex
            ; let n = t.exec(e)
            ; if (this.resumingScanAtSamePosition()) if (n && n.index === this.lastIndex); else {
              const t = this.getMatcher(0); t.lastIndex = this.lastIndex + 1, n = t.exec(e)
            }
          return n && (this.regexIndex += n.position + 1,
            this.regexIndex === this.count && this.considerAll()), n
        }
      }
      if (e.compilerExtensions || (e.compilerExtensions = []),
        e.contains && e.contains.includes("self")) throw Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.")
        ; return e.classNameAliases = i(e.classNameAliases || {}), function n (r, o) {
          const a = r
          ; if (r.isCompiled) return a
            ;[I, B, F, D].forEach((e => e(r, o))), e.compilerExtensions.forEach((e => e(r, o))),
              r.__beforeBegin = null, [T, L, P].forEach((e => e(r, o))), r.isCompiled = !0; let c = null
            ; return "object" == typeof r.keywords && r.keywords.$pattern && (r.keywords = Object.assign({}, r.keywords),
              c = r.keywords.$pattern,
              delete r.keywords.$pattern), c = c || /\w+/, r.keywords && (r.keywords = C(r.keywords, e.case_insensitive)),
              a.keywordPatternRe = t(c, !0),
              o && (r.begin || (r.begin = /\B|\b/), a.beginRe = t(a.begin), r.end || r.endsWithParent || (r.end = /\B|\b/),
                r.end && (a.endRe = t(a.end)),
                a.terminatorEnd = l(a.end) || "", r.endsWithParent && o.terminatorEnd && (a.terminatorEnd += (r.end ? "|" : "") + o.terminatorEnd)),
              r.illegal && (a.illegalRe = t(r.illegal)),
              r.contains || (r.contains = []), r.contains = [].concat(...r.contains.map((e => (e => (e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map((t => i(e, {
                variants: null
              }, t)))), e.cachedVariants ? e.cachedVariants : V(e) ? i(e, {
                starts: e.starts ? i(e.starts) : null
              }) : Object.isFrozen(e) ? i(e) : e))("self" === e ? r : e)))), r.contains.forEach((e => {
                n(e, a)
              })), r.starts && n(r.starts, o), a.matcher = (e => {
                const t = new s
                ; return e.contains.forEach((e => t.addRule(e.begin, {
                  rule: e, type: "begin"
                }))), e.terminatorEnd && t.addRule(e.terminatorEnd, {
                  type: "end"
                }), e.illegal && t.addRule(e.illegal, { type: "illegal" }), t
              })(a), a
        }(e)
    } function V (e) {
      return !!e && (e.endsWithParent || V(e.starts))
    } class q extends Error {
    constructor(e, t) { super(e), this.name = "HTMLInjectionError", this.html = t }
  }
  const J = n, Y = i, Q = Symbol("nomatch"), ee = n => {
    const i = Object.create(null), s = Object.create(null), r = []; let o = !0
      ; const a = "Could not find the language '{}', did you forget to load/include a language module?", l = {
        disableAutodetect: !0, name: "Plain text", contains: []
      }; let p = {
        ignoreUnescapedHTML: !1, throwUnescapedHTML: !1, noHighlightRe: /^(no-?highlight)$/i,
        languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i, classPrefix: "hljs-",
        cssSelector: "pre code", languages: null, __emitter: c
      }; function b (e) {
        return p.noHighlightRe.test(e)
      } function m (e, t, n) {
        let i = "", s = ""
        ; "object" == typeof t ? (i = e,
          n = t.ignoreIllegals, s = t.language) : (X("10.7.0", "highlight(lang, code, ...args) has been deprecated."),
            X("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277"),
            s = e, i = t), void 0 === n && (n = !0); const r = { code: i, language: s }; N("before:highlight", r)
          ; const o = r.result ? r.result : E(r.language, r.code, n)
          ; return o.code = r.code, N("after:highlight", o), o
      } function E (e, n, s, r) {
        const c = Object.create(null); function l () {
          if (!N.keywords) return void M.addText(R)
            ; let e = 0; N.keywordPatternRe.lastIndex = 0; let t = N.keywordPatternRe.exec(R), n = ""
            ; for (; t;) {
              n += R.substring(e, t.index)
              ; const s = w.case_insensitive ? t[0].toLowerCase() : t[0], r = (i = s, N.keywords[i]); if (r) {
                const [e, i] = r
                  ; if (M.addText(n), n = "", c[s] = (c[s] || 0) + 1, c[s] <= 7 && (j += i), e.startsWith("_")) n += t[0]; else {
                    const n = w.classNameAliases[e] || e; u(t[0], n)
                  }
              } else n += t[0]
                ; e = N.keywordPatternRe.lastIndex, t = N.keywordPatternRe.exec(R)
            } var i
            ; n += R.substring(e), M.addText(n)
        } function g () {
          null != N.subLanguage ? (() => {
            if ("" === R) return; let e = null; if ("string" == typeof N.subLanguage) {
              if (!i[N.subLanguage]) return void M.addText(R)
                ; e = E(N.subLanguage, R, !0, S[N.subLanguage]), S[N.subLanguage] = e._top
            } else e = x(R, N.subLanguage.length ? N.subLanguage : null)
              ; N.relevance > 0 && (j += e.relevance), M.__addSublanguage(e._emitter, e.language)
          })() : l(), R = ""
        } function u (e, t) {
          "" !== e && (M.startScope(t), M.addText(e), M.endScope())
        } function d (e, t) {
          let n = 1
          ; const i = t.length - 1; for (; n <= i;) {
            if (!e._emit[n]) { n++; continue }
            const i = w.classNameAliases[e[n]] || e[n], s = t[n]; i ? u(s, i) : (R = s, l(), R = ""), n++
          }
        }
        function h (e, t) {
          return e.scope && "string" == typeof e.scope && M.openNode(w.classNameAliases[e.scope] || e.scope),
            e.beginScope && (e.beginScope._wrap ? (u(R, w.classNameAliases[e.beginScope._wrap] || e.beginScope._wrap),
              R = "") : e.beginScope._multi && (d(e.beginScope, t), R = "")), N = Object.create(e, {
                parent: {
                  value: N
                }
              }), N
        } function f (e, n, i) {
          let s = ((e, t) => {
            const n = e && e.exec(t)
            ; return n && 0 === n.index
          })(e.endRe, i); if (s) {
            if (e["on:end"]) {
              const i = new t(e)
              ; e["on:end"](n, i), i.isMatchIgnored && (s = !1)
            } if (s) {
              for (; e.endsParent && e.parent;)e = e.parent; return e
            }
          }
          if (e.endsWithParent) return f(e.parent, n, i)
        } function b (e) {
          return 0 === N.matcher.regexIndex ? (R += e[0], 1) : (T = !0, 0)
        } function m (e) {
          const t = e[0], i = n.substring(e.index), s = f(N, e, i); if (!s) return Q; const r = N
            ; N.endScope && N.endScope._wrap ? (g(),
              u(t, N.endScope._wrap)) : N.endScope && N.endScope._multi ? (g(),
                d(N.endScope, e)) : r.skip ? R += t : (r.returnEnd || r.excludeEnd || (R += t),
                  g(), r.excludeEnd && (R = t)); do {
                    N.scope && M.closeNode(), N.skip || N.subLanguage || (j += N.relevance), N = N.parent
                  } while (N !== s.parent); return s.starts && h(s.starts, e), r.returnEnd ? 0 : t.length
        }
        let y = {}; function _ (i, r) {
          const a = r && r[0]; if (R += i, null == a) return g(), 0
            ; if ("begin" === y.type && "end" === r.type && y.index === r.index && "" === a) {
              if (R += n.slice(r.index, r.index + 1), !o) {
                const t = Error(`0 width match regex (${e})`)
                ; throw t.languageName = e, t.badRule = y.rule, t
              } return 1
            }
          if (y = r, "begin" === r.type) return (e => {
            const n = e[0], i = e.rule, s = new t(i), r = [i.__beforeBegin, i["on:begin"]]
              ; for (const t of r) if (t && (t(e, s), s.isMatchIgnored)) return b(n)
                ; return i.skip ? R += n : (i.excludeBegin && (R += n),
                  g(), i.returnBegin || i.excludeBegin || (R = n)), h(i, e), i.returnBegin ? 0 : n.length
          })(r)
            ; if ("illegal" === r.type && !s) {
              const e = Error('Illegal lexeme "' + a + '" for mode "' + (N.scope || "<unnamed>") + '"')
                ; throw e.mode = N, e
            } if ("end" === r.type) { const e = m(r); if (e !== Q) return e }
          if ("illegal" === r.type && "" === a) return R += "\n", 1
            ; if (I > 1e5 && I > 3 * r.index) throw Error("potential infinite loop, way more iterations than matches")
              ; return R += a, a.length
        } const w = O(e)
          ; if (!w) throw z(a.replace("{}", e)), Error('Unknown language: "' + e + '"')
            ; const v = Z(w); let k = "", N = r || v; const S = {}, M = new p.__emitter(p); (() => {
              const e = []
              ; for (let t = N; t !== w; t = t.parent)t.scope && e.unshift(t.scope)
                ; e.forEach((e => M.openNode(e)))
            })(); let R = "", j = 0, A = 0, I = 0, T = !1; try {
              if (w.__emitTokens) w.__emitTokens(n, M); else {
                for (N.matcher.considerAll(); ;) {
                  I++, T ? T = !1 : N.matcher.considerAll(), N.matcher.lastIndex = A
                    ; const e = N.matcher.exec(n); if (!e) break; const t = _(n.substring(A, e.index), e)
                    ; A = e.index + t
                } _(n.substring(A))
              } return M.finalize(), k = M.toHTML(), {
                language: e,
                value: k, relevance: j, illegal: !1, _emitter: M, _top: N
              }
            } catch (t) {
              if (t.message && t.message.includes("Illegal")) return {
                language: e, value: J(n),
                illegal: !0, relevance: 0, _illegalBy: {
                  message: t.message, index: A,
                  context: n.slice(A - 100, A + 100), mode: t.mode, resultSoFar: k
                }, _emitter: M
              }; if (o) return {
                language: e, value: J(n), illegal: !1, relevance: 0, errorRaised: t, _emitter: M, _top: N
              }
                ; throw t
            }
      } function x (e, t) {
        t = t || p.languages || Object.keys(i); const n = (e => {
          const t = { value: J(e), illegal: !1, relevance: 0, _top: l, _emitter: new p.__emitter(p) }
            ; return t._emitter.addText(e), t
        })(e), s = t.filter(O).filter(k).map((t => E(t, e, !1)))
          ; s.unshift(n); const r = s.sort(((e, t) => {
            if (e.relevance !== t.relevance) return t.relevance - e.relevance
              ; if (e.language && t.language) {
                if (O(e.language).supersetOf === t.language) return 1
                  ; if (O(t.language).supersetOf === e.language) return -1
              } return 0
          })), [o, a] = r, c = o
          ; return c.secondBest = a, c
      } function y (e) {
        let t = null; const n = (e => {
          let t = e.className + " "; t += e.parentNode ? e.parentNode.className : ""
            ; const n = p.languageDetectRe.exec(t); if (n) {
              const t = O(n[1])
              ; return t || (W(a.replace("{}", n[1])),
                W("Falling back to no-highlight mode for this block.", e)), t ? n[1] : "no-highlight"
            }
          return t.split(/\s+/).find((e => b(e) || O(e)))
        })(e); if (b(n)) return
          ; if (N("before:highlightElement", {
            el: e, language: n
          }), e.dataset.highlighted) return void console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", e)
            ; if (e.children.length > 0 && (p.ignoreUnescapedHTML || (console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."),
              console.warn("https://github.com/highlightjs/highlight.js/wiki/security"),
              console.warn("The element with unescaped HTML:"),
              console.warn(e)), p.throwUnescapedHTML)) throw new q("One of your code blocks includes unescaped HTML.", e.innerHTML)
          ; t = e; const i = t.textContent, r = n ? m(i, { language: n, ignoreIllegals: !0 }) : x(i)
          ; e.innerHTML = r.value, e.dataset.highlighted = "yes", ((e, t, n) => {
            const i = t && s[t] || n
            ; e.classList.add("hljs"), e.classList.add("language-" + i)
          })(e, n, r.language), e.result = {
            language: r.language, re: r.relevance,
            relevance: r.relevance
          }, r.secondBest && (e.secondBest = {
            language: r.secondBest.language, relevance: r.secondBest.relevance
          }), N("after:highlightElement", { el: e, result: r, text: i })
      } let _ = !1; function w () {
        if ("loading" === document.readyState) return _ || window.addEventListener("DOMContentLoaded", (() => {
          w()
        }), !1), void (_ = !0); document.querySelectorAll(p.cssSelector).forEach(y)
      }
    function O (e) { return e = (e || "").toLowerCase(), i[e] || i[s[e]] }
    function v (e, { languageName: t }) {
      "string" == typeof e && (e = [e]), e.forEach((e => {
        s[e.toLowerCase()] = t
      }))
    } function k (e) {
      const t = O(e)
      ; return t && !t.disableAutodetect
    } function N (e, t) {
      const n = e; r.forEach((e => {
        e[n] && e[n](t)
      }))
    } Object.assign(n, {
      highlight: m, highlightAuto: x, highlightAll: w,
      highlightElement: y,
      highlightBlock: e => (X("10.7.0", "highlightBlock will be removed entirely in v12.0"),
        X("10.7.0", "Please use highlightElement now."), y(e)), configure: e => { p = Y(p, e) },
      initHighlighting: () => {
        w(), X("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.")
      },
      initHighlightingOnLoad: () => {
        w(), X("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.")
      }, registerLanguage: (e, t) => {
        let s = null; try { s = t(n) } catch (t) {
          if (z("Language definition for '{}' could not be registered.".replace("{}", e)),
            !o) throw t; z(t), s = l
        }
        s.name || (s.name = e), i[e] = s, s.rawDefinition = t.bind(null, n), s.aliases && v(s.aliases, {
          languageName: e
        })
      }, unregisterLanguage: e => {
        delete i[e]
        ; for (const t of Object.keys(s)) s[t] === e && delete s[t]
      },
      listLanguages: () => Object.keys(i), getLanguage: O, registerAliases: v,
      autoDetection: k, inherit: Y, addPlugin: e => {
        (e => {
          e["before:highlightBlock"] && !e["before:highlightElement"] && (e["before:highlightElement"] = t => {
            e["before:highlightBlock"](Object.assign({ block: t.el }, t))
          }), e["after:highlightBlock"] && !e["after:highlightElement"] && (e["after:highlightElement"] = t => {
            e["after:highlightBlock"](Object.assign({ block: t.el }, t))
          })
        })(e), r.push(e)
      },
      removePlugin: e => { const t = r.indexOf(e); -1 !== t && r.splice(t, 1) }
    }), n.debugMode = () => {
      o = !1
    }, n.safeMode = () => { o = !0 }, n.versionString = "11.11.1", n.regex = {
      concat: h,
      lookahead: g, either: f, optional: d, anyNumberOfTimes: u
    }
      ; for (const t in j) "object" == typeof j[t] && e(j[t]); return Object.assign(n, j), n
  }, te = ee({}); return te.newInstance = () => ee({}), te
}()
  ; "object" == typeof exports && "undefined" != typeof module && (module.exports = hljs);/*! `css` grammar compiled for Highlight.js 11.11.1 */
(() => {
  var e = (() => {
    "use strict"
      ; const e = ["a", "abbr", "address", "article", "aside", "audio", "b", "blockquote", "body", "button", "canvas", "caption", "cite", "code", "dd", "del", "details", "dfn", "div", "dl", "dt", "em", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup", "html", "i", "iframe", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "mark", "menu", "nav", "object", "ol", "optgroup", "option", "p", "picture", "q", "quote", "samp", "section", "select", "source", "span", "strong", "summary", "sup", "table", "tbody", "td", "textarea", "tfoot", "th", "thead", "time", "tr", "ul", "var", "video", "defs", "g", "marker", "mask", "pattern", "svg", "switch", "symbol", "feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feFlood", "feGaussianBlur", "feImage", "feMerge", "feMorphology", "feOffset", "feSpecularLighting", "feTile", "feTurbulence", "linearGradient", "radialGradient", "stop", "circle", "ellipse", "image", "line", "path", "polygon", "polyline", "rect", "text", "use", "textPath", "tspan", "foreignObject", "clipPath"], i = ["any-hover", "any-pointer", "aspect-ratio", "color", "color-gamut", "color-index", "device-aspect-ratio", "device-height", "device-width", "display-mode", "forced-colors", "grid", "height", "hover", "inverted-colors", "monochrome", "orientation", "overflow-block", "overflow-inline", "pointer", "prefers-color-scheme", "prefers-contrast", "prefers-reduced-motion", "prefers-reduced-transparency", "resolution", "scan", "scripting", "update", "width", "min-width", "max-width", "min-height", "max-height"].sort().reverse(), t = ["active", "any-link", "blank", "checked", "current", "default", "defined", "dir", "disabled", "drop", "empty", "enabled", "first", "first-child", "first-of-type", "fullscreen", "future", "focus", "focus-visible", "focus-within", "has", "host", "host-context", "hover", "indeterminate", "in-range", "invalid", "is", "lang", "last-child", "last-of-type", "left", "link", "local-link", "not", "nth-child", "nth-col", "nth-last-child", "nth-last-col", "nth-last-of-type", "nth-of-type", "only-child", "only-of-type", "optional", "out-of-range", "past", "placeholder-shown", "read-only", "read-write", "required", "right", "root", "scope", "target", "target-within", "user-invalid", "valid", "visited", "where"].sort().reverse(), o = ["after", "backdrop", "before", "cue", "cue-region", "first-letter", "first-line", "grammar-error", "marker", "part", "placeholder", "selection", "slotted", "spelling-error"].sort().reverse(), r = ["accent-color", "align-content", "align-items", "align-self", "alignment-baseline", "all", "anchor-name", "animation", "animation-composition", "animation-delay", "animation-direction", "animation-duration", "animation-fill-mode", "animation-iteration-count", "animation-name", "animation-play-state", "animation-range", "animation-range-end", "animation-range-start", "animation-timeline", "animation-timing-function", "appearance", "aspect-ratio", "backdrop-filter", "backface-visibility", "background", "background-attachment", "background-blend-mode", "background-clip", "background-color", "background-image", "background-origin", "background-position", "background-position-x", "background-position-y", "background-repeat", "background-size", "baseline-shift", "block-size", "border", "border-block", "border-block-color", "border-block-end", "border-block-end-color", "border-block-end-style", "border-block-end-width", "border-block-start", "border-block-start-color", "border-block-start-style", "border-block-start-width", "border-block-style", "border-block-width", "border-bottom", "border-bottom-color", "border-bottom-left-radius", "border-bottom-right-radius", "border-bottom-style", "border-bottom-width", "border-collapse", "border-color", "border-end-end-radius", "border-end-start-radius", "border-image", "border-image-outset", "border-image-repeat", "border-image-slice", "border-image-source", "border-image-width", "border-inline", "border-inline-color", "border-inline-end", "border-inline-end-color", "border-inline-end-style", "border-inline-end-width", "border-inline-start", "border-inline-start-color", "border-inline-start-style", "border-inline-start-width", "border-inline-style", "border-inline-width", "border-left", "border-left-color", "border-left-style", "border-left-width", "border-radius", "border-right", "border-right-color", "border-right-style", "border-right-width", "border-spacing", "border-start-end-radius", "border-start-start-radius", "border-style", "border-top", "border-top-color", "border-top-left-radius", "border-top-right-radius", "border-top-style", "border-top-width", "border-width", "bottom", "box-align", "box-decoration-break", "box-direction", "box-flex", "box-flex-group", "box-lines", "box-ordinal-group", "box-orient", "box-pack", "box-shadow", "box-sizing", "break-after", "break-before", "break-inside", "caption-side", "caret-color", "clear", "clip", "clip-path", "clip-rule", "color", "color-interpolation", "color-interpolation-filters", "color-profile", "color-rendering", "color-scheme", "column-count", "column-fill", "column-gap", "column-rule", "column-rule-color", "column-rule-style", "column-rule-width", "column-span", "column-width", "columns", "contain", "contain-intrinsic-block-size", "contain-intrinsic-height", "contain-intrinsic-inline-size", "contain-intrinsic-size", "contain-intrinsic-width", "container", "container-name", "container-type", "content", "content-visibility", "counter-increment", "counter-reset", "counter-set", "cue", "cue-after", "cue-before", "cursor", "cx", "cy", "direction", "display", "dominant-baseline", "empty-cells", "enable-background", "field-sizing", "fill", "fill-opacity", "fill-rule", "filter", "flex", "flex-basis", "flex-direction", "flex-flow", "flex-grow", "flex-shrink", "flex-wrap", "float", "flood-color", "flood-opacity", "flow", "font", "font-display", "font-family", "font-feature-settings", "font-kerning", "font-language-override", "font-optical-sizing", "font-palette", "font-size", "font-size-adjust", "font-smooth", "font-smoothing", "font-stretch", "font-style", "font-synthesis", "font-synthesis-position", "font-synthesis-small-caps", "font-synthesis-style", "font-synthesis-weight", "font-variant", "font-variant-alternates", "font-variant-caps", "font-variant-east-asian", "font-variant-emoji", "font-variant-ligatures", "font-variant-numeric", "font-variant-position", "font-variation-settings", "font-weight", "forced-color-adjust", "gap", "glyph-orientation-horizontal", "glyph-orientation-vertical", "grid", "grid-area", "grid-auto-columns", "grid-auto-flow", "grid-auto-rows", "grid-column", "grid-column-end", "grid-column-start", "grid-gap", "grid-row", "grid-row-end", "grid-row-start", "grid-template", "grid-template-areas", "grid-template-columns", "grid-template-rows", "hanging-punctuation", "height", "hyphenate-character", "hyphenate-limit-chars", "hyphens", "icon", "image-orientation", "image-rendering", "image-resolution", "ime-mode", "initial-letter", "initial-letter-align", "inline-size", "inset", "inset-area", "inset-block", "inset-block-end", "inset-block-start", "inset-inline", "inset-inline-end", "inset-inline-start", "isolation", "justify-content", "justify-items", "justify-self", "kerning", "left", "letter-spacing", "lighting-color", "line-break", "line-height", "line-height-step", "list-style", "list-style-image", "list-style-position", "list-style-type", "margin", "margin-block", "margin-block-end", "margin-block-start", "margin-bottom", "margin-inline", "margin-inline-end", "margin-inline-start", "margin-left", "margin-right", "margin-top", "margin-trim", "marker", "marker-end", "marker-mid", "marker-start", "marks", "mask", "mask-border", "mask-border-mode", "mask-border-outset", "mask-border-repeat", "mask-border-slice", "mask-border-source", "mask-border-width", "mask-clip", "mask-composite", "mask-image", "mask-mode", "mask-origin", "mask-position", "mask-repeat", "mask-size", "mask-type", "masonry-auto-flow", "math-depth", "math-shift", "math-style", "max-block-size", "max-height", "max-inline-size", "max-width", "min-block-size", "min-height", "min-inline-size", "min-width", "mix-blend-mode", "nav-down", "nav-index", "nav-left", "nav-right", "nav-up", "none", "normal", "object-fit", "object-position", "offset", "offset-anchor", "offset-distance", "offset-path", "offset-position", "offset-rotate", "opacity", "order", "orphans", "outline", "outline-color", "outline-offset", "outline-style", "outline-width", "overflow", "overflow-anchor", "overflow-block", "overflow-clip-margin", "overflow-inline", "overflow-wrap", "overflow-x", "overflow-y", "overlay", "overscroll-behavior", "overscroll-behavior-block", "overscroll-behavior-inline", "overscroll-behavior-x", "overscroll-behavior-y", "padding", "padding-block", "padding-block-end", "padding-block-start", "padding-bottom", "padding-inline", "padding-inline-end", "padding-inline-start", "padding-left", "padding-right", "padding-top", "page", "page-break-after", "page-break-before", "page-break-inside", "paint-order", "pause", "pause-after", "pause-before", "perspective", "perspective-origin", "place-content", "place-items", "place-self", "pointer-events", "position", "position-anchor", "position-visibility", "print-color-adjust", "quotes", "r", "resize", "rest", "rest-after", "rest-before", "right", "rotate", "row-gap", "ruby-align", "ruby-position", "scale", "scroll-behavior", "scroll-margin", "scroll-margin-block", "scroll-margin-block-end", "scroll-margin-block-start", "scroll-margin-bottom", "scroll-margin-inline", "scroll-margin-inline-end", "scroll-margin-inline-start", "scroll-margin-left", "scroll-margin-right", "scroll-margin-top", "scroll-padding", "scroll-padding-block", "scroll-padding-block-end", "scroll-padding-block-start", "scroll-padding-bottom", "scroll-padding-inline", "scroll-padding-inline-end", "scroll-padding-inline-start", "scroll-padding-left", "scroll-padding-right", "scroll-padding-top", "scroll-snap-align", "scroll-snap-stop", "scroll-snap-type", "scroll-timeline", "scroll-timeline-axis", "scroll-timeline-name", "scrollbar-color", "scrollbar-gutter", "scrollbar-width", "shape-image-threshold", "shape-margin", "shape-outside", "shape-rendering", "speak", "speak-as", "src", "stop-color", "stop-opacity", "stroke", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke-width", "tab-size", "table-layout", "text-align", "text-align-all", "text-align-last", "text-anchor", "text-combine-upright", "text-decoration", "text-decoration-color", "text-decoration-line", "text-decoration-skip", "text-decoration-skip-ink", "text-decoration-style", "text-decoration-thickness", "text-emphasis", "text-emphasis-color", "text-emphasis-position", "text-emphasis-style", "text-indent", "text-justify", "text-orientation", "text-overflow", "text-rendering", "text-shadow", "text-size-adjust", "text-transform", "text-underline-offset", "text-underline-position", "text-wrap", "text-wrap-mode", "text-wrap-style", "timeline-scope", "top", "touch-action", "transform", "transform-box", "transform-origin", "transform-style", "transition", "transition-behavior", "transition-delay", "transition-duration", "transition-property", "transition-timing-function", "translate", "unicode-bidi", "user-modify", "user-select", "vector-effect", "vertical-align", "view-timeline", "view-timeline-axis", "view-timeline-inset", "view-timeline-name", "view-transition-name", "visibility", "voice-balance", "voice-duration", "voice-family", "voice-pitch", "voice-range", "voice-rate", "voice-stress", "voice-volume", "white-space", "white-space-collapse", "widows", "width", "will-change", "word-break", "word-spacing", "word-wrap", "writing-mode", "x", "y", "z-index", "zoom"].sort().reverse()
      ; return n => {
        const a = n.regex, l = (e => ({
          IMPORTANT: { scope: "meta", begin: "!important" },
          BLOCK_COMMENT: e.C_BLOCK_COMMENT_MODE, HEXCOLOR: {
            scope: "number",
            begin: /#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/
          }, FUNCTION_DISPATCH: {
            className: "built_in", begin: /[\w-]+(?=\()/
          }, ATTRIBUTE_SELECTOR_MODE: {
            scope: "selector-attr", begin: /\[/, end: /\]/, illegal: "$",
            contains: [e.APOS_STRING_MODE, e.QUOTE_STRING_MODE]
          }, CSS_NUMBER_MODE: {
            scope: "number",
            begin: e.NUMBER_RE + "(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",
            relevance: 0
          }, CSS_VARIABLE: { className: "attr", begin: /--[A-Za-z_][A-Za-z0-9_-]*/ }
        }))(n), s = [n.APOS_STRING_MODE, n.QUOTE_STRING_MODE]; return {
          name: "CSS",
          case_insensitive: !0, illegal: /[=|'\$]/, keywords: { keyframePosition: "from to" },
          classNameAliases: { keyframePosition: "selector-tag" }, contains: [l.BLOCK_COMMENT, {
            begin: /-(webkit|moz|ms|o)-(?=[a-z])/
          }, l.CSS_NUMBER_MODE, {
            className: "selector-id", begin: /#[A-Za-z0-9_-]+/, relevance: 0
          }, {
            className: "selector-class", begin: "\\.[a-zA-Z-][a-zA-Z0-9_-]*", relevance: 0
          }, l.ATTRIBUTE_SELECTOR_MODE, {
            className: "selector-pseudo", variants: [{
              begin: ":(" + t.join("|") + ")"
            }, { begin: ":(:)?(" + o.join("|") + ")" }]
          }, l.CSS_VARIABLE, {
            className: "attribute", begin: "\\b(" + r.join("|") + ")\\b"
          }, {
            begin: /:/, end: /[;}{]/,
            contains: [l.BLOCK_COMMENT, l.HEXCOLOR, l.IMPORTANT, l.CSS_NUMBER_MODE, ...s, {
              begin: /(url|data-uri)\(/, end: /\)/, relevance: 0, keywords: {
                built_in: "url data-uri"
              }, contains: [...s, {
                className: "string", begin: /[^)]/, endsWithParent: !0,
                excludeEnd: !0
              }]
            }, l.FUNCTION_DISPATCH]
          }, {
            begin: a.lookahead(/@/), end: "[{;]",
            relevance: 0, illegal: /:/, contains: [{
              className: "keyword", begin: /@-?\w[\w]*(-\w+)*/
            }, {
              begin: /\s/, endsWithParent: !0, excludeEnd: !0, relevance: 0, keywords: {
                $pattern: /[a-z-]+/, keyword: "and or not only", attribute: i.join(" ")
              }, contains: [{
                begin: /[a-z-]+(?=:)/, className: "attribute"
              }, ...s, l.CSS_NUMBER_MODE]
            }]
          }, {
            className: "selector-tag", begin: "\\b(" + e.join("|") + ")\\b"
          }]
        }
      }
  })()
  ; hljs.registerLanguage("css", e)
})();/*! `javascript` grammar compiled for Highlight.js 11.11.1 */
(() => {
  var e = (() => {
    "use strict"
      ; const e = "[A-Za-z$_][0-9A-Za-z$_]*", n = ["as", "in", "of", "if", "for", "while", "finally", "var", "new", "function", "do", "return", "void", "else", "break", "catch", "instanceof", "with", "throw", "case", "default", "try", "switch", "continue", "typeof", "delete", "let", "yield", "const", "class", "debugger", "async", "await", "static", "import", "from", "export", "extends", "using"], a = ["true", "false", "null", "undefined", "NaN", "Infinity"], t = ["Object", "Function", "Boolean", "Symbol", "Math", "Date", "Number", "BigInt", "String", "RegExp", "Array", "Float32Array", "Float64Array", "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Int32Array", "Uint16Array", "Uint32Array", "BigInt64Array", "BigUint64Array", "Set", "Map", "WeakSet", "WeakMap", "ArrayBuffer", "SharedArrayBuffer", "Atomics", "DataView", "JSON", "Promise", "Generator", "GeneratorFunction", "AsyncFunction", "Reflect", "Proxy", "Intl", "WebAssembly"], s = ["Error", "EvalError", "InternalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError"], r = ["setInterval", "setTimeout", "clearInterval", "clearTimeout", "require", "exports", "eval", "isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "escape", "unescape"], c = ["arguments", "this", "super", "console", "window", "document", "localStorage", "sessionStorage", "module", "global"], i = [].concat(r, t, s)
      ; return o => {
        const l = o.regex, d = e, b = {
          begin: /<[A-Za-z0-9\\._:-]+/,
          end: /\/[A-Za-z0-9\\._:-]+>|\/>/, isTrulyOpeningTag: (e, n) => {
            const a = e[0].length + e.index, t = e.input[a]
              ; if ("<" === t || "," === t) return void n.ignoreMatch(); let s
              ; ">" === t && (((e, { after: n }) => {
                const a = "</" + e[0].slice(1)
                ; return -1 !== e.input.indexOf(a, n)
              })(e, { after: a }) || n.ignoreMatch())
              ; const r = e.input.substring(a)
              ; ((s = r.match(/^\s*=/)) || (s = r.match(/^\s+extends\s+/)) && 0 === s.index) && n.ignoreMatch()
          }
        }, g = {
          $pattern: e, keyword: n, literal: a, built_in: i, "variable.language": c
        }, u = "[0-9](_?[0-9])*", m = `\\.(${u})`, E = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", A = {
          className: "number", variants: [{
            begin: `(\\b(${E})((${m})|\\.)?|(${m}))[eE][+-]?(${u})\\b`
          }, {
            begin: `\\b(${E})\\b((${m})\\b|\\.)?|(${m})\\b`
          }, {
            begin: "\\b(0|[1-9](_?[0-9])*)n\\b"
          }, {
            begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b"
          }, {
            begin: "\\b0[bB][0-1](_?[0-1])*n?\\b"
          }, { begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" }, {
            begin: "\\b0[0-7]+n?\\b"
          }], relevance: 0
        }, y = {
          className: "subst", begin: "\\$\\{",
          end: "\\}", keywords: g, contains: []
        }, h = {
          begin: ".?html`", end: "", starts: {
            end: "`",
            returnEnd: !1, contains: [o.BACKSLASH_ESCAPE, y], subLanguage: "xml"
          }
        }, _ = {
          begin: ".?css`", end: "", starts: {
            end: "`", returnEnd: !1,
            contains: [o.BACKSLASH_ESCAPE, y], subLanguage: "css"
          }
        }, N = {
          begin: ".?gql`", end: "",
          starts: {
            end: "`", returnEnd: !1, contains: [o.BACKSLASH_ESCAPE, y],
            subLanguage: "graphql"
          }
        }, f = {
          className: "string", begin: "`", end: "`",
          contains: [o.BACKSLASH_ESCAPE, y]
        }, p = {
          className: "comment",
          variants: [o.COMMENT(/\/\*\*(?!\/)/, "\\*/", {
            relevance: 0, contains: [{
              begin: "(?=@[A-Za-z]+)", relevance: 0, contains: [{
                className: "doctag",
                begin: "@[A-Za-z]+"
              }, {
                className: "type", begin: "\\{", end: "\\}", excludeEnd: !0,
                excludeBegin: !0, relevance: 0
              }, {
                className: "variable", begin: d + "(?=\\s*(-)|$)",
                endsParent: !0, relevance: 0
              }, { begin: /(?=[^\n])\s/, relevance: 0 }]
            }]
          }), o.C_BLOCK_COMMENT_MODE, o.C_LINE_COMMENT_MODE]
        }, v = [o.APOS_STRING_MODE, o.QUOTE_STRING_MODE, h, _, N, f, { match: /\$\d+/ }, A]
        ; y.contains = v.concat({
          begin: /\{/, end: /\}/, keywords: g, contains: ["self"].concat(v)
        }); const S = [].concat(p, y.contains), w = S.concat([{
          begin: /(\s*)\(/, end: /\)/,
          keywords: g, contains: ["self"].concat(S)
        }]), R = {
          className: "params", begin: /(\s*)\(/,
          end: /\)/, excludeBegin: !0, excludeEnd: !0, keywords: g, contains: w
        }, O = {
          variants: [{
            match: [/class/, /\s+/, d, /\s+/, /extends/, /\s+/, l.concat(d, "(", l.concat(/\./, d), ")*")],
            scope: { 1: "keyword", 3: "title.class", 5: "keyword", 7: "title.class.inherited" }
          }, {
            match: [/class/, /\s+/, d], scope: { 1: "keyword", 3: "title.class" }
          }]
        }, k = {
          relevance: 0,
          match: l.either(/\bJSON/, /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/, /\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/, /\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/),
          className: "title.class", keywords: { _: [...t, ...s] }
        }, I = {
          variants: [{
            match: [/function/, /\s+/, d, /(?=\s*\()/]
          }, { match: [/function/, /\s*(?=\()/] }],
          className: { 1: "keyword", 3: "title.function" }, label: "func.def", contains: [R],
          illegal: /%/
        }, x = {
          match: l.concat(/\b/, (T = [...r, "super", "import"].map((e => e + "\\s*\\(")),
            l.concat("(?!", T.join("|"), ")")), d, l.lookahead(/\s*\(/)),
          className: "title.function", relevance: 0
        }; var T; const C = {
          begin: l.concat(/\./, l.lookahead(l.concat(d, /(?![0-9A-Za-z$_(])/))), end: d,
          excludeBegin: !0, keywords: "prototype", className: "property", relevance: 0
        }, M = {
          match: [/get|set/, /\s+/, d, /(?=\()/], className: { 1: "keyword", 3: "title.function" },
          contains: [{ begin: /\(\)/ }, R]
        }, B = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + o.UNDERSCORE_IDENT_RE + ")\\s*=>", $ = {
          match: [/const|var|let/, /\s+/, d, /\s*/, /=\s*/, /(async\s*)?/, l.lookahead(B)],
          keywords: "async", className: { 1: "keyword", 3: "title.function" }, contains: [R]
        }
          ; return {
            name: "JavaScript", aliases: ["js", "jsx", "mjs", "cjs"], keywords: g, exports: {
              PARAMS_CONTAINS: w, CLASS_REFERENCE: k
            }, illegal: /#(?![$_A-z])/,
            contains: [o.SHEBANG({ label: "shebang", binary: "node", relevance: 5 }), {
              label: "use_strict", className: "meta", relevance: 10,
              begin: /^\s*['"]use (strict|asm)['"]/
            }, o.APOS_STRING_MODE, o.QUOTE_STRING_MODE, h, _, N, f, p, { match: /\$\d+/ }, A, k, {
              scope: "attr", match: d + l.lookahead(":"), relevance: 0
            }, $, {
              begin: "(" + o.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
              keywords: "return throw case", relevance: 0, contains: [p, o.REGEXP_MODE, {
                className: "function", begin: B, returnBegin: !0, end: "\\s*=>", contains: [{
                  className: "params", variants: [{ begin: o.UNDERSCORE_IDENT_RE, relevance: 0 }, {
                    className: null, begin: /\(\s*\)/, skip: !0
                  }, {
                    begin: /(\s*)\(/, end: /\)/,
                    excludeBegin: !0, excludeEnd: !0, keywords: g, contains: w
                  }]
                }]
              }, {
                begin: /,/, relevance: 0
                }, { match: /\s+/, relevance: 0 }, {
                  variants: [{ begin: "<>", end: "</>" }, {
                    match: /<[A-Za-z0-9\\._:-]+\s*\/>/
                  }, {
                    begin: b.begin,
                    "on:begin": b.isTrulyOpeningTag, end: b.end
                  }], subLanguage: "xml", contains: [{
                    begin: b.begin, end: b.end, skip: !0, contains: ["self"]
                  }]
                }]
            }, I, {
              beginKeywords: "while if switch catch for"
            }, {
              begin: "\\b(?!function)" + o.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
              returnBegin: !0, label: "func.def", contains: [R, o.inherit(o.TITLE_MODE, {
                begin: d,
                className: "title.function"
              })]
            }, { match: /\.\.\./, relevance: 0 }, C, {
              match: "\\$" + d,
              relevance: 0
            }, {
              match: [/\bconstructor(?=\s*\()/], className: { 1: "title.function" },
              contains: [R]
            }, x, {
              relevance: 0, match: /\b[A-Z][A-Z_0-9]+\b/,
              className: "variable.constant"
            }, O, M, { match: /\$[(.]/ }]
          }
      }
  })()
  ; hljs.registerLanguage("javascript", e)
})();/*! `markdown` grammar compiled for Highlight.js 11.11.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const n = {
        begin: /<\/?[A-Za-z_]/,
        end: ">", subLanguage: "xml", relevance: 0
      }, a = {
        variants: [{
          begin: /\[.+?\]\[.*?\]/,
          relevance: 0
        }, {
          begin: /\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
          relevance: 2
        }, {
          begin: e.regex.concat(/\[.+?\]\(/, /[A-Za-z][A-Za-z0-9+.-]*/, /:\/\/.*?\)/),
          relevance: 2
        }, { begin: /\[.+?\]\([./?&#].*?\)/, relevance: 1 }, {
          begin: /\[.*?\]\(.*?\)/, relevance: 0
        }], returnBegin: !0, contains: [{
          match: /\[(?=\])/
        }, {
          className: "string", relevance: 0, begin: "\\[", end: "\\]", excludeBegin: !0,
          returnEnd: !0
        }, {
          className: "link", relevance: 0, begin: "\\]\\(", end: "\\)",
          excludeBegin: !0, excludeEnd: !0
        }, {
          className: "symbol", relevance: 0, begin: "\\]\\[",
          end: "\\]", excludeBegin: !0, excludeEnd: !0
        }]
      }, i = {
        className: "strong", contains: [],
        variants: [{ begin: /_{2}(?!\s)/, end: /_{2}/ }, { begin: /\*{2}(?!\s)/, end: /\*{2}/ }]
      }, s = {
        className: "emphasis", contains: [], variants: [{ begin: /\*(?![*\s])/, end: /\*/ }, {
          begin: /_(?![_\s])/, end: /_/, relevance: 0
        }]
      }, c = e.inherit(i, {
        contains: []
      }), t = e.inherit(s, { contains: [] }); i.contains.push(t), s.contains.push(c)
        ; let g = [n, a]; return [i, s, c, t].forEach((e => {
          e.contains = e.contains.concat(g)
        })), g = g.concat(i, s), {
          name: "Markdown", aliases: ["md", "mkdown", "mkd"], contains: [{
            className: "section", variants: [{ begin: "^#{1,6}", end: "$", contains: g }, {
              begin: "(?=^.+?\\n[=-]{2,}$)", contains: [{ begin: "^[=-]*$" }, {
                begin: "^", end: "\\n",
                contains: g
              }]
            }]
          }, n, {
            className: "bullet", begin: "^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)",
            end: "\\s+", excludeEnd: !0
          }, i, s, {
            className: "quote", begin: "^>\\s+", contains: g,
            end: "$"
          }, {
            className: "code", variants: [{ begin: "(`{3,})[^`](.|\\n)*?\\1`*[ ]*" }, {
              begin: "(~{3,})[^~](.|\\n)*?\\1~*[ ]*"
            }, { begin: "```", end: "```+[ ]*$" }, {
              begin: "~~~", end: "~~~+[ ]*$"
            }, { begin: "`.+?`" }, {
              begin: "(?=^( {4}|\\t))",
              contains: [{ begin: "^( {4}|\\t)", end: "(\\n)$" }], relevance: 0
            }]
          }, {
            begin: "^[-\\*]{3,}", end: "$"
          }, a, {
            begin: /^\[[^\n]+\]:/, returnBegin: !0, contains: [{
              className: "symbol", begin: /\[/, end: /\]/, excludeBegin: !0, excludeEnd: !0
            }, {
              className: "link", begin: /:\s*/, end: /$/, excludeBegin: !0
            }]
          }, {
            scope: "literal",
            match: /&([a-zA-Z0-9]+|#[0-9]{1,7}|#[Xx][0-9a-fA-F]{1,6});/
          }]
        }
    }
  })()
  ; hljs.registerLanguage("markdown", e)
})();/*! `python` grammar compiled for Highlight.js 11.11.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const n = e.regex, a = /[\p{XID_Start}_]\p{XID_Continue}*/u, s = ["and", "as", "assert", "async", "await", "break", "case", "class", "continue", "def", "del", "elif", "else", "except", "finally", "for", "from", "global", "if", "import", "in", "is", "lambda", "match", "nonlocal|10", "not", "or", "pass", "raise", "return", "try", "while", "with", "yield"], t = {
        $pattern: /[A-Za-z]\w+|__\w+__/, keyword: s,
        built_in: ["__import__", "abs", "all", "any", "ascii", "bin", "bool", "breakpoint", "bytearray", "bytes", "callable", "chr", "classmethod", "compile", "complex", "delattr", "dict", "dir", "divmod", "enumerate", "eval", "exec", "filter", "float", "format", "frozenset", "getattr", "globals", "hasattr", "hash", "help", "hex", "id", "input", "int", "isinstance", "issubclass", "iter", "len", "list", "locals", "map", "max", "memoryview", "min", "next", "object", "oct", "open", "ord", "pow", "print", "property", "range", "repr", "reversed", "round", "set", "setattr", "slice", "sorted", "staticmethod", "str", "sum", "super", "tuple", "type", "vars", "zip"],
        literal: ["__debug__", "Ellipsis", "False", "None", "NotImplemented", "True"],
        type: ["Any", "Callable", "Coroutine", "Dict", "List", "Literal", "Generic", "Optional", "Sequence", "Set", "Tuple", "Type", "Union"]
      }, i = { className: "meta", begin: /^(>>>|\.\.\.) / }, r = {
        className: "subst", begin: /\{/,
        end: /\}/, keywords: t, illegal: /#/
      }, l = { begin: /\{\{/, relevance: 0 }, o = {
        className: "string", contains: [e.BACKSLASH_ESCAPE], variants: [{
          begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/, end: /'''/,
          contains: [e.BACKSLASH_ESCAPE, i], relevance: 10
        }, {
          begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/, end: /"""/,
          contains: [e.BACKSLASH_ESCAPE, i], relevance: 10
        }, {
          begin: /([fF][rR]|[rR][fF]|[fF])'''/, end: /'''/,
          contains: [e.BACKSLASH_ESCAPE, i, l, r]
        }, {
          begin: /([fF][rR]|[rR][fF]|[fF])"""/,
          end: /"""/, contains: [e.BACKSLASH_ESCAPE, i, l, r]
        }, {
          begin: /([uU]|[rR])'/, end: /'/,
          relevance: 10
        }, { begin: /([uU]|[rR])"/, end: /"/, relevance: 10 }, {
          begin: /([bB]|[bB][rR]|[rR][bB])'/, end: /'/
        }, {
          begin: /([bB]|[bB][rR]|[rR][bB])"/,
          end: /"/
        }, {
          begin: /([fF][rR]|[rR][fF]|[fF])'/, end: /'/,
          contains: [e.BACKSLASH_ESCAPE, l, r]
        }, {
          begin: /([fF][rR]|[rR][fF]|[fF])"/, end: /"/,
          contains: [e.BACKSLASH_ESCAPE, l, r]
        }, e.APOS_STRING_MODE, e.QUOTE_STRING_MODE]
      }, b = "[0-9](_?[0-9])*", c = `(\\b(${b}))?\\.(${b})|\\b(${b})\\.`, d = "\\b|" + s.join("|"), g = {
        className: "number", relevance: 0, variants: [{
          begin: `(\\b(${b})|(${c}))[eE][+-]?(${b})[jJ]?(?=${d})`
        }, { begin: `(${c})[jJ]?` }, {
          begin: `\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${d})`
        }, {
          begin: `\\b0[bB](_?[01])+[lL]?(?=${d})`
        }, {
          begin: `\\b0[oO](_?[0-7])+[lL]?(?=${d})`
        }, { begin: `\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${d})` }, {
          begin: `\\b(${b})[jJ](?=${d})`
        }]
      }, p = {
        className: "comment", begin: n.lookahead(/# type:/), end: /$/, keywords: t,
        contains: [{ begin: /# type:/ }, { begin: /#/, end: /\b\B/, endsWithParent: !0 }]
      }, m = {
        className: "params", variants: [{ className: "", begin: /\(\s*\)/, skip: !0 }, {
          begin: /\(/,
          end: /\)/, excludeBegin: !0, excludeEnd: !0, keywords: t,
          contains: ["self", i, g, o, e.HASH_COMMENT_MODE]
        }]
      }; return r.contains = [o, g, i], {
        name: "Python", aliases: ["py", "gyp", "ipython"], unicodeRegex: !0, keywords: t,
        illegal: /(<\/|\?)|=>/, contains: [i, g, {
          scope: "variable.language", match: /\bself\b/
        }, { beginKeywords: "if", relevance: 0 }, {
          match: /\bor\b/, scope: "keyword"
          }, o, p, e.HASH_COMMENT_MODE, {
            match: [/\bdef/, /\s+/, a], scope: {
              1: "keyword",
              3: "title.function"
            }, contains: [m]
          }, {
            variants: [{
              match: [/\bclass/, /\s+/, a, /\s*/, /\(\s*/, a, /\s*\)/]
            }, { match: [/\bclass/, /\s+/, a] }],
            scope: { 1: "keyword", 3: "title.class", 6: "title.class.inherited" }
          }, {
            className: "meta", begin: /^[\t ]*@/, end: /(?=#)|$/, contains: [g, m, o]
          }]
      }
    }
  })()
  ; hljs.registerLanguage("python", e)
})();