@fewangsit/wangsvue-fats 1.0.0-alpha.41 → 1.0.0-alpha.42

package/vendor/highlight.js-DHowhWoU.es.js

@@ -0,0 +1,2493 @@
+import { g as un } from "../components/imagecompressor/ImageCompressor-DaW0ak9c.es.js";
+function ke(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 s = e[n], r = typeof s;
+    (r === "object" || r === "function") && !Object.isFrozen(s) && ke(s);
+  }), e;
+}
+class Oe {
+  /**
+   * @param {CompiledMode} mode
+   */
+  constructor(n) {
+    n.data === void 0 && (n.data = {}), this.data = n.data, this.isMatchIgnored = !1;
+  }
+  ignoreMatch() {
+    this.isMatchIgnored = !0;
+  }
+}
+function De(e) {
+  return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+}
+function z(e, ...n) {
+  const s = /* @__PURE__ */ Object.create(null);
+  for (const r in e)
+    s[r] = e[r];
+  return n.forEach(function(r) {
+    for (const h in r)
+      s[h] = r[h];
+  }), /** @type {T} */
+  s;
+}
+const gn = "</span>", we = (e) => !!e.scope, fn = (e, { prefix: n }) => {
+  if (e.startsWith("language:"))
+    return e.replace("language:", "language-");
+  if (e.includes(".")) {
+    const s = e.split(".");
+    return [
+      `${n}${s.shift()}`,
+      ...s.map((r, h) => `${r}${"_".repeat(h + 1)}`)
+    ].join(" ");
+  }
+  return `${n}${e}`;
+};
+class dn {
+  /**
+   * Creates a new HTMLRenderer
+   *
+   * @param {Tree} parseTree - the parse tree (must support `walk` API)
+   * @param {{classPrefix: string}} options
+   */
+  constructor(n, s) {
+    this.buffer = "", this.classPrefix = s.classPrefix, n.walk(this);
+  }
+  /**
+   * Adds texts to the output stream
+   *
+   * @param {string} text */
+  addText(n) {
+    this.buffer += De(n);
+  }
+  /**
+   * Adds a node open to the output stream (if needed)
+   *
+   * @param {Node} node */
+  openNode(n) {
+    if (!we(n)) return;
+    const s = fn(
+      n.scope,
+      { prefix: this.classPrefix }
+    );
+    this.span(s);
+  }
+  /**
+   * Adds a node close to the output stream (if needed)
+   *
+   * @param {Node} node */
+  closeNode(n) {
+    we(n) && (this.buffer += gn);
+  }
+  /**
+   * returns the accumulated buffer
+  */
+  value() {
+    return this.buffer;
+  }
+  // helpers
+  /**
+   * Builds a span element
+   *
+   * @param {string} className */
+  span(n) {
+    this.buffer += `<span class="${n}">`;
+  }
+}
+const Ie = (e = {}) => {
+  const n = { children: [] };
+  return Object.assign(n, e), n;
+};
+class pe {
+  constructor() {
+    this.rootNode = Ie(), 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 s = Ie({ scope: n });
+    this.add(s), this.stack.push(s);
+  }
+  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, s) {
+    return typeof s == "string" ? n.addText(s) : s.children && (n.openNode(s), s.children.forEach((r) => this._walk(n, r)), n.closeNode(s)), n;
+  }
+  /**
+   * @param {Node} node
+   */
+  static _collapse(n) {
+    typeof n != "string" && n.children && (n.children.every((s) => typeof s == "string") ? n.children = [n.children.join("")] : n.children.forEach((s) => {
+      pe._collapse(s);
+    }));
+  }
+}
+class En extends pe {
+  /**
+   * @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, s) {
+    const r = n.root;
+    s && (r.scope = `language:${s}`), this.add(r);
+  }
+  toHTML() {
+    return new dn(this, this.options).value();
+  }
+  finalize() {
+    return this.closeAllNodes(), !0;
+  }
+}
+function ie(e) {
+  return e ? typeof e == "string" ? e : e.source : null;
+}
+function Be(e) {
+  return j("(?=", e, ")");
+}
+function hn(e) {
+  return j("(?:", e, ")*");
+}
+function bn(e) {
+  return j("(?:", e, ")?");
+}
+function j(...e) {
+  return e.map((s) => ie(s)).join("");
+}
+function pn(e) {
+  const n = e[e.length - 1];
+  return typeof n == "object" && n.constructor === Object ? (e.splice(e.length - 1, 1), n) : {};
+}
+function _e(...e) {
+  return "(" + (pn(e).capture ? "" : "?:") + e.map((r) => ie(r)).join("|") + ")";
+}
+function Ue(e) {
+  return new RegExp(e.toString() + "|").exec("").length - 1;
+}
+function _n(e, n) {
+  const s = e && e.exec(n);
+  return s && s.index === 0;
+}
+const Nn = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+function Ne(e, { joinWith: n }) {
+  let s = 0;
+  return e.map((r) => {
+    s += 1;
+    const h = s;
+    let S = ie(r), c = "";
+    for (; S.length > 0; ) {
+      const i = Nn.exec(S);
+      if (!i) {
+        c += S;
+        break;
+      }
+      c += S.substring(0, i.index), S = S.substring(i.index + i[0].length), i[0][0] === "\\" && i[1] ? c += "\\" + String(Number(i[1]) + h) : (c += i[0], i[0] === "(" && s++);
+    }
+    return c;
+  }).map((r) => `(${r})`).join(n);
+}
+const Sn = /\b\B/, Pe = "[a-zA-Z]\\w*", Se = "[a-zA-Z_]\\w*", $e = "\\b\\d+(\\.\\d+)?", He = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", Ge = "\\b(0b[01]+)", An = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~", Rn = (e = {}) => {
+  const n = /^#![ ]*\//;
+  return e.binary && (e.begin = j(
+    n,
+    /.*\b/,
+    e.binary,
+    /\b.*/
+  )), z({
+    scope: "meta",
+    begin: n,
+    end: /$/,
+    relevance: 0,
+    /** @type {ModeCallback} */
+    "on:begin": (s, r) => {
+      s.index !== 0 && r.ignoreMatch();
+    }
+  }, e);
+}, re = {
+  begin: "\\\\[\\s\\S]",
+  relevance: 0
+}, Tn = {
+  scope: "string",
+  begin: "'",
+  end: "'",
+  illegal: "\\n",
+  contains: [re]
+}, Mn = {
+  scope: "string",
+  begin: '"',
+  end: '"',
+  illegal: "\\n",
+  contains: [re]
+}, yn = {
+  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/
+}, fe = function(e, n, s = {}) {
+  const r = z(
+    {
+      scope: "comment",
+      begin: e,
+      end: n,
+      contains: []
+    },
+    s
+  );
+  r.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 h = _e(
+    // 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 r.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: j(
+        /[ ]+/,
+        // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
+        "(",
+        h,
+        /[.]?[:]?([.][ ]|[ ])/,
+        "){3}"
+      )
+      // look for 3 words in a row
+    }
+  ), r;
+}, On = fe("//", "$"), wn = fe("/\\*", "\\*/"), In = fe("#", "$"), xn = {
+  scope: "number",
+  begin: $e,
+  relevance: 0
+}, Cn = {
+  scope: "number",
+  begin: He,
+  relevance: 0
+}, mn = {
+  scope: "number",
+  begin: Ge,
+  relevance: 0
+}, vn = {
+  scope: "regexp",
+  begin: /\/(?=[^/\n]*\/)/,
+  end: /\/[gimuy]*/,
+  contains: [
+    re,
+    {
+      begin: /\[/,
+      end: /\]/,
+      relevance: 0,
+      contains: [re]
+    }
+  ]
+}, Ln = {
+  scope: "title",
+  begin: Pe,
+  relevance: 0
+}, kn = {
+  scope: "title",
+  begin: Se,
+  relevance: 0
+}, Dn = {
+  // excludes method names from keyword processing
+  begin: "\\.\\s*" + Se,
+  relevance: 0
+}, Bn = function(e) {
+  return Object.assign(
+    e,
+    {
+      /** @type {ModeCallback} */
+      "on:begin": (n, s) => {
+        s.data._beginMatch = n[1];
+      },
+      /** @type {ModeCallback} */
+      "on:end": (n, s) => {
+        s.data._beginMatch !== n[1] && s.ignoreMatch();
+      }
+    }
+  );
+};
+var le = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  APOS_STRING_MODE: Tn,
+  BACKSLASH_ESCAPE: re,
+  BINARY_NUMBER_MODE: mn,
+  BINARY_NUMBER_RE: Ge,
+  COMMENT: fe,
+  C_BLOCK_COMMENT_MODE: wn,
+  C_LINE_COMMENT_MODE: On,
+  C_NUMBER_MODE: Cn,
+  C_NUMBER_RE: He,
+  END_SAME_AS_BEGIN: Bn,
+  HASH_COMMENT_MODE: In,
+  IDENT_RE: Pe,
+  MATCH_NOTHING_RE: Sn,
+  METHOD_GUARD: Dn,
+  NUMBER_MODE: xn,
+  NUMBER_RE: $e,
+  PHRASAL_WORDS_MODE: yn,
+  QUOTE_STRING_MODE: Mn,
+  REGEXP_MODE: vn,
+  RE_STARTERS_RE: An,
+  SHEBANG: Rn,
+  TITLE_MODE: Ln,
+  UNDERSCORE_IDENT_RE: Se,
+  UNDERSCORE_TITLE_MODE: kn
+});
+function Un(e, n) {
+  e.input[e.index - 1] === "." && n.ignoreMatch();
+}
+function Pn(e, n) {
+  e.className !== void 0 && (e.scope = e.className, delete e.className);
+}
+function $n(e, n) {
+  n && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)", e.__beforeBegin = Un, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords, e.relevance === void 0 && (e.relevance = 0));
+}
+function Hn(e, n) {
+  Array.isArray(e.illegal) && (e.illegal = _e(...e.illegal));
+}
+function Gn(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 Fn(e, n) {
+  e.relevance === void 0 && (e.relevance = 1);
+}
+const zn = (e, n) => {
+  if (!e.beforeMatch) return;
+  if (e.starts) throw new Error("beforeMatch cannot be used with starts");
+  const s = Object.assign({}, e);
+  Object.keys(e).forEach((r) => {
+    delete e[r];
+  }), e.keywords = s.keywords, e.begin = j(s.beforeMatch, Be(s.begin)), e.starts = {
+    relevance: 0,
+    contains: [
+      Object.assign(s, { endsParent: !0 })
+    ]
+  }, e.relevance = 0, delete s.beforeMatch;
+}, Zn = [
+  "of",
+  "and",
+  "for",
+  "in",
+  "not",
+  "or",
+  "if",
+  "then",
+  "parent",
+  // common variable name
+  "list",
+  // common variable name
+  "value"
+  // common variable name
+], Kn = "keyword";
+function Fe(e, n, s = Kn) {
+  const r = /* @__PURE__ */ Object.create(null);
+  return typeof e == "string" ? h(s, e.split(" ")) : Array.isArray(e) ? h(s, e) : Object.keys(e).forEach(function(S) {
+    Object.assign(
+      r,
+      Fe(e[S], n, S)
+    );
+  }), r;
+  function h(S, c) {
+    n && (c = c.map((i) => i.toLowerCase())), c.forEach(function(i) {
+      const u = i.split("|");
+      r[u[0]] = [S, Wn(u[0], u[1])];
+    });
+  }
+}
+function Wn(e, n) {
+  return n ? Number(n) : Xn(e) ? 0 : 1;
+}
+function Xn(e) {
+  return Zn.includes(e.toLowerCase());
+}
+const xe = {}, X = (e) => {
+  console.error(e);
+}, Ce = (e, ...n) => {
+  console.log(`WARN: ${e}`, ...n);
+}, V = (e, n) => {
+  xe[`${e}/${n}`] || (console.log(`Deprecated as of ${e}. ${n}`), xe[`${e}/${n}`] = !0);
+}, ue = new Error();
+function ze(e, n, { key: s }) {
+  let r = 0;
+  const h = e[s], S = {}, c = {};
+  for (let i = 1; i <= n.length; i++)
+    c[i + r] = h[i], S[i + r] = !0, r += Ue(n[i - 1]);
+  e[s] = c, e[s]._emit = S, e[s]._multi = !0;
+}
+function jn(e) {
+  if (Array.isArray(e.begin)) {
+    if (e.skip || e.excludeBegin || e.returnBegin)
+      throw X("skip, excludeBegin, returnBegin not compatible with beginScope: {}"), ue;
+    if (typeof e.beginScope != "object" || e.beginScope === null)
+      throw X("beginScope must be object"), ue;
+    ze(e, e.begin, { key: "beginScope" }), e.begin = Ne(e.begin, { joinWith: "" });
+  }
+}
+function Yn(e) {
+  if (Array.isArray(e.end)) {
+    if (e.skip || e.excludeEnd || e.returnEnd)
+      throw X("skip, excludeEnd, returnEnd not compatible with endScope: {}"), ue;
+    if (typeof e.endScope != "object" || e.endScope === null)
+      throw X("endScope must be object"), ue;
+    ze(e, e.end, { key: "endScope" }), e.end = Ne(e.end, { joinWith: "" });
+  }
+}
+function Jn(e) {
+  e.scope && typeof e.scope == "object" && e.scope !== null && (e.beginScope = e.scope, delete e.scope);
+}
+function Vn(e) {
+  Jn(e), typeof e.beginScope == "string" && (e.beginScope = { _wrap: e.beginScope }), typeof e.endScope == "string" && (e.endScope = { _wrap: e.endScope }), jn(e), Yn(e);
+}
+function Qn(e) {
+  function n(c, i) {
+    return new RegExp(
+      ie(c),
+      "m" + (e.case_insensitive ? "i" : "") + (e.unicodeRegex ? "u" : "") + (i ? "g" : "")
+    );
+  }
+  class s {
+    constructor() {
+      this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0;
+    }
+    // @ts-ignore
+    addRule(i, u) {
+      u.position = this.position++, this.matchIndexes[this.matchAt] = u, this.regexes.push([u, i]), this.matchAt += Ue(i) + 1;
+    }
+    compile() {
+      this.regexes.length === 0 && (this.exec = () => null);
+      const i = this.regexes.map((u) => u[1]);
+      this.matcherRe = n(Ne(i, { joinWith: "|" }), !0), this.lastIndex = 0;
+    }
+    /** @param {string} s */
+    exec(i) {
+      this.matcherRe.lastIndex = this.lastIndex;
+      const u = this.matcherRe.exec(i);
+      if (!u)
+        return null;
+      const b = u.findIndex((I, R) => R > 0 && I !== void 0), p = this.matchIndexes[b];
+      return u.splice(0, b), Object.assign(u, p);
+    }
+  }
+  class r {
+    constructor() {
+      this.rules = [], this.multiRegexes = [], this.count = 0, this.lastIndex = 0, this.regexIndex = 0;
+    }
+    // @ts-ignore
+    getMatcher(i) {
+      if (this.multiRegexes[i]) return this.multiRegexes[i];
+      const u = new s();
+      return this.rules.slice(i).forEach(([b, p]) => u.addRule(b, p)), u.compile(), this.multiRegexes[i] = u, u;
+    }
+    resumingScanAtSamePosition() {
+      return this.regexIndex !== 0;
+    }
+    considerAll() {
+      this.regexIndex = 0;
+    }
+    // @ts-ignore
+    addRule(i, u) {
+      this.rules.push([i, u]), u.type === "begin" && this.count++;
+    }
+    /** @param {string} s */
+    exec(i) {
+      const u = this.getMatcher(this.regexIndex);
+      u.lastIndex = this.lastIndex;
+      let b = u.exec(i);
+      if (this.resumingScanAtSamePosition() && !(b && b.index === this.lastIndex)) {
+        const p = this.getMatcher(0);
+        p.lastIndex = this.lastIndex + 1, b = p.exec(i);
+      }
+      return b && (this.regexIndex += b.position + 1, this.regexIndex === this.count && this.considerAll()), b;
+    }
+  }
+  function h(c) {
+    const i = new r();
+    return c.contains.forEach((u) => i.addRule(u.begin, { rule: u, type: "begin" })), c.terminatorEnd && i.addRule(c.terminatorEnd, { type: "end" }), c.illegal && i.addRule(c.illegal, { type: "illegal" }), i;
+  }
+  function S(c, i) {
+    const u = (
+      /** @type CompiledMode */
+      c
+    );
+    if (c.isCompiled) return u;
+    [
+      Pn,
+      // do this early so compiler extensions generally don't have to worry about
+      // the distinction between match/begin
+      Gn,
+      Vn,
+      zn
+    ].forEach((p) => p(c, i)), e.compilerExtensions.forEach((p) => p(c, i)), c.__beforeBegin = null, [
+      $n,
+      // do this later so compiler extensions that come earlier have access to the
+      // raw array if they wanted to perhaps manipulate it, etc.
+      Hn,
+      // default to 1 relevance if not specified
+      Fn
+    ].forEach((p) => p(c, i)), c.isCompiled = !0;
+    let b = null;
+    return typeof c.keywords == "object" && c.keywords.$pattern && (c.keywords = Object.assign({}, c.keywords), b = c.keywords.$pattern, delete c.keywords.$pattern), b = b || /\w+/, c.keywords && (c.keywords = Fe(c.keywords, e.case_insensitive)), u.keywordPatternRe = n(b, !0), i && (c.begin || (c.begin = /\B|\b/), u.beginRe = n(u.begin), !c.end && !c.endsWithParent && (c.end = /\B|\b/), c.end && (u.endRe = n(u.end)), u.terminatorEnd = ie(u.end) || "", c.endsWithParent && i.terminatorEnd && (u.terminatorEnd += (c.end ? "|" : "") + i.terminatorEnd)), c.illegal && (u.illegalRe = n(
+      /** @type {RegExp | string} */
+      c.illegal
+    )), c.contains || (c.contains = []), c.contains = [].concat(...c.contains.map(function(p) {
+      return qn(p === "self" ? c : p);
+    })), c.contains.forEach(function(p) {
+      S(
+        /** @type Mode */
+        p,
+        u
+      );
+    }), c.starts && S(c.starts, i), u.matcher = h(u), u;
+  }
+  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 = z(e.classNameAliases || {}), S(
+    /** @type Mode */
+    e
+  );
+}
+function Ze(e) {
+  return e ? e.endsWithParent || Ze(e.starts) : !1;
+}
+function qn(e) {
+  return e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map(function(n) {
+    return z(e, { variants: null }, n);
+  })), e.cachedVariants ? e.cachedVariants : Ze(e) ? z(e, { starts: e.starts ? z(e.starts) : null }) : Object.isFrozen(e) ? z(e) : e;
+}
+var et = "11.10.0";
+class nt extends Error {
+  constructor(n, s) {
+    super(n), this.name = "HTMLInjectionError", this.html = s;
+  }
+}
+const be = De, me = z, ve = Symbol("nomatch"), tt = 7, Ke = function(e) {
+  const n = /* @__PURE__ */ Object.create(null), s = /* @__PURE__ */ Object.create(null), r = [];
+  let h = !0;
+  const S = "Could not find the language '{}', did you forget to load/include a language module?", c = { disableAutodetect: !0, name: "Plain text", contains: [] };
+  let i = {
+    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: En
+  };
+  function u(t) {
+    return i.noHighlightRe.test(t);
+  }
+  function b(t) {
+    let a = t.className + " ";
+    a += t.parentNode ? t.parentNode.className : "";
+    const g = i.languageDetectRe.exec(a);
+    if (g) {
+      const E = m(g[1]);
+      return E || (Ce(S.replace("{}", g[1])), Ce("Falling back to no-highlight mode for this block.", t)), E ? g[1] : "no-highlight";
+    }
+    return a.split(/\s+/).find((E) => u(E) || m(E));
+  }
+  function p(t, a, g) {
+    let E = "", _ = "";
+    typeof a == "object" ? (E = t, g = a.ignoreIllegals, _ = a.language) : (V("10.7.0", "highlight(lang, code, ...args) has been deprecated."), V("10.7.0", `Please use highlight(code, options) instead.
+https://github.com/highlightjs/highlight.js/issues/2277`), _ = t, E = a), g === void 0 && (g = !0);
+    const T = {
+      code: E,
+      language: _
+    };
+    F("before:highlight", T);
+    const w = T.result ? T.result : I(T.language, T.code, g);
+    return w.code = T.code, F("after:highlight", w), w;
+  }
+  function I(t, a, g, E) {
+    const _ = /* @__PURE__ */ Object.create(null);
+    function T(o, l) {
+      return o.keywords[l];
+    }
+    function w() {
+      if (!f.keywords) {
+        M.addText(A);
+        return;
+      }
+      let o = 0;
+      f.keywordPatternRe.lastIndex = 0;
+      let l = f.keywordPatternRe.exec(A), d = "";
+      for (; l; ) {
+        d += A.substring(o, l.index);
+        const N = B.case_insensitive ? l[0].toLowerCase() : l[0], O = T(f, N);
+        if (O) {
+          const [H, on] = O;
+          if (M.addText(d), d = "", _[N] = (_[N] || 0) + 1, _[N] <= tt && (oe += on), H.startsWith("_"))
+            d += l[0];
+          else {
+            const ln = B.classNameAliases[H] || H;
+            D(l[0], ln);
+          }
+        } else
+          d += l[0];
+        o = f.keywordPatternRe.lastIndex, l = f.keywordPatternRe.exec(A);
+      }
+      d += A.substring(o), M.addText(d);
+    }
+    function ae() {
+      if (A === "") return;
+      let o = null;
+      if (typeof f.subLanguage == "string") {
+        if (!n[f.subLanguage]) {
+          M.addText(A);
+          return;
+        }
+        o = I(f.subLanguage, A, !0, ye[f.subLanguage]), ye[f.subLanguage] = /** @type {CompiledMode} */
+        o._top;
+      } else
+        o = y(A, f.subLanguage.length ? f.subLanguage : null);
+      f.relevance > 0 && (oe += o.relevance), M.__addSublanguage(o._emitter, o.language);
+    }
+    function C() {
+      f.subLanguage != null ? ae() : w(), A = "";
+    }
+    function D(o, l) {
+      o !== "" && (M.startScope(l), M.addText(o), M.endScope());
+    }
+    function Ae(o, l) {
+      let d = 1;
+      const N = l.length - 1;
+      for (; d <= N; ) {
+        if (!o._emit[d]) {
+          d++;
+          continue;
+        }
+        const O = B.classNameAliases[o[d]] || o[d], H = l[d];
+        O ? D(H, O) : (A = H, w(), A = ""), d++;
+      }
+    }
+    function Re(o, l) {
+      return o.scope && typeof o.scope == "string" && M.openNode(B.classNameAliases[o.scope] || o.scope), o.beginScope && (o.beginScope._wrap ? (D(A, B.classNameAliases[o.beginScope._wrap] || o.beginScope._wrap), A = "") : o.beginScope._multi && (Ae(o.beginScope, l), A = "")), f = Object.create(o, { parent: { value: f } }), f;
+    }
+    function Te(o, l, d) {
+      let N = _n(o.endRe, d);
+      if (N) {
+        if (o["on:end"]) {
+          const O = new Oe(o);
+          o["on:end"](l, O), O.isMatchIgnored && (N = !1);
+        }
+        if (N) {
+          for (; o.endsParent && o.parent; )
+            o = o.parent;
+          return o;
+        }
+      }
+      if (o.endsWithParent)
+        return Te(o.parent, l, d);
+    }
+    function tn(o) {
+      return f.matcher.regexIndex === 0 ? (A += o[0], 1) : (he = !0, 0);
+    }
+    function sn(o) {
+      const l = o[0], d = o.rule, N = new Oe(d), O = [d.__beforeBegin, d["on:begin"]];
+      for (const H of O)
+        if (H && (H(o, N), N.isMatchIgnored))
+          return tn(l);
+      return d.skip ? A += l : (d.excludeBegin && (A += l), C(), !d.returnBegin && !d.excludeBegin && (A = l)), Re(d, o), d.returnBegin ? 0 : l.length;
+    }
+    function rn(o) {
+      const l = o[0], d = a.substring(o.index), N = Te(f, o, d);
+      if (!N)
+        return ve;
+      const O = f;
+      f.endScope && f.endScope._wrap ? (C(), D(l, f.endScope._wrap)) : f.endScope && f.endScope._multi ? (C(), Ae(f.endScope, o)) : O.skip ? A += l : (O.returnEnd || O.excludeEnd || (A += l), C(), O.excludeEnd && (A = l));
+      do
+        f.scope && M.closeNode(), !f.skip && !f.subLanguage && (oe += f.relevance), f = f.parent;
+      while (f !== N.parent);
+      return N.starts && Re(N.starts, o), O.returnEnd ? 0 : l.length;
+    }
+    function an() {
+      const o = [];
+      for (let l = f; l !== B; l = l.parent)
+        l.scope && o.unshift(l.scope);
+      o.forEach((l) => M.openNode(l));
+    }
+    let ce = {};
+    function Me(o, l) {
+      const d = l && l[0];
+      if (A += o, d == null)
+        return C(), 0;
+      if (ce.type === "begin" && l.type === "end" && ce.index === l.index && d === "") {
+        if (A += a.slice(l.index, l.index + 1), !h) {
+          const N = new Error(`0 width match regex (${t})`);
+          throw N.languageName = t, N.badRule = ce.rule, N;
+        }
+        return 1;
+      }
+      if (ce = l, l.type === "begin")
+        return sn(l);
+      if (l.type === "illegal" && !g) {
+        const N = new Error('Illegal lexeme "' + d + '" for mode "' + (f.scope || "<unnamed>") + '"');
+        throw N.mode = f, N;
+      } else if (l.type === "end") {
+        const N = rn(l);
+        if (N !== ve)
+          return N;
+      }
+      if (l.type === "illegal" && d === "")
+        return 1;
+      if (Ee > 1e5 && Ee > l.index * 3)
+        throw new Error("potential infinite loop, way more iterations than matches");
+      return A += d, d.length;
+    }
+    const B = m(t);
+    if (!B)
+      throw X(S.replace("{}", t)), new Error('Unknown language: "' + t + '"');
+    const cn = Qn(B);
+    let de = "", f = E || cn;
+    const ye = {}, M = new i.__emitter(i);
+    an();
+    let A = "", oe = 0, W = 0, Ee = 0, he = !1;
+    try {
+      if (B.__emitTokens)
+        B.__emitTokens(a, M);
+      else {
+        for (f.matcher.considerAll(); ; ) {
+          Ee++, he ? he = !1 : f.matcher.considerAll(), f.matcher.lastIndex = W;
+          const o = f.matcher.exec(a);
+          if (!o) break;
+          const l = a.substring(W, o.index), d = Me(l, o);
+          W = o.index + d;
+        }
+        Me(a.substring(W));
+      }
+      return M.finalize(), de = M.toHTML(), {
+        language: t,
+        value: de,
+        relevance: oe,
+        illegal: !1,
+        _emitter: M,
+        _top: f
+      };
+    } catch (o) {
+      if (o.message && o.message.includes("Illegal"))
+        return {
+          language: t,
+          value: be(a),
+          illegal: !0,
+          relevance: 0,
+          _illegalBy: {
+            message: o.message,
+            index: W,
+            context: a.slice(W - 100, W + 100),
+            mode: o.mode,
+            resultSoFar: de
+          },
+          _emitter: M
+        };
+      if (h)
+        return {
+          language: t,
+          value: be(a),
+          illegal: !1,
+          relevance: 0,
+          errorRaised: o,
+          _emitter: M,
+          _top: f
+        };
+      throw o;
+    }
+  }
+  function R(t) {
+    const a = {
+      value: be(t),
+      illegal: !1,
+      relevance: 0,
+      _top: c,
+      _emitter: new i.__emitter(i)
+    };
+    return a._emitter.addText(t), a;
+  }
+  function y(t, a) {
+    a = a || i.languages || Object.keys(n);
+    const g = R(t), E = a.filter(m).filter(J).map(
+      (C) => I(C, t, !1)
+    );
+    E.unshift(g);
+    const _ = E.sort((C, D) => {
+      if (C.relevance !== D.relevance) return D.relevance - C.relevance;
+      if (C.language && D.language) {
+        if (m(C.language).supersetOf === D.language)
+          return 1;
+        if (m(D.language).supersetOf === C.language)
+          return -1;
+      }
+      return 0;
+    }), [T, w] = _, ae = T;
+    return ae.secondBest = w, ae;
+  }
+  function U(t, a, g) {
+    const E = a && s[a] || g;
+    t.classList.add("hljs"), t.classList.add(`language-${E}`);
+  }
+  function v(t) {
+    let a = null;
+    const g = b(t);
+    if (u(g)) return;
+    if (F(
+      "before:highlightElement",
+      { el: t, language: g }
+    ), t.dataset.highlighted) {
+      console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", t);
+      return;
+    }
+    if (t.children.length > 0 && (i.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(t)), i.throwUnescapedHTML))
+      throw new nt(
+        "One of your code blocks includes unescaped HTML.",
+        t.innerHTML
+      );
+    a = t;
+    const E = a.textContent, _ = g ? p(E, { language: g, ignoreIllegals: !0 }) : y(E);
+    t.innerHTML = _.value, t.dataset.highlighted = "yes", U(t, g, _.language), t.result = {
+      language: _.language,
+      // TODO: remove with version 11.0
+      re: _.relevance,
+      relevance: _.relevance
+    }, _.secondBest && (t.secondBest = {
+      language: _.secondBest.language,
+      relevance: _.secondBest.relevance
+    }), F("after:highlightElement", { el: t, result: _, text: E });
+  }
+  function L(t) {
+    i = me(i, t);
+  }
+  const q = () => {
+    k(), V("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
+  };
+  function P() {
+    k(), V("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
+  }
+  let G = !1;
+  function k() {
+    if (document.readyState === "loading") {
+      G = !0;
+      return;
+    }
+    document.querySelectorAll(i.cssSelector).forEach(v);
+  }
+  function $() {
+    G && k();
+  }
+  typeof window < "u" && window.addEventListener && window.addEventListener("DOMContentLoaded", $, !1);
+  function x(t, a) {
+    let g = null;
+    try {
+      g = a(e);
+    } catch (E) {
+      if (X("Language definition for '{}' could not be registered.".replace("{}", t)), h)
+        X(E);
+      else
+        throw E;
+      g = c;
+    }
+    g.name || (g.name = t), n[t] = g, g.rawDefinition = a.bind(null, e), g.aliases && Y(g.aliases, { languageName: t });
+  }
+  function ee(t) {
+    delete n[t];
+    for (const a of Object.keys(s))
+      s[a] === t && delete s[a];
+  }
+  function Z() {
+    return Object.keys(n);
+  }
+  function m(t) {
+    return t = (t || "").toLowerCase(), n[t] || n[s[t]];
+  }
+  function Y(t, { languageName: a }) {
+    typeof t == "string" && (t = [t]), t.forEach((g) => {
+      s[g.toLowerCase()] = a;
+    });
+  }
+  function J(t) {
+    const a = m(t);
+    return a && !a.disableAutodetect;
+  }
+  function ne(t) {
+    t["before:highlightBlock"] && !t["before:highlightElement"] && (t["before:highlightElement"] = (a) => {
+      t["before:highlightBlock"](
+        Object.assign({ block: a.el }, a)
+      );
+    }), t["after:highlightBlock"] && !t["after:highlightElement"] && (t["after:highlightElement"] = (a) => {
+      t["after:highlightBlock"](
+        Object.assign({ block: a.el }, a)
+      );
+    });
+  }
+  function te(t) {
+    ne(t), r.push(t);
+  }
+  function se(t) {
+    const a = r.indexOf(t);
+    a !== -1 && r.splice(a, 1);
+  }
+  function F(t, a) {
+    const g = t;
+    r.forEach(function(E) {
+      E[g] && E[g](a);
+    });
+  }
+  function K(t) {
+    return V("10.7.0", "highlightBlock will be removed entirely in v12.0"), V("10.7.0", "Please use highlightElement now."), v(t);
+  }
+  Object.assign(e, {
+    highlight: p,
+    highlightAuto: y,
+    highlightAll: k,
+    highlightElement: v,
+    // TODO: Remove with v12 API
+    highlightBlock: K,
+    configure: L,
+    initHighlighting: q,
+    initHighlightingOnLoad: P,
+    registerLanguage: x,
+    unregisterLanguage: ee,
+    listLanguages: Z,
+    getLanguage: m,
+    registerAliases: Y,
+    autoDetection: J,
+    inherit: me,
+    addPlugin: te,
+    removePlugin: se
+  }), e.debugMode = function() {
+    h = !1;
+  }, e.safeMode = function() {
+    h = !0;
+  }, e.versionString = et, e.regex = {
+    concat: j,
+    lookahead: Be,
+    either: _e,
+    optional: bn,
+    anyNumberOfTimes: hn
+  };
+  for (const t in le)
+    typeof le[t] == "object" && ke(le[t]);
+  return Object.assign(e, le), e;
+}, Q = Ke({});
+Q.newInstance = () => Ke({});
+var st = Q;
+Q.HighlightJS = Q;
+Q.default = Q;
+const ut = /* @__PURE__ */ un(st), Le = "[A-Za-z$_][0-9A-Za-z$_]*", it = [
+  "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"
+], rt = [
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "NaN",
+  "Infinity"
+], We = [
+  // 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"
+], Xe = [
+  "Error",
+  "EvalError",
+  "InternalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError"
+], je = [
+  "setInterval",
+  "setTimeout",
+  "clearInterval",
+  "clearTimeout",
+  "require",
+  "exports",
+  "eval",
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
+  "escape",
+  "unescape"
+], at = [
+  "arguments",
+  "this",
+  "super",
+  "console",
+  "window",
+  "document",
+  "localStorage",
+  "sessionStorage",
+  "module",
+  "global"
+  // Node.js
+], ct = [].concat(
+  je,
+  We,
+  Xe
+);
+function gt(e) {
+  const n = e.regex, s = (a, { after: g }) => {
+    const E = "</" + a[0].slice(1);
+    return a.input.indexOf(E, g) !== -1;
+  }, r = Le, h = {
+    begin: "<>",
+    end: "</>"
+  }, S = /<[A-Za-z0-9\\._:-]+\s*\/>/, c = {
+    begin: /<[A-Za-z0-9\\._:-]+/,
+    end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+    /**
+     * @param {RegExpMatchArray} match
+     * @param {CallbackResponse} response
+     */
+    isTrulyOpeningTag: (a, g) => {
+      const E = a[0].length + a.index, _ = a.input[E];
+      if (
+        // HTML should not include another raw `<` inside a tag
+        // nested type?
+        // `<Array<Array<number>>`, etc.
+        _ === "<" || // the , gives away that this is not HTML
+        // `<T, A extends keyof T, V>`
+        _ === ","
+      ) {
+        g.ignoreMatch();
+        return;
+      }
+      _ === ">" && (s(a, { after: E }) || g.ignoreMatch());
+      let T;
+      const w = a.input.substring(E);
+      if (T = w.match(/^\s*=/)) {
+        g.ignoreMatch();
+        return;
+      }
+      if ((T = w.match(/^\s+extends\s+/)) && T.index === 0) {
+        g.ignoreMatch();
+        return;
+      }
+    }
+  }, i = {
+    $pattern: Le,
+    keyword: it,
+    literal: rt,
+    built_in: ct,
+    "variable.language": at
+  }, u = "[0-9](_?[0-9])*", b = `\\.(${u})`, p = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", I = {
+    className: "number",
+    variants: [
+      // DecimalLiteral
+      { begin: `(\\b(${p})((${b})|\\.)?|(${b}))[eE][+-]?(${u})\\b` },
+      { begin: `\\b(${p})\\b((${b})\\b|\\.)?|(${b})\\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
+  }, R = {
+    className: "subst",
+    begin: "\\$\\{",
+    end: "\\}",
+    keywords: i,
+    contains: []
+    // defined later
+  }, y = {
+    begin: ".?html`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        R
+      ],
+      subLanguage: "xml"
+    }
+  }, U = {
+    begin: ".?css`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        R
+      ],
+      subLanguage: "css"
+    }
+  }, v = {
+    begin: ".?gql`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        R
+      ],
+      subLanguage: "graphql"
+    }
+  }, L = {
+    className: "string",
+    begin: "`",
+    end: "`",
+    contains: [
+      e.BACKSLASH_ESCAPE,
+      R
+    ]
+  }, P = {
+    className: "comment",
+    variants: [
+      e.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: r + "(?=\\s*(-)|$)",
+                  endsParent: !0,
+                  relevance: 0
+                },
+                // eat spaces (not newlines) so we can find
+                // types or variables
+                {
+                  begin: /(?=[^\n])\s/,
+                  relevance: 0
+                }
+              ]
+            }
+          ]
+        }
+      ),
+      e.C_BLOCK_COMMENT_MODE,
+      e.C_LINE_COMMENT_MODE
+    ]
+  }, G = [
+    e.APOS_STRING_MODE,
+    e.QUOTE_STRING_MODE,
+    y,
+    U,
+    v,
+    L,
+    // Skip numbers when they are part of a variable name
+    { match: /\$\d+/ },
+    I
+    // This is intentional:
+    // See https://github.com/highlightjs/highlight.js/issues/3288
+    // hljs.REGEXP_MODE
+  ];
+  R.contains = G.concat({
+    // we need to pair up {} inside our subst to prevent
+    // it from ending too early by matching another }
+    begin: /\{/,
+    end: /\}/,
+    keywords: i,
+    contains: [
+      "self"
+    ].concat(G)
+  });
+  const k = [].concat(P, R.contains), $ = k.concat([
+    // eat recursive parens in sub expressions
+    {
+      begin: /(\s*)\(/,
+      end: /\)/,
+      keywords: i,
+      contains: ["self"].concat(k)
+    }
+  ]), x = {
+    className: "params",
+    // convert this to negative lookbehind in v12
+    begin: /(\s*)\(/,
+    // to match the parms with 
+    end: /\)/,
+    excludeBegin: !0,
+    excludeEnd: !0,
+    keywords: i,
+    contains: $
+  }, ee = {
+    variants: [
+      // class Car extends vehicle
+      {
+        match: [
+          /class/,
+          /\s+/,
+          r,
+          /\s+/,
+          /extends/,
+          /\s+/,
+          n.concat(r, "(", n.concat(/\./, r), ")*")
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class",
+          5: "keyword",
+          7: "title.class.inherited"
+        }
+      },
+      // class Car
+      {
+        match: [
+          /class/,
+          /\s+/,
+          r
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class"
+        }
+      }
+    ]
+  }, Z = {
+    relevance: 0,
+    match: n.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
+        ...We,
+        ...Xe
+      ]
+    }
+  }, m = {
+    label: "use_strict",
+    className: "meta",
+    relevance: 10,
+    begin: /^\s*['"]use (strict|asm)['"]/
+  }, Y = {
+    variants: [
+      {
+        match: [
+          /function/,
+          /\s+/,
+          r,
+          /(?=\s*\()/
+        ]
+      },
+      // anonymous function
+      {
+        match: [
+          /function/,
+          /\s*(?=\()/
+        ]
+      }
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    label: "func.def",
+    contains: [x],
+    illegal: /%/
+  }, J = {
+    relevance: 0,
+    match: /\b[A-Z][A-Z_0-9]+\b/,
+    className: "variable.constant"
+  };
+  function ne(a) {
+    return n.concat("(?!", a.join("|"), ")");
+  }
+  const te = {
+    match: n.concat(
+      /\b/,
+      ne([
+        ...je,
+        "super",
+        "import"
+      ].map((a) => `${a}\\s*\\(`)),
+      r,
+      n.lookahead(/\s*\(/)
+    ),
+    className: "title.function",
+    relevance: 0
+  }, se = {
+    begin: n.concat(/\./, n.lookahead(
+      n.concat(r, /(?![0-9A-Za-z$_(])/)
+    )),
+    end: r,
+    excludeBegin: !0,
+    keywords: "prototype",
+    className: "property",
+    relevance: 0
+  }, F = {
+    match: [
+      /get|set/,
+      /\s+/,
+      r,
+      /(?=\()/
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      {
+        // eat to avoid empty params
+        begin: /\(\)/
+      },
+      x
+    ]
+  }, K = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + e.UNDERSCORE_IDENT_RE + ")\\s*=>", t = {
+    match: [
+      /const|var|let/,
+      /\s+/,
+      r,
+      /\s*/,
+      /=\s*/,
+      /(async\s*)?/,
+      // async is optional
+      n.lookahead(K)
+    ],
+    keywords: "async",
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      x
+    ]
+  };
+  return {
+    name: "JavaScript",
+    aliases: ["js", "jsx", "mjs", "cjs"],
+    keywords: i,
+    // this will be extended by TypeScript
+    exports: { PARAMS_CONTAINS: $, CLASS_REFERENCE: Z },
+    illegal: /#(?![$_A-z])/,
+    contains: [
+      e.SHEBANG({
+        label: "shebang",
+        binary: "node",
+        relevance: 5
+      }),
+      m,
+      e.APOS_STRING_MODE,
+      e.QUOTE_STRING_MODE,
+      y,
+      U,
+      v,
+      L,
+      P,
+      // Skip numbers when they are part of a variable name
+      { match: /\$\d+/ },
+      I,
+      Z,
+      {
+        className: "attr",
+        begin: r + n.lookahead(":"),
+        relevance: 0
+      },
+      t,
+      {
+        // "value" container
+        begin: "(" + e.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+        keywords: "return throw case",
+        relevance: 0,
+        contains: [
+          P,
+          e.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: K,
+            returnBegin: !0,
+            end: "\\s*=>",
+            contains: [
+              {
+                className: "params",
+                variants: [
+                  {
+                    begin: e.UNDERSCORE_IDENT_RE,
+                    relevance: 0
+                  },
+                  {
+                    className: null,
+                    begin: /\(\s*\)/,
+                    skip: !0
+                  },
+                  {
+                    begin: /(\s*)\(/,
+                    end: /\)/,
+                    excludeBegin: !0,
+                    excludeEnd: !0,
+                    keywords: i,
+                    contains: $
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            // could be a comma delimited list of params to a function call
+            begin: /,/,
+            relevance: 0
+          },
+          {
+            match: /\s+/,
+            relevance: 0
+          },
+          {
+            // JSX
+            variants: [
+              { begin: h.begin, end: h.end },
+              { match: S },
+              {
+                begin: c.begin,
+                // we carefully check the opening tag to see if it truly
+                // is a tag and not a false positive
+                "on:begin": c.isTrulyOpeningTag,
+                end: c.end
+              }
+            ],
+            subLanguage: "xml",
+            contains: [
+              {
+                begin: c.begin,
+                end: c.end,
+                skip: !0,
+                contains: ["self"]
+              }
+            ]
+          }
+        ]
+      },
+      Y,
+      {
+        // 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)" + e.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+        // end parens
+        returnBegin: !0,
+        label: "func.def",
+        contains: [
+          x,
+          e.inherit(e.TITLE_MODE, { begin: r, className: "title.function" })
+        ]
+      },
+      // catch ... so it won't trigger the property rule below
+      {
+        match: /\.\.\./,
+        relevance: 0
+      },
+      se,
+      // hack: prevents detection of keywords in some circumstances
+      // .keyword()
+      // $keyword = x
+      {
+        match: "\\$" + r,
+        relevance: 0
+      },
+      {
+        match: [/\bconstructor(?=\s*\()/],
+        className: { 1: "title.function" },
+        contains: [x]
+      },
+      te,
+      J,
+      ee,
+      F,
+      {
+        match: /\$[(.]/
+        // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+      }
+    ]
+  };
+}
+function ft(e) {
+  const n = {
+    className: "attr",
+    begin: /"(\\.|[^\\"\r\n])*"(?=\s*:)/,
+    relevance: 1.01
+  }, s = {
+    match: /[{}[\],:]/,
+    className: "punctuation",
+    relevance: 0
+  }, r = [
+    "true",
+    "false",
+    "null"
+  ], h = {
+    scope: "literal",
+    beginKeywords: r.join(" ")
+  };
+  return {
+    name: "JSON",
+    aliases: ["jsonc"],
+    keywords: {
+      literal: r
+    },
+    contains: [
+      n,
+      s,
+      e.QUOTE_STRING_MODE,
+      h,
+      e.C_NUMBER_MODE,
+      e.C_LINE_COMMENT_MODE,
+      e.C_BLOCK_COMMENT_MODE
+    ],
+    illegal: "\\S"
+  };
+}
+const ge = "[A-Za-z$_][0-9A-Za-z$_]*", Ye = [
+  "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"
+], Je = [
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "NaN",
+  "Infinity"
+], Ve = [
+  // 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"
+], Qe = [
+  "Error",
+  "EvalError",
+  "InternalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError"
+], qe = [
+  "setInterval",
+  "setTimeout",
+  "clearInterval",
+  "clearTimeout",
+  "require",
+  "exports",
+  "eval",
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
+  "escape",
+  "unescape"
+], en = [
+  "arguments",
+  "this",
+  "super",
+  "console",
+  "window",
+  "document",
+  "localStorage",
+  "sessionStorage",
+  "module",
+  "global"
+  // Node.js
+], nn = [].concat(
+  qe,
+  Ve,
+  Qe
+);
+function ot(e) {
+  const n = e.regex, s = (a, { after: g }) => {
+    const E = "</" + a[0].slice(1);
+    return a.input.indexOf(E, g) !== -1;
+  }, r = ge, h = {
+    begin: "<>",
+    end: "</>"
+  }, S = /<[A-Za-z0-9\\._:-]+\s*\/>/, c = {
+    begin: /<[A-Za-z0-9\\._:-]+/,
+    end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+    /**
+     * @param {RegExpMatchArray} match
+     * @param {CallbackResponse} response
+     */
+    isTrulyOpeningTag: (a, g) => {
+      const E = a[0].length + a.index, _ = a.input[E];
+      if (
+        // HTML should not include another raw `<` inside a tag
+        // nested type?
+        // `<Array<Array<number>>`, etc.
+        _ === "<" || // the , gives away that this is not HTML
+        // `<T, A extends keyof T, V>`
+        _ === ","
+      ) {
+        g.ignoreMatch();
+        return;
+      }
+      _ === ">" && (s(a, { after: E }) || g.ignoreMatch());
+      let T;
+      const w = a.input.substring(E);
+      if (T = w.match(/^\s*=/)) {
+        g.ignoreMatch();
+        return;
+      }
+      if ((T = w.match(/^\s+extends\s+/)) && T.index === 0) {
+        g.ignoreMatch();
+        return;
+      }
+    }
+  }, i = {
+    $pattern: ge,
+    keyword: Ye,
+    literal: Je,
+    built_in: nn,
+    "variable.language": en
+  }, u = "[0-9](_?[0-9])*", b = `\\.(${u})`, p = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", I = {
+    className: "number",
+    variants: [
+      // DecimalLiteral
+      { begin: `(\\b(${p})((${b})|\\.)?|(${b}))[eE][+-]?(${u})\\b` },
+      { begin: `\\b(${p})\\b((${b})\\b|\\.)?|(${b})\\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
+  }, R = {
+    className: "subst",
+    begin: "\\$\\{",
+    end: "\\}",
+    keywords: i,
+    contains: []
+    // defined later
+  }, y = {
+    begin: ".?html`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        R
+      ],
+      subLanguage: "xml"
+    }
+  }, U = {
+    begin: ".?css`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        R
+      ],
+      subLanguage: "css"
+    }
+  }, v = {
+    begin: ".?gql`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        R
+      ],
+      subLanguage: "graphql"
+    }
+  }, L = {
+    className: "string",
+    begin: "`",
+    end: "`",
+    contains: [
+      e.BACKSLASH_ESCAPE,
+      R
+    ]
+  }, P = {
+    className: "comment",
+    variants: [
+      e.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: r + "(?=\\s*(-)|$)",
+                  endsParent: !0,
+                  relevance: 0
+                },
+                // eat spaces (not newlines) so we can find
+                // types or variables
+                {
+                  begin: /(?=[^\n])\s/,
+                  relevance: 0
+                }
+              ]
+            }
+          ]
+        }
+      ),
+      e.C_BLOCK_COMMENT_MODE,
+      e.C_LINE_COMMENT_MODE
+    ]
+  }, G = [
+    e.APOS_STRING_MODE,
+    e.QUOTE_STRING_MODE,
+    y,
+    U,
+    v,
+    L,
+    // Skip numbers when they are part of a variable name
+    { match: /\$\d+/ },
+    I
+    // This is intentional:
+    // See https://github.com/highlightjs/highlight.js/issues/3288
+    // hljs.REGEXP_MODE
+  ];
+  R.contains = G.concat({
+    // we need to pair up {} inside our subst to prevent
+    // it from ending too early by matching another }
+    begin: /\{/,
+    end: /\}/,
+    keywords: i,
+    contains: [
+      "self"
+    ].concat(G)
+  });
+  const k = [].concat(P, R.contains), $ = k.concat([
+    // eat recursive parens in sub expressions
+    {
+      begin: /(\s*)\(/,
+      end: /\)/,
+      keywords: i,
+      contains: ["self"].concat(k)
+    }
+  ]), x = {
+    className: "params",
+    // convert this to negative lookbehind in v12
+    begin: /(\s*)\(/,
+    // to match the parms with 
+    end: /\)/,
+    excludeBegin: !0,
+    excludeEnd: !0,
+    keywords: i,
+    contains: $
+  }, ee = {
+    variants: [
+      // class Car extends vehicle
+      {
+        match: [
+          /class/,
+          /\s+/,
+          r,
+          /\s+/,
+          /extends/,
+          /\s+/,
+          n.concat(r, "(", n.concat(/\./, r), ")*")
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class",
+          5: "keyword",
+          7: "title.class.inherited"
+        }
+      },
+      // class Car
+      {
+        match: [
+          /class/,
+          /\s+/,
+          r
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class"
+        }
+      }
+    ]
+  }, Z = {
+    relevance: 0,
+    match: n.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
+        ...Ve,
+        ...Qe
+      ]
+    }
+  }, m = {
+    label: "use_strict",
+    className: "meta",
+    relevance: 10,
+    begin: /^\s*['"]use (strict|asm)['"]/
+  }, Y = {
+    variants: [
+      {
+        match: [
+          /function/,
+          /\s+/,
+          r,
+          /(?=\s*\()/
+        ]
+      },
+      // anonymous function
+      {
+        match: [
+          /function/,
+          /\s*(?=\()/
+        ]
+      }
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    label: "func.def",
+    contains: [x],
+    illegal: /%/
+  }, J = {
+    relevance: 0,
+    match: /\b[A-Z][A-Z_0-9]+\b/,
+    className: "variable.constant"
+  };
+  function ne(a) {
+    return n.concat("(?!", a.join("|"), ")");
+  }
+  const te = {
+    match: n.concat(
+      /\b/,
+      ne([
+        ...qe,
+        "super",
+        "import"
+      ].map((a) => `${a}\\s*\\(`)),
+      r,
+      n.lookahead(/\s*\(/)
+    ),
+    className: "title.function",
+    relevance: 0
+  }, se = {
+    begin: n.concat(/\./, n.lookahead(
+      n.concat(r, /(?![0-9A-Za-z$_(])/)
+    )),
+    end: r,
+    excludeBegin: !0,
+    keywords: "prototype",
+    className: "property",
+    relevance: 0
+  }, F = {
+    match: [
+      /get|set/,
+      /\s+/,
+      r,
+      /(?=\()/
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      {
+        // eat to avoid empty params
+        begin: /\(\)/
+      },
+      x
+    ]
+  }, K = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + e.UNDERSCORE_IDENT_RE + ")\\s*=>", t = {
+    match: [
+      /const|var|let/,
+      /\s+/,
+      r,
+      /\s*/,
+      /=\s*/,
+      /(async\s*)?/,
+      // async is optional
+      n.lookahead(K)
+    ],
+    keywords: "async",
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      x
+    ]
+  };
+  return {
+    name: "JavaScript",
+    aliases: ["js", "jsx", "mjs", "cjs"],
+    keywords: i,
+    // this will be extended by TypeScript
+    exports: { PARAMS_CONTAINS: $, CLASS_REFERENCE: Z },
+    illegal: /#(?![$_A-z])/,
+    contains: [
+      e.SHEBANG({
+        label: "shebang",
+        binary: "node",
+        relevance: 5
+      }),
+      m,
+      e.APOS_STRING_MODE,
+      e.QUOTE_STRING_MODE,
+      y,
+      U,
+      v,
+      L,
+      P,
+      // Skip numbers when they are part of a variable name
+      { match: /\$\d+/ },
+      I,
+      Z,
+      {
+        className: "attr",
+        begin: r + n.lookahead(":"),
+        relevance: 0
+      },
+      t,
+      {
+        // "value" container
+        begin: "(" + e.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+        keywords: "return throw case",
+        relevance: 0,
+        contains: [
+          P,
+          e.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: K,
+            returnBegin: !0,
+            end: "\\s*=>",
+            contains: [
+              {
+                className: "params",
+                variants: [
+                  {
+                    begin: e.UNDERSCORE_IDENT_RE,
+                    relevance: 0
+                  },
+                  {
+                    className: null,
+                    begin: /\(\s*\)/,
+                    skip: !0
+                  },
+                  {
+                    begin: /(\s*)\(/,
+                    end: /\)/,
+                    excludeBegin: !0,
+                    excludeEnd: !0,
+                    keywords: i,
+                    contains: $
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            // could be a comma delimited list of params to a function call
+            begin: /,/,
+            relevance: 0
+          },
+          {
+            match: /\s+/,
+            relevance: 0
+          },
+          {
+            // JSX
+            variants: [
+              { begin: h.begin, end: h.end },
+              { match: S },
+              {
+                begin: c.begin,
+                // we carefully check the opening tag to see if it truly
+                // is a tag and not a false positive
+                "on:begin": c.isTrulyOpeningTag,
+                end: c.end
+              }
+            ],
+            subLanguage: "xml",
+            contains: [
+              {
+                begin: c.begin,
+                end: c.end,
+                skip: !0,
+                contains: ["self"]
+              }
+            ]
+          }
+        ]
+      },
+      Y,
+      {
+        // 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)" + e.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+        // end parens
+        returnBegin: !0,
+        label: "func.def",
+        contains: [
+          x,
+          e.inherit(e.TITLE_MODE, { begin: r, className: "title.function" })
+        ]
+      },
+      // catch ... so it won't trigger the property rule below
+      {
+        match: /\.\.\./,
+        relevance: 0
+      },
+      se,
+      // hack: prevents detection of keywords in some circumstances
+      // .keyword()
+      // $keyword = x
+      {
+        match: "\\$" + r,
+        relevance: 0
+      },
+      {
+        match: [/\bconstructor(?=\s*\()/],
+        className: { 1: "title.function" },
+        contains: [x]
+      },
+      te,
+      J,
+      ee,
+      F,
+      {
+        match: /\$[(.]/
+        // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+      }
+    ]
+  };
+}
+function dt(e) {
+  const n = ot(e), s = ge, r = [
+    "any",
+    "void",
+    "number",
+    "boolean",
+    "string",
+    "object",
+    "never",
+    "symbol",
+    "bigint",
+    "unknown"
+  ], h = {
+    begin: [
+      /namespace/,
+      /\s+/,
+      e.IDENT_RE
+    ],
+    beginScope: {
+      1: "keyword",
+      3: "title.class"
+    }
+  }, S = {
+    beginKeywords: "interface",
+    end: /\{/,
+    excludeEnd: !0,
+    keywords: {
+      keyword: "interface extends",
+      built_in: r
+    },
+    contains: [n.exports.CLASS_REFERENCE]
+  }, c = {
+    className: "meta",
+    relevance: 10,
+    begin: /^\s*['"]use strict['"]/
+  }, i = [
+    "type",
+    // "namespace",
+    "interface",
+    "public",
+    "private",
+    "protected",
+    "implements",
+    "declare",
+    "abstract",
+    "readonly",
+    "enum",
+    "override",
+    "satisfies"
+  ], u = {
+    $pattern: ge,
+    keyword: Ye.concat(i),
+    literal: Je,
+    built_in: nn.concat(r),
+    "variable.language": en
+  }, b = {
+    className: "meta",
+    begin: "@" + s
+  }, p = (y, U, v) => {
+    const L = y.contains.findIndex((q) => q.label === U);
+    if (L === -1)
+      throw new Error("can not find mode to replace");
+    y.contains.splice(L, 1, v);
+  };
+  Object.assign(n.keywords, u), n.exports.PARAMS_CONTAINS.push(b);
+  const I = n.contains.find((y) => y.className === "attr");
+  n.exports.PARAMS_CONTAINS.push([
+    n.exports.CLASS_REFERENCE,
+    // class reference for highlighting the params types
+    I
+    // highlight the params key
+  ]), n.contains = n.contains.concat([
+    b,
+    h,
+    S
+  ]), p(n, "shebang", e.SHEBANG()), p(n, "use_strict", c);
+  const R = n.contains.find((y) => y.label === "func.def");
+  return R.relevance = 0, Object.assign(n, {
+    name: "TypeScript",
+    aliases: [
+      "ts",
+      "tsx",
+      "mts",
+      "cts"
+    ]
+  }), n;
+}
+export {
+  ut as H,
+  ft as a,
+  gt as j,
+  dt as t
+};