OnlineEducation-back-front/public/mavonEditor/js/highlight.min.js

/*!
  Highlight.js v11.3.1 (git: 2a972d8658)
  (c) 2006-2021 Ivan Sagalaev and other contributors
  License: BSD-3-Clause
 */
var hljs = function () {
  "use strict"; var e = { exports: {} }; function t(e) {
    return e instanceof Map ? e.clear = e.delete = e.set = () => {
      throw Error("map is read-only")
    } : e instanceof Set && (e.add = e.clear = e.delete = () => {
      throw Error("set is read-only")
    }), Object.freeze(e), Object.getOwnPropertyNames(e).forEach((n => {
      var i = e[n]
        ; "object" != typeof i || Object.isFrozen(i) || t(i)
    })), e
  }
  e.exports = t, e.exports.default = t; var n = e.exports; class i {
    constructor(e) {
      void 0 === e.data && (e.data = {}), this.data = e.data, this.isMatchIgnored = !1
    }
    ignoreMatch() { this.isMatchIgnored = !0 }
  } function r(e) {
    return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;")
  } function s(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 o = e => !!e.kind
    ; class a {
    constructor(e, t) {
      this.buffer = "", this.classPrefix = t.classPrefix, e.walk(this)
    } addText(e) {
      this.buffer += r(e)
    } openNode(e) {
      if (!o(e)) return; let t = e.kind
        ; t = e.sublanguage ? "language-" + t : ((e, { prefix: t }) => {
          if (e.includes(".")) {
            const n = e.split(".")
              ; return [`${t}${n.shift()}`, ...n.map(((e, t) => `${e}${"_".repeat(t + 1)}`))].join(" ")
          } return `${t}${e}`
        })(t, { prefix: this.classPrefix }), this.span(t)
    } closeNode(e) {
      o(e) && (this.buffer += "</span>")
    } value() { return this.buffer } span(e) {
      this.buffer += `<span class="${e}">`
    }
  } class c {
    constructor() {
      this.rootNode = {
        children: []
      }, 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 = { kind: e, children: [] }
        ; 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 => {
        c._collapse(e)
      })))
    }
  } class l extends c {
    constructor(e) { super(), this.options = e }
    addKeyword(e, t) { "" !== e && (this.openNode(t), this.addText(e), this.closeNode()) }
    addText(e) { "" !== e && this.add(e) } addSublanguage(e, t) {
      const n = e.root
        ; n.kind = t, n.sublanguage = !0, this.add(n)
    } toHTML() {
      return new a(this, this.options).value()
    } finalize() { return !0 }
  } function g(e) {
    return e ? "string" == typeof e ? e : e.source : null
  } function d(e) { return f("(?=", e, ")") }
  function u(e) { return f("(?:", e, ")*") } function h(e) { return f("(?:", e, ")?") }
  function f(...e) { return e.map((e => g(e))).join("") } function p(...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 => g(e))).join("|") + ")"
  }
  function b(e) { return RegExp(e.toString() + "|").exec("").length - 1 }
  const m = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./
    ; function E(e, { joinWith: t }) {
      let n = 0; return e.map((e => {
        n += 1; const t = n
          ; let i = g(e), r = ""; for (; i.length > 0;) {
            const e = m.exec(i); if (!e) { r += i; break }
            r += i.substring(0, e.index),
              i = i.substring(e.index + e[0].length), "\\" === e[0][0] && e[1] ? r += "\\" + (Number(e[1]) + t) : (r += e[0],
                "(" === e[0] && n++)
          } return r
      })).map((e => `(${e})`)).join(t)
    }
  const x = "[a-zA-Z]\\w*", w = "[a-zA-Z_]\\w*", y = "\\b\\d+(\\.\\d+)?", _ = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", v = "\\b(0b[01]+)", O = {
    begin: "\\\\[\\s\\S]", relevance: 0
  }, k = {
    scope: "string", begin: "'", end: "'",
    illegal: "\\n", contains: [O]
  }, N = {
    scope: "string", begin: '"', end: '"', illegal: "\\n",
    contains: [O]
  }, M = (e, t, n = {}) => {
    const i = s({
      scope: "comment", begin: e, end: t,
      contains: []
    }, n); i.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 = p("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 i.contains.push({ begin: f(/[ ]+/, "(", r, /[.]?[:]?([.][ ]|[ ])/, "){3}") }), i
  }, S = M("//", "$"), R = M("/\\*", "\\*/"), j = M("#", "$"); var A = Object.freeze({
    __proto__: null, MATCH_NOTHING_RE: /\b\B/, IDENT_RE: x, UNDERSCORE_IDENT_RE: w,
    NUMBER_RE: y, C_NUMBER_RE: _, BINARY_NUMBER_RE: v,
    RE_STARTERS_RE: "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",
    SHEBANG: (e = {}) => {
      const t = /^#![ ]*\//
        ; return e.binary && (e.begin = f(t, /.*\b/, e.binary, /\b.*/)), s({
          scope: "meta", begin: t,
          end: /$/, relevance: 0, "on:begin": (e, t) => { 0 !== e.index && t.ignoreMatch() }
        }, e)
    },
    BACKSLASH_ESCAPE: O, APOS_STRING_MODE: k, QUOTE_STRING_MODE: N, 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/
    }, COMMENT: M, C_LINE_COMMENT_MODE: S, C_BLOCK_COMMENT_MODE: R, HASH_COMMENT_MODE: j,
    NUMBER_MODE: { scope: "number", begin: y, relevance: 0 }, C_NUMBER_MODE: {
      scope: "number",
      begin: _, relevance: 0
    }, BINARY_NUMBER_MODE: { scope: "number", begin: v, relevance: 0 },
    REGEXP_MODE: {
      begin: /(?=\/[^/\n]*\/)/, contains: [{
        scope: "regexp", begin: /\//,
        end: /\/[gimuy]*/, illegal: /\n/, contains: [O, {
          begin: /\[/, end: /\]/, relevance: 0,
          contains: [O]
        }]
      }]
    }, TITLE_MODE: { scope: "title", begin: x, relevance: 0 },
    UNDERSCORE_TITLE_MODE: { scope: "title", begin: w, relevance: 0 }, METHOD_GUARD: {
      begin: "\\.\\s*[a-zA-Z_]\\w*", relevance: 0
    }, 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()
      }
    })
  }); function I(e, t) {
    "." === e.input[e.index - 1] && t.ignoreMatch()
  } function T(e, t) {
    void 0 !== e.className && (e.scope = e.className, delete e.className)
  } function L(e, t) {
    t && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)",
      e.__beforeBegin = I, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords,
      void 0 === e.relevance && (e.relevance = 0))
  } function B(e, t) {
    Array.isArray(e.illegal) && (e.illegal = p(...e.illegal))
  } function D(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 H = (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 = f(n.beforeMatch, d(n.begin)), e.starts = {
          relevance: 0, contains: [Object.assign(n, { endsParent: !0 })]
        }, e.relevance = 0, delete n.beforeMatch
  }, C = ["of", "and", "for", "in", "not", "or", "if", "then", "parent", "list", "value"]
    ; function $(e, t, n = "keyword") {
      const i = Object.create(null)
        ; return "string" == typeof e ? r(n, e.split(" ")) : Array.isArray(e) ? r(n, e) : Object.keys(e).forEach((n => {
          Object.assign(i, $(e[n], t, n))
        })), i; function r(e, n) {
          t && (n = n.map((e => e.toLowerCase()))), n.forEach((t => {
            const n = t.split("|")
              ; i[n[0]] = [e, U(n[0], n[1])]
          }))
        }
    } function U(e, t) {
      return t ? Number(t) : (e => C.includes(e.toLowerCase()))(e) ? 0 : 1
    } const z = {}, K = e => {
      console.error(e)
    }, W = (e, ...t) => { console.log("WARN: " + e, ...t) }, X = (e, t) => {
      z[`${e}/${t}`] || (console.log(`Deprecated as of ${e}. ${t}`), z[`${e}/${t}`] = !0)
    }, G = Error(); function Z(e, t, { key: n }) {
      let i = 0; const r = e[n], s = {}, o = {}
        ; for (let e = 1; e <= t.length; e++)o[e + i] = r[e], s[e + i] = !0, i += b(t[e - 1])
          ; e[n] = o, e[n]._emit = s, 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 K("skip, excludeBegin, returnBegin not compatible with beginScope: {}"),
            G
            ; if ("object" != typeof e.beginScope || null === e.beginScope) throw K("beginScope must be object"),
              G; Z(e, e.begin, { key: "beginScope" }), e.begin = E(e.begin, { joinWith: "" })
        }
      })(e), (e => {
        if (Array.isArray(e.end)) {
          if (e.skip || e.excludeEnd || e.returnEnd) throw K("skip, excludeEnd, returnEnd not compatible with endScope: {}"),
            G
            ; if ("object" != typeof e.endScope || null === e.endScope) throw K("endScope must be object"),
              G; Z(e, e.end, { key: "endScope" }), e.end = E(e.end, { joinWith: "" })
        }
      })(e)
    } function V(e) {
      function t(t, n) {
        return RegExp(g(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 += b(e) + 1
        } compile() {
          0 === this.regexes.length && (this.exec = () => null)
            ; const e = this.regexes.map((e => e[1])); this.matcherRe = t(E(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 i {
        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 = s(e.classNameAliases || {}), function n(r, o) {
          const a = r
            ; if (r.isCompiled) return a
              ;[T, D, F, H].forEach((e => e(r, o))), e.compilerExtensions.forEach((e => e(r, o))),
                r.__beforeBegin = null, [L, B, 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 = $(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 = g(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 => s(e, {
                variants: null
              }, t)))), e.cachedVariants ? e.cachedVariants : q(e) ? s(e, {
                starts: e.starts ? s(e.starts) : null
              }) : Object.isFrozen(e) ? s(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 i
                  ; 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 q(e) {
      return !!e && (e.endsWithParent || q(e.starts))
    } class J extends Error {
    constructor(e, t) { super(e), this.name = "HTMLInjectionError", this.html = t }
  }
  const Y = r, Q = s, ee = Symbol("nomatch"); var te = (e => {
    const t = Object.create(null), r = Object.create(null), s = []; let o = !0
      ; const a = "Could not find the language '{}', did you forget to load/include a language module?", c = {
        disableAutodetect: !0, name: "Plain text", contains: []
      }; let g = {
        ignoreUnescapedHTML: !1, throwUnescapedHTML: !1, noHighlightRe: /^(no-?highlight)$/i,
        languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i, classPrefix: "hljs-",
        cssSelector: "pre code", languages: null, __emitter: l
      }; function b(e) {
        return g.noHighlightRe.test(e)
      } function m(e, t, n) {
        let i = "", r = ""
          ; "object" == typeof t ? (i = e,
            n = t.ignoreIllegals, r = 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"),
              r = e, i = t), void 0 === n && (n = !0); const s = { code: i, language: r }; N("before:highlight", s)
          ; const o = s.result ? s.result : E(s.language, s.code, n)
          ; return o.code = s.code, N("after:highlight", o), o
      } function E(e, n, r, s) {
        const c = Object.create(null); function l() {
          if (!k.keywords) return void M.addText(S)
            ; let e = 0; k.keywordPatternRe.lastIndex = 0; let t = k.keywordPatternRe.exec(S), n = ""
            ; for (; t;) {
              n += S.substring(e, t.index)
                ; const r = y.case_insensitive ? t[0].toLowerCase() : t[0], s = (i = r, k.keywords[i]); if (s) {
                  const [e, i] = s
                    ; if (M.addText(n), n = "", c[r] = (c[r] || 0) + 1, c[r] <= 7 && (R += i), e.startsWith("_")) n += t[0]; else {
                      const n = y.classNameAliases[e] || e; M.addKeyword(t[0], n)
                    }
                } else n += t[0]
                ; e = k.keywordPatternRe.lastIndex, t = k.keywordPatternRe.exec(S)
            } var i
            ; n += S.substr(e), M.addText(n)
        } function d() {
          null != k.subLanguage ? (() => {
            if ("" === S) return; let e = null; if ("string" == typeof k.subLanguage) {
              if (!t[k.subLanguage]) return void M.addText(S)
                ; e = E(k.subLanguage, S, !0, N[k.subLanguage]), N[k.subLanguage] = e._top
            } else e = x(S, k.subLanguage.length ? k.subLanguage : null)
              ; k.relevance > 0 && (R += e.relevance), M.addSublanguage(e._emitter, e.language)
          })() : l(), S = ""
        } function u(e, t) {
          let n = 1; for (; void 0 !== t[n];) {
            if (!e._emit[n]) {
              n++
                ; continue
            } const i = y.classNameAliases[e[n]] || e[n], r = t[n]
              ; i ? M.addKeyword(r, i) : (S = r, l(), S = ""), n++
          }
        } function h(e, t) {
          return e.scope && "string" == typeof e.scope && M.openNode(y.classNameAliases[e.scope] || e.scope),
            e.beginScope && (e.beginScope._wrap ? (M.addKeyword(S, y.classNameAliases[e.beginScope._wrap] || e.beginScope._wrap),
              S = "") : e.beginScope._multi && (u(e.beginScope, t), S = "")), k = Object.create(e, {
                parent: {
                  value: k
                }
              }), k
        } function f(e, t, n) {
          let r = ((e, t) => {
            const n = e && e.exec(t)
              ; return n && 0 === n.index
          })(e.endRe, n); if (r) {
            if (e["on:end"]) {
              const n = new i(e)
                ; e["on:end"](t, n), n.isMatchIgnored && (r = !1)
            } if (r) {
              for (; e.endsParent && e.parent;)e = e.parent; return e
            }
          }
          if (e.endsWithParent) return f(e.parent, t, n)
        } function p(e) {
          return 0 === k.matcher.regexIndex ? (S += e[0], 1) : (I = !0, 0)
        } function b(e) {
          const t = e[0], i = n.substr(e.index), r = f(k, e, i); if (!r) return ee; const s = k
            ; k.endScope && k.endScope._wrap ? (d(),
              M.addKeyword(t, k.endScope._wrap)) : k.endScope && k.endScope._multi ? (d(),
                u(k.endScope, e)) : s.skip ? S += t : (s.returnEnd || s.excludeEnd || (S += t),
                  d(), s.excludeEnd && (S = t)); do {
                    k.scope && M.closeNode(), k.skip || k.subLanguage || (R += k.relevance), k = k.parent
                  } while (k !== r.parent); return r.starts && h(r.starts, e), s.returnEnd ? 0 : t.length
        }
        let m = {}; function w(t, s) {
          const a = s && s[0]; if (S += t, null == a) return d(), 0
            ; if ("begin" === m.type && "end" === s.type && m.index === s.index && "" === a) {
              if (S += n.slice(s.index, s.index + 1), !o) {
                const t = Error(`0 width match regex (${e})`)
                  ; throw t.languageName = e, t.badRule = m.rule, t
              } return 1
            }
          if (m = s, "begin" === s.type) return (e => {
            const t = e[0], n = e.rule, r = new i(n), s = [n.__beforeBegin, n["on:begin"]]
              ; for (const n of s) if (n && (n(e, r), r.isMatchIgnored)) return p(t)
                ; return n.skip ? S += t : (n.excludeBegin && (S += t),
                  d(), n.returnBegin || n.excludeBegin || (S = t)), h(n, e), n.returnBegin ? 0 : t.length
          })(s)
            ; if ("illegal" === s.type && !r) {
              const e = Error('Illegal lexeme "' + a + '" for mode "' + (k.scope || "<unnamed>") + '"')
                ; throw e.mode = k, e
            } if ("end" === s.type) { const e = b(s); if (e !== ee) return e }
          if ("illegal" === s.type && "" === a) return 1
            ; if (A > 1e5 && A > 3 * s.index) throw Error("potential infinite loop, way more iterations than matches")
              ; return S += a, a.length
        } const y = v(e)
          ; if (!y) throw K(a.replace("{}", e)), Error('Unknown language: "' + e + '"')
            ; const _ = V(y); let O = "", k = s || _; const N = {}, M = new g.__emitter(g); (() => {
              const e = []
                ; for (let t = k; t !== y; t = t.parent)t.scope && e.unshift(t.scope)
                  ; e.forEach((e => M.openNode(e)))
            })(); let S = "", R = 0, j = 0, A = 0, I = !1; try {
              for (k.matcher.considerAll(); ;) {
                A++, I ? I = !1 : k.matcher.considerAll(), k.matcher.lastIndex = j
                  ; const e = k.matcher.exec(n); if (!e) break; const t = w(n.substring(j, e.index), e)
                  ; j = e.index + t
              } return w(n.substr(j)), M.closeAllNodes(), M.finalize(), O = M.toHTML(), {
                language: e, value: O, relevance: R, illegal: !1, _emitter: M, _top: k
              }
            } catch (t) {
              if (t.message && t.message.includes("Illegal")) return {
                language: e, value: Y(n),
                illegal: !0, relevance: 0, _illegalBy: {
                  message: t.message, index: j,
                  context: n.slice(j - 100, j + 100), mode: t.mode, resultSoFar: O
                }, _emitter: M
              }; if (o) return {
                language: e, value: Y(n), illegal: !1, relevance: 0, errorRaised: t, _emitter: M, _top: k
              }
                ; throw t
            }
      } function x(e, n) {
        n = n || g.languages || Object.keys(t); const i = (e => {
          const t = { value: Y(e), illegal: !1, relevance: 0, _top: c, _emitter: new g.__emitter(g) }
            ; return t._emitter.addText(e), t
        })(e), r = n.filter(v).filter(k).map((t => E(t, e, !1)))
          ; r.unshift(i); const s = r.sort(((e, t) => {
            if (e.relevance !== t.relevance) return t.relevance - e.relevance
              ; if (e.language && t.language) {
                if (v(e.language).supersetOf === t.language) return 1
                  ; if (v(t.language).supersetOf === e.language) return -1
              } return 0
          })), [o, a] = s, l = o
          ; return l.secondBest = a, l
      } function w(e) {
        let t = null; const n = (e => {
          let t = e.className + " "; t += e.parentNode ? e.parentNode.className : ""
            ; const n = g.languageDetectRe.exec(t); if (n) {
              const t = v(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) || v(e)))
        })(e); if (b(n)) return
          ; if (N("before:highlightElement", {
            el: e, language: n
          }), e.children.length > 0 && (g.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/issues/2886"),
            console.warn(e)),
            g.throwUnescapedHTML)) throw new J("One of your code blocks includes unescaped HTML.", e.innerHTML)
          ; t = e; const i = t.textContent, s = n ? m(i, { language: n, ignoreIllegals: !0 }) : x(i)
          ; e.innerHTML = s.value, ((e, t, n) => {
            const i = t && r[t] || n
              ; e.classList.add("hljs"), e.classList.add("language-" + i)
          })(e, n, s.language), e.result = {
            language: s.language, re: s.relevance,
            relevance: s.relevance
          }, s.secondBest && (e.secondBest = {
            language: s.secondBest.language, relevance: s.secondBest.relevance
          }), N("after:highlightElement", { el: e, result: s, text: i })
      } let y = !1; function _() {
        "loading" !== document.readyState ? document.querySelectorAll(g.cssSelector).forEach(w) : y = !0
      } function v(e) { return e = (e || "").toLowerCase(), t[e] || t[r[e]] }
    function O(e, { languageName: t }) {
      "string" == typeof e && (e = [e]), e.forEach((e => {
        r[e.toLowerCase()] = t
      }))
    } function k(e) {
      const t = v(e)
        ; return t && !t.disableAutodetect
    } function N(e, t) {
      const n = e; s.forEach((e => {
        e[n] && e[n](t)
      }))
    }
    "undefined" != typeof window && window.addEventListener && window.addEventListener("DOMContentLoaded", (() => {
      y && _()
    }), !1), Object.assign(e, {
      highlight: m, highlightAuto: x, highlightAll: _,
      highlightElement: w,
      highlightBlock: e => (X("10.7.0", "highlightBlock will be removed entirely in v12.0"),
        X("10.7.0", "Please use highlightElement now."), w(e)), configure: e => { g = Q(g, e) },
      initHighlighting: () => {
        _(), X("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.")
      },
      initHighlightingOnLoad: () => {
        _(), X("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.")
      }, registerLanguage: (n, i) => {
        let r = null; try { r = i(e) } catch (e) {
          if (K("Language definition for '{}' could not be registered.".replace("{}", n)),
            !o) throw e; K(e), r = c
        }
        r.name || (r.name = n), t[n] = r, r.rawDefinition = i.bind(null, e), r.aliases && O(r.aliases, {
          languageName: n
        })
      }, unregisterLanguage: e => {
        delete t[e]
          ; for (const t of Object.keys(r)) r[t] === e && delete r[t]
      },
      listLanguages: () => Object.keys(t), getLanguage: v, registerAliases: O,
      autoDetection: k, inherit: Q, 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), s.push(e)
      }
    }), e.debugMode = () => { o = !1 }, e.safeMode = () => {
      o = !0
    }, e.versionString = "11.3.1", e.regex = {
      concat: f, lookahead: d, either: p, optional: h,
      anyNumberOfTimes: u
    }; for (const e in A) "object" == typeof A[e] && n(A[e])
      ; return Object.assign(e, A), e
  })({}); return te
}()
  ; "object" == typeof exports && "undefined" != typeof module && (module.exports = hljs);/*! `css` grammar compiled for Highlight.js 11.3.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", "p", "q", "quote", "samp", "section", "span", "strong", "summary", "sup", "table", "tbody", "td", "textarea", "tfoot", "th", "thead", "time", "tr", "ul", "var", "video"], t = ["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"], i = ["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"], o = ["after", "backdrop", "before", "cue", "cue-region", "first-letter", "first-line", "grammar-error", "marker", "part", "placeholder", "selection", "slotted", "spelling-error"], r = ["align-content", "align-items", "align-self", "all", "animation", "animation-delay", "animation-direction", "animation-duration", "animation-fill-mode", "animation-iteration-count", "animation-name", "animation-play-state", "animation-timing-function", "backface-visibility", "background", "background-attachment", "background-clip", "background-color", "background-image", "background-origin", "background-position", "background-repeat", "background-size", "border", "border-bottom", "border-bottom-color", "border-bottom-left-radius", "border-bottom-right-radius", "border-bottom-style", "border-bottom-width", "border-collapse", "border-color", "border-image", "border-image-outset", "border-image-repeat", "border-image-slice", "border-image-source", "border-image-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-style", "border-top", "border-top-color", "border-top-left-radius", "border-top-right-radius", "border-top-style", "border-top-width", "border-width", "bottom", "box-decoration-break", "box-shadow", "box-sizing", "break-after", "break-before", "break-inside", "caption-side", "caret-color", "clear", "clip", "clip-path", "clip-rule", "color", "column-count", "column-fill", "column-gap", "column-rule", "column-rule-color", "column-rule-style", "column-rule-width", "column-span", "column-width", "columns", "contain", "content", "content-visibility", "counter-increment", "counter-reset", "cue", "cue-after", "cue-before", "cursor", "direction", "display", "empty-cells", "filter", "flex", "flex-basis", "flex-direction", "flex-flow", "flex-grow", "flex-shrink", "flex-wrap", "float", "flow", "font", "font-display", "font-family", "font-feature-settings", "font-kerning", "font-language-override", "font-size", "font-size-adjust", "font-smoothing", "font-stretch", "font-style", "font-synthesis", "font-variant", "font-variant-caps", "font-variant-east-asian", "font-variant-ligatures", "font-variant-numeric", "font-variant-position", "font-variation-settings", "font-weight", "gap", "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", "hyphens", "icon", "image-orientation", "image-rendering", "image-resolution", "ime-mode", "isolation", "justify-content", "left", "letter-spacing", "line-break", "line-height", "list-style", "list-style-image", "list-style-position", "list-style-type", "margin", "margin-bottom", "margin-left", "margin-right", "margin-top", "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", "max-height", "max-width", "min-height", "min-width", "mix-blend-mode", "nav-down", "nav-index", "nav-left", "nav-right", "nav-up", "none", "normal", "object-fit", "object-position", "opacity", "order", "orphans", "outline", "outline-color", "outline-offset", "outline-style", "outline-width", "overflow", "overflow-wrap", "overflow-x", "overflow-y", "padding", "padding-bottom", "padding-left", "padding-right", "padding-top", "page-break-after", "page-break-before", "page-break-inside", "pause", "pause-after", "pause-before", "perspective", "perspective-origin", "pointer-events", "position", "quotes", "resize", "rest", "rest-after", "rest-before", "right", "row-gap", "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", "shape-image-threshold", "shape-margin", "shape-outside", "speak", "speak-as", "src", "tab-size", "table-layout", "text-align", "text-align-all", "text-align-last", "text-combine-upright", "text-decoration", "text-decoration-color", "text-decoration-line", "text-decoration-style", "text-emphasis", "text-emphasis-color", "text-emphasis-position", "text-emphasis-style", "text-indent", "text-justify", "text-orientation", "text-overflow", "text-rendering", "text-shadow", "text-transform", "text-underline-position", "top", "transform", "transform-box", "transform-origin", "transform-style", "transition", "transition-delay", "transition-duration", "transition-property", "transition-timing-function", "unicode-bidi", "vertical-align", "visibility", "voice-balance", "voice-duration", "voice-family", "voice-pitch", "voice-range", "voice-rate", "voice-stress", "voice-volume", "white-space", "widows", "width", "will-change", "word-break", "word-spacing", "word-wrap", "writing-mode", "z-index"].reverse()
      ; return a => {
        const n = a.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_-]*/ }
        }))(a), s = [a.APOS_STRING_MODE, a.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: ":(" + i.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: [{ className: "string", begin: /[^)]/, endsWithParent: !0, excludeEnd: !0 }]
            }, l.FUNCTION_DISPATCH]
          }, {
            begin: n.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: t.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.3.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"], 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", "module", "global"], i = [].concat(r, t, s)
      ; return o => {
        const l = o.regex, b = e, d = {
          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()), (s = e.input.substr(a).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 = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", E = {
          className: "number", variants: [{
            begin: `(\\b(${m})((${u})|\\.)?|(${u}))[eE][+-]?([0-9](_?[0-9])*)\\b`
          }, {
            begin: `\\b(${m})\\b((${u})\\b|\\.)?|(${u})\\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
        }, A = {
          className: "subst", begin: "\\$\\{",
          end: "\\}", keywords: g, contains: []
        }, y = {
          begin: "html`", end: "", starts: {
            end: "`",
            returnEnd: !1, contains: [o.BACKSLASH_ESCAPE, A], subLanguage: "xml"
          }
        }, N = {
          begin: "css`", end: "", starts: {
            end: "`", returnEnd: !1,
            contains: [o.BACKSLASH_ESCAPE, A], subLanguage: "css"
          }
        }, _ = {
          className: "string",
          begin: "`", end: "`", contains: [o.BACKSLASH_ESCAPE, A]
        }, f = {
          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: b + "(?=\\s*(-)|$)",
                endsParent: !0, relevance: 0
              }, { begin: /(?=[^\n])\s/, relevance: 0 }]
            }]
          }), o.C_BLOCK_COMMENT_MODE, o.C_LINE_COMMENT_MODE]
        }, h = [o.APOS_STRING_MODE, o.QUOTE_STRING_MODE, y, N, _, E]; A.contains = h.concat({
          begin: /\{/, end: /\}/, keywords: g, contains: ["self"].concat(h)
        })
          ; const v = [].concat(f, A.contains), p = v.concat([{
            begin: /\(/, end: /\)/, keywords: g,
            contains: ["self"].concat(v)
          }]), S = {
            className: "params", begin: /\(/, end: /\)/,
            excludeBegin: !0, excludeEnd: !0, keywords: g, contains: p
          }, w = {
            variants: [{
              match: [/class/, /\s+/, b, /\s+/, /extends/, /\s+/, l.concat(b, "(", l.concat(/\./, b), ")*")],
              scope: { 1: "keyword", 3: "title.class", 5: "keyword", 7: "title.class.inherited" }
            }, {
              match: [/class/, /\s+/, b], scope: { 1: "keyword", 3: "title.class" }
            }]
          }, R = {
            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)+/),
            className: "title.class", keywords: { _: [...t, ...s] }
          }, O = {
            variants: [{
              match: [/function/, /\s+/, b, /(?=\s*\()/]
            }, { match: [/function/, /\s*(?=\()/] }],
            className: { 1: "keyword", 3: "title.function" }, label: "func.def", contains: [S],
            illegal: /%/
          }, I = {
            match: l.concat(/\b/, (k = [...r, "super"], l.concat("(?!", k.join("|"), ")")), b, l.lookahead(/\(/)),
            className: "title.function", relevance: 0
          }; var k; const x = {
            begin: l.concat(/\./, l.lookahead(l.concat(b, /(?![0-9A-Za-z$_(])/))), end: b,
            excludeBegin: !0, keywords: "prototype", className: "property", relevance: 0
          }, T = {
            match: [/get|set/, /\s+/, b, /(?=\()/], className: { 1: "keyword", 3: "title.function" },
            contains: [{ begin: /\(\)/ }, S]
          }, C = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + o.UNDERSCORE_IDENT_RE + ")\\s*=>", M = {
            match: [/const|var|let/, /\s+/, b, /\s*/, /=\s*/, l.lookahead(C)], className: {
              1: "keyword", 3: "title.function"
            }, contains: [S]
          }; return {
            name: "Javascript",
            aliases: ["js", "jsx", "mjs", "cjs"], keywords: g, exports: {
              PARAMS_CONTAINS: p,
              CLASS_REFERENCE: R
            }, 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, y, N, _, f, E, R, {
              className: "attr",
              begin: b + l.lookahead(":"), relevance: 0
            }, M, {
              begin: "(" + o.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
              keywords: "return throw case", relevance: 0, contains: [f, o.REGEXP_MODE, {
                className: "function", begin: C, returnBegin: !0, end: "\\s*=>", contains: [{
                  className: "params", variants: [{ begin: o.UNDERSCORE_IDENT_RE, relevance: 0 }, {
                    className: null, begin: /\(\s*\)/, skip: !0
                  }, {
                    begin: /\(/, end: /\)/, excludeBegin: !0,
                    excludeEnd: !0, keywords: g, contains: p
                  }]
                }]
              }, { begin: /,/, relevance: 0 }, {
                  match: /\s+/,
                  relevance: 0
                }, {
                  variants: [{ begin: "<>", end: "</>" }, {
                    match: /<[A-Za-z0-9\\._:-]+\s*\/>/
                  }, {
                    begin: d.begin,
                    "on:begin": d.isTrulyOpeningTag, end: d.end
                  }], subLanguage: "xml", contains: [{
                    begin: d.begin, end: d.end, skip: !0, contains: ["self"]
                  }]
                }]
            }, O, {
              beginKeywords: "while if switch catch for"
            }, {
              begin: "\\b(?!function)" + o.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
              returnBegin: !0, label: "func.def", contains: [S, o.inherit(o.TITLE_MODE, {
                begin: b,
                className: "title.function"
              })]
            }, { match: /\.\.\./, relevance: 0 }, x, {
              match: "\\$" + b,
              relevance: 0
            }, {
              match: [/\bconstructor(?=\s*\()/], className: { 1: "title.function" },
              contains: [S]
            }, I, {
              relevance: 0, match: /\b[A-Z][A-Z_0-9]+\b/,
              className: "variable.constant"
            }, w, T, { match: /\$[(.]/ }]
          }
      }
  })()
    ; hljs.registerLanguage("javascript", e)
})();/*! `bash` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const s = e.regex, t = {}, n = {
        begin: /\$\{/,
        end: /\}/, contains: ["self", { begin: /:-/, contains: [t] }]
      }; Object.assign(t, {
        className: "variable", variants: [{
          begin: s.concat(/\$[\w\d#@][\w\d_]*/, "(?![\\w\\d])(?![$])")
        }, n]
      }); const a = {
        className: "subst", begin: /\$\(/, end: /\)/, contains: [e.BACKSLASH_ESCAPE]
      }, i = {
        begin: /<<-?\s*(?=\w+)/, starts: {
          contains: [e.END_SAME_AS_BEGIN({
            begin: /(\w+)/,
            end: /(\w+)/, className: "string"
          })]
        }
      }, c = {
        className: "string", begin: /"/, end: /"/,
        contains: [e.BACKSLASH_ESCAPE, t, a]
      }; a.contains.push(c); const o = {
        begin: /\$\(\(/,
        end: /\)\)/, contains: [{ begin: /\d+#[0-9a-f]+/, className: "number" }, e.NUMBER_MODE, t]
      }, r = e.SHEBANG({
        binary: "(fish|bash|zsh|sh|csh|ksh|tcsh|dash|scsh)", relevance: 10
      }), l = {
        className: "function", begin: /\w[\w\d_]*\s*\(\s*\)\s*\{/, returnBegin: !0,
        contains: [e.inherit(e.TITLE_MODE, { begin: /\w[\w\d_]*/ })], relevance: 0
      }; return {
        name: "Bash", aliases: ["sh"], keywords: {
          $pattern: /\b[a-z._-]+\b/,
          keyword: ["if", "then", "else", "elif", "fi", "for", "while", "in", "do", "done", "case", "esac", "function"],
          literal: ["true", "false"],
          built_in: ["break", "cd", "continue", "eval", "exec", "exit", "export", "getopts", "hash", "pwd", "readonly", "return", "shift", "test", "times", "trap", "umask", "unset", "alias", "bind", "builtin", "caller", "command", "declare", "echo", "enable", "help", "let", "local", "logout", "mapfile", "printf", "read", "readarray", "source", "type", "typeset", "ulimit", "unalias", "set", "shopt", "autoload", "bg", "bindkey", "bye", "cap", "chdir", "clone", "comparguments", "compcall", "compctl", "compdescribe", "compfiles", "compgroups", "compquote", "comptags", "comptry", "compvalues", "dirs", "disable", "disown", "echotc", "echoti", "emulate", "fc", "fg", "float", "functions", "getcap", "getln", "history", "integer", "jobs", "kill", "limit", "log", "noglob", "popd", "print", "pushd", "pushln", "rehash", "sched", "setcap", "setopt", "stat", "suspend", "ttyctl", "unfunction", "unhash", "unlimit", "unsetopt", "vared", "wait", "whence", "where", "which", "zcompile", "zformat", "zftp", "zle", "zmodload", "zparseopts", "zprof", "zpty", "zregexparse", "zsocket", "zstyle", "ztcp", "chcon", "chgrp", "chown", "chmod", "cp", "dd", "df", "dir", "dircolors", "ln", "ls", "mkdir", "mkfifo", "mknod", "mktemp", "mv", "realpath", "rm", "rmdir", "shred", "sync", "touch", "truncate", "vdir", "b2sum", "base32", "base64", "cat", "cksum", "comm", "csplit", "cut", "expand", "fmt", "fold", "head", "join", "md5sum", "nl", "numfmt", "od", "paste", "ptx", "pr", "sha1sum", "sha224sum", "sha256sum", "sha384sum", "sha512sum", "shuf", "sort", "split", "sum", "tac", "tail", "tr", "tsort", "unexpand", "uniq", "wc", "arch", "basename", "chroot", "date", "dirname", "du", "echo", "env", "expr", "factor", "groups", "hostid", "id", "link", "logname", "nice", "nohup", "nproc", "pathchk", "pinky", "printenv", "printf", "pwd", "readlink", "runcon", "seq", "sleep", "stat", "stdbuf", "stty", "tee", "test", "timeout", "tty", "uname", "unlink", "uptime", "users", "who", "whoami", "yes"]
        }, contains: [r, e.SHEBANG(), l, o, e.HASH_COMMENT_MODE, i, { match: /(\/[a-z._-]+)+/ }, c, {
          className: "", begin: /\\"/
        }, { className: "string", begin: /'/, end: /'/ }, t]
      }
    }
  })()
    ; hljs.registerLanguage("bash", e)
})();/*! `vbnet` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const n = e.regex, t = /\d{1,2}\/\d{1,2}\/\d{4}/, a = /\d{4}-\d{1,2}-\d{1,2}/, i = /(\d|1[012])(:\d+){0,2} *(AM|PM)/, s = /\d{1,2}(:\d{1,2}){1,2}/, r = {
        className: "literal", variants: [{ begin: n.concat(/# */, n.either(a, t), / *#/) }, {
          begin: n.concat(/# */, s, / *#/)
        }, { begin: n.concat(/# */, i, / *#/) }, {
          begin: n.concat(/# */, n.either(a, t), / +/, n.either(i, s), / *#/)
        }]
      }, l = e.COMMENT(/'''/, /$/, {
        contains: [{ className: "doctag", begin: /<\/?/, end: />/ }]
      }), o = e.COMMENT(null, /$/, { variants: [{ begin: /'/ }, { begin: /([\t ]|^)REM(?=\s)/ }] })
        ; return {
          name: "Visual Basic .NET", aliases: ["vb"], case_insensitive: !0,
          classNameAliases: { label: "symbol" }, keywords: {
            keyword: "addhandler alias aggregate ansi as async assembly auto binary by byref byval call case catch class compare const continue custom declare default delegate dim distinct do each equals else elseif end enum erase error event exit explicit finally for friend from function get global goto group handles if implements imports in inherits interface into iterator join key let lib loop me mid module mustinherit mustoverride mybase myclass namespace narrowing new next notinheritable notoverridable of off on operator option optional order overloads overridable overrides paramarray partial preserve private property protected public raiseevent readonly redim removehandler resume return select set shadows shared skip static step stop structure strict sub synclock take text then throw to try unicode until using when where while widening with withevents writeonly yield",
            built_in: "addressof and andalso await directcast gettype getxmlnamespace is isfalse isnot istrue like mod nameof new not or orelse trycast typeof xor cbool cbyte cchar cdate cdbl cdec cint clng cobj csbyte cshort csng cstr cuint culng cushort",
            type: "boolean byte char date decimal double integer long object sbyte short single string uinteger ulong ushort",
            literal: "true false nothing"
          },
          illegal: "//|\\{|\\}|endif|gosub|variant|wend|^\\$ ", contains: [{
            className: "string", begin: /"(""|[^/n])"C\b/
          }, {
            className: "string", begin: /"/,
            end: /"/, illegal: /\n/, contains: [{ begin: /""/ }]
          }, r, {
            className: "number", relevance: 0,
            variants: [{
              begin: /\b\d[\d_]*((\.[\d_]+(E[+-]?[\d_]+)?)|(E[+-]?[\d_]+))[RFD@!#]?/
            }, { begin: /\b\d[\d_]*((U?[SIL])|[%&])?/ }, { begin: /&H[\dA-F_]+((U?[SIL])|[%&])?/ }, {
              begin: /&O[0-7_]+((U?[SIL])|[%&])?/
            }, { begin: /&B[01_]+((U?[SIL])|[%&])?/ }]
          }, {
            className: "label", begin: /^\w+:/
          }, l, o, {
            className: "meta",
            begin: /[\t ]*#(const|disable|else|elseif|enable|end|externalsource|if|region)\b/,
            end: /$/, keywords: {
              keyword: "const disable else elseif enable end externalsource if region then"
            },
            contains: [o]
          }]
        }
    }
  })(); hljs.registerLanguage("vbnet", e)
})();/*! `java` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"
      ; var e = "\\.([0-9](_*[0-9])*)", a = "[0-9a-fA-F](_*[0-9a-fA-F])*", n = {
        className: "number", variants: [{
          begin: `(\\b([0-9](_*[0-9])*)((${e})|\\.)?|(${e}))[eE][+-]?([0-9](_*[0-9])*)[fFdD]?\\b`
        }, { begin: `\\b([0-9](_*[0-9])*)((${e})[fFdD]?\\b|\\.([fFdD]\\b)?)` }, {
          begin: `(${e})[fFdD]?\\b`
        }, { begin: "\\b([0-9](_*[0-9])*)[fFdD]\\b" }, {
          begin: `\\b0[xX]((${a})\\.?|(${a})?\\.(${a}))[pP][+-]?([0-9](_*[0-9])*)[fFdD]?\\b`
        }, { begin: "\\b(0|[1-9](_*[0-9])*)[lL]?\\b" }, { begin: `\\b0[xX](${a})[lL]?\\b` }, {
          begin: "\\b0(_*[0-7])*[lL]?\\b"
        }, { begin: "\\b0[bB][01](_*[01])*[lL]?\\b" }],
        relevance: 0
      }; function s(e, a, n) { return -1 === n ? "" : e.replace(a, (t => s(e, a, n - 1))) }
    return e => {
      e.regex
        ; const a = "[\xc0-\u02b8a-zA-Z_$][\xc0-\u02b8a-zA-Z_$0-9]*", t = a + s("(?:<" + a + "~~~(?:\\s*,\\s*" + a + "~~~)*>)?", /~~~/g, 2), i = {
          keyword: ["synchronized", "abstract", "private", "var", "static", "if", "const ", "for", "while", "strictfp", "finally", "protected", "import", "native", "final", "void", "enum", "else", "break", "transient", "catch", "instanceof", "volatile", "case", "assert", "package", "default", "public", "try", "switch", "continue", "throws", "protected", "public", "private", "module", "requires", "exports", "do"],
          literal: ["false", "true", "null"],
          type: ["char", "boolean", "long", "float", "int", "byte", "short", "double"],
          built_in: ["super", "this"]
        }, r = {
          className: "meta", begin: "@" + a, contains: [{
            begin: /\(/, end: /\)/, contains: ["self"]
          }]
        }, l = {
          className: "params", begin: /\(/,
          end: /\)/, keywords: i, relevance: 0, contains: [e.C_BLOCK_COMMENT_MODE], endsParent: !0
        }
        ; return {
          name: "Java", aliases: ["jsp"], keywords: i, illegal: /<\/|#/,
          contains: [e.COMMENT("/\\*\\*", "\\*/", {
            relevance: 0, contains: [{
              begin: /\w+@/,
              relevance: 0
            }, { className: "doctag", begin: "@[A-Za-z]+" }]
          }), {
            begin: /import java\.[a-z]+\./, keywords: "import", relevance: 2
          }, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE, {
            begin: /"""/, end: /"""/,
            className: "string", contains: [e.BACKSLASH_ESCAPE]
          }, e.APOS_STRING_MODE, e.QUOTE_STRING_MODE, {
            match: [/\b(?:class|interface|enum|extends|implements|new)/, /\s+/, a], className: {
              1: "keyword", 3: "title.class"
            }
          }, {
            begin: [a, /\s+/, a, /\s+/, /=/], className: {
              1: "type",
              3: "variable", 5: "operator"
            }
          }, {
            begin: [/record/, /\s+/, a], className: {
              1: "keyword",
              3: "title.class"
            }, contains: [l, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE]
          }, {
            beginKeywords: "new throw return else", relevance: 0
          }, {
            begin: ["(?:" + t + "\\s+)", e.UNDERSCORE_IDENT_RE, /\s*(?=\()/], className: {
              2: "title.function"
            }, keywords: i, contains: [{
              className: "params", begin: /\(/,
              end: /\)/, keywords: i, relevance: 0,
              contains: [r, e.APOS_STRING_MODE, e.QUOTE_STRING_MODE, n, e.C_BLOCK_COMMENT_MODE]
            }, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE]
          }, n, r]
        }
    }
  })()
    ; hljs.registerLanguage("java", e)
})();/*! `python` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const n = e.regex, a = /[\p{XID_Start}_]\p{XID_Continue}*/u, i = {
        $pattern: /[A-Za-z]\w+|__\w+__/,
        keyword: ["and", "as", "assert", "async", "await", "break", "class", "continue", "def", "del", "elif", "else", "except", "finally", "for", "from", "global", "if", "import", "in", "is", "lambda", "nonlocal|10", "not", "or", "pass", "raise", "return", "try", "while", "with", "yield"],
        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"]
      }, s = { className: "meta", begin: /^(>>>|\.\.\.) / }, t = {
        className: "subst", begin: /\{/,
        end: /\}/, keywords: i, illegal: /#/
      }, r = { begin: /\{\{/, relevance: 0 }, l = {
        className: "string", contains: [e.BACKSLASH_ESCAPE], variants: [{
          begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/, end: /'''/,
          contains: [e.BACKSLASH_ESCAPE, s], relevance: 10
        }, {
          begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/, end: /"""/,
          contains: [e.BACKSLASH_ESCAPE, s], relevance: 10
        }, {
          begin: /([fF][rR]|[rR][fF]|[fF])'''/, end: /'''/,
          contains: [e.BACKSLASH_ESCAPE, s, r, t]
        }, {
          begin: /([fF][rR]|[rR][fF]|[fF])"""/,
          end: /"""/, contains: [e.BACKSLASH_ESCAPE, s, r, t]
        }, {
          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, r, t]
        }, {
          begin: /([fF][rR]|[rR][fF]|[fF])"/, end: /"/,
          contains: [e.BACKSLASH_ESCAPE, r, t]
        }, e.APOS_STRING_MODE, e.QUOTE_STRING_MODE]
      }, b = "[0-9](_?[0-9])*", o = `(\\b(${b}))?\\.(${b})|\\b(${b})\\.`, c = {
        className: "number", relevance: 0, variants: [{
          begin: `(\\b(${b})|(${o}))[eE][+-]?(${b})[jJ]?\\b`
        }, { begin: `(${o})[jJ]?` }, {
          begin: "\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?\\b"
        }, {
          begin: "\\b0[bB](_?[01])+[lL]?\\b"
        }, { begin: "\\b0[oO](_?[0-7])+[lL]?\\b" }, {
          begin: "\\b0[xX](_?[0-9a-fA-F])+[lL]?\\b"
        }, { begin: `\\b(${b})[jJ]\\b` }]
      }, d = {
        className: "comment", begin: n.lookahead(/# type:/), end: /$/, keywords: i, contains: [{
          begin: /# type:/
        }, { begin: /#/, end: /\b\B/, endsWithParent: !0 }]
      }, g = {
        className: "params", variants: [{ className: "", begin: /\(\s*\)/, skip: !0 }, {
          begin: /\(/,
          end: /\)/, excludeBegin: !0, excludeEnd: !0, keywords: i,
          contains: ["self", s, c, l, e.HASH_COMMENT_MODE]
        }]
      }; return t.contains = [l, c, s], {
        name: "Python", aliases: ["py", "gyp", "ipython"], unicodeRegex: !0, keywords: i,
        illegal: /(<\/|->|\?)|=>/, contains: [s, c, { begin: /\bself\b/ }, {
          beginKeywords: "if",
          relevance: 0
        }, l, d, e.HASH_COMMENT_MODE, {
            match: [/def/, /\s+/, a], scope: {
              1: "keyword",
              3: "title.function"
            }, contains: [g]
          }, {
            variants: [{
              match: [/class/, /\s+/, a, /\s*/, /\(\s*/, a, /\s*\)/]
            }, { match: [/class/, /\s+/, a] }],
            scope: { 1: "keyword", 3: "title.class", 6: "title.class.inherited" }
          }, {
            className: "meta", begin: /^[\t ]*@/, end: /(?=#)|$/, contains: [c, g, l]
          }]
      }
    }
  })()
    ; hljs.registerLanguage("python", e)
})();/*! `makefile` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const i = {
        className: "variable",
        variants: [{
          begin: "\\$\\(" + e.UNDERSCORE_IDENT_RE + "\\)",
          contains: [e.BACKSLASH_ESCAPE]
        }, { begin: /\$[@%<?\^\+\*]/ }]
      }, a = {
        className: "string",
        begin: /"/, end: /"/, contains: [e.BACKSLASH_ESCAPE, i]
      }, n = {
        className: "variable",
        begin: /\$\([\w-]+\s/, end: /\)/, keywords: {
          built_in: "subst patsubst strip findstring filter filter-out sort word wordlist firstword lastword dir notdir suffix basename addsuffix addprefix join wildcard realpath abspath error warning shell origin flavor foreach if or and call eval file value"
        }, contains: [i]
      }, s = { begin: "^" + e.UNDERSCORE_IDENT_RE + "\\s*(?=[:+?]?=)" }, r = {
        className: "section", begin: /^[^\s]+:/, end: /$/, contains: [i]
      }; return {
        name: "Makefile", aliases: ["mk", "mak", "make"], keywords: {
          $pattern: /[\w-]+/,
          keyword: "define endef undefine ifdef ifndef ifeq ifneq else endif include -include sinclude override export unexport private vpath"
        }, contains: [e.HASH_COMMENT_MODE, i, a, n, s, {
          className: "meta", begin: /^\.PHONY:/,
          end: /$/, keywords: { $pattern: /[\.\w]+/, keyword: ".PHONY" }
        }, r]
      }
    }
  })()
    ; hljs.registerLanguage("makefile", e)
})();/*! `r` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const a = e.regex, n = /(?:(?:[a-zA-Z]|\.[._a-zA-Z])[._a-zA-Z0-9]*)|\.(?!\d)/, i = a.either(/0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*[pP][+-]?\d+i?/, /0[xX][0-9a-fA-F]+(?:[pP][+-]?\d+)?[Li]?/, /(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?[Li]?/), s = /[=!<>:]=|\|\||&&|:::?|<-|<<-|->>|->|\|>|[-+*\/?!$&|:<=>@^~]|\*\*/, t = a.either(/[()]/, /[{}]/, /\[\[/, /[[\]]/, /\\/, /,/)
        ; return {
          name: "R", keywords: {
            $pattern: n,
            keyword: "function if in break next repeat else for while",
            literal: "NULL NA TRUE FALSE Inf NaN NA_integer_|10 NA_real_|10 NA_character_|10 NA_complex_|10",
            built_in: "LETTERS letters month.abb month.name pi T F abs acos acosh all any anyNA Arg as.call as.character as.complex as.double as.environment as.integer as.logical as.null.default as.numeric as.raw asin asinh atan atanh attr attributes baseenv browser c call ceiling class Conj cos cosh cospi cummax cummin cumprod cumsum digamma dim dimnames emptyenv exp expression floor forceAndCall gamma gc.time globalenv Im interactive invisible is.array is.atomic is.call is.character is.complex is.double is.environment is.expression is.finite is.function is.infinite is.integer is.language is.list is.logical is.matrix is.na is.name is.nan is.null is.numeric is.object is.pairlist is.raw is.recursive is.single is.symbol lazyLoadDBfetch length lgamma list log max min missing Mod names nargs nzchar oldClass on.exit pos.to.env proc.time prod quote range Re rep retracemem return round seq_along seq_len seq.int sign signif sin sinh sinpi sqrt standardGeneric substitute sum switch tan tanh tanpi tracemem trigamma trunc unclass untracemem UseMethod xtfrm"
          }, contains: [e.COMMENT(/#'/, /$/, {
            contains: [{
              scope: "doctag", match: /@examples/,
              starts: {
                end: a.lookahead(a.either(/\n^#'\s*(?=@[a-zA-Z]+)/, /\n^(?!#')/)),
                endsParent: !0
              }
            }, {
              scope: "doctag", begin: "@param", end: /$/, contains: [{
                scope: "variable", variants: [{ match: n }, { match: /`(?:\\.|[^`\\])+`/ }], endsParent: !0
              }]
            }, { scope: "doctag", match: /@[a-zA-Z]+/ }, { scope: "keyword", match: /\\[a-zA-Z]+/ }]
          }), e.HASH_COMMENT_MODE, {
            scope: "string", contains: [e.BACKSLASH_ESCAPE],
            variants: [e.END_SAME_AS_BEGIN({
              begin: /[rR]"(-*)\(/, end: /\)(-*)"/
            }), e.END_SAME_AS_BEGIN({
              begin: /[rR]"(-*)\{/, end: /\}(-*)"/
            }), e.END_SAME_AS_BEGIN({
              begin: /[rR]"(-*)\[/, end: /\](-*)"/
            }), e.END_SAME_AS_BEGIN({
              begin: /[rR]'(-*)\(/, end: /\)(-*)'/
            }), e.END_SAME_AS_BEGIN({
              begin: /[rR]'(-*)\{/, end: /\}(-*)'/
            }), e.END_SAME_AS_BEGIN({ begin: /[rR]'(-*)\[/, end: /\](-*)'/ }), {
              begin: '"', end: '"',
              relevance: 0
            }, { begin: "'", end: "'", relevance: 0 }]
          }, {
            relevance: 0, variants: [{
              scope: {
                1: "operator", 2: "number"
              }, match: [s, i]
            }, {
              scope: { 1: "operator", 2: "number" },
              match: [/%[^%]*%/, i]
            }, { scope: { 1: "punctuation", 2: "number" }, match: [t, i] }, {
              scope: {
                2: "number"
              }, match: [/[^a-zA-Z0-9._]|^/, i]
            }]
          }, {
            scope: { 3: "operator" },
            match: [n, /\s+/, /<-/, /\s+/]
          }, {
            scope: "operator", relevance: 0, variants: [{ match: s }, {
              match: /%[^%]*%/
            }]
          }, { scope: "punctuation", relevance: 0, match: t }, {
            begin: "`", end: "`",
            contains: [{ begin: /\\./ }]
          }]
        }
    }
  })(); hljs.registerLanguage("r", e)
})();/*! `diff` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const a = e.regex; return {
        name: "Diff",
        aliases: ["patch"], contains: [{
          className: "meta", relevance: 10,
          match: a.either(/^@@ +-\d+,\d+ +\+\d+,\d+ +@@/, /^\*\*\* +\d+,\d+ +\*\*\*\*$/, /^--- +\d+,\d+ +----$/)
        }, {
          className: "comment", variants: [{
            begin: a.either(/Index: /, /^index/, /={3,}/, /^-{3}/, /^\*{3} /, /^\+{3}/, /^diff --git/),
            end: /$/
          }, { match: /^\*{15}$/ }]
        }, { className: "addition", begin: /^\+/, end: /$/ }, {
          className: "deletion", begin: /^-/, end: /$/
        }, {
          className: "addition", begin: /^!/,
          end: /$/
        }]
      }
    }
  })(); hljs.registerLanguage("diff", e)
})();/*! `less` grammar compiled for Highlight.js 11.3.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", "p", "q", "quote", "samp", "section", "span", "strong", "summary", "sup", "table", "tbody", "td", "textarea", "tfoot", "th", "thead", "time", "tr", "ul", "var", "video"], t = ["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"], i = ["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"], r = ["after", "backdrop", "before", "cue", "cue-region", "first-letter", "first-line", "grammar-error", "marker", "part", "placeholder", "selection", "slotted", "spelling-error"], o = ["align-content", "align-items", "align-self", "all", "animation", "animation-delay", "animation-direction", "animation-duration", "animation-fill-mode", "animation-iteration-count", "animation-name", "animation-play-state", "animation-timing-function", "backface-visibility", "background", "background-attachment", "background-clip", "background-color", "background-image", "background-origin", "background-position", "background-repeat", "background-size", "border", "border-bottom", "border-bottom-color", "border-bottom-left-radius", "border-bottom-right-radius", "border-bottom-style", "border-bottom-width", "border-collapse", "border-color", "border-image", "border-image-outset", "border-image-repeat", "border-image-slice", "border-image-source", "border-image-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-style", "border-top", "border-top-color", "border-top-left-radius", "border-top-right-radius", "border-top-style", "border-top-width", "border-width", "bottom", "box-decoration-break", "box-shadow", "box-sizing", "break-after", "break-before", "break-inside", "caption-side", "caret-color", "clear", "clip", "clip-path", "clip-rule", "color", "column-count", "column-fill", "column-gap", "column-rule", "column-rule-color", "column-rule-style", "column-rule-width", "column-span", "column-width", "columns", "contain", "content", "content-visibility", "counter-increment", "counter-reset", "cue", "cue-after", "cue-before", "cursor", "direction", "display", "empty-cells", "filter", "flex", "flex-basis", "flex-direction", "flex-flow", "flex-grow", "flex-shrink", "flex-wrap", "float", "flow", "font", "font-display", "font-family", "font-feature-settings", "font-kerning", "font-language-override", "font-size", "font-size-adjust", "font-smoothing", "font-stretch", "font-style", "font-synthesis", "font-variant", "font-variant-caps", "font-variant-east-asian", "font-variant-ligatures", "font-variant-numeric", "font-variant-position", "font-variation-settings", "font-weight", "gap", "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", "hyphens", "icon", "image-orientation", "image-rendering", "image-resolution", "ime-mode", "isolation", "justify-content", "left", "letter-spacing", "line-break", "line-height", "list-style", "list-style-image", "list-style-position", "list-style-type", "margin", "margin-bottom", "margin-left", "margin-right", "margin-top", "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", "max-height", "max-width", "min-height", "min-width", "mix-blend-mode", "nav-down", "nav-index", "nav-left", "nav-right", "nav-up", "none", "normal", "object-fit", "object-position", "opacity", "order", "orphans", "outline", "outline-color", "outline-offset", "outline-style", "outline-width", "overflow", "overflow-wrap", "overflow-x", "overflow-y", "padding", "padding-bottom", "padding-left", "padding-right", "padding-top", "page-break-after", "page-break-before", "page-break-inside", "pause", "pause-after", "pause-before", "perspective", "perspective-origin", "pointer-events", "position", "quotes", "resize", "rest", "rest-after", "rest-before", "right", "row-gap", "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", "shape-image-threshold", "shape-margin", "shape-outside", "speak", "speak-as", "src", "tab-size", "table-layout", "text-align", "text-align-all", "text-align-last", "text-combine-upright", "text-decoration", "text-decoration-color", "text-decoration-line", "text-decoration-style", "text-emphasis", "text-emphasis-color", "text-emphasis-position", "text-emphasis-style", "text-indent", "text-justify", "text-orientation", "text-overflow", "text-rendering", "text-shadow", "text-transform", "text-underline-position", "top", "transform", "transform-box", "transform-origin", "transform-style", "transition", "transition-delay", "transition-duration", "transition-property", "transition-timing-function", "unicode-bidi", "vertical-align", "visibility", "voice-balance", "voice-duration", "voice-family", "voice-pitch", "voice-range", "voice-rate", "voice-stress", "voice-volume", "white-space", "widows", "width", "will-change", "word-break", "word-spacing", "word-wrap", "writing-mode", "z-index"].reverse(), n = i.concat(r)
      ; return a => {
        const s = (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_-]*/ }
        }))(a), l = n, d = "([\\w-]+|@\\{[\\w-]+\\})", c = [], g = [], m = e => ({
          className: "string",
          begin: "~?" + e + ".*?" + e
        }), p = (e, t, i) => ({ className: e, begin: t, relevance: i }), b = {
          $pattern: /[a-z-]+/, keyword: "and or not only", attribute: t.join(" ")
        }, u = {
          begin: "\\(", end: "\\)", contains: g, keywords: b, relevance: 0
        }
          ; g.push(a.C_LINE_COMMENT_MODE, a.C_BLOCK_COMMENT_MODE, m("'"), m('"'), s.CSS_NUMBER_MODE, {
            begin: "(url|data-uri)\\(", starts: {
              className: "string", end: "[\\)\\n]",
              excludeEnd: !0
            }
          }, s.HEXCOLOR, u, p("variable", "@@?[\\w-]+", 10), p("variable", "@\\{[\\w-]+\\}"), p("built_in", "~?`[^`]*?`"), {
            className: "attribute", begin: "[\\w-]+\\s*:", end: ":", returnBegin: !0, excludeEnd: !0
          }, s.IMPORTANT); const h = g.concat({ begin: /\{/, end: /\}/, contains: c }), f = {
            beginKeywords: "when", endsWithParent: !0, contains: [{
              beginKeywords: "and not"
            }].concat(g)
          }, v = {
            begin: d + "\\s*:", returnBegin: !0, end: /[;}]/, relevance: 0,
            contains: [{ begin: /-(webkit|moz|ms|o)-/ }, s.CSS_VARIABLE, {
              className: "attribute",
              begin: "\\b(" + o.join("|") + ")\\b", end: /(?=:)/, starts: {
                endsWithParent: !0,
                illegal: "[<=$]", relevance: 0, contains: g
              }
            }]
          }, w = {
            className: "keyword",
            begin: "@(import|media|charset|font-face|(-[a-z]+-)?keyframes|supports|document|namespace|page|viewport|host)\\b",
            starts: { end: "[;{}]", keywords: b, returnEnd: !0, contains: g, relevance: 0 }
          }, k = {
            className: "variable", variants: [{ begin: "@[\\w-]+\\s*:", relevance: 15 }, {
              begin: "@[\\w-]+"
            }], starts: { end: "[;}]", returnEnd: !0, contains: h }
          }, y = {
            variants: [{
              begin: "[\\.#:&\\[>]", end: "[;{}]"
            }, { begin: d, end: /\{/ }], returnBegin: !0,
            returnEnd: !0, illegal: "[<='$\"]", relevance: 0,
            contains: [a.C_LINE_COMMENT_MODE, a.C_BLOCK_COMMENT_MODE, f, p("keyword", "all\\b"), p("variable", "@\\{[\\w-]+\\}"), {
              begin: "\\b(" + e.join("|") + ")\\b", className: "selector-tag"
            }, s.CSS_NUMBER_MODE, p("selector-tag", d, 0), p("selector-id", "#" + d), p("selector-class", "\\." + d, 0), p("selector-tag", "&", 0), s.ATTRIBUTE_SELECTOR_MODE, {
              className: "selector-pseudo", begin: ":(" + i.join("|") + ")"
            }, {
              className: "selector-pseudo", begin: ":(:)?(" + r.join("|") + ")"
            }, {
              begin: /\(/,
              end: /\)/, relevance: 0, contains: h
            }, { begin: "!important" }, s.FUNCTION_DISPATCH]
          }, x = {
            begin: `[\\w-]+:(:)?(${l.join("|")})`, returnBegin: !0, contains: [y]
          }
          ; return c.push(a.C_LINE_COMMENT_MODE, a.C_BLOCK_COMMENT_MODE, w, k, x, v, y), {
            name: "Less", case_insensitive: !0, illegal: "[=>'/<($\"]", contains: c
          }
      }
  })()
    ; hljs.registerLanguage("less", e)
})();/*! `swift` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; function e(e) {
      return e ? "string" == typeof e ? e : e.source : null
    } function a(e) { return t("(?=", e, ")") }
    function t(...a) { return a.map((a => e(a))).join("") } function n(...a) {
      const t = (e => {
        const a = e[e.length - 1]
          ; return "object" == typeof a && a.constructor === Object ? (e.splice(e.length - 1, 1), a) : {}
      })(a); return "(" + (t.capture ? "" : "?:") + a.map((a => e(a))).join("|") + ")"
    }
    const i = e => t(/\b/, e, /\w$/.test(e) ? /\b/ : /\B/), s = ["Protocol", "Type"].map(i), u = ["init", "self"].map(i), c = ["Any", "Self"], r = ["actor", "associatedtype", "async", "await", /as\?/, /as!/, "as", "break", "case", "catch", "class", "continue", "convenience", "default", "defer", "deinit", "didSet", "do", "dynamic", "else", "enum", "extension", "fallthrough", /fileprivate\(set\)/, "fileprivate", "final", "for", "func", "get", "guard", "if", "import", "indirect", "infix", /init\?/, /init!/, "inout", /internal\(set\)/, "internal", "in", "is", "isolated", "nonisolated", "lazy", "let", "mutating", "nonmutating", /open\(set\)/, "open", "operator", "optional", "override", "postfix", "precedencegroup", "prefix", /private\(set\)/, "private", "protocol", /public\(set\)/, "public", "repeat", "required", "rethrows", "return", "set", "some", "static", "struct", "subscript", "super", "switch", "throws", "throw", /try\?/, /try!/, "try", "typealias", /unowned\(safe\)/, /unowned\(unsafe\)/, "unowned", "var", "weak", "where", "while", "willSet"], o = ["false", "nil", "true"], l = ["assignment", "associativity", "higherThan", "left", "lowerThan", "none", "right"], m = ["#colorLiteral", "#column", "#dsohandle", "#else", "#elseif", "#endif", "#error", "#file", "#fileID", "#fileLiteral", "#filePath", "#function", "#if", "#imageLiteral", "#keyPath", "#line", "#selector", "#sourceLocation", "#warn_unqualified_access", "#warning"], p = ["abs", "all", "any", "assert", "assertionFailure", "debugPrint", "dump", "fatalError", "getVaList", "isKnownUniquelyReferenced", "max", "min", "numericCast", "pointwiseMax", "pointwiseMin", "precondition", "preconditionFailure", "print", "readLine", "repeatElement", "sequence", "stride", "swap", "swift_unboxFromSwiftValueWithType", "transcode", "type", "unsafeBitCast", "unsafeDowncast", "withExtendedLifetime", "withUnsafeMutablePointer", "withUnsafePointer", "withVaList", "withoutActuallyEscaping", "zip"], d = n(/[/=\-+!*%<>&|^~?]/, /[\u00A1-\u00A7]/, /[\u00A9\u00AB]/, /[\u00AC\u00AE]/, /[\u00B0\u00B1]/, /[\u00B6\u00BB\u00BF\u00D7\u00F7]/, /[\u2016-\u2017]/, /[\u2020-\u2027]/, /[\u2030-\u203E]/, /[\u2041-\u2053]/, /[\u2055-\u205E]/, /[\u2190-\u23FF]/, /[\u2500-\u2775]/, /[\u2794-\u2BFF]/, /[\u2E00-\u2E7F]/, /[\u3001-\u3003]/, /[\u3008-\u3020]/, /[\u3030]/), F = n(d, /[\u0300-\u036F]/, /[\u1DC0-\u1DFF]/, /[\u20D0-\u20FF]/, /[\uFE00-\uFE0F]/, /[\uFE20-\uFE2F]/), b = t(d, F, "*"), h = n(/[a-zA-Z_]/, /[\u00A8\u00AA\u00AD\u00AF\u00B2-\u00B5\u00B7-\u00BA]/, /[\u00BC-\u00BE\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF]/, /[\u0100-\u02FF\u0370-\u167F\u1681-\u180D\u180F-\u1DBF]/, /[\u1E00-\u1FFF]/, /[\u200B-\u200D\u202A-\u202E\u203F-\u2040\u2054\u2060-\u206F]/, /[\u2070-\u20CF\u2100-\u218F\u2460-\u24FF\u2776-\u2793]/, /[\u2C00-\u2DFF\u2E80-\u2FFF]/, /[\u3004-\u3007\u3021-\u302F\u3031-\u303F\u3040-\uD7FF]/, /[\uF900-\uFD3D\uFD40-\uFDCF\uFDF0-\uFE1F\uFE30-\uFE44]/, /[\uFE47-\uFEFE\uFF00-\uFFFD]/), f = n(h, /\d/, /[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/), w = t(h, f, "*"), y = t(/[A-Z]/, f, "*"), g = ["autoclosure", t(/convention\(/, n("swift", "block", "c"), /\)/), "discardableResult", "dynamicCallable", "dynamicMemberLookup", "escaping", "frozen", "GKInspectable", "IBAction", "IBDesignable", "IBInspectable", "IBOutlet", "IBSegueAction", "inlinable", "main", "nonobjc", "NSApplicationMain", "NSCopying", "NSManaged", t(/objc\(/, w, /\)/), "objc", "objcMembers", "propertyWrapper", "requires_stored_property_inits", "resultBuilder", "testable", "UIApplicationMain", "unknown", "usableFromInline"], E = ["iOS", "iOSApplicationExtension", "macOS", "macOSApplicationExtension", "macCatalyst", "macCatalystApplicationExtension", "watchOS", "watchOSApplicationExtension", "tvOS", "tvOSApplicationExtension", "swift"]
      ; return e => {
        const d = { match: /\s+/, relevance: 0 }, h = e.COMMENT("/\\*", "\\*/", {
          contains: ["self"]
        }), v = [e.C_LINE_COMMENT_MODE, h], A = {
          match: [/\./, n(...s, ...u)],
          className: { 2: "keyword" }
        }, N = {
          match: t(/\./, n(...r)), relevance: 0
        }, C = r.filter((e => "string" == typeof e)).concat(["_|0"]), D = {
          variants: [{
            className: "keyword",
            match: n(...r.filter((e => "string" != typeof e)).concat(c).map(i), ...u)
          }]
        }, k = {
          $pattern: n(/\b\w+/, /#\w+/), keyword: C.concat(m), literal: o
        }, B = [A, N, D], _ = [{
          match: t(/\./, n(...p)), relevance: 0
        }, {
          className: "built_in",
          match: t(/\b/, n(...p), /(?=\()/)
        }], S = { match: /->/, relevance: 0 }, M = [S, {
          className: "operator", relevance: 0, variants: [{ match: b }, { match: `\\.(\\.|${F})+` }]
        }], x = "([0-9a-fA-F]_*)+", I = {
          className: "number", relevance: 0, variants: [{
            match: "\\b(([0-9]_*)+)(\\.(([0-9]_*)+))?([eE][+-]?(([0-9]_*)+))?\\b"
          }, {
            match: `\\b0x(${x})(\\.(${x}))?([pP][+-]?(([0-9]_*)+))?\\b`
          }, {
            match: /\b0o([0-7]_*)+\b/
          }, { match: /\b0b([01]_*)+\b/ }]
        }, L = (e = "") => ({
          className: "subst", variants: [{ match: t(/\\/, e, /[0\\tnr"']/) }, {
            match: t(/\\/, e, /u\{[0-9a-fA-F]{1,8}\}/)
          }]
        }), O = (e = "") => ({
          className: "subst",
          match: t(/\\/, e, /[\t ]*(?:[\r\n]|\r\n)/)
        }), T = (e = "") => ({
          className: "subst",
          label: "interpol", begin: t(/\\/, e, /\(/), end: /\)/
        }), $ = (e = "") => ({
          begin: t(e, /"""/),
          end: t(/"""/, e), contains: [L(e), O(e), T(e)]
        }), j = (e = "") => ({
          begin: t(e, /"/),
          end: t(/"/, e), contains: [L(e), T(e)]
        }), P = {
          className: "string",
          variants: [$(), $("#"), $("##"), $("###"), j(), j("#"), j("##"), j("###")]
        }, K = {
          match: t(/`/, w, /`/)
        }, z = [K, { className: "variable", match: /\$\d+/ }, {
          className: "variable", match: `\\$${f}+`
        }], q = [{
          match: /(@|#)available/,
          className: "keyword", starts: {
            contains: [{
              begin: /\(/, end: /\)/, keywords: E,
              contains: [...M, I, P]
            }]
          }
        }, { className: "keyword", match: t(/@/, n(...g)) }, {
          className: "meta", match: t(/@/, w)
        }], U = {
          match: a(/\b[A-Z]/), relevance: 0, contains: [{
            className: "type",
            match: t(/(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)/, f, "+")
          }, { className: "type", match: y, relevance: 0 }, { match: /[?!]+/, relevance: 0 }, {
            match: /\.\.\./, relevance: 0
          }, { match: t(/\s+&\s+/, a(y)), relevance: 0 }]
        }, Z = {
          begin: /</, end: />/, keywords: k, contains: [...v, ...B, ...q, S, U]
        }; U.contains.push(Z)
          ; const V = {
            begin: /\(/, end: /\)/, relevance: 0, keywords: k, contains: ["self", {
              match: t(w, /\s*:/), keywords: "_|0", relevance: 0
            }, ...v, ...B, ..._, ...M, I, P, ...z, ...q, U]
          }, W = {
            begin: /</, end: />/, contains: [...v, U]
          }, G = {
            begin: /\(/, end: /\)/, keywords: k, contains: [{
              begin: n(a(t(w, /\s*:/)), a(t(w, /\s+/, w, /\s*:/))), end: /:/, relevance: 0, contains: [{
                className: "keyword", match: /\b_\b/
              }, { className: "params", match: w }]
            }, ...v, ...B, ...M, I, P, ...q, U, V], endsParent: !0, illegal: /["']/
          }, R = {
            match: [/func/, /\s+/, n(K.match, w, b)], className: { 1: "keyword", 3: "title.function" },
            contains: [W, G, d], illegal: [/\[/, /%/]
          }, X = {
            match: [/\b(?:subscript|init[?!]?)/, /\s*(?=[<(])/], className: { 1: "keyword" },
            contains: [W, G, d], illegal: /\[|%/
          }, H = {
            match: [/operator/, /\s+/, b], className: {
              1: "keyword", 3: "title"
            }
          }, J = {
            begin: [/precedencegroup/, /\s+/, y], className: {
              1: "keyword", 3: "title"
            }, contains: [U], keywords: [...l, ...o], end: /}/
          }
          ; for (const e of P.variants) {
            const a = e.contains.find((e => "interpol" === e.label))
              ; a.keywords = k; const t = [...B, ..._, ...M, I, P, ...z]; a.contains = [...t, {
                begin: /\(/,
                end: /\)/, contains: ["self", ...t]
              }]
          } return {
            name: "Swift", keywords: k,
            contains: [...v, R, X, {
              beginKeywords: "struct protocol class extension enum actor",
              end: "\\{", excludeEnd: !0, keywords: k, contains: [e.inherit(e.TITLE_MODE, {
                className: "title.class", begin: /[A-Za-z$_][\u00C0-\u02B80-9A-Za-z$_]*/
              }), ...B]
            }, H, J, {
              beginKeywords: "import", end: /$/, contains: [...v], relevance: 0
            }, ...B, ..._, ...M, I, P, ...z, ...q, U, V]
          }
      }
  })(); hljs.registerLanguage("swift", e)
})();/*! `go` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const n = {
        keyword: ["break", "case", "chan", "const", "continue", "default", "defer", "else", "fallthrough", "for", "func", "go", "goto", "if", "import", "interface", "map", "package", "range", "return", "select", "struct", "switch", "type", "var"],
        type: ["bool", "byte", "complex64", "complex128", "error", "float32", "float64", "int8", "int16", "int32", "int64", "string", "uint8", "uint16", "uint32", "uint64", "int", "uint", "uintptr", "rune"],
        literal: ["true", "false", "iota", "nil"],
        built_in: ["append", "cap", "close", "complex", "copy", "imag", "len", "make", "new", "panic", "print", "println", "real", "recover", "delete"]
      }; return {
        name: "Go", aliases: ["golang"], keywords: n, illegal: "</",
        contains: [e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE, {
          className: "string",
          variants: [e.QUOTE_STRING_MODE, e.APOS_STRING_MODE, { begin: "`", end: "`" }]
        }, {
          className: "number", variants: [{
            begin: e.C_NUMBER_RE + "[i]", relevance: 1
          }, e.C_NUMBER_MODE]
        }, { begin: /:=/ }, {
          className: "function", beginKeywords: "func",
          end: "\\s*(\\{|$)", excludeEnd: !0, contains: [e.TITLE_MODE, {
            className: "params",
            begin: /\(/, end: /\)/, endsParent: !0, keywords: n, illegal: /["']/
          }]
        }]
      }
    }
  })()
    ; hljs.registerLanguage("go", e)
})();/*! `kotlin` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"
      ; var e = "\\.([0-9](_*[0-9])*)", n = "[0-9a-fA-F](_*[0-9a-fA-F])*", a = {
        className: "number", variants: [{
          begin: `(\\b([0-9](_*[0-9])*)((${e})|\\.)?|(${e}))[eE][+-]?([0-9](_*[0-9])*)[fFdD]?\\b`
        }, { begin: `\\b([0-9](_*[0-9])*)((${e})[fFdD]?\\b|\\.([fFdD]\\b)?)` }, {
          begin: `(${e})[fFdD]?\\b`
        }, { begin: "\\b([0-9](_*[0-9])*)[fFdD]\\b" }, {
          begin: `\\b0[xX]((${n})\\.?|(${n})?\\.(${n}))[pP][+-]?([0-9](_*[0-9])*)[fFdD]?\\b`
        }, { begin: "\\b(0|[1-9](_*[0-9])*)[lL]?\\b" }, { begin: `\\b0[xX](${n})[lL]?\\b` }, {
          begin: "\\b0(_*[0-7])*[lL]?\\b"
        }, { begin: "\\b0[bB][01](_*[01])*[lL]?\\b" }],
        relevance: 0
      }; return e => {
        const n = {
          keyword: "abstract as val var vararg get set class object open private protected public noinline crossinline dynamic final enum if else do while for when throw try catch finally import package is in fun override companion reified inline lateinit init interface annotation data sealed internal infix operator out by constructor super tailrec where const inner suspend typealias external expect actual",
          built_in: "Byte Short Char Int Long Boolean Float Double Void Unit Nothing",
          literal: "true false null"
        }, i = {
          className: "symbol", begin: e.UNDERSCORE_IDENT_RE + "@"
        }, s = { className: "subst", begin: /\$\{/, end: /\}/, contains: [e.C_NUMBER_MODE] }, t = {
          className: "variable", begin: "\\$" + e.UNDERSCORE_IDENT_RE
        }, r = {
          className: "string",
          variants: [{ begin: '"""', end: '"""(?=[^"])', contains: [t, s] }, {
            begin: "'", end: "'",
            illegal: /\n/, contains: [e.BACKSLASH_ESCAPE]
          }, {
            begin: '"', end: '"', illegal: /\n/,
            contains: [e.BACKSLASH_ESCAPE, t, s]
          }]
        }; s.contains.push(r); const l = {
          className: "meta",
          begin: "@(?:file|property|field|get|set|receiver|param|setparam|delegate)\\s*:(?:\\s*" + e.UNDERSCORE_IDENT_RE + ")?"
        }, c = {
          className: "meta", begin: "@" + e.UNDERSCORE_IDENT_RE, contains: [{
            begin: /\(/,
            end: /\)/, contains: [e.inherit(r, { className: "string" })]
          }]
        }, o = a, b = e.COMMENT("/\\*", "\\*/", { contains: [e.C_BLOCK_COMMENT_MODE] }), E = {
          variants: [{ className: "type", begin: e.UNDERSCORE_IDENT_RE }, {
            begin: /\(/, end: /\)/,
            contains: []
          }]
        }, d = E; return d.variants[1].contains = [E], E.variants[1].contains = [d],
        {
          name: "Kotlin", aliases: ["kt", "kts"], keywords: n,
          contains: [e.COMMENT("/\\*\\*", "\\*/", {
            relevance: 0, contains: [{
              className: "doctag",
              begin: "@[A-Za-z]+"
            }]
          }), e.C_LINE_COMMENT_MODE, b, {
            className: "keyword",
            begin: /\b(break|continue|return|this)\b/, starts: {
              contains: [{
                className: "symbol",
                begin: /@\w+/
              }]
            }
          }, i, l, c, {
            className: "function", beginKeywords: "fun", end: "[(]|$",
            returnBegin: !0, excludeEnd: !0, keywords: n, relevance: 5, contains: [{
              begin: e.UNDERSCORE_IDENT_RE + "\\s*\\(", returnBegin: !0, relevance: 0,
              contains: [e.UNDERSCORE_TITLE_MODE]
            }, {
              className: "type", begin: /</, end: />/,
              keywords: "reified", relevance: 0
            }, {
              className: "params", begin: /\(/, end: /\)/,
              endsParent: !0, keywords: n, relevance: 0, contains: [{
                begin: /:/, end: /[=,\/]/,
                endsWithParent: !0, contains: [E, e.C_LINE_COMMENT_MODE, b], relevance: 0
              }, e.C_LINE_COMMENT_MODE, b, l, c, r, e.C_NUMBER_MODE]
            }, b]
          }, {
            className: "class",
            beginKeywords: "class interface trait", end: /[:\{(]|$/, excludeEnd: !0,
            illegal: "extends implements", contains: [{
              beginKeywords: "public protected internal private constructor"
            }, e.UNDERSCORE_TITLE_MODE, {
              className: "type", begin: /</, end: />/, excludeBegin: !0,
              excludeEnd: !0, relevance: 0
            }, {
              className: "type", begin: /[,:]\s*/, end: /[<\(,]|$/,
              excludeBegin: !0, returnEnd: !0
            }, l, c]
          }, r, {
            className: "meta", begin: "^#!/usr/bin/env",
            end: "$", illegal: "\n"
          }, o]
        }
      }
  })(); hljs.registerLanguage("kotlin", e)
})();/*! `http` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const n = "HTTP/(2|1\\.[01])", a = {
        className: "attribute",
        begin: e.regex.concat("^", /[A-Za-z][A-Za-z0-9-]*/, "(?=\\:\\s)"), starts: {
          contains: [{
            className: "punctuation", begin: /: /, relevance: 0, starts: {
              end: "$",
              relevance: 0
            }
          }]
        }
      }, s = [a, {
        begin: "\\n\\n", starts: { subLanguage: [], endsWithParent: !0 }
      }]; return {
        name: "HTTP", aliases: ["https"], illegal: /\S/, contains: [{
          begin: "^(?=" + n + " \\d{3})", end: /$/, contains: [{ className: "meta", begin: n }, {
            className: "number", begin: "\\b\\d{3}\\b"
          }], starts: {
            end: /\b\B/, illegal: /\S/,
            contains: s
          }
        }, {
          begin: "(?=^[A-Z]+ (.*?) " + n + "$)", end: /$/, contains: [{
            className: "string", begin: " ", end: " ", excludeBegin: !0, excludeEnd: !0
          }, {
            className: "meta", begin: n
          }, { className: "keyword", begin: "[A-Z]+" }], starts: {
            end: /\b\B/, illegal: /\S/, contains: s
          }
        }, e.inherit(a, { relevance: 0 })]
      }
    }
  })()
    ; hljs.registerLanguage("http", e)
})();/*! `xml` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const a = e.regex, n = a.concat(/[A-Z_]/, a.optional(/[A-Z0-9_.-]*:/), /[A-Z0-9_.-]*/), s = {
        className: "symbol", begin: /&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/
      }, t = {
        begin: /\s/,
        contains: [{ className: "keyword", begin: /#?[a-z_][a-z1-9_-]+/, illegal: /\n/ }]
      }, i = e.inherit(t, { begin: /\(/, end: /\)/ }), c = e.inherit(e.APOS_STRING_MODE, {
        className: "string"
      }), l = e.inherit(e.QUOTE_STRING_MODE, { className: "string" }), r = {
        endsWithParent: !0, illegal: /</, relevance: 0, contains: [{
          className: "attr",
          begin: /[A-Za-z0-9._:-]+/, relevance: 0
        }, {
          begin: /=\s*/, relevance: 0, contains: [{
            className: "string", endsParent: !0, variants: [{ begin: /"/, end: /"/, contains: [s] }, {
              begin: /'/, end: /'/, contains: [s]
            }, { begin: /[^\s"'=<>`]+/ }]
          }]
        }]
      }; return {
        name: "HTML, XML",
        aliases: ["html", "xhtml", "rss", "atom", "xjb", "xsd", "xsl", "plist", "wsf", "svg"],
        case_insensitive: !0, contains: [{
          className: "meta", begin: /<![a-z]/, end: />/,
          relevance: 10, contains: [t, l, c, i, {
            begin: /\[/, end: /\]/, contains: [{
              className: "meta",
              begin: /<![a-z]/, end: />/, contains: [t, i, l, c]
            }]
          }]
        }, e.COMMENT(/<!--/, /-->/, {
          relevance: 10
        }), { begin: /<!\[CDATA\[/, end: /\]\]>/, relevance: 10 }, s, {
          className: "meta", begin: /<\?xml/, end: /\?>/, relevance: 10
        }, {
          className: "tag",
          begin: /<style(?=\s|>)/, end: />/, keywords: { name: "style" }, contains: [r], starts: {
            end: /<\/style>/, returnEnd: !0, subLanguage: ["css", "xml"]
          }
        }, {
          className: "tag",
          begin: /<script(?=\s|>)/, end: />/, keywords: { name: "script" }, contains: [r], starts: {
            end: /<\/script>/, returnEnd: !0, subLanguage: ["javascript", "handlebars", "xml"]
          }
        }, {
          className: "tag", begin: /<>|<\/>/
        }, {
          className: "tag",
          begin: a.concat(/</, a.lookahead(a.concat(n, a.either(/\/>/, />/, /\s/)))),
          end: /\/?>/, contains: [{ className: "name", begin: n, relevance: 0, starts: r }]
        }, {
          className: "tag", begin: a.concat(/<\//, a.lookahead(a.concat(n, />/))), contains: [{
            className: "name", begin: n, relevance: 0
          }, { begin: />/, relevance: 0, endsParent: !0 }]
        }]
      }
    }
  })(); hljs.registerLanguage("xml", e)
})();/*! `markdown` grammar compiled for Highlight.js 11.3.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}/, end: /_{2}/ }, { begin: /\*{2}/, end: /\*{2}/ }]
      }, s = {
        className: "emphasis", contains: [], variants: [{ begin: /\*(?!\*)/, end: /\*/ }, {
          begin: /_(?!_)/, end: /_/, relevance: 0
        }]
      }; i.contains.push(s), s.contains.push(i)
        ; let c = [n, a]
        ; return i.contains = i.contains.concat(c), s.contains = s.contains.concat(c),
          c = c.concat(i, s), {
          name: "Markdown", aliases: ["md", "mkdown", "mkd"], contains: [{
            className: "section", variants: [{ begin: "^#{1,6}", end: "$", contains: c }, {
              begin: "(?=^.+?\\n[=-]{2,}$)", contains: [{ begin: "^[=-]*$" }, {
                begin: "^", end: "\\n",
                contains: c
              }]
            }]
          }, n, {
            className: "bullet", begin: "^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)",
            end: "\\s+", excludeEnd: !0
          }, i, s, {
            className: "quote", begin: "^>\\s+", contains: c,
            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
            }]
          }]
        }
    }
  })()
    ; hljs.registerLanguage("markdown", e)
})();/*! `php` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const r = {
        className: "variable",
        begin: "\\$+[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*(?![A-Za-z0-9])(?![$])"
      }, t = {
        className: "meta", variants: [{ begin: /<\?php/, relevance: 10 }, { begin: /<\?[=]?/ }, {
          begin: /\?>/
        }]
      }, a = {
        className: "subst", variants: [{ begin: /\$\w+/ }, {
          begin: /\{\$/,
          end: /\}/
        }]
      }, n = e.inherit(e.APOS_STRING_MODE, {
        illegal: null
      }), i = e.inherit(e.QUOTE_STRING_MODE, {
        illegal: null,
        contains: e.QUOTE_STRING_MODE.contains.concat(a)
      }), o = e.END_SAME_AS_BEGIN({
        begin: /<<<[ \t]*(\w+)\n/, end: /[ \t]*(\w+)\b/,
        contains: e.QUOTE_STRING_MODE.contains.concat(a)
      }), l = {
        className: "string",
        contains: [e.BACKSLASH_ESCAPE, t], variants: [e.inherit(n, {
          begin: "b'", end: "'"
        }), e.inherit(i, { begin: 'b"', end: '"' }), i, n, o]
      }, s = {
        className: "number", variants: [{
          begin: "\\b0b[01]+(?:_[01]+)*\\b"
        }, { begin: "\\b0o[0-7]+(?:_[0-7]+)*\\b" }, {
          begin: "\\b0x[\\da-f]+(?:_[\\da-f]+)*\\b"
        }, {
          begin: "(?:\\b\\d+(?:_\\d+)*(\\.(?:\\d+(?:_\\d+)*))?|\\B\\.\\d+)(?:e[+-]?\\d+)?"
        }], relevance: 0
      }, c = {
        keyword: "__CLASS__ __DIR__ __FILE__ __FUNCTION__ __LINE__ __METHOD__ __NAMESPACE__ __TRAIT__ die echo exit include include_once print require require_once array abstract and as binary bool boolean break callable case catch class clone const continue declare default do double else elseif empty enddeclare endfor endforeach endif endswitch endwhile enum eval extends final finally float for foreach from global goto if implements instanceof insteadof int integer interface isset iterable list match|0 mixed new object or private protected public real return string switch throw trait try unset use var void while xor yield",
        literal: "false null true",
        built_in: "Error|0 AppendIterator ArgumentCountError ArithmeticError ArrayIterator ArrayObject AssertionError BadFunctionCallException BadMethodCallException CachingIterator CallbackFilterIterator CompileError Countable DirectoryIterator DivisionByZeroError DomainException EmptyIterator ErrorException Exception FilesystemIterator FilterIterator GlobIterator InfiniteIterator InvalidArgumentException IteratorIterator LengthException LimitIterator LogicException MultipleIterator NoRewindIterator OutOfBoundsException OutOfRangeException OuterIterator OverflowException ParentIterator ParseError RangeException RecursiveArrayIterator RecursiveCachingIterator RecursiveCallbackFilterIterator RecursiveDirectoryIterator RecursiveFilterIterator RecursiveIterator RecursiveIteratorIterator RecursiveRegexIterator RecursiveTreeIterator RegexIterator RuntimeException SeekableIterator SplDoublyLinkedList SplFileInfo SplFileObject SplFixedArray SplHeap SplMaxHeap SplMinHeap SplObjectStorage SplObserver SplObserver SplPriorityQueue SplQueue SplStack SplSubject SplSubject SplTempFileObject TypeError UnderflowException UnexpectedValueException UnhandledMatchError ArrayAccess Closure Generator Iterator IteratorAggregate Serializable Stringable Throwable Traversable WeakReference WeakMap Directory __PHP_Incomplete_Class parent php_user_filter self static stdClass"
      }; return {
        case_insensitive: !0, keywords: c,
        contains: [e.HASH_COMMENT_MODE, e.COMMENT("//", "$", {
          contains: [t]
        }), e.COMMENT("/\\*", "\\*/", {
          contains: [{ className: "doctag", begin: "@[A-Za-z]+" }]
        }), e.COMMENT("__halt_compiler.+?;", !1, {
          endsWithParent: !0,
          keywords: "__halt_compiler"
        }), t, { className: "keyword", begin: /\$this\b/ }, r, {
          begin: /(::|->)+[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/
        }, {
          className: "function",
          relevance: 0, beginKeywords: "fn function", end: /[;{]/, excludeEnd: !0,
          illegal: "[$%\\[]", contains: [{ beginKeywords: "use" }, e.UNDERSCORE_TITLE_MODE, {
            begin: "=>", endsParent: !0
          }, {
            className: "params", begin: "\\(", end: "\\)",
            excludeBegin: !0, excludeEnd: !0, keywords: c,
            contains: ["self", r, e.C_BLOCK_COMMENT_MODE, l, s]
          }]
        }, {
          className: "class", variants: [{
            beginKeywords: "enum", illegal: /[($"]/
          }, {
            beginKeywords: "class interface trait",
            illegal: /[:($"]/
          }], relevance: 0, end: /\{/, excludeEnd: !0, contains: [{
            beginKeywords: "extends implements"
          }, e.UNDERSCORE_TITLE_MODE]
        }, {
          beginKeywords: "namespace", relevance: 0, end: ";", illegal: /[.']/,
          contains: [e.UNDERSCORE_TITLE_MODE]
        }, {
          beginKeywords: "use", relevance: 0, end: ";",
          contains: [e.UNDERSCORE_TITLE_MODE]
        }, l, s]
      }
    }
  })(); hljs.registerLanguage("php", e)
})();/*! `php-template` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var n = (() => {
    "use strict"; return n => ({
      name: "PHP template",
      subLanguage: "xml", contains: [{
        begin: /<\?(php|=)?/, end: /\?>/, subLanguage: "php",
        contains: [{ begin: "/\\*", end: "\\*/", skip: !0 }, { begin: 'b"', end: '"', skip: !0 }, {
          begin: "b'", end: "'", skip: !0
        }, n.inherit(n.APOS_STRING_MODE, {
          illegal: null,
          className: null, contains: null, skip: !0
        }), n.inherit(n.QUOTE_STRING_MODE, {
          illegal: null, className: null, contains: null, skip: !0
        })]
      }]
    })
  })()
    ; hljs.registerLanguage("php-template", n)
})();/*! `ini` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const n = e.regex, a = {
        className: "number",
        relevance: 0, variants: [{ begin: /([+-]+)?[\d]+_[\d_]+/ }, { begin: e.NUMBER_RE }]
      }, s = e.COMMENT(); s.variants = [{ begin: /;/, end: /$/ }, { begin: /#/, end: /$/ }]; const i = {
        className: "variable", variants: [{ begin: /\$[\w\d"][\w\d_]*/ }, {
          begin: /\$\{(.*?)\}/
        }]
      }, t = { className: "literal", begin: /\bon|off|true|false|yes|no\b/ }, r = {
        className: "string", contains: [e.BACKSLASH_ESCAPE], variants: [{
          begin: "'''",
          end: "'''", relevance: 10
        }, { begin: '"""', end: '"""', relevance: 10 }, {
          begin: '"', end: '"'
        }, { begin: "'", end: "'" }]
      }, l = {
        begin: /\[/, end: /\]/, contains: [s, t, i, r, a, "self"],
        relevance: 0
      }, c = n.either(/[A-Za-z0-9_-]+/, /"(\\"|[^"])*"/, /'[^']*'/); return {
        name: "TOML, also INI", aliases: ["toml"], case_insensitive: !0, illegal: /\S/,
        contains: [s, { className: "section", begin: /\[+/, end: /\]+/ }, {
          begin: n.concat(c, "(\\s*\\.\\s*", c, ")*", n.lookahead(/\s*=\s*[^#\s]/)),
          className: "attr", starts: { end: /$/, contains: [s, l, t, i, r, a] }
        }]
      }
    }
  })()
    ; hljs.registerLanguage("ini", e)
})();/*! `rust` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const t = e.regex, n = {
        className: "title.function.invoke", relevance: 0,
        begin: t.concat(/\b/, /(?!let\b)/, e.IDENT_RE, t.lookahead(/\s*\(/))
      }, a = "([ui](8|16|32|64|128|size)|f(32|64))?", i = ["drop ", "Copy", "Send", "Sized", "Sync", "Drop", "Fn", "FnMut", "FnOnce", "ToOwned", "Clone", "Debug", "PartialEq", "PartialOrd", "Eq", "Ord", "AsRef", "AsMut", "Into", "From", "Default", "Iterator", "Extend", "IntoIterator", "DoubleEndedIterator", "ExactSizeIterator", "SliceConcatExt", "ToString", "assert!", "assert_eq!", "bitflags!", "bytes!", "cfg!", "col!", "concat!", "concat_idents!", "debug_assert!", "debug_assert_eq!", "env!", "panic!", "file!", "format!", "format_args!", "include_bin!", "include_str!", "line!", "local_data_key!", "module_path!", "option_env!", "print!", "println!", "select!", "stringify!", "try!", "unimplemented!", "unreachable!", "vec!", "write!", "writeln!", "macro_rules!", "assert_ne!", "debug_assert_ne!"]
        ; return {
          name: "Rust", aliases: ["rs"], keywords: {
            $pattern: e.IDENT_RE + "!?",
            type: ["i8", "i16", "i32", "i64", "i128", "isize", "u8", "u16", "u32", "u64", "u128", "usize", "f32", "f64", "str", "char", "bool", "Box", "Option", "Result", "String", "Vec"],
            keyword: ["abstract", "as", "async", "await", "become", "box", "break", "const", "continue", "crate", "do", "dyn", "else", "enum", "extern", "false", "final", "fn", "for", "if", "impl", "in", "let", "loop", "macro", "match", "mod", "move", "mut", "override", "priv", "pub", "ref", "return", "self", "Self", "static", "struct", "super", "trait", "true", "try", "type", "typeof", "unsafe", "unsized", "use", "virtual", "where", "while", "yield"],
            literal: ["true", "false", "Some", "None", "Ok", "Err"], built_in: i
          }, illegal: "</",
          contains: [e.C_LINE_COMMENT_MODE, e.COMMENT("/\\*", "\\*/", {
            contains: ["self"]
          }), e.inherit(e.QUOTE_STRING_MODE, { begin: /b?"/, illegal: null }), {
            className: "string", variants: [{ begin: /b?r(#*)"(.|\n)*?"\1(?!#)/ }, {
              begin: /b?'\\?(x\w{2}|u\w{4}|U\w{8}|.)'/
            }]
          }, {
            className: "symbol",
            begin: /'[a-zA-Z_][a-zA-Z0-9_]*/
          }, {
            className: "number", variants: [{
              begin: "\\b0b([01_]+)" + a
            }, { begin: "\\b0o([0-7_]+)" + a }, {
              begin: "\\b0x([A-Fa-f0-9_]+)" + a
            }, {
              begin: "\\b(\\d[\\d_]*(\\.[0-9_]+)?([eE][+-]?[0-9_]+)?)" + a
            }], relevance: 0
          }, {
            begin: [/fn/, /\s+/, e.UNDERSCORE_IDENT_RE], className: {
              1: "keyword",
              3: "title.function"
            }
          }, {
            className: "meta", begin: "#!?\\[", end: "\\]", contains: [{
              className: "string", begin: /"/, end: /"/
            }]
          }, {
            begin: [/let/, /\s+/, /(?:mut\s+)?/, e.UNDERSCORE_IDENT_RE], className: {
              1: "keyword",
              3: "keyword", 4: "variable"
            }
          }, {
            begin: [/for/, /\s+/, e.UNDERSCORE_IDENT_RE, /\s+/, /in/], className: {
              1: "keyword",
              3: "variable", 5: "keyword"
            }
          }, {
            begin: [/type/, /\s+/, e.UNDERSCORE_IDENT_RE],
            className: { 1: "keyword", 3: "title.class" }
          }, {
            begin: [/(?:trait|enum|struct|union|impl|for)/, /\s+/, e.UNDERSCORE_IDENT_RE],
            className: { 1: "keyword", 3: "title.class" }
          }, {
            begin: e.IDENT_RE + "::", keywords: {
              keyword: "Self", built_in: i
            }
          }, { className: "punctuation", begin: "->" }, n]
        }
    }
  })()
    ; hljs.registerLanguage("rust", e)
})();/*! `scss` grammar compiled for Highlight.js 11.3.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", "p", "q", "quote", "samp", "section", "span", "strong", "summary", "sup", "table", "tbody", "td", "textarea", "tfoot", "th", "thead", "time", "tr", "ul", "var", "video"], t = ["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"], i = ["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"], r = ["after", "backdrop", "before", "cue", "cue-region", "first-letter", "first-line", "grammar-error", "marker", "part", "placeholder", "selection", "slotted", "spelling-error"], o = ["align-content", "align-items", "align-self", "all", "animation", "animation-delay", "animation-direction", "animation-duration", "animation-fill-mode", "animation-iteration-count", "animation-name", "animation-play-state", "animation-timing-function", "backface-visibility", "background", "background-attachment", "background-clip", "background-color", "background-image", "background-origin", "background-position", "background-repeat", "background-size", "border", "border-bottom", "border-bottom-color", "border-bottom-left-radius", "border-bottom-right-radius", "border-bottom-style", "border-bottom-width", "border-collapse", "border-color", "border-image", "border-image-outset", "border-image-repeat", "border-image-slice", "border-image-source", "border-image-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-style", "border-top", "border-top-color", "border-top-left-radius", "border-top-right-radius", "border-top-style", "border-top-width", "border-width", "bottom", "box-decoration-break", "box-shadow", "box-sizing", "break-after", "break-before", "break-inside", "caption-side", "caret-color", "clear", "clip", "clip-path", "clip-rule", "color", "column-count", "column-fill", "column-gap", "column-rule", "column-rule-color", "column-rule-style", "column-rule-width", "column-span", "column-width", "columns", "contain", "content", "content-visibility", "counter-increment", "counter-reset", "cue", "cue-after", "cue-before", "cursor", "direction", "display", "empty-cells", "filter", "flex", "flex-basis", "flex-direction", "flex-flow", "flex-grow", "flex-shrink", "flex-wrap", "float", "flow", "font", "font-display", "font-family", "font-feature-settings", "font-kerning", "font-language-override", "font-size", "font-size-adjust", "font-smoothing", "font-stretch", "font-style", "font-synthesis", "font-variant", "font-variant-caps", "font-variant-east-asian", "font-variant-ligatures", "font-variant-numeric", "font-variant-position", "font-variation-settings", "font-weight", "gap", "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", "hyphens", "icon", "image-orientation", "image-rendering", "image-resolution", "ime-mode", "isolation", "justify-content", "left", "letter-spacing", "line-break", "line-height", "list-style", "list-style-image", "list-style-position", "list-style-type", "margin", "margin-bottom", "margin-left", "margin-right", "margin-top", "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", "max-height", "max-width", "min-height", "min-width", "mix-blend-mode", "nav-down", "nav-index", "nav-left", "nav-right", "nav-up", "none", "normal", "object-fit", "object-position", "opacity", "order", "orphans", "outline", "outline-color", "outline-offset", "outline-style", "outline-width", "overflow", "overflow-wrap", "overflow-x", "overflow-y", "padding", "padding-bottom", "padding-left", "padding-right", "padding-top", "page-break-after", "page-break-before", "page-break-inside", "pause", "pause-after", "pause-before", "perspective", "perspective-origin", "pointer-events", "position", "quotes", "resize", "rest", "rest-after", "rest-before", "right", "row-gap", "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", "shape-image-threshold", "shape-margin", "shape-outside", "speak", "speak-as", "src", "tab-size", "table-layout", "text-align", "text-align-all", "text-align-last", "text-combine-upright", "text-decoration", "text-decoration-color", "text-decoration-line", "text-decoration-style", "text-emphasis", "text-emphasis-color", "text-emphasis-position", "text-emphasis-style", "text-indent", "text-justify", "text-orientation", "text-overflow", "text-rendering", "text-shadow", "text-transform", "text-underline-position", "top", "transform", "transform-box", "transform-origin", "transform-style", "transition", "transition-delay", "transition-duration", "transition-property", "transition-timing-function", "unicode-bidi", "vertical-align", "visibility", "voice-balance", "voice-duration", "voice-family", "voice-pitch", "voice-range", "voice-rate", "voice-stress", "voice-volume", "white-space", "widows", "width", "will-change", "word-break", "word-spacing", "word-wrap", "writing-mode", "z-index"].reverse()
      ; return a => {
        const n = (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_-]*/ }
        }))(a), l = r, s = i, d = "@[a-z-]+", c = {
          className: "variable",
          begin: "(\\$[a-zA-Z-][a-zA-Z0-9_-]*)\\b"
        }; return {
          name: "SCSS", case_insensitive: !0,
          illegal: "[=/|']",
          contains: [a.C_LINE_COMMENT_MODE, a.C_BLOCK_COMMENT_MODE, n.CSS_NUMBER_MODE, {
            className: "selector-id", begin: "#[A-Za-z0-9_-]+", relevance: 0
          }, {
            className: "selector-class", begin: "\\.[A-Za-z0-9_-]+", relevance: 0
          }, n.ATTRIBUTE_SELECTOR_MODE, {
            className: "selector-tag",
            begin: "\\b(" + e.join("|") + ")\\b", relevance: 0
          }, {
            className: "selector-pseudo",
            begin: ":(" + s.join("|") + ")"
          }, {
            className: "selector-pseudo",
            begin: ":(:)?(" + l.join("|") + ")"
          }, c, {
            begin: /\(/, end: /\)/,
            contains: [n.CSS_NUMBER_MODE]
          }, n.CSS_VARIABLE, {
            className: "attribute",
            begin: "\\b(" + o.join("|") + ")\\b"
          }, {
            begin: "\\b(whitespace|wait|w-resize|visible|vertical-text|vertical-ideographic|uppercase|upper-roman|upper-alpha|underline|transparent|top|thin|thick|text|text-top|text-bottom|tb-rl|table-header-group|table-footer-group|sw-resize|super|strict|static|square|solid|small-caps|separate|se-resize|scroll|s-resize|rtl|row-resize|ridge|right|repeat|repeat-y|repeat-x|relative|progress|pointer|overline|outside|outset|oblique|nowrap|not-allowed|normal|none|nw-resize|no-repeat|no-drop|newspaper|ne-resize|n-resize|move|middle|medium|ltr|lr-tb|lowercase|lower-roman|lower-alpha|loose|list-item|line|line-through|line-edge|lighter|left|keep-all|justify|italic|inter-word|inter-ideograph|inside|inset|inline|inline-block|inherit|inactive|ideograph-space|ideograph-parenthesis|ideograph-numeric|ideograph-alpha|horizontal|hidden|help|hand|groove|fixed|ellipsis|e-resize|double|dotted|distribute|distribute-space|distribute-letter|distribute-all-lines|disc|disabled|default|decimal|dashed|crosshair|collapse|col-resize|circle|char|center|capitalize|break-word|break-all|bottom|both|bolder|bold|block|bidi-override|below|baseline|auto|always|all-scroll|absolute|table|table-cell)\\b"
          }, {
            begin: /:/, end: /[;}{]/,
            contains: [n.BLOCK_COMMENT, c, n.HEXCOLOR, n.CSS_NUMBER_MODE, a.QUOTE_STRING_MODE, a.APOS_STRING_MODE, n.IMPORTANT]
          }, { begin: "@(page|font-face)", keywords: { $pattern: d, keyword: "@page @font-face" } }, {
            begin: "@", end: "[{;]", returnBegin: !0, keywords: {
              $pattern: /[a-z-]+/,
              keyword: "and or not only", attribute: t.join(" ")
            }, contains: [{
              begin: d,
              className: "keyword"
            }, {
              begin: /[a-z-]+(?=:)/, className: "attribute"
            }, c, a.QUOTE_STRING_MODE, a.APOS_STRING_MODE, n.HEXCOLOR, n.CSS_NUMBER_MODE]
          }, n.FUNCTION_DISPATCH]
        }
      }
  })(); hljs.registerLanguage("scss", e)
})();/*! `objectivec` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const n = /[a-zA-Z@][a-zA-Z0-9_]*/, _ = {
        $pattern: n, keyword: ["@interface", "@class", "@protocol", "@implementation"]
      }
        ; return {
          name: "Objective-C",
          aliases: ["mm", "objc", "obj-c", "obj-c++", "objective-c++"], keywords: {
            $pattern: n,
            keyword: ["int", "float", "while", "char", "export", "sizeof", "typedef", "const", "struct", "for", "union", "unsigned", "long", "volatile", "static", "bool", "mutable", "if", "do", "return", "goto", "void", "enum", "else", "break", "extern", "asm", "case", "short", "default", "double", "register", "explicit", "signed", "typename", "this", "switch", "continue", "wchar_t", "inline", "readonly", "assign", "readwrite", "self", "@synchronized", "id", "typeof", "nonatomic", "super", "unichar", "IBOutlet", "IBAction", "strong", "weak", "copy", "in", "out", "inout", "bycopy", "byref", "oneway", "__strong", "__weak", "__block", "__autoreleasing", "@private", "@protected", "@public", "@try", "@property", "@end", "@throw", "@catch", "@finally", "@autoreleasepool", "@synthesize", "@dynamic", "@selector", "@optional", "@required", "@encode", "@package", "@import", "@defs", "@compatibility_alias", "__bridge", "__bridge_transfer", "__bridge_retained", "__bridge_retain", "__covariant", "__contravariant", "__kindof", "_Nonnull", "_Nullable", "_Null_unspecified", "__FUNCTION__", "__PRETTY_FUNCTION__", "__attribute__", "getter", "setter", "retain", "unsafe_unretained", "nonnull", "nullable", "null_unspecified", "null_resettable", "class", "instancetype", "NS_DESIGNATED_INITIALIZER", "NS_UNAVAILABLE", "NS_REQUIRES_SUPER", "NS_RETURNS_INNER_POINTER", "NS_INLINE", "NS_AVAILABLE", "NS_DEPRECATED", "NS_ENUM", "NS_OPTIONS", "NS_SWIFT_UNAVAILABLE", "NS_ASSUME_NONNULL_BEGIN", "NS_ASSUME_NONNULL_END", "NS_REFINED_FOR_SWIFT", "NS_SWIFT_NAME", "NS_SWIFT_NOTHROW", "NS_DURING", "NS_HANDLER", "NS_ENDHANDLER", "NS_VALUERETURN", "NS_VOIDRETURN"],
            literal: ["false", "true", "FALSE", "TRUE", "nil", "YES", "NO", "NULL"],
            built_in: ["BOOL", "dispatch_once_t", "dispatch_queue_t", "dispatch_sync", "dispatch_async", "dispatch_once"]
          }, illegal: "</", contains: [{
            className: "built_in",
            begin: "\\b(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)\\w+"
          }, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE, e.C_NUMBER_MODE, e.QUOTE_STRING_MODE, e.APOS_STRING_MODE, {
            className: "string", variants: [{
              begin: '@"', end: '"', illegal: "\\n",
              contains: [e.BACKSLASH_ESCAPE]
            }]
          }, {
            className: "meta", begin: /#\s*[a-z]+\b/, end: /$/,
            keywords: {
              keyword: "if else elif endif define undef warning error line pragma ifdef ifndef include"
            }, contains: [{ begin: /\\\n/, relevance: 0 }, e.inherit(e.QUOTE_STRING_MODE, {
              className: "string"
            }), {
              className: "string", begin: /<.*?>/, end: /$/, illegal: "\\n"
            }, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE]
          }, {
            className: "class",
            begin: "(" + _.keyword.join("|") + ")\\b", end: /(\{|$)/, excludeEnd: !0, keywords: _,
            contains: [e.UNDERSCORE_TITLE_MODE]
          }, {
            begin: "\\." + e.UNDERSCORE_IDENT_RE,
            relevance: 0
          }]
        }
    }
  })(); hljs.registerLanguage("objectivec", e)
})();/*! `python-repl` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var a = (() => {
    "use strict"; return a => ({
      aliases: ["pycon"], contains: [{
        className: "meta", starts: { end: / |$/, starts: { end: "$", subLanguage: "python" } },
        variants: [{ begin: /^>>>(?=[ ]|$)/ }, { begin: /^\.\.\.(?=[ ]|$)/ }]
      }]
    })
  })()
    ; hljs.registerLanguage("python-repl", a)
})();/*! `csharp` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const n = {
        keyword: ["abstract", "as", "base", "break", "case", "catch", "class", "const", "continue", "do", "else", "event", "explicit", "extern", "finally", "fixed", "for", "foreach", "goto", "if", "implicit", "in", "interface", "internal", "is", "lock", "namespace", "new", "operator", "out", "override", "params", "private", "protected", "public", "readonly", "record", "ref", "return", "sealed", "sizeof", "stackalloc", "static", "struct", "switch", "this", "throw", "try", "typeof", "unchecked", "unsafe", "using", "virtual", "void", "volatile", "while"].concat(["add", "alias", "and", "ascending", "async", "await", "by", "descending", "equals", "from", "get", "global", "group", "init", "into", "join", "let", "nameof", "not", "notnull", "on", "or", "orderby", "partial", "remove", "select", "set", "unmanaged", "value|0", "var", "when", "where", "with", "yield"]),
        built_in: ["bool", "byte", "char", "decimal", "delegate", "double", "dynamic", "enum", "float", "int", "long", "nint", "nuint", "object", "sbyte", "short", "string", "ulong", "uint", "ushort"],
        literal: ["default", "false", "null", "true"]
      }, a = e.inherit(e.TITLE_MODE, {
        begin: "[a-zA-Z](\\.?\\w)*"
      }), i = {
        className: "number", variants: [{
          begin: "\\b(0b[01']+)"
        }, {
          begin: "(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)(u|U|l|L|ul|UL|f|F|b|B)"
        }, {
          begin: "(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"
        }], relevance: 0
      }, s = {
        className: "string", begin: '@"', end: '"', contains: [{ begin: '""' }]
      }, t = e.inherit(s, { illegal: /\n/ }), r = {
        className: "subst", begin: /\{/, end: /\}/,
        keywords: n
      }, l = e.inherit(r, { illegal: /\n/ }), c = {
        className: "string", begin: /\$"/,
        end: '"', illegal: /\n/, contains: [{ begin: /\{\{/ }, {
          begin: /\}\}/
        }, e.BACKSLASH_ESCAPE, l]
      }, o = {
        className: "string", begin: /\$@"/, end: '"', contains: [{
          begin: /\{\{/
        }, { begin: /\}\}/ }, { begin: '""' }, r]
      }, d = e.inherit(o, {
        illegal: /\n/,
        contains: [{ begin: /\{\{/ }, { begin: /\}\}/ }, { begin: '""' }, l]
      })
        ; r.contains = [o, c, s, e.APOS_STRING_MODE, e.QUOTE_STRING_MODE, i, e.C_BLOCK_COMMENT_MODE],
          l.contains = [d, c, t, e.APOS_STRING_MODE, e.QUOTE_STRING_MODE, i, e.inherit(e.C_BLOCK_COMMENT_MODE, {
            illegal: /\n/
          })]; const g = {
            variants: [o, c, s, e.APOS_STRING_MODE, e.QUOTE_STRING_MODE]
          }, E = {
            begin: "<", end: ">", contains: [{ beginKeywords: "in out" }, a]
          }, _ = e.IDENT_RE + "(<" + e.IDENT_RE + "(\\s*,\\s*" + e.IDENT_RE + ")*>)?(\\[\\])?", b = {
            begin: "@" + e.IDENT_RE, relevance: 0
          }; return {
            name: "C#", aliases: ["cs", "c#"],
            keywords: n, illegal: /::/, contains: [e.COMMENT("///", "$", {
              returnBegin: !0,
              contains: [{
                className: "doctag", variants: [{ begin: "///", relevance: 0 }, {
                  begin: "\x3c!--|--\x3e"
                }, { begin: "</?", end: ">" }]
              }]
            }), e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE, {
              className: "meta", begin: "#",
              end: "$", keywords: {
                keyword: "if else elif endif define undef warning error line region endregion pragma checksum"
              }
            }, g, i, {
              beginKeywords: "class interface", relevance: 0, end: /[{;=]/,
              illegal: /[^\s:,]/, contains: [{
                beginKeywords: "where class"
              }, a, E, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE]
            }, {
              beginKeywords: "namespace",
              relevance: 0, end: /[{;=]/, illegal: /[^\s:]/,
              contains: [a, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE]
            }, {
              beginKeywords: "record", relevance: 0, end: /[{;=]/, illegal: /[^\s:]/,
              contains: [a, E, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE]
            }, {
              className: "meta",
              begin: "^\\s*\\[(?=[\\w])", excludeBegin: !0, end: "\\]", excludeEnd: !0, contains: [{
                className: "string", begin: /"/, end: /"/
              }]
            }, {
              beginKeywords: "new return throw await else", relevance: 0
            }, {
              className: "function",
              begin: "(" + _ + "\\s+)+" + e.IDENT_RE + "\\s*(<[^=]+>\\s*)?\\(", returnBegin: !0,
              end: /\s*[{;=]/, excludeEnd: !0, keywords: n, contains: [{
                beginKeywords: "public private protected static internal protected abstract async extern override unsafe virtual new sealed partial",
                relevance: 0
              }, {
                begin: e.IDENT_RE + "\\s*(<[^=]+>\\s*)?\\(", returnBegin: !0,
                contains: [e.TITLE_MODE, E], relevance: 0
              }, { match: /\(\)/ }, {
                className: "params",
                begin: /\(/, end: /\)/, excludeBegin: !0, excludeEnd: !0, keywords: n, relevance: 0,
                contains: [g, i, e.C_BLOCK_COMMENT_MODE]
              }, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE]
            }, b]
          }
    }
  })()
    ; hljs.registerLanguage("csharp", e)
})();/*! `typescript` grammar compiled for Highlight.js 11.3.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"], 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", "module", "global"], i = [].concat(r, t, s)
      ; function o(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()), (s = e.input.substr(a).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 = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", E = {
          className: "number", variants: [{
            begin: `(\\b(${m})((${u})|\\.)?|(${u}))[eE][+-]?([0-9](_?[0-9])*)\\b`
          }, {
            begin: `\\b(${m})\\b((${u})\\b|\\.)?|(${u})\\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: []
        }, A = {
          begin: "html`", end: "", starts: {
            end: "`",
            returnEnd: !1, contains: [o.BACKSLASH_ESCAPE, y], subLanguage: "xml"
          }
        }, p = {
          begin: "css`", end: "", starts: {
            end: "`", returnEnd: !1,
            contains: [o.BACKSLASH_ESCAPE, y], subLanguage: "css"
          }
        }, _ = {
          className: "string",
          begin: "`", end: "`", contains: [o.BACKSLASH_ESCAPE, y]
        }, f = {
          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]
        }, N = [o.APOS_STRING_MODE, o.QUOTE_STRING_MODE, A, p, _, E]; y.contains = N.concat({
          begin: /\{/, end: /\}/, keywords: g, contains: ["self"].concat(N)
        })
          ; const h = [].concat(f, y.contains), v = h.concat([{
            begin: /\(/, end: /\)/, keywords: g,
            contains: ["self"].concat(h)
          }]), S = {
            className: "params", begin: /\(/, end: /\)/,
            excludeBegin: !0, excludeEnd: !0, keywords: g, contains: v
          }, w = {
            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" }
            }]
          }, R = {
            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)+/),
            className: "title.class", keywords: { _: [...t, ...s] }
          }, x = {
            variants: [{
              match: [/function/, /\s+/, d, /(?=\s*\()/]
            }, { match: [/function/, /\s*(?=\()/] }],
            className: { 1: "keyword", 3: "title.function" }, label: "func.def", contains: [S],
            illegal: /%/
          }, O = {
            match: l.concat(/\b/, (k = [...r, "super"], l.concat("(?!", k.join("|"), ")")), d, l.lookahead(/\(/)),
            className: "title.function", relevance: 0
          }; var k; const I = {
            begin: l.concat(/\./, l.lookahead(l.concat(d, /(?![0-9A-Za-z$_(])/))), end: d,
            excludeBegin: !0, keywords: "prototype", className: "property", relevance: 0
          }, C = {
            match: [/get|set/, /\s+/, d, /(?=\()/], className: { 1: "keyword", 3: "title.function" },
            contains: [{ begin: /\(\)/ }, S]
          }, T = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + o.UNDERSCORE_IDENT_RE + ")\\s*=>", M = {
            match: [/const|var|let/, /\s+/, d, /\s*/, /=\s*/, l.lookahead(T)], className: {
              1: "keyword", 3: "title.function"
            }, contains: [S]
          }; return {
            name: "Javascript",
            aliases: ["js", "jsx", "mjs", "cjs"], keywords: g, exports: {
              PARAMS_CONTAINS: v,
              CLASS_REFERENCE: R
            }, 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, A, p, _, f, E, R, {
              className: "attr",
              begin: d + l.lookahead(":"), relevance: 0
            }, M, {
              begin: "(" + o.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
              keywords: "return throw case", relevance: 0, contains: [f, o.REGEXP_MODE, {
                className: "function", begin: T, returnBegin: !0, end: "\\s*=>", contains: [{
                  className: "params", variants: [{ begin: o.UNDERSCORE_IDENT_RE, relevance: 0 }, {
                    className: null, begin: /\(\s*\)/, skip: !0
                  }, {
                    begin: /\(/, end: /\)/, excludeBegin: !0,
                    excludeEnd: !0, keywords: g, contains: v
                  }]
                }]
              }, { 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"]
                  }]
                }]
            }, x, {
              beginKeywords: "while if switch catch for"
            }, {
              begin: "\\b(?!function)" + o.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
              returnBegin: !0, label: "func.def", contains: [S, o.inherit(o.TITLE_MODE, {
                begin: d,
                className: "title.function"
              })]
            }, { match: /\.\.\./, relevance: 0 }, I, {
              match: "\\$" + d,
              relevance: 0
            }, {
              match: [/\bconstructor(?=\s*\()/], className: { 1: "title.function" },
              contains: [S]
            }, O, {
              relevance: 0, match: /\b[A-Z][A-Z_0-9]+\b/,
              className: "variable.constant"
            }, w, C, { match: /\$[(.]/ }]
          }
      } return t => {
        const s = o(t), r = ["any", "void", "number", "boolean", "string", "object", "never", "enum"], l = {
          beginKeywords: "namespace", end: /\{/, excludeEnd: !0,
          contains: [s.exports.CLASS_REFERENCE]
        }, d = {
          beginKeywords: "interface", end: /\{/,
          excludeEnd: !0, keywords: { keyword: "interface extends", built_in: r },
          contains: [s.exports.CLASS_REFERENCE]
        }, b = {
          $pattern: e,
          keyword: n.concat(["type", "namespace", "typedef", "interface", "public", "private", "protected", "implements", "declare", "abstract", "readonly"]),
          literal: a, built_in: i.concat(r), "variable.language": c
        }, g = {
          className: "meta",
          begin: "@[A-Za-z$_][0-9A-Za-z$_]*"
        }, u = (e, n, a) => {
          const t = e.contains.findIndex((e => e.label === n))
            ; if (-1 === t) throw Error("can not find mode to replace"); e.contains.splice(t, 1, a)
        }
          ; return Object.assign(s.keywords, b),
            s.exports.PARAMS_CONTAINS.push(g), s.contains = s.contains.concat([g, l, d]),
            u(s, "shebang", t.SHEBANG()), u(s, "use_strict", {
              className: "meta", relevance: 10,
              begin: /^\s*['"]use strict['"]/
            }), s.contains.find((e => "func.def" === e.label)).relevance = 0, Object.assign(s, {
              name: "TypeScript", aliases: ["ts", "tsx"]
            }), s
      }
  })()
    ; hljs.registerLanguage("typescript", e)
})();/*! `ruby` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const n = e.regex, a = "([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)", i = {
        keyword: "and then defined module in return redo if BEGIN retry end for self when next until do begin unless END rescue else break undef not super class case require yield alias while ensure elsif or include attr_reader attr_writer attr_accessor __FILE__",
        built_in: "proc lambda", literal: "true false nil"
      }, s = {
        className: "doctag",
        begin: "@[A-Za-z]+"
      }, b = { begin: "#<", end: ">" }, r = [e.COMMENT("#", "$", {
        contains: [s]
      }), e.COMMENT("^=begin", "^=end", {
        contains: [s], relevance: 10
      }), e.COMMENT("^__END__", "\\n$")], c = {
        className: "subst", begin: /#\{/, end: /\}/,
        keywords: i
      }, t = {
        className: "string", contains: [e.BACKSLASH_ESCAPE, c], variants: [{
          begin: /'/, end: /'/
        }, { begin: /"/, end: /"/ }, { begin: /`/, end: /`/ }, {
          begin: /%[qQwWx]?\(/,
          end: /\)/
        }, { begin: /%[qQwWx]?\[/, end: /\]/ }, { begin: /%[qQwWx]?\{/, end: /\}/ }, {
          begin: /%[qQwWx]?</, end: />/
        }, { begin: /%[qQwWx]?\//, end: /\// }, {
          begin: /%[qQwWx]?%/,
          end: /%/
        }, { begin: /%[qQwWx]?-/, end: /-/ }, { begin: /%[qQwWx]?\|/, end: /\|/ }, {
          begin: /\B\?(\\\d{1,3})/
        }, { begin: /\B\?(\\x[A-Fa-f0-9]{1,2})/ }, {
          begin: /\B\?(\\u\{?[A-Fa-f0-9]{1,6}\}?)/
        }, {
          begin: /\B\?(\\M-\\C-|\\M-\\c|\\c\\M-|\\M-|\\C-\\M-)[\x20-\x7e]/
        }, {
          begin: /\B\?\\(c|C-)[\x20-\x7e]/
        }, { begin: /\B\?\\?\S/ }, {
          begin: n.concat(/<<[-~]?'?/, n.lookahead(/(\w+)(?=\W)[^\n]*\n(?:[^\n]*\n)*?\s*\1\b/)),
          contains: [e.END_SAME_AS_BEGIN({
            begin: /(\w+)/, end: /(\w+)/,
            contains: [e.BACKSLASH_ESCAPE, c]
          })]
        }]
      }, d = "[0-9](_?[0-9])*", g = {
        className: "number",
        relevance: 0, variants: [{
          begin: `\\b([1-9](_?[0-9])*|0)(\\.(${d}))?([eE][+-]?(${d})|r)?i?\\b`
        }, {
          begin: "\\b0[dD][0-9](_?[0-9])*r?i?\\b"
        }, {
          begin: "\\b0[bB][0-1](_?[0-1])*r?i?\\b"
        }, { begin: "\\b0[oO][0-7](_?[0-7])*r?i?\\b" }, {
          begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*r?i?\\b"
        }, {
          begin: "\\b0(_?[0-7])+r?i?\\b"
        }]
      }, l = {
        className: "params", begin: "\\(", end: "\\)",
        endsParent: !0, keywords: i
      }, o = [t, {
        className: "class", beginKeywords: "class module",
        end: "$|;", illegal: /=/, contains: [e.inherit(e.TITLE_MODE, {
          begin: "[A-Za-z_]\\w*(::\\w+)*(\\?|!)?"
        }), {
          begin: "<\\s*", contains: [{
            begin: "(" + e.IDENT_RE + "::)?" + e.IDENT_RE, relevance: 0
          }]
        }].concat(r)
      }, {
          className: "function", begin: n.concat(/def\s+/, n.lookahead(a + "\\s*(\\(|;|$)")),
          relevance: 0, keywords: "def", end: "$|;", contains: [e.inherit(e.TITLE_MODE, {
            begin: a
          }), l].concat(r)
        }, { begin: e.IDENT_RE + "::" }, {
          className: "symbol",
          begin: e.UNDERSCORE_IDENT_RE + "(!|\\?)?:", relevance: 0
        }, {
          className: "symbol",
          begin: ":(?!\\s)", contains: [t, { begin: a }], relevance: 0
        }, g, {
          className: "variable",
          begin: "(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])"
        }, {
          className: "params", begin: /\|/, end: /\|/, relevance: 0, keywords: i
        }, {
          begin: "(" + e.RE_STARTERS_RE + "|unless)\\s*", keywords: "unless", contains: [{
            className: "regexp", contains: [e.BACKSLASH_ESCAPE, c], illegal: /\n/, variants: [{
              begin: "/", end: "/[a-z]*"
            }, { begin: /%r\{/, end: /\}[a-z]*/ }, {
              begin: "%r\\(",
              end: "\\)[a-z]*"
            }, { begin: "%r!", end: "![a-z]*" }, { begin: "%r\\[", end: "\\][a-z]*" }]
          }].concat(b, r), relevance: 0
        }].concat(b, r); c.contains = o, l.contains = o; const _ = [{
          begin: /^\s*=>/, starts: { end: "$", contains: o }
        }, {
          className: "meta",
          begin: "^([>?]>|[\\w#]+\\(\\w+\\):\\d+:\\d+>|(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>)(?=[ ])",
          starts: { end: "$", contains: o }
        }]; return r.unshift(b), {
          name: "Ruby",
          aliases: ["rb", "gemspec", "podspec", "thor", "irb"], keywords: i, illegal: /\/\*/,
          contains: [e.SHEBANG({ binary: "ruby" })].concat(_).concat(r).concat(o)
        }
    }
  })()
    ; hljs.registerLanguage("ruby", e)
})();/*! `yaml` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const n = "true false yes no null", a = "[\\w#;/?:@&=+$,.~*'()[\\]]+", s = {
        className: "string", relevance: 0, variants: [{ begin: /'/, end: /'/ }, {
          begin: /"/, end: /"/
        }, { begin: /\S+/ }], contains: [e.BACKSLASH_ESCAPE, {
          className: "template-variable",
          variants: [{ begin: /\{\{/, end: /\}\}/ }, { begin: /%\{/, end: /\}/ }]
        }]
      }, i = e.inherit(s, {
        variants: [{ begin: /'/, end: /'/ }, { begin: /"/, end: /"/ }, { begin: /[^\s,{}[\]]+/ }]
      }), l = {
        end: ",", endsWithParent: !0, excludeEnd: !0, keywords: n, relevance: 0
      }, t = {
        begin: /\{/,
        end: /\}/, contains: [l], illegal: "\\n", relevance: 0
      }, g = {
        begin: "\\[", end: "\\]",
        contains: [l], illegal: "\\n", relevance: 0
      }, b = [{
        className: "attr", variants: [{
          begin: "\\w[\\w :\\/.-]*:(?=[ \t]|$)"
        }, { begin: '"\\w[\\w :\\/.-]*":(?=[ \t]|$)' }, {
          begin: "'\\w[\\w :\\/.-]*':(?=[ \t]|$)"
        }]
      }, {
        className: "meta", begin: "^---\\s*$",
        relevance: 10
      }, {
        className: "string",
        begin: "[\\|>]([1-9]?[+-])?[ ]*\\n( +)[^ ][^\\n]*\\n(\\2[^\\n]+\\n?)*"
      }, {
        begin: "<%[%=-]?", end: "[%-]?%>", subLanguage: "ruby", excludeBegin: !0, excludeEnd: !0,
        relevance: 0
      }, { className: "type", begin: "!\\w+!" + a }, {
        className: "type",
        begin: "!<" + a + ">"
      }, { className: "type", begin: "!" + a }, {
        className: "type", begin: "!!" + a
      }, { className: "meta", begin: "&" + e.UNDERSCORE_IDENT_RE + "$" }, {
        className: "meta",
        begin: "\\*" + e.UNDERSCORE_IDENT_RE + "$"
      }, {
        className: "bullet", begin: "-(?=[ ]|$)",
        relevance: 0
      }, e.HASH_COMMENT_MODE, { beginKeywords: n, keywords: { literal: n } }, {
        className: "number",
        begin: "\\b[0-9]{4}(-[0-9][0-9]){0,2}([Tt \\t][0-9][0-9]?(:[0-9][0-9]){2})?(\\.[0-9]*)?([ \\t])*(Z|[-+][0-9][0-9]?(:[0-9][0-9])?)?\\b"
      }, { className: "number", begin: e.C_NUMBER_RE + "\\b", relevance: 0 }, t, g, s], r = [...b]
        ; return r.pop(), r.push(i), l.contains = r, {
          name: "YAML", case_insensitive: !0,
          aliases: ["yml"], contains: b
        }
    }
  })(); hljs.registerLanguage("yaml", e)
})();/*! `c` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const n = e.regex, t = e.COMMENT("//", "$", {
        contains: [{ begin: /\\\n/ }]
      }), s = "[a-zA-Z_]\\w*::", a = "(decltype\\(auto\\)|" + n.optional(s) + "[a-zA-Z_]\\w*" + n.optional("<[^<>]+>") + ")", r = {
        className: "type", variants: [{ begin: "\\b[a-z\\d_]*_t\\b" }, {
          match: /\batomic_[a-z]{3,6}\b/
        }]
      }, i = {
        className: "string", variants: [{
          begin: '(u8?|U|L)?"', end: '"', illegal: "\\n", contains: [e.BACKSLASH_ESCAPE]
        }, {
          begin: "(u8?|U|L)?'(\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)|.)",
          end: "'", illegal: "."
        }, e.END_SAME_AS_BEGIN({
          begin: /(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/, end: /\)([^()\\ ]{0,16})"/
        })]
      }, l = {
        className: "number", variants: [{ begin: "\\b(0b[01']+)" }, {
          begin: "(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)"
        }, {
          begin: "(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"
        }], relevance: 0
      }, o = {
        className: "meta", begin: /#\s*[a-z]+\b/, end: /$/, keywords: {
          keyword: "if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include"
        }, contains: [{ begin: /\\\n/, relevance: 0 }, e.inherit(i, { className: "string" }), {
          className: "string", begin: /<.*?>/
        }, t, e.C_BLOCK_COMMENT_MODE]
      }, c = {
        className: "title", begin: n.optional(s) + e.IDENT_RE, relevance: 0
      }, d = n.optional(s) + e.IDENT_RE + "\\s*\\(", u = {
        keyword: ["asm", "auto", "break", "case", "continue", "default", "do", "else", "enum", "extern", "for", "fortran", "goto", "if", "inline", "register", "restrict", "return", "sizeof", "struct", "switch", "typedef", "union", "volatile", "while", "_Alignas", "_Alignof", "_Atomic", "_Generic", "_Noreturn", "_Static_assert", "_Thread_local", "alignas", "alignof", "noreturn", "static_assert", "thread_local", "_Pragma"],
        type: ["float", "double", "signed", "unsigned", "int", "short", "long", "char", "void", "_Bool", "_Complex", "_Imaginary", "_Decimal32", "_Decimal64", "_Decimal128", "const", "static", "complex", "bool", "imaginary"],
        literal: "true false NULL",
        built_in: "std string wstring cin cout cerr clog stdin stdout stderr stringstream istringstream ostringstream auto_ptr deque list queue stack vector map set pair bitset multiset multimap unordered_set unordered_map unordered_multiset unordered_multimap priority_queue make_pair array shared_ptr abort terminate abs acos asin atan2 atan calloc ceil cosh cos exit exp fabs floor fmod fprintf fputs free frexp fscanf future isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit tolower toupper labs ldexp log10 log malloc realloc memchr memcmp memcpy memset modf pow printf putchar puts scanf sinh sin snprintf sprintf sqrt sscanf strcat strchr strcmp strcpy strcspn strlen strncat strncmp strncpy strpbrk strrchr strspn strstr tanh tan vfprintf vprintf vsprintf endl initializer_list unique_ptr"
      }, g = [o, r, t, e.C_BLOCK_COMMENT_MODE, l, i], m = {
        variants: [{ begin: /=/, end: /;/ }, {
          begin: /\(/, end: /\)/
        }, { beginKeywords: "new throw return else", end: /;/ }],
        keywords: u, contains: g.concat([{
          begin: /\(/, end: /\)/, keywords: u,
          contains: g.concat(["self"]), relevance: 0
        }]), relevance: 0
      }, p = {
        begin: "(" + a + "[\\*&\\s]+)+" + d, returnBegin: !0, end: /[{;=]/, excludeEnd: !0,
        keywords: u, illegal: /[^\w\s\*&:<>.]/, contains: [{
          begin: "decltype\\(auto\\)",
          keywords: u, relevance: 0
        }, {
          begin: d, returnBegin: !0, contains: [e.inherit(c, {
            className: "title.function"
          })], relevance: 0
        }, { relevance: 0, match: /,/ }, {
          className: "params", begin: /\(/, end: /\)/, keywords: u, relevance: 0,
          contains: [t, e.C_BLOCK_COMMENT_MODE, i, l, r, {
            begin: /\(/, end: /\)/, keywords: u,
            relevance: 0, contains: ["self", t, e.C_BLOCK_COMMENT_MODE, i, l, r]
          }]
        }, r, t, e.C_BLOCK_COMMENT_MODE, o]
      }; return {
        name: "C", aliases: ["h"], keywords: u,
        disableAutodetect: !0, illegal: "</", contains: [].concat(m, p, g, [o, {
          begin: e.IDENT_RE + "::", keywords: u
        }, {
            className: "class",
            beginKeywords: "enum class struct union", end: /[{;:<>=]/, contains: [{
              beginKeywords: "final class struct"
            }, e.TITLE_MODE]
          }]), exports: {
            preprocessor: o,
            strings: i, keywords: u
          }
      }
    }
  })(); hljs.registerLanguage("c", e)
})();/*! `sql` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const r = e.regex, t = e.COMMENT("--", "$"), n = ["true", "false", "unknown"], a = ["bigint", "binary", "blob", "boolean", "char", "character", "clob", "date", "dec", "decfloat", "decimal", "float", "int", "integer", "interval", "nchar", "nclob", "national", "numeric", "real", "row", "smallint", "time", "timestamp", "varchar", "varying", "varbinary"], i = ["abs", "acos", "array_agg", "asin", "atan", "avg", "cast", "ceil", "ceiling", "coalesce", "corr", "cos", "cosh", "count", "covar_pop", "covar_samp", "cume_dist", "dense_rank", "deref", "element", "exp", "extract", "first_value", "floor", "json_array", "json_arrayagg", "json_exists", "json_object", "json_objectagg", "json_query", "json_table", "json_table_primitive", "json_value", "lag", "last_value", "lead", "listagg", "ln", "log", "log10", "lower", "max", "min", "mod", "nth_value", "ntile", "nullif", "percent_rank", "percentile_cont", "percentile_disc", "position", "position_regex", "power", "rank", "regr_avgx", "regr_avgy", "regr_count", "regr_intercept", "regr_r2", "regr_slope", "regr_sxx", "regr_sxy", "regr_syy", "row_number", "sin", "sinh", "sqrt", "stddev_pop", "stddev_samp", "substring", "substring_regex", "sum", "tan", "tanh", "translate", "translate_regex", "treat", "trim", "trim_array", "unnest", "upper", "value_of", "var_pop", "var_samp", "width_bucket"], s = ["create table", "insert into", "primary key", "foreign key", "not null", "alter table", "add constraint", "grouping sets", "on overflow", "character set", "respect nulls", "ignore nulls", "nulls first", "nulls last", "depth first", "breadth first"], o = i, c = ["abs", "acos", "all", "allocate", "alter", "and", "any", "are", "array", "array_agg", "array_max_cardinality", "as", "asensitive", "asin", "asymmetric", "at", "atan", "atomic", "authorization", "avg", "begin", "begin_frame", "begin_partition", "between", "bigint", "binary", "blob", "boolean", "both", "by", "call", "called", "cardinality", "cascaded", "case", "cast", "ceil", "ceiling", "char", "char_length", "character", "character_length", "check", "classifier", "clob", "close", "coalesce", "collate", "collect", "column", "commit", "condition", "connect", "constraint", "contains", "convert", "copy", "corr", "corresponding", "cos", "cosh", "count", "covar_pop", "covar_samp", "create", "cross", "cube", "cume_dist", "current", "current_catalog", "current_date", "current_default_transform_group", "current_path", "current_role", "current_row", "current_schema", "current_time", "current_timestamp", "current_path", "current_role", "current_transform_group_for_type", "current_user", "cursor", "cycle", "date", "day", "deallocate", "dec", "decimal", "decfloat", "declare", "default", "define", "delete", "dense_rank", "deref", "describe", "deterministic", "disconnect", "distinct", "double", "drop", "dynamic", "each", "element", "else", "empty", "end", "end_frame", "end_partition", "end-exec", "equals", "escape", "every", "except", "exec", "execute", "exists", "exp", "external", "extract", "false", "fetch", "filter", "first_value", "float", "floor", "for", "foreign", "frame_row", "free", "from", "full", "function", "fusion", "get", "global", "grant", "group", "grouping", "groups", "having", "hold", "hour", "identity", "in", "indicator", "initial", "inner", "inout", "insensitive", "insert", "int", "integer", "intersect", "intersection", "interval", "into", "is", "join", "json_array", "json_arrayagg", "json_exists", "json_object", "json_objectagg", "json_query", "json_table", "json_table_primitive", "json_value", "lag", "language", "large", "last_value", "lateral", "lead", "leading", "left", "like", "like_regex", "listagg", "ln", "local", "localtime", "localtimestamp", "log", "log10", "lower", "match", "match_number", "match_recognize", "matches", "max", "member", "merge", "method", "min", "minute", "mod", "modifies", "module", "month", "multiset", "national", "natural", "nchar", "nclob", "new", "no", "none", "normalize", "not", "nth_value", "ntile", "null", "nullif", "numeric", "octet_length", "occurrences_regex", "of", "offset", "old", "omit", "on", "one", "only", "open", "or", "order", "out", "outer", "over", "overlaps", "overlay", "parameter", "partition", "pattern", "per", "percent", "percent_rank", "percentile_cont", "percentile_disc", "period", "portion", "position", "position_regex", "power", "precedes", "precision", "prepare", "primary", "procedure", "ptf", "range", "rank", "reads", "real", "recursive", "ref", "references", "referencing", "regr_avgx", "regr_avgy", "regr_count", "regr_intercept", "regr_r2", "regr_slope", "regr_sxx", "regr_sxy", "regr_syy", "release", "result", "return", "returns", "revoke", "right", "rollback", "rollup", "row", "row_number", "rows", "running", "savepoint", "scope", "scroll", "search", "second", "seek", "select", "sensitive", "session_user", "set", "show", "similar", "sin", "sinh", "skip", "smallint", "some", "specific", "specifictype", "sql", "sqlexception", "sqlstate", "sqlwarning", "sqrt", "start", "static", "stddev_pop", "stddev_samp", "submultiset", "subset", "substring", "substring_regex", "succeeds", "sum", "symmetric", "system", "system_time", "system_user", "table", "tablesample", "tan", "tanh", "then", "time", "timestamp", "timezone_hour", "timezone_minute", "to", "trailing", "translate", "translate_regex", "translation", "treat", "trigger", "trim", "trim_array", "true", "truncate", "uescape", "union", "unique", "unknown", "unnest", "update", "upper", "user", "using", "value", "values", "value_of", "var_pop", "var_samp", "varbinary", "varchar", "varying", "versioning", "when", "whenever", "where", "width_bucket", "window", "with", "within", "without", "year", "add", "asc", "collation", "desc", "final", "first", "last", "view"].filter((e => !i.includes(e))), l = {
        begin: r.concat(/\b/, r.either(...o), /\s*\(/), relevance: 0, keywords: { built_in: o }
      }
        ; return {
          name: "SQL", case_insensitive: !0, illegal: /[{}]|<\//, keywords: {
            $pattern: /\b[\w\.]+/, keyword: ((e, { exceptions: r, when: t } = {}) => {
              const n = t
                ; return r = r || [], e.map((e => e.match(/\|\d+$/) || r.includes(e) ? e : n(e) ? e + "|0" : e))
            })(c, { when: e => e.length < 3 }), literal: n, type: a,
            built_in: ["current_catalog", "current_date", "current_default_transform_group", "current_path", "current_role", "current_schema", "current_transform_group_for_type", "current_user", "session_user", "system_time", "system_user", "current_time", "localtime", "current_timestamp", "localtimestamp"]
          }, contains: [{
            begin: r.either(...s), relevance: 0, keywords: {
              $pattern: /[\w\.]+/,
              keyword: c.concat(s), literal: n, type: a
            }
          }, {
            className: "type",
            begin: r.either("double precision", "large object", "with timezone", "without timezone")
          }, l, { className: "variable", begin: /@[a-z0-9]+/ }, {
            className: "string", variants: [{
              begin: /'/, end: /'/, contains: [{ begin: /''/ }]
            }]
          }, {
            begin: /"/, end: /"/, contains: [{
              begin: /""/
            }]
          }, e.C_NUMBER_MODE, e.C_BLOCK_COMMENT_MODE, t, {
            className: "operator",
            begin: /[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/, relevance: 0
          }]
        }
    }
  })()
    ; hljs.registerLanguage("sql", e)
})();/*! `plaintext` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var t = (() => {
    "use strict"; return t => ({
      name: "Plain text",
      aliases: ["text", "txt"], disableAutodetect: !0
    })
  })()
    ; hljs.registerLanguage("plaintext", t)
})();/*! `cpp` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const t = e.regex, a = e.COMMENT("//", "$", {
        contains: [{ begin: /\\\n/ }]
      }), n = "[a-zA-Z_]\\w*::", r = "(?!struct)(decltype\\(auto\\)|" + t.optional(n) + "[a-zA-Z_]\\w*" + t.optional("<[^<>]+>") + ")", i = {
        className: "type", begin: "\\b[a-z\\d_]*_t\\b"
      }, s = {
        className: "string", variants: [{
          begin: '(u8?|U|L)?"', end: '"', illegal: "\\n", contains: [e.BACKSLASH_ESCAPE]
        }, {
          begin: "(u8?|U|L)?'(\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)|.)",
          end: "'", illegal: "."
        }, e.END_SAME_AS_BEGIN({
          begin: /(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/, end: /\)([^()\\ ]{0,16})"/
        })]
      }, c = {
        className: "number", variants: [{ begin: "\\b(0b[01']+)" }, {
          begin: "(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)"
        }, {
          begin: "(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"
        }], relevance: 0
      }, o = {
        className: "meta", begin: /#\s*[a-z]+\b/, end: /$/, keywords: {
          keyword: "if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include"
        }, contains: [{ begin: /\\\n/, relevance: 0 }, e.inherit(s, { className: "string" }), {
          className: "string", begin: /<.*?>/
        }, a, e.C_BLOCK_COMMENT_MODE]
      }, l = {
        className: "title", begin: t.optional(n) + e.IDENT_RE, relevance: 0
      }, d = t.optional(n) + e.IDENT_RE + "\\s*\\(", u = {
        type: ["bool", "char", "char16_t", "char32_t", "char8_t", "double", "float", "int", "long", "short", "void", "wchar_t", "unsigned", "signed", "const", "static"],
        keyword: ["alignas", "alignof", "and", "and_eq", "asm", "atomic_cancel", "atomic_commit", "atomic_noexcept", "auto", "bitand", "bitor", "break", "case", "catch", "class", "co_await", "co_return", "co_yield", "compl", "concept", "const_cast|10", "consteval", "constexpr", "constinit", "continue", "decltype", "default", "delete", "do", "dynamic_cast|10", "else", "enum", "explicit", "export", "extern", "false", "final", "for", "friend", "goto", "if", "import", "inline", "module", "mutable", "namespace", "new", "noexcept", "not", "not_eq", "nullptr", "operator", "or", "or_eq", "override", "private", "protected", "public", "reflexpr", "register", "reinterpret_cast|10", "requires", "return", "sizeof", "static_assert", "static_cast|10", "struct", "switch", "synchronized", "template", "this", "thread_local", "throw", "transaction_safe", "transaction_safe_dynamic", "true", "try", "typedef", "typeid", "typename", "union", "using", "virtual", "volatile", "while", "xor", "xor_eq"],
        literal: ["NULL", "false", "nullopt", "nullptr", "true"], built_in: ["_Pragma"],
        _type_hints: ["any", "auto_ptr", "barrier", "binary_semaphore", "bitset", "complex", "condition_variable", "condition_variable_any", "counting_semaphore", "deque", "false_type", "future", "imaginary", "initializer_list", "istringstream", "jthread", "latch", "lock_guard", "multimap", "multiset", "mutex", "optional", "ostringstream", "packaged_task", "pair", "promise", "priority_queue", "queue", "recursive_mutex", "recursive_timed_mutex", "scoped_lock", "set", "shared_future", "shared_lock", "shared_mutex", "shared_timed_mutex", "shared_ptr", "stack", "string_view", "stringstream", "timed_mutex", "thread", "true_type", "tuple", "unique_lock", "unique_ptr", "unordered_map", "unordered_multimap", "unordered_multiset", "unordered_set", "variant", "vector", "weak_ptr", "wstring", "wstring_view"]
      }, p = {
        className: "function.dispatch", relevance: 0, keywords: {
          _hint: ["abort", "abs", "acos", "apply", "as_const", "asin", "atan", "atan2", "calloc", "ceil", "cerr", "cin", "clog", "cos", "cosh", "cout", "declval", "endl", "exchange", "exit", "exp", "fabs", "floor", "fmod", "forward", "fprintf", "fputs", "free", "frexp", "fscanf", "future", "invoke", "isalnum", "isalpha", "iscntrl", "isdigit", "isgraph", "islower", "isprint", "ispunct", "isspace", "isupper", "isxdigit", "labs", "launder", "ldexp", "log", "log10", "make_pair", "make_shared", "make_shared_for_overwrite", "make_tuple", "make_unique", "malloc", "memchr", "memcmp", "memcpy", "memset", "modf", "move", "pow", "printf", "putchar", "puts", "realloc", "scanf", "sin", "sinh", "snprintf", "sprintf", "sqrt", "sscanf", "std", "stderr", "stdin", "stdout", "strcat", "strchr", "strcmp", "strcpy", "strcspn", "strlen", "strncat", "strncmp", "strncpy", "strpbrk", "strrchr", "strspn", "strstr", "swap", "tan", "tanh", "terminate", "to_underlying", "tolower", "toupper", "vfprintf", "visit", "vprintf", "vsprintf"]
        },
        begin: t.concat(/\b/, /(?!decltype)/, /(?!if)/, /(?!for)/, /(?!switch)/, /(?!while)/, e.IDENT_RE, t.lookahead(/(<[^<>]+>|)\s*\(/))
      }, _ = [p, o, i, a, e.C_BLOCK_COMMENT_MODE, c, s], m = {
        variants: [{ begin: /=/, end: /;/ }, {
          begin: /\(/, end: /\)/
        }, { beginKeywords: "new throw return else", end: /;/ }],
        keywords: u, contains: _.concat([{
          begin: /\(/, end: /\)/, keywords: u,
          contains: _.concat(["self"]), relevance: 0
        }]), relevance: 0
      }, g = {
        className: "function",
        begin: "(" + r + "[\\*&\\s]+)+" + d, returnBegin: !0, end: /[{;=]/, excludeEnd: !0,
        keywords: u, illegal: /[^\w\s\*&:<>.]/, contains: [{
          begin: "decltype\\(auto\\)",
          keywords: u, relevance: 0
        }, { begin: d, returnBegin: !0, contains: [l], relevance: 0 }, {
          begin: /::/, relevance: 0
        }, { begin: /:/, endsWithParent: !0, contains: [s, c] }, {
          relevance: 0, match: /,/
        }, {
          className: "params", begin: /\(/, end: /\)/, keywords: u,
          relevance: 0, contains: [a, e.C_BLOCK_COMMENT_MODE, s, c, i, {
            begin: /\(/, end: /\)/,
            keywords: u, relevance: 0, contains: ["self", a, e.C_BLOCK_COMMENT_MODE, s, c, i]
          }]
        }, i, a, e.C_BLOCK_COMMENT_MODE, o]
      }; return {
        name: "C++",
        aliases: ["cc", "c++", "h++", "hpp", "hh", "hxx", "cxx"], keywords: u, illegal: "</",
        classNameAliases: { "function.dispatch": "built_in" },
        contains: [].concat(m, g, p, _, [o, {
          begin: "\\b(deque|list|queue|priority_queue|pair|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array|tuple|optional|variant|function)\\s*<",
          end: ">", keywords: u, contains: ["self", i]
        }, { begin: e.IDENT_RE + "::", keywords: u }, {
            match: [/\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/, /\s+/, /\w+/],
            className: { 1: "keyword", 3: "title.class" }
          }])
      }
    }
  })(); hljs.registerLanguage("cpp", e)
})();/*! `shell` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var s = (() => {
    "use strict"; return s => ({
      name: "Shell Session",
      aliases: ["console", "shellsession"], contains: [{
        className: "meta",
        begin: /^\s{0,3}[/~\w\d[\]()@-]*[>%$#][ ]?/, starts: {
          end: /[^\\](?=\s*$)/,
          subLanguage: "bash"
        }
      }]
    })
  })(); hljs.registerLanguage("shell", s)
})();/*! `perl` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const n = e.regex, t = /[dualxmsipngr]{0,12}/, r = {
        $pattern: /[\w.]+/,
        keyword: "abs accept alarm and atan2 bind binmode bless break caller chdir chmod chomp chop chown chr chroot close closedir connect continue cos crypt dbmclose dbmopen defined delete die do dump each else elsif endgrent endhostent endnetent endprotoent endpwent endservent eof eval exec exists exit exp fcntl fileno flock for foreach fork format formline getc getgrent getgrgid getgrnam gethostbyaddr gethostbyname gethostent getlogin getnetbyaddr getnetbyname getnetent getpeername getpgrp getpriority getprotobyname getprotobynumber getprotoent getpwent getpwnam getpwuid getservbyname getservbyport getservent getsockname getsockopt given glob gmtime goto grep gt hex if index int ioctl join keys kill last lc lcfirst length link listen local localtime log lstat lt ma map mkdir msgctl msgget msgrcv msgsnd my ne next no not oct open opendir or ord our pack package pipe pop pos print printf prototype push q|0 qq quotemeta qw qx rand read readdir readline readlink readpipe recv redo ref rename require reset return reverse rewinddir rindex rmdir say scalar seek seekdir select semctl semget semop send setgrent sethostent setnetent setpgrp setpriority setprotoent setpwent setservent setsockopt shift shmctl shmget shmread shmwrite shutdown sin sleep socket socketpair sort splice split sprintf sqrt srand stat state study sub substr symlink syscall sysopen sysread sysseek system syswrite tell telldir tie tied time times tr truncate uc ucfirst umask undef unless unlink unpack unshift untie until use utime values vec wait waitpid wantarray warn when while write x|0 xor y|0"
      }, s = { className: "subst", begin: "[$@]\\{", end: "\\}", keywords: r }, i = {
        begin: /->\{/,
        end: /\}/
      }, a = {
        variants: [{ begin: /\$\d/ }, {
          begin: n.concat(/[$%@](\^\w\b|#\w+(::\w+)*|\{\w+\}|\w+(::\w*)*)/, "(?![A-Za-z])(?![@$%])")
        }, { begin: /[$%@][^\s\w{]/, relevance: 0 }]
      }, c = [e.BACKSLASH_ESCAPE, s, a], o = [/!/, /\//, /\|/, /\?/, /'/, /"/, /#/], g = (e, r, s = "\\1") => {
        const i = "\\1" === s ? s : n.concat(s, r)
          ; return n.concat(n.concat("(?:", e, ")"), r, /(?:\\.|[^\\\/])*?/, i, /(?:\\.|[^\\\/])*?/, s, t)
      }, l = (e, r, s) => n.concat(n.concat("(?:", e, ")"), r, /(?:\\.|[^\\\/])*?/, s, t), d = [a, e.HASH_COMMENT_MODE, e.COMMENT(/^=\w/, /=cut/, {
        endsWithParent: !0
      }), i, {
          className: "string", contains: c, variants: [{
            begin: "q[qwxr]?\\s*\\(", end: "\\)", relevance: 5
          }, {
            begin: "q[qwxr]?\\s*\\[",
            end: "\\]", relevance: 5
          }, { begin: "q[qwxr]?\\s*\\{", end: "\\}", relevance: 5 }, {
            begin: "q[qwxr]?\\s*\\|", end: "\\|", relevance: 5
          }, {
            begin: "q[qwxr]?\\s*<", end: ">",
            relevance: 5
          }, { begin: "qw\\s+q", end: "q", relevance: 5 }, {
            begin: "'", end: "'",
            contains: [e.BACKSLASH_ESCAPE]
          }, { begin: '"', end: '"' }, {
            begin: "`", end: "`",
            contains: [e.BACKSLASH_ESCAPE]
          }, { begin: /\{\w+\}/, relevance: 0 }, {
            begin: "-?\\w+\\s*=>", relevance: 0
          }]
        }, {
          className: "number",
          begin: "(\\b0[0-7_]+)|(\\b0x[0-9a-fA-F_]+)|(\\b[1-9][0-9_]*(\\.[0-9_]+)?)|[0_]\\b",
          relevance: 0
        }, {
          begin: "(\\/\\/|" + e.RE_STARTERS_RE + "|\\b(split|return|print|reverse|grep)\\b)\\s*",
          keywords: "split return print reverse grep", relevance: 0,
          contains: [e.HASH_COMMENT_MODE, {
            className: "regexp", variants: [{
              begin: g("s|tr|y", n.either(...o, { capture: !0 }))
            }, { begin: g("s|tr|y", "\\(", "\\)") }, {
              begin: g("s|tr|y", "\\[", "\\]")
            }, { begin: g("s|tr|y", "\\{", "\\}") }], relevance: 2
          }, {
            className: "regexp", variants: [{ begin: /(m|qr)\/\//, relevance: 0 }, {
              begin: l("(?:m|qr)?", /\//, /\//)
            }, {
              begin: l("m|qr", n.either(...o, {
                capture: !0
              }), /\1/)
            }, { begin: l("m|qr", /\(/, /\)/) }, { begin: l("m|qr", /\[/, /\]/) }, {
              begin: l("m|qr", /\{/, /\}/)
            }]
          }]
        }, {
          className: "function", beginKeywords: "sub",
          end: "(\\s*\\(.*?\\))?[;{]", excludeEnd: !0, relevance: 5, contains: [e.TITLE_MODE]
        }, {
          begin: "-\\w\\b", relevance: 0
        }, {
          begin: "^__DATA__$", end: "^__END__$",
          subLanguage: "mojolicious", contains: [{ begin: "^@@.*", end: "$", className: "comment" }]
        }]; return s.contains = d, i.contains = d, {
          name: "Perl", aliases: ["pl", "pm"], keywords: r,
          contains: d
        }
    }
  })(); hljs.registerLanguage("perl", e)
})();/*! `json` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => ({
      name: "JSON", contains: [{
        className: "attr", begin: /"(\\.|[^\\"\r\n])*"(?=\s*:)/, relevance: 1.01
      }, {
        match: /[{}[\],:]/, className: "punctuation", relevance: 0
      }, e.QUOTE_STRING_MODE, {
        beginKeywords: "true false null"
      }, e.C_NUMBER_MODE, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE], illegal: "\\S"
    })
  })(); hljs.registerLanguage("json", e)
})();/*! `lua` grammar compiled for Highlight.js 11.3.1 */
(() => {
  var e = (() => {
    "use strict"; return e => {
      const t = "\\[=*\\[", a = "\\]=*\\]", n = {
        begin: t, end: a, contains: ["self"]
      }, o = [e.COMMENT("--(?!\\[=*\\[)", "$"), e.COMMENT("--\\[=*\\[", a, {
        contains: [n],
        relevance: 10
      })]; return {
        name: "Lua", keywords: {
          $pattern: e.UNDERSCORE_IDENT_RE,
          literal: "true false nil",
          keyword: "and break do else elseif end for goto if in local not or repeat return then until while",
          built_in: "_G _ENV _VERSION __index __newindex __mode __call __metatable __tostring __len __gc __add __sub __mul __div __mod __pow __concat __unm __eq __lt __le assert collectgarbage dofile error getfenv getmetatable ipairs load loadfile loadstring module next pairs pcall print rawequal rawget rawset require select setfenv setmetatable tonumber tostring type unpack xpcall arg self coroutine resume yield status wrap create running debug getupvalue debug sethook getmetatable gethook setmetatable setlocal traceback setfenv getinfo setupvalue getlocal getregistry getfenv io lines write close flush open output type read stderr stdin input stdout popen tmpfile math log max acos huge ldexp pi cos tanh pow deg tan cosh sinh random randomseed frexp ceil floor rad abs sqrt modf asin min mod fmod log10 atan2 exp sin atan os exit setlocale date getenv difftime remove time clock tmpname rename execute package preload loadlib loaded loaders cpath config path seeall string sub upper len gfind rep find match char dump gmatch reverse byte format gsub lower table setn insert getn foreachi maxn foreach concat sort remove"
        }, contains: o.concat([{
          className: "function", beginKeywords: "function", end: "\\)",
          contains: [e.inherit(e.TITLE_MODE, {
            begin: "([_a-zA-Z]\\w*\\.)*([_a-zA-Z]\\w*:)?[_a-zA-Z]\\w*"
          }), {
            className: "params",
            begin: "\\(", endsWithParent: !0, contains: o
          }].concat(o)
        }, e.C_NUMBER_MODE, e.APOS_STRING_MODE, e.QUOTE_STRING_MODE, {
          className: "string",
          begin: t, end: a, contains: [n], relevance: 5
        }])
      }
    }
  })(); hljs.registerLanguage("lua", e)
})();