@plebeiantech/lat.md 0.12.3-fork.1

package/dist/src/view/highlight.js

@@ -0,0 +1,3767 @@
+/*!
+BSD 3-Clause License
+
+Copyright (c) 2006, Ivan Sagalaev.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+import { extname as st } from "node:path";
+function it(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var Ue, nn;
+function rt() {
+  if (nn) return Ue;
+  nn = 1;
+  function t(e) {
+    return e instanceof Map ? e.clear = e.delete = e.set = function() {
+      throw new Error("map is read-only");
+    } : e instanceof Set && (e.add = e.clear = e.delete = function() {
+      throw new Error("set is read-only");
+    }), Object.freeze(e), Object.getOwnPropertyNames(e).forEach((n) => {
+      const i = e[n], E = typeof i;
+      (E === "object" || E === "function") && !Object.isFrozen(i) && t(i);
+    }), e;
+  }
+  class g {
+    /**
+     * @param {CompiledMode} mode
+     */
+    constructor(n) {
+      n.data === void 0 && (n.data = {}), this.data = n.data, this.isMatchIgnored = !1;
+    }
+    ignoreMatch() {
+      this.isMatchIgnored = !0;
+    }
+  }
+  function d(e) {
+    return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+  }
+  function o(e, ...n) {
+    const i = /* @__PURE__ */ Object.create(null);
+    for (const E in e)
+      i[E] = e[E];
+    return n.forEach(function(E) {
+      for (const x in E)
+        i[x] = E[x];
+    }), /** @type {T} */
+    i;
+  }
+  const A = "</span>", D = (e) => !!e.scope, y = (e, { prefix: n }) => {
+    if (e.startsWith("language:"))
+      return e.replace("language:", "language-");
+    if (e.includes(".")) {
+      const i = e.split(".");
+      return [
+        `${n}${i.shift()}`,
+        ...i.map((E, x) => `${E}${"_".repeat(x + 1)}`)
+      ].join(" ");
+    }
+    return `${n}${e}`;
+  };
+  class h {
+    /**
+     * Creates a new HTMLRenderer
+     *
+     * @param {Tree} parseTree - the parse tree (must support `walk` API)
+     * @param {{classPrefix: string}} options
+     */
+    constructor(n, i) {
+      this.buffer = "", this.classPrefix = i.classPrefix, n.walk(this);
+    }
+    /**
+     * Adds texts to the output stream
+     *
+     * @param {string} text */
+    addText(n) {
+      this.buffer += d(n);
+    }
+    /**
+     * Adds a node open to the output stream (if needed)
+     *
+     * @param {Node} node */
+    openNode(n) {
+      if (!D(n)) return;
+      const i = y(
+        n.scope,
+        { prefix: this.classPrefix }
+      );
+      this.span(i);
+    }
+    /**
+     * Adds a node close to the output stream (if needed)
+     *
+     * @param {Node} node */
+    closeNode(n) {
+      D(n) && (this.buffer += A);
+    }
+    /**
+     * returns the accumulated buffer
+    */
+    value() {
+      return this.buffer;
+    }
+    // helpers
+    /**
+     * Builds a span element
+     *
+     * @param {string} className */
+    span(n) {
+      this.buffer += `<span class="${n}">`;
+    }
+  }
+  const M = (e = {}) => {
+    const n = { children: [] };
+    return Object.assign(n, e), n;
+  };
+  class w {
+    constructor() {
+      this.rootNode = M(), this.stack = [this.rootNode];
+    }
+    get top() {
+      return this.stack[this.stack.length - 1];
+    }
+    get root() {
+      return this.rootNode;
+    }
+    /** @param {Node} node */
+    add(n) {
+      this.top.children.push(n);
+    }
+    /** @param {string} scope */
+    openNode(n) {
+      const i = M({ scope: n });
+      this.add(i), this.stack.push(i);
+    }
+    closeNode() {
+      if (this.stack.length > 1)
+        return this.stack.pop();
+    }
+    closeAllNodes() {
+      for (; this.closeNode(); ) ;
+    }
+    toJSON() {
+      return JSON.stringify(this.rootNode, null, 4);
+    }
+    /**
+     * @typedef { import("./html_renderer").Renderer } Renderer
+     * @param {Renderer} builder
+     */
+    walk(n) {
+      return this.constructor._walk(n, this.rootNode);
+    }
+    /**
+     * @param {Renderer} builder
+     * @param {Node} node
+     */
+    static _walk(n, i) {
+      return typeof i == "string" ? n.addText(i) : i.children && (n.openNode(i), i.children.forEach((E) => this._walk(n, E)), n.closeNode(i)), n;
+    }
+    /**
+     * @param {Node} node
+     */
+    static _collapse(n) {
+      typeof n != "string" && n.children && (n.children.every((i) => typeof i == "string") ? n.children = [n.children.join("")] : n.children.forEach((i) => {
+        w._collapse(i);
+      }));
+    }
+  }
+  class I extends w {
+    /**
+     * @param {*} options
+     */
+    constructor(n) {
+      super(), this.options = n;
+    }
+    /**
+     * @param {string} text
+     */
+    addText(n) {
+      n !== "" && this.add(n);
+    }
+    /** @param {string} scope */
+    startScope(n) {
+      this.openNode(n);
+    }
+    endScope() {
+      this.closeNode();
+    }
+    /**
+     * @param {Emitter & {root: DataNode}} emitter
+     * @param {string} name
+     */
+    __addSublanguage(n, i) {
+      const E = n.root;
+      i && (E.scope = `language:${i}`), this.add(E);
+    }
+    toHTML() {
+      return new h(this, this.options).value();
+    }
+    finalize() {
+      return this.closeAllNodes(), !0;
+    }
+  }
+  function C(e) {
+    return e ? typeof e == "string" ? e : e.source : null;
+  }
+  function T(e) {
+    return R("(?=", e, ")");
+  }
+  function F(e) {
+    return R("(?:", e, ")*");
+  }
+  function L(e) {
+    return R("(?:", e, ")?");
+  }
+  function R(...e) {
+    return e.map((i) => C(i)).join("");
+  }
+  function Z(e) {
+    const n = e[e.length - 1];
+    return typeof n == "object" && n.constructor === Object ? (e.splice(e.length - 1, 1), n) : {};
+  }
+  function Y(...e) {
+    return "(" + (Z(e).capture ? "" : "?:") + e.map((E) => C(E)).join("|") + ")";
+  }
+  function W(e) {
+    return new RegExp(e.toString() + "|").exec("").length - 1;
+  }
+  function Q(e, n) {
+    const i = e && e.exec(n);
+    return i && i.index === 0;
+  }
+  const U = new RegExp(Y(
+    /\[(?:[^\\\]]|\\.)*\]/,
+    // a character class, inside which ( and \ lose their meaning
+    /\(\?<(?![=!])[^>]+>/,
+    // a named capture group `(?<name>` (not a lookbehind `(?<=` / `(?<!`)
+    /\(\?'[^']+'/,
+    // a named capture group `(?'name'`
+    /\(\??/,
+    // an opening parenthesis, capturing or non-capturing / lookahead
+    /\\([1-9][0-9]*)/,
+    // a backreference like `\1`
+    /\\./
+    // any other escape sequence
+  ));
+  function G(e, { joinWith: n }) {
+    let i = 0;
+    return e.map((E) => {
+      i += 1;
+      const x = i;
+      let v = C(E), c = "";
+      for (; v.length > 0; ) {
+        const a = U.exec(v);
+        if (!a) {
+          c += v;
+          break;
+        }
+        c += v.substring(0, a.index), v = v.substring(a.index + a[0].length), a[0][0] === "\\" && a[1] ? c += "\\" + String(Number(a[1]) + x) : (c += a[0], (a[0] === "(" || /^\(\?[<']/.test(a[0])) && i++);
+      }
+      return c;
+    }).map((E) => `(${E})`).join(n);
+  }
+  const K = /\b\B/, re = "[a-zA-Z]\\w*", ne = "[a-zA-Z_]\\w*", de = "\\b\\d+(\\.\\d+)?", Ee = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", _e = "\\b(0b[01]+)", he = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~", Se = (e = {}) => {
+    const n = /^#![ ]*\//;
+    return e.binary && (e.begin = R(
+      n,
+      /.*\b/,
+      e.binary,
+      /\b.*/
+    )), o({
+      scope: "meta",
+      begin: n,
+      end: /$/,
+      relevance: 0,
+      /** @type {ModeCallback} */
+      "on:begin": (i, E) => {
+        i.index !== 0 && E.ignoreMatch();
+      }
+    }, e);
+  }, te = {
+    begin: "\\\\[\\s\\S]",
+    relevance: 0
+  }, Ae = {
+    scope: "string",
+    begin: "'",
+    end: "'",
+    illegal: "\\n",
+    contains: [te]
+  }, oe = {
+    scope: "string",
+    begin: '"',
+    end: '"',
+    illegal: "\\n",
+    contains: [te]
+  }, Ne = {
+    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/
+  }, S = function(e, n, i = {}) {
+    const E = o(
+      {
+        scope: "comment",
+        begin: e,
+        end: n,
+        contains: []
+      },
+      i
+    );
+    E.contains.push({
+      scope: "doctag",
+      // hack to avoid the space from being included. the space is necessary to
+      // match here to prevent the plain text rule below from gobbling up doctags
+      begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
+      end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
+      excludeBegin: !0,
+      relevance: 0
+    });
+    const x = Y(
+      // list of common 1 and 2 letter words in English
+      "I",
+      "a",
+      "is",
+      "so",
+      "us",
+      "to",
+      "at",
+      "if",
+      "in",
+      "it",
+      "on",
+      // note: this is not an exhaustive list of contractions, just popular ones
+      /[A-Za-z]+['](d|ve|re|ll|t|s|n)/,
+      // contractions - can't we'd they're let's, etc
+      /[A-Za-z]+[-][a-z]+/,
+      // `no-way`, etc.
+      /[A-Za-z][a-z]{2,}/
+      // allow capitalized words at beginning of sentences
+    );
+    return E.contains.push(
+      {
+        // TODO: how to include ", (, ) without breaking grammars that use these for
+        // comment delimiters?
+        // begin: /[ ]+([()"]?([A-Za-z'-]{3,}|is|a|I|so|us|[tT][oO]|at|if|in|it|on)[.]?[()":]?([.][ ]|[ ]|\))){3}/
+        // ---
+        // this tries to find sequences of 3 english words in a row (without any
+        // "programming" type syntax) this gives us a strong signal that we've
+        // TRULY found a comment - vs perhaps scanning with the wrong language.
+        // It's possible to find something that LOOKS like the start of the
+        // comment - but then if there is no readable text - good chance it is a
+        // false match and not a comment.
+        //
+        // for a visual example please see:
+        // https://github.com/highlightjs/highlight.js/issues/2827
+        begin: R(
+          /[ ]+/,
+          // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
+          "(",
+          x,
+          /[.]?[:]?([.][ ]|[ ])/,
+          "){3}"
+        )
+        // look for 3 words in a row
+      }
+    ), E;
+  }, z = S("//", "$"), X = S("/\\*", "\\*/"), J = S("#", "$"), se = {
+    scope: "number",
+    begin: de,
+    relevance: 0
+  }, le = {
+    scope: "number",
+    begin: Ee,
+    relevance: 0
+  }, En = {
+    scope: "number",
+    begin: _e,
+    relevance: 0
+  }, _n = {
+    scope: "regexp",
+    begin: /\/(?=[^/\n]*\/)/,
+    end: /\/[gimuy]*/,
+    contains: [
+      te,
+      {
+        begin: /\[/,
+        end: /\]/,
+        relevance: 0,
+        contains: [te]
+      }
+    ]
+  }, bn = {
+    scope: "title",
+    begin: re,
+    relevance: 0
+  }, pn = {
+    scope: "title",
+    begin: ne,
+    relevance: 0
+  }, hn = {
+    // excludes method names from keyword processing
+    begin: "\\.\\s*" + ne,
+    relevance: 0
+  };
+  var ye = /* @__PURE__ */ Object.freeze({
+    __proto__: null,
+    APOS_STRING_MODE: Ae,
+    BACKSLASH_ESCAPE: te,
+    BINARY_NUMBER_MODE: En,
+    BINARY_NUMBER_RE: _e,
+    COMMENT: S,
+    C_BLOCK_COMMENT_MODE: X,
+    C_LINE_COMMENT_MODE: z,
+    C_NUMBER_MODE: le,
+    C_NUMBER_RE: Ee,
+    END_SAME_AS_BEGIN: function(e) {
+      return Object.assign(
+        e,
+        {
+          /** @type {ModeCallback} */
+          "on:begin": (n, i) => {
+            i.data._beginMatch = n[1];
+          },
+          /** @type {ModeCallback} */
+          "on:end": (n, i) => {
+            i.data._beginMatch !== n[1] && i.ignoreMatch();
+          }
+        }
+      );
+    },
+    HASH_COMMENT_MODE: J,
+    IDENT_RE: re,
+    MATCH_NOTHING_RE: K,
+    METHOD_GUARD: hn,
+    NUMBER_MODE: se,
+    NUMBER_RE: de,
+    PHRASAL_WORDS_MODE: Ne,
+    QUOTE_STRING_MODE: oe,
+    REGEXP_MODE: _n,
+    RE_STARTERS_RE: he,
+    SHEBANG: Se,
+    TITLE_MODE: bn,
+    UNDERSCORE_IDENT_RE: ne,
+    UNDERSCORE_TITLE_MODE: pn
+  });
+  function Sn(e, n) {
+    e.input[e.index - 1] === "." && n.ignoreMatch();
+  }
+  function An(e, n) {
+    e.className !== void 0 && (e.scope = e.className, delete e.className);
+  }
+  function Nn(e, n) {
+    n && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)", e.__beforeBegin = Sn, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords, e.relevance === void 0 && (e.relevance = 0));
+  }
+  function Tn(e, n) {
+    Array.isArray(e.illegal) && (e.illegal = Y(...e.illegal));
+  }
+  function yn(e, n) {
+    if (e.match) {
+      if (e.begin || e.end) throw new Error("begin & end are not supported with match");
+      e.begin = e.match, delete e.match;
+    }
+  }
+  function Rn(e, n) {
+    e.relevance === void 0 && (e.relevance = 1);
+  }
+  const On = (e, n) => {
+    if (!e.beforeMatch) return;
+    if (e.starts) throw new Error("beforeMatch cannot be used with starts");
+    const i = Object.assign({}, e);
+    Object.keys(e).forEach((E) => {
+      delete e[E];
+    }), e.keywords = i.keywords, e.begin = R(i.beforeMatch, T(i.begin)), e.starts = {
+      relevance: 0,
+      contains: [
+        Object.assign(i, { endsParent: !0 })
+      ]
+    }, e.relevance = 0, delete i.beforeMatch;
+  }, mn = [
+    "of",
+    "and",
+    "for",
+    "in",
+    "not",
+    "or",
+    "if",
+    "then",
+    "parent",
+    // common variable name
+    "list",
+    // common variable name
+    "value"
+    // common variable name
+  ], Mn = "keyword";
+  function $e(e, n, i = Mn) {
+    const E = /* @__PURE__ */ Object.create(null);
+    return typeof e == "string" ? x(i, e.split(" ")) : Array.isArray(e) ? x(i, e) : Object.keys(e).forEach(function(v) {
+      Object.assign(
+        E,
+        $e(e[v], n, v)
+      );
+    }), E;
+    function x(v, c) {
+      n && (c = c.map((a) => a.toLowerCase())), c.forEach(function(a) {
+        const f = a.split("|");
+        E[f[0]] = [v, wn(f[0], f[1])];
+      });
+    }
+  }
+  function wn(e, n) {
+    return n ? Number(n) : In(e) ? 0 : 1;
+  }
+  function In(e) {
+    return mn.includes(e.toLowerCase());
+  }
+  const Fe = {}, ue = (e) => {
+    console.error(e);
+  }, He = (e, ...n) => {
+    console.log(`WARN: ${e}`, ...n);
+  }, be = (e, n) => {
+    Fe[`${e}/${n}`] || (console.log(`Deprecated as of ${e}. ${n}`), Fe[`${e}/${n}`] = !0);
+  }, Re = new Error();
+  function Ge(e, n, { key: i }) {
+    let E = 0;
+    const x = e[i], v = {}, c = {};
+    for (let a = 1; a <= n.length; a++)
+      c[a + E] = x[a], v[a + E] = !0, E += W(n[a - 1]);
+    e[i] = c, e[i]._emit = v, e[i]._multi = !0;
+  }
+  function Cn(e) {
+    if (Array.isArray(e.begin)) {
+      if (e.skip || e.excludeBegin || e.returnBegin)
+        throw ue("skip, excludeBegin, returnBegin not compatible with beginScope: {}"), Re;
+      if (typeof e.beginScope != "object" || e.beginScope === null)
+        throw ue("beginScope must be object"), Re;
+      Ge(e, e.begin, { key: "beginScope" }), e.begin = G(e.begin, { joinWith: "" });
+    }
+  }
+  function xn(e) {
+    if (Array.isArray(e.end)) {
+      if (e.skip || e.excludeEnd || e.returnEnd)
+        throw ue("skip, excludeEnd, returnEnd not compatible with endScope: {}"), Re;
+      if (typeof e.endScope != "object" || e.endScope === null)
+        throw ue("endScope must be object"), Re;
+      Ge(e, e.end, { key: "endScope" }), e.end = G(e.end, { joinWith: "" });
+    }
+  }
+  function vn(e) {
+    e.scope && typeof e.scope == "object" && e.scope !== null && (e.beginScope = e.scope, delete e.scope);
+  }
+  function Ln(e) {
+    vn(e), typeof e.beginScope == "string" && (e.beginScope = { _wrap: e.beginScope }), typeof e.endScope == "string" && (e.endScope = { _wrap: e.endScope }), Cn(e), xn(e);
+  }
+  function kn(e) {
+    function n(c, a) {
+      return new RegExp(
+        C(c),
+        "m" + (e.case_insensitive ? "i" : "") + (e.unicodeRegex ? "u" : "") + (a ? "g" : "")
+      );
+    }
+    class i {
+      constructor() {
+        this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0;
+      }
+      // @ts-ignore
+      addRule(a, f) {
+        f.position = this.position++, this.matchIndexes[this.matchAt] = f, this.regexes.push([f, a]), this.matchAt += W(a) + 1;
+      }
+      compile() {
+        this.regexes.length === 0 && (this.exec = () => null);
+        const a = this.regexes.map((f) => f[1]);
+        this.matcherRe = n(G(a, { joinWith: "|" }), !0), this.lastIndex = 0;
+      }
+      /** @param {string} s */
+      exec(a) {
+        this.matcherRe.lastIndex = this.lastIndex;
+        const f = this.matcherRe.exec(a);
+        if (!f)
+          return null;
+        const P = f.findIndex((Te, ve) => ve > 0 && Te !== void 0), k = this.matchIndexes[P];
+        return f.splice(0, P), Object.assign(f, k);
+      }
+    }
+    class E {
+      constructor() {
+        this.rules = [], this.multiRegexes = [], this.count = 0, this.lastIndex = 0, this.regexIndex = 0;
+      }
+      // @ts-ignore
+      getMatcher(a) {
+        if (this.multiRegexes[a]) return this.multiRegexes[a];
+        const f = new i();
+        return this.rules.slice(a).forEach(([P, k]) => f.addRule(P, k)), f.compile(), this.multiRegexes[a] = f, f;
+      }
+      resumingScanAtSamePosition() {
+        return this.regexIndex !== 0;
+      }
+      considerAll() {
+        this.regexIndex = 0;
+      }
+      // @ts-ignore
+      addRule(a, f) {
+        this.rules.push([a, f]), f.type === "begin" && this.count++;
+      }
+      /** @param {string} s */
+      exec(a) {
+        const f = this.getMatcher(this.regexIndex);
+        f.lastIndex = this.lastIndex;
+        let P = f.exec(a);
+        if (this.resumingScanAtSamePosition() && !(P && P.index === this.lastIndex)) {
+          const k = this.getMatcher(0);
+          k.lastIndex = this.lastIndex + 1, P = k.exec(a);
+        }
+        return P && (this.regexIndex += P.position + 1, this.regexIndex === this.count && this.considerAll()), P;
+      }
+    }
+    function x(c) {
+      const a = new E();
+      return c.contains.forEach((f) => a.addRule(f.begin, { rule: f, type: "begin" })), c.terminatorEnd && a.addRule(c.terminatorEnd, { type: "end" }), c.illegal && a.addRule(c.illegal, { type: "illegal" }), a;
+    }
+    function v(c, a) {
+      const f = (
+        /** @type CompiledMode */
+        c
+      );
+      if (c.isCompiled) return f;
+      [
+        An,
+        // do this early so compiler extensions generally don't have to worry about
+        // the distinction between match/begin
+        yn,
+        Ln,
+        On
+      ].forEach((k) => k(c, a)), e.compilerExtensions.forEach((k) => k(c, a)), c.__beforeBegin = null, [
+        Nn,
+        // do this later so compiler extensions that come earlier have access to the
+        // raw array if they wanted to perhaps manipulate it, etc.
+        Tn,
+        // default to 1 relevance if not specified
+        Rn
+      ].forEach((k) => k(c, a)), c.isCompiled = !0;
+      let P = null;
+      return typeof c.keywords == "object" && c.keywords.$pattern && (c.keywords = Object.assign({}, c.keywords), P = c.keywords.$pattern, delete c.keywords.$pattern), P = P || /\w+/, c.keywords && (c.keywords = $e(c.keywords, e.case_insensitive)), f.keywordPatternRe = n(P, !0), a && (c.begin || (c.begin = /\B|\b/), f.beginRe = n(f.begin), !c.end && !c.endsWithParent && (c.end = /\B|\b/), c.end && (f.endRe = n(f.end)), f.terminatorEnd = C(f.end) || "", c.endsWithParent && a.terminatorEnd && (f.terminatorEnd += (c.end ? "|" : "") + a.terminatorEnd)), c.illegal && (f.illegalRe = n(
+        /** @type {RegExp | string} */
+        c.illegal
+      )), c.contains || (c.contains = []), c.contains = [].concat(...c.contains.map(function(k) {
+        return Dn(k === "self" ? c : k);
+      })), c.contains.forEach(function(k) {
+        v(
+          /** @type Mode */
+          k,
+          f
+        );
+      }), c.starts && v(c.starts, a), f.matcher = x(f), f;
+    }
+    if (e.compilerExtensions || (e.compilerExtensions = []), e.contains && e.contains.includes("self"))
+      throw new Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.");
+    return e.classNameAliases = o(e.classNameAliases || {}), v(
+      /** @type Mode */
+      e
+    );
+  }
+  function Ke(e) {
+    return e ? e.endsWithParent || Ke(e.starts) : !1;
+  }
+  function Dn(e) {
+    return e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map(function(n) {
+      return o(e, { variants: null }, n);
+    })), e.cachedVariants ? e.cachedVariants : Ke(e) ? o(e, { starts: e.starts ? o(e.starts) : null }) : Object.isFrozen(e) ? o(e) : e;
+  }
+  var Bn = "11.12.0";
+  class Pn extends Error {
+    constructor(n, i) {
+      super(n), this.name = "HTMLInjectionError", this.html = i;
+    }
+  }
+  const xe = d, ze = o, Ze = /* @__PURE__ */ Symbol("nomatch"), Un = 7, We = function(e) {
+    const n = /* @__PURE__ */ Object.create(null), i = /* @__PURE__ */ Object.create(null), E = [];
+    let x = !0;
+    const v = "Could not find the language '{}', did you forget to load/include a language module?", c = { disableAutodetect: !0, name: "Plain text", contains: [] };
+    let a = {
+      ignoreUnescapedHTML: !1,
+      throwUnescapedHTML: !1,
+      noHighlightRe: /^(no-?highlight)$/i,
+      languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
+      classPrefix: "hljs-",
+      cssSelector: "pre code",
+      languages: null,
+      // beta configuration options, subject to change, welcome to discuss
+      // https://github.com/highlightjs/highlight.js/issues/1086
+      __emitter: I
+    };
+    function f(s) {
+      return a.noHighlightRe.test(s);
+    }
+    function P(s) {
+      let u = s.className + " ";
+      u += s.parentNode ? s.parentNode.className : "";
+      const p = a.languageDetectRe.exec(u);
+      if (p) {
+        const O = ae(p[1]);
+        return O || (He(v.replace("{}", p[1])), He("Falling back to no-highlight mode for this block.", s)), O ? p[1] : "no-highlight";
+      }
+      return u.split(/\s+/).find((O) => f(O) || ae(O));
+    }
+    function k(s, u, p) {
+      let O = "", B = "";
+      typeof u == "object" ? (O = s, p = u.ignoreIllegals, B = u.language) : (be("10.7.0", "highlight(lang, code, ...args) has been deprecated."), be("10.7.0", `Please use highlight(code, options) instead.
+https://github.com/highlightjs/highlight.js/issues/2277`), B = s, O = u), p === void 0 && (p = !0);
+      const V = {
+        code: O,
+        language: B
+      };
+      me("before:highlight", V);
+      const ce = V.result ? V.result : Te(V.language, V.code, p);
+      return ce.code = V.code, me("after:highlight", ce), ce;
+    }
+    function Te(s, u, p, O) {
+      const B = /* @__PURE__ */ Object.create(null);
+      function V(r, l) {
+        return r.keywords[l];
+      }
+      function ce() {
+        if (!_.keywords) {
+          $.addText(m);
+          return;
+        }
+        let r = 0;
+        _.keywordPatternRe.lastIndex = 0;
+        let l = _.keywordPatternRe.exec(m), b = "";
+        for (; l; ) {
+          b += m.substring(r, l.index);
+          const N = ee.case_insensitive ? l[0].toLowerCase() : l[0], H = V(_, N);
+          if (H) {
+            const [ie, nt] = H;
+            if ($.addText(b), b = "", B[N] = (B[N] || 0) + 1, B[N] <= Un && (Ie += nt), ie.startsWith("_"))
+              b += l[0];
+            else {
+              const tt = ee.classNameAliases[ie] || ie;
+              j(l[0], tt);
+            }
+          } else
+            b += l[0];
+          r = _.keywordPatternRe.lastIndex, l = _.keywordPatternRe.exec(m);
+        }
+        b += m.substring(r), $.addText(b);
+      }
+      function Me() {
+        if (m === "") return;
+        let r = null;
+        if (typeof _.subLanguage == "string") {
+          if (!n[_.subLanguage]) {
+            $.addText(m);
+            return;
+          }
+          r = Te(_.subLanguage, m, !0, en[_.subLanguage]), en[_.subLanguage] = /** @type {CompiledMode} */
+          r._top;
+        } else
+          r = Le(m, _.subLanguage.length ? _.subLanguage : null);
+        _.relevance > 0 && (Ie += r.relevance), $.__addSublanguage(r._emitter, r.language);
+      }
+      function q() {
+        _.subLanguage != null ? Me() : ce(), m = "";
+      }
+      function j(r, l) {
+        r !== "" && ($.startScope(l), $.addText(r), $.endScope());
+      }
+      function Je(r, l) {
+        let b = 1;
+        const N = l.length - 1;
+        for (; b <= N; ) {
+          if (!r._emit[b]) {
+            b++;
+            continue;
+          }
+          const H = ee.classNameAliases[r[b]] || r[b], ie = l[b];
+          H ? j(ie, H) : (m = ie, ce(), m = ""), b++;
+        }
+      }
+      function Ve(r, l) {
+        return r.scope && typeof r.scope == "string" && $.openNode(ee.classNameAliases[r.scope] || r.scope), r.beginScope && (r.beginScope._wrap ? (j(m, ee.classNameAliases[r.beginScope._wrap] || r.beginScope._wrap), m = "") : r.beginScope._multi && (Je(r.beginScope, l), m = "")), _ = Object.create(r, { parent: { value: _ } }), _;
+      }
+      function Qe(r, l, b) {
+        let N = Q(r.endRe, b);
+        if (N) {
+          if (r["on:end"]) {
+            const H = new g(r);
+            r["on:end"](l, H), H.isMatchIgnored && (N = !1);
+          }
+          if (N) {
+            for (; r.endsParent && r.parent; )
+              r = r.parent;
+            return r;
+          }
+        }
+        if (r.endsWithParent)
+          return Qe(r.parent, l, b);
+      }
+      function Jn(r) {
+        return _.matcher.regexIndex === 0 ? (m += r[0], 1) : (Pe = !0, 0);
+      }
+      function Vn(r) {
+        const l = r[0], b = r.rule, N = new g(b), H = [b.__beforeBegin, b["on:begin"]];
+        for (const ie of H)
+          if (ie && (ie(r, N), N.isMatchIgnored))
+            return Jn(l);
+        return b.skip ? m += l : (b.excludeBegin && (m += l), q(), !b.returnBegin && !b.excludeBegin && (m = l)), Ve(b, r), b.returnBegin ? 0 : l.length;
+      }
+      function Qn(r) {
+        const l = r[0], b = u.substring(r.index), N = Qe(_, r, b);
+        if (!N)
+          return Ze;
+        const H = _;
+        _.endScope && _.endScope._wrap ? (q(), j(l, _.endScope._wrap)) : _.endScope && _.endScope._multi ? (q(), Je(_.endScope, r)) : H.skip ? m += l : (H.returnEnd || H.excludeEnd || (m += l), q(), H.excludeEnd && (m = l));
+        do
+          _.scope && $.closeNode(), !_.skip && !_.subLanguage && (Ie += _.relevance), _ = _.parent;
+        while (_ !== N.parent);
+        return N.starts && Ve(N.starts, r), H.returnEnd ? 0 : l.length;
+      }
+      function jn() {
+        const r = [];
+        for (let l = _; l !== ee; l = l.parent)
+          l.scope && r.unshift(l.scope);
+        r.forEach((l) => $.openNode(l));
+      }
+      let we = {};
+      function je(r, l) {
+        const b = l && l[0];
+        if (m += r, b == null)
+          return q(), 0;
+        if (we.type === "begin" && l.type === "end" && we.index === l.index && b === "") {
+          if (m += u.slice(l.index, l.index + 1), !x) {
+            const N = new Error(`0 width match regex (${s})`);
+            throw N.languageName = s, N.badRule = we.rule, N;
+          }
+          return 1;
+        }
+        if (we = l, l.type === "begin")
+          return Vn(l);
+        if (l.type === "illegal" && !p) {
+          const N = new Error('Illegal lexeme "' + b + '" for mode "' + (_.scope || "<unnamed>") + '"');
+          throw N.mode = _, N;
+        } else if (l.type === "end") {
+          const N = Qn(l);
+          if (N !== Ze)
+            return N;
+        }
+        if (l.type === "illegal" && b === "")
+          return l.index === u.length || (m += `
+`), 1;
+        if (Be > 1e5 && Be > l.index * 3)
+          throw new Error("potential infinite loop, way more iterations than matches");
+        return m += b, b.length;
+      }
+      const ee = ae(s);
+      if (!ee)
+        throw ue(v.replace("{}", s)), new Error('Unknown language: "' + s + '"');
+      const et = kn(ee);
+      let De = "", _ = O || et;
+      const en = {}, $ = new a.__emitter(a);
+      jn();
+      let m = "", Ie = 0, ge = 0, Be = 0, Pe = !1;
+      try {
+        if (ee.__emitTokens)
+          ee.__emitTokens(u, $);
+        else {
+          for (_.matcher.considerAll(); ; ) {
+            Be++, Pe ? Pe = !1 : _.matcher.considerAll(), _.matcher.lastIndex = ge;
+            const r = _.matcher.exec(u);
+            if (!r) break;
+            const l = u.substring(ge, r.index), b = je(l, r);
+            ge = r.index + b;
+          }
+          je(u.substring(ge));
+        }
+        return $.finalize(), De = $.toHTML(), {
+          language: s,
+          value: De,
+          relevance: Ie,
+          illegal: !1,
+          _emitter: $,
+          _top: _
+        };
+      } catch (r) {
+        if (r.message && r.message.includes("Illegal"))
+          return {
+            language: s,
+            value: xe(u),
+            illegal: !0,
+            relevance: 0,
+            _illegalBy: {
+              message: r.message,
+              index: ge,
+              context: u.slice(ge - 100, ge + 100),
+              mode: r.mode,
+              resultSoFar: De
+            },
+            _emitter: $
+          };
+        if (x)
+          return {
+            language: s,
+            value: xe(u),
+            illegal: !1,
+            relevance: 0,
+            errorRaised: r,
+            _emitter: $,
+            _top: _
+          };
+        throw r;
+      }
+    }
+    function ve(s) {
+      const u = {
+        value: xe(s),
+        illegal: !1,
+        relevance: 0,
+        _top: c,
+        _emitter: new a.__emitter(a)
+      };
+      return u._emitter.addText(s), u;
+    }
+    function Le(s, u) {
+      u = u || a.languages || Object.keys(n);
+      const p = ve(s), O = u.filter(ae).filter(qe).map(
+        (q) => Te(q, s, !1)
+      );
+      O.unshift(p);
+      const B = O.sort((q, j) => {
+        if (q.relevance !== j.relevance) return j.relevance - q.relevance;
+        if (q.language && j.language) {
+          if (ae(q.language).supersetOf === j.language)
+            return 1;
+          if (ae(j.language).supersetOf === q.language)
+            return -1;
+        }
+        return 0;
+      }), [V, ce] = B, Me = V;
+      return Me.secondBest = ce, Me;
+    }
+    function $n(s, u, p) {
+      const O = u && i[u] || p;
+      s.classList.add("hljs"), s.classList.add(`language-${O}`);
+    }
+    function ke(s) {
+      let u = null;
+      const p = P(s);
+      if (f(p)) return;
+      if (me(
+        "before:highlightElement",
+        { el: s, language: p }
+      ), s.dataset.highlighted) {
+        console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", s);
+        return;
+      }
+      if (s.children.length > 0 && (a.ignoreUnescapedHTML || (console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."), console.warn("https://github.com/highlightjs/highlight.js/wiki/security"), console.warn("The element with unescaped HTML:"), console.warn(s)), a.throwUnescapedHTML))
+        throw new Pn(
+          "One of your code blocks includes unescaped HTML.",
+          s.innerHTML
+        );
+      u = s;
+      const O = u.textContent, B = p ? k(O, { language: p, ignoreIllegals: !0 }) : Le(O);
+      s.innerHTML = B.value, s.dataset.highlighted = "yes", $n(s, p, B.language), s.result = {
+        language: B.language,
+        // TODO: remove with version 11.0
+        re: B.relevance,
+        relevance: B.relevance
+      }, B.secondBest && (s.secondBest = {
+        language: B.secondBest.language,
+        relevance: B.secondBest.relevance
+      }), me("after:highlightElement", { el: s, result: B, text: O });
+    }
+    function Fn(s) {
+      a = ze(a, s);
+    }
+    const Hn = () => {
+      Oe(), be("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
+    };
+    function Gn() {
+      Oe(), be("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
+    }
+    let Ye = !1;
+    function Oe() {
+      function s() {
+        Oe();
+      }
+      if (document.readyState === "loading") {
+        Ye || window.addEventListener("DOMContentLoaded", s, !1), Ye = !0;
+        return;
+      }
+      document.querySelectorAll(a.cssSelector).forEach(ke);
+    }
+    function Kn(s, u) {
+      let p = null;
+      try {
+        p = u(e);
+      } catch (O) {
+        if (ue("Language definition for '{}' could not be registered.".replace("{}", s)), x)
+          ue(O);
+        else
+          throw O;
+        p = c;
+      }
+      p.name || (p.name = s), n[s] = p, p.rawDefinition = u.bind(null, e), p.aliases && Xe(p.aliases, { languageName: s });
+    }
+    function zn(s) {
+      delete n[s];
+      for (const u of Object.keys(i))
+        i[u] === s && delete i[u];
+    }
+    function Zn() {
+      return Object.keys(n);
+    }
+    function ae(s) {
+      return s = (s || "").toLowerCase(), n[s] || n[i[s]];
+    }
+    function Xe(s, { languageName: u }) {
+      typeof s == "string" && (s = [s]), s.forEach((p) => {
+        i[p.toLowerCase()] = u;
+      });
+    }
+    function qe(s) {
+      const u = ae(s);
+      return u && !u.disableAutodetect;
+    }
+    function Wn(s) {
+      s["before:highlightBlock"] && !s["before:highlightElement"] && (s["before:highlightElement"] = (u) => {
+        s["before:highlightBlock"](
+          Object.assign({ block: u.el }, u)
+        );
+      }), s["after:highlightBlock"] && !s["after:highlightElement"] && (s["after:highlightElement"] = (u) => {
+        s["after:highlightBlock"](
+          Object.assign({ block: u.el }, u)
+        );
+      });
+    }
+    function Yn(s) {
+      Wn(s), E.push(s);
+    }
+    function Xn(s) {
+      const u = E.indexOf(s);
+      u !== -1 && E.splice(u, 1);
+    }
+    function me(s, u) {
+      const p = s;
+      E.forEach(function(O) {
+        O[p] && O[p](u);
+      });
+    }
+    function qn(s) {
+      return be("10.7.0", "highlightBlock will be removed entirely in v12.0"), be("10.7.0", "Please use highlightElement now."), ke(s);
+    }
+    Object.assign(e, {
+      highlight: k,
+      highlightAuto: Le,
+      highlightAll: Oe,
+      highlightElement: ke,
+      // TODO: Remove with v12 API
+      highlightBlock: qn,
+      configure: Fn,
+      initHighlighting: Hn,
+      initHighlightingOnLoad: Gn,
+      registerLanguage: Kn,
+      unregisterLanguage: zn,
+      listLanguages: Zn,
+      getLanguage: ae,
+      registerAliases: Xe,
+      autoDetection: qe,
+      inherit: ze,
+      addPlugin: Yn,
+      removePlugin: Xn
+    }), e.debugMode = function() {
+      x = !1;
+    }, e.safeMode = function() {
+      x = !0;
+    }, e.versionString = Bn, e.regex = {
+      concat: R,
+      lookahead: T,
+      either: Y,
+      optional: L,
+      anyNumberOfTimes: F
+    };
+    for (const s in ye)
+      typeof ye[s] == "object" && t(ye[s]);
+    return Object.assign(e, ye), e;
+  }, pe = We({});
+  return pe.newInstance = () => We({}), Ue = pe, pe.HighlightJS = pe, pe.default = pe, Ue;
+}
+var at = /* @__PURE__ */ rt();
+const fe = /* @__PURE__ */ it(at);
+function ct(t) {
+  const g = t.regex, d = t.COMMENT("//", "$", { contains: [{ begin: /\\\n/ }] }), o = "decltype\\(auto\\)", A = "[a-zA-Z_]\\w*::", y = "(" + o + "|" + g.optional(A) + "[a-zA-Z_]\\w*" + g.optional("<[^<>]+>") + ")", h = g.concat(/\batomic_/, g.either(
+    "bool",
+    "char",
+    "schar",
+    "uchar",
+    "short",
+    "ushort",
+    "int",
+    "uint",
+    "long",
+    "ulong",
+    "llong",
+    "ullong",
+    "char16_t",
+    "char32_t",
+    "wchar_t",
+    "int_least8_t",
+    "uint_least8_t",
+    "int_least16_t",
+    "uint_least16_t",
+    "int_least32_t",
+    "uint_least32_t",
+    "int_least64_t",
+    "uint_least64_t",
+    "int_fast8_t",
+    "uint_fast8_t",
+    "int_fast16_t",
+    "uint_fast16_t",
+    "int_fast32_t",
+    "uint_fast32_t",
+    "int_fast64_t",
+    "uint_fast64_t",
+    "intptr_t",
+    "uintptr_t",
+    "size_t",
+    "ptrdiff_t",
+    "intmax_t",
+    "uintmax_t"
+  ), /\b/), M = {
+    className: "type",
+    variants: [
+      { begin: "\\b[a-z\\d_]*_t\\b" },
+      { match: h }
+    ]
+  }, I = {
+    className: "string",
+    variants: [
+      {
+        begin: '(u8?|U|L)?"',
+        end: '"',
+        illegal: "\\n",
+        contains: [t.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: "."
+      },
+      // https://en.cppreference.com/w/cpp/language/string_literal
+      // a d-char-sequence never contains parentheses, backslashes or whitespace;
+      // quotes are excluded as well so the closing delimiter cannot swallow the
+      // quote that actually terminates the literal
+      t.END_SAME_AS_BEGIN({
+        begin: /(?:u8?|U|L)?R"([^()\\\s"]{0,16})\(/,
+        end: /\)([^()\\\s"]{0,16})"/
+      })
+    ]
+  }, C = {
+    className: "number",
+    variants: [
+      { match: /\b(0b[01']+)/ },
+      { match: /(-?)\b([\d']+(\.[\d']*)?|\.[\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)/ },
+      { match: /(-?)\b(0[xX][a-fA-F0-9]+(?:'[a-fA-F0-9]+)*(?:\.[a-fA-F0-9]*(?:'[a-fA-F0-9]*)*)?(?:[pP][-+]?[0-9]+)?(l|L)?(u|U)?)/ },
+      { match: /(-?)\b\d+(?:'\d+)*(?:\.\d*(?:'\d*)*)?(?:[eE][-+]?\d+)?/ }
+    ],
+    relevance: 0
+  }, T = {
+    scope: "meta",
+    begin: /#\s*include\b/,
+    end: /$/,
+    keywords: { keyword: "include" },
+    contains: [
+      {
+        // the `\` at the end of a line signaling continuation
+        begin: /\\\n/
+      },
+      I,
+      {
+        scope: "string",
+        begin: /<.*?>/
+      },
+      d,
+      t.C_BLOCK_COMMENT_MODE
+    ]
+  }, F = {
+    className: "meta",
+    begin: /#\s*[a-z]+\b/,
+    end: /$/,
+    keywords: { keyword: "if else elif endif define undef warning error line pragma _Pragma ifdef ifndef elifdef elifndef include" },
+    contains: [
+      {
+        begin: /\\\n/,
+        relevance: 0
+      },
+      t.inherit(I, { className: "string" }),
+      d,
+      t.C_BLOCK_COMMENT_MODE
+    ]
+  }, L = [
+    T,
+    F
+  ], R = {
+    className: "title",
+    begin: g.optional(A) + t.IDENT_RE,
+    relevance: 0
+  }, Z = g.optional(A) + t.IDENT_RE + "\\s*\\(", Y = 12, U = {
+    keyword: [
+      "asm",
+      "auto",
+      "break",
+      "case",
+      "continue",
+      "default",
+      "do",
+      "else",
+      "enum",
+      "extern",
+      "for",
+      "fortran",
+      "goto",
+      "if",
+      "inline",
+      "register",
+      "restrict",
+      "return",
+      "sizeof",
+      "typeof",
+      "typeof_unqual",
+      "struct",
+      "switch",
+      "typedef",
+      "union",
+      "volatile",
+      "while",
+      "_Alignas",
+      "_Alignof",
+      "_Atomic",
+      "_Generic",
+      "_Noreturn",
+      "_Static_assert",
+      "_Thread_local",
+      // aliases
+      "alignas",
+      "alignof",
+      "noreturn",
+      "static_assert",
+      "thread_local",
+      // not a C keyword but is, for all intents and purposes, treated exactly like one.
+      "_Pragma"
+    ],
+    type: [
+      "float",
+      "double",
+      "signed",
+      "unsigned",
+      "int",
+      "short",
+      "long",
+      "char",
+      "void",
+      "_Bool",
+      "_BitInt",
+      "_Complex",
+      "_Imaginary",
+      "_Decimal32",
+      "_Decimal64",
+      "_Decimal96",
+      "_Decimal128",
+      "_Decimal64x",
+      "_Decimal128x",
+      "_Float16",
+      "_Float32",
+      "_Float64",
+      "_Float128",
+      "_Float32x",
+      "_Float64x",
+      "_Float128x",
+      // modifiers
+      "const",
+      "static",
+      "constexpr",
+      // aliases
+      "complex",
+      "bool",
+      "imaginary"
+    ],
+    literal: "true false NULL",
+    // TODO: apply hinting work similar to what was done in cpp.js
+    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 = [
+    ...L,
+    M,
+    d,
+    t.C_BLOCK_COMMENT_MODE,
+    C,
+    I
+  ], K = {
+    // This mode covers expression context where we can't expect a function
+    // definition and shouldn't highlight anything that looks like one:
+    // `return some()`, `else if()`, `(x*sum(1, 2))`
+    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
+  }, re = {
+    begin: "(" + y + "[\\*&\\s]+){1," + Y + "}" + Z,
+    returnBegin: !0,
+    end: /[{;=]/,
+    excludeEnd: !0,
+    keywords: U,
+    illegal: /[^\w\s\*&:<>.]/,
+    contains: [
+      {
+        // to prevent it from being confused as the function title
+        begin: o,
+        keywords: U,
+        relevance: 0
+      },
+      {
+        begin: Z,
+        returnBegin: !0,
+        contains: [t.inherit(R, { className: "title.function" })],
+        relevance: 0
+      },
+      // allow for multiple declarations, e.g.:
+      // extern void f(int), g(char);
+      {
+        relevance: 0,
+        match: /,/
+      },
+      {
+        className: "params",
+        begin: /\(/,
+        end: /\)/,
+        keywords: U,
+        relevance: 0,
+        contains: [
+          d,
+          t.C_BLOCK_COMMENT_MODE,
+          I,
+          C,
+          M,
+          // Count matching parentheses.
+          {
+            begin: /\(/,
+            end: /\)/,
+            keywords: U,
+            relevance: 0,
+            contains: [
+              "self",
+              d,
+              t.C_BLOCK_COMMENT_MODE,
+              I,
+              C,
+              M
+            ]
+          }
+        ]
+      },
+      M,
+      d,
+      t.C_BLOCK_COMMENT_MODE,
+      ...L
+    ]
+  };
+  return {
+    name: "C",
+    aliases: ["h"],
+    keywords: U,
+    // Until differentiations are added between `c` and `cpp`, `c` will
+    // not be auto-detected to avoid auto-detect conflicts between C and C++
+    disableAutodetect: !0,
+    illegal: "</",
+    contains: [].concat(
+      K,
+      re,
+      G,
+      [
+        ...L,
+        {
+          begin: t.IDENT_RE + "::",
+          keywords: U
+        },
+        {
+          className: "class",
+          beginKeywords: "enum class struct union",
+          end: /[{;:<>=]/,
+          contains: [
+            { beginKeywords: "final class struct" },
+            t.TITLE_MODE
+          ]
+        }
+      ]
+    ),
+    exports: {
+      preprocessor: F,
+      strings: I,
+      keywords: U
+    }
+  };
+}
+function ot(t) {
+  const D = {
+    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: D,
+    illegal: "</",
+    contains: [
+      t.C_LINE_COMMENT_MODE,
+      t.C_BLOCK_COMMENT_MODE,
+      {
+        className: "string",
+        variants: [
+          t.QUOTE_STRING_MODE,
+          t.APOS_STRING_MODE,
+          {
+            begin: "`",
+            end: "`"
+          }
+        ]
+      },
+      {
+        className: "number",
+        variants: [
+          {
+            match: /-?\b0[xX]\.[a-fA-F0-9](_?[a-fA-F0-9])*[pP][+-]?\d(_?\d)*i?/,
+            // hex without a present digit before . (making a digit afterwards required)
+            relevance: 0
+          },
+          {
+            match: /-?\b0[xX](_?[a-fA-F0-9])+((\.([a-fA-F0-9](_?[a-fA-F0-9])*)?)?[pP][+-]?\d(_?\d)*)?i?/,
+            // hex with a present digit before . (making a digit afterwards optional)
+            relevance: 0
+          },
+          {
+            match: /-?\b0[oO](_?[0-7])*i?/,
+            // leading 0o octal
+            relevance: 0
+          },
+          {
+            match: /-?\b0[bB](_?[01])*i?/,
+            // leading 0b binary
+            relevance: 0
+          },
+          {
+            match: /-?\.\d(_?\d)*([eE][+-]?\d(_?\d)*)?i?/,
+            // decimal without a present digit before . (making a digit afterwards required)
+            relevance: 0
+          },
+          {
+            match: /-?\b\d(_?\d)*(\.(\d(_?\d)*)?)?([eE][+-]?\d(_?\d)*)?i?/,
+            // decimal with a present digit before . (making a digit afterwards optional)
+            relevance: 0
+          }
+        ]
+      },
+      {
+        begin: /:=/
+        // relevance booster
+      },
+      {
+        className: "function",
+        beginKeywords: "func",
+        end: "\\s*(\\{|$)",
+        excludeEnd: !0,
+        contains: [
+          t.TITLE_MODE,
+          {
+            className: "params",
+            begin: /\(/,
+            end: /\)/,
+            endsParent: !0,
+            keywords: D,
+            illegal: /["']/
+          }
+        ]
+      }
+    ]
+  };
+}
+const tn = "[A-Za-z$_][0-9A-Za-z$_]*", lt = [
+  "as",
+  // for exports
+  "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",
+  // JS handles these with a special rule
+  // "get",
+  // "set",
+  "debugger",
+  "async",
+  "await",
+  "static",
+  "import",
+  "from",
+  "export",
+  "extends",
+  // It's reached stage 3, which is "recommended for implementation":
+  "using"
+], ut = [
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "NaN",
+  "Infinity"
+], sn = [
+  // Fundamental objects
+  "Object",
+  "Function",
+  "Boolean",
+  "Symbol",
+  // numbers and dates
+  "Math",
+  "Date",
+  "Number",
+  "BigInt",
+  // text
+  "String",
+  "RegExp",
+  // Indexed collections
+  "Array",
+  "Float32Array",
+  "Float64Array",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Int32Array",
+  "Uint16Array",
+  "Uint32Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  // Keyed collections
+  "Set",
+  "Map",
+  "WeakSet",
+  "WeakMap",
+  // Structured data
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "Atomics",
+  "DataView",
+  "JSON",
+  // Control abstraction objects
+  "Promise",
+  "Generator",
+  "GeneratorFunction",
+  "AsyncFunction",
+  // Reflection
+  "Reflect",
+  "Proxy",
+  // Internationalization
+  "Intl",
+  // WebAssembly
+  "WebAssembly"
+], rn = [
+  "Error",
+  "EvalError",
+  "InternalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError"
+], an = [
+  "setInterval",
+  "setTimeout",
+  "clearInterval",
+  "clearTimeout",
+  "require",
+  "exports",
+  "eval",
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
+  "escape",
+  "unescape"
+], gt = [
+  "arguments",
+  "this",
+  "super",
+  "console",
+  "window",
+  "document",
+  "localStorage",
+  "sessionStorage",
+  "module",
+  "self",
+  "global"
+  // Node.js
+], ft = [].concat(
+  an,
+  sn,
+  rn
+);
+function dt(t) {
+  const g = t.regex, d = (S, { after: z }) => {
+    const X = "</" + S[0].slice(1);
+    return S.input.indexOf(X, z) !== -1;
+  }, o = tn, A = {
+    begin: "<>",
+    end: "</>"
+  }, D = /<[A-Za-z0-9\\._:-]+\s*\/>/, y = {
+    begin: /<[A-Za-z0-9\\._:-]+/,
+    end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+    /**
+     * @param {RegExpMatchArray} match
+     * @param {CallbackResponse} response
+     */
+    isTrulyOpeningTag: (S, z) => {
+      const X = S[0].length + S.index, J = S.input[X];
+      if (
+        // HTML should not include another raw `<` inside a tag
+        // nested type?
+        // `<Array<Array<number>>`, etc.
+        J === "<" || // the , gives away that this is not HTML
+        // `<T, A extends keyof T, V>`
+        J === ","
+      ) {
+        z.ignoreMatch();
+        return;
+      }
+      J === ">" && (d(S, { after: X }) || z.ignoreMatch());
+      let se;
+      const le = S.input.substring(X);
+      if (se = le.match(/^\s*=/)) {
+        z.ignoreMatch();
+        return;
+      }
+      if ((se = le.match(/^\s+extends\s+/)) && se.index === 0) {
+        z.ignoreMatch();
+        return;
+      }
+    }
+  }, h = {
+    $pattern: tn,
+    keyword: lt,
+    literal: ut,
+    built_in: ft,
+    "variable.language": gt
+  }, M = "[0-9](_?[0-9])*", w = `\\.(${M})`, I = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", C = {
+    className: "number",
+    variants: [
+      // DecimalLiteral
+      { begin: `(\\b(${I})((${w})|\\.)?|(${w}))[eE][+-]?(${M})\\b` },
+      { begin: `\\b(${I})\\b((${w})\\b|\\.)?|(${w})\\b` },
+      // DecimalBigIntegerLiteral
+      { begin: "\\b(0|[1-9](_?[0-9])*)n\\b" },
+      // NonDecimalIntegerLiteral
+      { 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" },
+      // LegacyOctalIntegerLiteral (does not include underscore separators)
+      // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+      { begin: "\\b0[0-7]+n?\\b" }
+    ],
+    relevance: 0
+  }, T = {
+    className: "subst",
+    begin: "\\$\\{",
+    end: "\\}",
+    keywords: h,
+    contains: []
+    // defined later
+  }, F = {
+    begin: ".?html`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        t.BACKSLASH_ESCAPE,
+        T
+      ],
+      subLanguage: "xml"
+    }
+  }, L = {
+    begin: ".?css`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        t.BACKSLASH_ESCAPE,
+        T
+      ],
+      subLanguage: "css"
+    }
+  }, R = {
+    begin: ".?gql`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        t.BACKSLASH_ESCAPE,
+        T
+      ],
+      subLanguage: "graphql"
+    }
+  }, Z = {
+    className: "string",
+    begin: "`",
+    end: "`",
+    contains: [
+      t.BACKSLASH_ESCAPE,
+      T
+    ]
+  }, W = {
+    className: "comment",
+    variants: [
+      t.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: o + "(?=\\s*(-)|$)",
+                  endsParent: !0,
+                  relevance: 0
+                },
+                // eat spaces (not newlines) so we can find
+                // types or variables
+                {
+                  begin: /(?=[^\n])\s/,
+                  relevance: 0
+                }
+              ]
+            }
+          ]
+        }
+      ),
+      t.C_BLOCK_COMMENT_MODE,
+      t.C_LINE_COMMENT_MODE
+    ]
+  }, Q = [
+    t.APOS_STRING_MODE,
+    t.QUOTE_STRING_MODE,
+    F,
+    L,
+    R,
+    Z,
+    // Skip numbers when they are part of a variable name
+    { match: /\$\d+/ },
+    C
+    // This is intentional:
+    // See https://github.com/highlightjs/highlight.js/issues/3288
+    // hljs.REGEXP_MODE
+  ];
+  T.contains = Q.concat({
+    // we need to pair up {} inside our subst to prevent
+    // it from ending too early by matching another }
+    begin: /\{/,
+    end: /\}/,
+    keywords: h,
+    contains: [
+      "self"
+    ].concat(Q)
+  });
+  const U = [].concat(W, T.contains), G = U.concat([
+    // eat recursive parens in sub expressions
+    {
+      begin: /(\s*)\(/,
+      end: /\)/,
+      keywords: h,
+      contains: ["self"].concat(U)
+    }
+  ]), K = {
+    className: "params",
+    // convert this to negative lookbehind in v12
+    begin: /(\s*)\(/,
+    // to match the parms with
+    end: /\)/,
+    excludeBegin: !0,
+    excludeEnd: !0,
+    keywords: h,
+    contains: G
+  }, re = {
+    variants: [
+      // class Car extends vehicle
+      {
+        match: [
+          /class/,
+          /\s+/,
+          o,
+          /\s+/,
+          /extends/,
+          /\s+/,
+          g.concat(o, "(", g.concat(/\./, o), ")*")
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class",
+          5: "keyword",
+          7: "title.class.inherited"
+        }
+      },
+      // class Car
+      {
+        match: [
+          /class/,
+          /\s+/,
+          o
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class"
+        }
+      }
+    ]
+  }, ne = {
+    relevance: 0,
+    match: g.either(
+      // Hard coded exceptions
+      /\bJSON/,
+      // Float32Array, OutT
+      /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,
+      // CSSFactory, CSSFactoryT
+      /\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/,
+      // FPs, FPsT
+      /\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/
+      // P
+      // single letters are not highlighted
+      // BLAH
+      // this will be flagged as a UPPER_CASE_CONSTANT instead
+    ),
+    className: "title.class",
+    keywords: {
+      _: [
+        // se we still get relevance credit for JS library classes
+        ...sn,
+        ...rn
+      ]
+    }
+  }, de = {
+    label: "use_strict",
+    className: "meta",
+    relevance: 10,
+    begin: /^\s*['"]use (strict|asm)['"]/
+  }, Ee = {
+    variants: [
+      {
+        match: [
+          /function/,
+          /\s+/,
+          o,
+          /(?=\s*\()/
+        ]
+      },
+      // anonymous function
+      {
+        match: [
+          /function/,
+          /\s*(?=\()/
+        ]
+      }
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    label: "func.def",
+    contains: [K],
+    illegal: /%/
+  }, _e = {
+    relevance: 0,
+    match: /\b[A-Z][A-Z_0-9]+\b/,
+    className: "variable.constant"
+  };
+  function he(S) {
+    return g.concat("(?!", S.join("|"), ")");
+  }
+  const Se = {
+    match: g.concat(
+      /\b/,
+      he([
+        ...an,
+        "super",
+        "import",
+        "await"
+      ].map((S) => `${S}\\s*\\(`)),
+      o,
+      g.lookahead(/\s*\(/)
+    ),
+    className: "title.function",
+    relevance: 0
+  }, te = {
+    begin: g.concat(/\./, g.lookahead(
+      g.concat(o, /(?![0-9A-Za-z$_(])/)
+    )),
+    end: o,
+    excludeBegin: !0,
+    keywords: "prototype",
+    className: "property",
+    relevance: 0
+  }, Ae = {
+    match: [
+      /get|set/,
+      /\s+/,
+      o,
+      /(?=\()/
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      {
+        // eat to avoid empty params
+        begin: /\(\)/
+      },
+      K
+    ]
+  }, oe = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + t.UNDERSCORE_IDENT_RE + ")\\s*=>", Ne = {
+    match: [
+      /const|var|let/,
+      /\s+/,
+      o,
+      /\s*/,
+      /=\s*/,
+      /(async\s*)?/,
+      // async is optional
+      g.lookahead(oe)
+    ],
+    keywords: "async",
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      K
+    ]
+  };
+  return {
+    name: "JavaScript",
+    aliases: ["js", "jsx", "mjs", "cjs"],
+    keywords: h,
+    // this will be extended by TypeScript
+    exports: { PARAMS_CONTAINS: G, CLASS_REFERENCE: ne },
+    illegal: /#(?![$_A-Za-z])/,
+    contains: [
+      t.SHEBANG({
+        label: "shebang",
+        binary: "node",
+        relevance: 5
+      }),
+      de,
+      t.APOS_STRING_MODE,
+      t.QUOTE_STRING_MODE,
+      F,
+      L,
+      R,
+      Z,
+      W,
+      // Skip numbers when they are part of a variable name
+      { match: /\$\d+/ },
+      C,
+      ne,
+      {
+        scope: "attr",
+        match: o + g.lookahead(":"),
+        relevance: 0
+      },
+      Ne,
+      {
+        // "value" container
+        begin: "(" + t.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+        keywords: "return throw case",
+        relevance: 0,
+        contains: [
+          W,
+          t.REGEXP_MODE,
+          {
+            className: "function",
+            // we have to count the parens to make sure we actually have the
+            // correct bounding ( ) before the =>.  There could be any number of
+            // sub-expressions inside also surrounded by parens.
+            begin: oe,
+            returnBegin: !0,
+            end: "\\s*=>",
+            contains: [
+              {
+                className: "params",
+                variants: [
+                  {
+                    begin: t.UNDERSCORE_IDENT_RE,
+                    relevance: 0
+                  },
+                  {
+                    className: null,
+                    begin: /\(\s*\)/,
+                    skip: !0
+                  },
+                  {
+                    begin: /(\s*)\(/,
+                    end: /\)/,
+                    excludeBegin: !0,
+                    excludeEnd: !0,
+                    keywords: h,
+                    contains: G
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            // could be a comma delimited list of params to a function call
+            begin: /,/,
+            relevance: 0
+          },
+          {
+            match: /\s+/,
+            relevance: 0
+          },
+          {
+            // JSX
+            variants: [
+              { begin: A.begin, end: A.end },
+              { match: D },
+              {
+                begin: y.begin,
+                // we carefully check the opening tag to see if it truly
+                // is a tag and not a false positive
+                "on:begin": y.isTrulyOpeningTag,
+                end: y.end
+              }
+            ],
+            subLanguage: "xml",
+            contains: [
+              {
+                begin: y.begin,
+                end: y.end,
+                skip: !0,
+                contains: ["self"]
+              }
+            ]
+          }
+        ]
+      },
+      Ee,
+      {
+        // prevent this from getting swallowed up by function
+        // since they appear "function like"
+        beginKeywords: "while if switch catch for"
+      },
+      {
+        // we have to count the parens to make sure we actually have the correct
+        // bounding ( ).  There could be any number of sub-expressions inside
+        // also surrounded by parens.
+        begin: "\\b(?!function)" + t.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+        // end parens
+        returnBegin: !0,
+        label: "func.def",
+        contains: [
+          K,
+          t.inherit(t.TITLE_MODE, { begin: o, className: "title.function" })
+        ]
+      },
+      // catch ... so it won't trigger the property rule below
+      {
+        match: /\.\.\./,
+        relevance: 0
+      },
+      te,
+      // hack: prevents detection of keywords in some circumstances
+      // .keyword()
+      // $keyword = x
+      {
+        match: "\\$" + o,
+        relevance: 0
+      },
+      {
+        match: [/\bconstructor(?=\s*\()/],
+        className: { 1: "title.function" },
+        contains: [K]
+      },
+      Se,
+      _e,
+      re,
+      Ae,
+      {
+        match: /\$[(.]/
+        // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+      }
+    ]
+  };
+}
+function Et(t) {
+  const g = t.regex, d = /[\p{XID_Start}_]\p{XID_Continue}*/u, o = [
+    "and",
+    "as",
+    "assert",
+    "async",
+    "await",
+    "break",
+    "case",
+    "class",
+    "continue",
+    "def",
+    "del",
+    "elif",
+    "else",
+    "except",
+    "finally",
+    "for",
+    "from",
+    "global",
+    "if",
+    "import",
+    "in",
+    "is",
+    "lambda",
+    "lazy",
+    "match",
+    "nonlocal|10",
+    "not",
+    "or",
+    "pass",
+    "raise",
+    "return",
+    "try",
+    "while",
+    "with",
+    "yield"
+  ], h = {
+    $pattern: /[A-Za-z]\w+|__\w+__/,
+    keyword: o,
+    built_in: [
+      "__import__",
+      "abs",
+      "aiter",
+      "all",
+      "anext",
+      "any",
+      "ascii",
+      "bin",
+      "bool",
+      "breakpoint",
+      "bytearray",
+      "bytes",
+      "callable",
+      "chr",
+      "classmethod",
+      "compile",
+      "complex",
+      "delattr",
+      "dict",
+      "dir",
+      "divmod",
+      "enumerate",
+      "eval",
+      "exec",
+      "filter",
+      "float",
+      "format",
+      "frozendict",
+      "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",
+      "sentinel",
+      "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"
+    ]
+  }, M = {
+    className: "meta",
+    begin: /^(>>>|\.\.\.) /
+  }, w = {
+    className: "subst",
+    begin: /\{/,
+    end: /\}/,
+    keywords: h,
+    illegal: /#/
+  }, I = {
+    begin: /\{\{/,
+    relevance: 0
+  }, C = {
+    className: "string",
+    contains: [t.BACKSLASH_ESCAPE],
+    variants: [
+      {
+        begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,
+        end: /'''/,
+        contains: [
+          t.BACKSLASH_ESCAPE,
+          M
+        ],
+        relevance: 10
+      },
+      {
+        begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,
+        end: /"""/,
+        contains: [
+          t.BACKSLASH_ESCAPE,
+          M
+        ],
+        relevance: 10
+      },
+      {
+        begin: /([fFtT][rR]|[rR][fFtT]|[fFtT])'''/,
+        end: /'''/,
+        contains: [
+          t.BACKSLASH_ESCAPE,
+          M,
+          I,
+          w
+        ]
+      },
+      {
+        begin: /([fFtT][rR]|[rR][fFtT]|[fFtT])"""/,
+        end: /"""/,
+        contains: [
+          t.BACKSLASH_ESCAPE,
+          M,
+          I,
+          w
+        ]
+      },
+      {
+        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: /([fFtT][rR]|[rR][fFtT]|[fFtT])'/,
+        end: /'/,
+        contains: [
+          t.BACKSLASH_ESCAPE,
+          I,
+          w
+        ]
+      },
+      {
+        begin: /([fFtT][rR]|[rR][fFtT]|[fFtT])"/,
+        end: /"/,
+        contains: [
+          t.BACKSLASH_ESCAPE,
+          I,
+          w
+        ]
+      },
+      t.APOS_STRING_MODE,
+      t.QUOTE_STRING_MODE
+    ]
+  }, T = "[0-9](_?[0-9])*", F = `(\\b(${T}))?\\.(${T})|\\b(${T})\\.`, L = `\\b|${o.join("|")}`, R = {
+    className: "number",
+    relevance: 0,
+    variants: [
+      // exponentfloat, pointfloat
+      // https://docs.python.org/3.9/reference/lexical_analysis.html#floating-point-literals
+      // optionally imaginary
+      // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
+      // Note: no leading \b because floats can start with a decimal point
+      // and we don't want to mishandle e.g. `fn(.5)`,
+      // no trailing \b for pointfloat because it can end with a decimal point
+      // and we don't want to mishandle e.g. `0..hex()`; this should be safe
+      // because both MUST contain a decimal point and so cannot be confused with
+      // the interior part of an identifier
+      {
+        begin: `(\\b(${T})|(${F}))[eE][+-]?(${T})[jJ]?(?=${L})`
+      },
+      {
+        begin: `(${F})[jJ]?`
+      },
+      // decinteger, bininteger, octinteger, hexinteger
+      // https://docs.python.org/3.9/reference/lexical_analysis.html#integer-literals
+      // optionally "long" in Python 2
+      // https://docs.python.org/2.7/reference/lexical_analysis.html#integer-and-long-integer-literals
+      // decinteger is optionally imaginary
+      // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
+      {
+        begin: `\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${L})`
+      },
+      {
+        begin: `\\b0[bB](_?[01])+[lL]?(?=${L})`
+      },
+      {
+        begin: `\\b0[oO](_?[0-7])+[lL]?(?=${L})`
+      },
+      {
+        begin: `\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${L})`
+      },
+      // imagnumber (digitpart-based)
+      // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
+      {
+        begin: `\\b(${T})[jJ](?=${L})`
+      }
+    ]
+  }, Z = {
+    className: "comment",
+    begin: g.lookahead(/# type:/),
+    end: /$/,
+    keywords: h,
+    contains: [
+      {
+        // prevent keywords from coloring `type`
+        begin: /# type:/
+      },
+      // comment within a datatype comment includes no keywords
+      {
+        begin: /#/,
+        end: /\b\B/,
+        endsWithParent: !0
+      }
+    ]
+  }, Y = {
+    className: "params",
+    variants: [
+      // Exclude params in functions without params
+      {
+        className: "",
+        begin: /\(\s*\)/,
+        skip: !0
+      },
+      {
+        begin: /\(/,
+        end: /\)/,
+        excludeBegin: !0,
+        excludeEnd: !0,
+        keywords: h,
+        contains: [
+          "self",
+          M,
+          R,
+          C,
+          t.HASH_COMMENT_MODE
+        ]
+      }
+    ]
+  };
+  return w.contains = [
+    C,
+    R,
+    M
+  ], {
+    name: "Python",
+    aliases: [
+      "py",
+      "gyp",
+      "ipython"
+    ],
+    unicodeRegex: !0,
+    keywords: h,
+    illegal: /(<\/|\?)|=>/,
+    contains: [
+      M,
+      R,
+      {
+        // very common convention
+        scope: "variable.language",
+        match: /\bself\b/
+      },
+      {
+        // eat "if" prior to string so that it won't accidentally be
+        // labeled as an f-string
+        beginKeywords: "if",
+        relevance: 0
+      },
+      { match: /\bor\b/, scope: "keyword" },
+      C,
+      Z,
+      t.HASH_COMMENT_MODE,
+      {
+        match: [
+          /\bdef/,
+          /\s+/,
+          d
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.function"
+        },
+        contains: [Y]
+      },
+      {
+        variants: [
+          {
+            match: [
+              /\bclass/,
+              /\s+/,
+              d,
+              /\s*/,
+              /\(\s*/,
+              d,
+              /\s*\)/
+            ]
+          },
+          {
+            match: [
+              /\bclass/,
+              /\s+/,
+              d
+            ]
+          }
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class",
+          6: "title.class.inherited"
+        }
+      },
+      {
+        className: "meta",
+        begin: /^[\t ]*@/,
+        end: /(?=#)|$/,
+        contains: [
+          R,
+          Y,
+          C
+        ]
+      }
+    ]
+  };
+}
+function _t(t) {
+  const g = t.regex, d = /(r#)?/, o = g.concat(d, t.UNDERSCORE_IDENT_RE), A = g.concat(d, t.IDENT_RE), D = {
+    scope: "title.function.invoke",
+    relevance: 0,
+    begin: g.concat(
+      /\b/,
+      /(?!(?:let|for|while|if|else|match)\b)/,
+      A,
+      g.lookahead(/\s*\(/)
+    )
+  }, y = "([ui](8|16|32|64|128|size)|f(16|32|64|128))?", h = [
+    "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",
+    "raw",
+    "ref",
+    "return",
+    "self",
+    "Self",
+    "static",
+    "struct",
+    "super",
+    "trait",
+    "true",
+    "try",
+    "type",
+    "typeof",
+    "union",
+    "unsafe",
+    "unsized",
+    "use",
+    "virtual",
+    "where",
+    "while",
+    "yield"
+  ], M = [
+    "true",
+    "false",
+    "Some",
+    "None",
+    "Ok",
+    "Err"
+  ], w = [
+    // functions
+    "drop ",
+    // traits
+    "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",
+    // macros
+    "assert!",
+    "assert_eq!",
+    "bitflags!",
+    "bytes!",
+    "cfg!",
+    "col!",
+    "concat!",
+    "concat_idents!",
+    "debug_assert!",
+    "debug_assert_eq!",
+    "env!",
+    "eprintln!",
+    "panic!",
+    "file!",
+    "format!",
+    "format_args!",
+    "include_bytes!",
+    "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!"
+  ], I = [
+    "i8",
+    "i16",
+    "i32",
+    "i64",
+    "i128",
+    "isize",
+    "u8",
+    "u16",
+    "u32",
+    "u64",
+    "u128",
+    "usize",
+    "f16",
+    "f32",
+    "f64",
+    "f128",
+    "str",
+    "char",
+    "bool",
+    "Box",
+    "Option",
+    "Result",
+    "String",
+    "Vec"
+  ];
+  return {
+    name: "Rust",
+    aliases: ["rs"],
+    keywords: {
+      $pattern: t.IDENT_RE + "!?",
+      type: I,
+      keyword: h,
+      literal: M,
+      built_in: w
+    },
+    illegal: "</",
+    contains: [
+      t.C_LINE_COMMENT_MODE,
+      t.COMMENT("/\\*", "\\*/", { contains: ["self"] }),
+      t.inherit(t.QUOTE_STRING_MODE, {
+        begin: /b?"/,
+        illegal: null
+      }),
+      {
+        scope: "symbol",
+        // negative lookahead to avoid matching `'`
+        begin: /'[a-zA-Z_][a-zA-Z0-9_]*(?!')/
+      },
+      {
+        scope: "string",
+        variants: [
+          { begin: /b?r(#*)"(.|\n)*?"\1(?!#)/ },
+          {
+            begin: /b?'/,
+            end: /'/,
+            contains: [
+              {
+                scope: "char.escape",
+                match: /\\('|"|\\|\w|x\w{2}|u\w{4}|U\w{8})/
+              }
+            ]
+          }
+        ]
+      },
+      {
+        scope: "number",
+        variants: [
+          { begin: "\\b0b([01_]+)" + y },
+          { begin: "\\b0o([0-7_]+)" + y },
+          { begin: "\\b0x([A-Fa-f0-9_]+)" + y },
+          { begin: "\\b(\\d[\\d_]*(\\.[0-9_]+)?([eE][+-]?[0-9_]+)?)" + y }
+        ],
+        relevance: 0
+      },
+      {
+        begin: [
+          /\bsafe/,
+          /\s+/,
+          /extern/
+        ],
+        scope: {
+          1: "keyword",
+          3: "keyword"
+        }
+      },
+      {
+        begin: [
+          /fn/,
+          /\s+/,
+          o
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.function"
+        }
+      },
+      {
+        scope: "meta",
+        begin: "#!?\\[",
+        end: "\\]",
+        contains: [
+          {
+            scope: "string",
+            begin: /"/,
+            end: /"/,
+            contains: [
+              t.BACKSLASH_ESCAPE
+            ]
+          }
+        ]
+      },
+      {
+        begin: [
+          /let/,
+          /\s+/,
+          /(?:mut\s+)?/,
+          o
+        ],
+        scope: {
+          1: "keyword",
+          3: "keyword",
+          4: "variable"
+        }
+      },
+      // must come before impl/for rule later
+      {
+        begin: [
+          /for/,
+          /\s+/,
+          o,
+          /\s+/,
+          /in/
+        ],
+        scope: {
+          1: "keyword",
+          3: "variable",
+          5: "keyword"
+        }
+      },
+      {
+        begin: [
+          /type/,
+          /\s+/,
+          o
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class"
+        }
+      },
+      {
+        begin: [
+          /(?:trait|enum|struct|union|impl|for)/,
+          /\s+/,
+          o
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class"
+        }
+      },
+      {
+        begin: t.IDENT_RE + "::",
+        keywords: {
+          keyword: "Self",
+          built_in: w,
+          type: I
+        }
+      },
+      {
+        scope: "punctuation",
+        begin: "->"
+      },
+      D
+    ]
+  };
+}
+const Ce = "[A-Za-z$_][0-9A-Za-z$_]*", cn = [
+  "as",
+  // for exports
+  "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",
+  // JS handles these with a special rule
+  // "get",
+  // "set",
+  "debugger",
+  "async",
+  "await",
+  "static",
+  "import",
+  "from",
+  "export",
+  "extends",
+  // It's reached stage 3, which is "recommended for implementation":
+  "using"
+], on = [
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "NaN",
+  "Infinity"
+], ln = [
+  // Fundamental objects
+  "Object",
+  "Function",
+  "Boolean",
+  "Symbol",
+  // numbers and dates
+  "Math",
+  "Date",
+  "Number",
+  "BigInt",
+  // text
+  "String",
+  "RegExp",
+  // Indexed collections
+  "Array",
+  "Float32Array",
+  "Float64Array",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Int32Array",
+  "Uint16Array",
+  "Uint32Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  // Keyed collections
+  "Set",
+  "Map",
+  "WeakSet",
+  "WeakMap",
+  // Structured data
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "Atomics",
+  "DataView",
+  "JSON",
+  // Control abstraction objects
+  "Promise",
+  "Generator",
+  "GeneratorFunction",
+  "AsyncFunction",
+  // Reflection
+  "Reflect",
+  "Proxy",
+  // Internationalization
+  "Intl",
+  // WebAssembly
+  "WebAssembly"
+], un = [
+  "Error",
+  "EvalError",
+  "InternalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError"
+], gn = [
+  "setInterval",
+  "setTimeout",
+  "clearInterval",
+  "clearTimeout",
+  "require",
+  "exports",
+  "eval",
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
+  "escape",
+  "unescape"
+], fn = [
+  "arguments",
+  "this",
+  "super",
+  "console",
+  "window",
+  "document",
+  "localStorage",
+  "sessionStorage",
+  "module",
+  "self",
+  "global"
+  // Node.js
+], dn = [].concat(
+  gn,
+  ln,
+  un
+);
+function bt(t) {
+  const g = t.regex, d = (S, { after: z }) => {
+    const X = "</" + S[0].slice(1);
+    return S.input.indexOf(X, z) !== -1;
+  }, o = Ce, A = {
+    begin: "<>",
+    end: "</>"
+  }, D = /<[A-Za-z0-9\\._:-]+\s*\/>/, y = {
+    begin: /<[A-Za-z0-9\\._:-]+/,
+    end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+    /**
+     * @param {RegExpMatchArray} match
+     * @param {CallbackResponse} response
+     */
+    isTrulyOpeningTag: (S, z) => {
+      const X = S[0].length + S.index, J = S.input[X];
+      if (
+        // HTML should not include another raw `<` inside a tag
+        // nested type?
+        // `<Array<Array<number>>`, etc.
+        J === "<" || // the , gives away that this is not HTML
+        // `<T, A extends keyof T, V>`
+        J === ","
+      ) {
+        z.ignoreMatch();
+        return;
+      }
+      J === ">" && (d(S, { after: X }) || z.ignoreMatch());
+      let se;
+      const le = S.input.substring(X);
+      if (se = le.match(/^\s*=/)) {
+        z.ignoreMatch();
+        return;
+      }
+      if ((se = le.match(/^\s+extends\s+/)) && se.index === 0) {
+        z.ignoreMatch();
+        return;
+      }
+    }
+  }, h = {
+    $pattern: Ce,
+    keyword: cn,
+    literal: on,
+    built_in: dn,
+    "variable.language": fn
+  }, M = "[0-9](_?[0-9])*", w = `\\.(${M})`, I = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", C = {
+    className: "number",
+    variants: [
+      // DecimalLiteral
+      { begin: `(\\b(${I})((${w})|\\.)?|(${w}))[eE][+-]?(${M})\\b` },
+      { begin: `\\b(${I})\\b((${w})\\b|\\.)?|(${w})\\b` },
+      // DecimalBigIntegerLiteral
+      { begin: "\\b(0|[1-9](_?[0-9])*)n\\b" },
+      // NonDecimalIntegerLiteral
+      { 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" },
+      // LegacyOctalIntegerLiteral (does not include underscore separators)
+      // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+      { begin: "\\b0[0-7]+n?\\b" }
+    ],
+    relevance: 0
+  }, T = {
+    className: "subst",
+    begin: "\\$\\{",
+    end: "\\}",
+    keywords: h,
+    contains: []
+    // defined later
+  }, F = {
+    begin: ".?html`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        t.BACKSLASH_ESCAPE,
+        T
+      ],
+      subLanguage: "xml"
+    }
+  }, L = {
+    begin: ".?css`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        t.BACKSLASH_ESCAPE,
+        T
+      ],
+      subLanguage: "css"
+    }
+  }, R = {
+    begin: ".?gql`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        t.BACKSLASH_ESCAPE,
+        T
+      ],
+      subLanguage: "graphql"
+    }
+  }, Z = {
+    className: "string",
+    begin: "`",
+    end: "`",
+    contains: [
+      t.BACKSLASH_ESCAPE,
+      T
+    ]
+  }, W = {
+    className: "comment",
+    variants: [
+      t.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: o + "(?=\\s*(-)|$)",
+                  endsParent: !0,
+                  relevance: 0
+                },
+                // eat spaces (not newlines) so we can find
+                // types or variables
+                {
+                  begin: /(?=[^\n])\s/,
+                  relevance: 0
+                }
+              ]
+            }
+          ]
+        }
+      ),
+      t.C_BLOCK_COMMENT_MODE,
+      t.C_LINE_COMMENT_MODE
+    ]
+  }, Q = [
+    t.APOS_STRING_MODE,
+    t.QUOTE_STRING_MODE,
+    F,
+    L,
+    R,
+    Z,
+    // Skip numbers when they are part of a variable name
+    { match: /\$\d+/ },
+    C
+    // This is intentional:
+    // See https://github.com/highlightjs/highlight.js/issues/3288
+    // hljs.REGEXP_MODE
+  ];
+  T.contains = Q.concat({
+    // we need to pair up {} inside our subst to prevent
+    // it from ending too early by matching another }
+    begin: /\{/,
+    end: /\}/,
+    keywords: h,
+    contains: [
+      "self"
+    ].concat(Q)
+  });
+  const U = [].concat(W, T.contains), G = U.concat([
+    // eat recursive parens in sub expressions
+    {
+      begin: /(\s*)\(/,
+      end: /\)/,
+      keywords: h,
+      contains: ["self"].concat(U)
+    }
+  ]), K = {
+    className: "params",
+    // convert this to negative lookbehind in v12
+    begin: /(\s*)\(/,
+    // to match the parms with
+    end: /\)/,
+    excludeBegin: !0,
+    excludeEnd: !0,
+    keywords: h,
+    contains: G
+  }, re = {
+    variants: [
+      // class Car extends vehicle
+      {
+        match: [
+          /class/,
+          /\s+/,
+          o,
+          /\s+/,
+          /extends/,
+          /\s+/,
+          g.concat(o, "(", g.concat(/\./, o), ")*")
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class",
+          5: "keyword",
+          7: "title.class.inherited"
+        }
+      },
+      // class Car
+      {
+        match: [
+          /class/,
+          /\s+/,
+          o
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class"
+        }
+      }
+    ]
+  }, ne = {
+    relevance: 0,
+    match: g.either(
+      // Hard coded exceptions
+      /\bJSON/,
+      // Float32Array, OutT
+      /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,
+      // CSSFactory, CSSFactoryT
+      /\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/,
+      // FPs, FPsT
+      /\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/
+      // P
+      // single letters are not highlighted
+      // BLAH
+      // this will be flagged as a UPPER_CASE_CONSTANT instead
+    ),
+    className: "title.class",
+    keywords: {
+      _: [
+        // se we still get relevance credit for JS library classes
+        ...ln,
+        ...un
+      ]
+    }
+  }, de = {
+    label: "use_strict",
+    className: "meta",
+    relevance: 10,
+    begin: /^\s*['"]use (strict|asm)['"]/
+  }, Ee = {
+    variants: [
+      {
+        match: [
+          /function/,
+          /\s+/,
+          o,
+          /(?=\s*\()/
+        ]
+      },
+      // anonymous function
+      {
+        match: [
+          /function/,
+          /\s*(?=\()/
+        ]
+      }
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    label: "func.def",
+    contains: [K],
+    illegal: /%/
+  }, _e = {
+    relevance: 0,
+    match: /\b[A-Z][A-Z_0-9]+\b/,
+    className: "variable.constant"
+  };
+  function he(S) {
+    return g.concat("(?!", S.join("|"), ")");
+  }
+  const Se = {
+    match: g.concat(
+      /\b/,
+      he([
+        ...gn,
+        "super",
+        "import",
+        "await"
+      ].map((S) => `${S}\\s*\\(`)),
+      o,
+      g.lookahead(/\s*\(/)
+    ),
+    className: "title.function",
+    relevance: 0
+  }, te = {
+    begin: g.concat(/\./, g.lookahead(
+      g.concat(o, /(?![0-9A-Za-z$_(])/)
+    )),
+    end: o,
+    excludeBegin: !0,
+    keywords: "prototype",
+    className: "property",
+    relevance: 0
+  }, Ae = {
+    match: [
+      /get|set/,
+      /\s+/,
+      o,
+      /(?=\()/
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      {
+        // eat to avoid empty params
+        begin: /\(\)/
+      },
+      K
+    ]
+  }, oe = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + t.UNDERSCORE_IDENT_RE + ")\\s*=>", Ne = {
+    match: [
+      /const|var|let/,
+      /\s+/,
+      o,
+      /\s*/,
+      /=\s*/,
+      /(async\s*)?/,
+      // async is optional
+      g.lookahead(oe)
+    ],
+    keywords: "async",
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      K
+    ]
+  };
+  return {
+    name: "JavaScript",
+    aliases: ["js", "jsx", "mjs", "cjs"],
+    keywords: h,
+    // this will be extended by TypeScript
+    exports: { PARAMS_CONTAINS: G, CLASS_REFERENCE: ne },
+    illegal: /#(?![$_A-Za-z])/,
+    contains: [
+      t.SHEBANG({
+        label: "shebang",
+        binary: "node",
+        relevance: 5
+      }),
+      de,
+      t.APOS_STRING_MODE,
+      t.QUOTE_STRING_MODE,
+      F,
+      L,
+      R,
+      Z,
+      W,
+      // Skip numbers when they are part of a variable name
+      { match: /\$\d+/ },
+      C,
+      ne,
+      {
+        scope: "attr",
+        match: o + g.lookahead(":"),
+        relevance: 0
+      },
+      Ne,
+      {
+        // "value" container
+        begin: "(" + t.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+        keywords: "return throw case",
+        relevance: 0,
+        contains: [
+          W,
+          t.REGEXP_MODE,
+          {
+            className: "function",
+            // we have to count the parens to make sure we actually have the
+            // correct bounding ( ) before the =>.  There could be any number of
+            // sub-expressions inside also surrounded by parens.
+            begin: oe,
+            returnBegin: !0,
+            end: "\\s*=>",
+            contains: [
+              {
+                className: "params",
+                variants: [
+                  {
+                    begin: t.UNDERSCORE_IDENT_RE,
+                    relevance: 0
+                  },
+                  {
+                    className: null,
+                    begin: /\(\s*\)/,
+                    skip: !0
+                  },
+                  {
+                    begin: /(\s*)\(/,
+                    end: /\)/,
+                    excludeBegin: !0,
+                    excludeEnd: !0,
+                    keywords: h,
+                    contains: G
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            // could be a comma delimited list of params to a function call
+            begin: /,/,
+            relevance: 0
+          },
+          {
+            match: /\s+/,
+            relevance: 0
+          },
+          {
+            // JSX
+            variants: [
+              { begin: A.begin, end: A.end },
+              { match: D },
+              {
+                begin: y.begin,
+                // we carefully check the opening tag to see if it truly
+                // is a tag and not a false positive
+                "on:begin": y.isTrulyOpeningTag,
+                end: y.end
+              }
+            ],
+            subLanguage: "xml",
+            contains: [
+              {
+                begin: y.begin,
+                end: y.end,
+                skip: !0,
+                contains: ["self"]
+              }
+            ]
+          }
+        ]
+      },
+      Ee,
+      {
+        // prevent this from getting swallowed up by function
+        // since they appear "function like"
+        beginKeywords: "while if switch catch for"
+      },
+      {
+        // we have to count the parens to make sure we actually have the correct
+        // bounding ( ).  There could be any number of sub-expressions inside
+        // also surrounded by parens.
+        begin: "\\b(?!function)" + t.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+        // end parens
+        returnBegin: !0,
+        label: "func.def",
+        contains: [
+          K,
+          t.inherit(t.TITLE_MODE, { begin: o, className: "title.function" })
+        ]
+      },
+      // catch ... so it won't trigger the property rule below
+      {
+        match: /\.\.\./,
+        relevance: 0
+      },
+      te,
+      // hack: prevents detection of keywords in some circumstances
+      // .keyword()
+      // $keyword = x
+      {
+        match: "\\$" + o,
+        relevance: 0
+      },
+      {
+        match: [/\bconstructor(?=\s*\()/],
+        className: { 1: "title.function" },
+        contains: [K]
+      },
+      Se,
+      _e,
+      re,
+      Ae,
+      {
+        match: /\$[(.]/
+        // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+      }
+    ]
+  };
+}
+function pt(t) {
+  const g = t.regex, d = bt(t), o = Ce, A = [
+    "any",
+    "void",
+    "number",
+    "boolean",
+    "string",
+    "object",
+    "never",
+    "symbol",
+    "bigint",
+    "unknown"
+  ], D = {
+    begin: [
+      /namespace/,
+      /\s+/,
+      t.IDENT_RE
+    ],
+    beginScope: {
+      1: "keyword",
+      3: "title.class"
+    }
+  }, y = {
+    beginKeywords: "interface",
+    end: /\{/,
+    excludeEnd: !0,
+    keywords: {
+      keyword: "interface extends",
+      built_in: A
+    },
+    contains: [d.exports.CLASS_REFERENCE]
+  }, h = {
+    className: "meta",
+    relevance: 10,
+    begin: /^\s*['"]use strict['"]/
+  }, M = [
+    "type",
+    // "namespace",
+    "interface",
+    "public",
+    "private",
+    "protected",
+    "implements",
+    "declare",
+    "abstract",
+    "readonly",
+    "enum",
+    "override",
+    "satisfies"
+  ], w = {
+    $pattern: Ce,
+    keyword: cn.concat(M),
+    literal: on,
+    built_in: dn.concat(A),
+    "variable.language": fn
+  }, I = {
+    className: "meta",
+    begin: "@" + o
+  }, C = (R, Z, Y) => {
+    const W = R.contains.findIndex((Q) => Q.label === Z);
+    if (W === -1)
+      throw new Error("can not find mode to replace");
+    R.contains.splice(W, 1, Y);
+  };
+  Object.assign(d.keywords, w), d.exports.PARAMS_CONTAINS.push(I);
+  const T = d.contains.find((R) => R.scope === "attr"), F = Object.assign(
+    {},
+    T,
+    { match: g.concat(o, g.lookahead(/\s*\?:/)) }
+  );
+  d.exports.PARAMS_CONTAINS.push([
+    d.exports.CLASS_REFERENCE,
+    // class reference for highlighting the params types
+    T,
+    // highlight the params key
+    F
+    // Added for optional property assignment highlighting
+  ]), d.contains = d.contains.concat([
+    I,
+    D,
+    y,
+    F
+    // Added for optional property assignment highlighting
+  ]), C(d, "shebang", t.SHEBANG()), C(d, "use_strict", h);
+  const L = d.contains.find((R) => R.label === "func.def");
+  return L.relevance = 0, Object.assign(d, {
+    name: "TypeScript",
+    aliases: [
+      "ts",
+      "tsx",
+      "mts",
+      "cts"
+    ]
+  }), d;
+}
+fe.registerLanguage("c", ct);
+fe.registerLanguage("go", ot);
+fe.registerLanguage("javascript", dt);
+fe.registerLanguage("python", Et);
+fe.registerLanguage("rust", _t);
+fe.registerLanguage("typescript", pt);
+const ht = {
+  ".c": "c",
+  ".go": "go",
+  ".h": "c",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".py": "python",
+  ".rs": "rust",
+  ".ts": "typescript",
+  ".tsx": "typescript"
+};
+function St(t) {
+  return t.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#x27;");
+}
+function At(t) {
+  const g = [], d = [], o = /<span class="[^"]+">|<\/span>|\n/g;
+  let A = "", D = 0;
+  for (const y of t.matchAll(o)) {
+    A += t.slice(D, y.index);
+    const h = y[0];
+    h === `
+` ? (A += "</span>".repeat(d.length), g.push(A), A = d.join("")) : h === "</span>" ? (d.pop(), A += h) : (d.push(h), A += h), D = y.index + h.length;
+  }
+  return A += t.slice(D), g.push(A), g;
+}
+function yt(t, g) {
+  const d = ht[st(t)];
+  if (!d) return g.split(/\r?\n/).map(St);
+  const o = g.replaceAll(`\r
+`, `
+`), A = fe.highlight(o, {
+    language: d,
+    ignoreIllegals: !0
+  }).value;
+  return At(A);
+}
+export {
+  yt as highlightSource
+};