zudoku 0.33.1 → 0.34.0

package/lib/ui/SyntaxHighlight.js

@@ -1,45 +1,45 @@
-import { j as F } from "../jsx-runtime-CYK1ROHF.js";
-import { createElement as de, useCallback as V, useMemo as ge, useState as ye } from "react";
-import { a as oe, c as K } from "../cn-qaFjX9_3.js";
-import { CheckIcon as fe, CopyIcon as be } from "lucide-react";
-import { z as me } from "../index-DwT-v3zK.js";
-import { C as he } from "../ClientOnly-E7hGysn1.js";
-var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties, we = Object.getOwnPropertyDescriptor, xe = Object.getOwnPropertyDescriptors, se = Object.getOwnPropertyNames, G = Object.getOwnPropertySymbols, Ee = Object.getPrototypeOf, Q = Object.prototype.hasOwnProperty, le = Object.prototype.propertyIsEnumerable, te = (e, t, a) => t in e ? Z(e, t, { enumerable: !0, configurable: !0, writable: !0, value: a }) : e[t] = a, N = (e, t) => {
-  for (var a in t || (t = {}))
-    Q.call(t, a) && te(e, a, t[a]);
+import { j as _ } from "../jsx-runtime-CYK1ROHF.js";
+import { createElement as de, useCallback as K, useMemo as ye, memo as fe, useState as be } from "react";
+import { a as se, c as ee } from "../cn-qaFjX9_3.js";
+import { CheckIcon as me, CopyIcon as he } from "lucide-react";
+import { z as ve } from "../index-DwT-v3zK.js";
+import { C as te } from "../ClientOnly-E7hGysn1.js";
+var ke = Object.create, Z = Object.defineProperty, we = Object.defineProperties, Ee = Object.getOwnPropertyDescriptor, xe = Object.getOwnPropertyDescriptors, le = Object.getOwnPropertyNames, G = Object.getOwnPropertySymbols, Ae = Object.getPrototypeOf, X = Object.prototype.hasOwnProperty, ie = Object.prototype.propertyIsEnumerable, ae = (e, t, r) => t in e ? Z(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r, N = (e, t) => {
+  for (var r in t || (t = {}))
+    X.call(t, r) && ae(e, r, t[r]);
   if (G)
-    for (var a of G(t))
-      le.call(t, a) && te(e, a, t[a]);
+    for (var r of G(t))
+      ie.call(t, r) && ae(e, r, t[r]);
   return e;
-}, q = (e, t) => ke(e, xe(t)), ie = (e, t) => {
-  var a = {};
+}, q = (e, t) => we(e, xe(t)), ue = (e, t) => {
+  var r = {};
   for (var i in e)
-    Q.call(e, i) && t.indexOf(i) < 0 && (a[i] = e[i]);
+    X.call(e, i) && t.indexOf(i) < 0 && (r[i] = e[i]);
   if (e != null && G)
     for (var i of G(e))
-      t.indexOf(i) < 0 && le.call(e, i) && (a[i] = e[i]);
-  return a;
-}, Ae = (e, t) => function() {
-  return t || (0, e[se(e)[0]])((t = { exports: {} }).exports, t), t.exports;
-}, Se = (e, t) => {
-  for (var a in t)
-    Z(e, a, { get: t[a], enumerable: !0 });
-}, _e = (e, t, a, i) => {
+      t.indexOf(i) < 0 && ie.call(e, i) && (r[i] = e[i]);
+  return r;
+}, Se = (e, t) => function() {
+  return t || (0, e[le(e)[0]])((t = { exports: {} }).exports, t), t.exports;
+}, _e = (e, t) => {
+  for (var r in t)
+    Z(e, r, { get: t[r], enumerable: !0 });
+}, Fe = (e, t, r, i) => {
   if (t && typeof t == "object" || typeof t == "function")
-    for (let y of se(t))
-      !Q.call(e, y) && y !== a && Z(e, y, { get: () => t[y], enumerable: !(i = we(t, y)) || i.enumerable });
+    for (let f of le(t))
+      !X.call(e, f) && f !== r && Z(e, f, { get: () => t[f], enumerable: !(i = Ee(t, f)) || i.enumerable });
   return e;
-}, Fe = (e, t, a) => (a = e != null ? ve(Ee(e)) : {}, _e(
+}, Te = (e, t, r) => (r = e != null ? ke(Ae(e)) : {}, Fe(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
   // compatible transform (i.e. "__esModule" has not been set), then set
   // "default" to the CommonJS "module.exports" for node compatibility.
-  !e || !e.__esModule ? Z(a, "default", { value: e, enumerable: !0 }) : a,
+  !e || !e.__esModule ? Z(r, "default", { value: e, enumerable: !0 }) : r,
   e
-)), Te = Ae({
+)), Re = Se({
   "../../node_modules/.pnpm/prismjs@1.29.0_patch_hash=vrxx3pzkik6jpmgpayxfjunetu/node_modules/prismjs/prism.js"(e, t) {
-    var a = function() {
-      var i = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, y = 0, m = {}, c = {
+    var r = function() {
+      var i = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, f = 0, h = {}, u = {
         /**
          * A namespace for utility methods.
          *
@@ -50,8 +50,8 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
          * @memberof Prism
          */
         util: {
-          encode: function n(r) {
-            return r instanceof h ? new h(r.type, n(r.content), r.alias) : Array.isArray(r) ? r.map(n) : r.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\u00a0/g, " ");
+          encode: function n(a) {
+            return a instanceof m ? new m(a.type, n(a.content), a.alias) : Array.isArray(a) ? a.map(n) : a.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\u00a0/g, " ");
           },
           /**
            * Returns the name of the type of the given value.
@@ -79,7 +79,7 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
            * @returns {number}
            */
           objId: function(n) {
-            return n.__id || Object.defineProperty(n, "__id", { value: ++y }), n.__id;
+            return n.__id || Object.defineProperty(n, "__id", { value: ++f }), n.__id;
           },
           /**
            * Creates a deep clone of the given object.
@@ -91,28 +91,28 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
            * @returns {T}
            * @template T
            */
-          clone: function n(r, s) {
+          clone: function n(a, s) {
             s = s || {};
-            var u, l;
-            switch (c.util.type(r)) {
+            var c, l;
+            switch (u.util.type(a)) {
               case "Object":
-                if (l = c.util.objId(r), s[l])
+                if (l = u.util.objId(a), s[l])
                   return s[l];
-                u = /** @type {Record<string, any>} */
-                {}, s[l] = u;
-                for (var g in r)
-                  r.hasOwnProperty(g) && (u[g] = n(r[g], s));
+                c = /** @type {Record<string, any>} */
+                {}, s[l] = c;
+                for (var d in a)
+                  a.hasOwnProperty(d) && (c[d] = n(a[d], s));
                 return (
                   /** @type {any} */
-                  u
+                  c
                 );
               case "Array":
-                return l = c.util.objId(r), s[l] ? s[l] : (u = [], s[l] = u, r.forEach(function(k, x) {
-                  u[x] = n(k, s);
+                return l = u.util.objId(a), s[l] ? s[l] : (c = [], s[l] = c, a.forEach(function(k, E) {
+                  c[E] = n(k, s);
                 }), /** @type {any} */
-                u);
+                c);
               default:
-                return r;
+                return a;
             }
           },
           /**
@@ -125,9 +125,9 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
            */
           getLanguage: function(n) {
             for (; n; ) {
-              var r = i.exec(n.className);
-              if (r)
-                return r[1].toLowerCase();
+              var a = i.exec(n.className);
+              if (a)
+                return a[1].toLowerCase();
               n = n.parentElement;
             }
             return "none";
@@ -139,8 +139,8 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
            * @param {string} language
            * @returns {void}
            */
-          setLanguage: function(n, r) {
-            n.className = n.className.replace(RegExp(i, "gi"), ""), n.classList.add("language-" + r);
+          setLanguage: function(n, a) {
+            n.className = n.className.replace(RegExp(i, "gi"), ""), n.classList.add("language-" + a);
           },
           /**
            * Returns whether a given class is active for `element`.
@@ -161,12 +161,12 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
            * @param {boolean} [defaultActivation=false]
            * @returns {boolean}
            */
-          isActive: function(n, r, s) {
-            for (var u = "no-" + r; n; ) {
+          isActive: function(n, a, s) {
+            for (var c = "no-" + a; n; ) {
               var l = n.classList;
-              if (l.contains(r))
+              if (l.contains(a))
                 return !0;
-              if (l.contains(u))
+              if (l.contains(c))
                 return !1;
               n = n.parentElement;
             }
@@ -184,10 +184,10 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
           /**
            * The grammar for plain, unformatted text.
            */
-          plain: m,
-          plaintext: m,
-          text: m,
-          txt: m,
+          plain: h,
+          plaintext: h,
+          text: h,
+          txt: h,
           /**
            * Creates a deep copy of the language with the given id and appends the given tokens.
            *
@@ -216,10 +216,10 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
            *     'color': /\b(?:red|green|blue)\b/
            * });
            */
-          extend: function(n, r) {
-            var s = c.util.clone(c.languages[n]);
-            for (var u in r)
-              s[u] = r[u];
+          extend: function(n, a) {
+            var s = u.util.clone(u.languages[n]);
+            for (var c in a)
+              s[c] = a[c];
             return s;
           },
           /**
@@ -297,31 +297,31 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
            * @returns {Grammar} The new grammar object.
            * @public
            */
-          insertBefore: function(n, r, s, u) {
-            u = u || /** @type {any} */
-            c.languages;
-            var l = u[n], g = {};
+          insertBefore: function(n, a, s, c) {
+            c = c || /** @type {any} */
+            u.languages;
+            var l = c[n], d = {};
             for (var k in l)
               if (l.hasOwnProperty(k)) {
-                if (k == r)
-                  for (var x in s)
-                    s.hasOwnProperty(x) && (g[x] = s[x]);
-                s.hasOwnProperty(k) || (g[k] = l[k]);
+                if (k == a)
+                  for (var E in s)
+                    s.hasOwnProperty(E) && (d[E] = s[E]);
+                s.hasOwnProperty(k) || (d[k] = l[k]);
               }
-            var A = u[n];
-            return u[n] = g, c.languages.DFS(c.languages, function(E, _) {
-              _ === A && E != n && (this[E] = g);
-            }), g;
+            var A = c[n];
+            return c[n] = d, u.languages.DFS(u.languages, function(x, F) {
+              F === A && x != n && (this[x] = d);
+            }), d;
           },
           // Traverse a language definition with Depth First Search
-          DFS: function n(r, s, u, l) {
+          DFS: function n(a, s, c, l) {
             l = l || {};
-            var g = c.util.objId;
-            for (var k in r)
-              if (r.hasOwnProperty(k)) {
-                s.call(r, k, r[k], u || k);
-                var x = r[k], A = c.util.type(x);
-                A === "Object" && !l[g(x)] ? (l[g(x)] = !0, n(x, s, null, l)) : A === "Array" && !l[g(x)] && (l[g(x)] = !0, n(x, s, k, l));
+            var d = u.util.objId;
+            for (var k in a)
+              if (a.hasOwnProperty(k)) {
+                s.call(a, k, a[k], c || k);
+                var E = a[k], A = u.util.type(E);
+                A === "Object" && !l[d(E)] ? (l[d(E)] = !0, n(E, s, null, l)) : A === "Array" && !l[d(E)] && (l[d(E)] = !0, n(E, s, k, l));
               }
           }
         },
@@ -346,15 +346,15 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
          * @example
          * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
          */
-        highlight: function(n, r, s) {
-          var u = {
+        highlight: function(n, a, s) {
+          var c = {
             code: n,
-            grammar: r,
+            grammar: a,
             language: s
           };
-          if (c.hooks.run("before-tokenize", u), !u.grammar)
-            throw new Error('The language "' + u.language + '" has no grammar.');
-          return u.tokens = c.tokenize(u.code, u.grammar), c.hooks.run("after-tokenize", u), h.stringify(c.util.encode(u.tokens), u.language);
+          if (u.hooks.run("before-tokenize", c), !c.grammar)
+            throw new Error('The language "' + c.language + '" has no grammar.');
+          return c.tokens = u.tokenize(c.code, c.grammar), u.hooks.run("after-tokenize", c), m.stringify(u.util.encode(c.tokens), c.language);
         },
         /**
          * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
@@ -380,15 +380,15 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
          *     }
          * });
          */
-        tokenize: function(n, r) {
-          var s = r.rest;
+        tokenize: function(n, a) {
+          var s = a.rest;
           if (s) {
-            for (var u in s)
-              r[u] = s[u];
-            delete r.rest;
+            for (var c in s)
+              a[c] = s[c];
+            delete a.rest;
           }
           var l = new b();
-          return f(l, l.head, n), d(n, l, r, l.head, 0), w(l);
+          return y(l, l.head, n), g(n, l, a, l.head, 0), w(l);
         },
         /**
          * @namespace
@@ -409,9 +409,9 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
            * @param {HookCallback} callback The callback function which is given environment variables.
            * @public
            */
-          add: function(n, r) {
-            var s = c.hooks.all;
-            s[n] = s[n] || [], s[n].push(r);
+          add: function(n, a) {
+            var s = u.hooks.all;
+            s[n] = s[n] || [], s[n].push(a);
           },
           /**
            * Runs a hook invoking all registered callbacks with the given environment variables.
@@ -422,93 +422,93 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
            * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
            * @public
            */
-          run: function(n, r) {
-            var s = c.hooks.all[n];
+          run: function(n, a) {
+            var s = u.hooks.all[n];
             if (!(!s || !s.length))
-              for (var u = 0, l; l = s[u++]; )
-                l(r);
+              for (var c = 0, l; l = s[c++]; )
+                l(a);
           }
         },
-        Token: h
+        Token: m
       };
-      function h(n, r, s, u) {
-        this.type = n, this.content = r, this.alias = s, this.length = (u || "").length | 0;
-      }
-      h.stringify = function n(r, s) {
-        if (typeof r == "string")
-          return r;
-        if (Array.isArray(r)) {
-          var u = "";
-          return r.forEach(function(A) {
-            u += n(A, s);
-          }), u;
+      function m(n, a, s, c) {
+        this.type = n, this.content = a, this.alias = s, this.length = (c || "").length | 0;
+      }
+      m.stringify = function n(a, s) {
+        if (typeof a == "string")
+          return a;
+        if (Array.isArray(a)) {
+          var c = "";
+          return a.forEach(function(A) {
+            c += n(A, s);
+          }), c;
         }
         var l = {
-          type: r.type,
-          content: n(r.content, s),
+          type: a.type,
+          content: n(a.content, s),
           tag: "span",
-          classes: ["token", r.type],
+          classes: ["token", a.type],
           attributes: {},
           language: s
-        }, g = r.alias;
-        g && (Array.isArray(g) ? Array.prototype.push.apply(l.classes, g) : l.classes.push(g)), c.hooks.run("wrap", l);
+        }, d = a.alias;
+        d && (Array.isArray(d) ? Array.prototype.push.apply(l.classes, d) : l.classes.push(d)), u.hooks.run("wrap", l);
         var k = "";
-        for (var x in l.attributes)
-          k += " " + x + '="' + (l.attributes[x] || "").replace(/"/g, "&quot;") + '"';
+        for (var E in l.attributes)
+          k += " " + E + '="' + (l.attributes[E] || "").replace(/"/g, "&quot;") + '"';
         return "<" + l.tag + ' class="' + l.classes.join(" ") + '"' + k + ">" + l.content + "</" + l.tag + ">";
       };
-      function p(n, r, s, u) {
-        n.lastIndex = r;
+      function p(n, a, s, c) {
+        n.lastIndex = a;
         var l = n.exec(s);
-        if (l && u && l[1]) {
-          var g = l[1].length;
-          l.index += g, l[0] = l[0].slice(g);
+        if (l && c && l[1]) {
+          var d = l[1].length;
+          l.index += d, l[0] = l[0].slice(d);
         }
         return l;
       }
-      function d(n, r, s, u, l, g) {
+      function g(n, a, s, c, l, d) {
         for (var k in s)
           if (!(!s.hasOwnProperty(k) || !s[k])) {
-            var x = s[k];
-            x = Array.isArray(x) ? x : [x];
-            for (var A = 0; A < x.length; ++A) {
-              if (g && g.cause == k + "," + A)
+            var E = s[k];
+            E = Array.isArray(E) ? E : [E];
+            for (var A = 0; A < E.length; ++A) {
+              if (d && d.cause == k + "," + A)
                 return;
-              var E = x[A], _ = E.inside, T = !!E.lookbehind, D = !!E.greedy, C = E.alias;
-              if (D && !E.pattern.global) {
-                var L = E.pattern.toString().match(/[imsuy]*$/)[0];
-                E.pattern = RegExp(E.pattern.source, L + "g");
+              var x = E[A], F = x.inside, T = !!x.lookbehind, D = !!x.greedy, C = x.alias;
+              if (D && !x.pattern.global) {
+                var L = x.pattern.toString().match(/[imsuy]*$/)[0];
+                x.pattern = RegExp(x.pattern.source, L + "g");
               }
-              for (var J = E.pattern || E, S = u.next, O = l; S !== r.tail && !(g && O >= g.reach); O += S.value.length, S = S.next) {
+              for (var Q = x.pattern || x, S = c.next, O = l; S !== a.tail && !(d && O >= d.reach); O += S.value.length, S = S.next) {
                 var $ = S.value;
-                if (r.length > n.length)
+                if (a.length > n.length)
                   return;
-                if (!($ instanceof h)) {
-                  var P = 1, I;
+                if (!($ instanceof m)) {
+                  var j = 1, I;
                   if (D) {
-                    if (I = p(J, O, n, T), !I || I.index >= n.length)
+                    if (I = p(Q, O, n, T), !I || I.index >= n.length)
                       break;
-                    var z = I.index, ce = I.index + I[0].length, B = O;
+                    var z = I.index, pe = I.index + I[0].length, B = O;
                     for (B += S.value.length; z >= B; )
                       S = S.next, B += S.value.length;
-                    if (B -= S.value.length, O = B, S.value instanceof h)
+                    if (B -= S.value.length, O = B, S.value instanceof m)
                       continue;
-                    for (var j = S; j !== r.tail && (B < ce || typeof j.value == "string"); j = j.next)
-                      P++, B += j.value.length;
-                    P--, $ = n.slice(O, B), I.index -= O;
-                  } else if (I = p(J, 0, $, T), !I)
+                    for (var P = S; P !== a.tail && (B < pe || typeof P.value == "string"); P = P.next)
+                      j++, B += P.value.length;
+                    j--, $ = n.slice(O, B), I.index -= O;
+                  } else if (I = p(Q, 0, $, T), !I)
                     continue;
-                  var z = I.index, M = I[0], W = $.slice(0, z), ee = $.slice(z + M.length), H = O + $.length;
-                  g && H > g.reach && (g.reach = H);
+                  var z = I.index, M = I[0], W = $.slice(0, z), J = $.slice(z + M.length), H = O + $.length;
+                  d && H > d.reach && (d.reach = H);
                   var U = S.prev;
-                  W && (U = f(r, U, W), O += W.length), v(r, U, P);
-                  var pe = new h(k, _ ? c.tokenize(M, _) : M, C, M);
-                  if (S = f(r, U, pe), ee && f(r, S, ee), P > 1) {
+                  W && (U = y(a, U, W), O += W.length), v(a, U, j);
+                  var ge = new m(k, F ? u.tokenize(M, F) : M, C, M);
+                  if (S = y(a, U, ge), J && y(a, S, J), j > 1) {
                     var Y = {
                       cause: k + "," + A,
                       reach: H
                     };
-                    d(n, r, s, S.prev, O, Y), g && Y.reach > g.reach && (g.reach = Y.reach);
+                    g(n, a, s, S.prev, O, Y), d && Y.reach > d.reach && (d.reach = Y.reach);
                   }
                 }
               }
@@ -516,57 +516,57 @@ var ve = Object.create, Z = Object.defineProperty, ke = Object.defineProperties,
           }
       }
       function b() {
-        var n = { value: null, prev: null, next: null }, r = { value: null, prev: n, next: null };
-        n.next = r, this.head = n, this.tail = r, this.length = 0;
+        var n = { value: null, prev: null, next: null }, a = { value: null, prev: n, next: null };
+        n.next = a, this.head = n, this.tail = a, this.length = 0;
       }
-      function f(n, r, s) {
-        var u = r.next, l = { value: s, prev: r, next: u };
-        return r.next = l, u.prev = l, n.length++, l;
+      function y(n, a, s) {
+        var c = a.next, l = { value: s, prev: a, next: c };
+        return a.next = l, c.prev = l, n.length++, l;
       }
-      function v(n, r, s) {
-        for (var u = r.next, l = 0; l < s && u !== n.tail; l++)
-          u = u.next;
-        r.next = u, u.prev = r, n.length -= l;
+      function v(n, a, s) {
+        for (var c = a.next, l = 0; l < s && c !== n.tail; l++)
+          c = c.next;
+        a.next = c, c.prev = a, n.length -= l;
       }
       function w(n) {
-        for (var r = [], s = n.head.next; s !== n.tail; )
-          r.push(s.value), s = s.next;
-        return r;
+        for (var a = [], s = n.head.next; s !== n.tail; )
+          a.push(s.value), s = s.next;
+        return a;
       }
-      return c;
+      return u;
     }();
-    t.exports = a, a.default = a;
+    t.exports = r, r.default = r;
   }
-}), o = Fe(Te());
+}), o = Te(Re());
 o.languages.markup = { comment: { pattern: /<!--(?:(?!<!--)[\s\S])*?-->/, greedy: !0 }, prolog: { pattern: /<\?[\s\S]+?\?>/, greedy: !0 }, doctype: { pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i, greedy: !0, inside: { "internal-subset": { pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/, lookbehind: !0, greedy: !0, inside: null }, string: { pattern: /"[^"]*"|'[^']*'/, greedy: !0 }, punctuation: /^<!|>$|[[\]]/, "doctype-tag": /^DOCTYPE/i, name: /[^\s<>'"]+/ } }, cdata: { pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i, greedy: !0 }, tag: { pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/, greedy: !0, inside: { tag: { pattern: /^<\/?[^\s>\/]+/, inside: { punctuation: /^<\/?/, namespace: /^[^\s>\/:]+:/ } }, "special-attr": [], "attr-value": { pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/, inside: { punctuation: [{ pattern: /^=/, alias: "attr-equals" }, { pattern: /^(\s*)["']|["']$/, lookbehind: !0 }] } }, punctuation: /\/?>/, "attr-name": { pattern: /[^\s>\/]+/, inside: { namespace: /^[^\s>\/:]+:/ } } } }, entity: [{ pattern: /&[\da-z]{1,8};/i, alias: "named-entity" }, /&#x?[\da-f]{1,8};/i] }, o.languages.markup.tag.inside["attr-value"].inside.entity = o.languages.markup.entity, o.languages.markup.doctype.inside["internal-subset"].inside = o.languages.markup, o.hooks.add("wrap", function(e) {
   e.type === "entity" && (e.attributes.title = e.content.replace(/&amp;/, "&"));
 }), Object.defineProperty(o.languages.markup.tag, "addInlined", { value: function(e, i) {
-  var a = {}, a = (a["language-" + i] = { pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i, lookbehind: !0, inside: o.languages[i] }, a.cdata = /^<!\[CDATA\[|\]\]>$/i, { "included-cdata": { pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i, inside: a } }), i = (a["language-" + i] = { pattern: /[\s\S]+/, inside: o.languages[i] }, {});
+  var r = {}, r = (r["language-" + i] = { pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i, lookbehind: !0, inside: o.languages[i] }, r.cdata = /^<!\[CDATA\[|\]\]>$/i, { "included-cdata": { pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i, inside: r } }), i = (r["language-" + i] = { pattern: /[\s\S]+/, inside: o.languages[i] }, {});
   i[e] = { pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
     return e;
-  }), "i"), lookbehind: !0, greedy: !0, inside: a }, o.languages.insertBefore("markup", "cdata", i);
+  }), "i"), lookbehind: !0, greedy: !0, inside: r }, o.languages.insertBefore("markup", "cdata", i);
 } }), Object.defineProperty(o.languages.markup.tag, "addAttribute", { value: function(e, t) {
   o.languages.markup.tag.inside["special-attr"].push({ pattern: RegExp(/(^|["'\s])/.source + "(?:" + e + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source, "i"), lookbehind: !0, inside: { "attr-name": /^[^\s=]+/, "attr-value": { pattern: /=[\s\S]+/, inside: { value: { pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/, lookbehind: !0, alias: [t, "language-" + t], inside: o.languages[t] }, punctuation: [{ pattern: /^=/, alias: "attr-equals" }, /"|'/] } } } });
 } }), o.languages.html = o.languages.markup, o.languages.mathml = o.languages.markup, o.languages.svg = o.languages.markup, o.languages.xml = o.languages.extend("markup", {}), o.languages.ssml = o.languages.xml, o.languages.atom = o.languages.xml, o.languages.rss = o.languages.xml, function(e) {
-  var t = { pattern: /\\[\\(){}[\]^$+*?|.]/, alias: "escape" }, a = /\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/, i = "(?:[^\\\\-]|" + a.source + ")", i = RegExp(i + "-" + i), y = { pattern: /(<|')[^<>']+(?=[>']$)/, lookbehind: !0, alias: "variable" };
-  e.languages.regex = { "char-class": { pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/, lookbehind: !0, inside: { "char-class-negation": { pattern: /(^\[)\^/, lookbehind: !0, alias: "operator" }, "char-class-punctuation": { pattern: /^\[|\]$/, alias: "punctuation" }, range: { pattern: i, inside: { escape: a, "range-punctuation": { pattern: /-/, alias: "operator" } } }, "special-escape": t, "char-set": { pattern: /\\[wsd]|\\p\{[^{}]+\}/i, alias: "class-name" }, escape: a } }, "special-escape": t, "char-set": { pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i, alias: "class-name" }, backreference: [{ pattern: /\\(?![123][0-7]{2})[1-9]/, alias: "keyword" }, { pattern: /\\k<[^<>']+>/, alias: "keyword", inside: { "group-name": y } }], anchor: { pattern: /[$^]|\\[ABbGZz]/, alias: "function" }, escape: a, group: [{ pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/, alias: "punctuation", inside: { "group-name": y } }, { pattern: /\)/, alias: "punctuation" }], quantifier: { pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/, alias: "number" }, alternation: { pattern: /\|/, alias: "keyword" } };
+  var t = { pattern: /\\[\\(){}[\]^$+*?|.]/, alias: "escape" }, r = /\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/, i = "(?:[^\\\\-]|" + r.source + ")", i = RegExp(i + "-" + i), f = { pattern: /(<|')[^<>']+(?=[>']$)/, lookbehind: !0, alias: "variable" };
+  e.languages.regex = { "char-class": { pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/, lookbehind: !0, inside: { "char-class-negation": { pattern: /(^\[)\^/, lookbehind: !0, alias: "operator" }, "char-class-punctuation": { pattern: /^\[|\]$/, alias: "punctuation" }, range: { pattern: i, inside: { escape: r, "range-punctuation": { pattern: /-/, alias: "operator" } } }, "special-escape": t, "char-set": { pattern: /\\[wsd]|\\p\{[^{}]+\}/i, alias: "class-name" }, escape: r } }, "special-escape": t, "char-set": { pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i, alias: "class-name" }, backreference: [{ pattern: /\\(?![123][0-7]{2})[1-9]/, alias: "keyword" }, { pattern: /\\k<[^<>']+>/, alias: "keyword", inside: { "group-name": f } }], anchor: { pattern: /[$^]|\\[ABbGZz]/, alias: "function" }, escape: r, group: [{ pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/, alias: "punctuation", inside: { "group-name": f } }, { pattern: /\)/, alias: "punctuation" }], quantifier: { pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/, alias: "number" }, alternation: { pattern: /\|/, alias: "keyword" } };
 }(o), o.languages.clike = { comment: [{ pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/, lookbehind: !0, greedy: !0 }, { pattern: /(^|[^\\:])\/\/.*/, lookbehind: !0, greedy: !0 }], string: { pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, greedy: !0 }, "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: /\b(?:false|true)\b/, function: /\b\w+(?=\()/, number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i, operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/, punctuation: /[{}[\];(),.:]/ }, o.languages.javascript = o.languages.extend("clike", { "class-name": [o.languages.clike["class-name"], { pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/, lookbehind: !0 }], keyword: [{ pattern: /((?:^|\})\s*)catch\b/, lookbehind: !0 }, { pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/, lookbehind: !0 }], function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/, number: { pattern: RegExp(/(^|[^\w$])/.source + "(?:" + /NaN|Infinity/.source + "|" + /0[bB][01]+(?:_[01]+)*n?/.source + "|" + /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + /\d+(?:_\d+)*n/.source + "|" + /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source + ")" + /(?![\w$])/.source), lookbehind: !0 }, operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/ }), o.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, o.languages.insertBefore("javascript", "keyword", { regex: { pattern: RegExp(/((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + /\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source), lookbehind: !0, greedy: !0, inside: { "regex-source": { pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/, lookbehind: !0, alias: "language-regex", inside: o.languages.regex }, "regex-delimiter": /^\/|\/$/, "regex-flags": /^[a-z]+$/ } }, "function-variable": { pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/, alias: "function" }, parameter: [{ pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/, lookbehind: !0, inside: o.languages.javascript }, { pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i, lookbehind: !0, inside: o.languages.javascript }, { pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/, lookbehind: !0, inside: o.languages.javascript }, { pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/, lookbehind: !0, inside: o.languages.javascript }], constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/ }), o.languages.insertBefore("javascript", "string", { hashbang: { pattern: /^#!.*/, greedy: !0, alias: "comment" }, "template-string": { pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/, greedy: !0, inside: { "template-punctuation": { pattern: /^`|`$/, alias: "string" }, interpolation: { pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/, lookbehind: !0, inside: { "interpolation-punctuation": { pattern: /^\$\{|\}$/, alias: "punctuation" }, rest: o.languages.javascript } }, string: /[\s\S]+/ } }, "string-property": { pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m, lookbehind: !0, greedy: !0, alias: "property" } }), o.languages.insertBefore("javascript", "operator", { "literal-property": { pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m, lookbehind: !0, alias: "property" } }), o.languages.markup && (o.languages.markup.tag.addInlined("script", "javascript"), o.languages.markup.tag.addAttribute(/on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source, "javascript")), o.languages.js = o.languages.javascript, o.languages.actionscript = o.languages.extend("javascript", { keyword: /\b(?:as|break|case|catch|class|const|default|delete|do|dynamic|each|else|extends|final|finally|for|function|get|if|implements|import|in|include|instanceof|interface|internal|is|namespace|native|new|null|override|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|use|var|void|while|with)\b/, operator: /\+\+|--|(?:[+\-*\/%^]|&&?|\|\|?|<<?|>>?>?|[!=]=?)=?|[~?@]/ }), o.languages.actionscript["class-name"].alias = "function", delete o.languages.actionscript.parameter, delete o.languages.actionscript["literal-property"], o.languages.markup && o.languages.insertBefore("actionscript", "string", { xml: { pattern: /(^|[^.])<\/?\w+(?:\s+[^\s>\/=]+=("|')(?:\\[\s\S]|(?!\2)[^\\])*\2)*\s*\/?>/, lookbehind: !0, inside: o.languages.markup } }), function(e) {
-  var t = /#(?!\{).+/, a = { pattern: /#\{[^}]+\}/, alias: "variable" };
-  e.languages.coffeescript = e.languages.extend("javascript", { comment: t, string: [{ pattern: /'(?:\\[\s\S]|[^\\'])*'/, greedy: !0 }, { pattern: /"(?:\\[\s\S]|[^\\"])*"/, greedy: !0, inside: { interpolation: a } }], keyword: /\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/, "class-member": { pattern: /@(?!\d)\w+/, alias: "variable" } }), e.languages.insertBefore("coffeescript", "comment", { "multiline-comment": { pattern: /###[\s\S]+?###/, alias: "comment" }, "block-regex": { pattern: /\/{3}[\s\S]*?\/{3}/, alias: "regex", inside: { comment: t, interpolation: a } } }), e.languages.insertBefore("coffeescript", "string", { "inline-javascript": { pattern: /`(?:\\[\s\S]|[^\\`])*`/, inside: { delimiter: { pattern: /^`|`$/, alias: "punctuation" }, script: { pattern: /[\s\S]+/, alias: "language-javascript", inside: e.languages.javascript } } }, "multiline-string": [{ pattern: /'''[\s\S]*?'''/, greedy: !0, alias: "string" }, { pattern: /"""[\s\S]*?"""/, greedy: !0, alias: "string", inside: { interpolation: a } }] }), e.languages.insertBefore("coffeescript", "keyword", { property: /(?!\d)\w+(?=\s*:(?!:))/ }), delete e.languages.coffeescript["template-string"], e.languages.coffee = e.languages.coffeescript;
+  var t = /#(?!\{).+/, r = { pattern: /#\{[^}]+\}/, alias: "variable" };
+  e.languages.coffeescript = e.languages.extend("javascript", { comment: t, string: [{ pattern: /'(?:\\[\s\S]|[^\\'])*'/, greedy: !0 }, { pattern: /"(?:\\[\s\S]|[^\\"])*"/, greedy: !0, inside: { interpolation: r } }], keyword: /\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/, "class-member": { pattern: /@(?!\d)\w+/, alias: "variable" } }), e.languages.insertBefore("coffeescript", "comment", { "multiline-comment": { pattern: /###[\s\S]+?###/, alias: "comment" }, "block-regex": { pattern: /\/{3}[\s\S]*?\/{3}/, alias: "regex", inside: { comment: t, interpolation: r } } }), e.languages.insertBefore("coffeescript", "string", { "inline-javascript": { pattern: /`(?:\\[\s\S]|[^\\`])*`/, inside: { delimiter: { pattern: /^`|`$/, alias: "punctuation" }, script: { pattern: /[\s\S]+/, alias: "language-javascript", inside: e.languages.javascript } } }, "multiline-string": [{ pattern: /'''[\s\S]*?'''/, greedy: !0, alias: "string" }, { pattern: /"""[\s\S]*?"""/, greedy: !0, alias: "string", inside: { interpolation: r } }] }), e.languages.insertBefore("coffeescript", "keyword", { property: /(?!\d)\w+(?=\s*:(?!:))/ }), delete e.languages.coffeescript["template-string"], e.languages.coffee = e.languages.coffeescript;
 }(o), function(e) {
   var t = e.languages.javadoclike = { parameter: { pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*@(?:arg|arguments|param)\s+)\w+/m, lookbehind: !0 }, keyword: { pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*|\{)@[a-z][a-zA-Z-]+\b/m, lookbehind: !0 }, punctuation: /[{}]/ };
-  Object.defineProperty(t, "addSupport", { value: function(a, i) {
-    (a = typeof a == "string" ? [a] : a).forEach(function(y) {
-      var m = function(f) {
-        f.inside || (f.inside = {}), f.inside.rest = i;
-      }, c = "doc-comment";
-      if (h = e.languages[y]) {
-        var h, p = h[c];
-        if ((p = p || (h = e.languages.insertBefore(y, "comment", { "doc-comment": { pattern: /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/, lookbehind: !0, alias: "comment" } }))[c]) instanceof RegExp && (p = h[c] = { pattern: p }), Array.isArray(p))
-          for (var d = 0, b = p.length; d < b; d++)
-            p[d] instanceof RegExp && (p[d] = { pattern: p[d] }), m(p[d]);
+  Object.defineProperty(t, "addSupport", { value: function(r, i) {
+    (r = typeof r == "string" ? [r] : r).forEach(function(f) {
+      var h = function(y) {
+        y.inside || (y.inside = {}), y.inside.rest = i;
+      }, u = "doc-comment";
+      if (m = e.languages[f]) {
+        var m, p = m[u];
+        if ((p = p || (m = e.languages.insertBefore(f, "comment", { "doc-comment": { pattern: /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/, lookbehind: !0, alias: "comment" } }))[u]) instanceof RegExp && (p = m[u] = { pattern: p }), Array.isArray(p))
+          for (var g = 0, b = p.length; g < b; g++)
+            p[g] instanceof RegExp && (p[g] = { pattern: p[g] }), h(p[g]);
         else
-          m(p);
+          h(p);
       }
     });
   } }), t.addSupport(["java", "javascript", "php"], t);
@@ -574,212 +574,212 @@ o.languages.markup = { comment: { pattern: /<!--(?:(?!<!--)[\s\S])*?-->/, greedy
   var t = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/, t = (e.languages.css = { comment: /\/\*[\s\S]*?\*\//, atrule: { pattern: RegExp("@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + t.source + ")*?" + /(?:;|(?=\s*\{))/.source), inside: { 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 } } }, url: { pattern: RegExp("\\burl\\((?:" + t.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"), greedy: !0, inside: { function: /^url/i, punctuation: /^\(|\)$/, string: { pattern: RegExp("^" + t.source + "$"), alias: "url" } } }, selector: { pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + t.source + ")*(?=\\s*\\{)"), lookbehind: !0 }, string: { pattern: t, greedy: !0 }, property: { pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i, lookbehind: !0 }, important: /!important\b/i, function: { pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i, lookbehind: !0 }, punctuation: /[(){};:,]/ }, e.languages.css.atrule.inside.rest = e.languages.css, e.languages.markup);
   t && (t.tag.addInlined("style", "css"), t.tag.addAttribute("style", "css"));
 }(o), function(e) {
-  var t = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, t = (e.languages.css.selector = { pattern: e.languages.css.selector.pattern, lookbehind: !0, inside: t = { "pseudo-element": /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/, "pseudo-class": /:[-\w]+/, class: /\.[-\w]+/, id: /#[-\w]+/, attribute: { pattern: RegExp(`\\[(?:[^[\\]"']|` + t.source + ")*\\]"), 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": [t, { pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/, 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: />|\+|~|\|\|/, punctuation: /[(),]/ } }, e.languages.css.atrule.inside["selector-function-argument"].inside = t, e.languages.insertBefore("css", "property", { variable: { pattern: /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i, lookbehind: !0 } }), { pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/, lookbehind: !0 }), a = { pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/, lookbehind: !0 };
-  e.languages.insertBefore("css", "function", { operator: { pattern: /(\s)[+\-*\/](?=\s)/, lookbehind: !0 }, hexcode: { pattern: /\B#[\da-f]{3,8}\b/i, alias: "color" }, color: [{ pattern: /(^|[^\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|RebeccaPurple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|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: { unit: t, number: a, function: /[\w-]+(?=\()/, punctuation: /[(),]/ } }], entity: /\\[\da-f]{1,8}/i, unit: t, number: a });
+  var t = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, t = (e.languages.css.selector = { pattern: e.languages.css.selector.pattern, lookbehind: !0, inside: t = { "pseudo-element": /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/, "pseudo-class": /:[-\w]+/, class: /\.[-\w]+/, id: /#[-\w]+/, attribute: { pattern: RegExp(`\\[(?:[^[\\]"']|` + t.source + ")*\\]"), 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": [t, { pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/, 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: />|\+|~|\|\|/, punctuation: /[(),]/ } }, e.languages.css.atrule.inside["selector-function-argument"].inside = t, e.languages.insertBefore("css", "property", { variable: { pattern: /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i, lookbehind: !0 } }), { pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/, lookbehind: !0 }), r = { pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/, lookbehind: !0 };
+  e.languages.insertBefore("css", "function", { operator: { pattern: /(\s)[+\-*\/](?=\s)/, lookbehind: !0 }, hexcode: { pattern: /\B#[\da-f]{3,8}\b/i, alias: "color" }, color: [{ pattern: /(^|[^\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|RebeccaPurple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|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: { unit: t, number: r, function: /[\w-]+(?=\()/, punctuation: /[(),]/ } }], entity: /\\[\da-f]{1,8}/i, unit: t, number: r });
 }(o), function(e) {
-  var t = /[*&][^\s[\]{},]+/, a = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, i = "(?:" + a.source + "(?:[ 	]+" + t.source + ")?|" + t.source + "(?:[ 	]+" + a.source + ")?)", y = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(/<PLAIN>/g, function() {
+  var t = /[*&][^\s[\]{},]+/, r = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, i = "(?:" + r.source + "(?:[ 	]+" + t.source + ")?|" + t.source + "(?:[ 	]+" + r.source + ")?)", f = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(/<PLAIN>/g, function() {
     return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
-  }), m = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
-  function c(h, p) {
+  }), h = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
+  function u(m, p) {
     p = (p || "").replace(/m/g, "") + "m";
-    var d = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
+    var g = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
       return i;
     }).replace(/<<value>>/g, function() {
-      return h;
+      return m;
     });
-    return RegExp(d, p);
+    return RegExp(g, p);
   }
   e.languages.yaml = { scalar: { pattern: RegExp(/([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(/<<prop>>/g, function() {
     return i;
   })), lookbehind: !0, alias: "string" }, comment: /#.*/, key: { pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
     return i;
   }).replace(/<<key>>/g, function() {
-    return "(?:" + y + "|" + m + ")";
-  })), lookbehind: !0, greedy: !0, alias: "atrule" }, directive: { pattern: /(^[ \t]*)%.+/m, lookbehind: !0, alias: "important" }, datetime: { pattern: c(/\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source), lookbehind: !0, alias: "number" }, boolean: { pattern: c(/false|true/.source, "i"), lookbehind: !0, alias: "important" }, null: { pattern: c(/null|~/.source, "i"), lookbehind: !0, alias: "important" }, string: { pattern: c(m), lookbehind: !0, greedy: !0 }, number: { pattern: c(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, "i"), lookbehind: !0 }, tag: a, important: t, punctuation: /---|[:[\]{}\-,|>?]|\.\.\./ }, e.languages.yml = e.languages.yaml;
+    return "(?:" + f + "|" + h + ")";
+  })), lookbehind: !0, greedy: !0, alias: "atrule" }, directive: { pattern: /(^[ \t]*)%.+/m, lookbehind: !0, alias: "important" }, datetime: { pattern: u(/\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source), lookbehind: !0, alias: "number" }, boolean: { pattern: u(/false|true/.source, "i"), lookbehind: !0, alias: "important" }, null: { pattern: u(/null|~/.source, "i"), lookbehind: !0, alias: "important" }, string: { pattern: u(h), lookbehind: !0, greedy: !0 }, number: { pattern: u(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, "i"), lookbehind: !0 }, tag: r, important: t, punctuation: /---|[:[\]{}\-,|>?]|\.\.\./ }, e.languages.yml = e.languages.yaml;
 }(o), function(e) {
   var t = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
-  function a(d) {
-    return d = d.replace(/<inner>/g, function() {
+  function r(g) {
+    return g = g.replace(/<inner>/g, function() {
       return t;
-    }), RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + d + ")");
+    }), RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + g + ")");
   }
-  var i = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source, y = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function() {
+  var i = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source, f = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function() {
     return i;
-  }), m = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source, c = (e.languages.markdown = e.languages.extend("markup", {}), e.languages.insertBefore("markdown", "prolog", { "front-matter-block": { pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/, lookbehind: !0, greedy: !0, inside: { punctuation: /^---|---$/, "front-matter": { pattern: /\S+(?:\s+\S+)*/, alias: ["yaml", "language-yaml"], inside: e.languages.yaml } } }, blockquote: { pattern: /^>(?:[\t ]*>)*/m, alias: "punctuation" }, table: { pattern: RegExp("^" + y + m + "(?:" + y + ")*", "m"), inside: { "table-data-rows": { pattern: RegExp("^(" + y + m + ")(?:" + y + ")*$"), lookbehind: !0, inside: { "table-data": { pattern: RegExp(i), inside: e.languages.markdown }, punctuation: /\|/ } }, "table-line": { pattern: RegExp("^(" + y + ")" + m + "$"), lookbehind: !0, inside: { punctuation: /\||:?-{3,}:?/ } }, "table-header-row": { pattern: RegExp("^" + y + "$"), inside: { "table-header": { pattern: RegExp(i), alias: "important", inside: e.languages.markdown }, punctuation: /\|/ } } } }, code: [{ pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/, lookbehind: !0, alias: "keyword" }, { pattern: /^```[\s\S]*?^```$/m, greedy: !0, inside: { "code-block": { pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m, lookbehind: !0 }, "code-language": { pattern: /^(```).+/, lookbehind: !0 }, punctuation: /```/ } }], title: [{ pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m, alias: "important", inside: { punctuation: /==+$|--+$/ } }, { pattern: /(^\s*)#.+/m, lookbehind: !0, alias: "important", inside: { punctuation: /^#+|#+$/ } }], hr: { pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m, lookbehind: !0, alias: "punctuation" }, list: { pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m, lookbehind: !0, alias: "punctuation" }, "url-reference": { pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/, inside: { variable: { pattern: /^(!?\[)[^\]]+/, lookbehind: !0 }, string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/, punctuation: /^[\[\]!:]|[<>]/ }, alias: "url" }, bold: { pattern: a(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^..)[\s\S]+(?=..$)/, lookbehind: !0, inside: {} }, punctuation: /\*\*|__/ } }, italic: { pattern: a(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^.)[\s\S]+(?=.$)/, lookbehind: !0, inside: {} }, punctuation: /[*_]/ } }, strike: { pattern: a(/(~~?)(?:(?!~)<inner>)+\2/.source), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^~~?)[\s\S]+(?=\1$)/, lookbehind: !0, inside: {} }, punctuation: /~~?/ } }, "code-snippet": { pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/, lookbehind: !0, greedy: !0, alias: ["code", "keyword"] }, url: { pattern: a(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source), lookbehind: !0, greedy: !0, inside: { operator: /^!/, content: { pattern: /(^\[)[^\]]+(?=\])/, lookbehind: !0, inside: {} }, variable: { pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/, lookbehind: !0 }, url: { pattern: /(^\]\()[^\s)]+/, lookbehind: !0 }, string: { pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/, lookbehind: !0 } } } }), ["url", "bold", "italic", "strike"].forEach(function(d) {
+  }), h = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source, u = (e.languages.markdown = e.languages.extend("markup", {}), e.languages.insertBefore("markdown", "prolog", { "front-matter-block": { pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/, lookbehind: !0, greedy: !0, inside: { punctuation: /^---|---$/, "front-matter": { pattern: /\S+(?:\s+\S+)*/, alias: ["yaml", "language-yaml"], inside: e.languages.yaml } } }, blockquote: { pattern: /^>(?:[\t ]*>)*/m, alias: "punctuation" }, table: { pattern: RegExp("^" + f + h + "(?:" + f + ")*", "m"), inside: { "table-data-rows": { pattern: RegExp("^(" + f + h + ")(?:" + f + ")*$"), lookbehind: !0, inside: { "table-data": { pattern: RegExp(i), inside: e.languages.markdown }, punctuation: /\|/ } }, "table-line": { pattern: RegExp("^(" + f + ")" + h + "$"), lookbehind: !0, inside: { punctuation: /\||:?-{3,}:?/ } }, "table-header-row": { pattern: RegExp("^" + f + "$"), inside: { "table-header": { pattern: RegExp(i), alias: "important", inside: e.languages.markdown }, punctuation: /\|/ } } } }, code: [{ pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/, lookbehind: !0, alias: "keyword" }, { pattern: /^```[\s\S]*?^```$/m, greedy: !0, inside: { "code-block": { pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m, lookbehind: !0 }, "code-language": { pattern: /^(```).+/, lookbehind: !0 }, punctuation: /```/ } }], title: [{ pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m, alias: "important", inside: { punctuation: /==+$|--+$/ } }, { pattern: /(^\s*)#.+/m, lookbehind: !0, alias: "important", inside: { punctuation: /^#+|#+$/ } }], hr: { pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m, lookbehind: !0, alias: "punctuation" }, list: { pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m, lookbehind: !0, alias: "punctuation" }, "url-reference": { pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/, inside: { variable: { pattern: /^(!?\[)[^\]]+/, lookbehind: !0 }, string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/, punctuation: /^[\[\]!:]|[<>]/ }, alias: "url" }, bold: { pattern: r(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^..)[\s\S]+(?=..$)/, lookbehind: !0, inside: {} }, punctuation: /\*\*|__/ } }, italic: { pattern: r(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^.)[\s\S]+(?=.$)/, lookbehind: !0, inside: {} }, punctuation: /[*_]/ } }, strike: { pattern: r(/(~~?)(?:(?!~)<inner>)+\2/.source), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^~~?)[\s\S]+(?=\1$)/, lookbehind: !0, inside: {} }, punctuation: /~~?/ } }, "code-snippet": { pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/, lookbehind: !0, greedy: !0, alias: ["code", "keyword"] }, url: { pattern: r(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source), lookbehind: !0, greedy: !0, inside: { operator: /^!/, content: { pattern: /(^\[)[^\]]+(?=\])/, lookbehind: !0, inside: {} }, variable: { pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/, lookbehind: !0 }, url: { pattern: /(^\]\()[^\s)]+/, lookbehind: !0 }, string: { pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/, lookbehind: !0 } } } }), ["url", "bold", "italic", "strike"].forEach(function(g) {
     ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(b) {
-      d !== b && (e.languages.markdown[d].inside.content.inside[b] = e.languages.markdown[b]);
+      g !== b && (e.languages.markdown[g].inside.content.inside[b] = e.languages.markdown[b]);
     });
-  }), e.hooks.add("after-tokenize", function(d) {
-    d.language !== "markdown" && d.language !== "md" || function b(f) {
-      if (f && typeof f != "string")
-        for (var v = 0, w = f.length; v < w; v++) {
-          var n, r = f[v];
-          r.type !== "code" ? b(r.content) : (n = r.content[1], r = r.content[3], n && r && n.type === "code-language" && r.type === "code-block" && typeof n.content == "string" && (n = n.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp"), n = "language-" + (n = (/[a-z][\w-]*/i.exec(n) || [""])[0].toLowerCase()), r.alias ? typeof r.alias == "string" ? r.alias = [r.alias, n] : r.alias.push(n) : r.alias = [n]));
+  }), e.hooks.add("after-tokenize", function(g) {
+    g.language !== "markdown" && g.language !== "md" || function b(y) {
+      if (y && typeof y != "string")
+        for (var v = 0, w = y.length; v < w; v++) {
+          var n, a = y[v];
+          a.type !== "code" ? b(a.content) : (n = a.content[1], a = a.content[3], n && a && n.type === "code-language" && a.type === "code-block" && typeof n.content == "string" && (n = n.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp"), n = "language-" + (n = (/[a-z][\w-]*/i.exec(n) || [""])[0].toLowerCase()), a.alias ? typeof a.alias == "string" ? a.alias = [a.alias, n] : a.alias.push(n) : a.alias = [n]));
         }
-    }(d.tokens);
-  }), e.hooks.add("wrap", function(d) {
-    if (d.type === "code-block") {
-      for (var b = "", f = 0, v = d.classes.length; f < v; f++) {
-        var w = d.classes[f], w = /language-(.+)/.exec(w);
+    }(g.tokens);
+  }), e.hooks.add("wrap", function(g) {
+    if (g.type === "code-block") {
+      for (var b = "", y = 0, v = g.classes.length; y < v; y++) {
+        var w = g.classes[y], w = /language-(.+)/.exec(w);
         if (w) {
           b = w[1];
           break;
         }
       }
-      var n, r = e.languages[b];
-      r ? d.content = e.highlight(function(s) {
-        return s = s.replace(c, ""), s = s.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(u, l) {
-          var g;
-          return (l = l.toLowerCase())[0] === "#" ? (g = l[1] === "x" ? parseInt(l.slice(2), 16) : Number(l.slice(1)), p(g)) : h[l] || u;
+      var n, a = e.languages[b];
+      a ? g.content = e.highlight(function(s) {
+        return s = s.replace(u, ""), s = s.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(c, l) {
+          var d;
+          return (l = l.toLowerCase())[0] === "#" ? (d = l[1] === "x" ? parseInt(l.slice(2), 16) : Number(l.slice(1)), p(d)) : m[l] || c;
         });
-      }(d.content), r, b) : b && b !== "none" && e.plugins.autoloader && (n = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(1e16 * Math.random()), d.attributes.id = n, e.plugins.autoloader.loadLanguages(b, function() {
+      }(g.content), a, b) : b && b !== "none" && e.plugins.autoloader && (n = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(1e16 * Math.random()), g.attributes.id = n, e.plugins.autoloader.loadLanguages(b, function() {
         var s = document.getElementById(n);
         s && (s.innerHTML = e.highlight(s.textContent, e.languages[b], b));
       }));
     }
-  }), RegExp(e.languages.markup.tag.pattern.source, "gi")), h = { amp: "&", lt: "<", gt: ">", quot: '"' }, p = String.fromCodePoint || String.fromCharCode;
+  }), RegExp(e.languages.markup.tag.pattern.source, "gi")), m = { amp: "&", lt: "<", gt: ">", quot: '"' }, p = String.fromCodePoint || String.fromCharCode;
   e.languages.md = e.languages.markdown;
 }(o), o.languages.graphql = { comment: /#.*/, description: { pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i, greedy: !0, alias: "string", inside: { "language-markdown": { pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/, lookbehind: !0, inside: o.languages.markdown } } }, string: { pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/, greedy: !0 }, number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i, boolean: /\b(?:false|true)\b/, variable: /\$[a-z_]\w*/i, directive: { pattern: /@[a-z_]\w*/i, alias: "function" }, "attr-name": { pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i, 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))[a-zA-Z_]\w*/, lookbehind: !0, alias: "function" }, "definition-mutation": { pattern: /(\bmutation\s+)[a-zA-Z_]\w*/, lookbehind: !0, alias: "function" }, "definition-query": { pattern: /(\bquery\s+)[a-zA-Z_]\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+/ }, o.hooks.add("after-tokenize", function(e) {
   if (e.language === "graphql")
     for (var t = e.tokens.filter(function(n) {
       return typeof n != "string" && n.type !== "comment" && n.type !== "scalar";
-    }), a = 0; a < t.length; ) {
-      var i = t[a++];
+    }), r = 0; r < t.length; ) {
+      var i = t[r++];
       if (i.type === "keyword" && i.content === "mutation") {
-        var y = [];
-        if (f(["definition-mutation", "punctuation"]) && b(1).content === "(") {
-          a += 2;
-          var m = v(/^\($/, /^\)$/);
-          if (m === -1)
+        var f = [];
+        if (y(["definition-mutation", "punctuation"]) && b(1).content === "(") {
+          r += 2;
+          var h = v(/^\($/, /^\)$/);
+          if (h === -1)
             continue;
-          for (; a < m; a++) {
-            var c = b(0);
-            c.type === "variable" && (w(c, "variable-input"), y.push(c.content));
+          for (; r < h; r++) {
+            var u = b(0);
+            u.type === "variable" && (w(u, "variable-input"), f.push(u.content));
           }
-          a = m + 1;
+          r = h + 1;
         }
-        if (f(["punctuation", "property-query"]) && b(0).content === "{" && (a++, w(b(0), "property-mutation"), 0 < y.length)) {
-          var h = v(/^\{$/, /^\}$/);
-          if (h !== -1)
-            for (var p = a; p < h; p++) {
-              var d = t[p];
-              d.type === "variable" && 0 <= y.indexOf(d.content) && w(d, "variable-input");
+        if (y(["punctuation", "property-query"]) && b(0).content === "{" && (r++, w(b(0), "property-mutation"), 0 < f.length)) {
+          var m = v(/^\{$/, /^\}$/);
+          if (m !== -1)
+            for (var p = r; p < m; p++) {
+              var g = t[p];
+              g.type === "variable" && 0 <= f.indexOf(g.content) && w(g, "variable-input");
             }
         }
       }
     }
   function b(n) {
-    return t[a + n];
+    return t[r + n];
   }
-  function f(n, r) {
-    r = r || 0;
+  function y(n, a) {
+    a = a || 0;
     for (var s = 0; s < n.length; s++) {
-      var u = b(s + r);
-      if (!u || u.type !== n[s])
+      var c = b(s + a);
+      if (!c || c.type !== n[s])
         return;
     }
     return 1;
   }
-  function v(n, r) {
-    for (var s = 1, u = a; u < t.length; u++) {
-      var l = t[u], g = l.content;
-      if (l.type === "punctuation" && typeof g == "string") {
-        if (n.test(g))
+  function v(n, a) {
+    for (var s = 1, c = r; c < t.length; c++) {
+      var l = t[c], d = l.content;
+      if (l.type === "punctuation" && typeof d == "string") {
+        if (n.test(d))
           s++;
-        else if (r.test(g) && --s === 0)
-          return u;
+        else if (a.test(d) && --s === 0)
+          return c;
       }
     }
     return -1;
   }
-  function w(n, r) {
+  function w(n, a) {
     var s = n.alias;
-    s ? Array.isArray(s) || (n.alias = s = [s]) : n.alias = s = [], s.push(r);
+    s ? Array.isArray(s) || (n.alias = s = [s]) : n.alias = s = [], s.push(a);
   }
 }), o.languages.sql = { comment: { pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/, lookbehind: !0 }, variable: [{ pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/, greedy: !0 }, /@[\w.$]+/], string: { pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/, greedy: !0, lookbehind: !0 }, identifier: { pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/, greedy: !0, lookbehind: !0, inside: { punctuation: /^`|`$/ } }, function: /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i, keyword: /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|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)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|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|INT|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|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|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|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i, boolean: /\b(?:FALSE|NULL|TRUE)\b/i, number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i, operator: /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i, punctuation: /[;[\]()`,.]/ }, function(e) {
-  var t = e.languages.javascript["template-string"], a = t.pattern.source, i = t.inside.interpolation, y = i.inside["interpolation-punctuation"], m = i.pattern.source;
-  function c(f, v) {
-    if (e.languages[f])
-      return { pattern: RegExp("((?:" + v + ")\\s*)" + a), lookbehind: !0, greedy: !0, inside: { "template-punctuation": { pattern: /^`|`$/, alias: "string" }, "embedded-code": { pattern: /[\s\S]+/, alias: f } } };
+  var t = e.languages.javascript["template-string"], r = t.pattern.source, i = t.inside.interpolation, f = i.inside["interpolation-punctuation"], h = i.pattern.source;
+  function u(y, v) {
+    if (e.languages[y])
+      return { pattern: RegExp("((?:" + v + ")\\s*)" + r), lookbehind: !0, greedy: !0, inside: { "template-punctuation": { pattern: /^`|`$/, alias: "string" }, "embedded-code": { pattern: /[\s\S]+/, alias: y } } };
   }
-  function h(f, v, w) {
-    return f = { code: f, grammar: v, language: w }, e.hooks.run("before-tokenize", f), f.tokens = e.tokenize(f.code, f.grammar), e.hooks.run("after-tokenize", f), f.tokens;
+  function m(y, v, w) {
+    return y = { code: y, grammar: v, language: w }, e.hooks.run("before-tokenize", y), y.tokens = e.tokenize(y.code, y.grammar), e.hooks.run("after-tokenize", y), y.tokens;
   }
-  function p(f, v, w) {
-    var s = e.tokenize(f, { interpolation: { pattern: RegExp(m), lookbehind: !0 } }), n = 0, r = {}, s = h(s.map(function(l) {
+  function p(y, v, w) {
+    var s = e.tokenize(y, { interpolation: { pattern: RegExp(h), lookbehind: !0 } }), n = 0, a = {}, s = m(s.map(function(l) {
       if (typeof l == "string")
         return l;
-      for (var g, k, l = l.content; f.indexOf((k = n++, g = "___" + w.toUpperCase() + "_" + k + "___")) !== -1; )
+      for (var d, k, l = l.content; y.indexOf((k = n++, d = "___" + w.toUpperCase() + "_" + k + "___")) !== -1; )
         ;
-      return r[g] = l, g;
-    }).join(""), v, w), u = Object.keys(r);
-    return n = 0, function l(g) {
-      for (var k = 0; k < g.length; k++) {
-        if (n >= u.length)
+      return a[d] = l, d;
+    }).join(""), v, w), c = Object.keys(a);
+    return n = 0, function l(d) {
+      for (var k = 0; k < d.length; k++) {
+        if (n >= c.length)
           return;
-        var x, A, E, _, T, D, C, L = g[k];
-        typeof L == "string" || typeof L.content == "string" ? (x = u[n], (C = (D = typeof L == "string" ? L : L.content).indexOf(x)) !== -1 && (++n, A = D.substring(0, C), T = r[x], E = void 0, (_ = {})["interpolation-punctuation"] = y, (_ = e.tokenize(T, _)).length === 3 && ((E = [1, 1]).push.apply(E, h(_[1], e.languages.javascript, "javascript")), _.splice.apply(_, E)), E = new e.Token("interpolation", _, i.alias, T), _ = D.substring(C + x.length), T = [], A && T.push(A), T.push(E), _ && (l(D = [_]), T.push.apply(T, D)), typeof L == "string" ? (g.splice.apply(g, [k, 1].concat(T)), k += T.length - 1) : L.content = T)) : (C = L.content, Array.isArray(C) ? l(C) : l([C]));
+        var E, A, x, F, T, D, C, L = d[k];
+        typeof L == "string" || typeof L.content == "string" ? (E = c[n], (C = (D = typeof L == "string" ? L : L.content).indexOf(E)) !== -1 && (++n, A = D.substring(0, C), T = a[E], x = void 0, (F = {})["interpolation-punctuation"] = f, (F = e.tokenize(T, F)).length === 3 && ((x = [1, 1]).push.apply(x, m(F[1], e.languages.javascript, "javascript")), F.splice.apply(F, x)), x = new e.Token("interpolation", F, i.alias, T), F = D.substring(C + E.length), T = [], A && T.push(A), T.push(x), F && (l(D = [F]), T.push.apply(T, D)), typeof L == "string" ? (d.splice.apply(d, [k, 1].concat(T)), k += T.length - 1) : L.content = T)) : (C = L.content, Array.isArray(C) ? l(C) : l([C]));
       }
-    }(s), new e.Token(w, s, "language-" + w, f);
+    }(s), new e.Token(w, s, "language-" + w, y);
   }
-  e.languages.javascript["template-string"] = [c("css", /\b(?:styled(?:\([^)]*\))?(?:\s*\.\s*\w+(?:\([^)]*\))*)*|css(?:\s*\.\s*(?:global|resolve))?|createGlobalStyle|keyframes)/.source), c("html", /\bhtml|\.\s*(?:inner|outer)HTML\s*\+?=/.source), c("svg", /\bsvg/.source), c("markdown", /\b(?:markdown|md)/.source), c("graphql", /\b(?:gql|graphql(?:\s*\.\s*experimental)?)/.source), c("sql", /\bsql/.source), t].filter(Boolean);
-  var d = { javascript: !0, js: !0, typescript: !0, ts: !0, jsx: !0, tsx: !0 };
-  function b(f) {
-    return typeof f == "string" ? f : Array.isArray(f) ? f.map(b).join("") : b(f.content);
+  e.languages.javascript["template-string"] = [u("css", /\b(?:styled(?:\([^)]*\))?(?:\s*\.\s*\w+(?:\([^)]*\))*)*|css(?:\s*\.\s*(?:global|resolve))?|createGlobalStyle|keyframes)/.source), u("html", /\bhtml|\.\s*(?:inner|outer)HTML\s*\+?=/.source), u("svg", /\bsvg/.source), u("markdown", /\b(?:markdown|md)/.source), u("graphql", /\b(?:gql|graphql(?:\s*\.\s*experimental)?)/.source), u("sql", /\bsql/.source), t].filter(Boolean);
+  var g = { javascript: !0, js: !0, typescript: !0, ts: !0, jsx: !0, tsx: !0 };
+  function b(y) {
+    return typeof y == "string" ? y : Array.isArray(y) ? y.map(b).join("") : b(y.content);
   }
-  e.hooks.add("after-tokenize", function(f) {
-    f.language in d && function v(w) {
-      for (var n = 0, r = w.length; n < r; n++) {
-        var s, u, l, g = w[n];
-        typeof g != "string" && (s = g.content, Array.isArray(s) ? g.type === "template-string" ? (g = s[1], s.length === 3 && typeof g != "string" && g.type === "embedded-code" && (u = b(g), g = g.alias, g = Array.isArray(g) ? g[0] : g, l = e.languages[g]) && (s[1] = p(u, l, g))) : v(s) : typeof s != "string" && v([s]));
+  e.hooks.add("after-tokenize", function(y) {
+    y.language in g && function v(w) {
+      for (var n = 0, a = w.length; n < a; n++) {
+        var s, c, l, d = w[n];
+        typeof d != "string" && (s = d.content, Array.isArray(s) ? d.type === "template-string" ? (d = s[1], s.length === 3 && typeof d != "string" && d.type === "embedded-code" && (c = b(d), d = d.alias, d = Array.isArray(d) ? d[0] : d, l = e.languages[d]) && (s[1] = p(c, l, d))) : v(s) : typeof s != "string" && v([s]));
       }
-    }(f.tokens);
+    }(y.tokens);
   });
 }(o), function(e) {
   e.languages.typescript = e.languages.extend("javascript", { "class-name": { pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/, lookbehind: !0, greedy: !0, inside: null }, builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/ }), e.languages.typescript.keyword.push(/\b(?:abstract|declare|is|keyof|readonly|require)\b/, /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/, /\btype\b(?=\s*(?:[\{*]|$))/), delete e.languages.typescript.parameter, delete e.languages.typescript["literal-property"];
   var t = e.languages.extend("typescript", {});
   delete t["class-name"], e.languages.typescript["class-name"].inside = t, e.languages.insertBefore("typescript", "function", { decorator: { pattern: /@[$\w\xA0-\uFFFF]+/, inside: { at: { pattern: /^@/, alias: "operator" }, function: /^[\s\S]+/ } }, "generic-function": { pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/, greedy: !0, inside: { function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/, generic: { pattern: /<[\s\S]+/, alias: "class-name", inside: t } } } }), e.languages.ts = e.languages.typescript;
 }(o), function(e) {
-  var t = e.languages.javascript, a = /\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})+\}/.source, i = "(@(?:arg|argument|param|property)\\s+(?:" + a + "\\s+)?)";
+  var t = e.languages.javascript, r = /\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})+\}/.source, i = "(@(?:arg|argument|param|property)\\s+(?:" + r + "\\s+)?)";
   e.languages.jsdoc = e.languages.extend("javadoclike", { parameter: { pattern: RegExp(i + /(?:(?!\s)[$\w\xA0-\uFFFF.])+(?=\s|$)/.source), lookbehind: !0, inside: { punctuation: /\./ } } }), e.languages.insertBefore("jsdoc", "keyword", { "optional-parameter": { pattern: RegExp(i + /\[(?:(?!\s)[$\w\xA0-\uFFFF.])+(?:=[^[\]]+)?\](?=\s|$)/.source), lookbehind: !0, inside: { parameter: { pattern: /(^\[)[$\w\xA0-\uFFFF\.]+/, lookbehind: !0, inside: { punctuation: /\./ } }, code: { pattern: /(=)[\s\S]*(?=\]$)/, lookbehind: !0, inside: t, alias: "language-javascript" }, punctuation: /[=[\]]/ } }, "class-name": [{ pattern: RegExp(/(@(?:augments|class|extends|interface|memberof!?|template|this|typedef)\s+(?:<TYPE>\s+)?)[A-Z]\w*(?:\.[A-Z]\w*)*/.source.replace(/<TYPE>/g, function() {
-    return a;
-  })), lookbehind: !0, inside: { punctuation: /\./ } }, { pattern: RegExp("(@[a-z]+\\s+)" + a), lookbehind: !0, inside: { string: t.string, number: t.number, boolean: t.boolean, keyword: e.languages.typescript.keyword, operator: /=>|\.\.\.|[&|?:*]/, punctuation: /[.,;=<>{}()[\]]/ } }], example: { pattern: /(@example\s+(?!\s))(?:[^@\s]|\s+(?!\s))+?(?=\s*(?:\*\s*)?(?:@\w|\*\/))/, lookbehind: !0, inside: { code: { pattern: /^([\t ]*(?:\*\s*)?)\S.*$/m, lookbehind: !0, inside: t, alias: "language-javascript" } } } }), e.languages.javadoclike.addSupport("javascript", e.languages.jsdoc);
+    return r;
+  })), lookbehind: !0, inside: { punctuation: /\./ } }, { pattern: RegExp("(@[a-z]+\\s+)" + r), lookbehind: !0, inside: { string: t.string, number: t.number, boolean: t.boolean, keyword: e.languages.typescript.keyword, operator: /=>|\.\.\.|[&|?:*]/, punctuation: /[.,;=<>{}()[\]]/ } }], example: { pattern: /(@example\s+(?!\s))(?:[^@\s]|\s+(?!\s))+?(?=\s*(?:\*\s*)?(?:@\w|\*\/))/, lookbehind: !0, inside: { code: { pattern: /^([\t ]*(?:\*\s*)?)\S.*$/m, lookbehind: !0, inside: t, alias: "language-javascript" } } } }), e.languages.javadoclike.addSupport("javascript", e.languages.jsdoc);
 }(o), function(e) {
   e.languages.flow = e.languages.extend("javascript", {}), e.languages.insertBefore("flow", "keyword", { type: [{ pattern: /\b(?:[Bb]oolean|Function|[Nn]umber|[Ss]tring|[Ss]ymbol|any|mixed|null|void)\b/, alias: "class-name" }] }), e.languages.flow["function-variable"].pattern = /(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=\s*(?:function\b|(?:\([^()]*\)(?:\s*:\s*\w+)?|(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/i, delete e.languages.flow.parameter, e.languages.insertBefore("flow", "operator", { "flow-punctuation": { pattern: /\{\||\|\}/, alias: "punctuation" } }), Array.isArray(e.languages.flow.keyword) || (e.languages.flow.keyword = [e.languages.flow.keyword]), e.languages.flow.keyword.unshift({ pattern: /(^|[^$]\b)(?:Class|declare|opaque|type)\b(?!\$)/, lookbehind: !0 }, { pattern: /(^|[^$]\B)\$(?:Diff|Enum|Exact|Keys|ObjMap|PropertyType|Record|Shape|Subtype|Supertype|await)\b(?!\$)/, lookbehind: !0 });
 }(o), o.languages.n4js = o.languages.extend("javascript", { keyword: /\b(?:Array|any|boolean|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|false|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|module|new|null|number|package|private|protected|public|return|set|static|string|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\b/ }), o.languages.insertBefore("n4js", "constant", { annotation: { pattern: /@+\w+/, alias: "operator" } }), o.languages.n4jsd = o.languages.n4js, function(e) {
-  function t(c, h) {
-    return RegExp(c.replace(/<ID>/g, function() {
+  function t(u, m) {
+    return RegExp(u.replace(/<ID>/g, function() {
       return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source;
-    }), h);
+    }), m);
   }
   e.languages.insertBefore("javascript", "function-variable", { "method-variable": { pattern: RegExp("(\\.\\s*)" + e.languages.javascript["function-variable"].pattern.source), lookbehind: !0, alias: ["function-variable", "method", "function", "property-access"] } }), e.languages.insertBefore("javascript", "function", { method: { pattern: RegExp("(\\.\\s*)" + e.languages.javascript.function.source), lookbehind: !0, alias: ["function", "property-access"] } }), e.languages.insertBefore("javascript", "constant", { "known-class-name": [{ pattern: /\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\b/, alias: "class-name" }, { pattern: /\b(?:[A-Z]\w*)Error\b/, alias: "class-name" }] }), e.languages.insertBefore("javascript", "keyword", { imports: { pattern: t(/(\bimport\b\s*)(?:<ID>(?:\s*,\s*(?:\*\s*as\s+<ID>|\{[^{}]*\}))?|\*\s*as\s+<ID>|\{[^{}]*\})(?=\s*\bfrom\b)/.source), lookbehind: !0, inside: e.languages.javascript }, exports: { pattern: t(/(\bexport\b\s*)(?:\*(?:\s*as\s+<ID>)?(?=\s*\bfrom\b)|\{[^{}]*\})/.source), lookbehind: !0, inside: e.languages.javascript } }), e.languages.javascript.keyword.unshift({ pattern: /\b(?:as|default|export|from|import)\b/, alias: "module" }, { pattern: /\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/, alias: "control-flow" }, { pattern: /\bnull\b/, alias: ["null", "nil"] }, { pattern: /\bundefined\b/, alias: "nil" }), e.languages.insertBefore("javascript", "operator", { spread: { pattern: /\.{3}/, alias: "operator" }, arrow: { pattern: /=>/, alias: "operator" } }), e.languages.insertBefore("javascript", "punctuation", { "property-access": { pattern: t(/(\.\s*)#?<ID>/.source), lookbehind: !0 }, "maybe-class-name": { pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/, lookbehind: !0 }, dom: { pattern: /\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\b/, alias: "variable" }, console: { pattern: /\bconsole(?=\s*\.)/, alias: "class-name" } });
-  for (var a = ["function", "function-variable", "method", "method-variable", "property-access"], i = 0; i < a.length; i++) {
-    var m = a[i], y = e.languages.javascript[m], m = (y = e.util.type(y) === "RegExp" ? e.languages.javascript[m] = { pattern: y } : y).inside || {};
-    (y.inside = m)["maybe-class-name"] = /^[A-Z][\s\S]*/;
+  for (var r = ["function", "function-variable", "method", "method-variable", "property-access"], i = 0; i < r.length; i++) {
+    var h = r[i], f = e.languages.javascript[h], h = (f = e.util.type(f) === "RegExp" ? e.languages.javascript[h] = { pattern: f } : f).inside || {};
+    (f.inside = h)["maybe-class-name"] = /^[A-Z][\s\S]*/;
   }
 }(o), function(e) {
-  var t = e.util.clone(e.languages.javascript), a = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source, i = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source, y = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
-  function m(p, d) {
+  var t = e.util.clone(e.languages.javascript), r = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source, i = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source, f = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
+  function h(p, g) {
     return p = p.replace(/<S>/g, function() {
-      return a;
+      return r;
     }).replace(/<BRACES>/g, function() {
       return i;
     }).replace(/<SPREAD>/g, function() {
-      return y;
-    }), RegExp(p, d);
+      return f;
+    }), RegExp(p, g);
   }
-  y = m(y).source, e.languages.jsx = e.languages.extend("markup", t), e.languages.jsx.tag.pattern = m(/<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source), e.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/, e.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/, e.languages.jsx.tag.inside.tag.inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/, e.languages.jsx.tag.inside.comment = t.comment, e.languages.insertBefore("inside", "attr-name", { spread: { pattern: m(/<SPREAD>/.source), inside: e.languages.jsx } }, e.languages.jsx.tag), e.languages.insertBefore("inside", "special-attr", { script: { pattern: m(/=<BRACES>/.source), alias: "language-javascript", inside: { "script-punctuation": { pattern: /^=(?=\{)/, alias: "punctuation" }, rest: e.languages.jsx } } }, e.languages.jsx.tag);
-  function c(p) {
-    for (var d = [], b = 0; b < p.length; b++) {
-      var f = p[b], v = !1;
-      typeof f != "string" && (f.type === "tag" && f.content[0] && f.content[0].type === "tag" ? f.content[0].content[0].content === "</" ? 0 < d.length && d[d.length - 1].tagName === h(f.content[0].content[1]) && d.pop() : f.content[f.content.length - 1].content !== "/>" && d.push({ tagName: h(f.content[0].content[1]), openedBraces: 0 }) : 0 < d.length && f.type === "punctuation" && f.content === "{" ? d[d.length - 1].openedBraces++ : 0 < d.length && 0 < d[d.length - 1].openedBraces && f.type === "punctuation" && f.content === "}" ? d[d.length - 1].openedBraces-- : v = !0), (v || typeof f == "string") && 0 < d.length && d[d.length - 1].openedBraces === 0 && (v = h(f), b < p.length - 1 && (typeof p[b + 1] == "string" || p[b + 1].type === "plain-text") && (v += h(p[b + 1]), p.splice(b + 1, 1)), 0 < b && (typeof p[b - 1] == "string" || p[b - 1].type === "plain-text") && (v = h(p[b - 1]) + v, p.splice(b - 1, 1), b--), p[b] = new e.Token("plain-text", v, null, v)), f.content && typeof f.content != "string" && c(f.content);
+  f = h(f).source, e.languages.jsx = e.languages.extend("markup", t), e.languages.jsx.tag.pattern = h(/<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source), e.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/, e.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/, e.languages.jsx.tag.inside.tag.inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/, e.languages.jsx.tag.inside.comment = t.comment, e.languages.insertBefore("inside", "attr-name", { spread: { pattern: h(/<SPREAD>/.source), inside: e.languages.jsx } }, e.languages.jsx.tag), e.languages.insertBefore("inside", "special-attr", { script: { pattern: h(/=<BRACES>/.source), alias: "language-javascript", inside: { "script-punctuation": { pattern: /^=(?=\{)/, alias: "punctuation" }, rest: e.languages.jsx } } }, e.languages.jsx.tag);
+  function u(p) {
+    for (var g = [], b = 0; b < p.length; b++) {
+      var y = p[b], v = !1;
+      typeof y != "string" && (y.type === "tag" && y.content[0] && y.content[0].type === "tag" ? y.content[0].content[0].content === "</" ? 0 < g.length && g[g.length - 1].tagName === m(y.content[0].content[1]) && g.pop() : y.content[y.content.length - 1].content !== "/>" && g.push({ tagName: m(y.content[0].content[1]), openedBraces: 0 }) : 0 < g.length && y.type === "punctuation" && y.content === "{" ? g[g.length - 1].openedBraces++ : 0 < g.length && 0 < g[g.length - 1].openedBraces && y.type === "punctuation" && y.content === "}" ? g[g.length - 1].openedBraces-- : v = !0), (v || typeof y == "string") && 0 < g.length && g[g.length - 1].openedBraces === 0 && (v = m(y), b < p.length - 1 && (typeof p[b + 1] == "string" || p[b + 1].type === "plain-text") && (v += m(p[b + 1]), p.splice(b + 1, 1)), 0 < b && (typeof p[b - 1] == "string" || p[b - 1].type === "plain-text") && (v = m(p[b - 1]) + v, p.splice(b - 1, 1), b--), p[b] = new e.Token("plain-text", v, null, v)), y.content && typeof y.content != "string" && u(y.content);
     }
   }
-  var h = function(p) {
-    return p ? typeof p == "string" ? p : typeof p.content == "string" ? p.content : p.content.map(h).join("") : "";
+  var m = function(p) {
+    return p ? typeof p == "string" ? p : typeof p.content == "string" ? p.content : p.content.map(m).join("") : "";
   };
   e.hooks.add("after-tokenize", function(p) {
-    p.language !== "jsx" && p.language !== "tsx" || c(p.tokens);
+    p.language !== "jsx" && p.language !== "tsx" || u(p.tokens);
   });
 }(o), function(e) {
   var t = e.util.clone(e.languages.typescript), t = (e.languages.tsx = e.languages.extend("jsx", t), delete e.languages.tsx.parameter, delete e.languages.tsx["literal-property"], e.languages.tsx.tag);
@@ -791,7 +791,7 @@ o.languages.markup = { comment: { pattern: /<!--(?:(?!<!--)[\s\S])*?-->/, greedy
   var t = { "interpolation-punctuation": { pattern: /^\$\{?|\}$/, alias: "punctuation" }, expression: { pattern: /[\s\S]+/, inside: e.languages.kotlin } };
   e.languages.insertBefore("kotlin", "string", { "string-literal": [{ pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/, alias: "multiline", inside: { interpolation: { pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i, inside: t }, string: /[\s\S]+/ } }, { pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/, alias: "singleline", inside: { interpolation: { pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i, lookbehind: !0, inside: t }, string: /[\s\S]+/ } }], char: { pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/, greedy: !0 } }), delete e.languages.kotlin.string, e.languages.insertBefore("kotlin", "keyword", { annotation: { pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/, alias: "builtin" } }), e.languages.insertBefore("kotlin", "function", { label: { pattern: /\b\w+@|@\w+\b/, alias: "symbol" } }), e.languages.kt = e.languages.kotlin, e.languages.kts = e.languages.kotlin;
 }(o), o.languages.c = o.languages.extend("clike", { comment: { pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/, greedy: !0 }, string: { pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/, greedy: !0 }, "class-name": { pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\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/, function: /\b[a-z_]\w*(?=\s*\()/i, number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i, operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/ }), o.languages.insertBefore("c", "string", { char: { pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/, greedy: !0 } }), o.languages.insertBefore("c", "string", { macro: { pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im, lookbehind: !0, greedy: !0, alias: "property", inside: { string: [{ pattern: /^(#\s*include\s*)<[^>]+>/, lookbehind: !0 }, o.languages.c.string], char: o.languages.c.char, comment: o.languages.c.comment, "macro-name": [{ pattern: /(^#\s*define\s+)\w+\b(?!\()/i, lookbehind: !0 }, { pattern: /(^#\s*define\s+)\w+\b(?=\()/i, lookbehind: !0, alias: "function" }], directive: { pattern: /^(#\s*)[a-z]+/, lookbehind: !0, alias: "keyword" }, "directive-hash": /^#/, punctuation: /##|\\(?=[\r\n])/, expression: { pattern: /\S[\s\S]*/, inside: o.languages.c } } } }), o.languages.insertBefore("c", "function", { constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/ }), delete o.languages.c.boolean, o.languages.objectivec = o.languages.extend("c", { string: { pattern: /@?"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/, greedy: !0 }, keyword: /\b(?:asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|in|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 o.languages.objectivec["class-name"], o.languages.objc = o.languages.objectivec, o.languages.reason = o.languages.extend("clike", { string: { pattern: /"(?:\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/, greedy: !0 }, "class-name": /\b[A-Z]\w*/, keyword: /\b(?:and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|sig|struct|switch|then|to|try|type|val|virtual|when|while|with)\b/, operator: /\.{3}|:[:=]|\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\-*\/]\.?|\b(?:asr|land|lor|lsl|lsr|lxor|mod)\b/ }), o.languages.insertBefore("reason", "class-name", { char: { pattern: /'(?:\\x[\da-f]{2}|\\o[0-3][0-7][0-7]|\\\d{3}|\\.|[^'\\\r\n])'/, greedy: !0 }, constructor: /\b[A-Z]\w*\b(?!\s*\.)/, label: { pattern: /\b[a-z]\w*(?=::)/, alias: "symbol" } }), delete o.languages.reason.function, function(e) {
-  for (var t = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source, a = 0; a < 2; a++)
+  for (var t = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source, r = 0; r < 2; r++)
     t = t.replace(/<self>/g, function() {
       return t;
     });
@@ -799,39 +799,39 @@ o.languages.markup = { comment: { pattern: /<!--(?:(?!<!--)[\s\S])*?-->/, greedy
     return /[^\s\S]/.source;
   }), e.languages.rust = { comment: [{ pattern: RegExp(/(^|[^\\])/.source + t), lookbehind: !0, greedy: !0 }, { pattern: /(^|[^\\:])\/\/.*/, lookbehind: !0, greedy: !0 }], string: { pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/, greedy: !0 }, char: { pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/, greedy: !0 }, attribute: { pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/, greedy: !0, alias: "attr-name", inside: { string: null } }, "closure-params": { pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/, lookbehind: !0, greedy: !0, inside: { "closure-punctuation": { pattern: /^\||\|$/, alias: "punctuation" }, rest: null } }, "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: /::/ } }], 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)\b/, /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/], 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: /::/ } }, number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/, boolean: /\b(?:false|true)\b/, punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/, operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/ }, e.languages.rust["closure-params"].inside.rest = e.languages.rust, e.languages.rust.attribute.inside.string = e.languages.rust.string;
 }(o), o.languages.go = o.languages.extend("clike", { string: { pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/, 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|iota|nil|true)\b/, number: [/\b0(?:b[01_]+|o[0-7_]+)i?\b/i, /\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i, /(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i], operator: /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./, 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/ }), o.languages.insertBefore("go", "string", { char: { pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/, greedy: !0 } }), delete o.languages.go["class-name"], function(e) {
-  var t = /\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/, a = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(/<keyword>/g, function() {
+  var t = /\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/, r = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(/<keyword>/g, function() {
     return t.source;
   });
   e.languages.cpp = e.languages.extend("c", { "class-name": [{ pattern: RegExp(/(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(/<keyword>/g, function() {
     return t.source;
   })), lookbehind: !0 }, /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/], keyword: t, number: { pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i, greedy: !0 }, operator: />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/, boolean: /\b(?:false|true)\b/ }), e.languages.insertBefore("cpp", "string", { module: { pattern: RegExp(/(\b(?:import|module)\s+)/.source + "(?:" + /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + "|" + /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(/<mod-name>/g, function() {
-    return a;
+    return r;
   }) + ")"), lookbehind: !0, greedy: !0, inside: { string: /^[<"][\s\S]+/, operator: /:/, punctuation: /\./ } }, "raw-string": { pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/, alias: "string", greedy: !0 } }), e.languages.insertBefore("cpp", "keyword", { "generic-function": { pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i, inside: { function: /^\w+/, generic: { pattern: /<[\s\S]+/, alias: "class-name", inside: e.languages.cpp } } } }), e.languages.insertBefore("cpp", "operator", { "double-colon": { pattern: /::/, alias: "punctuation" } }), e.languages.insertBefore("cpp", "class-name", { "base-clause": { pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/, lookbehind: !0, greedy: !0, inside: e.languages.extend("cpp", {}) } }), e.languages.insertBefore("inside", "double-colon", { "class-name": /\b[a-z_]\w*\b(?!\s*::)/i }, e.languages.cpp["base-clause"]);
 }(o), o.languages.python = { comment: { pattern: /(^|[^\\])#.*/, lookbehind: !0, greedy: !0 }, "string-interpolation": { pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i, greedy: !0, inside: { interpolation: { pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/, lookbehind: !0, inside: { "format-spec": { pattern: /(:)[^:(){}]+(?=\}$)/, lookbehind: !0 }, "conversion-option": { pattern: /![sra](?=[:}]$)/, alias: "punctuation" }, rest: null } }, string: /[\s\S]+/ } }, "triple-quoted-string": { pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i, greedy: !0, alias: "string" }, string: { pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i, greedy: !0 }, function: { pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g, lookbehind: !0 }, "class-name": { pattern: /(\bclass\s+)\w+/i, lookbehind: !0 }, decorator: { pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m, lookbehind: !0, alias: ["annotation", "punctuation"], inside: { punctuation: /\./ } }, keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|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|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/, boolean: /\b(?:False|None|True)\b/, number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i, operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/, punctuation: /[{}[\];(),.:]/ }, o.languages.python["string-interpolation"].inside.interpolation.inside.rest = o.languages.python, o.languages.py = o.languages.python, o.languages.json = { property: { pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/, lookbehind: !0, greedy: !0 }, string: { pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/, lookbehind: !0, greedy: !0 }, comment: { pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/, greedy: !0 }, number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i, punctuation: /[{}[\],]/, operator: /:/, boolean: /\b(?:false|true)\b/, null: { pattern: /\bnull\b/, alias: "keyword" } }, o.languages.webmanifest = o.languages.json;
-var X = {};
-Se(X, {
-  dracula: () => Ie,
-  duotoneDark: () => Oe,
-  duotoneLight: () => Ce,
-  github: () => Be,
-  gruvboxMaterialDark: () => pt,
-  gruvboxMaterialLight: () => gt,
-  jettwaveDark: () => nt,
-  jettwaveLight: () => ot,
+var V = {};
+_e(V, {
+  dracula: () => Le,
+  duotoneDark: () => Ne,
+  duotoneLight: () => De,
+  github: () => $e,
+  gruvboxMaterialDark: () => gt,
+  gruvboxMaterialLight: () => yt,
+  jettwaveDark: () => rt,
+  jettwaveLight: () => st,
   nightOwl: () => je,
-  nightOwlLight: () => ze,
-  oceanicNext: () => Ue,
-  okaidia: () => Ze,
-  oneDark: () => lt,
-  oneLight: () => ut,
-  palenight: () => We,
-  shadesOfPurple: () => Ye,
-  synthwave84: () => Ve,
-  ultramin: () => Qe,
-  vsDark: () => ue,
-  vsLight: () => tt
+  nightOwlLight: () => Me,
+  oceanicNext: () => Ge,
+  okaidia: () => qe,
+  oneDark: () => it,
+  oneLight: () => ct,
+  palenight: () => He,
+  shadesOfPurple: () => Ke,
+  synthwave84: () => Xe,
+  ultramin: () => Je,
+  vsDark: () => ce,
+  vsLight: () => at
 });
-var Re = {
+var Ie = {
   plain: {
     color: "#F8F8F2",
     backgroundColor: "#282A36"
@@ -893,7 +893,7 @@ var Re = {
       }
     }
   ]
-}, Ie = Re, Le = {
+}, Le = Ie, Oe = {
   plain: {
     backgroundColor: "#2a2734",
     color: "#9a86fd"
@@ -987,7 +987,7 @@ var Re = {
       }
     }
   ]
-}, Oe = Le, Ne = {
+}, Ne = Oe, Ce = {
   plain: {
     backgroundColor: "#faf8f5",
     color: "#728fcb"
@@ -1085,7 +1085,7 @@ var Re = {
       }
     }
   ]
-}, Ce = Ne, De = {
+}, De = Ce, Be = {
   plain: {
     color: "#393A34",
     backgroundColor: "#f6f8fa"
@@ -1158,7 +1158,7 @@ var Re = {
       }
     }
   ]
-}, Be = De, $e = {
+}, $e = Be, Pe = {
   plain: {
     color: "#d6deeb",
     backgroundColor: "#011627"
@@ -1262,7 +1262,7 @@ var Re = {
       }
     }
   ]
-}, je = $e, Pe = {
+}, je = Pe, ze = {
   plain: {
     color: "#403f53",
     backgroundColor: "#FBFBFB"
@@ -1354,7 +1354,7 @@ var Re = {
       }
     }
   ]
-}, ze = Pe, R = {
+}, Me = ze, R = {
   char: "#D8DEE9",
   comment: "#999999",
   keyword: "#c5a5c5",
@@ -1365,7 +1365,7 @@ var Re = {
   tag: "#fc929e",
   function: "#79b6f2",
   className: "#FAC863"
-}, Me = {
+}, Ue = {
   plain: {
     backgroundColor: "#282c34",
     color: "#ffffff"
@@ -1488,7 +1488,7 @@ var Re = {
       }
     }
   ]
-}, Ue = Me, Ge = {
+}, Ge = Ue, Ze = {
   plain: {
     color: "#f8f8f2",
     backgroundColor: "#272822"
@@ -1603,7 +1603,7 @@ var Re = {
       }
     }
   ]
-}, Ze = Ge, qe = {
+}, qe = Ze, We = {
   plain: {
     color: "#bfc7d5",
     backgroundColor: "#292d3e"
@@ -1696,7 +1696,7 @@ var Re = {
       }
     }
   ]
-}, We = qe, He = {
+}, He = We, Ye = {
   plain: {
     color: "#9EFEFF",
     backgroundColor: "#2D2A55"
@@ -1784,7 +1784,7 @@ var Re = {
       }
     }
   ]
-}, Ye = He, Ke = {
+}, Ke = Ye, Ve = {
   plain: {
     backgroundColor: "linear-gradient(to bottom, #2a2139 75%, #34294f)",
     backgroundImage: "#34294f",
@@ -1909,7 +1909,7 @@ var Re = {
       }
     }
   ]
-}, Ve = Ke, Xe = {
+}, Xe = Ve, Qe = {
   plain: {
     color: "#282a2e",
     backgroundColor: "#ffffff"
@@ -1934,7 +1934,7 @@ var Re = {
       }
     }
   ]
-}, Qe = Xe, Je = {
+}, Je = Qe, et = {
   plain: {
     color: "#9CDCFE",
     backgroundColor: "#1E1E1E"
@@ -2036,7 +2036,7 @@ var Re = {
       }
     }
   ]
-}, ue = Je, et = {
+}, ce = et, tt = {
   plain: {
     color: "#000000",
     backgroundColor: "#ffffff"
@@ -2109,7 +2109,7 @@ var Re = {
       }
     }
   ]
-}, tt = et, at = {
+}, at = tt, nt = {
   plain: {
     color: "#f8fafc",
     backgroundColor: "#011627"
@@ -2208,7 +2208,7 @@ var Re = {
       }
     }
   ]
-}, nt = at, rt = {
+}, rt = nt, ot = {
   plain: {
     color: "#0f172a",
     backgroundColor: "#f1f5f9"
@@ -2307,7 +2307,7 @@ var Re = {
       }
     }
   ]
-}, ot = rt, st = {
+}, st = ot, lt = {
   plain: {
     backgroundColor: "hsl(220, 13%, 18%)",
     color: "hsl(220, 14%, 71%)",
@@ -2405,7 +2405,7 @@ var Re = {
       }
     }
   ]
-}, lt = st, it = {
+}, it = lt, ut = {
   plain: {
     backgroundColor: "hsl(230, 1%, 98%)",
     color: "hsl(230, 8%, 24%)"
@@ -2506,7 +2506,7 @@ var Re = {
       }
     }
   ]
-}, ut = it, ct = {
+}, ct = ut, pt = {
   plain: {
     color: "#ebdbb2",
     backgroundColor: "#292828"
@@ -2579,7 +2579,7 @@ var Re = {
       }
     }
   ]
-}, pt = ct, dt = {
+}, gt = pt, dt = {
   plain: {
     color: "#654735",
     backgroundColor: "#f9f5d7"
@@ -2651,46 +2651,46 @@ var Re = {
       }
     }
   ]
-}, gt = dt, yt = (e) => V(
+}, yt = dt, ft = (e) => K(
   (t) => {
-    var a = t, { className: i, style: y, line: m } = a, c = ie(a, ["className", "style", "line"]);
-    const h = q(N({}, c), {
-      className: oe("token-line", i)
+    var r = t, { className: i, style: f, line: h } = r, u = ue(r, ["className", "style", "line"]);
+    const m = q(N({}, u), {
+      className: se("token-line", i)
     });
-    return typeof e == "object" && "plain" in e && (h.style = e.plain), typeof y == "object" && (h.style = N(N({}, h.style || {}), y)), h;
+    return typeof e == "object" && "plain" in e && (m.style = e.plain), typeof f == "object" && (m.style = N(N({}, m.style || {}), f)), m;
   },
   [e]
-), ft = (e) => {
-  const t = V(
-    ({ types: a, empty: i }) => {
+), bt = (e) => {
+  const t = K(
+    ({ types: r, empty: i }) => {
       if (e != null) {
         {
-          if (a.length === 1 && a[0] === "plain")
+          if (r.length === 1 && r[0] === "plain")
             return i != null ? { display: "inline-block" } : void 0;
-          if (a.length === 1 && i != null)
-            return e[a[0]];
+          if (r.length === 1 && i != null)
+            return e[r[0]];
         }
         return Object.assign(
           i != null ? { display: "inline-block" } : {},
-          ...a.map((y) => e[y])
+          ...r.map((f) => e[f])
         );
       }
     },
     [e]
   );
-  return V(
-    (a) => {
-      var i = a, { token: y, className: m, style: c } = i, h = ie(i, ["token", "className", "style"]);
-      const p = q(N({}, h), {
-        className: oe("token", ...y.types, m),
-        children: y.content,
-        style: t(y)
+  return K(
+    (r) => {
+      var i = r, { token: f, className: h, style: u } = i, m = ue(i, ["token", "className", "style"]);
+      const p = q(N({}, m), {
+        className: se("token", ...f.types, h),
+        children: f.content,
+        style: t(f)
       });
-      return c != null && (p.style = N(N({}, p.style || {}), c)), p;
+      return u != null && (p.style = N(N({}, p.style || {}), u)), p;
     },
     [t]
   );
-}, bt = /\r\n|\r|\n/, ae = (e) => {
+}, mt = /\r\n|\r|\n/, ne = (e) => {
   e.length === 0 ? e.push({
     types: ["plain"],
     content: `
@@ -2698,78 +2698,78 @@ var Re = {
     empty: !0
   }) : e.length === 1 && e[0].content === "" && (e[0].content = `
 `, e[0].empty = !0);
-}, ne = (e, t) => {
-  const a = e.length;
-  return a > 0 && e[a - 1] === t ? e : e.concat(t);
-}, mt = (e) => {
-  const t = [[]], a = [e], i = [0], y = [e.length];
-  let m = 0, c = 0, h = [];
-  const p = [h];
-  for (; c > -1; ) {
-    for (; (m = i[c]++) < y[c]; ) {
-      let d, b = t[c];
-      const v = a[c][m];
-      if (typeof v == "string" ? (b = c > 0 ? b : ["plain"], d = v) : (b = ne(b, v.type), v.alias && (b = ne(b, v.alias)), d = v.content), typeof d != "string") {
-        c++, t.push(b), a.push(d), i.push(0), y.push(d.length);
+}, re = (e, t) => {
+  const r = e.length;
+  return r > 0 && e[r - 1] === t ? e : e.concat(t);
+}, ht = (e) => {
+  const t = [[]], r = [e], i = [0], f = [e.length];
+  let h = 0, u = 0, m = [];
+  const p = [m];
+  for (; u > -1; ) {
+    for (; (h = i[u]++) < f[u]; ) {
+      let g, b = t[u];
+      const v = r[u][h];
+      if (typeof v == "string" ? (b = u > 0 ? b : ["plain"], g = v) : (b = re(b, v.type), v.alias && (b = re(b, v.alias)), g = v.content), typeof g != "string") {
+        u++, t.push(b), r.push(g), i.push(0), f.push(g.length);
         continue;
       }
-      const w = d.split(bt), n = w.length;
-      h.push({
+      const w = g.split(mt), n = w.length;
+      m.push({
         types: b,
         content: w[0]
       });
-      for (let r = 1; r < n; r++)
-        ae(h), p.push(h = []), h.push({
+      for (let a = 1; a < n; a++)
+        ne(m), p.push(m = []), m.push({
           types: b,
-          content: w[r]
+          content: w[a]
         });
     }
-    c--, t.pop(), a.pop(), i.pop(), y.pop();
+    u--, t.pop(), r.pop(), i.pop(), f.pop();
   }
-  return ae(h), p;
-}, re = mt, ht = ({ prism: e, code: t, grammar: a, language: i }) => ge(() => {
-  if (a == null)
-    return re([t]);
-  const y = {
+  return ne(m), p;
+}, oe = ht, vt = ({ prism: e, code: t, grammar: r, language: i }) => ye(() => {
+  if (r == null)
+    return oe([t]);
+  const f = {
     code: t,
-    grammar: a,
+    grammar: r,
     language: i,
     tokens: []
   };
-  return e.hooks.run("before-tokenize", y), y.tokens = e.tokenize(t, a), e.hooks.run("after-tokenize", y), re(y.tokens);
+  return e.hooks.run("before-tokenize", f), f.tokens = e.tokenize(t, r), e.hooks.run("after-tokenize", f), oe(f.tokens);
 }, [
   t,
-  a,
+  r,
   i,
   // prism is a stable import
   e
-]), vt = (e, t) => {
-  const { plain: a } = e, i = e.styles.reduce((y, m) => {
-    const { languages: c, style: h } = m;
-    return c && !c.includes(t) || m.types.forEach((p) => {
-      const d = N(N({}, y[p]), h);
-      y[p] = d;
-    }), y;
+]), kt = (e, t) => {
+  const { plain: r } = e, i = e.styles.reduce((f, h) => {
+    const { languages: u, style: m } = h;
+    return u && !u.includes(t) || h.types.forEach((p) => {
+      const g = N(N({}, f[p]), m);
+      f[p] = g;
+    }), f;
   }, {});
-  return i.root = a, i.plain = q(N({}, a), { backgroundColor: void 0 }), i;
-}, kt = vt, wt = ({
+  return i.root = r, i.plain = q(N({}, r), { backgroundColor: void 0 }), i;
+}, wt = kt, Et = ({
   children: e,
   language: t,
-  code: a,
+  code: r,
   theme: i,
-  prism: y
+  prism: f
 }) => {
-  const m = t.toLowerCase(), c = kt(i, m), h = yt(c), p = ft(c), d = y.languages[m], b = ht({ prism: y, language: m, code: a, grammar: d });
+  const h = t.toLowerCase(), u = wt(i, h), m = ft(u), p = bt(u), g = f.languages[h], b = vt({ prism: f, language: h, code: r, grammar: g });
   return e({
     tokens: b,
-    className: `prism-code language-${m}`,
-    style: c != null ? c.root : {},
-    getLineProps: h,
+    className: `prism-code language-${h}`,
+    style: u != null ? u.root : {},
+    getLineProps: m,
     getTokenProps: p
   });
-}, xt = (e) => de(wt, q(N({}, e), {
+}, xt = (e) => de(Et, q(N({}, e), {
   prism: e.prism || o,
-  theme: e.theme || ue,
+  theme: e.theme || ce,
   code: e.code,
   language: e.language
 }));
@@ -2796,110 +2796,91 @@ import("../prism-objectivec.min-BXSWqpJJ.js");
 import("../prism-markdown.min-C0Qn0m-5.js");
 import("../prism-javascript.min-CEqHqgbm.js");
 import("../prism-typescript.min-CD7H2IYQ.js").then((e) => e.p);
-const Et = {
+const At = {
   mdx: "md"
-}, It = ({
+}, St = ({
   language: e = "plain",
   showCopy: t = "hover",
-  showCopyText: a,
+  showCopyText: r,
   title: i,
-  children: y,
-  ...m
+  children: f,
+  disabled: h,
+  ...u
 }) => {
-  const { resolvedTheme: c } = me(), [h, p] = ye(!1), d = y ?? m.code;
-  if (!d)
+  const { resolvedTheme: m } = ve(), [p, g] = be(!1), b = f ?? u.code;
+  if (!b)
     return null;
-  const b = c === "dark" ? X.vsDark : X.github;
-  return /* @__PURE__ */ F.jsx(
-    he,
-    {
-      fallback: /* @__PURE__ */ F.jsxs("div", { className: "relative group", children: [
-        i && /* @__PURE__ */ F.jsx("div", { className: "text-xs text-muted-foreground absolute top-2 font-mono border-b w-full pb-2 px-4 ", children: i }),
-        /* @__PURE__ */ F.jsx(
-          "pre",
-          {
-            className: K(
-              "relative scrollbar overflow-x-auto",
-              m.className,
-              m.noBackground ? "!bg-transparent" : "bg-[#f6f8fa] text-[#393a34] dark:bg-[#1e1e1e] dark:text-[#9cdcfe]",
-              m.wrapLines && "whitespace-pre-wrap break-words",
-              i && "pt-10"
-            ),
-            children: d
-          }
+  const y = m === "dark" ? V.vsDark : V.github, v = "bg-[#f6f8fa] text-[#393a34] dark:bg-[#1e1e1e] dark:text-[#9cdcfe]", w = ({
+    children: n,
+    className: a,
+    style: s
+  }) => /* @__PURE__ */ _.jsxs("div", { className: "relative group", children: [
+    i && /* @__PURE__ */ _.jsx("div", { className: "text-xs text-muted-foreground absolute top-2 font-mono border-b w-full pb-2 px-4 ", children: i }),
+    /* @__PURE__ */ _.jsx(
+      "pre",
+      {
+        className: ee(
+          "relative scrollbar overflow-x-auto",
+          u.className,
+          u.noBackground ? "!bg-transparent" : v,
+          u.wrapLines && "whitespace-pre-wrap break-words",
+          i && "pt-10",
+          a
         ),
-        m.showLanguageIndicator && /* @__PURE__ */ F.jsx("span", { className: "absolute top-1.5 right-3 text-[11px] font-mono text-muted-foreground transition group-hover:opacity-0", children: e })
-      ] }),
-      children: /* @__PURE__ */ F.jsx(
-        xt,
-        {
-          theme: b,
-          language: Et[e] ?? e,
-          ...m,
-          code: d,
-          children: ({ className: v, style: w, tokens: n, getLineProps: r, getTokenProps: s }) => /* @__PURE__ */ F.jsxs("div", { className: "relative group", children: [
-            i && /* @__PURE__ */ F.jsx("div", { className: "text-xs text-muted-foreground absolute top-2 font-mono border-b w-full pb-2 px-4 ", children: i }),
-            /* @__PURE__ */ F.jsx(
-              "pre",
-              {
-                className: K(
-                  "relative scrollbar overflow-x-auto",
-                  v,
-                  m.className,
-                  m.noBackground && "!bg-transparent",
-                  m.wrapLines && "whitespace-pre-wrap break-words",
-                  i && "pt-10"
-                ),
-                style: w,
-                children: n.map((u, l) => (
-                  // eslint-disable-next-line react/no-array-index-key
-                  /* @__PURE__ */ F.jsx("div", { ...r({ line: u }), children: u.map((g, k) => (
-                    // eslint-disable-next-line react/no-array-index-key
-                    /* @__PURE__ */ F.jsx("span", { ...s({ token: g }) }, k)
-                  )) }, l)
-                ))
-              }
-            ),
-            m.showLanguageIndicator && /* @__PURE__ */ F.jsx("span", { className: "absolute top-1.5 right-3 text-[11px] font-mono text-muted-foreground transition group-hover:opacity-0", children: e }),
-            t !== "never" && /* @__PURE__ */ F.jsxs(
-              "button",
-              {
-                type: "button",
-                "aria-label": "Copy code",
-                title: "Copy code",
-                className: K(
-                  "absolute top-2 right-2 p-2  hover:outline hover:outline-border/75 dark:hover:outline-border rounded-md text-sm text-muted-foreground transition",
-                  t === "hover" ? "opacity-0 group-hover:opacity-100 group-hover:bg-zinc-100 group-hover:dark:bg-zinc-700" : "bg-zinc-100 dark:bg-zinc-700",
-                  a && "flex gap-2 items-center font-medium"
-                ),
-                disabled: h,
-                onClick: () => {
-                  p(!0), navigator.clipboard.writeText(
-                    n.map((u) => u.map(({ content: l }) => l).join("")).join(`
-`)
-                  ), setTimeout(() => p(!1), 2e3);
-                },
-                children: [
-                  h ? /* @__PURE__ */ F.jsx(
-                    fe,
-                    {
-                      className: "text-emerald-600",
-                      size: 16,
-                      strokeWidth: 2.5,
-                      absoluteStrokeWidth: !0
-                    }
-                  ) : /* @__PURE__ */ F.jsx(be, { size: 16 }),
-                  a && "Copy"
-                ]
-              }
-            )
-          ] })
-        }
-      )
+        style: s,
+        children: n
+      }
+    ),
+    u.showLanguageIndicator && /* @__PURE__ */ _.jsx("span", { className: "absolute top-1.5 right-3 text-[11px] font-mono text-muted-foreground transition group-hover:opacity-0", children: e }),
+    t !== "never" && /* @__PURE__ */ _.jsxs(
+      "button",
+      {
+        type: "button",
+        "aria-label": "Copy code",
+        title: "Copy code",
+        className: ee(
+          "absolute top-2 right-2 p-2  hover:outline hover:outline-border/75 dark:hover:outline-border rounded-md text-sm text-muted-foreground transition",
+          t === "hover" ? "opacity-0 group-hover:opacity-100 group-hover:bg-zinc-100 group-hover:dark:bg-zinc-700" : "bg-zinc-100 dark:bg-zinc-700",
+          r && "flex gap-2 items-center font-medium"
+        ),
+        disabled: p,
+        onClick: () => {
+          g(!0), navigator.clipboard.writeText(b), setTimeout(() => g(!1), 2e3);
+        },
+        children: [
+          p ? /* @__PURE__ */ _.jsx(
+            me,
+            {
+              className: "text-emerald-600",
+              size: 16,
+              strokeWidth: 2.5,
+              absoluteStrokeWidth: !0
+            }
+          ) : /* @__PURE__ */ _.jsx(he, { size: 16 }),
+          r && "Copy"
+        ]
+      }
+    )
+  ] });
+  return h ? /* @__PURE__ */ _.jsx(te, { fallback: /* @__PURE__ */ _.jsx(w, { children: b }), children: /* @__PURE__ */ _.jsx(w, { children: b }) }) : /* @__PURE__ */ _.jsx(te, { fallback: /* @__PURE__ */ _.jsx(w, { children: b }), children: /* @__PURE__ */ _.jsx(
+    xt,
+    {
+      theme: y,
+      language: At[e] ?? e,
+      ...u,
+      code: b,
+      children: ({ className: n, style: a, tokens: s, getLineProps: c, getTokenProps: l }) => /* @__PURE__ */ _.jsx(w, { className: n, style: a, children: s.map((d, k) => (
+        // eslint-disable-next-line react/no-array-index-key
+        /* @__PURE__ */ _.jsx("div", { ...c({ line: d }), children: d.map((E, A) => (
+          // eslint-disable-next-line react/no-array-index-key
+          /* @__PURE__ */ _.jsx("span", { ...l({ token: E }) }, A)
+        )) }, k)
+      )) })
     }
-  );
-};
+  ) });
+}, _t = fe(St);
+_t.displayName = "SyntaxHighlight";
 export {
-  It as SyntaxHighlight
+  _t as SyntaxHighlight
 };
 //# sourceMappingURL=SyntaxHighlight.js.map