@remarkablejames/editor 0.0.1

package/lib/CodeBlock.js

@@ -0,0 +1,4065 @@
+import { h as ta, j as Te, N as na, t as Pt, k as aa, m as ra } from "./clsx-CDyrfCnw.js";
+import { jsx as C, Fragment as ia, jsxs as tt } from "react/jsx-runtime";
+import { u as sa, d as oa, A as la, J as ca, I as Ee } from "./index-lj3VWExo.js";
+import { useRef as $t, useCallback as nt, useEffect as Dt } from "react";
+import "./theme.js";
+import { S as Ft, a as Ut, b as da, c as Bt, d as Gt } from "./select-CuE_HaQJ.js";
+import { d as ua } from "./delete-node-eQHsyyhR.js";
+function br() {
+  const e = sa(ea.name), {
+    icon: t = void 0,
+    tooltip: n = void 0,
+    tooltipOptions: s = {},
+    action: l = void 0,
+    isActive: u = void 0
+  } = (e == null ? void 0 : e.componentProps) ?? {}, { dataState: f, disabled: E, update: y } = oa(u), v = () => {
+    E || l && (l(), y());
+  };
+  return e ? /* @__PURE__ */ C(
+    la,
+    {
+      action: v,
+      dataState: f,
+      disabled: E,
+      icon: t,
+      tooltip: n,
+      tooltipOptions: s
+    }
+  ) : /* @__PURE__ */ C(ia, {});
+}
+var xe = {}, j = Symbol(), J = Symbol(), St = (e) => typeof e == "string" ? _[e] : e, _ = {
+  plain: xe,
+  plaintext: xe,
+  text: xe,
+  txt: xe
+}, ke = (e, t) => (t[J] || Se)(e, t), Se = (e, t) => {
+  for (var n = [e], s, l = [], u = 0; s = St(t[j]); )
+    delete t[j], Object.assign(t, s);
+  for (xn(e, t, n, 0); l[u++] = n[0], n = n[1]; ) ;
+  return l;
+}, zt = "</span>", Oe = "", ye = "", Sn = (e) => {
+  for (var t = "", n = e.length, s = 0; s < n; ) t += Tn(e[s++]);
+  return t;
+}, Tn = (e) => {
+  if (e instanceof ue) {
+    var { type: t, alias: n, content: s } = e, l = Oe, u = ye, f = `<span class="token ${t + (n ? " " + n : "") + (t == "keyword" && typeof s == "string" ? " keyword-" + s : "")}">`;
+    ye += zt, Oe += f;
+    var E = Tn(s);
+    return Oe = l, ye = u, f + E + zt;
+  }
+  return typeof e != "string" ? Sn(e) : (e = e.replace(/&/g, "&amp;").replace(/</g, "&lt;"), ye && e.includes(`
+`) ? e.replace(/\n/g, ye + `
+` + Oe) : e);
+}, xn = (e, t, n, s, l) => {
+  for (var u in t)
+    if (t[u]) for (var f = 0, E = t[u], y = Array.isArray(E) ? E : [E]; f < y.length; ++f) {
+      if (l && l[0] == u && l[1] == f)
+        return;
+      for (var v = y[f], m = v.pattern || v, p = St(v.inside), c = v.lookbehind, b = v.greedy && m.global, g = v.alias, a = n, r = s; a && (!l || r < l[2]); r += a[0].length, a = a[1]) {
+        var d = a[0], o = 0, i, h;
+        if (!(d instanceof ue)) {
+          if (m.lastIndex = b ? r : 0, i = m.exec(b ? e : d), i && c && i[1] && (h = i[1].length, i.index += h, i[0] = i[0].slice(h)), b) {
+            if (!i)
+              break;
+            if (i[0]) {
+              for (var S = i.index, k = S + i[0].length, I; S >= r + (I = a[0].length); a = a[1], r += I) ;
+              if (a[0] instanceof ue)
+                continue;
+              for (var w = a, E = r; (E += w[0].length) < k; w = w[1], o++) ;
+              d = e.slice(r, E), i.index -= r;
+            }
+          }
+          if (i && i[0]) {
+            for (var S = i.index, x = i[0], T = d.slice(S + x.length), N = r + d.length, P = new ue(u, p ? ke(x, p) : x, x, g), M = a, V = 0, z; M = M[1], V++ < o; ) ;
+            T && (!M || M[0] instanceof ue ? M = [T, M] : M[0] = T + M[0]), r += S, a[0] = S ? d.slice(0, S) : P, S ? a = a[1] = [P, M] : a[1] = M, o && (xn(e, t, a, r, z = [u, f, N]), N = z[2]), l && N > l[2] && (l[2] = N);
+          }
+        }
+      }
+    }
+};
+function ue(e, t, n, s) {
+  this.type = e, this.content = t, this.alias = s, this.length = n.length;
+}
+const pa = (e, t, ...n) => {
+  var Y;
+  let s, l, u = [], f, E = "", y, v = !1, m = !1, p = !0, c = [], b, g = 0;
+  const a = fa(), r = a.firstChild, d = r.children, o = d[0], i = o.firstChild, h = { language: "text", value: E }, k = new Set(n), I = {}, w = (A) => {
+    if (Object.assign(h, A), E = A.value ?? E, s = h.language, !_[s]) throw Error(`Language '${s}' has no grammar.`);
+    b = !!h.readOnly, a.style.tabSize = h.tabSize || 2, i.inputMode = b ? "none" : "", i.setAttribute("aria-readonly", b), T(), x(), (l != (l = _[s]) || E != i.value) && (V(), i.value = E, i.selectionEnd = 0, S());
+  }, S = () => {
+    c = ke(E = i.value, l), z("tokenize", c, s, E);
+    let A = Sn(c).split(`
+`), R = 0, L = g, Z = g = A.length;
+    for (; A[R] == u[R] && R < Z; ) ++R;
+    for (; Z && A[--Z] == u[--L]; ) ;
+    if (R == Z && R == L) d[R + 1].innerHTML = A[R] + `
+`;
+    else {
+      let X = L < R ? L : R - 1, K = X, _e = "";
+      for (; K < Z; ) _e += `<div class=pce-line aria-hidden=true>${A[++K]}
+</div>`;
+      for (K = Z < R ? Z : R - 1; K < L; K++) d[R + 1].remove();
+      for (_e && d[X + 1].insertAdjacentHTML("afterend", _e), K = X + 1; K < g; ) d[++K].setAttribute("data-line", K);
+      a.style.setProperty(
+        "--number-width",
+        Math.ceil(Math.log10(g + 1)) + ".001ch"
+      );
+    }
+    z("update", E), U(!0), p && setTimeout(setTimeout, 0, () => p = !0), u = A, p = !1;
+  }, x = (A) => {
+    (A || k).forEach((R) => {
+      typeof R == "object" ? (R.update(D, h), A && k.add(R)) : (R(D, h), A || k.delete(R));
+    });
+  }, T = ([A, R] = N()) => {
+    a.className = `prism-code-editor language-${s}${h.lineNumbers == !1 ? "" : " show-line-numbers"} pce-${h.wordWrap ? "" : "no"}wrap${h.rtl ? " pce-rtl" : ""} pce-${A < R ? "has" : "no"}-selection${m ? " pce-focus" : ""}${b ? " pce-readonly" : ""}`;
+  }, N = () => [
+    i.selectionStart,
+    i.selectionEnd,
+    i.selectionDirection
+  ], P = {
+    Escape() {
+      i.blur();
+    }
+  }, M = {}, V = () => $e && !m && G(
+    D,
+    "focus",
+    (A) => {
+      let R = A.relatedTarget;
+      R ? R.focus() : i.blur();
+    },
+    { once: !0 }
+  ), z = (A, ...R) => {
+    var L, Z;
+    (L = I[A]) == null || L.forEach((X) => X.apply(D, R)), (Z = h["on" + A[0].toUpperCase() + A.slice(1)]) == null || Z.apply(D, R);
+  }, U = (A) => {
+    if (A || p) {
+      const R = N(), L = d[y = Nn(E, 0, R[R[2] < "f" ? 0 : 1])];
+      L != f && (f == null || f.classList.remove("active-line"), L.classList.add("active-line"), f = L), T(R), z("selectionChange", R, E);
+    }
+  }, D = {
+    scrollContainer: a,
+    wrapper: r,
+    overlays: o,
+    textarea: i,
+    get activeLine() {
+      return f;
+    },
+    get activeLineNumber() {
+      return y;
+    },
+    get value() {
+      return E;
+    },
+    options: h,
+    get focused() {
+      return m;
+    },
+    get removed() {
+      return v;
+    },
+    get tokens() {
+      return c;
+    },
+    inputCommandMap: M,
+    keyCommandMap: P,
+    extensions: {},
+    setOptions: w,
+    update: S,
+    getSelection: N,
+    setSelection(A, R = A, L) {
+      V(), i.setSelectionRange(A, R, L), U(!0);
+    },
+    addExtensions(...A) {
+      x(A);
+    },
+    addListener(A, R) {
+      (I[A] || (I[A] = /* @__PURE__ */ new Set())).add(R);
+    },
+    removeListener(A, R) {
+      var L;
+      (L = I[A]) == null || L.delete(R);
+    },
+    remove() {
+      a.remove(), v = !0;
+    }
+  };
+  return G(D, "keydown", (A) => {
+    var R;
+    (R = P[A.key]) != null && R.call(P, A, N(), E) && B(A);
+  }), G(D, "beforeinput", (A) => {
+    var R;
+    (b || A.inputType == "insertText" && ((R = M[A.data]) != null && R.call(M, A, N(), E))) && B(A);
+  }), G(D, "input", S), G(D, "blur", () => {
+    Re = null, m = !1, T();
+  }), G(D, "focus", () => {
+    Re = U, m = !0, T();
+  }), G(D, "selectionchange", (A) => {
+    U(), B(A);
+  }), (Y = ba(e)) == null || Y.append(a), t && w(t), D;
+}, Ht = /* @__PURE__ */ document.createElement("div"), Ye = (e) => {
+  Ht.innerHTML = e;
+  const t = Ht.firstChild;
+  return () => t.cloneNode(!0);
+}, G = (e, t, n, s) => e.textarea.addEventListener(t, n, s), ba = (e) => typeof e == "string" ? document.querySelector(e) : e, On = navigator.userAgent, Ge = /Mac|iPhone|iPod|iPad/i.test(navigator.platform), ze = /Chrome\//.test(On), $e = !ze && /AppleWebKit\//.test(On), Nn = (e, t = 0, n = 1 / 0) => {
+  let s = 1;
+  for (; (t = e.indexOf(`
+`, t) + 1) && t <= n; s++) ;
+  return s;
+}, at = {}, fa = /* @__PURE__ */ Ye(
+  "<div><div class=pce-wrapper><div class=pce-overlays><textarea spellcheck=false autocapitalize=off autocomplete=off>"
+), B = (e) => {
+  e.preventDefault(), e.stopImmediatePropagation();
+};
+let Re;
+document.addEventListener("selectionchange", () => Re == null ? void 0 : Re());
+const ga = (e, t, n = 0) => {
+  const s = e.scrollContainer.style, l = document.documentElement.style;
+  s.scrollPaddingBlock = l.scrollPaddingBlock = `${n}px ${ze && !t.textContent ? t.offsetHeight : 0}px`, t.scrollIntoView({ block: "nearest" }), s.scrollPaddingBlock = l.scrollPaddingBlock = "";
+}, He = (e, t) => t ? e.lastIndexOf(`
+`, t - 1) + 1 : 0, Xe = (e, t) => (t = e.indexOf(`
+`, t)) + 1 ? t : e.length, ma = (e, t, n) => (e.addListener(t, n), () => e.removeListener(t, n)), ha = (e, t) => parseFloat(getComputedStyle(e)[t]);
+let pe;
+const ve = (e) => e.replace(/[$+?|.^*()[\]{}\\]/g, "\\$&"), pt = (e, t) => e.slice(He(e, t), t), ee = (e, t, n = t) => [
+  e.slice(t = He(e, t), n = Xe(e, n)).split(`
+`),
+  t,
+  n
+], Ve = (e, t, n = 0, s = n, l = e.getSelection()[0]) => {
+  var m;
+  const u = e.value, f = e.wrapper.children[Nn(u, 0, l)], E = document.createTreeWalker(f, 5);
+  let y = E.lastChild(), v = Xe(u, l) + 1 - l - y.length;
+  for (; -v <= s && (y = E.previousNode()); )
+    if (!y.lastChild && (v -= y.length || 0, v <= n)) {
+      for (; y != f; y = y.parentNode)
+        if ((m = y.matches) != null && m.call(y, t)) return y;
+    }
+}, rt = (e, t) => {
+  var n;
+  return ((n = Ve(e, '[class*="language-"]', 0, 0, t)) == null ? void 0 : n.className.match(
+    /language-(\S*)/
+  )[1]) || e.options.language;
+}, H = (e, t, n, s, l, u) => {
+  if (e.options.readOnly) return;
+  pe = e.getSelection(), s ?? (s = n);
+  let f = e.textarea, E = e.value, y = ze && !E[s ?? pe[1]] && /\n$/.test(t) && /^$|\n$/.test(E), v;
+  e.focused || f.focus(), n != null && f.setSelectionRange(n, s), l != null && (v = ma(e, "update", () => {
+    f.setSelectionRange(
+      l,
+      u ?? l,
+      pe[2]
+    ), v();
+  })), $e || f.dispatchEvent(new InputEvent("beforeinput", { data: t })), ze || $e ? (y && (f.selectionEnd--, t = t.slice(0, -1)), $e && (t += `
+`), document.execCommand(
+    t ? "insertHTML" : "delete",
+    !1,
+    t.replace(/&/g, "&amp;").replace(/</g, "&lt;")
+  ), y && f.selectionStart++) : document.execCommand(t ? "insertText" : "delete", !1, t), pe = 0;
+}, Ae = (e) => e.altKey + e.ctrlKey * 2 + e.metaKey * 4 + e.shiftKey * 8;
+let bt = !1;
+const Vt = navigator.clipboard, oe = Ge ? 4 : 2, _a = (e) => bt = e, ie = (e) => e.search(/\S|$/), Ea = (e = ['""', "''", "``", "()", "[]", "{}"], t = /([^$\w'"`]["'`]|.[[({])[.,:;\])}>\s]|.[[({]`/s) => (n, s) => {
+  let l;
+  const { keyCommandMap: u, inputCommandMap: f, getSelection: E, scrollContainer: y } = n, v = ({ insertSpaces: a = !0, tabSize: r } = s) => [a ? " " : "	", a ? r || 2 : 1], m = () => {
+    var a;
+    return !s.readOnly && !((a = n.extensions.cursor) != null && a.scrollIntoView());
+  }, p = ([a, r], [d, o], i, h) => (a < r || !h && t.test((i[r - 1] || " ") + d + (i[r] || " "))) && !H(n, d + i.slice(a, r) + o, null, null, a + 1, r + 1), c = ([a, r], d, o) => a == r && o[r] == d && !n.setSelection(a + 1), b = (a, r, d, o, i, h) => {
+    let k = r.join(`
+`);
+    if (k != a.join(`
+`)) {
+      const I = a.length - 1, w = r[I], S = a[I], x = S.length - w.length, T = r[0].length - a[0].length, N = d + ie((T < 0 ? r : a)[0]), P = o - S.length + ie(x > 0 ? w : S), M = d - o + k.length + x, V = N > i ? i : Math.max(N, i + T), z = h + d - o + k.length;
+      H(
+        n,
+        k,
+        d,
+        o,
+        V,
+        h < P ? z + x : Math.max(P + M, z)
+      );
+    }
+  }, g = (a, r, d, o, i, h, k, I) => {
+    b(
+      r,
+      r.map(
+        a ? (w) => w.slice(ie(w) ? I - ie(w) % I : 0) : (w) => w && k.repeat(I - ie(w) % I) + w
+      ),
+      d,
+      o,
+      i,
+      h
+    );
+  };
+  f["<"] = (a, r, d) => p(r, "<>", d, !0), e.forEach(([a, r]) => {
+    const d = a == r;
+    f[a] = (o, i, h) => (d && c(i, r, h) || p(i, a + r, h)) && m(), d || (f[r] = (o, i, h) => c(i, r, h) && m());
+  }), f[">"] = (a, r, d) => {
+    var i, h;
+    const o = (h = (i = at[rt(n)]) == null ? void 0 : i.autoCloseTags) == null ? void 0 : h.call(i, r, d, n);
+    o && (H(n, ">" + o, null, null, r[0] + 1), B(a));
+  }, u.Tab = (a, [r, d], o) => {
+    if (bt || s.readOnly || Ae(a) & 6) return;
+    const [i, h] = v(s), k = a.shiftKey, [I, w, S] = ee(o, r, d);
+    return r < d || k ? g(k, I, w, S, r, d, i, h) : H(n, i.repeat(h - (r - w) % h)), m();
+  }, u.Enter = (a, r, d) => {
+    var i, h, k;
+    const o = Ae(a) & 7;
+    if (!o || o == oe) {
+      o && (r[0] = r[1] = ee(d, r[1])[2]);
+      const [I, w] = v(), [S, x] = r, T = (i = at[rt(n)]) == null ? void 0 : i.autoIndent, N = Math.floor(ie(pt(d, S)) / w) * w, P = (h = T == null ? void 0 : T[0]) != null && h.call(T, r, d, n) ? w : 0, M = (k = T == null ? void 0 : T[1]) == null ? void 0 : k.call(T, r, d, n), V = `
+` + I.repeat(N + P) + (M ? `
+` + I.repeat(N) : "");
+      if (V[1] || d[x])
+        return H(n, V, S, x, S + N + P + 1), m();
+    }
+  }, u.Backspace = (a, [r, d], o) => {
+    if (r == d) {
+      const i = pt(o, r), h = s.tabSize || 2, k = e.includes(o.slice(r - 1, r + 1)), I = /[^ ]/.test(i) ? 0 : (i.length - 1) % h + 1;
+      if (k || I > 1)
+        return H(n, "", r - (k ? 1 : I), r + k), m();
+    }
+  };
+  for (let a = 0; a < 2; a++)
+    u[a ? "ArrowDown" : "ArrowUp"] = (r, [d, o], i) => {
+      const h = Ae(r);
+      if (h == 1) {
+        const k = a ? d : He(i, d) - 1, I = a ? i.indexOf(`
+`, o) + 1 : o;
+        if (k > -1 && I > 0) {
+          const [w, S, x] = ee(i, k, I), T = w[a ? "pop" : "shift"](), N = (T.length + 1) * (a ? 1 : -1);
+          w[a ? "unshift" : "push"](T), H(n, w.join(`
+`), S, x, d + N, o + N);
+        }
+        return m();
+      } else if (h == 9) {
+        const [k, I, w] = ee(i, d, o), S = k.join(`
+`), x = a ? S.length + 1 : 0;
+        return H(n, S + `
+` + S, I, w, d + x, o + x), m();
+      } else if (h == 2 && !Ge)
+        return y.scrollBy(0, ha(y, "lineHeight") * (a ? 1 : -1)), !0;
+    };
+  G(n, "keydown", (a) => {
+    var k;
+    const r = Ae(a), d = a.keyCode, [o, i, h] = E();
+    if (r == oe && (d == 221 || d == 219))
+      g(d == 219, ...ee(n.value, o, i), o, i, ...v()), m(), B(a);
+    else if (r == (Ge ? 10 : 2) && d == 77)
+      _a(!bt), B(a);
+    else if (d == 191 && r == oe || d == 65 && r == 9) {
+      const I = n.value, w = r == 9, S = w ? o : He(I, o), x = at[rt(n, S)] || {}, { line: T, block: N } = ((k = x.getComments) == null ? void 0 : k.call(x, n, S, I)) || x.comments || {}, [P, M, V] = ee(I, o, i), z = P.length - 1;
+      if (w) {
+        if (N) {
+          const [U, D] = N, Y = I.slice(o, i), A = I.slice(0, o).search(ve(U) + " ?$"), R = RegExp("^ ?" + ve(D)).test(I.slice(i));
+          A + 1 && R ? H(
+            n,
+            Y,
+            A,
+            i + +(I[i] == " ") + D.length,
+            A,
+            A + i - o
+          ) : H(
+            n,
+            `${U} ${Y} ${D}`,
+            o,
+            i,
+            o + U.length + 1,
+            i + U.length + 1
+          ), m(), B(a);
+        }
+      } else if (T) {
+        const U = ve(T), D = RegExp(`^\\s*(${U} ?|$)`), Y = RegExp(U + " ?"), A = !/\S/.test(I.slice(M, V)), R = P.map(
+          P.every((L) => D.test(L)) && !A ? (L) => L.replace(Y, "") : (L) => A || /\S/.test(L) ? L.replace(/^\s*/, `$&${T} `) : L
+        );
+        b(P, R, M, V, o, i), m(), B(a);
+      } else if (N) {
+        const [U, D] = N, Y = ie(P[0]), A = P[0].startsWith(U, Y) && P[z].endsWith(D), R = P.slice();
+        R[0] = P[0].replace(
+          A ? RegExp(ve(U) + " ?") : /(?=\S)|$/,
+          A ? "" : U + " "
+        );
+        let L = R[0].length - P[0].length;
+        R[z] = A ? R[z].replace(RegExp(`( ?${ve(D)})?$`), "") : R[z] + " " + D;
+        let Z = R.join(`
+`), X = Y + M, K = X > o ? o : Math.max(o + L, X), _e = X > i - (o != i) ? i : Math.min(Math.max(X, i + L), M + Z.length);
+        H(n, Z, M, V, K, Math.max(K, _e)), m(), B(a);
+      }
+    } else if (r == 8 + oe && d == 75) {
+      const I = n.value, [w, S, x] = ee(I, o, i), T = h > "f" ? i - x + w.pop().length : o - S, N = Xe(I, x + 1) - x - 1;
+      H(
+        n,
+        "",
+        S - !!S,
+        x + !S,
+        S + Math.min(T, N)
+      ), m(), B(a);
+    }
+  }), ["copy", "cut", "paste"].forEach(
+    (a) => G(n, a, (r) => {
+      const [d, o] = E();
+      if (d == o && Vt) {
+        const [[i], h, k] = ee(n.value, d, o);
+        a == "paste" ? r.clipboardData.getData("text/plain") == l && (H(n, l + `
+`, h, h, d + l.length + 1), m(), B(r)) : (Vt.writeText(l = i), a == "cut" && (H(n, "", h, k + 1), m()), B(r));
+      }
+    })
+  );
+}, ya = (e = 999) => {
+  let t = 0, n, s, l = !1, u, f, E, y, v, m;
+  const p = [], c = (a) => {
+    a >= e && (a--, p.shift()), p.splice(t = a, e, [n.value, m(), m()]);
+  }, b = (a) => {
+    var r;
+    p[a] && (v.value = p[a][0], v.setSelectionRange(...p[a][a < t ? 2 : 1]), n.update(), (r = n.extensions.cursor) == null || r.scrollIntoView(), t = a, s = !1);
+  }, g = (a, r) => {
+    a.extensions.history = g, n = a, m = a.getSelection, v || c(0), v = a.textarea, a.addListener("selectionChange", () => {
+      s = l, l = !1;
+    }), G(a, "beforeinput", (d) => {
+      let o = d.data, i = d.inputType, h = d.timeStamp;
+      /history/.test(i) ? (b(t + (i[7] == "U" ? -1 : 1)), B(d)) : (y = s && (u == i || h - E < 99 && i.slice(-4) == "Drop") && !pe && (o != " " || f == o)) || (p[t][2] = pe || m()), l = !0, f = o, E = h, u = i;
+    }), G(a, "input", () => c(t + !y)), G(a, "keydown", (d) => {
+      if (!r.readOnly) {
+        const o = Ae(d), i = d.keyCode, h = o == oe && i == 90, k = o == oe + 8 && i == 90 || !Ge && o == oe && i == 89;
+        h ? (b(t - 1), B(d)) : k && (b(t + 1), B(d));
+      }
+    });
+  };
+  return g.clear = () => {
+    c(0), s = !1;
+  }, g.has = (a) => t + a in p, g.go = (a) => b(t + a), g;
+}, va = Ye(
+  "<div style=position:absolute;top:0;opacity:0;padding:inherit> <span><span></span> "
+), wa = () => {
+  let e, t = " ", n = " ";
+  const s = va(), [l, u] = s.childNodes, [f, E] = u.childNodes, y = (p) => {
+    let { value: c, activeLine: b } = e, g = p[p[2] < "f" ? 0 : 1], a = pt(c, g), r = c.slice(g, Xe(c, g));
+    !a && !r && (r = " "), t != a && (l.data = t = a), n != r && (E.data = n = r), s.parentNode != b && b.prepend(s);
+  }, v = () => ga(e, f), m = (p) => {
+    p.addListener("selectionChange", y), e = p, p.extensions.cursor = m, G(p, "input", (c) => {
+      /history/.test(c.inputType) && v();
+    }), p.activeLine && y(p.getSelection());
+  };
+  return m.getPosition = () => {
+    const p = f.getBoundingClientRect(), c = e.overlays.getBoundingClientRect();
+    return {
+      top: p.y - c.y,
+      bottom: c.bottom - p.bottom,
+      left: p.x - c.x,
+      right: c.right - p.x,
+      height: p.height
+    };
+  }, m.scrollIntoView = v, m.element = f, m;
+}, Aa = Ye(
+  "<div class=guide-indents style=left:var(--padding-left);bottom:auto;right:auto> "
+), Ia = Ye(
+  "<div style=width:1px;position:absolute;background:var(--bg-guide-indent)>"
+), Ra = () => {
+  let e, t = 0, n, s = -1, l;
+  const u = [], f = [], E = Aa(), y = [], v = (b) => {
+    n = [];
+    const g = p(b.split(`
+`)), a = g.length;
+    for (let r = 0, d = [], o = g[0]; o; r++) {
+      const i = (u[r] || (u[r] = Ia())).style, [h, k, I] = o, w = f[r];
+      o = g[r + 1], h != (w == null ? void 0 : w[0]) && (i.top = h + "00%"), k != (w == null ? void 0 : w[1]) && (i.height = k + "00%"), I != (w == null ? void 0 : w[2]) && (i.left = I * 100 + "%");
+      const S = d[0] != h && (o == null ? void 0 : o[0]) != h, x = d[0] + d[1] != h + k && (o == null ? void 0 : o[0]) + (o == null ? void 0 : o[1]) != h + k;
+      for (let T = -S, N = k + x; T < N; T++)
+        n[T + h] = r;
+      d = f[r] = g[r];
+    }
+    for (let r = t; r > a; ) u[--r].remove();
+    E.append(...u.slice(t, t = a));
+  }, m = () => {
+    const b = n[l.activeLineNumber - 1] ?? -1;
+    b != s && (s > -1 && (u[s].className = ""), b > -1 && (u[b].className = "active")), s = b;
+  }, p = (b) => {
+    const g = b.length, a = [], r = [];
+    for (let d = 0, o = -1, i = 0, h = 0; ; i++) {
+      const k = i == g, I = k ? 0 : y[i] = c(b[i]);
+      if (I < 0)
+        o < 0 && (o = i);
+      else {
+        for (let w = I; w < d; w++)
+          a[w][1] = (o < 0 || w == I && !k ? i : o) - a[w][0];
+        for (let w = d; w < I; )
+          r[h++] = a[w] = [
+            o < 0 || w > d ? i : o,
+            0,
+            w++ * e
+          ];
+        o = -1, d = I;
+      }
+      if (k) break;
+    }
+    return y.length = g, r;
+  }, c = (b) => {
+    let g = b.search(/\S/), a = 0;
+    if (g < 0) return g;
+    for (let r = 0; r < g; )
+      a += b[r++] == "	" ? e - a % e : 1;
+    return Math.ceil(a / e);
+  };
+  return {
+    lines: E.children,
+    indentLevels: y,
+    update(b, g) {
+      l || (l = b, b.extensions.indentGuides = this, b.overlays.append(E), b.addListener("update", v), b.addListener("selectionChange", m)), E.style.display = g.wordWrap ? "none" : "", e != (e = g.tabSize || 2) && (v(b.value), m());
+    }
+  };
+}, ka = () => (e) => {
+  let t, n, s, l = -1, u = [], f = () => {
+    n || (n = e.extensions.matchBrackets);
+    let [v, m] = e.getSelection(), p = v == m && e.focused && n && E(m) || -1;
+    if (p != l) {
+      if (y(), p + 1) {
+        let c = t[s[p]], b = t[p];
+        u = [c, b].map(
+          (g) => Ve(e, ".punctuation", 0, -1, g[1])
+        ), u[0] != u[1] && c[1] + c[3].length == b[1] && (u[0].textContent += u[1].textContent, u[1].textContent = "", u[1] = u[0]), y(!0);
+      } else u = [];
+      l = p;
+    }
+  }, E = (v) => {
+    var m;
+    ({ brackets: t, pairs: s } = n);
+    for (let p = 0, c; c = t[++p]; )
+      if (!c[4] && c[5] >= v && ((m = t[s[p]]) == null ? void 0 : m[1]) <= v)
+        return p;
+  }, y = (v) => u.forEach((m) => m.classList.toggle("active-bracket", !!v));
+  G(e, "focus", f), G(e, "blur", f), e.addListener("selectionChange", f), e.addListener("update", () => {
+    y(), l = -1;
+  });
+}, Sa = (e = !0, t = "([{", n = ")]}") => {
+  let s, l;
+  const u = [], f = (p) => {
+    p.extensions.matchBrackets = f, p.addListener("tokenize", v), e && p.tokens[0] ? p.update() : v(p.tokens);
+  }, E = f.brackets = [], y = f.pairs = [], v = (p) => {
+    if (y.length = E.length = l = s = 0, m(p, 0), e)
+      for (let c = 0, b; b = E[c]; ) {
+        let g = b[0].alias;
+        b[0].alias = (g ? g + " " : "") + `bracket-${c++ in y ? "level-" + b[2] % 12 : "error"}`;
+      }
+  }, m = (p, c) => {
+    let b, g = 0;
+    for (; b = p[g++]; ) {
+      let a = b.length;
+      if (typeof b != "string") {
+        let r = b.content;
+        if (Array.isArray(r))
+          m(r, c);
+        else if ((b.alias || b.type) == "punctuation") {
+          let d = Zt(r, t, a - 1), o = d || Zt(r, n, a - 1);
+          if (o) {
+            if (E[s] = [b, c, 0, r, !!d, c + a], d) u[l++] = [s, d];
+            else
+              for (let i = l; i; ) {
+                let [h, k] = u[--i];
+                o == k && (y[y[s] = h] = s, E[s][2] = E[h][2] = l = i, i = 0);
+              }
+            s++;
+          }
+        }
+      }
+      c += a;
+    }
+  };
+  return f;
+}, Zt = (e, t, n) => t.indexOf(e[0]) + 1 || n && t.indexOf(e[n]) + 1, Ta = "xml,rss,atom,jsx,tsx,xquery,actionscript".split(","), xa = /^(?:area|base|w?br|col|embed|hr|img|input|link|meta|source|track)$/i, Oa = (e) => {
+  let t = [], n, s = [], l, u, f = [], E = (v, m, p) => {
+    n = p, s.length = t.length = l = u = 0, y(v, m, 0);
+  }, y = (v, m, p) => {
+    let c = Ta.includes(m), b = 0, g = v.length;
+    for (; b < g; ) {
+      const a = v[b++], r = a.content, d = a.length;
+      if (Array.isArray(r))
+        if (a.type == "tag" && n[p] == "<") {
+          const o = r[0].length, i = r[2] ? n.substr(p + o, r[1].length) : "", h = r[r.length - 1].length < 2 && (c || !xa.test(i));
+          if (r[2] && c && y(r, m, p), h)
+            if (o > 1)
+              for (let k = u; k; )
+                i == f[--k][1] && (t[t[l] = f[u = k][0]] = l, k = 0);
+            else
+              f[u++] = [l, i];
+          s[l++] = [
+            a,
+            p,
+            p + d,
+            i,
+            o > 1,
+            h
+          ];
+        } else {
+          let o = a.alias || a.type;
+          y(
+            r,
+            o.slice(0, 9) == "language-" ? o.slice(9) : m,
+            p
+          );
+        }
+      p += d;
+    }
+  };
+  return e.addListener("tokenize", E), E(e.tokens, e.options.language, e.value), {
+    tags: s,
+    pairs: t
+  };
+}, Na = (e, t) => {
+  for (let n = 0, s = t.length; n < s; n++) if (t[n][1] <= e && t[n][2] >= e) return n;
+}, La = () => (e) => {
+  var t;
+  let n, s;
+  const { tags: l, pairs: u } = (t = e.extensions).matchTags || (t.matchTags = Oa(e)), f = (E) => [n, s].forEach((y) => {
+    y && y.classList.toggle("active-tagname", !E);
+  });
+  e.addListener("selectionChange", ([E, y]) => {
+    let v, m, p;
+    E == y && e.focused && (p = Na(E, l), p + 1 && (p = u[p], p + 1 && (v = Ve(e, ".tag>.tag")) && (m = Ve(e, ".tag>.tag", 2, 0, l[p][1])))), n != v && (f(!0), n = v, s = m, f());
+  });
+};
+var Ze = "\\b(?:BASH(?:OPTS|_ALIASES|_ARG[CV]|_CMDS|_COMPLETION_COMPAT_DIR|_LINENO|_REMATCH|_SOURCE|_VERSINFO|_VERSION)?|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|E?UID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_(?:ADDRESS|ALL|IDENTIFICATION|MEASUREMENT|MONETARY|NAME|NUMERIC|PAPER|TELEPHONE|TIME)|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS[1-4]|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_(?:CONFIG_DIRS|CURRENT_DESKTOP|DATA_DIRS|GREETER_DATA_DIR|MENU_PREFIX|RUNTIME_DIR|SEAT|SEAT_PATH|SESSION_DESKTOP|SESSION_ID|SESSION_PATH|SESSION_TYPE|VTNR)|XMODIFIERS)\\b", ft = {
+  pattern: /(^(["']?)\w+\2)[ 	]+\S.*/,
+  lookbehind: !0,
+  alias: "punctuation"
+  // this looks reasonably well in all themes
+}, Ln = {
+  variable: /^\$\(|^`|\)$|`$/
+}, Ne = {
+  bash: ft,
+  environment: {
+    pattern: RegExp("\\$" + Ze),
+    alias: "constant"
+  },
+  variable: [
+    // [0]: Arithmetic Environment
+    {
+      pattern: /\$?\(\([^]*?\)\)/g,
+      greedy: !0,
+      inside: {
+        // If there is a $ sign at the beginning highlight $(( and )) as variable
+        variable: [
+          {
+            pattern: /(^\$[^]+)../,
+            lookbehind: !0
+          },
+          /^\$\(\(/
+        ],
+        number: /\b0x[a-fA-F\d]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+        // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
+        operator: /--|\+\+|&&|\|\||(?:\*\*|<<|>>|[%&|^!=<>/*+-])=?|[?:~]/,
+        // If there is no $ sign at the beginning highlight (( and )) as punctuation
+        punctuation: /\(\(?|\)\)?|,|;/
+      }
+    },
+    // [1]: Command Substitution
+    {
+      pattern: /\$\((?:[^()]|\([^)]*\))*\)|`[^`]+`/g,
+      greedy: !0,
+      inside: Ln
+    },
+    // [2]: Brace expansion
+    {
+      pattern: /\$\{[^}]*\}/g,
+      greedy: !0,
+      inside: {
+        operator: /:[?=+-]?|[!/]|##?|%%?|\^\^?|,,?/,
+        punctuation: /[[\]]/,
+        environment: {
+          pattern: RegExp("(\\{)" + Ze),
+          lookbehind: !0,
+          alias: "constant"
+        }
+      }
+    },
+    /\$(?:\w+|[#?*!@$])/
+  ],
+  // Escape sequences from echo and printf's manuals, and escaped quotes.
+  entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[a-fA-F\d]{8}|u[a-fA-F\d]{4}|x[a-fA-F\d]{1,2})/
+}, Ca = ft.inside = _.sh = _.shell = _.bash = {
+  shebang: {
+    pattern: /^#!\s*\/.*/,
+    alias: "important"
+  },
+  comment: {
+    pattern: /(^|[^"{\\$])#.*/,
+    lookbehind: !0
+  },
+  "function-name": [
+    // a) function foo {
+    // b) foo() {
+    // c) function foo() {
+    // but not “foo {”
+    {
+      // a) and c)
+      pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
+      lookbehind: !0,
+      alias: "function"
+    },
+    {
+      // b)
+      pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
+      alias: "function"
+    }
+  ],
+  // Highlight variable names as variables in for and select beginnings.
+  "for-or-select": {
+    pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
+    lookbehind: !0,
+    alias: "variable"
+  },
+  // Highlight variable names as variables in the left-hand part
+  // of assignments (“=” and “+=”).
+  "assign-left": {
+    pattern: /(^|[\s;|&]|[<>]\()\w+(?:\.\w+)*(?=\+?=)/,
+    lookbehind: !0,
+    alias: "variable",
+    inside: {
+      environment: {
+        pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + Ze),
+        lookbehind: !0,
+        alias: "constant"
+      }
+    }
+  },
+  // Highlight parameter names as variables
+  parameter: {
+    pattern: /(^|\s)-{1,2}(?:\w+:[+-]?)?\w+(?:\.\w+)*(?![^\s=])/,
+    lookbehind: !0,
+    alias: "variable"
+  },
+  string: [
+    // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
+    {
+      pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[^]*?\n\2/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: Ne
+    },
+    // Here-document with quotes around the tag
+    // → No expansion (so no “inside”).
+    {
+      pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[^]*?\n\3/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        bash: ft
+      }
+    },
+    // “Normal” string
+    {
+      // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
+      pattern: /(^|[^\\](?:\\\\)*)"(?:\\[^]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^\\"`$])*"/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: Ne
+    },
+    {
+      // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
+      pattern: /(^|[^$\\])'[^']*'/g,
+      lookbehind: !0,
+      greedy: !0
+    },
+    {
+      // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
+      pattern: /\$'(?:\\[^]|[^\\'])*'/g,
+      greedy: !0,
+      inside: {
+        entity: Ne.entity
+      }
+    }
+  ],
+  environment: {
+    pattern: RegExp("\\$?" + Ze),
+    alias: "constant"
+  },
+  variable: Ne.variable,
+  function: {
+    pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|basename|bash|bc|bconsole|bg|bzip2|cal|cargo|cat|c?fdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cron|crontab|c?split|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff3?|dig|dircolors|dirname|dirs?|dmesg|docker|docker-compose|du|[ef]?grep|eject|env|ethtool|expand|expect|expr|fdformat|fg|file|find|fmt|fold|format|free|fsck|fuser|g?awk|git|g?parted|groupadd|groupdel|groupmod|groups|grub-mkconfig|halt|head|hg|history|host|hostname|iconv|id|ifconfig|ifdown|ifup|import|install|ip|java|jobs|join|killall|less|link|ln|logname|logrotate|look|lpc|lprint[dq]?|lprm?|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mm?v|more|most|mtools|m?tr|mutt|nano|nc|netstat|nice|nl|node|nohup|notify-send|nslookup|op|open|passwd|paste|pathchk|ping|p?kill|p?npm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ra[mr]|reboot|remsync|rename|renice|rev|rmdir|rp?m|r?sync|[sr]?cp|screen|sdiff|se[dq]|sendmail|service|s?ftp|shellcheck|shuf|shutdown|sleep|s?locate|[sz]?sh|stat|strace|sudo|sum?|suspend|swapon|sysctl|tac|tail|tar|tee|time|timeout|h?top|touch|traceroute|t?sort|tty|u?mount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vim?|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|g?zip|zsh|zypper)(?=$|[)\s;|&])/,
+    lookbehind: !0
+  },
+  keyword: {
+    pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
+    lookbehind: !0
+  },
+  // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
+  builtin: {
+    pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|[ls]et|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
+    lookbehind: !0,
+    // Alias added to make those easier to distinguish from strings.
+    alias: "class-name"
+  },
+  boolean: {
+    pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
+    lookbehind: !0
+  },
+  "file-descriptor": {
+    pattern: /\B&\d\b/,
+    alias: "important"
+  },
+  operator: {
+    // Lots of redirections here, but not just that.
+    pattern: /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
+    inside: {
+      "file-descriptor": {
+        pattern: /^\d/,
+        alias: "important"
+      }
+    }
+  },
+  punctuation: /\$?\(\(?|\)\)?|\.\.|[[\]{};\\]/,
+  number: {
+    pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
+    lookbehind: !0
+  }
+};
+[
+  "comment",
+  "function-name",
+  "for-or-select",
+  "assign-left",
+  "parameter",
+  "string",
+  "environment",
+  "function",
+  "keyword",
+  "builtin",
+  "boolean",
+  "file-descriptor",
+  "operator",
+  "punctuation",
+  "number"
+].forEach((e) => Ln[e] = Ca[e]);
+var Cn = /(?:"(?:\\[^]|[^\\\n"])*"|'(?:\\[^]|[^\\\n'])*')/g, Le = Cn.source, qt = {
+  rule: /^@[\w-]+/,
+  "selector-function-argument": {
+    pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^)]*\))*\))+(?=\s*\))/,
+    lookbehind: !0,
+    alias: "selector"
+  },
+  keyword: {
+    pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+    lookbehind: !0
+  }
+  // See rest below
+};
+qt[j] = _.css = {
+  comment: /\/\*[^]*?\*\//,
+  atrule: {
+    pattern: RegExp(`@[\\w-](?:[^;{\\s"']|\\s+(?!\\s)|${Le})*?(?:;|(?=\\s*\\{))`),
+    inside: qt
+  },
+  url: {
+    // https://drafts.csswg.org/css-values-3/#urls
+    pattern: RegExp(`\\burl\\((?:${Le}|(?:[^\\\\
+"')=]|\\\\[^])*)\\)`, "gi"),
+    greedy: !0,
+    inside: {
+      function: /^url/i,
+      punctuation: /^\(|\)$/,
+      string: {
+        pattern: RegExp("^" + Le + "$"),
+        alias: "url"
+      }
+    }
+  },
+  selector: {
+    pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|${Le})*(?=\\s*\\{)`),
+    lookbehind: !0
+  },
+  string: {
+    pattern: Cn,
+    greedy: !0
+  },
+  property: {
+    pattern: /(^|[^-\w\xa0-\uffff])(?!\d)(?:(?!\s)[-\w\xa0-\uffff])+(?=\s*:)/i,
+    lookbehind: !0
+  },
+  important: /!important\b/i,
+  function: {
+    pattern: /(^|[^-a-z\d])[-a-z\d]+(?=\()/i,
+    lookbehind: !0
+  },
+  punctuation: /[(){},:;]/
+};
+var De = (e, t) => {
+  if (t.has(e)) return t.get(e);
+  var n = e, s = Ma.call(e).slice(8, -1);
+  if (s == "Object") {
+    t.set(e, n = {});
+    for (var l in e)
+      n[l] = De(e[l], t);
+    e[j] && (n[j] = De(e[j], t)), e[J] && (n[J] = e[J]);
+  } else if (s == "Array") {
+    t.set(e, n = []);
+    for (var u = 0, f = e.length; u < f; u++)
+      n[u] = De(e[u], t);
+  }
+  return n;
+}, Qe = (e) => De(e, /* @__PURE__ */ new Map()), ae = (e, t) => Object.assign(Qe(_[e]), t), $ = (e, t, n) => {
+  var s = {};
+  for (var l in e)
+    s[l] = e[l], delete e[l];
+  for (var l in s)
+    l == t && Object.assign(e, n), n.hasOwnProperty(l) || (e[l] = s[l]);
+}, Ma = {}.toString, qe = _.css, Kt = {
+  pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/,
+  lookbehind: !0
+}, Wt = {
+  pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
+  lookbehind: !0
+};
+qe.selector.inside = qe.atrule.inside["selector-function-argument"].inside = {
+  "pseudo-element": /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
+  "pseudo-class": /:[-\w]+/,
+  class: /\.[-\w]+/,
+  id: /#[-\w]+/,
+  attribute: {
+    pattern: /\[(?:[^[\]"']|(["'])(?:\\[^]|(?!\1)[^\\\n])*\1)*\]/g,
+    greedy: !0,
+    inside: {
+      punctuation: /^\[|\]$/,
+      "case-sensitivity": {
+        pattern: /(\s)[si]$/i,
+        lookbehind: !0,
+        alias: "keyword"
+      },
+      namespace: {
+        pattern: /^(\s*)(?:(?!\s)[-*\w\xa0-\uffff])*\|(?!=)/,
+        lookbehind: !0,
+        inside: {
+          punctuation: /\|$/
+        }
+      },
+      "attr-name": {
+        pattern: /^(\s*)(?:(?!\s)[-\w\xa0-\uffff])+/,
+        lookbehind: !0
+      },
+      "attr-value": {
+        pattern: /(=\s*)(?:(?!\s)[-\w\xa0-\uffff])+(?=\s*$)|(["'])(?:\\[^]|(?!\2)[^\\\n])*\2/,
+        lookbehind: !0
+      },
+      operator: /[|~*^$]?=/
+    }
+  },
+  "n-th": [
+    {
+      pattern: /(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/,
+      lookbehind: !0,
+      inside: {
+        number: /[\dn]+/,
+        operator: /[+-]/
+      }
+    },
+    {
+      pattern: /(\(\s*)(?:even|odd)(?=\s*\))/i,
+      lookbehind: !0
+    }
+  ],
+  combinator: />|\+|~|\|\|/,
+  // the `tag` token has been existed and removed.
+  // because we can't find a perfect tokenize to match it.
+  // if you want to add it, please read https://github.com/PrismJS/prism/pull/2373 first.
+  punctuation: /[(),]/
+};
+$(qe, "property", {
+  variable: {
+    pattern: /(^|[^-\w\xa0-\uffff])--(?!\d)(?:(?!\s)[-\w\xa0-\uffff])*/i,
+    lookbehind: !0
+  }
+});
+$(qe, "function", {
+  operator: {
+    pattern: /(\s)[/*+-](?!\S)/,
+    lookbehind: !0
+  },
+  // CAREFUL!
+  // Previewers and Inline color use hexcode and color.
+  hexcode: {
+    pattern: /\B#[a-f\d]{3,8}\b/i,
+    alias: "color"
+  },
+  color: [
+    {
+      pattern: /(^|[^\w-])(?:(?:alice|cadet|cornflower|deepsky|dodger|midnight|powder|royal|sky|steel)blue|antiquewhite|aqua|aquamarine|azure|beige|bisque|black|blanchedalmond|blueviolet|brown|burlywood|chartreuse|chocolate|coral|cornsilk|crimson|(?:dark)?(?:blue|cyan|goldenrod|gr[ae]y|green|khaki|magenta|olivegreen|orange|orchid|red|salmon|seagreen|slateblue|slategr[ae]y|turquoise|violet)|deeppink|dimgr[ae]y|firebrick|floralwhite|(?:forest|lawn|lime|pale|spring)green|fuchsia|gainsboro|ghostwhite|gold|greenyellow|honeydew|hotpink|indianred|indigo|ivory|lavender|lavenderblush|lemonchiffon|light(?:blue|coral|cyan|goldenrodyellow|gr[ae]y|green|pink|salmon|seagreen|skyblue|slategr[ae]y|steelblue|yellow)|lime|linen|maroon|medium(?:aquamarine|blue|orchid|purple|seagreen|slateblue|springgreen|turquoise|violetred)|mintcream|mistyrose|moccasin|navajowhite|navy|oldlace|olive|olivedrab|orangered|palegoldenrod|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|purple|rebeccapurple|rosybrown|saddlebrown|sandybrown|seashell|sienna|silver|snow|tan|teal|thistle|tomato|transparent|wheat|white|whitesmoke|yellow|yellowgreen)(?![\w-])/i,
+      lookbehind: !0
+    },
+    {
+      pattern: /\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,
+      inside: {
+        function: /^[^(]+/,
+        unit: Kt,
+        number: Wt,
+        punctuation: /[(),]/
+      }
+    }
+  ],
+  // it's important that there is no boundary assertion after the hex digits
+  entity: /\\[a-f\d]{1,8}/i,
+  unit: Kt,
+  number: Wt
+});
+_.ini = {
+  /**
+   * The component mimics the behavior of the Win32 API parser.
+   *
+   * @see {@link https://github.com/PrismJS/prism/issues/2775#issuecomment-787477723}
+   */
+  comment: {
+    pattern: /(^[ \f	\v]*)[#;].*/m,
+    lookbehind: !0
+  },
+  section: {
+    pattern: /(^[ \f	\v]*)\[[^\n\]]*\]?/m,
+    lookbehind: !0,
+    inside: {
+      "section-name": {
+        pattern: /(^\[[ \f	\v]*)[^ \f	\v\]]+(?:[ \f	\v]+[^ \f	\v\]]+)*/,
+        lookbehind: !0,
+        alias: "selector"
+      },
+      punctuation: /[[\]]/
+    }
+  },
+  key: {
+    pattern: /(^[ \f	\v]*)[^ \f\n	\v=]+(?:[ \f	\v]+[^ \f\n	\v=]+)*(?=[ \f	\v]*=)/m,
+    lookbehind: !0,
+    alias: "attr-name"
+  },
+  value: {
+    pattern: /(=[ \f	\v]*)[^ \f\n	\v]+(?:[ \f	\v]+[^ \f\n	\v]+)*/,
+    lookbehind: !0,
+    alias: "attr-value",
+    inside: {
+      "inner-value": {
+        pattern: /^(["']).+(?=\1$)/,
+        lookbehind: !0
+      }
+    }
+  },
+  punctuation: /=/
+};
+var re = () => ({
+  pattern: /\/\/.*|\/\*[^]*?(?:\*\/|$)/g,
+  greedy: !0
+}), Tt = () => ({
+  pattern: /(["'])(?:\\[^]|(?!\1)[^\\\n])*\1/g,
+  greedy: !0
+}), Mn = /\b0x[a-f\d]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i, te = /[()[\]{}.,:;]/, q = /\b(?:false|true)\b/, it = {
+  "interpolation-punctuation": {
+    pattern: /^\$\{?|\}$/,
+    alias: "punctuation"
+  },
+  expression: {
+    pattern: /[^]+/
+  }
+};
+it.expression.inside = _.kts = _.kt = _.kotlin = {
+  // https://kotlinlang.org/spec/expressions.html#string-interpolation-expressions
+  "string-literal": [
+    {
+      pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
+      alias: "multiline",
+      inside: {
+        interpolation: {
+          pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+          inside: it
+        },
+        string: /[^]+/
+      }
+    },
+    {
+      pattern: /"(?:\\.|[^\\\n"$]|\$(?:(?!\{)|\{[^{}]*\}))*"/,
+      alias: "singleline",
+      inside: {
+        interpolation: {
+          pattern: /((?:^|[^\\])(?:\\\\)*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+          lookbehind: !0,
+          inside: it
+        },
+        string: /[^]+/
+      }
+    }
+  ],
+  char: {
+    // https://kotlinlang.org/spec/expressions.html#character-literals
+    pattern: /'(?:[^\\\n']|\\(?:.|u[a-fA-F\d]{0,4}))'/g,
+    greedy: !0
+  },
+  comment: re(),
+  annotation: {
+    pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
+    alias: "builtin"
+  },
+  keyword: {
+    // The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get
+    pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
+    lookbehind: !0
+  },
+  boolean: q,
+  label: {
+    pattern: /\b\w+@|@\w+/,
+    alias: "symbol"
+  },
+  function: {
+    pattern: /(?:`[^\n`]+`|\b\w+)(?=\s*\()|(\.)(?:`[^\n`]+`|\w+)(?=\s*\{)/g,
+    lookbehind: !0,
+    greedy: !0
+  },
+  number: /\b(?:0[xX][a-fA-F\d]+(?:_[a-fA-F\d]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,
+  operator: /--|\+\+|&&|\|\||->|[!=]==|!!|[%!=<>/*+-]=?|[?:]:?|\.\.|\b(?:and|inv|shl|u?shr|x?or)\b/,
+  punctuation: te
+};
+var Pn = [
+  {
+    pattern: /&[a-z\d]{1,8};/i,
+    alias: "named-entity"
+  },
+  /&#x?[a-f\d]{1,8};/i
+], Pa = {
+  pattern: /<\/?(?!\d)[^\s/=>$<%]+(?:\s(?:\s*[^\s/=>]+(?:\s*=\s*(?!\s)(?:"[^"]*"|'[^']*'|[^\s"'=>]+(?=[\s>]))?|(?=[\s/>])))+)?\s*\/?>/g,
+  greedy: !0,
+  inside: {
+    punctuation: /^<\/?|\/?>$/,
+    tag: {
+      pattern: /^\S+/,
+      inside: {
+        namespace: /^[^:]+:/
+      }
+    },
+    "attr-value": [{
+      pattern: /(=\s*)(?:"[^"]*"|'[^']*'|[^\s"'=>]+)/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        punctuation: /^["']|["']$/,
+        entity: Pn
+      }
+    }],
+    "attr-equals": /=/,
+    "attr-name": {
+      pattern: /\S+/,
+      inside: {
+        namespace: /^[^:]+:/
+      }
+    }
+  }
+};
+_.rss = _.atom = _.ssml = _.xml = {
+  comment: {
+    pattern: /<!--(?:(?!<!--)[^])*?-->/g,
+    greedy: !0
+  },
+  prolog: {
+    pattern: /<\?[^]+?\?>/g,
+    greedy: !0
+  },
+  doctype: {
+    // https://www.w3.org/TR/xml/#NT-doctypedecl
+    pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/gi,
+    greedy: !0,
+    inside: {
+      "internal-subset": {
+        pattern: /(\[)[^]+(?=\]\s*>$)/,
+        lookbehind: !0,
+        inside: "xml"
+      },
+      string: /"[^"]*"|'[^']*'/,
+      punctuation: /^<!|[>[\]]/,
+      "doctype-tag": /^DOCTYPE/i,
+      name: /\S+/
+    }
+  },
+  cdata: {
+    pattern: /<!\[CDATA\[[^]*?\]\]>/gi,
+    greedy: !0
+  },
+  tag: Pa,
+  entity: Pn,
+  "markup-bracket": {
+    pattern: /[()[\]{}]/,
+    alias: "punctuation"
+  }
+};
+var gt = (e, t) => (e["language-" + t] = {
+  pattern: /[^]+/,
+  inside: t
+}, e), jt = (e, t) => ({
+  pattern: RegExp(`(<${e}[^>]*>)(?!</${e}>)(?:<!\\[CDATA\\[(?:[^\\]]|\\](?!\\]>))*\\]\\]>|(?!<!\\[CDATA\\[)[^])+?(?=</${e}>)`, "gi"),
+  lookbehind: !0,
+  greedy: !0,
+  inside: gt({
+    "included-cdata": {
+      pattern: /<!\[CDATA\[[^]*?\]\]>/i,
+      inside: gt({
+        cdata: /^<!\[CDATA\[|\]\]>$/i
+      }, t)
+    }
+  }, t)
+}), Yt = (e, t) => ({
+  pattern: RegExp(`((?:^|["'\\s])(?:${e})\\s*=\\s*)(?:"[^"]*"|'[^']*'|[^\\s"'=>]+)`, "gi"),
+  lookbehind: !0,
+  greedy: !0,
+  inside: gt({
+    punctuation: /^["']|["']$/
+  }, t)
+}), $n = _.svg = _.mathml = _.html = _.markup = Qe(_.xml);
+$n.tag.inside["attr-value"].unshift(
+  Yt("style", "css"),
+  Yt("on[a-z]+", "javascript")
+);
+$($n, "cdata", {
+  style: jt("style", "css"),
+  script: jt("script", "javascript")
+});
+_.r = {
+  comment: /#.*/,
+  string: {
+    pattern: /(["'])(?:\\.|(?!\1)[^\\\n])*\1/g,
+    greedy: !0
+  },
+  "percent-operator": {
+    // Includes user-defined operators
+    // and %%, %*%, %/%, %in%, %o%, %x%
+    pattern: /%[^%\s]*%/,
+    alias: "operator"
+  },
+  boolean: /\b(?:FALSE|TRUE)\b/,
+  ellipsis: /\.\.(?:\.|\d+)/,
+  number: [
+    /\b(?:Inf|NaN)\b/,
+    /(?:\b0x[a-fA-F\d]+(?:\.\d*)?|\b\d+(?:\.\d*)?|\B\.\d+)(?:[EePp][+-]?\d+)?[iL]?/
+  ],
+  keyword: /\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\b/,
+  operator: /->>?|<=|<<?-|[!=<>]=?|::?|&&?|\|\|?|[~^$@/*+-]/,
+  punctuation: /[()[\]{},;]/
+};
+_.basic = {
+  comment: {
+    pattern: /(?:!|rem\b).+/i,
+    inside: {
+      keyword: /^rem/i
+    }
+  },
+  string: {
+    pattern: /"(?:""|[#$%&'().,:;\w ?^!=<>/*+-])*"/g,
+    greedy: !0
+  },
+  number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+  keyword: /\b(?:as|beep|bload|bsave|call absolute|call|case|chain|chdir|clear|close|cls|com|common|const|data|declare|def(?: fn| seg|dbl|int|[ls]ng|str)|dim|do|double|else|elseif|environ|erase|error|exit|field|files|for|function|get|gosub|goto|if|input|integer|ioctl|key|kill|line input|locate|lock|long|loop|[lr]set|mkdir|name|next|off|on(?: com| error| key| timer)?|open|option base|[op]ut|poke|read|redim|rem|restore|resume|return|rmdir|run|select case|shared|shell|single|sleep|static|step|stop|string|sub|swap|system|then|timer|to|troff|tron|type|unlock|until|using|view print|wait|w?end|while|write)(?:\$|\b)/i,
+  function: /\b(?:abs|access|a?cos|angle|area|arithmetic|array|a?sin|ask|atn?|base|begin|break|cause|ceil|chr|clip|collate|color|co[nst]|cosh|csc|date|datum|debug|decimal|de[fgt]|degrees|delete|device|display|dot|elapsed|eps|erasable|exline|exp|external|extype|filetype|fixed|fp|go|graph|handler|idn|image|int?|internal|ip|is|keyed|[lu]bound|[lu]case|left|le[nt]|length|lines?|log2?|log10|[lr]trim|margin|ma[tx]|maxnum|mi[dn]|missing|mod|native|nul|numeric|of|option|ord|organization|outin|output|pi|pointer|points?|pos|print|program|prompt|rad|radians|randomize|record|recsize|rectype|relative|remainder|repeat|rest|retry|rewrite|right|rnd|round|same|se[ct]|select|sequential|setter|sgn|sinh|size|skip|s[qt]r|standard|status|stream|style|tab|tanh?|template|text|there|time|timeout|trace|transform|truncate|use|val|variable|viewport|when|window|with|zer|zonewidth)(?:\$|\b)/i,
+  operator: /<=|<>|>=|[&^=<>/*+-]|\b(?:and|eqv|imp|not|x?or)\b/i,
+  punctuation: /[(),:;]/
+};
+_.vbnet = ae("basic", {
+  comment: {
+    pattern: /(?:!|'|rem\b).*/i,
+    inside: {
+      keyword: /^rem/i
+    }
+  },
+  string: {
+    pattern: /(^|[^"])"(?:""|[^"])*"(?!")/g,
+    lookbehind: !0,
+    greedy: !0
+  },
+  keyword: /(?:\b(?:addhandler|addressof|alias|and|andalso|as|beep|bload|boolean|bsave|byref|byval|call absolute|call|case|catch|cbool|c?byte|cc?har|c?date|cdbl|cdec|chain|chdir|cu?int|class|clear|close|cls|cobj|com|common|const|continue|c?sbyte|c?u?short|c?sng|cstr|c?type|cu?lng|data|decimal|declare|def(?: fn| seg|dbl|int|lng|sng|str)|default|delegate|dim|directcast|do|double|else|elseif|enum|environ|erase|error|event|exit|false|true|field|files|finally|for each|for|friend|function|[gls]et|gettype|getxmlnamespace|global|gosub|goto|handles|i[fns]|implements|imports|inherits|input|interface|ioctl|isnot|key|kill|lib|like|line input|locate|lock|loop|[lr]set|me|mkdir|mod|module|mustinherit|mustoverride|mybase|myclass|name|namespace|narrowing|new|next|not|nothing|notinheritable|notoverridable|object|off?|on (?:com|error|key|timer)|on|open|operator|option base|option|optional|orelse|out|overloads|overridable|overrides|paramarray|partial|poke|private|property|protected|public|put|raiseevent|read|readonly|redim|removehandler|restore|resume|return|rmdir|run|select case|select|shadows|shared|shell|single|sleep|static|step|stop|string|structure|sub|swap|synclock|system|[tw]hen|throw|timer|to|troff|tron|try|trycast|typeof|u?integer|u?long|unlock|until|using|view print|wait|w?end|while|widening|with|withevents|write|writeonly|x?or)|\B#(?:const|else|elseif|end|if))(?:\$|\b)/i,
+  punctuation: /[(){},:;]/
+});
+var Xt = {
+  // https://en.cppreference.com/w/c/language/character_constant
+  pattern: /'(?:\\[^]|[^\\\n']){0,32}'/g,
+  greedy: !0
+}, Qt = {
+  pattern: /\/\/(?:[^\\\n]|\\\n?)*|\/\*[^]*?(?:\*\/|$)/g,
+  greedy: !0
+}, Jt = {
+  // https://en.cppreference.com/w/c/language/string_literal
+  pattern: /"(?:\\[^]|[^\\\n"])*"/g,
+  greedy: !0
+}, en = {
+  pattern: /\S[^]*/
+};
+en.inside = _.c = {
+  comment: Qt,
+  char: Xt,
+  macro: {
+    // allow for multiline macro definitions
+    // spaces after the # character compile fine with gcc
+    pattern: /(^[ 	]*)#\s*[a-z](?:[^\\\n/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\[^])*/img,
+    lookbehind: !0,
+    greedy: !0,
+    alias: "property",
+    inside: {
+      string: [
+        {
+          // highlight the path of the include statement as a string
+          pattern: /^(#\s*include\s*)<[^>]+>/,
+          lookbehind: !0
+        },
+        Jt
+      ],
+      char: Xt,
+      comment: Qt,
+      "macro-name": [
+        {
+          pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
+          lookbehind: !0
+        },
+        {
+          pattern: /(^#\s*define\s+)\w+/i,
+          lookbehind: !0,
+          alias: "function"
+        }
+      ],
+      // highlight macro directives as keywords
+      directive: {
+        pattern: /^(#\s*)[a-z]+/,
+        lookbehind: !0,
+        alias: "keyword"
+      },
+      "directive-hash": /^#/,
+      punctuation: /##|\\(?=\n)/,
+      expression: en
+    }
+  },
+  string: Jt,
+  "class-name": {
+    pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([^]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
+    lookbehind: !0
+  },
+  keyword: /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
+  // highlight predefined macros as constants
+  constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/,
+  function: /\b[a-z_]\w*(?=\s*\()/i,
+  number: /(?:\b0x(?:[a-f\d]+(?:\.[a-f\d]*)?|\.[a-f\d]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
+  operator: /->|([&|:+-])\1|[?:~]|>>=?|<<=?|[%&|^!=<>/*+-]=?/,
+  punctuation: te
+};
+$(
+  _.opencl = ae("c", {
+    // Extracted from the official specs (2.0) and http://streamcomputing.eu/downloads/?opencl.lang (opencl-keywords, opencl-types) and http://sourceforge.net/tracker/?func=detail&aid=2957794&group_id=95717&atid=612384 (Words2, partly Words3)
+    keyword: /\b(?:(?:__)?(?:constant|global|kernel|local|private|read_only|read_write|write_only)|__attribute__|auto|(?:bool|u?(?:char|int|long|short)|half|quad)(?:2|3|4|8|16)?|break|case|complex|const|continue|(?:double|float)(?:16(?:x(?:1|2|4|8|16))?|1x(?:1|2|4|8|16)|2(?:x(?:1|2|4|8|16))?|3|4(?:x(?:1|2|4|8|16))?|8(?:x(?:1|2|4|8|16))?)?|default|do|else|enum|extern|for|goto|if|imaginary|inline|packed|pipe|register|restrict|return|signed|sizeof|static|struct|switch|typedef|uniform|union|unsigned|void|volatile|while)\b/,
+    // Extracted from http://streamcomputing.eu/downloads/?opencl.lang (opencl-const)
+    // Math Constants: https://www.khronos.org/registry/OpenCL/sdk/2.1/docs/man/xhtml/mathConstants.html
+    // Macros and Limits: https://www.khronos.org/registry/OpenCL/sdk/2.1/docs/man/xhtml/macroLimits.html
+    number: /(?:\b0x(?:[a-f\d]+(?:\.[a-f\d]*)?|\.[a-f\d]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[fuhl]{0,4}/i,
+    boolean: q,
+    "constant-opencl-kernel": {
+      pattern: /\b(?:CHAR_(?:BIT|MAX|MIN)|CLK_(?:ADDRESS_(?:CLAMP(?:_TO_EDGE)?|NONE|REPEAT)|FILTER_(?:LINEAR|NEAREST)|(?:GLOBAL|LOCAL)_MEM_FENCE|NORMALIZED_COORDS_(?:FALSE|TRUE))|CL_(?:BGRA|(?:HALF_)?FLOAT|INTENSITY|LUMINANCE|A?R?G?B?[Ax]?|(?:(?:UN)?SIGNED|[US]NORM)_(?:INT(?:8|16|32))|UNORM_(?:INT_101010|SHORT_(?:555|565)))|(?:DBL|FLT|HALF)_(?:DIG|EPSILON|(?:MAX|MIN)(?:(?:_10)?_EXP)?|MANT_DIG)|FLT_RADIX|HUGE_VALF?|(?:INT|LONG|SCHAR|SHRT)_(?:MAX|MIN)|INFINITY|MAXFLOAT|M_(?:[12]_PI|2_SQRTPI|E|LN2|LN10|LOG2E?|LOG10E?|PI(?:_[24])?|SQRT(?:1_2|2))(?:_F|_H)?|NAN|(?:UCHAR|UINT|ULONG|USHRT)_MAX)\b/,
+      alias: "constant"
+    }
+  }),
+  "class-name",
+  {
+    // https://www.khronos.org/registry/OpenCL/sdk/2.1/docs/man/xhtml/scalarDataTypes.html
+    // https://www.khronos.org/registry/OpenCL/sdk/2.1/docs/man/xhtml/otherDataTypes.html
+    "builtin-type": {
+      pattern: /\b(?:_cl_(?:command_queue|context|device_id|event|kernel|mem|platform_id|program|sampler)|cl_(?:image_format|mem_fence_flags)|clk_event_t|event_t|image(?:1d_(?:array_|buffer_)?t|2d_(?:array_(?:depth_|msaa_depth_|msaa_)?|depth_|msaa_depth_|msaa_)?t|3d_t)|ndrange_t|ptrdiff_t|queue_t|reserve_id_t|sampler_t|size_t|u?intptr_t)\b/,
+      alias: "keyword"
+    }
+  }
+);
+var mt = {
+  // Extracted from http://streamcomputing.eu/downloads/?opencl_host.lang (opencl-types and opencl-host)
+  "type-opencl-host": {
+    pattern: /\b(?:cl_(?:GLenum|GLint|GLuin|addressing_mode|bitfield|bool|buffer_create_type|build_status|channel_(?:order|type)|(?:u?(?:char|int|long|short)|double|float)(?:[2348]|16)?|command_(?:queue(?:_info|_properties)?|type)|context(?:_info|_properties)?|device_(?:exec_capabilities|fp_config|id|info|local_mem_type|mem_cache_type|type)|(?:event|sampler)(?:_info)?|filter_mode|half|image_info|kernel(?:_info|_work_group_info)?|map_flags|mem(?:_flags|_info|_object_type)?|platform_(?:id|info)|profiling_info|program(?:_build_info|_info)?))\b/,
+    alias: "keyword"
+  },
+  "boolean-opencl-host": {
+    pattern: /\bCL_(?:FALSE|TRUE)\b/,
+    alias: "boolean"
+  },
+  // Extracted from cl.h (2.0) and http://streamcomputing.eu/downloads/?opencl_host.lang (opencl-const)
+  "constant-opencl-host": {
+    pattern: /\bCL_(?:A|ABGR|ADDRESS_(?:CLAMP(?:_TO_EDGE)?|MIRRORED_REPEAT|NONE|REPEAT)|ARGB|BLOCKING|BUFFER_CREATE_TYPE_REGION|BUILD_(?:ERROR|IN_PROGRESS|NONE|PROGRAM_FAILURE|SUCCESS)|COMMAND_(?:ACQUIRE_GL_OBJECTS|BARRIER|COPY_(?:BUFFER(?:_RECT|_TO_IMAGE)?|IMAGE(?:_TO_BUFFER)?)|FILL_(?:BUFFER|IMAGE)|MAP(?:_BUFFER|_IMAGE)|MARKER|MIGRATE(?:_SVM)?_MEM_OBJECTS|NATIVE_KERNEL|NDRANGE_KERNEL|READ_(?:BUFFER(?:_RECT)?|IMAGE)|RELEASE_GL_OBJECTS|SVM_(?:FREE|MAP|MEMCPY|MEMFILL|UNMAP)|TASK|UNMAP_MEM_OBJECT|USER|WRITE_(?:BUFFER(?:_RECT)?|IMAGE))|COMPILER_NOT_AVAILABLE|COMPILE_PROGRAM_FAILURE|COMPLETE|CONTEXT_(?:DEVICES|INTEROP_USER_SYNC|NUM_DEVICES|PLATFORM|PROPERTIES|REFERENCE_COUNT)|DEPTH(?:_STENCIL)?|DEVICE_(?:ADDRESS_BITS|AFFINITY_DOMAIN_(?:L[1-4]_CACHE|NEXT_PARTITIONABLE|NUMA)|AVAILABLE|BUILT_IN_KERNELS|COMPILER_AVAILABLE|DOUBLE_FP_CONFIG|ENDIAN_LITTLE|ERROR_CORRECTION_SUPPORT|EXECUTION_CAPABILITIES|EXTENSIONS|GLOBAL_(?:MEM_(?:CACHELINE_SIZE|CACHE_SIZE|CACHE_TYPE|SIZE)|VARIABLE_PREFERRED_TOTAL_SIZE)|HOST_UNIFIED_MEMORY|IL_VERSION|IMAGE(?:2D_MAX_(?:HEIGHT|WIDTH)|3D_MAX_(?:DEPTH|HEIGHT|WIDTH)|_BASE_ADDRESS_ALIGNMENT|_MAX_ARRAY_SIZE|_MAX_BUFFER_SIZE|_PITCH_ALIGNMENT|_SUPPORT)|LINKER_AVAILABLE|LOCAL_MEM_SIZE|LOCAL_MEM_TYPE|MAX_(?:CLOCK_FREQUENCY|COMPUTE_UNITS|CONSTANT_ARGS|CONSTANT_BUFFER_SIZE|GLOBAL_VARIABLE_SIZE|MEM_ALLOC_SIZE|NUM_SUB_GROUPS|ON_DEVICE_(?:EVENTS|QUEUES)|PARAMETER_SIZE|PIPE_ARGS|READ_IMAGE_ARGS|READ_WRITE_IMAGE_ARGS|SAMPLERS|WORK_GROUP_SIZE|WORK_ITEM_DIMENSIONS|WORK_ITEM_SIZES|WRITE_IMAGE_ARGS)|MEM_BASE_ADDR_ALIGN|MIN_DATA_TYPE_ALIGN_SIZE|NAME|NATIVE_VECTOR_WIDTH_(?:CHAR|DOUBLE|FLOAT|HALF|INT|LONG|SHORT)|NOT_(?:AVAILABLE|FOUND)|OPENCL_C_VERSION|PARENT_DEVICE|PARTITION_(?:AFFINITY_DOMAIN|BY_AFFINITY_DOMAIN|BY_COUNTS|BY_COUNTS_LIST_END|EQUALLY|FAILED|MAX_SUB_DEVICES|PROPERTIES|TYPE)|PIPE_MAX_(?:ACTIVE_RESERVATIONS|PACKET_SIZE)|PLATFORM|PREFERRED_(?:GLOBAL_ATOMIC_ALIGNMENT|INTEROP_USER_SYNC|LOCAL_ATOMIC_ALIGNMENT|PLATFORM_ATOMIC_ALIGNMENT|VECTOR_WIDTH_(?:CHAR|DOUBLE|FLOAT|HALF|INT|LONG|SHORT))|PRINTF_BUFFER_SIZE|PROFILE|PROFILING_TIMER_RESOLUTION|QUEUE_(?:ON_(?:DEVICE_(?:MAX_SIZE|PREFERRED_SIZE|PROPERTIES)|HOST_PROPERTIES)|PROPERTIES)|REFERENCE_COUNT|SINGLE_FP_CONFIG|SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS|SVM_(?:ATOMICS|CAPABILITIES|COARSE_GRAIN_BUFFER|FINE_GRAIN_BUFFER|FINE_GRAIN_SYSTEM)|TYPE(?:_ACCELERATOR|_ALL|_CPU|_CUSTOM|_DEFAULT|_GPU)?|VENDOR(?:_ID)?|VERSION)|DRIVER_VERSION|EVENT_(?:COMMAND_(?:EXECUTION_STATUS|QUEUE|TYPE)|CONTEXT|REFERENCE_COUNT)|EXEC_(?:KERNEL|NATIVE_KERNEL|STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST)|FILTER_(?:LINEAR|NEAREST)|FLOAT|FP_(?:CORRECTLY_ROUNDED_DIVIDE_SQRT|DENORM|FMA|INF_NAN|ROUND_TO_INF|ROUND_TO_NEAREST|ROUND_TO_ZERO|SOFT_FLOAT)|GLOBAL|HALF_FLOAT|IMAGE_(?:ARRAY_SIZE|BUFFER|DEPTH|ELEMENT_SIZE|FORMAT|FORMAT_MISMATCH|FORMAT_NOT_SUPPORTED|HEIGHT|NUM_MIP_LEVELS|NUM_SAMPLES|ROW_PITCH|SLICE_PITCH|WIDTH)|INTENSITY|INVALID_(?:ARG_INDEX|ARG_SIZE|ARG_VALUE|BINARY|BUFFER_SIZE|BUILD_OPTIONS|COMMAND_QUEUE|COMPILER_OPTIONS|CONTEXT|DEVICE|DEVICE_PARTITION_COUNT|DEVICE_QUEUE|DEVICE_TYPE|EVENT|EVENT_WAIT_LIST|GLOBAL_OFFSET|GLOBAL_WORK_SIZE|GL_OBJECT|HOST_PTR|IMAGE_DESCRIPTOR|IMAGE_FORMAT_DESCRIPTOR|IMAGE_SIZE|KERNEL|KERNEL_ARGS|KERNEL_DEFINITION|KERNEL_NAME|LINKER_OPTIONS|MEM_OBJECT|MIP_LEVEL|OPERATION|PIPE_SIZE|PLATFORM|PROGRAM|PROGRAM_EXECUTABLE|PROPERTY|QUEUE_PROPERTIES|SAMPLER|VALUE|WORK_DIMENSION|WORK_GROUP_SIZE|WORK_ITEM_SIZE)|KERNEL_(?:ARG_(?:ACCESS_(?:NONE|QUALIFIER|READ_ONLY|READ_WRITE|WRITE_ONLY)|ADDRESS_(?:CONSTANT|GLOBAL|LOCAL|PRIVATE|QUALIFIER)|INFO_NOT_AVAILABLE|NAME|TYPE_(?:CONST|NAME|NONE|PIPE|QUALIFIER|RESTRICT|VOLATILE))|ATTRIBUTES|COMPILE_NUM_SUB_GROUPS|COMPILE_WORK_GROUP_SIZE|CONTEXT|EXEC_INFO_SVM_FINE_GRAIN_SYSTEM|EXEC_INFO_SVM_PTRS|FUNCTION_NAME|GLOBAL_WORK_SIZE|LOCAL_MEM_SIZE|LOCAL_SIZE_FOR_SUB_GROUP_COUNT|MAX_NUM_SUB_GROUPS|MAX_SUB_GROUP_SIZE_FOR_NDRANGE|NUM_ARGS|PREFERRED_WORK_GROUP_SIZE_MULTIPLE|PRIVATE_MEM_SIZE|PROGRAM|REFERENCE_COUNT|SUB_GROUP_COUNT_FOR_NDRANGE|WORK_GROUP_SIZE)|LINKER_NOT_AVAILABLE|LINK_PROGRAM_FAILURE|LOCAL|LUMINANCE|MAP_(?:FAILURE|READ|WRITE|WRITE_INVALIDATE_REGION)|MEM_(?:ALLOC_HOST_PTR|ASSOCIATED_MEMOBJECT|CONTEXT|COPY_HOST_PTR|COPY_OVERLAP|FLAGS|HOST_NO_ACCESS|HOST_PTR|HOST_READ_ONLY|HOST_WRITE_ONLY|KERNEL_READ_AND_WRITE|MAP_COUNT|OBJECT_(?:ALLOCATION_FAILURE|BUFFER|IMAGE1D|IMAGE1D_ARRAY|IMAGE1D_BUFFER|IMAGE2D|IMAGE2D_ARRAY|IMAGE3D|PIPE)|OFFSET|READ_ONLY|READ_WRITE|REFERENCE_COUNT|SIZE|SVM_ATOMICS|SVM_FINE_GRAIN_BUFFER|TYPE|USES_SVM_POINTER|USE_HOST_PTR|WRITE_ONLY)|MIGRATE_MEM_OBJECT_(?:CONTENT_UNDEFINED|HOST)|MISALIGNED_SUB_BUFFER_OFFSET|NONE|NON_BLOCKING|OUT_OF_(?:HOST_MEMORY|RESOURCES)|PIPE_(?:MAX_PACKETS|PACKET_SIZE)|PLATFORM_(?:EXTENSIONS|HOST_TIMER_RESOLUTION|NAME|PROFILE|VENDOR|VERSION)|PROFILING_(?:COMMAND_(?:COMPLETE|END|QUEUED|START|SUBMIT)|INFO_NOT_AVAILABLE)|PROGRAM_(?:BINARIES|BINARY_SIZES|BINARY_TYPE(?:_COMPILED_OBJECT|_EXECUTABLE|_LIBRARY|_NONE)?|BUILD_(?:GLOBAL_VARIABLE_TOTAL_SIZE|LOG|OPTIONS|STATUS)|CONTEXT|DEVICES|IL|KERNEL_NAMES|NUM_DEVICES|NUM_KERNELS|REFERENCE_COUNT|SOURCE)|QUEUED|QUEUE_(?:CONTEXT|DEVICE|DEVICE_DEFAULT|ON_DEVICE|ON_DEVICE_DEFAULT|OUT_OF_ORDER_EXEC_MODE_ENABLE|PROFILING_ENABLE|PROPERTIES|REFERENCE_COUNT|SIZE)|RA?|READ_(?:ONLY|WRITE)_CACHE|RG|RGB[Ax]?|RG?x|RUNNING|SAMPLER_(?:ADDRESSING_MODE|CONTEXT|FILTER_MODE|LOD_MAX|LOD_MIN|MIP_FILTER_MODE|NORMALIZED_COORDS|REFERENCE_COUNT)|(?:UN)?SIGNED_INT(?:8|16|32)|SNORM_INT(?:8|16)|SUBMITTED|SUCCESS|UNORM_INT(?:8|16|24|_101010|_101010_2)|UNORM_SHORT_5[56]5|VERSION_(?:1_[012]|2_[01])|s?BGRA|sRGB[Ax]?)\b/,
+    alias: "constant"
+  },
+  // Extracted from cl.h (2.0) and http://streamcomputing.eu/downloads/?opencl_host.lang (opencl-host)
+  "function-opencl-host": {
+    pattern: /\bcl(?:BuildProgram|CloneKernel|CompileProgram|Create(?:Buffer|CommandQueue(?:WithProperties)?|Context|ContextFromType|Image|Image[23]D|Kernel|KernelsInProgram|Pipe|ProgramWith(?:Binary|BuiltInKernels|IL|Source)|Sampler|SamplerWithProperties|SubBuffer|SubDevices|UserEvent)|Enqueue(?:(?:Barrier|Marker)(?:WithWaitList)?|Copy(?:Buffer(?:Rect|ToImage)?|Image(?:ToBuffer)?)|(?:Fill|Map)(?:Buffer|Image)|MigrateMemObjects|NDRangeKernel|NativeKernel|(?:Read|Write)(?:Buffer(?:Rect)?|Image)|SVM(?:Free|Map|MemFill|Memcpy|MigrateMem|Unmap)|Task|UnmapMemObject|WaitForEvents)|Finish|Flush|Get(?:CommandQueueInfo|ContextInfo|Device(?:AndHostTimer|IDs|Info)|Event(?:Profiling)?Info|ExtensionFunctionAddress(?:ForPlatform)?|HostTimer|ImageInfo|Kernel(?:ArgInfo|Info|SubGroupInfo|WorkGroupInfo)|MemObjectInfo|PipeInfo|Platform(?:IDs|Info)|Program(?:Build)?Info|SamplerInfo|SupportedImageFormats)|LinkProgram|(?:Release|Retain)(?:CommandQueue|Context|Device|Event|Kernel|MemObject|Program|Sampler)|SVM(?:Alloc|Free)|Set(?:CommandQueueProperty|DefaultDeviceCommandQueue|EventCallback|Kernel|Kernel(?:Arg(?:SVMPointer)?|ExecInfo)|MemObjectDestructorCallback|UserEventStatus)|Unload(?:Platform)?Compiler|WaitForEvents)\b/,
+    alias: "function"
+  }
+};
+$(_.c, "keyword", mt);
+_.cpp && (mt["type-opencl-host-cpp"] = {
+  pattern: /\b(?:Buffer|BufferGL|BufferRenderGL|CommandQueue|Context|Device|DeviceCommandQueue|EnqueueArgs|Event|Image(?:[123]D|[12]DArray|1DBuffer|[23]DGL|Format|GL)?|Kernel|KernelFunctor|LocalSpaceArg|Memory|NDRange|Pipe|Platform|Program|SVMAllocator|SVMTrait(?:Atomic|Coarse|Fine|ReadOnly|ReadWrite|WriteOnly)|Sampler|UserEvent)\b/,
+  alias: "keyword"
+}, $(_.cpp, "keyword", mt));
+var $a = _.diff = {
+  // Match all kinds of coord lines (prefixed by "+++", "---" or "***").
+  // Match "@@ ... @@" coord lines in unified diff.
+  // Match coord lines in normal diff (starts with a number).
+  coord: /^(?:\*{3}|-{3}|\+{3}|\d).*$|^@@.*@@$/m
+  // deleted, inserted, unchanged, diff
+}, st = {
+  "deleted-sign": "-",
+  "deleted-arrow": "<",
+  "inserted-sign": "+",
+  "inserted-arrow": ">",
+  unchanged: " ",
+  diff: "!"
+};
+for (var ce in st) {
+  var ot = ce.split("-")[0];
+  $a[ce] = {
+    pattern: RegExp("^(?:[" + st[ce] + `].*$
+?)+`, "m"),
+    alias: ot != ce ? ot : ce == "diff" ? "bold" : void 0,
+    inside: {
+      prefix: {
+        pattern: RegExp("^[" + st[ce] + "]", "mg"),
+        greedy: !0,
+        alias: ot
+      }
+    }
+  };
+}
+var lt = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|opens?|package|permits|private|protected|provides|public|record(?!\s*[()[\]{}%~.,:;?%&|^=<>/*+-])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throws?|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/, Ie = "(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*", ht = {
+  pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+  inside: {
+    punctuation: /\./
+  }
+}, _t = {
+  namespace: ht,
+  punctuation: /\./
+}, tn = {
+  pattern: RegExp(`(^|[^\\w.])${Ie}[A-Z](?:[\\d_A-Z]*[a-z]\\w*)?\\b`),
+  lookbehind: !0,
+  inside: _t
+};
+_.java = {
+  "doc-comment": {
+    pattern: /\/\*\*(?!\/)[^]*?(?:\*\/|$)/g,
+    greedy: !0,
+    alias: "comment",
+    inside: "javadoc"
+  },
+  comment: re(),
+  "triple-quoted-string": {
+    // http://openjdk.java.net/jeps/355#Description
+    pattern: /"""[ 	]*\n(?:\\.|[^\\])*?"""/g,
+    greedy: !0,
+    alias: "string"
+  },
+  char: {
+    pattern: /'(?:\\.|[^\\\n']){1,6}'/g,
+    greedy: !0
+  },
+  string: {
+    pattern: /(^|[^\\])"(?:\\.|[^\\\n"])*"/g,
+    lookbehind: !0,
+    greedy: !0
+  },
+  annotation: {
+    pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
+    lookbehind: !0,
+    alias: "punctuation"
+  },
+  generics: {
+    pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
+    inside: {
+      "class-name": tn,
+      keyword: lt,
+      punctuation: /[().,:<>]/,
+      operator: /[?&|]/
+    }
+  },
+  import: [
+    {
+      pattern: RegExp(`(\\bimport\\s+)${Ie}(?:[A-Z]\\w*|\\*)(?=\\s*;)`),
+      lookbehind: !0,
+      inside: {
+        namespace: ht,
+        punctuation: /\./,
+        operator: /\*/,
+        "class-name": /\w+/
+      }
+    },
+    {
+      pattern: RegExp(`(\\bimport\\s+static\\s+)${Ie}(?:\\w+|\\*)(?=\\s*;)`),
+      lookbehind: !0,
+      alias: "static",
+      inside: {
+        namespace: ht,
+        static: /\b\w+$/,
+        punctuation: /\./,
+        operator: /\*/,
+        "class-name": /\w+/
+      }
+    }
+  ],
+  namespace: {
+    pattern: RegExp(
+      `(\\b(?:exports|import(?:\\s+static)?|module|opens?|package|provides|requires|to|transitive|uses|with)\\s+)(?!${lt.source})[a-z]\\w*(?:\\.[a-z]\\w*)*\\.?`
+    ),
+    lookbehind: !0,
+    inside: {
+      punctuation: /\./
+    }
+  },
+  "class-name": [
+    tn,
+    {
+      // variables, parameters, and constructor references
+      // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+      pattern: RegExp(`(^|[^\\w.])${Ie}[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()]|\\s*(?:\\[[\\s,]*\\]\\s*)?::\\s*new\\b)`),
+      lookbehind: !0,
+      inside: _t
+    },
+    {
+      // class names based on keyword
+      // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+      pattern: RegExp(`(\\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\\s+)${Ie}[A-Z]\\w*\\b`),
+      lookbehind: !0,
+      inside: _t
+    }
+  ],
+  keyword: lt,
+  boolean: q,
+  function: {
+    pattern: /\b\w+(?=\()|(::\s*)[a-z_]\w*/,
+    lookbehind: !0
+  },
+  number: /\b0b[01][01_]*l?\b|\b0x(?:\.[a-f\d_p+-]+|[a-f\d_]+(?:\.[a-f\d_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
+  constant: /\b[A-Z][A-Z_\d]+\b/,
+  operator: {
+    pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[%&|^!=<>/*+-]=?)/m,
+    lookbehind: !0
+  },
+  punctuation: te
+};
+$(
+  _.less = ae("css", {
+    comment: re(),
+    atrule: {
+      pattern: /@[\w-](?:\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};\s]|\s+(?!\s))*?(?=\s*\{)/,
+      inside: {
+        punctuation: /[():]/
+      }
+    },
+    // selectors and mixins are considered the same
+    selector: {
+      pattern: /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};@\s]|\s+(?!\s))*?(?=\s*\{)/,
+      inside: {
+        // mixin parameters
+        variable: /@+[\w-]+/
+      }
+    },
+    property: /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/,
+    operator: /[/*+-]/
+  }),
+  "property",
+  {
+    variable: [
+      // Variable declaration (the colon must be consumed!)
+      {
+        pattern: /@[\w-]+\s*:/,
+        inside: {
+          punctuation: /:/
+        }
+      },
+      // Variable usage
+      /@@?[\w-]+/
+    ],
+    "mixin-usage": {
+      pattern: /([{;]\s*)[.#](?!\d)[\w-].*?(?=[(;])/,
+      lookbehind: !0,
+      alias: "function"
+    }
+  }
+);
+_.objc = _.objectivec = ae("c", {
+  string: {
+    pattern: /@?"(?:\\[^]|[^\\\n"])*"/g,
+    greedy: !0
+  },
+  keyword: /\b(?:asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int?|long|register|return|self|short|signed|sizeof|static|struct|super|switch|typedef|typeof|union|unsigned|void|volatile|while)\b|(?:@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector)\b/,
+  operator: /-[->]?|\+\+?|!=?|==?|>>?=?|<<?=?|&&?|\|\|?|[~^@%?/*]/
+});
+delete _.objc["class-name"];
+var Dn = {
+  pattern: /^(..)[^]+(?=.)/,
+  lookbehind: !0
+}, ct = "(?:([^a-zA-Z\\d\\s{(\\[<=])(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|\\((?:\\\\[\\s\\S]|[^\\\\()]|\\((?:\\\\[\\s\\S]|[^\\\\()])*\\))*\\)|\\{(?:\\\\[\\s\\S]|[^\\\\{}]|\\{(?:\\\\[\\s\\S]|[^\\\\{}])*\\})*\\}|\\[(?:\\\\[\\s\\S]|[^\\\\[\\]]|\\[(?:\\\\[\\s\\S]|[^\\\\[\\]])*\\])*\\]|<(?:\\\\[\\s\\S]|[^\\\\<>]|<(?:\\\\[\\s\\S]|[^\\\\<>])*>)*>)", nn = `(?:"(?:\\\\.|[^\\\\
+"])*"|(?:\\b(?!\\d)\\w+|[^\\s\0-\\x7f]+)[?!]?|\\$.)`, se = {
+  pattern: /((?:^|[^\\])(?:\\\\)*)#\{(?:[^{}]|\{[^}]*\})*\}/,
+  lookbehind: !0,
+  inside: {
+    content: Dn,
+    delimiter: {
+      pattern: /.+/,
+      alias: "punctuation"
+    }
+  }
+};
+Dn.inside = _.rb = _.ruby = {
+  comment: {
+    pattern: /#.*|^=begin\s[^]*?^=end/mg,
+    greedy: !0
+  },
+  "string-literal": [
+    {
+      pattern: RegExp("%[qQiIwWs]?" + ct, "g"),
+      greedy: !0,
+      inside: {
+        interpolation: se,
+        string: /[^]+/
+      }
+    },
+    {
+      pattern: /(["'])(?:#\{[^}]+\}|#(?!\{)|\\[^]|(?!\1)[^\\#\n])*\1/g,
+      greedy: !0,
+      inside: {
+        interpolation: se,
+        string: /[^]+/
+      }
+    },
+    {
+      pattern: /<<[-~]?([a-z_]\w*)\n(?:.*\n)*?[ 	]*\1/gi,
+      alias: "heredoc-string",
+      greedy: !0,
+      inside: {
+        delimiter: {
+          pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
+          inside: {
+            symbol: /\w+/,
+            punctuation: /^<<[-~]?/
+          }
+        },
+        interpolation: se,
+        string: /[^]+/
+      }
+    },
+    {
+      pattern: /<<[-~]?'([a-z_]\w*)'\n(?:.*\n)*?[ 	]*\1/gi,
+      alias: "heredoc-string",
+      greedy: !0,
+      inside: {
+        delimiter: {
+          pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
+          inside: {
+            symbol: /\w+/,
+            punctuation: /^<<[-~]?'|'$/
+          }
+        },
+        string: /[^]+/
+      }
+    }
+  ],
+  "command-literal": [
+    {
+      pattern: RegExp("%x" + ct, "g"),
+      greedy: !0,
+      inside: {
+        interpolation: se,
+        command: {
+          pattern: /[^]+/,
+          alias: "string"
+        }
+      }
+    },
+    {
+      pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\[^]|[^\\`#\n])*`/g,
+      greedy: !0,
+      inside: {
+        interpolation: se,
+        command: {
+          pattern: /[^]+/,
+          alias: "string"
+        }
+      }
+    }
+  ],
+  "class-name": {
+    pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
+    lookbehind: !0,
+    inside: {
+      punctuation: /[.\\]/
+    }
+  },
+  "regex-literal": [
+    {
+      pattern: RegExp(`%r${ct}[egimnosux]{0,6}`, "g"),
+      greedy: !0,
+      inside: {
+        interpolation: se,
+        regex: /[^]+/
+      }
+    },
+    {
+      pattern: /(^|[^/])\/(?!\/)(?:\[[^\n\]]+\]|\\.|[^\\\n/[])+\/[egimnosux]{0,6}(?=\s*(?:$|[\n,.;})#]))/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        interpolation: se,
+        regex: /[^]+/
+      }
+    }
+  ],
+  variable: /[@$]+(?!\d)\w+(?:[?!]|\b)/,
+  symbol: [
+    {
+      pattern: RegExp("(^|[^:]):" + nn, "g"),
+      lookbehind: !0,
+      greedy: !0
+    },
+    {
+      pattern: RegExp(`([
+{(,][ 	]*)` + nn + "(?=:(?!:))", "g"),
+      lookbehind: !0,
+      greedy: !0
+    }
+  ],
+  "method-definition": {
+    pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
+    lookbehind: !0,
+    inside: {
+      function: /\b\w+$/,
+      keyword: /^self\b/,
+      "class-name": /^\w+/,
+      punctuation: /\./
+    }
+  },
+  keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|f?or|if|in|include|module|new|next|nil|not|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|[tw]hen|throw|undef|unless|until|while|yield)\b/,
+  boolean: q,
+  builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
+  constant: /\b[A-Z][A-Z\d_]*(?:[?!]|\b)/,
+  number: Mn,
+  "double-colon": {
+    pattern: /::/,
+    alias: "punctuation"
+  },
+  operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[%&|^!=<>/*+-])=?|[?:]/,
+  punctuation: /[()[\]{}.,;]/
+};
+_.sql = {
+  comment: /\/\*[^]*?\*\/|(?:--|\/\/|#).*/,
+  variable: [
+    {
+      pattern: /@(["'`])(?:\\[^]|(?!\1)[^\\])+\1/g,
+      greedy: !0
+    },
+    /@[\w.$]+/
+  ],
+  string: {
+    pattern: /(^|[^@\\])(["'])(?:\\[^]|(?!\2)[^\\]|\2\2)*\2/g,
+    lookbehind: !0,
+    greedy: !0
+  },
+  identifier: {
+    pattern: /(^|[^@\\])`(?:\\[^]|[^\\`]|``)*`/g,
+    lookbehind: !0,
+    greedy: !0,
+    inside: {
+      punctuation: /^`|`$/
+    }
+  },
+  function: /\b(?:avg|count|first|format|last|[lu]case|len|max|mi[dn]|mod|now|round|sum)(?=\s*\()/i,
+  // Should we highlight user defined functions too?
+  keyword: /\b(?:action|add|after|algorithm|alter|analyze|any|apply|asc?|authorization|auto_increment|backup|bdb|begin|berkeleydb|bigint|binary|bit|blob|bool|boolean|break|browse|[br]tree|bulk|by|c?all|cascaded?|case|chain|character|charset|check(?:point)?|close|clustered|coalesce|collate|columns?|comment|commit(?:ted)?|compute|connect|consistent|constraint|contains(?:table)?|continue|convert|create|cross|current(?:_date|_time|_timestamp|_user)?|cursor|cycle|data(?:bases?)?|date(?:time)?|day|dbcc|deallocate|dec|decimal|declare|default|definer|delayed|delete|delimiters?|deny|desc|describe|deterministic|disable|discard|disk|distinct|distinctrow|distributed|do|double|drop|dummy|dump(?:file)?|duplicate|else(?:if)?|enable|enclosed|end|engine|enum|errlvl|errors|escaped?|except|exec(?:ute)?|exists|exit|explain|extended|fetch|fields|file|fillfactor|first|fixed|float|following|for each row|for|force|foreign|freetexttable|freetext|from|full|function|geometry(?:collection)?|global|goto|grant|group|handler|hash|having|holdlock|hour|identity(?:col|_insert)?|if|ignore|import|index|infile|inner|innodb|inout|insert|integer|intersect|interval|into?|invoker|isolation|iterate|join|keys?|kill|language|last|leave|left|level|limit|lineno|lines|linestring|load|local|lock|long(?:blob|text)|loop|matched|match|(?:medium|tiny)(?:blob|int|text)|merge|middleint|minute|mode|modifies|modify|month|multi(?:linestring|point|polygon)|national|natural|n?char|next|no|nonclustered|nullif|numeric|off?|offsets?|on|open(?:datasource|query|rowset)?|optimize|option(?:ally)?|order|out(?:er|file)?|over|partial|partition|percent|pivot|plan|point|polygon|preceding|precision|prepare|prev|primary|print|privileges|proc(?:edure)?|public|purge|quick|raiserror|reads?|real|reconfigure|references|release|rename|repeat(?:able)?|replace|replication|require|resignal|restore|restrict|returning|returns?|revoke|right|rollback|routine|row(?:count|guidcol|s)?|rule|savepoint|save|schema|second|select|serializable|serial|session_user|session|setuser|set|share|show|shutdown|simple|smallint|snapshot|some|soname|sql|start(?:ing)?|statistics|status|striped|system_user|tables?|tablespace|temp(?:orary|table)?|terminated|textsize|text|[tw]hen|timestamp|time|top?|transactions?|tran|trigger|truncate|tsequal|types?|unbounded|uncommitted|undefined|union|unique|unlock|unpivot|unsigned|updatetext|update|usage|user?|using|values?|var(?:binary|char|character|ying)|view|waitfor|warnings|where|while|with(?: rollup|in)?|work|writetext|write|year)\b/i,
+  boolean: /\b(?:false|true|null)\b/i,
+  number: /\b0x[a-f\d]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
+  operator: /[=%~^/*+-]|&&?|\|\|?|!=?|<<|<=?>?|>[>=]?|\b(?:and|between|div|[ir]?like|in|is|not|x?or|regexp|sounds like)\b/i,
+  punctuation: /[()[\].,;`]/
+};
+_.wasm = {
+  comment: /\(;[^]*?;\)|;;.*/,
+  string: {
+    pattern: /"(?:\\[^]|[^\\"])*"/g,
+    greedy: !0
+  },
+  keyword: [
+    {
+      pattern: /\b(?:align|offset)=/,
+      inside: {
+        operator: /=/
+      }
+    },
+    {
+      pattern: /\b(?:(?:[fi]32|[fi]64)(?:\.(?:abs|a[dn]d|ceil|clz|const|convert_[su]\/i(?:32|64)|copysign|ctz|demote\/f64|div(?:_[su])?|eqz?|extend_[su]\/i32|floor|ge(?:_[su])?|gt(?:_[su])?|le(?:_[su])?|load(?:(?:8|16|32)_[su])?|lt(?:_[su])?|max|min|mul|neg?|nearest|popcnt|promote\/f32|reinterpret\/[fi](?:32|64)|rem_[su]|rot[lr]|shl|shr_[su]|sqrt|store(?:8|16|32)?|sub|trunc(?:_[su]\/f(?:32|64))?|wrap\/i64|x?or))?|memory\.(?:grow|size))\b/,
+      inside: {
+        punctuation: /\./
+      }
+    },
+    /\b(?:anyfunc|block|br(?:_if|_table)?|call(?:_indirect)?|data|drop|elem|else|end|export|func|get_(?:global|local)|global|if|import|local|loop|memory|module|mut|nop|offset|param|result|return|select|set_(?:global|local)|start|table|tee_local|then|type|unreachable)\b/
+  ],
+  variable: /\$[\w!#$%&'*./:<=>?@\\^`|~+-]+/,
+  number: /[+-]?\b(?:\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?|0x[a-fA-F\d](?:_?[a-fA-F\d])*(?:\.[a-fA-F\d](?:_?[\da-fA-D])*)?(?:[pP][+-]?\d(?:_?\d)*)?)\b|\binf\b|\bnan(?::0x[a-fA-F\d](?:_?[\da-fA-D])*)?\b/,
+  punctuation: /[()]/
+};
+var me = (e, t) => {
+  for (var n = 0; n < t; n++)
+    e = e.replace(/<self>/g, `(?:${e})`);
+  return e.replace(/<self>/g, "[]");
+}, F = (e, t) => e.replace(/<(\d+)>/g, (n, s) => `(?:${t[+s]})`), O = (e, t, n) => RegExp(F(e, t), n), Et = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/, ge = _.cpp = ae("c", {
+  "class-name": [
+    {
+      pattern: RegExp(`(\\b(?:class|concept|enum|struct|typename)\\s+)(?!${Et.source})\\w+`),
+      lookbehind: !0
+    },
+    // This is intended to capture the class name of method implementations like:
+    //   void foo::bar() const {}
+    // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
+    // it starts with an uppercase letter. This approximation should give decent results.
+    /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,
+    // This will capture the class name before destructors like:
+    //   Foo::~Foo() {}
+    /\b[a-z_]\w*(?=\s*::\s*~\w+\s*\()/i,
+    // This also intends to capture the class name of method implementations but here the class has template
+    // parameters, so it can't be a namespace (until C++ adds generic namespaces).
+    /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
+  ],
+  keyword: Et,
+  number: {
+    pattern: /(?:\b0b[01']+|\b0x(?:[a-f\d']+(?:\.[a-f\d']*)?|\.[a-f\d']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/gi,
+    greedy: !0
+  },
+  operator: /->|--|\+\+|&&|\|\||[?:~]|<=>|>>=?|<<=?|[%&|^!=<>/*+-]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|x?or|x?or_eq)\b/,
+  boolean: q
+});
+$(ge, "string", {
+  module: {
+    // https://en.cppreference.com/w/cpp/language/modules
+    pattern: O(
+      `(\\b(?:import|module)\\s+)(?:"(?:\\\\[\\s\\S]|[^\\\\
+"])*"|<[^<>
+]*>|<0>(?:\\s*:\\s*<0>)?|:\\s*<0>)`,
+      [`\\b(?!${Et.source})\\w+(?:\\s*\\.\\s*\\w+)*\\b`],
+      "g"
+    ),
+    lookbehind: !0,
+    greedy: !0,
+    inside: {
+      string: /^[<"][^]+/,
+      operator: /:/,
+      punctuation: /\./
+    }
+  },
+  "raw-string": {
+    pattern: /R"([^()\\ ]{0,16})\([^]*?\)\1"/g,
+    greedy: !0,
+    alias: "string"
+  }
+});
+$(ge, "keyword", {
+  "generic-function": {
+    pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
+    inside: {
+      function: /^\w+/,
+      generic: {
+        pattern: /<[^]+/,
+        alias: "class-name",
+        inside: ge
+      }
+    }
+  }
+});
+$(ge, "operator", {
+  "double-colon": {
+    pattern: /::/,
+    alias: "punctuation"
+  }
+});
+var Fn = Object.assign({}, ge);
+$(ge, "class-name", {
+  // the base clause is an optional list of parent classes
+  // https://en.cppreference.com/w/cpp/language/class
+  "base-clause": {
+    pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/g,
+    lookbehind: !0,
+    greedy: !0,
+    inside: Fn
+  }
+});
+$(Fn, "double-colon", {
+  // All untokenized words that are not namespaces should be class names
+  "class-name": /\b[a-z_]\w*\b(?!\s*::)/i
+});
+_.go = {
+  comment: re(),
+  char: {
+    pattern: /'(?:\\.|[^\\\n']){0,10}'/g,
+    greedy: !0
+  },
+  string: {
+    pattern: /(^|[^\\])"(?:\\.|[^\\\n"])*"|`[^`]*`/g,
+    lookbehind: !0,
+    greedy: !0
+  },
+  keyword: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,
+  boolean: /\b(?:_|false|true|iota|nil)\b/,
+  function: /\b\w+(?=\()/,
+  number: [
+    // binary and octal integers
+    /\b0(?:b[01_]+|o[0-7_]+)i?\b/i,
+    // hexadecimal integers and floats
+    /\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i,
+    // decimal integers and floats
+    /(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i
+  ],
+  operator: /--|\+\+|&&|\|\||&\^=?|<-|<<=?|>>=?|[%&|^!=<>/*+-]=?|:=|\.{3}/,
+  punctuation: te,
+  builtin: /\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/
+};
+var dt = {};
+_.js = _.javascript = Object.assign(dt, {
+  "doc-comment": {
+    pattern: /\/\*\*(?!\/)[^]*?(?:\*\/|$)/g,
+    greedy: !0,
+    alias: "comment",
+    inside: "jsdoc"
+  },
+  comment: re(),
+  hashbang: {
+    pattern: /^#!.*/g,
+    greedy: !0,
+    alias: "comment"
+  },
+  "template-string": {
+    pattern: /`(?:\\[^]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})*\}|(?!\$\{)[^\\`])*`/g,
+    greedy: !0,
+    inside: {
+      "template-punctuation": {
+        pattern: /^`|`$/,
+        alias: "string"
+      },
+      interpolation: {
+        pattern: /((?:^|[^\\])(?:\\\\)*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})*\}/,
+        lookbehind: !0,
+        inside: {
+          "interpolation-punctuation": {
+            pattern: /^\$\{|\}$/,
+            alias: "punctuation"
+          },
+          [j]: dt
+        }
+      },
+      string: /[^]+/
+    }
+  },
+  "string-property": {
+    pattern: /((?:^|[,{])[ 	]*)(["'])(?:\\[^]|(?!\2)[^\\\n])*\2(?=\s*:)/mg,
+    lookbehind: !0,
+    greedy: !0,
+    alias: "property"
+  },
+  string: Tt(),
+  regex: {
+    pattern: /((?:^|[^$\w\xa0-\uffff"'`.)\]\s]|\b(?:return|yield))\s*)\/(?:(?:\[(?:\\.|[^\\\n\]])*\]|\\.|[^\\\n/[])+\/[dgimyus]{0,7}|(?:\[(?:\\.|[^\\\n[\]]|\[(?:\\.|[^\\\n[\]]|\[(?:\\.|[^\\\n[\]])*\])*\])*\]|\\.|[^\\\n/[])+\/[dgimyus]{0,7}v[dgimyus]{0,7})(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?!\/\*|[^()[\]{}.,:;?`\n%&|^!=<>/*+-]))/g,
+    lookbehind: !0,
+    greedy: !0,
+    inside: {
+      "regex-flags": /\w+$/,
+      "regex-delimiter": /^\/|\/$/,
+      "regex-source": {
+        pattern: /.+/,
+        alias: "language-regex",
+        inside: "regex"
+      }
+    }
+  },
+  "class-name": [
+    {
+      pattern: /(\b(?:class|extends|implements|instanceof|interface|new)\s+)(?!\d)(?:(?!\s)[$\w.\xa0-\uffff])+/,
+      lookbehind: !0,
+      inside: {
+        punctuation: /\./
+      }
+    },
+    {
+      pattern: /(^|[^$\w\xa0-\uffff]|\s)(?![a-z\d])(?:(?!\s)[$\w\xa0-\uffff])+(?=\.(?:constructor|prototype)\b)/,
+      lookbehind: !0
+    }
+  ],
+  // This must be declared before keyword because we use "function" inside the look-forward
+  "function-variable": {
+    pattern: /#?(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^)]*\))*\)|(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+)\s*=>))/,
+    alias: "function",
+    inside: {
+      "maybe-class-name": /^[A-Z].*/
+    }
+  },
+  parameter: [
+    /(function(?:\s+(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
+    /(^|[^$\w\xa0-\uffff]|\s)(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+(?=\s*=>)/,
+    /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+    /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|continue|default|do|else|finally|for|if|return|switch|throw|try|while|yield|class|const|debugger|delete|enum|extends|function|[gs]et|export|from|import|implements|in|instanceof|interface|let|new|null|of|package|private|protected|public|static|super|this|typeof|undefined|var|void|with)(?![$\w\xa0-\uffff]))(?:(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/
+  ].map((e) => ({
+    pattern: e,
+    lookbehind: !0,
+    inside: dt
+  })),
+  constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/,
+  keyword: [
+    {
+      pattern: /(^|[^.]|\.{3}\s*)\b(?:as|assert(?=\s*\{)|export|from(?!\s*[^\s"'])|import)\b/,
+      alias: "module",
+      lookbehind: !0
+    },
+    {
+      pattern: /(^|[^.]|\.{3}\s*)\b(?:await|break|case|catch|continue|default|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/,
+      alias: "control-flow",
+      lookbehind: !0
+    },
+    {
+      pattern: /(^|[^.]|\.{3}\s*)\b(?:async(?!\s*[^\s($\w\xa0-\uffff])|class|const|debugger|delete|enum|extends|function|[gs]et(?!\s*[^\s#[$\w\xa0-\uffff])|implements|in|instanceof|interface|let|new|null|of|package|private|protected|public|static|super|this|typeof|undefined|var|void|with)\b/,
+      lookbehind: !0
+    }
+  ],
+  boolean: q,
+  // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
+  function: {
+    pattern: /#?(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+    inside: {
+      "maybe-class-name": /^[A-Z].*/
+    }
+  },
+  number: {
+    pattern: /(^|[^$\w])(?:NaN|Infinity|0[bB][01]+(?:_[01]+)*n?|0[oO][0-7]+(?:_[0-7]+)*n?|0[xX][a-fA-F\d]+(?:_[a-fA-F\d]+)*n?|\d+(?:_\d+)*n|(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?)(?![$\w])/,
+    lookbehind: !0
+  },
+  "literal-property": {
+    pattern: /([\n,{][ 	]*)(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+(?=\s*:)/,
+    lookbehind: !0,
+    alias: "property"
+  },
+  operator: [
+    {
+      pattern: /=>/,
+      alias: "arrow"
+    },
+    /--|\+\+|(?:\*\*|&&|\|\||[!=]=|>>>?|<<|[%&|^!=<>/*+-]|\?\?)=?|\.{3}|\?(?!\.)|~|:/
+  ],
+  "property-access": {
+    pattern: /(\.\s*)#?(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+/,
+    lookbehind: !0,
+    inside: {
+      "maybe-class-name": /^[A-Z].*/
+    }
+  },
+  "maybe-class-name": {
+    pattern: /(^|[^$\w\xa0-\uffff])[A-Z][$\w\xa0-\uffff]+/,
+    lookbehind: !0
+  },
+  punctuation: /\?\.|[()[\]{}.,:;]/
+});
+var Un = (e) => (t, n) => {
+  for (var s = St(e), l = "", u = [], f = 0, E = Se(t, n), y = 0, v = E.length, g = 0; y < v; ) {
+    var m = E[y++], p = m.length, c = m.type;
+    c && c.slice(0, 6) != "ignore" ? (u[f++] = [g, m], l += " ".repeat(p)) : l += t.slice(g, g + p), g += p;
+  }
+  var b = 0, g = 0, a = (d) => {
+    for (var o = 0; b < f && o < d.length; o++) {
+      var i = d[o], h = i.content;
+      if (Array.isArray(h))
+        a(h);
+      else {
+        for (var k = i.length, I = [], w, S, x = 0, T = g; ([w, S] = u[b], w >= g && w < g + k) && (T < w && (I[x++] = l.slice(T, w)), T = w + S.length, I[x++] = S, ++b != f); )
+          ;
+        g += k, x && (T < g && (I[x++] = l.slice(T, g)), h ? i.content = I : (d.splice(o, 1, ...I), o += x - 1));
+      }
+    }
+  }, r = s ? ke(l, s) : [l];
+  return a(r), r;
+}, Bn = _.js, xt = Bn["template-string"], Da = xt.pattern.source, Fa = xt.inside.interpolation.pattern, de = (e, t) => ({
+  pattern: RegExp("((?:" + t + ")\\s*)" + Da, "g"),
+  lookbehind: !0,
+  greedy: !0,
+  inside: {
+    "template-punctuation": {
+      pattern: /^`|`$/,
+      alias: "string"
+    },
+    ["language-" + e]: {
+      pattern: /[^]+/,
+      inside: {
+        interpolation: {
+          pattern: Fa,
+          lookbehind: !0,
+          alias: "language-javascript",
+          inside: {
+            "interpolation-punctuation": {
+              pattern: /^\$\{|\}$/,
+              alias: "punctuation"
+            },
+            [j]: "js"
+          }
+        },
+        [J]: Un(e)
+      }
+    }
+  }
+});
+Bn["template-string"] = [
+  // styled-jsx:
+  //   css`a { color: #25F; }`
+  // styled-components:
+  //   styled.h1`color: red;`
+  de("css", "\\b(?:styled(?:\\([^)]*\\))?(?:\\s*\\.\\s*\\w+(?:\\([^)]*\\))*)*|css(?:\\s*\\.\\s*(?:global|resolve))?|createGlobalStyle|keyframes)"),
+  // html`<p></p>`
+  // div.innerHTML = `<p></p>`
+  de("html", "\\bhtml|\\.\\s*(?:inner|outer)HTML\\s*\\+?="),
+  // svg`<path fill="#fff" d="M55.37 ..."/>`
+  de("svg", "\\bsvg"),
+  // md`# h1`, markdown`## h2`
+  de("markdown", "\\b(?:markdown|md)"),
+  // gql`...`, graphql`...`, graphql.experimental`...`
+  de("graphql", "\\b(?:gql|graphql(?:\\s*\\.\\s*experimental)?)"),
+  // sql`...`
+  de("sql", "\\bsql"),
+  // vanilla template string
+  xt
+];
+var Fe = "\\s|//.*(?!.)|/\\*(?:[^*]|\\*(?!/))*\\*/", yt = "\\{(?:[^{}]|\\{(?:[^{}]|\\{[^}]*\\})*\\})*\\}", an = F("\\{<0>*\\.{3}(?:[^{}]|<1>)*\\}", [Fe, yt]), rn = (e) => e && (!e.type || e.type == "plain-text"), Ua = (e, t, n) => {
+  for (var s = 0, l = [], u = 0; s < e.length; s++) {
+    var f = e[s], E = f.length, y = f.type, v = !y, m, p, c, b, g;
+    y && (g = f.content, y == "tag" ? (c = g[0].length, p = g[2] ? t.substr(n + c, g[1].length) : "", c > 1 ? u && l[u - 1][0] == p && u-- : g[g.length - 1].length < 2 && (l[u++] = [p, 0])) : u && y == "punctuation" ? (m = l[u - 1], g == "{" ? m[1]++ : m[1] && g == "}" ? m[1]-- : v = !"}()[]".includes(g)) : v = !0), v && u && !l[u - 1][1] && (c = n, rn(e[s + 1]) && (E += e[s + 1].length, e.splice(s + 1, 1)), rn(e[s - 1]) && (c -= e[--s].length, e.splice(s, 1)), b = t.slice(c, n + E), e[s] = new ue("plain-text", b, b)), n += E;
+  }
+  return e;
+}, Gn = (e, t) => {
+  $(_[t] = e = Qe(e), "regex", {
+    tag: {
+      pattern: O(
+        `</?(?:(?!\\d)[^\\s/=><%]+(?:<0>(?:<0>*(?:[^\\s<>/={*]+(?:<0>*=<0>*(?!\\s)(?:"[^"]*"|'[^']*'|<1>)?|(?=[\\s/>]))|<2>))+)?<0>*/?)?>`,
+        [Fe, yt, an],
+        "g"
+      ),
+      greedy: !0,
+      inside: {
+        punctuation: /^<\/?|\/?>$/,
+        tag: {
+          pattern: /^[^\s/]+/,
+          inside: {
+            namespace: /^[^:]+:/,
+            "class-name": /^[A-Z]\w*(?:\.[A-Z]\w*)*$/
+          }
+        },
+        script: {
+          // Allow for two levels of nesting
+          pattern: O("(=<0>*)<1>", [Fe, yt]),
+          lookbehind: !0,
+          alias: t = "language-" + t,
+          inside: e
+        },
+        spread: {
+          pattern: RegExp(an),
+          alias: t,
+          inside: e
+        },
+        "attr-value": {
+          pattern: O(`(=<0>*)(?:"[^"]*"|'[^']*')`, [Fe]),
+          lookbehind: !0,
+          inside: {
+            punctuation: /^["']|["']$/
+          }
+        },
+        comment: e.comment,
+        "attr-equals": /=/,
+        "attr-name": {
+          pattern: /\S+/,
+          inside: {
+            namespace: /^[^:]+:/
+          }
+        }
+      }
+    }
+  }), e[J] = (n, s) => Ua(Se(n, s), n, 0);
+};
+Gn(_.js, "jsx");
+_.lua = {
+  comment: /^#!.+|--(?:\[(=*)\[[^]*?\]\1\]|.*)/m,
+  // \z may be used to skip the following space
+  string: {
+    pattern: /(["'])(?:(?!\1)[^\\\n]|\\z\s|\\[^z])*\1|\[(=*)\[[^]*?\]\2\]/g,
+    greedy: !0
+  },
+  number: /\b0x[a-f\d]+(?:\.[a-f\d]*)?(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|(?:\.\d*)?(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i,
+  keyword: /\b(?:and|break|do|else|elseif|end|false|true|f?or|function|goto|if|in|local|nil|not|repeat|return|then|until|while)\b/,
+  function: /(?!\d)\w+(?=\s*(?:[({]))/,
+  // Match ".." but don't break "..."
+  operator: {
+    pattern: /[%&|^#*+-]|\/\/?|<[<=]?|>[>=]?|[=~]=?|(^|[^.])\.\.(?!\.)/,
+    lookbehind: !0
+  },
+  punctuation: /[()[\]{},;]|\.+|:+/
+};
+var Ce = "(?:\\((?:\\\\[\\s\\S]|[^\\\\()])*\\)|\\{(?:\\\\[\\s\\S]|[^\\\\{}])*\\}|\\[(?:\\\\[\\s\\S]|[^\\\\[\\]])*\\]|<(?:\\\\[\\s\\S]|[^\\\\<>])*>)", sn = "(?![a-zA-Zd])\\s*(?:([^a-zA-Zd\\s{([<])(?:\\\\[^]|(?!\\1)[^\\\\])*\\1|([a-zA-Zd])(?:\\\\[^]|(?!\\2)[^\\\\])*\\2";
+_.perl = {
+  comment: [
+    {
+      // POD
+      pattern: /(^\s*)=\w[^]*?=cut.*/mg,
+      lookbehind: !0,
+      greedy: !0
+    },
+    {
+      pattern: /(^|[^\\$])#.*/g,
+      lookbehind: !0,
+      greedy: !0
+    }
+  ],
+  // TODO Could be nice to handle Heredoc too.
+  string: {
+    pattern: RegExp(
+      `\\bq[qwx]?${sn}|${Ce})|("|\`)(?:\\\\[^]|(?!\\3)[^\\\\])*\\3|'(?:\\\\.|[^\\\\
+'])*'`,
+      "g"
+    ),
+    greedy: !0
+  },
+  regex: [
+    {
+      pattern: RegExp(
+        `\\b(?:m|qr)${sn}|${Ce})[msixpodualngc]*`,
+        "g"
+      ),
+      greedy: !0
+    },
+    // The lookbehinds prevent -s from breaking
+    {
+      pattern: RegExp(
+        `(^|[^-])\\b(?:s|tr|y)(?![a-zA-Zd])\\s*(?:([^a-zA-Zd\\s{([<])(?:\\\\[^]|(?!\\2)[^\\\\])*\\2(?:\\\\[^]|(?!\\2)[^\\\\])*\\2|([a-zA-Zd])(?:\\\\[^]|(?!\\3)[^\\\\])*\\3(?:\\\\[^]|(?!\\3)[^\\\\])*\\3|${Ce}\\s*${Ce})[msixpodualngcer]*`,
+        "g"
+      ),
+      lookbehind: !0,
+      greedy: !0
+    },
+    // /.../
+    // The look-ahead tries to prevent two divisions on
+    // the same line from being highlighted as regex.
+    // This does not support multi-line regex.
+    {
+      pattern: /\/(?:\\.|[^\\\n/])*\/[msixpodualngc]*(?=\s*(?:$|[\n,.;})&|*~<>!?^+-]|(?:and|cmp|eq|[gl][et]|ne|not|x|x?or)\b))/g,
+      greedy: !0
+    }
+  ],
+  // FIXME Not sure about the handling of ::, ', and #
+  variable: /[&*$@%](?:\{\^[A-Z]+\}|\^[A-Z_]|#?(?=\{)|#?(?:(?:::)*'?(?!\d)[$\w]+(?![$\w]))+(?:::)*|\d+)|(?!%=)[$@%][!"#$%&'*,./:;<=>?@()[\]{}||^_`|~+-]/,
+  filehandle: {
+    // <>, <FOO>, _
+    pattern: /<(?![<=])\S*?>|\b_\b/,
+    alias: "symbol"
+  },
+  "v-string": {
+    // v1.2, 1.2.3
+    pattern: /v\d+(?:\.\d+)*|\d+(?:\.\d+){2,}/,
+    alias: "string"
+  },
+  function: {
+    pattern: /(\bsub[ 	]+)\w+/,
+    lookbehind: !0
+  },
+  keyword: /\b(?:any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|return|say|state|sub|switch|undef|unless|until|use|when|while)\b/,
+  number: /\b(?:0x[a-fA-F\d](?:_?[a-fA-F\d])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)\b/,
+  operator: /-[rwxoRWXOezsfdlpSbctugkTBMAC]\b|->|=>|=~|~~|<=>?|!~|--|\+\+|(?:\*\*|\/\/|&&|\|\||<<|>>|[~%&|^!=<>/*+-])=?|\.(?:=|\.\.?)?|[\\?]|\bx(?:=|\b)|\b(?:and|cmp|eq|[gl][et]|ne|not|x?or)\b/,
+  punctuation: /[()[\]{},:;]/
+};
+var on = {
+  "format-spec": {
+    pattern: /(:)[^(){}:]+(?=\}$)/,
+    lookbehind: !0
+  },
+  "conversion-option": {
+    pattern: /![sra](?=[:}]$)/,
+    alias: "punctuation"
+  }
+};
+on[j] = _.py = _.python = {
+  comment: {
+    pattern: /#.*/g,
+    greedy: !0
+  },
+  "string-interpolation": {
+    pattern: /(?:fr?|rf)(?:("""|''')[^]*?\1|(["'])(?:\\[^]|(?!\2)[^\\\n])*\2)/gi,
+    greedy: !0,
+    inside: {
+      interpolation: {
+        // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
+        pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})*\}/,
+        lookbehind: !0,
+        inside: on
+      },
+      string: /[^]+/
+    }
+  },
+  "triple-quoted-string": {
+    pattern: /(?:br?|rb?|u)?("""|''')[^]*?\1/gi,
+    greedy: !0,
+    alias: "string"
+  },
+  string: {
+    pattern: /(?:br?|rb?|u)?(["'])(?:\\[^]|(?!\1)[^\\\n])*\1/gi,
+    greedy: !0
+  },
+  function: {
+    pattern: /((?:^|\s)def[ 	]+)(?!\d)\w+(?=\s*\()/,
+    lookbehind: !0
+  },
+  "class-name": {
+    pattern: /(\bclass\s+)\w+/i,
+    lookbehind: !0
+  },
+  decorator: {
+    pattern: /(^[ 	]*)@\w+(?:\.\w+)*/m,
+    lookbehind: !0,
+    alias: "annotation punctuation",
+    inside: {
+      punctuation: /\./
+    }
+  },
+  keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|de[fl]|elif|else|except|exec|finally|f?or|from|global|i[fns]|import|lambda|match|nonlocal|not|pass|print|raise|return|try|while|with|yield)\b/,
+  builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|ma[px]|memoryview|min|next|object|oct|open|ord|pow|property|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|x?range|zip)\b/,
+  boolean: /\b(?:False|True|None)\b/,
+  number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f\d])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+  operator: /!=|:=|\*\*=?|\/\/=?|<>|>>|<<|[%=<>/*+-]=?|[&|^~]/,
+  punctuation: te
+};
+var Ba = me("/\\*(?:[^*/]|\\*(?!/)|/(?!\\*)|<self>)*\\*/", 2), ln = {
+  pattern: /b?"(?:\\[^]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/g,
+  greedy: !0
+}, cn = {
+  "closure-punctuation": {
+    pattern: /^\||\|$/,
+    alias: "punctuation"
+  }
+};
+cn[j] = _.rust = {
+  comment: {
+    pattern: RegExp("//.*|" + Ba, "g"),
+    greedy: !0
+  },
+  string: ln,
+  char: {
+    pattern: /b?'(?:\\(?:x[0-7][a-fA-F\d]|u\{(?:[a-fA-F\d]_*){1,6}\}|.)|[^\\\n	'])'/g,
+    greedy: !0
+  },
+  attribute: {
+    pattern: /#!?\[(?:[^[\]"]|"(?:\\[^]|[^\\"])*")*\]/g,
+    greedy: !0,
+    alias: "attr-name",
+    inside: {
+      string: ln
+    }
+  },
+  // Closure params should not be confused with bitwise OR |
+  "closure-params": {
+    pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/g,
+    lookbehind: !0,
+    greedy: !0,
+    inside: cn
+  },
+  "lifetime-annotation": {
+    pattern: /'\w+/,
+    alias: "symbol"
+  },
+  "fragment-specifier": {
+    pattern: /(\$\w+:)[a-z]+/,
+    lookbehind: !0,
+    alias: "punctuation"
+  },
+  variable: /\$\w+/,
+  "function-definition": {
+    pattern: /(\bfn\s+)\w+/,
+    lookbehind: !0,
+    alias: "function"
+  },
+  "type-definition": {
+    pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
+    lookbehind: !0,
+    alias: "class-name"
+  },
+  "module-declaration": [
+    {
+      pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
+      lookbehind: !0,
+      alias: "namespace"
+    },
+    {
+      pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
+      lookbehind: !0,
+      alias: "namespace",
+      inside: {
+        punctuation: /::/
+      }
+    }
+  ],
+  // https://github.com/rust-lang/reference/blob/master/src/keywords.md
+  // primitives and str
+  // https://doc.rust-lang.org/stable/rust-by-example/primitives.html
+  keyword: /\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield|bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/,
+  // functions can technically start with an upper-case letter, but this will introduce a lot of false positives
+  // and Rust's naming conventions recommend snake_case anyway.
+  // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html
+  function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
+  macro: {
+    pattern: /\b\w+!/,
+    alias: "property"
+  },
+  constant: /\b[A-Z_][A-Z_\d]+\b/,
+  "class-name": /\b[A-Z]\w*\b/,
+  namespace: {
+    pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
+    inside: {
+      punctuation: /::/
+    }
+  },
+  // Hex, oct, bin, dec numbers with visual separators and type suffix
+  number: /\b(?:0x[a-fA-F\d](?:_?[a-fA-F\d])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
+  boolean: q,
+  punctuation: /->|\.\.=|\.{1,3}|::|[()[\]{},:;]/,
+  operator: /&&|\|\||=>|>>=?|<<=?|[%&|^!=<>/*+-]=?|[@?]/
+};
+var dn = _.swift = {
+  comment: {
+    // Nested comments are supported up to 2 levels
+    pattern: /\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\//g,
+    greedy: !0
+  },
+  "string-literal": [
+    // https://docs.swift.org/swift-book/LanguageGuide/StringsAndCharacters.html
+    {
+      pattern: /(^|[^"#])(?:"(?:\\(?:\((?:[^()]|\([^)]*\))*\)|[^(])|[^\\\n"])*"|"""(?:\\(?:\((?:[^()]|\([^)]*\))*\)|[^(])|[^\\"]|"(?!""))*""")(?!["#])/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        interpolation: {
+          pattern: /(\\\()(?:[^()]|\([^()]*\))+(?=\))/,
+          lookbehind: !0
+        },
+        "interpolation-punctuation": {
+          pattern: /^\)|\\\($/,
+          alias: "punctuation"
+        },
+        punctuation: /\\(?=\n)/,
+        string: /[^]+/
+      }
+    },
+    {
+      pattern: /(^|[^"#])(#+)(?:"(?:\\(?:#+\((?:[^()]|\([^)]*\))*\)|[^#])|[^\\\n])*?"|"""(?:\\(?:#+\((?:[^()]|\([^)]*\))*\)|[^#])|[^\\])*?""")\2/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        interpolation: {
+          pattern: /(\\#+\()(?:[^()]|\([^()]*\))+(?=\))/,
+          lookbehind: !0
+        },
+        "interpolation-punctuation": {
+          pattern: /^\)|\\#+\($/,
+          alias: "punctuation"
+        },
+        string: /[^]+/
+      }
+    }
+  ],
+  directive: {
+    // directives with conditions
+    pattern: /#(?:(?:elseif|if)\b(?:[ 	]*(?:![ 	]*)?(?:\b\w+\b(?:[ 	]*\((?:[^()]|\([^)]*\))*\))?|\((?:[^()]|\([^)]*\))*\))(?:[ 	]*(?:&&|\|\|))?)+|(?:else|endif)\b)/,
+    alias: "property",
+    inside: {
+      "directive-name": /^#\w+/,
+      boolean: q,
+      number: /\b\d+(?:\.\d+)*\b/,
+      operator: /!|&&|\|\||[<>]=?/,
+      punctuation: /[(),]/
+    }
+  },
+  literal: {
+    pattern: /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/,
+    alias: "constant"
+  },
+  "other-directive": {
+    pattern: /#\w+/,
+    alias: "property"
+  },
+  attribute: {
+    pattern: /@\w+/,
+    alias: "atrule"
+  },
+  "function-definition": {
+    pattern: /(\bfunc\s+)\w+/,
+    lookbehind: !0,
+    alias: "function"
+  },
+  label: {
+    // https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html#ID141
+    pattern: /\b(break|continue)\s+\w+|\b(?!\d)\w+(?=\s*:\s*(?:for|repeat|while)\b)/,
+    lookbehind: !0,
+    alias: "important"
+  },
+  keyword: /\b(?:Any|[Pp]rotocol|[Ss]elf|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|[gs]et|guard|higherThan|i[fns]|import|indirect|infix|init|inout|internal|isolated|lazy|lef?t|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|public|repeat|required|rethrows|return|right|safe|some|static|struct|subscript|super|switch|throws?|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/,
+  boolean: q,
+  nil: {
+    pattern: /\bnil\b/,
+    alias: "constant"
+  },
+  "short-argument": /\$\d+\b/,
+  omit: {
+    pattern: /\b_\b/,
+    alias: "keyword"
+  },
+  number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f\d_]+(?:\.[a-f\dp_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
+  // A class name must start with an upper-case letter and be either 1 letter long or contain a lower-case letter.
+  "class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/,
+  function: /\b[a-z_]\w*(?=\s*\()/i,
+  constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
+  // Operators are generic in Swift. Developers can even create new operators (e.g. +++).
+  // https://docs.swift.org/swift-book/ReferenceManual/zzSummaryOfTheGrammar.html#ID481
+  // This regex only supports ASCII operators.
+  operator: /[~?%&|^!=<>/*+-]+|\.[.~?%&|^!=<>/*+-]+/,
+  punctuation: /[()[\]{}.,:;\\]/
+};
+dn["string-literal"].forEach((e) => {
+  e.inside.interpolation.inside = dn;
+});
+_.clike = {
+  comment: re(),
+  string: Tt(),
+  "class-name": {
+    pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
+    lookbehind: !0,
+    inside: {
+      punctuation: /[.\\]/
+    }
+  },
+  keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
+  boolean: q,
+  function: /\b\w+(?=\()/,
+  number: Mn,
+  operator: /[!=]==|[!=<>]=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
+  punctuation: te
+};
+var Je = (e) => `\\b(?:${e})\\b`, zn = "bool|char|decimal|double|dynamic|float|object|s?byte|string|u?int|u?long|u?short|var|void", et = "class|enum|interface|record|struct", Hn = "add|alias|and|ascending|async|await|by|descending|from(?!\\s*[^\\s\\w])|[gls]et|global|group|into|init(?=\\s*;)|join|nameof|not|notnull|on|or|orderby|partial|remove|select|unmanaged|value|when|where|with(?=\\s*{)", Ot = "abstract|as|[bc]ase|break|catch|checked|const|continue|default|delegate|do|else|event|explicit|extern|finally|fixed|for|foreach|goto|i[fns]|implicit|internal|lock|namespace|new|null|operator|out|override|params|private|protected|public|readonly|ref|return|sealed|sizeof|stackalloc|static|switch|this|throw|try|typeof|unchecked|unsafe|using|virtual|volatile|while|yield", Vn = Je(et), Ke = RegExp(Je(zn + "|" + et + "|" + Hn + "|" + Ot)), Ga = Je(et + "|" + Hn + "|" + Ot), za = Je(zn + "|" + et + "|" + Ot), We = me("<(?:[^<>;=*/%&|^+-]|<self>)*>", 2), Ue = me("\\((?:[^()]|<self>)*\\)", 2), Q = "@?\\b(?!\\d)\\w+\\b", je = F("<0>(?:\\s*<1>)?", [Q, We]), le = F("(?!<0>)<1>(?:\\s*\\.\\s*<1>)*", [Ga, je]), Nt = "\\[\\s*(?:,\\s*)*\\]", Ha = F("<0>(?:\\s*(?:\\?\\s*)?<1>)*(?:\\s*\\?)?", [le, Nt]), Va = F("[^()[\\],;%&|^=<>/*+-]|<0>|<1>|<2>", [We, Ue, Nt]), Za = F("\\(<0>+(?:,<0>+)+\\)", [Va]), be = F("(?:<0>|<1>)(?:\\s*(?:\\?\\s*)?<2>)*(?:\\s*\\?)?", [Za, le, Nt]), W = {
+  keyword: Ke,
+  punctuation: /[()[\].,:<>?]/
+}, Zn = `'(?:\\\\.|[^
+'\\\\]|\\\\[Uux][a-fA-F\\d]{1,8})'`, qn = `"(?:\\\\.|[^\\\\
+"])*"`, qa = '@"(?:""|\\\\[\\s\\S]|[^\\\\"])*"(?!")', ne = _.dotnet = _.cs = _.csharp = ae("clike", {
+  string: [
+    {
+      pattern: O("(^|[^$\\\\])<0>", [qa], "g"),
+      lookbehind: !0,
+      greedy: !0
+    },
+    {
+      pattern: O("(^|[^@$\\\\])<0>", [qn], "g"),
+      lookbehind: !0,
+      greedy: !0
+    }
+  ],
+  "class-name": [
+    {
+      // Using static
+      // using static System.Math;
+      pattern: O("(\\busing\\s+static\\s+)<0>(?=\\s*;)", [le]),
+      lookbehind: !0,
+      inside: W
+    },
+    {
+      // Using alias (type)
+      // using Project = PC.MyCompany.Project;
+      pattern: O("(\\busing\\s+<0>\\s*=\\s*)<1>(?=\\s*;)", [Q, be]),
+      lookbehind: !0,
+      inside: W
+    },
+    {
+      // Using alias (alias)
+      // using Project = PC.MyCompany.Project;
+      pattern: O("(\\busing\\s+)<0>(?=\\s*=)", [Q]),
+      lookbehind: !0
+    },
+    {
+      // Type declarations
+      // class Foo<A, B>
+      // interface Foo<out A, B>
+      pattern: O("(\\b<0>\\s+)<1>", [Vn, je]),
+      lookbehind: !0,
+      inside: W
+    },
+    {
+      // Single catch exception declaration
+      // catch(Foo)
+      // (things like catch(Foo e) is covered by variable declaration)
+      pattern: O("(\\bcatch\\s*\\(\\s*)<0>", [le]),
+      lookbehind: !0,
+      inside: W
+    },
+    {
+      // Name of the type parameter of generic constraints
+      // where Foo : class
+      pattern: O("(\\bwhere\\s+)<0>", [Q]),
+      lookbehind: !0
+    },
+    {
+      // Casts and checks via as and is.
+      // as Foo<A>, is Bar<B>
+      // (things like if(a is Foo b) is covered by variable declaration)
+      pattern: O("(\\b(?:is(?:\\s+not)?|as)\\s+)<0>", [Ha]),
+      lookbehind: !0,
+      inside: W
+    },
+    {
+      // Variable, field and parameter declaration
+      // (Foo bar, Bar baz, Foo[,,] bay, Foo<Bar, FooBar<Bar>> bax)
+      pattern: O("\\b<0>(?=\\s+(?!<1>|with\\s*\\{)<2>(?:\\s*[=,:;{)\\]]|\\s+(?:in|when)\\b))", [be, za, Q]),
+      inside: W
+    }
+  ],
+  keyword: Ke,
+  // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#literals
+  number: /(?:\b0(?:x[a-f\d_]*[a-f\d]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[+-]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
+  operator: /[=-]>|([&|+-])\1|~|\?\?=?|>>=?|<<=?|[%&|^!=<>/*+-]=?/,
+  punctuation: /\?\.?|::|[()[\]{}.,:;]/
+});
+$(ne, "number", {
+  range: {
+    pattern: /\.\./,
+    alias: "operator"
+  }
+});
+$(ne, "punctuation", {
+  "named-parameter": {
+    pattern: O("([(,]\\s*)<0>(?=\\s*:)", [Q]),
+    lookbehind: !0,
+    alias: "punctuation"
+  }
+});
+$(ne, "class-name", {
+  namespace: {
+    // namespace Foo.Bar {}
+    // using Foo.Bar;
+    pattern: O("(\\b(?:namespace|using)\\s+)<0>(?:\\s*\\.\\s*<0>)*(?=\\s*[;{])", [Q]),
+    lookbehind: !0,
+    inside: {
+      punctuation: /\./
+    }
+  },
+  "type-expression": {
+    // default(Foo), typeof(Foo<Bar>), sizeof(int)
+    pattern: O("(\\b(?:default|sizeof|typeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<0>)+(?=\\s*\\))", [Ue]),
+    lookbehind: !0,
+    alias: "class-name",
+    inside: W
+  },
+  "return-type": {
+    // Foo<Bar> ForBar(); Foo IFoo.Bar() => 0
+    // int this[int index] => 0; T IReadOnlyList<T>.this[int index] => this[index];
+    // int Foo => 0; int Foo { get; set } = 0;
+    pattern: O("<0>(?=\\s+(?:<1>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))", [be, le]),
+    alias: "class-name",
+    inside: W
+  },
+  "constructor-invocation": {
+    // new List<Foo<Bar[]>> { }
+    pattern: O("(\\bnew\\s+)<0>(?=\\s*[[({])", [be]),
+    lookbehind: !0,
+    alias: "class-name",
+    inside: W
+  },
+  /*'explicit-implementation': {
+  	// int IFoo<Foo>.Bar => 0; void IFoo<Foo<Foo>>.Foo<T>();
+  	pattern: replace(/\b<0>(?=\.<1>)/, className, methodOrPropertyDeclaration),
+  	inside: classNameInside,
+  	alias: 'class-name'
+  },*/
+  "generic-method": {
+    // foo<Bar>()
+    pattern: O("<0>\\s*<1>(?=\\s*\\()", [Q, We]),
+    inside: {
+      function: O("^<0>", [Q]),
+      generic: {
+        pattern: RegExp(We),
+        alias: "class-name",
+        inside: W
+      }
+    }
+  },
+  "type-list": {
+    // The list of types inherited or of generic constraints
+    // class Foo<F> : Bar, IList<FooBar>
+    // where F : Bar, IList<int>
+    pattern: O(
+      "\\b((?:<0>\\s+<1>|record\\s+<1>\\s*<5>|where\\s+<2>)\\s*:\\s*)(?:<3>|<4>|<1>\\s*<5>|<6>)(?:\\s*,\\s*(?:<3>|<4>|<6>))*(?=\\s*(?:where|[{;]|=>|$))",
+      [Vn, je, Q, be, Ke.source, Ue, "\\bnew\\s*\\(\\s*\\)"]
+    ),
+    lookbehind: !0,
+    inside: {
+      "record-arguments": {
+        pattern: O("(^(?!new\\s*\\()<0>\\s*)<1>", [je, Ue], "g"),
+        lookbehind: !0,
+        greedy: !0,
+        inside: ne
+      },
+      keyword: Ke,
+      "class-name": {
+        pattern: RegExp(be, "g"),
+        greedy: !0,
+        inside: W
+      },
+      punctuation: /[(),]/
+    }
+  },
+  preprocessor: {
+    pattern: /(^[ 	]*)#.*/m,
+    lookbehind: !0,
+    alias: "property",
+    inside: {
+      // highlight preprocessor directives as keywords
+      directive: {
+        pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
+        lookbehind: !0,
+        alias: "keyword"
+      }
+    }
+  }
+});
+var Kn = qn + "|" + Zn, Wn = F(`/(?![*/])|//[^
+]*
+|/\\*(?:[^*]|\\*(?!/))*\\*/|<0>`, [Kn]), jn = me(F(`[^()"'/]|<0>|\\(<self>*\\)`, [Wn]), 2), un = "\\b(?:assembly|event|field|method|module|param|property|return|type)\\b", Ka = F("<0>(?:\\s*\\(<1>*\\))?", [le, jn]), Lt = `:[^
+}]+`, Yn = me(F(`[^()"'/]|<0>|\\(<self>*\\)`, [Wn]), 2), pn = F("\\{(?!\\{)(?:(?![}:])<0>)*<1>?\\}", [Yn, Lt]), Xn = me(F(`[^()"'/]|/(?!\\*)|/\\*(?:[^*]|\\*(?!/))*\\*/|<0>|\\(<self>*\\)`, [Kn]), 2), bn = F("\\{(?!\\{)(?:(?![}:])<0>)*<1>?\\}", [Xn, Lt]), fn = (e, t) => ({
+  interpolation: {
+    pattern: O("((?:^|[^{])(?:\\{\\{)*)<0>", [e]),
+    lookbehind: !0,
+    inside: {
+      "format-string": {
+        pattern: O("(^\\{(?:(?![}:])<0>)*)<1>(?=\\}$)", [t, Lt]),
+        lookbehind: !0,
+        inside: {
+          punctuation: /^:/
+        }
+      },
+      punctuation: /^\{|\}$/,
+      expression: {
+        pattern: /[^]+/,
+        alias: "language-csharp",
+        inside: ne
+      }
+    }
+  },
+  string: /[^]+/
+});
+$(ne, "class-name", {
+  attribute: {
+    // Attributes
+    // [Foo], [Foo(1), Bar(2, Prop = "foo")], [return: Foo(1), Bar(2)], [assembly: Foo(Bar)]
+    pattern: O("((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<0>\\s*:\\s*)?<1>(?:\\s*,\\s*<1>)*(?=\\s*\\])", [un, Ka], "g"),
+    lookbehind: !0,
+    greedy: !0,
+    inside: {
+      target: {
+        pattern: O("^<0>(?=\\s*:)", [un]),
+        alias: "keyword"
+      },
+      "attribute-arguments": {
+        pattern: O("\\(<0>*\\)", [jn]),
+        inside: ne
+      },
+      "class-name": {
+        pattern: RegExp(le),
+        inside: {
+          punctuation: /\./
+        }
+      },
+      punctuation: /[,:]/
+    }
+  }
+});
+$(ne, "string", {
+  "interpolation-string": [
+    {
+      pattern: O('(^|[^\\\\])(?:\\$@|@\\$)"(?:""|\\\\[\\s\\S]|\\{\\{|<0>|[^\\\\{"])*"', [pn], "g"),
+      lookbehind: !0,
+      greedy: !0,
+      inside: fn(pn, Yn)
+    },
+    {
+      pattern: O('(^|[^@\\\\])\\$"(?:\\\\.|\\{\\{|<0>|[^\\\\"{])*"', [bn], "g"),
+      lookbehind: !0,
+      greedy: !0,
+      inside: fn(bn, Xn)
+    }
+  ],
+  char: {
+    pattern: RegExp(Zn, "g"),
+    greedy: !0
+  }
+});
+_.graphql = {
+  comment: /#.*/,
+  description: {
+    pattern: /(?:"""(?:[^"]|"(?!""))*"""|"(?:\\.|[^\\\n"])*")(?=\s*[a-z_])/gi,
+    greedy: !0,
+    alias: "string",
+    inside: {
+      "language-markdown": {
+        pattern: /("(?!")|""")[^]+(?=\1)/,
+        lookbehind: !0,
+        inside: "md"
+      }
+    }
+  },
+  string: {
+    pattern: /"""[^]*?"""|"(?:\\.|[^\\\n"])*"/g,
+    greedy: !0
+  },
+  number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+  boolean: q,
+  variable: /\$[a-z_]\w*/i,
+  directive: {
+    pattern: /@[a-z_]\w*/i,
+    alias: "function"
+  },
+  "attr-name": {
+    pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\\n"])*")*\))?:)/gi,
+    greedy: !0
+  },
+  "atom-input": {
+    pattern: /\b[A-Z]\w*Input\b/,
+    alias: "class-name"
+  },
+  scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
+  constant: /\b[A-Z][A-Z_\d]*\b/,
+  "class-name": {
+    pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
+    lookbehind: !0
+  },
+  fragment: {
+    pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))(?!\d)\w+/,
+    lookbehind: !0,
+    alias: "function"
+  },
+  "definition-mutation": {
+    pattern: /(\bmutation\s+)(?!\d)\w+/,
+    lookbehind: !0,
+    alias: "function"
+  },
+  "definition-query": {
+    pattern: /(\bquery\s+)(?!\d)\w+/,
+    lookbehind: !0,
+    alias: "function"
+  },
+  keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
+  operator: /[&|!=]|\.{3}/,
+  "property-query": /\w+(?=\s*\()/,
+  object: /\w+(?=\s*\{)/,
+  punctuation: /[()[\]{},:!=]/,
+  property: /\w+/,
+  [J](e, t) {
+    for (var n = Se(e, t), s = n.filter(({ type: a }) => a && a != "comment" && a != "scalar"), l = s.length, u = 0, f = (a) => {
+      for (var r = 0; r < a.length; r++)
+        if (u + r == l || s[u + r].type != a[r])
+          return !0;
+    }, E = (a, r) => {
+      for (var d = 1, o = u; o < l; o++) {
+        var i = s[o], h = i.content;
+        if (i.type == "punctuation") {
+          if (a == h)
+            d++;
+          else if (r == h && !--d)
+            return o;
+        }
+      }
+    }; u < l; ) {
+      var y = s[u++];
+      if (y.type == "keyword" && y.content == "mutation") {
+        var v = [];
+        if (!f(["definition-mutation", "punctuation"]) && s[u + 1].content == "(") {
+          u += 2;
+          var m = E("(", ")");
+          if (!m) continue;
+          for (; u < m; u++) {
+            var p = s[u];
+            p.type == "variable" && (p.alias = "variable-input", v.push(p.content));
+          }
+          u = m + 1;
+        }
+        if (!f(["punctuation", "property-query"]) && s[u].content == "{" && (s[++u].alias = "property-mutation", v[0])) {
+          var c = E("{", "}");
+          if (c) for (var b = u; b < c; b++) {
+            var g = s[b];
+            g.type == "variable" && v.indexOf(g.content) >= 0 && (g.alias = "variable-input");
+          }
+        }
+      }
+    }
+    return n;
+  }
+};
+_.webmanifest = _.json = {
+  property: {
+    pattern: /"(?:\\.|[^\\\n"])*"(?=\s*:)/g,
+    greedy: !0
+  },
+  string: {
+    pattern: /"(?:\\.|[^\\\n"])*"/g,
+    greedy: !0
+  },
+  comment: re(),
+  number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+  operator: /:/,
+  punctuation: /[[\]{},]/,
+  boolean: q,
+  null: {
+    pattern: /\bnull\b/,
+    alias: "keyword"
+  }
+};
+_.makefile = {
+  comment: /#(?:\\[^]|[^\\\n])*/,
+  string: Tt(),
+  "builtin-target": {
+    pattern: /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/,
+    alias: "builtin"
+  },
+  target: {
+    pattern: /^(?:[^:=\s]|[ 	]+(?![\s:]))+(?=\s*:(?!=))/m,
+    alias: "symbol",
+    inside: {
+      variable: /\$+(?:(?!\$)[^(){}:#=\s]+|(?=[({]))/
+    }
+  },
+  variable: /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/,
+  // Directives
+  keyword: /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|override|private|s?include|undefine|unexport|vpath)\b/,
+  function: {
+    pattern: /(\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ 	])/,
+    lookbehind: !0
+  },
+  operator: /(?:::|[?:+!])?=|[|@]/,
+  punctuation: /[:;(){}]/
+};
+var Ct = _.scss = ae("css", {
+  comment: re(),
+  atrule: {
+    pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\s+[{;])/,
+    inside: {
+      rule: /@[\w-]+/,
+      [j]: "scss"
+    }
+  },
+  // url, compassified
+  url: /(?:[-a-z]+-)?url(?=\()/i,
+  // CSS selector regex is not appropriate for Sass
+  // since there can be lot more things (var, @ directive, nesting..)
+  // a selector must start at the end of a property or after a brace (end of other rules or nesting)
+  // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable
+  // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var
+  // can "pass" as a selector- e.g: proper#{$erty})
+  // this one was hard to do, so please be careful if you edit this one :)
+  selector: {
+    // Initial look-ahead is used to prevent matching of blank selectors
+    pattern: /(?!\s)[^@;(){}]?(?:[^@;(){}\s]|\s+(?!\s)|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}][^:{}]*[:{][^}]))/,
+    inside: {
+      parent: {
+        pattern: /&/,
+        alias: "important"
+      },
+      placeholder: /%[-\w]+/,
+      variable: /\$[-\w]+|#\{\$[-\w]+\}/
+    }
+  },
+  property: {
+    pattern: /(?:[-\w]|\$[-\w]|#\{\$[-\w]+\})+(?=\s*:)/,
+    inside: {
+      variable: /\$[-\w]+|#\{\$[-\w]+\}/
+    }
+  }
+});
+$(Ct, "atrule", {
+  keyword: [
+    /@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i,
+    {
+      pattern: /( )(?:from|through)(?= )/,
+      lookbehind: !0
+    }
+  ]
+});
+$(Ct, "important", {
+  // var and interpolated vars
+  variable: /\$[-\w]+|#\{\$[-\w]+\}/
+});
+$(Ct, "function", {
+  "module-modifier": {
+    pattern: /\b(?:as|hide|show|with)\b/i,
+    alias: "keyword"
+  },
+  placeholder: {
+    pattern: /%[-\w]+/,
+    alias: "selector"
+  },
+  statement: {
+    pattern: /\B!(?:default|optional)\b/i,
+    alias: "keyword"
+  },
+  boolean: q,
+  null: {
+    pattern: /\bnull\b/,
+    alias: "keyword"
+  },
+  operator: {
+    pattern: /(\s)(?:[%/*+-]|[!=]=|[<>]=?|and|not|or)(?!\S)/,
+    lookbehind: !0
+  }
+});
+var Qn = {
+  pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/g,
+  lookbehind: !0,
+  greedy: !0
+}, he = _.ts = _.typescript = ae("js", {
+  "class-name": Qn
+});
+$(he, "operator", {
+  builtin: /\b(?:Array|Function|Promise|any|boolean|never|number|string|symbol|unknown)\b/
+});
+he.keyword.push(
+  /\b(?:abstract|declare|is|keyof|readonly|require)\b|\b(?:asserts|infer|interface|module|namespace|type)\b(?!\s*[^\s{_$a-zA-Z\xa0-\uffff])|\btype(?=\s*\*)/
+);
+delete he.parameter;
+delete he["literal-property"];
+var Mt = Qn.inside = Object.assign({}, he);
+delete Mt["class-name"];
+delete Mt["maybe-class-name"];
+$(he, "function", {
+  decorator: {
+    pattern: /@[$\w\xa0-\uffff]+/,
+    inside: {
+      at: {
+        pattern: /^@/,
+        alias: "operator"
+      },
+      function: /.+/
+    }
+  },
+  "generic-function": {
+    // e.g. foo<T extends "bar" | "baz">( ...
+    pattern: /#?(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+\s*<(?:[^<>=]|=[^<]|=?<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/g,
+    greedy: !0,
+    inside: {
+      generic: {
+        pattern: /<[^]+/,
+        // everything after the first <
+        alias: "class-name",
+        inside: Mt
+      },
+      function: /\S+/
+    }
+  }
+});
+Gn(_.ts, "tsx");
+var vt = _.tsx.tag, Jn = "(?:^|(";
+try {
+  RegExp("(?<=)"), Jn += "?<=";
+} catch {
+  vt.lookbehind = !0;
+}
+vt.pattern = RegExp(Jn + `[^\\w$])|(?=</))${vt.pattern.source}`, "g");
+var wt = /[*&][^\s[\]{},]+/, At = /!(?:<[\w%#;/?:@&=$,.!~*'()[\]+-]+>|(?:[a-zA-Z\d-]*!)?[\w%#;/?:@&=$.~*'()+-]+)?/, It = `(?:${At.source}(?:[ 	]+${wt.source})?|${wt.source}(?:[ 	]+${At.source})?)`, Wa = F(
+  "(?:[^\\s\0-\\x08\\x0e-\\x1f!\"#%&'*,:>?@[\\]{}`|\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff-]|[?:-]<0>)(?:[ 	]*(?:(?![#:])<0>|:<0>))*",
+  ["[^\\s\0-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]"]
+), gn = `"(?:\\\\.|[^\\\\
+"])*"|'(?:\\\\.|[^\\\\
+'])*'`, we = (e, t) => O(
+  `([:,[{-]\\s*(?:\\s<0>[ 	]+)?)<1>(?=[ 	]*(?:$|,|\\]|\\}|(?:
+\\s*)?#))`,
+  [It, e],
+  t
+);
+_.yml = _.yaml = {
+  scalar: {
+    pattern: O(`([:-]\\s*(?:\\s<0>[ 	]+)?[|>])[ 	]*(?:(
+[ 	]+)\\S.*(?:\\2.+)*)`, [It]),
+    lookbehind: !0,
+    alias: "string"
+  },
+  comment: /#.*/,
+  key: {
+    pattern: O(
+      `((?:^|[:,[{
+?-])[ 	]*(?:<0>[ 	]+)?)<1>(?=\\s*:\\s)`,
+      [It, "(?:" + Wa + "|" + gn + ")"],
+      "g"
+    ),
+    lookbehind: !0,
+    greedy: !0,
+    alias: "atrule"
+  },
+  directive: {
+    pattern: /(^[ 	]*)%.+/m,
+    lookbehind: !0,
+    alias: "important"
+  },
+  datetime: {
+    pattern: we("\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ 	]+)\\d\\d?:\\d\\d:\\d\\d(?:\\.\\d*)?(?:[ 	]*(?:Z|[+-]\\d\\d?(?::\\d\\d)?))?|\\d{4}-\\d\\d-\\d\\d|\\d\\d?:\\d\\d(?::\\d\\d(?:\\.\\d*)?)?", "m"),
+    lookbehind: !0,
+    alias: "number"
+  },
+  boolean: {
+    pattern: we("false|true", "im"),
+    lookbehind: !0,
+    alias: "important"
+  },
+  null: {
+    pattern: we("null|~", "im"),
+    lookbehind: !0,
+    alias: "important"
+  },
+  string: {
+    pattern: we(gn, "mg"),
+    lookbehind: !0,
+    greedy: !0
+  },
+  number: {
+    pattern: we("[+-]?(?:0x[a-f\\d]+|0o[0-7]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)", "im"),
+    lookbehind: !0
+  },
+  tag: At,
+  important: wt,
+  punctuation: /---|[:[\]{},|>?-]|\.{3}/
+};
+var mn = {
+  pattern: /\\[\\()[\]{}^$+*?|.]/,
+  alias: "escape"
+}, Be = /\\(?:x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|u\{[a-fA-F\d]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/, ja = {
+  pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i,
+  alias: "class-name"
+}, Ya = {
+  pattern: /\\[wsd]|\\p\{[^{}]+\}/i,
+  alias: "class-name"
+}, hn = "(?:[^\\\\-]|" + Be.source + ")", Xa = RegExp(hn + "-" + hn), _n = {
+  pattern: /(<|')[^<>']+(?=[>']$)/,
+  lookbehind: !0,
+  alias: "variable"
+};
+_.regex = {
+  "char-class": {
+    pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:\\[^]|[^\\\]])*\]/,
+    lookbehind: !0,
+    inside: {
+      "char-class-punctuation": {
+        pattern: /^.|.$/g,
+        greedy: !0,
+        alias: "punctuation"
+      },
+      "char-class-negation": {
+        pattern: /^\^/,
+        alias: "operator"
+      },
+      range: {
+        pattern: Xa,
+        inside: {
+          escape: Be,
+          "range-punctuation": {
+            pattern: /-/,
+            alias: "operator"
+          }
+        }
+      },
+      "special-escape": mn,
+      "char-set": Ya,
+      escape: Be
+    }
+  },
+  "special-escape": mn,
+  "char-set": ja,
+  backreference: [
+    {
+      // a backreference which is not an octal escape
+      pattern: /\\(?![123][0-7]{2})[1-9]/,
+      alias: "keyword"
+    },
+    {
+      pattern: /\\k<[^<>']+>/,
+      alias: "keyword",
+      inside: {
+        "group-name": _n
+      }
+    }
+  ],
+  anchor: {
+    pattern: /[$^]|\\[ABbGZz]/,
+    alias: "function"
+  },
+  escape: Be,
+  group: [
+    {
+      // https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html
+      // https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference?view=netframework-4.7.2#grouping-constructs
+      // (), (?<name>), (?'name'), (?>), (?:), (?=), (?!), (?<=), (?<!), (?is-m), (?i-m:)
+      pattern: /(\()\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[!=]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?)/,
+      lookbehind: !0,
+      inside: {
+        "group-name": _n
+      }
+    },
+    {
+      pattern: /[()]/,
+      alias: "punctuation"
+    }
+  ],
+  quantifier: {
+    pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/,
+    alias: "number"
+  },
+  alternation: {
+    pattern: /\|/,
+    alias: "keyword"
+  }
+};
+var En = /\/\*[^]*?\*\/|\/\/.*|#(?!\[).*/, yn = [
+  {
+    pattern: /\b(?:false|true)\b/i,
+    alias: "boolean"
+  },
+  {
+    pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/gi,
+    lookbehind: !0,
+    greedy: !0
+  },
+  {
+    pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/gi,
+    lookbehind: !0,
+    greedy: !0
+  },
+  /\b(?:null)\b/i,
+  /\b[A-Z_][A-Z\d_]*\b(?!\s*\()/
+], vn = /\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[a-f\d]+(?:_[a-f\d]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i, wn = /<?=>|\?\?=?|\.{3}|\??->|[!=]==|::|--|\+\+|&&|\*\*=?|\|\||>>|<<|[?~]|[.%&|^!=<>/*+-]=?/, Rt = {
+  pattern: /\{\$(?:[^{}]|\{(?:[^{}]|\{[^}]+\})*\})*\}|(^|[^\\{])\$+(?:\w+(?:\[[^\n[\]]*\]|->\w+)?)/,
+  lookbehind: !0
+}, An = [
+  {
+    pattern: /<<<'([^']+)'\n(?:.*\n)*?\1;/g,
+    alias: "nowdoc-string",
+    greedy: !0,
+    inside: {
+      delimiter: {
+        pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
+        alias: "symbol",
+        inside: {
+          punctuation: /^<<<'?|[';]$/
+        }
+      }
+    }
+  },
+  {
+    pattern: /<<<(?:"([^"]+)"\n(?:.*\n)*?\1;|([a-z_]\w*)\n(?:.*\n)*?\2;)/gi,
+    greedy: !0,
+    alias: "heredoc-string",
+    inside: {
+      delimiter: {
+        pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
+        alias: "symbol",
+        inside: {
+          punctuation: /^<<<"?|[";]$/
+        }
+      },
+      interpolation: Rt
+    }
+  },
+  {
+    pattern: /`(?:\\[^]|[^\\`])*`/g,
+    alias: "backtick-quoted-string",
+    greedy: !0
+  },
+  {
+    pattern: /'(?:\\[^]|[^\\'])*'/g,
+    greedy: !0,
+    alias: "single-quoted-string"
+  },
+  {
+    pattern: /"(?:\\[^]|[^\\"])*"/g,
+    greedy: !0,
+    alias: "double-quoted-string",
+    inside: {
+      interpolation: Rt
+    }
+  }
+], In = Rt.inside = {
+  delimiter: {
+    pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
+    alias: "important"
+  },
+  "doc-comment": {
+    pattern: /\/\*\*(?!\/)[^]*?\*\//g,
+    greedy: !0,
+    alias: "comment",
+    inside: "phpdoc"
+  },
+  comment: En,
+  string: An,
+  attribute: {
+    pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[^]|[^\\"])*"|'(?:\\[^]|[^\\'])*')+\](?=\s*[a-z$#])/img,
+    greedy: !0,
+    inside: {
+      "attribute-content": {
+        pattern: /^(..)[^]+(?=.)/,
+        lookbehind: !0,
+        // inside can appear subset of php
+        inside: {
+          comment: En,
+          string: An,
+          "attribute-class-name": [
+            {
+              pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/gi,
+              lookbehind: !0,
+              greedy: !0,
+              alias: "class-name"
+            },
+            {
+              pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/gi,
+              lookbehind: !0,
+              greedy: !0,
+              alias: "class-name class-name-fully-qualified",
+              inside: {
+                punctuation: /\\/
+              }
+            }
+          ],
+          constant: yn,
+          number: vn,
+          operator: wn,
+          punctuation: te
+        }
+      },
+      delimiter: {
+        pattern: /.+/,
+        alias: "punctuation"
+      }
+    }
+  },
+  variable: /\$+(?:\w+|(?=\{))/,
+  package: {
+    pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+    lookbehind: !0,
+    inside: {
+      punctuation: /\\/
+    }
+  },
+  "class-name-definition": {
+    pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
+    lookbehind: !0,
+    alias: "class-name"
+  },
+  "function-definition": {
+    pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
+    lookbehind: !0,
+    alias: "function"
+  },
+  keyword: [
+    {
+      pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/gi,
+      lookbehind: !0,
+      greedy: !0,
+      alias: "type-casting"
+    },
+    {
+      pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/gi,
+      lookbehind: !0,
+      greedy: !0,
+      alias: "type-hint"
+    },
+    {
+      pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|never|object|self|static|string|void)\b/gi,
+      lookbehind: !0,
+      greedy: !0,
+      alias: "return-type"
+    },
+    {
+      pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/gi,
+      alias: "type-declaration",
+      greedy: !0
+    },
+    {
+      pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/gi,
+      lookbehind: !0,
+      greedy: !0,
+      alias: "type-declaration"
+    },
+    {
+      pattern: /\b(?:parent|self|static)(?=\s*::)/gi,
+      greedy: !0,
+      alias: "static-context"
+    },
+    {
+      // yield from
+      pattern: /(\byield\s+)from\b/gi,
+      lookbehind: !0
+    },
+    // `class` is always a keyword unlike other keywords
+    /\bclass\b/i,
+    {
+      // https://www.php.net/manual/en/reserved.keywords.php
+      //
+      // keywords cannot be preceded by "->"
+      // the complex lookbehind means `(?<!(?:->|::)\s*)`
+      pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|[fx]?or|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|never|new|parent|print|private|protected|public|readonly|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|yield|__halt_compiler)\b/i,
+      lookbehind: !0
+    }
+  ],
+  "argument-name": {
+    pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i,
+    lookbehind: !0
+  },
+  "class-name": [
+    {
+      pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/gi,
+      lookbehind: !0,
+      greedy: !0
+    },
+    {
+      pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/gi,
+      lookbehind: !0,
+      greedy: !0
+    },
+    {
+      pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/gi,
+      greedy: !0
+    },
+    {
+      pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/gi,
+      lookbehind: !0,
+      greedy: !0,
+      alias: "class-name-fully-qualified",
+      inside: {
+        punctuation: /\\/
+      }
+    },
+    {
+      pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/gi,
+      greedy: !0,
+      alias: "class-name-fully-qualified",
+      inside: {
+        punctuation: /\\/
+      }
+    },
+    {
+      pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/gi,
+      lookbehind: !0,
+      greedy: !0,
+      alias: "class-name-fully-qualified",
+      inside: {
+        punctuation: /\\/
+      }
+    },
+    {
+      pattern: /\b[a-z_]\w*(?=\s*\$)/gi,
+      greedy: !0,
+      alias: "type-declaration"
+    },
+    {
+      pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/gi,
+      greedy: !0,
+      alias: "class-name-fully-qualified type-declaration",
+      inside: {
+        punctuation: /\\/
+      }
+    },
+    {
+      pattern: /\b[a-z_]\w*(?=\s*::)/gi,
+      greedy: !0,
+      alias: "static-context"
+    },
+    {
+      pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/gi,
+      greedy: !0,
+      alias: "class-name-fully-qualified static-context",
+      inside: {
+        punctuation: /\\/
+      }
+    },
+    {
+      pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/gi,
+      lookbehind: !0,
+      greedy: !0,
+      alias: "type-hint"
+    },
+    {
+      pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/gi,
+      lookbehind: !0,
+      greedy: !0,
+      alias: "class-name-fully-qualified type-hint",
+      inside: {
+        punctuation: /\\/
+      }
+    },
+    {
+      pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/gi,
+      alias: "return-type",
+      lookbehind: !0,
+      greedy: !0
+    },
+    {
+      pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/gi,
+      lookbehind: !0,
+      greedy: !0,
+      alias: "class-name-fully-qualified return-type",
+      inside: {
+        punctuation: /\\/
+      }
+    }
+  ],
+  constant: yn,
+  function: {
+    pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
+    lookbehind: !0,
+    inside: {
+      punctuation: /\\/
+    }
+  },
+  property: {
+    pattern: /(->\s*)\w+/,
+    lookbehind: !0
+  },
+  number: vn,
+  operator: wn,
+  punctuation: te
+}, Qa = Un("html");
+_.php = {
+  php: {
+    pattern: /<\?(?:[^"'/#]|\/(?![*/])|(["'])(?:\\[^]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^\n?]|\?(?!>))*(?=$|\?>|\n)|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/,
+    alias: "language-php",
+    inside: In
+  },
+  [J]: (e, t) => e.includes("<?") ? Qa(e, t) : ke(e, In)
+};
+var Ja = [`(?:\\\\.|[^\\\\
+]|
+(?!
+))`], Me = (e) => O(`((?:^|[^\\\\])(?:\\\\\\\\)*)(?:${e})`, Ja, "g"), kt = /(?:\\.|``(?:[^\n`]|`(?!`))+``|`[^\n`]+`|[^\\\n|`])+/, Rn = F(`\\|?<0>(?:\\|<0>)+\\|?(?:
+|(?![\\s\\S]))`, [kt.source]), er = `\\|?[ 	]*:?-{3,}:?[ 	]*(?:\\|[ 	]*:?-{3,}:?[ 	]*)+\\|?
+`, fe = _.md = _.markdown = Qe(_.html);
+$(fe, "prolog", {
+  "front-matter-block": {
+    pattern: /(^(?:\s*\n)?)---(?!.)[^]*?\n---(?!.)/g,
+    lookbehind: !0,
+    greedy: !0,
+    inside: {
+      punctuation: /^---|---$/,
+      "front-matter": {
+        pattern: /\S(?:[^]*\S)?/,
+        alias: "language-yaml",
+        inside: "yaml"
+      }
+    }
+  },
+  blockquote: {
+    // > ...
+    pattern: /^>(?:[ 	]*>)*/m,
+    alias: "punctuation"
+  },
+  table: {
+    pattern: RegExp("^" + Rn + er + "(?:" + Rn + ")*", "m"),
+    inside: {
+      "table-header-row": {
+        pattern: /^.+/,
+        inside: {
+          "table-header": {
+            pattern: kt,
+            alias: "important",
+            inside: fe
+          },
+          punctuation: /\|/
+        }
+      },
+      "table-data-rows": {
+        pattern: /(.+\n)[^]+/,
+        lookbehind: !0,
+        inside: {
+          "table-data": {
+            pattern: kt,
+            inside: fe
+          },
+          punctuation: /\|/
+        }
+      },
+      "table-line": {
+        pattern: /.+/,
+        inside: {
+          punctuation: /\S+/
+        }
+      }
+    }
+  },
+  code: [
+    {
+      // Prefixed by 4 spaces or 1 tab and preceded by an empty line
+      pattern: /(^[ 	]*\n)(?:    |	).+(?:\n(?:    |	).+)*/m,
+      lookbehind: !0,
+      alias: "keyword"
+    },
+    {
+      // ```optional language
+      // code block
+      // ```
+      pattern: /^(```+)[^`][^]*?^\1`*$/mg,
+      greedy: !0,
+      inside: {
+        punctuation: /^`+|`+$/,
+        "code-language": /^.+/,
+        "code-block": /(?!^)[^]+(?=\n)/,
+        [J](e, t) {
+          var n = Se(e, t), s;
+          return n[5] && (s = (/[a-z][\w-]*/i.exec(
+            n[1].content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp")
+          ) || [""])[0].toLowerCase(), n[3].alias = "language-" + s, (t = _[s]) && (n[3].content = ke(n[3].content, t))), n;
+        }
+      }
+    }
+  ],
+  title: [
+    {
+      // title 1
+      // =======
+      // title 2
+      // -------
+      pattern: /\S.*\n(?:==+|--+)(?=[ 	]*$)/m,
+      alias: "important",
+      inside: {
+        punctuation: /=+$|-+$/
+      }
+    },
+    {
+      // # title 1
+      // ###### title 6
+      pattern: /(^\s*)#.+/m,
+      lookbehind: !0,
+      alias: "important",
+      inside: {
+        punctuation: /^#+|#+$/
+      }
+    }
+  ],
+  hr: {
+    // ***
+    // ---
+    // * * *
+    // -----------
+    pattern: /(^\s*)([*-])(?:[ 	]*\2){2,}(?=\s*$)/m,
+    lookbehind: !0,
+    alias: "punctuation"
+  },
+  list: {
+    // * item
+    // + item
+    // - item
+    // 1. item
+    pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[ 	].)/m,
+    lookbehind: !0,
+    alias: "punctuation"
+  },
+  "url-reference": {
+    // [id]: http://example.com "Optional title"
+    // [id]: http://example.com 'Optional title'
+    // [id]: http://example.com (Optional title)
+    // [id]: <http://example.com> "Optional title"
+    pattern: /!?\[[^\]]+\]:[ 	]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[ 	]+(?:"(?:\\.|[^\\"])*"|'(?:\\.|[^\\'])*'|\((?:\\.|[^)\\])*\)))?/,
+    inside: {
+      variable: {
+        pattern: /^(!?\[)[^\]]+/,
+        lookbehind: !0
+      },
+      string: /(?:"(?:\\.|[^\\"])*"|'(?:\\.|[^\\'])*'|\((?:\\.|[^)\\])*\))$/,
+      punctuation: /^[[\]!:]|<|>/
+    },
+    alias: "url"
+  },
+  bold: {
+    // **strong**
+    // __strong__
+    // allow one nested instance of italic text using the same delimiter
+    pattern: Me("\\b__(?:(?!_)<0>|_(?:(?!_)<0>)+_)+__\\b|\\*\\*(?:(?!\\*)<0>|\\*(?:(?!\\*)<0>)+\\*)+\\*\\*"),
+    lookbehind: !0,
+    greedy: !0,
+    inside: {
+      content: {
+        pattern: /(^..)[^]+(?=..)/,
+        lookbehind: !0,
+        inside: {}
+        // see below
+      },
+      punctuation: /../
+    }
+  },
+  italic: {
+    // *em*
+    // _em_
+    // allow one nested instance of bold text using the same delimiter
+    pattern: Me("\\b_(?:(?!_)<0>|__(?:(?!_)<0>)+__)+_\\b|\\*(?:(?!\\*)<0>|\\*\\*(?:(?!\\*)<0>)+\\*\\*)+\\*"),
+    lookbehind: !0,
+    greedy: !0,
+    inside: {
+      content: {
+        pattern: /(?!^)[^]+(?=.)/,
+        inside: {}
+        // see below
+      },
+      punctuation: /./
+    }
+  },
+  strike: {
+    // ~~strike through~~
+    // ~strike~
+    // eslint-disable-next-line regexp/strict
+    pattern: Me("(~~?)(?:(?!~)<0>)+\\2"),
+    lookbehind: !0,
+    greedy: !0,
+    inside: {
+      punctuation: /^~~?|~~?$/,
+      content: {
+        pattern: /[^]+/,
+        inside: {}
+        // see below
+      }
+    }
+  },
+  "code-snippet": {
+    // `code`
+    // ``code``
+    pattern: /(^|[^\\`])(?:``[^\n`]+(?:`[^\n`]+)*``(?!`)|`[^\n`]+`(?!`))/g,
+    lookbehind: !0,
+    greedy: !0,
+    alias: "code keyword"
+  },
+  url: {
+    // [example](http://example.com "Optional title")
+    // [example][id]
+    // [example] [id]
+    pattern: Me('!?\\[(?:(?!\\])<0>)+\\](?:\\([^\\s)]+(?:[ 	]+"(?:\\\\.|[^\\\\"])*")?\\)|[ 	]?\\[(?:(?!\\])<0>)+\\])'),
+    lookbehind: !0,
+    greedy: !0,
+    inside: {
+      operator: /^!/,
+      content: {
+        pattern: /(^\[)[^\]]+(?=\])/,
+        lookbehind: !0,
+        inside: {}
+        // see below
+      },
+      variable: {
+        pattern: /(^\][ 	]?\[)[^\]]+(?=\]$)/,
+        lookbehind: !0
+      },
+      url: {
+        pattern: /(^\]\()[^\s)]+/,
+        lookbehind: !0
+      },
+      string: {
+        pattern: /(^[ 	]+)"(?:\\.|[^\\"])*"(?=\)$)/,
+        lookbehind: !0
+      },
+      "markup-bracket": fe["markup-bracket"]
+    }
+  }
+});
+["url", "bold", "italic", "strike"].forEach((e) => {
+  ["url", "bold", "italic", "strike", "code-snippet", "markup-bracket"].forEach((t) => {
+    e != t && (fe[e].inside.content.inside[t] = fe[t]);
+  });
+});
+const tr = "_wrap_1x3wi_1", nr = "_blockInfoEditable_1x3wi_30", kn = {
+  wrap: tr,
+  blockInfoEditable: nr
+}, Pe = [
+  { value: "plaintext", label: "plaintext" },
+  { value: "javascript", label: "JavaScript" },
+  { value: "typescript", label: "TypeScript" },
+  { value: "html", label: "HTML" },
+  { value: "css", label: "CSS" },
+  { value: "python", label: "Python" },
+  { value: "java", label: "Java" },
+  { value: "cpp", label: "C++" },
+  { value: "go", label: "Go" },
+  { value: "rust", label: "Rust" },
+  { value: "sql", label: "SQL" },
+  { value: "json", label: "JSON" },
+  { value: "yaml", label: "YAML" },
+  { value: "markdown", label: "Markdown" },
+  { value: "bash", label: "Bash" },
+  { value: "php", label: "PHP" }
+], ut = [2, 4, 8];
+function ar(e) {
+  const t = ca(), n = $t(null), s = nt(() => ua(ea.name, e == null ? void 0 : e.editor), [e == null ? void 0 : e.editor]), l = $t(null), u = e.node.attrs.code || e.node.textContent || "", f = nt((c) => {
+    c == null || c.stopPropagation(), setTimeout(() => {
+      var b, g, a;
+      (a = (g = (b = l.current) == null ? void 0 : b.textarea) == null ? void 0 : g.focus) == null || a.call(g);
+    }, 0);
+  }, []), E = async () => {
+    if (u)
+      try {
+        if (navigator.clipboard)
+          await navigator.clipboard.writeText(u);
+        else {
+          const c = document.createElement("textarea");
+          c.value = u, document.body.appendChild(c), c.select(), document.execCommand("copy"), document.body.removeChild(c);
+        }
+      } catch (c) {
+        console.error("Error:", c);
+      } finally {
+        f();
+      }
+  }, y = () => {
+    e.updateAttributes({
+      lineNumbers: !e.node.attrs.lineNumbers
+    }), f();
+  }, v = () => {
+    e.updateAttributes({
+      wordWrap: !e.node.attrs.wordWrap
+    }), f();
+  }, m = (c) => {
+    const b = { ...c };
+    return b.language && !Pe.some((g) => g.value === b.language) && (b.language = "plaintext", e.updateAttributes({
+      language: "plaintext"
+    })), b;
+  }, p = nt(
+    (c) => {
+      f(c);
+    },
+    [f]
+  );
+  return Dt(() => {
+    if (n.current) {
+      const c = m(e.node.attrs);
+      l.current = pa(n.current, {
+        readOnly: !t,
+        language: c.language || "plaintext",
+        tabSize: c.tabSize ?? 2,
+        lineNumbers: c.lineNumbers ?? !0,
+        wordWrap: c.wordWrap ?? !1,
+        value: u,
+        rtl: !1,
+        onUpdate(b) {
+          queueMicrotask(() => {
+            e.updateAttributes({ code: b });
+          });
+        }
+      }), l.current.addExtensions(
+        Sa(),
+        La(),
+        Ra(),
+        ka(),
+        wa(),
+        Ea(),
+        ya()
+      ), e.node.attrs.shouldFocus && setTimeout(() => {
+        f(), e.updateAttributes({
+          shouldFocus: !1
+        });
+      }, 0);
+    }
+    return () => {
+      var c, b;
+      (c = l.current) != null && c.remove && ((b = l.current) == null || b.remove());
+    };
+  }, [n]), Dt(() => {
+    var c, b;
+    if ((c = l.current) != null && c.setOptions) {
+      const g = m(e.node.attrs);
+      (b = l.current) == null || b.setOptions(g);
+    }
+  }, [l, e.node.attrs]), /* @__PURE__ */ C(ta, { className: Te(kn.wrap, "render-wrapper"), children: /* @__PURE__ */ C(
+    "div",
+    {
+      onClick: p,
+      ref: n,
+      className: Te(
+        "richtext-node-container richtext-hover-shadow richtext-select-outline richtext-node-code-block !richtext-my-[10px]",
+        {
+          [kn.blockInfoEditable]: !t
+        }
+      ),
+      children: /* @__PURE__ */ tt("div", { className: "richtext-code-block-toolbar", children: [
+        /* @__PURE__ */ C("div", { children: /* @__PURE__ */ tt(
+          Ft,
+          {
+            defaultValue: e.node.attrs.language,
+            disabled: !t,
+            onValueChange: (c) => {
+              e.updateAttributes({
+                language: c
+              }), f();
+            },
+            children: [
+              /* @__PURE__ */ C(Ut, { className: "richtext-h-7 richtext-w-[160px] richtext-border-none richtext-text-sm richtext-outline-none hover:richtext-bg-[#5a5d5e4f]", children: /* @__PURE__ */ C(da, { placeholder: "Select language" }) }),
+              /* @__PURE__ */ C(Bt, { onCloseAutoFocus: (c) => c.preventDefault(), children: Pe == null ? void 0 : Pe.map((c) => /* @__PURE__ */ C(Gt, { value: c.value, children: c.label }, c.value)) })
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ C("div", { className: "toolbar-divider" }),
+        /* @__PURE__ */ C(
+          "div",
+          {
+            className: "richtext-flex richtext-size-7 richtext-cursor-pointer richtext-items-center richtext-justify-center richtext-rounded-sm hover:richtext-bg-[#5a5d5e4f]",
+            onClick: E,
+            children: /* @__PURE__ */ C(Ee, { className: "richtext-size-4", name: "Copy" })
+          }
+        ),
+        /* @__PURE__ */ C("div", { className: "toolbar-divider" }),
+        /* @__PURE__ */ C(
+          "div",
+          {
+            onClick: y,
+            className: Te(
+              "richtext-flex richtext-size-7 richtext-cursor-pointer richtext-items-center richtext-justify-center richtext-rounded-sm hover:richtext-bg-[#5a5d5e4f]",
+              {
+                "richtext-bg-[#5a5d5e4f]": e == null ? void 0 : e.node.attrs.lineNumbers
+              }
+            ),
+            children: /* @__PURE__ */ C(Ee, { className: "richtext-size-4", name: "List" })
+          }
+        ),
+        /* @__PURE__ */ C("div", { className: "toolbar-divider" }),
+        /* @__PURE__ */ C(
+          "div",
+          {
+            onClick: v,
+            className: Te(
+              "richtext-flex richtext-size-7 richtext-cursor-pointer richtext-items-center richtext-justify-center richtext-rounded-sm hover:richtext-bg-[#5a5d5e4f]",
+              {
+                "richtext-bg-[#5a5d5e4f]": e == null ? void 0 : e.node.attrs.wordWrap
+              }
+            ),
+            children: /* @__PURE__ */ C(Ee, { className: "richtext-size-4", name: "WrapText" })
+          }
+        ),
+        /* @__PURE__ */ C("div", { className: "toolbar-divider" }),
+        /* @__PURE__ */ C("div", { children: /* @__PURE__ */ tt(
+          Ft,
+          {
+            defaultValue: e.node.attrs.tabSize,
+            disabled: !t,
+            onValueChange: (c) => {
+              e.updateAttributes({
+                tabSize: c
+              }), f();
+            },
+            children: [
+              /* @__PURE__ */ C(Ut, { className: "richtext-h-7 richtext-w-[60px] richtext-border-none richtext-text-sm richtext-outline-none hover:richtext-bg-[#5a5d5e4f]", children: /* @__PURE__ */ C(Ee, { className: "richtext-size-4", name: "IndentIncrease" }) }),
+              /* @__PURE__ */ C(Bt, { onCloseAutoFocus: (c) => c.preventDefault(), children: ut == null ? void 0 : ut.map((c) => /* @__PURE__ */ C(Gt, { value: c, children: c }, c)) })
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ C("div", { className: "toolbar-divider" }),
+        /* @__PURE__ */ C(
+          "div",
+          {
+            className: "richtext-flex richtext-size-7 richtext-cursor-pointer richtext-items-center richtext-justify-center richtext-rounded-sm hover:richtext-bg-[#5a5d5e4f]",
+            onClick: s,
+            children: /* @__PURE__ */ C(Ee, { className: "richtext-size-4", name: "Trash2" })
+          }
+        )
+      ] })
+    }
+  ) });
+}
+const rr = /^`{3}([a-z]+)?\s$/, ir = /^~{3}([a-z]+)?\s$/, ea = /* @__PURE__ */ na.create({
+  name: "codeBlock",
+  group: "block",
+  atom: !0,
+  content: "text*",
+  addOptions() {
+    var e;
+    return {
+      ...(e = this.parent) == null ? void 0 : e.call(this),
+      languages: [],
+      button: ({ editor: t, t: n }) => ({
+        componentProps: {
+          action: () => t.commands.setCodeBlock({}),
+          isActive: () => t.isActive("codeBlock"),
+          disabled: !1,
+          icon: "Code2",
+          tooltip: n("editor.codeblock.tooltip")
+        }
+      })
+    };
+  },
+  addAttributes() {
+    return {
+      code: {
+        default: "",
+        parseHTML: (e) => e.textContent || ""
+      },
+      language: {
+        default: "plaintext"
+      },
+      lineNumbers: {
+        default: !0
+      },
+      wordWrap: {
+        default: !1
+      },
+      tabSize: {
+        default: 2
+      },
+      shouldFocus: {
+        default: !0,
+        parseHTML: () => !1,
+        renderHTML: !1
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "pre",
+        preserveWhitespace: "full",
+        getAttrs: (e) => ({
+          code: e.textContent || ""
+        })
+      },
+      {
+        tag: "pre code",
+        preserveWhitespace: "full",
+        getAttrs: (e) => ({
+          code: e.textContent || ""
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e, node: t }) {
+    var s;
+    const n = t.attrs.code || ((s = t.content.firstChild) == null ? void 0 : s.text) || "";
+    return [
+      "pre",
+      ra(this.options.HTMLAttributes, e),
+      ["code", {}, n]
+    ];
+  },
+  addNodeView() {
+    return aa(ar);
+  },
+  addCommands() {
+    return {
+      setCodeBlock: (e) => ({ commands: t }) => t.insertContent({
+        type: this.name,
+        attrs: {
+          ...e,
+          shouldFocus: !0
+        }
+      })
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Alt-c": () => this.editor.commands.setCodeBlock({})
+    };
+  },
+  addInputRules() {
+    return [
+      Pt({
+        find: rr,
+        type: this.type,
+        getAttributes: (e) => ({
+          language: e[1]
+        })
+      }),
+      Pt({
+        find: ir,
+        type: this.type,
+        getAttributes: (e) => ({
+          language: e[1]
+        })
+      })
+    ];
+  }
+});
+export {
+  ea as CodeBlock,
+  br as RichTextCodeBlock,
+  rr as backtickInputRegex,
+  ir as tildeInputRegex
+};