@salesforcedevs/dx-components 0.16.3 → 0.17.1-review-diff1

package/src/modules/dxUtils/prismjs/prismjs.ts

@@ -0,0 +1,4183 @@
+/* eslint-disable */
+/* prettier-ignore */
+// @ts-nocheck
+var commonjsGlobal =
+    typeof globalThis !== "undefined"
+        ? globalThis
+        : typeof window !== "undefined"
+        ? window
+        : typeof global !== "undefined"
+        ? global
+        : typeof self !== "undefined"
+        ? self
+        : {};
+
+function createCommonjsModule(fn, basedir, module) {
+    return (
+        (module = {
+            path: basedir,
+            exports: {},
+            require: function (path, base) {
+                return commonjsRequire(
+                    path,
+                    base === undefined || base === null ? module.path : base
+                );
+            }
+        }),
+        fn(module, module.exports),
+        module.exports
+    );
+}
+
+function commonjsRequire() {
+    throw new Error(
+        "Dynamic requires are not currently supported by @rollup/plugin-commonjs"
+    );
+}
+//Start autogenerated code
+var prism = createCommonjsModule(function (module) {
+    /* PrismJS 1.29.0
+    https://prismjs.com/download.html#themes=prism&languages=markup+css+clike+javascript+apex+aspnet+bash+basic+c+csharp+cpp+css-extras+dataweave+graphql+handlebars+hcl+java+javadoc+javadoclike+jsdoc+js-extras+json+json5+jsonp+jsstacktrace+kotlin+markdown+markup-templating+objectivec+php+phpdoc+php-extras+plsql+python+jsx+regex+sql+swift+typescript+typoscript+uri+vbnet+yaml&plugins=unescaped-markup+match-braces */
+    var _self =
+            "undefined" != typeof window
+                ? window
+                : "undefined" != typeof WorkerGlobalScope &&
+                  self instanceof WorkerGlobalScope
+                ? self
+                : {},
+        Prism = (function (e) {
+            var n = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i,
+                t = 0,
+                r = {},
+                a = {
+                    manual: e.Prism && e.Prism.manual,
+                    disableWorkerMessageHandler:
+                        e.Prism && e.Prism.disableWorkerMessageHandler,
+                    util: {
+                        encode: function e(n) {
+                            return n instanceof i
+                                ? new i(n.type, e(n.content), n.alias)
+                                : Array.isArray(n)
+                                ? n.map(e)
+                                : n
+                                      .replace(/&/g, "&")
+                                      .replace(/</g, "&lt;")
+                                      .replace(/\u00a0/g, " ");
+                        },
+                        type: function (e) {
+                            return Object.prototype.toString
+                                .call(e)
+                                .slice(8, -1);
+                        },
+                        objId: function (e) {
+                            return (
+                                e.__id ||
+                                    Object.defineProperty(e, "__id", {
+                                        value: ++t
+                                    }),
+                                e.__id
+                            );
+                        },
+                        clone: function e(n, t) {
+                            var r, i;
+                            switch (((t = t || {}), a.util.type(n))) {
+                                case "Object":
+                                    if (((i = a.util.objId(n)), t[i]))
+                                        return t[i];
+                                    for (var l in ((r = {}), (t[i] = r), n))
+                                        n.hasOwnProperty(l) &&
+                                            (r[l] = e(n[l], t));
+                                    return r;
+                                case "Array":
+                                    return (
+                                        (i = a.util.objId(n)),
+                                        t[i]
+                                            ? t[i]
+                                            : ((r = []),
+                                              (t[i] = r),
+                                              n.forEach(function (n, a) {
+                                                  r[a] = e(n, t);
+                                              }),
+                                              r)
+                                    );
+                                default:
+                                    return n;
+                            }
+                        },
+                        getLanguage: function (e) {
+                            for (; e; ) {
+                                var t = n.exec(e.className);
+                                if (t) return t[1].toLowerCase();
+                                e = e.parentElement;
+                            }
+                            return "none";
+                        },
+                        setLanguage: function (e, t) {
+                            (e.className = e.className.replace(
+                                RegExp(n, "gi"),
+                                ""
+                            )),
+                                e.classList.add("language-" + t);
+                        },
+                        currentScript: function () {
+                            if ("undefined" == typeof document) return null;
+                            if ("currentScript" in document)
+                                return document.currentScript;
+                            try {
+                                throw new Error();
+                            } catch (r) {
+                                var e =
+                                    (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(
+                                        r.stack
+                                    ) || [])[1];
+                                if (e) {
+                                    var n =
+                                        document.getElementsByTagName("script");
+                                    for (var t in n)
+                                        if (n[t].src == e) return n[t];
+                                }
+                                return null;
+                            }
+                        },
+                        isActive: function (e, n, t) {
+                            for (var r = "no-" + n; e; ) {
+                                var a = e.classList;
+                                if (a.contains(n)) return !0;
+                                if (a.contains(r)) return !1;
+                                e = e.parentElement;
+                            }
+                            return !!t;
+                        }
+                    },
+                    languages: {
+                        plain: r,
+                        plaintext: r,
+                        text: r,
+                        txt: r,
+                        extend: function (e, n) {
+                            var t = a.util.clone(a.languages[e]);
+                            for (var r in n) t[r] = n[r];
+                            return t;
+                        },
+                        insertBefore: function (e, n, t, r) {
+                            var i = (r = r || a.languages)[e],
+                                l = {};
+                            for (var o in i)
+                                if (i.hasOwnProperty(o)) {
+                                    if (o == n)
+                                        for (var s in t)
+                                            t.hasOwnProperty(s) &&
+                                                (l[s] = t[s]);
+                                    t.hasOwnProperty(o) || (l[o] = i[o]);
+                                }
+                            var u = r[e];
+                            return (
+                                (r[e] = l),
+                                a.languages.DFS(a.languages, function (n, t) {
+                                    t === u && n != e && (this[n] = l);
+                                }),
+                                l
+                            );
+                        },
+                        DFS: function e(n, t, r, i) {
+                            i = i || {};
+                            var l = a.util.objId;
+                            for (var o in n)
+                                if (n.hasOwnProperty(o)) {
+                                    t.call(n, o, n[o], r || o);
+                                    var s = n[o],
+                                        u = a.util.type(s);
+                                    "Object" !== u || i[l(s)]
+                                        ? "Array" !== u ||
+                                          i[l(s)] ||
+                                          ((i[l(s)] = !0), e(s, t, o, i))
+                                        : ((i[l(s)] = !0), e(s, t, null, i));
+                                }
+                        }
+                    },
+                    plugins: {},
+                    highlightAll: function (e, n) {
+                        a.highlightAllUnder(document, e, n);
+                    },
+                    highlightAllUnder: function (e, n, t) {
+                        var r = {
+                            callback: t,
+                            container: e,
+                            selector:
+                                'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
+                        };
+                        a.hooks.run("before-highlightall", r),
+                            (r.elements = Array.prototype.slice.apply(
+                                r.container.querySelectorAll(r.selector)
+                            )),
+                            a.hooks.run("before-all-elements-highlight", r);
+                        for (var i, l = 0; (i = r.elements[l++]); )
+                            a.highlightElement(i, !0 === n, r.callback);
+                    },
+                    highlightElement: function (n, t, r) {
+                        var i = a.util.getLanguage(n),
+                            l = a.languages[i];
+                        a.util.setLanguage(n, i);
+                        var o = n.parentElement;
+                        o &&
+                            "pre" === o.nodeName.toLowerCase() &&
+                            a.util.setLanguage(o, i);
+                        var s = {
+                            element: n,
+                            language: i,
+                            grammar: l,
+                            code: n.textContent
+                        };
+                        function u(e) {
+                            (s.highlightedCode = e),
+                                a.hooks.run("before-insert", s),
+                                (s.element.innerHTML = s.highlightedCode),
+                                a.hooks.run("after-highlight", s),
+                                a.hooks.run("complete", s),
+                                r && r.call(s.element);
+                        }
+                        if (
+                            (a.hooks.run("before-sanity-check", s),
+                            (o = s.element.parentElement) &&
+                                "pre" === o.nodeName.toLowerCase() &&
+                                !o.hasAttribute("tabindex") &&
+                                o.setAttribute("tabindex", "0"),
+                            !s.code)
+                        )
+                            return (
+                                a.hooks.run("complete", s),
+                                void (r && r.call(s.element))
+                            );
+                        if ((a.hooks.run("before-highlight", s), s.grammar))
+                            if (t && e.Worker) {
+                                var c = new Worker(a.filename);
+                                (c.onmessage = function (e) {
+                                    u(e.data);
+                                }),
+                                    c.postMessage(
+                                        JSON.stringify({
+                                            language: s.language,
+                                            code: s.code,
+                                            immediateClose: !0
+                                        })
+                                    );
+                            } else
+                                u(a.highlight(s.code, s.grammar, s.language));
+                        else u(a.util.encode(s.code));
+                    },
+                    highlight: function (e, n, t) {
+                        var r = { code: e, grammar: n, language: t };
+                        if ((a.hooks.run("before-tokenize", r), !r.grammar))
+                            throw new Error(
+                                'The language "' +
+                                    r.language +
+                                    '" has no grammar.'
+                            );
+                        return (
+                            (r.tokens = a.tokenize(r.code, r.grammar)),
+                            a.hooks.run("after-tokenize", r),
+                            i.stringify(a.util.encode(r.tokens), r.language)
+                        );
+                    },
+                    tokenize: function (e, n) {
+                        var t = n.rest;
+                        if (t) {
+                            for (var r in t) n[r] = t[r];
+                            delete n.rest;
+                        }
+                        var a = new s();
+                        return (
+                            u(a, a.head, e),
+                            o(e, a, n, a.head, 0),
+                            (function (e) {
+                                for (
+                                    var n = [], t = e.head.next;
+                                    t !== e.tail;
+
+                                )
+                                    n.push(t.value), (t = t.next);
+                                return n;
+                            })(a)
+                        );
+                    },
+                    hooks: {
+                        all: {},
+                        add: function (e, n) {
+                            var t = a.hooks.all;
+                            (t[e] = t[e] || []), t[e].push(n);
+                        },
+                        run: function (e, n) {
+                            var t = a.hooks.all[e];
+                            if (t && t.length)
+                                for (var r, i = 0; (r = t[i++]); ) r(n);
+                        }
+                    },
+                    Token: i
+                };
+            function i(e, n, t, r) {
+                (this.type = e),
+                    (this.content = n),
+                    (this.alias = t),
+                    (this.length = 0 | (r || "").length);
+            }
+            function l(e, n, t, r) {
+                e.lastIndex = n;
+                var a = e.exec(t);
+                if (a && r && a[1]) {
+                    var i = a[1].length;
+                    (a.index += i), (a[0] = a[0].slice(i));
+                }
+                return a;
+            }
+            function o(e, n, t, r, s, g) {
+                for (var f in t)
+                    if (t.hasOwnProperty(f) && t[f]) {
+                        var h = t[f];
+                        h = Array.isArray(h) ? h : [h];
+                        for (var d = 0; d < h.length; ++d) {
+                            if (g && g.cause == f + "," + d) return;
+                            var v = h[d],
+                                p = v.inside,
+                                m = !!v.lookbehind,
+                                y = !!v.greedy,
+                                k = v.alias;
+                            if (y && !v.pattern.global) {
+                                var x = v.pattern
+                                    .toString()
+                                    .match(/[imsuy]*$/)[0];
+                                v.pattern = RegExp(v.pattern.source, x + "g");
+                            }
+                            for (
+                                var b = v.pattern || v, w = r.next, A = s;
+                                w !== n.tail && !(g && A >= g.reach);
+                                A += w.value.length, w = w.next
+                            ) {
+                                var E = w.value;
+                                if (n.length > e.length) return;
+                                if (!(E instanceof i)) {
+                                    var P,
+                                        L = 1;
+                                    if (y) {
+                                        if (
+                                            !(P = l(b, A, e, m)) ||
+                                            P.index >= e.length
+                                        )
+                                            break;
+                                        var S = P.index,
+                                            O = P.index + P[0].length,
+                                            j = A;
+                                        for (j += w.value.length; S >= j; )
+                                            j += (w = w.next).value.length;
+                                        if (
+                                            ((A = j -= w.value.length),
+                                            w.value instanceof i)
+                                        )
+                                            continue;
+                                        for (
+                                            var C = w;
+                                            C !== n.tail &&
+                                            (j < O ||
+                                                "string" == typeof C.value);
+                                            C = C.next
+                                        )
+                                            L++, (j += C.value.length);
+                                        L--,
+                                            (E = e.slice(A, j)),
+                                            (P.index -= A);
+                                    } else if (!(P = l(b, 0, E, m))) continue;
+                                    S = P.index;
+                                    var N = P[0],
+                                        _ = E.slice(0, S),
+                                        M = E.slice(S + N.length),
+                                        W = A + E.length;
+                                    g && W > g.reach && (g.reach = W);
+                                    var z = w.prev;
+                                    if (
+                                        (_ &&
+                                            ((z = u(n, z, _)), (A += _.length)),
+                                        c(n, z, L),
+                                        (w = u(
+                                            n,
+                                            z,
+                                            new i(
+                                                f,
+                                                p ? a.tokenize(N, p) : N,
+                                                k,
+                                                N
+                                            )
+                                        )),
+                                        M && u(n, w, M),
+                                        L > 1)
+                                    ) {
+                                        var I = {
+                                            cause: f + "," + d,
+                                            reach: W
+                                        };
+                                        o(e, n, t, w.prev, A, I),
+                                            g &&
+                                                I.reach > g.reach &&
+                                                (g.reach = I.reach);
+                                    }
+                                }
+                            }
+                        }
+                    }
+            }
+            function s() {
+                var e = { value: null, prev: null, next: null },
+                    n = { value: null, prev: e, next: null };
+                (e.next = n),
+                    (this.head = e),
+                    (this.tail = n),
+                    (this.length = 0);
+            }
+            function u(e, n, t) {
+                var r = n.next,
+                    a = { value: t, prev: n, next: r };
+                return (n.next = a), (r.prev = a), e.length++, a;
+            }
+            function c(e, n, t) {
+                for (var r = n.next, a = 0; a < t && r !== e.tail; a++)
+                    r = r.next;
+                (n.next = r), (r.prev = n), (e.length -= a);
+            }
+            if (
+                ((e.Prism = a),
+                (i.stringify = function e(n, t) {
+                    if ("string" == typeof n) return n;
+                    if (Array.isArray(n)) {
+                        var r = "";
+                        return (
+                            n.forEach(function (n) {
+                                r += e(n, t);
+                            }),
+                            r
+                        );
+                    }
+                    var i = {
+                            type: n.type,
+                            content: e(n.content, t),
+                            tag: "span",
+                            classes: ["token", n.type],
+                            attributes: {},
+                            language: t
+                        },
+                        l = n.alias;
+                    l &&
+                        (Array.isArray(l)
+                            ? Array.prototype.push.apply(i.classes, l)
+                            : i.classes.push(l)),
+                        a.hooks.run("wrap", i);
+                    var o = "";
+                    for (var s in i.attributes)
+                        o +=
+                            " " +
+                            s +
+                            '="' +
+                            (i.attributes[s] || "").replace(/"/g, "&quot;") +
+                            '"';
+                    return (
+                        "<" +
+                        i.tag +
+                        ' class="' +
+                        i.classes.join(" ") +
+                        '"' +
+                        o +
+                        ">" +
+                        i.content +
+                        "</" +
+                        i.tag +
+                        ">"
+                    );
+                }),
+                !e.document)
+            )
+                return e.addEventListener
+                    ? (a.disableWorkerMessageHandler ||
+                          e.addEventListener(
+                              "message",
+                              function (n) {
+                                  var t = JSON.parse(n.data),
+                                      r = t.language,
+                                      i = t.code,
+                                      l = t.immediateClose;
+                                  e.postMessage(
+                                      a.highlight(i, a.languages[r], r)
+                                  ),
+                                      l && e.close();
+                              },
+                              !1
+                          ),
+                      a)
+                    : a;
+            var g = a.util.currentScript();
+            function f() {
+                a.manual || a.highlightAll();
+            }
+            if (
+                (g &&
+                    ((a.filename = g.src),
+                    g.hasAttribute("data-manual") && (a.manual = !0)),
+                !a.manual)
+            ) {
+                var h = document.readyState;
+                "loading" === h || ("interactive" === h && g && g.defer)
+                    ? document.addEventListener("DOMContentLoaded", f)
+                    : window.requestAnimationFrame
+                    ? window.requestAnimationFrame(f)
+                    : window.setTimeout(f, 16);
+            }
+            return a;
+        })(_self);
+    "undefined" != typeof module && module.exports && (module.exports = Prism),
+        "undefined" != typeof global && (global.Prism = Prism);
+    (Prism.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
+        ]
+    }),
+        (Prism.languages.markup.tag.inside["attr-value"].inside.entity =
+            Prism.languages.markup.entity),
+        (Prism.languages.markup.doctype.inside["internal-subset"].inside =
+            Prism.languages.markup),
+        Prism.hooks.add("wrap", function (a) {
+            "entity" === a.type &&
+                (a.attributes.title = a.content.replace(/&amp;/, "&"));
+        }),
+        Object.defineProperty(Prism.languages.markup.tag, "addInlined", {
+            value: function (a, e) {
+                var s = {};
+                (s["language-" + e] = {
+                    pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+                    lookbehind: !0,
+                    inside: Prism.languages[e]
+                }),
+                    (s.cdata = /^<!\[CDATA\[|\]\]>$/i);
+                var t = {
+                    "included-cdata": {
+                        pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+                        inside: s
+                    }
+                };
+                t["language-" + e] = {
+                    pattern: /[\s\S]+/,
+                    inside: Prism.languages[e]
+                };
+                var n = {};
+                (n[a] = {
+                    pattern: RegExp(
+                        "(<__[^>]*>)(?:<!\\[CDATA\\[(?:[^\\]]|\\](?!\\]>))*\\]\\]>|(?!<!\\[CDATA\\[)[^])*?(?=</__>)".replace(
+                            /__/g,
+                            function () {
+                                return a;
+                            }
+                        ),
+                        "i"
+                    ),
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: t
+                }),
+                    Prism.languages.insertBefore("markup", "cdata", n);
+            }
+        }),
+        Object.defineProperty(Prism.languages.markup.tag, "addAttribute", {
+            value: function (a, e) {
+                Prism.languages.markup.tag.inside["special-attr"].push({
+                    pattern: RegExp(
+                        "(^|[\"'\\s])(?:" +
+                            a +
+                            ")\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+(?=[\\s>]))",
+                        "i"
+                    ),
+                    lookbehind: !0,
+                    inside: {
+                        "attr-name": /^[^\s=]+/,
+                        "attr-value": {
+                            pattern: /=[\s\S]+/,
+                            inside: {
+                                value: {
+                                    pattern:
+                                        /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+                                    lookbehind: !0,
+                                    alias: [e, "language-" + e],
+                                    inside: Prism.languages[e]
+                                },
+                                punctuation: [
+                                    { pattern: /^=/, alias: "attr-equals" },
+                                    /"|'/
+                                ]
+                            }
+                        }
+                    }
+                });
+            }
+        }),
+        (Prism.languages.html = Prism.languages.markup),
+        (Prism.languages.mathml = Prism.languages.markup),
+        (Prism.languages.svg = Prism.languages.markup),
+        (Prism.languages.xml = Prism.languages.extend("markup", {})),
+        (Prism.languages.ssml = Prism.languages.xml),
+        (Prism.languages.atom = Prism.languages.xml),
+        (Prism.languages.rss = Prism.languages.xml);
+    !(function (s) {
+        var e =
+            /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+        (s.languages.css = {
+            comment: /\/\*[\s\S]*?\*\//,
+            atrule: {
+                pattern: RegExp(
+                    "@[\\w-](?:[^;{\\s\"']|\\s+(?!\\s)|" +
+                        e.source +
+                        ")*?(?:;|(?=\\s*\\{))"
+                ),
+                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\\((?:" +
+                        e.source +
+                        "|(?:[^\\\\\r\n()\"']|\\\\[^])*)\\)",
+                    "i"
+                ),
+                greedy: !0,
+                inside: {
+                    function: /^url/i,
+                    punctuation: /^\(|\)$/,
+                    string: {
+                        pattern: RegExp("^" + e.source + "$"),
+                        alias: "url"
+                    }
+                }
+            },
+            selector: {
+                pattern: RegExp(
+                    "(^|[{}\\s])[^{}\\s](?:[^{};\"'\\s]|\\s+(?![\\s{])|" +
+                        e.source +
+                        ")*(?=\\s*\\{)"
+                ),
+                lookbehind: !0
+            },
+            string: { pattern: e, 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: /[(){};:,]/
+        }),
+            (s.languages.css.atrule.inside.rest = s.languages.css);
+        var t = s.languages.markup;
+        t &&
+            (t.tag.addInlined("style", "css"),
+            t.tag.addAttribute("style", "css"));
+    })(Prism);
+    Prism.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: /[{}[\];(),.:]/
+    };
+    (Prism.languages.javascript = Prism.languages.extend("clike", {
+        "class-name": [
+            Prism.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$])(?:NaN|Infinity|0[bB][01]+(?:_[01]+)*n?|0[oO][0-7]+(?:_[0-7]+)*n?|0[xX][\\dA-Fa-f]+(?:_[\\dA-Fa-f]+)*n?|\\d+(?:_\\d+)*n|(?:\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\.\\d+(?:_\\d+)*)(?:[Ee][+-]?\\d+(?:_\\d+)*)?)(?![\\w$])"
+            ),
+            lookbehind: !0
+        },
+        operator:
+            /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
+    })),
+        (Prism.languages.javascript["class-name"][0].pattern =
+            /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/),
+        Prism.languages.insertBefore("javascript", "keyword", {
+            regex: {
+                pattern: RegExp(
+                    "((?:^|[^$\\w\\xA0-\\uFFFF.\"'\\])\\s]|\\b(?:return|yield))\\s*)/(?:(?:\\[(?:[^\\]\\\\\r\n]|\\\\.)*\\]|\\\\.|[^/\\\\\\[\r\n])+/[dgimyus]{0,7}|(?:\\[(?:[^[\\]\\\\\r\n]|\\\\.|\\[(?:[^[\\]\\\\\r\n]|\\\\.|\\[(?:[^[\\]\\\\\r\n]|\\\\.)*\\])*\\])*\\]|\\\\.|[^/\\\\\\[\r\n])+/[dgimyus]{0,7}v[dgimyus]{0,7})(?=(?:\\s|/\\*(?:[^*]|\\*(?!/))*\\*/)*(?:$|[\r\n,.;:})\\]]|//))"
+                ),
+                lookbehind: !0,
+                greedy: !0,
+                inside: {
+                    "regex-source": {
+                        pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+                        lookbehind: !0,
+                        alias: "language-regex",
+                        inside: Prism.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: Prism.languages.javascript
+                },
+                {
+                    pattern:
+                        /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+                    lookbehind: !0,
+                    inside: Prism.languages.javascript
+                },
+                {
+                    pattern:
+                        /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+                    lookbehind: !0,
+                    inside: Prism.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: Prism.languages.javascript
+                }
+            ],
+            constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
+        }),
+        Prism.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: Prism.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"
+            }
+        }),
+        Prism.languages.insertBefore("javascript", "operator", {
+            "literal-property": {
+                pattern:
+                    /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
+                lookbehind: !0,
+                alias: "property"
+            }
+        }),
+        Prism.languages.markup &&
+            (Prism.languages.markup.tag.addInlined("script", "javascript"),
+            Prism.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)",
+                "javascript"
+            )),
+        (Prism.languages.js = Prism.languages.javascript);
+    Prism.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 =
+                /\b(?:(?:after|before)(?=\s+[a-z])|abstract|activate|and|any|array|as|asc|autonomous|begin|bigdecimal|blob|boolean|break|bulk|by|byte|case|cast|catch|char|class|collect|commit|const|continue|currency|date|datetime|decimal|default|delete|desc|do|double|else|end|enum|exception|exit|export|extends|final|finally|float|for|from|get(?=\s*[{};])|global|goto|group|having|hint|if|implements|import|in|inner|insert|instanceof|int|integer|interface|into|join|like|limit|list|long|loop|map|merge|new|not|null|nulls|number|object|of|on|or|outer|override|package|parallel|pragma|private|protected|public|retrieve|return|rollback|select|set|short|sObject|sort|static|string|super|switch|synchronized|system|testmethod|then|this|throw|time|transaction|transient|trigger|try|undelete|update|upsert|using|virtual|void|webservice|when|where|while|(?:inherited|with|without)\s+sharing)\b/i,
+            n =
+                "\\b(?:(?=[a-z_]\\w*\\s*[<\\[])|(?!<keyword>))[A-Z_]\\w*(?:\\s*\\.\\s*[A-Z_]\\w*)*\\b(?:\\s*(?:\\[\\s*\\]|<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>))*".replace(
+                    /<keyword>/g,
+                    function () {
+                        return t.source;
+                    }
+                );
+        function i(e) {
+            return RegExp(
+                e.replace(/<CLASS-NAME>/g, function () {
+                    return n;
+                }),
+                "i"
+            );
+        }
+        var a = { keyword: t, punctuation: /[()\[\]{};,:.<>]/ };
+        e.languages.apex = {
+            comment: e.languages.clike.comment,
+            string: e.languages.clike.string,
+            sql: {
+                pattern: /((?:[=,({:]|\breturn)\s*)\[[^\[\]]*\]/i,
+                lookbehind: !0,
+                greedy: !0,
+                alias: "language-sql",
+                inside: e.languages.sql
+            },
+            annotation: { pattern: /@\w+\b/, alias: "punctuation" },
+            "class-name": [
+                {
+                    pattern: i(
+                        "(\\b(?:class|enum|extends|implements|instanceof|interface|new|trigger\\s+\\w+\\s+on)\\s+)<CLASS-NAME>"
+                    ),
+                    lookbehind: !0,
+                    inside: a
+                },
+                {
+                    pattern: i("(\\(\\s*)<CLASS-NAME>(?=\\s*\\)\\s*[\\w(])"),
+                    lookbehind: !0,
+                    inside: a
+                },
+                {
+                    pattern: i("<CLASS-NAME>(?=\\s*\\w+\\s*[;=,(){:])"),
+                    inside: a
+                }
+            ],
+            trigger: {
+                pattern: /(\btrigger\s+)\w+\b/i,
+                lookbehind: !0,
+                alias: "class-name"
+            },
+            keyword: t,
+            function: /\b[a-z_]\w*(?=\s*\()/i,
+            boolean: /\b(?:false|true)\b/i,
+            number: /(?:\B\.\d+|\b\d+(?:\.\d+|L)?)\b/i,
+            operator:
+                /[!=](?:==?)?|\?\.?|&&|\|\||--|\+\+|[-+*/^&|]=?|:|<<?=?|>{1,3}=?/,
+            punctuation: /[()\[\]{};,.]/
+        };
+    })(Prism);
+    !(function (e) {
+        function n(e, n) {
+            return e.replace(/<<(\d+)>>/g, function (e, s) {
+                return "(?:" + n[+s] + ")";
+            });
+        }
+        function s(e, s, a) {
+            return RegExp(n(e, s), a || "");
+        }
+        function a(e, n) {
+            for (var s = 0; s < n; s++)
+                e = e.replace(/<<self>>/g, function () {
+                    return "(?:" + e + ")";
+                });
+            return e.replace(/<<self>>/g, "[^\\s\\S]");
+        }
+        var t =
+                "bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void",
+            r = "class enum interface record struct",
+            i =
+                "add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)",
+            o =
+                "abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield";
+        function l(e) {
+            return "\\b(?:" + e.trim().replace(/ /g, "|") + ")\\b";
+        }
+        var d = l(r),
+            p = RegExp(l(t + " " + r + " " + i + " " + o)),
+            c = l(r + " " + i + " " + o),
+            u = l(t + " " + r + " " + o),
+            g = a("<(?:[^<>;=+\\-*/%&|^]|<<self>>)*>", 2),
+            b = a("\\((?:[^()]|<<self>>)*\\)", 2),
+            h = "@?\\b[A-Za-z_]\\w*\\b",
+            f = n("<<0>>(?:\\s*<<1>>)?", [h, g]),
+            m = n("(?!<<0>>)<<1>>(?:\\s*\\.\\s*<<1>>)*", [c, f]),
+            k = "\\[\\s*(?:,\\s*)*\\]",
+            y = n("<<0>>(?:\\s*(?:\\?\\s*)?<<1>>)*(?:\\s*\\?)?", [m, k]),
+            w = n("[^,()<>[\\];=+\\-*/%&|^]|<<0>>|<<1>>|<<2>>", [g, b, k]),
+            v = n("\\(<<0>>+(?:,<<0>>+)+\\)", [w]),
+            x = n("(?:<<0>>|<<1>>)(?:\\s*(?:\\?\\s*)?<<2>>)*(?:\\s*\\?)?", [
+                v,
+                m,
+                k
+            ]),
+            $ = { keyword: p, punctuation: /[<>()?,.:[\]]/ },
+            _ = "'(?:[^\r\n'\\\\]|\\\\.|\\\\[Uux][\\da-fA-F]{1,8})'",
+            B = '"(?:\\\\.|[^\\\\"\r\n])*"';
+        (e.languages.csharp = e.languages.extend("clike", {
+            string: [
+                {
+                    pattern: s("(^|[^$\\\\])<<0>>", [
+                        '@"(?:""|\\\\[^]|[^\\\\"])*"(?!")'
+                    ]),
+                    lookbehind: !0,
+                    greedy: !0
+                },
+                {
+                    pattern: s("(^|[^@$\\\\])<<0>>", [B]),
+                    lookbehind: !0,
+                    greedy: !0
+                }
+            ],
+            "class-name": [
+                {
+                    pattern: s("(\\busing\\s+static\\s+)<<0>>(?=\\s*;)", [m]),
+                    lookbehind: !0,
+                    inside: $
+                },
+                {
+                    pattern: s("(\\busing\\s+<<0>>\\s*=\\s*)<<1>>(?=\\s*;)", [
+                        h,
+                        x
+                    ]),
+                    lookbehind: !0,
+                    inside: $
+                },
+                {
+                    pattern: s("(\\busing\\s+)<<0>>(?=\\s*=)", [h]),
+                    lookbehind: !0
+                },
+                {
+                    pattern: s("(\\b<<0>>\\s+)<<1>>", [d, f]),
+                    lookbehind: !0,
+                    inside: $
+                },
+                {
+                    pattern: s("(\\bcatch\\s*\\(\\s*)<<0>>", [m]),
+                    lookbehind: !0,
+                    inside: $
+                },
+                { pattern: s("(\\bwhere\\s+)<<0>>", [h]), lookbehind: !0 },
+                {
+                    pattern: s("(\\b(?:is(?:\\s+not)?|as)\\s+)<<0>>", [y]),
+                    lookbehind: !0,
+                    inside: $
+                },
+                {
+                    pattern: s(
+                        "\\b<<0>>(?=\\s+(?!<<1>>|with\\s*\\{)<<2>>(?:\\s*[=,;:{)\\]]|\\s+(?:in|when)\\b))",
+                        [x, u, h]
+                    ),
+                    inside: $
+                }
+            ],
+            keyword: p,
+            number: /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
+            operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
+            punctuation: /\?\.?|::|[{}[\];(),.:]/
+        })),
+            e.languages.insertBefore("csharp", "number", {
+                range: { pattern: /\.\./, alias: "operator" }
+            }),
+            e.languages.insertBefore("csharp", "punctuation", {
+                "named-parameter": {
+                    pattern: s("([(,]\\s*)<<0>>(?=\\s*:)", [h]),
+                    lookbehind: !0,
+                    alias: "punctuation"
+                }
+            }),
+            e.languages.insertBefore("csharp", "class-name", {
+                namespace: {
+                    pattern: s(
+                        "(\\b(?:namespace|using)\\s+)<<0>>(?:\\s*\\.\\s*<<0>>)*(?=\\s*[;{])",
+                        [h]
+                    ),
+                    lookbehind: !0,
+                    inside: { punctuation: /\./ }
+                },
+                "type-expression": {
+                    pattern: s(
+                        "(\\b(?:default|sizeof|typeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<<0>>)*(?=\\s*\\))",
+                        [b]
+                    ),
+                    lookbehind: !0,
+                    alias: "class-name",
+                    inside: $
+                },
+                "return-type": {
+                    pattern: s(
+                        "<<0>>(?=\\s+(?:<<1>>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))",
+                        [x, m]
+                    ),
+                    inside: $,
+                    alias: "class-name"
+                },
+                "constructor-invocation": {
+                    pattern: s("(\\bnew\\s+)<<0>>(?=\\s*[[({])", [x]),
+                    lookbehind: !0,
+                    inside: $,
+                    alias: "class-name"
+                },
+                "generic-method": {
+                    pattern: s("<<0>>\\s*<<1>>(?=\\s*\\()", [h, g]),
+                    inside: {
+                        function: s("^<<0>>", [h]),
+                        generic: {
+                            pattern: RegExp(g),
+                            alias: "class-name",
+                            inside: $
+                        }
+                    }
+                },
+                "type-list": {
+                    pattern: s(
+                        "\\b((?:<<0>>\\s+<<1>>|record\\s+<<1>>\\s*<<5>>|where\\s+<<2>>)\\s*:\\s*)(?:<<3>>|<<4>>|<<1>>\\s*<<5>>|<<6>>)(?:\\s*,\\s*(?:<<3>>|<<4>>|<<6>>))*(?=\\s*(?:where|[{;]|=>|$))",
+                        [d, f, h, x, p.source, b, "\\bnew\\s*\\(\\s*\\)"]
+                    ),
+                    lookbehind: !0,
+                    inside: {
+                        "record-arguments": {
+                            pattern: s("(^(?!new\\s*\\()<<0>>\\s*)<<1>>", [
+                                f,
+                                b
+                            ]),
+                            lookbehind: !0,
+                            greedy: !0,
+                            inside: e.languages.csharp
+                        },
+                        keyword: p,
+                        "class-name": {
+                            pattern: RegExp(x),
+                            greedy: !0,
+                            inside: $
+                        },
+                        punctuation: /[,()]/
+                    }
+                },
+                preprocessor: {
+                    pattern: /(^[\t ]*)#.*/m,
+                    lookbehind: !0,
+                    alias: "property",
+                    inside: {
+                        directive: {
+                            pattern:
+                                /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
+                            lookbehind: !0,
+                            alias: "keyword"
+                        }
+                    }
+                }
+            });
+        var E = B + "|" + _,
+            R = n(
+                "/(?![*/])|//[^\r\n]*[\r\n]|/\\*(?:[^*]|\\*(?!/))*\\*/|<<0>>",
+                [E]
+            ),
+            z = a(n("[^\"'/()]|<<0>>|\\(<<self>>*\\)", [R]), 2),
+            S =
+                "\\b(?:assembly|event|field|method|module|param|property|return|type)\\b",
+            j = n("<<0>>(?:\\s*\\(<<1>>*\\))?", [m, z]);
+        e.languages.insertBefore("csharp", "class-name", {
+            attribute: {
+                pattern: s(
+                    "((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<<0>>\\s*:\\s*)?<<1>>(?:\\s*,\\s*<<1>>)*(?=\\s*\\])",
+                    [S, j]
+                ),
+                lookbehind: !0,
+                greedy: !0,
+                inside: {
+                    target: {
+                        pattern: s("^<<0>>(?=\\s*:)", [S]),
+                        alias: "keyword"
+                    },
+                    "attribute-arguments": {
+                        pattern: s("\\(<<0>>*\\)", [z]),
+                        inside: e.languages.csharp
+                    },
+                    "class-name": {
+                        pattern: RegExp(m),
+                        inside: { punctuation: /\./ }
+                    },
+                    punctuation: /[:,]/
+                }
+            }
+        });
+        var A = ":[^}\r\n]+",
+            F = a(n("[^\"'/()]|<<0>>|\\(<<self>>*\\)", [R]), 2),
+            P = n("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [F, A]),
+            U = a(
+                n(
+                    "[^\"'/()]|/(?!\\*)|/\\*(?:[^*]|\\*(?!/))*\\*/|<<0>>|\\(<<self>>*\\)",
+                    [E]
+                ),
+                2
+            ),
+            Z = n("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [U, A]);
+        function q(n, a) {
+            return {
+                interpolation: {
+                    pattern: s("((?:^|[^{])(?:\\{\\{)*)<<0>>", [n]),
+                    lookbehind: !0,
+                    inside: {
+                        "format-string": {
+                            pattern: s(
+                                "(^\\{(?:(?![}:])<<0>>)*)<<1>>(?=\\}$)",
+                                [a, A]
+                            ),
+                            lookbehind: !0,
+                            inside: { punctuation: /^:/ }
+                        },
+                        punctuation: /^\{|\}$/,
+                        expression: {
+                            pattern: /[\s\S]+/,
+                            alias: "language-csharp",
+                            inside: e.languages.csharp
+                        }
+                    }
+                },
+                string: /[\s\S]+/
+            };
+        }
+        e.languages.insertBefore("csharp", "string", {
+            "interpolation-string": [
+                {
+                    pattern: s(
+                        '(^|[^\\\\])(?:\\$@|@\\$)"(?:""|\\\\[^]|\\{\\{|<<0>>|[^\\\\{"])*"',
+                        [P]
+                    ),
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: q(P, F)
+                },
+                {
+                    pattern: s(
+                        '(^|[^@\\\\])\\$"(?:\\\\.|\\{\\{|<<0>>|[^\\\\"{])*"',
+                        [Z]
+                    ),
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: q(Z, U)
+                }
+            ],
+            char: { pattern: RegExp(_), greedy: !0 }
+        }),
+            (e.languages.dotnet = e.languages.cs = e.languages.csharp);
+    })(Prism);
+    (Prism.languages.aspnet = Prism.languages.extend("markup", {
+        "page-directive": {
+            pattern: /<%\s*@.*%>/,
+            alias: "tag",
+            inside: {
+                "page-directive": {
+                    pattern:
+                        /<%\s*@\s*(?:Assembly|Control|Implements|Import|Master(?:Type)?|OutputCache|Page|PreviousPageType|Reference|Register)?|%>/i,
+                    alias: "tag"
+                },
+                rest: Prism.languages.markup.tag.inside
+            }
+        },
+        directive: {
+            pattern: /<%.*%>/,
+            alias: "tag",
+            inside: {
+                directive: { pattern: /<%\s*?[$=%#:]{0,2}|%>/, alias: "tag" },
+                rest: Prism.languages.csharp
+            }
+        }
+    })),
+        (Prism.languages.aspnet.tag.pattern =
+            /<(?!%)\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/),
+        Prism.languages.insertBefore(
+            "inside",
+            "punctuation",
+            { directive: Prism.languages.aspnet.directive },
+            Prism.languages.aspnet.tag.inside["attr-value"]
+        ),
+        Prism.languages.insertBefore("aspnet", "comment", {
+            "asp-comment": {
+                pattern: /<%--[\s\S]*?--%>/,
+                alias: ["asp", "comment"]
+            }
+        }),
+        Prism.languages.insertBefore(
+            "aspnet",
+            Prism.languages.javascript ? "script" : "tag",
+            {
+                "asp-script": {
+                    pattern:
+                        /(<script(?=.*runat=['"]?server\b)[^>]*>)[\s\S]*?(?=<\/script>)/i,
+                    lookbehind: !0,
+                    alias: ["asp", "script"],
+                    inside: Prism.languages.csharp || {}
+                }
+            }
+        );
+    !(function (e) {
+        var t =
+                "\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b",
+            a = {
+                pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
+                lookbehind: !0,
+                alias: "punctuation",
+                inside: null
+            },
+            n = {
+                bash: a,
+                environment: { pattern: RegExp("\\$" + t), alias: "constant" },
+                variable: [
+                    {
+                        pattern: /\$?\(\([\s\S]+?\)\)/,
+                        greedy: !0,
+                        inside: {
+                            variable: [
+                                {
+                                    pattern: /(^\$\(\([\s\S]+)\)\)/,
+                                    lookbehind: !0
+                                },
+                                /^\$\(\(/
+                            ],
+                            number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+                            operator:
+                                /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
+                            punctuation: /\(\(?|\)\)?|,|;/
+                        }
+                    },
+                    {
+                        pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
+                        greedy: !0,
+                        inside: { variable: /^\$\(|^`|\)$|`$/ }
+                    },
+                    {
+                        pattern: /\$\{[^}]+\}/,
+                        greedy: !0,
+                        inside: {
+                            operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
+                            punctuation: /[\[\]]/,
+                            environment: {
+                                pattern: RegExp("(\\{)" + t),
+                                lookbehind: !0,
+                                alias: "constant"
+                            }
+                        }
+                    },
+                    /\$(?:\w+|[#?*!@$])/
+                ],
+                entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
+            };
+        (e.languages.bash = {
+            shebang: { pattern: /^#!\s*\/.*/, alias: "important" },
+            comment: { pattern: /(^|[^"{\\$])#.*/, lookbehind: !0 },
+            "function-name": [
+                {
+                    pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
+                    lookbehind: !0,
+                    alias: "function"
+                },
+                { pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/, alias: "function" }
+            ],
+            "for-or-select": {
+                pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
+                alias: "variable",
+                lookbehind: !0
+            },
+            "assign-left": {
+                pattern: /(^|[\s;|&]|[<>]\()\w+(?:\.\w+)*(?=\+?=)/,
+                inside: {
+                    environment: {
+                        pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + t),
+                        lookbehind: !0,
+                        alias: "constant"
+                    }
+                },
+                alias: "variable",
+                lookbehind: !0
+            },
+            parameter: {
+                pattern: /(^|\s)-{1,2}(?:\w+:[+-]?)?\w+(?:\.\w+)*(?=[=\s]|$)/,
+                alias: "variable",
+                lookbehind: !0
+            },
+            string: [
+                {
+                    pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: n
+                },
+                {
+                    pattern:
+                        /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: { bash: a }
+                },
+                {
+                    pattern:
+                        /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: n
+                },
+                { pattern: /(^|[^$\\])'[^']*'/, lookbehind: !0, greedy: !0 },
+                {
+                    pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
+                    greedy: !0,
+                    inside: { entity: n.entity }
+                }
+            ],
+            environment: { pattern: RegExp("\\$?" + t), alias: "constant" },
+            variable: n.variable,
+            function: {
+                pattern:
+                    /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cargo|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|java|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|sysctl|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
+                lookbehind: !0
+            },
+            keyword: {
+                pattern:
+                    /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
+                lookbehind: !0
+            },
+            builtin: {
+                pattern:
+                    /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
+                lookbehind: !0,
+                alias: "class-name"
+            },
+            boolean: {
+                pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
+                lookbehind: !0
+            },
+            "file-descriptor": { pattern: /\B&\d\b/, alias: "important" },
+            operator: {
+                pattern:
+                    /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
+                inside: {
+                    "file-descriptor": { pattern: /^\d/, alias: "important" }
+                }
+            },
+            punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
+            number: {
+                pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
+                lookbehind: !0
+            }
+        }),
+            (a.inside = e.languages.bash);
+        for (
+            var s = [
+                    "comment",
+                    "function-name",
+                    "for-or-select",
+                    "assign-left",
+                    "parameter",
+                    "string",
+                    "environment",
+                    "function",
+                    "keyword",
+                    "builtin",
+                    "boolean",
+                    "file-descriptor",
+                    "operator",
+                    "punctuation",
+                    "number"
+                ],
+                o = n.variable[1].inside,
+                i = 0;
+            i < s.length;
+            i++
+        )
+            o[s[i]] = e.languages.bash[s[i]];
+        (e.languages.sh = e.languages.bash),
+            (e.languages.shell = e.languages.bash);
+    })(Prism);
+    Prism.languages.basic = {
+        comment: { pattern: /(?:!|REM\b).+/i, inside: { keyword: /^REM/i } },
+        string: {
+            pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
+            greedy: !0
+        },
+        number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
+        keyword:
+            /\b(?:AS|BEEP|BLOAD|BSAVE|CALL(?: ABSOLUTE)?|CASE|CHAIN|CHDIR|CLEAR|CLOSE|CLS|COM|COMMON|CONST|DATA|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DIM|DO|DOUBLE|ELSE|ELSEIF|END|ENVIRON|ERASE|ERROR|EXIT|FIELD|FILES|FOR|FUNCTION|GET|GOSUB|GOTO|IF|INPUT|INTEGER|IOCTL|KEY|KILL|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|MKDIR|NAME|NEXT|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPTION BASE|OUT|POKE|PUT|READ|REDIM|REM|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SELECT CASE|SHARED|SHELL|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|SUB|SWAP|SYSTEM|THEN|TIMER|TO|TROFF|TRON|TYPE|UNLOCK|UNTIL|USING|VIEW PRINT|WAIT|WEND|WHILE|WRITE)(?:\$|\b)/i,
+        function:
+            /\b(?:ABS|ACCESS|ACOS|ANGLE|AREA|ARITHMETIC|ARRAY|ASIN|ASK|AT|ATN|BASE|BEGIN|BREAK|CAUSE|CEIL|CHR|CLIP|COLLATE|COLOR|CON|COS|COSH|COT|CSC|DATE|DATUM|DEBUG|DECIMAL|DEF|DEG|DEGREES|DELETE|DET|DEVICE|DISPLAY|DOT|ELAPSED|EPS|ERASABLE|EXLINE|EXP|EXTERNAL|EXTYPE|FILETYPE|FIXED|FP|GO|GRAPH|HANDLER|IDN|IMAGE|IN|INT|INTERNAL|IP|IS|KEYED|LBOUND|LCASE|LEFT|LEN|LENGTH|LET|LINE|LINES|LOG|LOG10|LOG2|LTRIM|MARGIN|MAT|MAX|MAXNUM|MID|MIN|MISSING|MOD|NATIVE|NUL|NUMERIC|OF|OPTION|ORD|ORGANIZATION|OUTIN|OUTPUT|PI|POINT|POINTER|POINTS|POS|PRINT|PROGRAM|PROMPT|RAD|RADIANS|RANDOMIZE|RECORD|RECSIZE|RECTYPE|RELATIVE|REMAINDER|REPEAT|REST|RETRY|REWRITE|RIGHT|RND|ROUND|RTRIM|SAME|SEC|SELECT|SEQUENTIAL|SET|SETTER|SGN|SIN|SINH|SIZE|SKIP|SQR|STANDARD|STATUS|STR|STREAM|STYLE|TAB|TAN|TANH|TEMPLATE|TEXT|THERE|TIME|TIMEOUT|TRACE|TRANSFORM|TRUNCATE|UBOUND|UCASE|USE|VAL|VARIABLE|VIEWPORT|WHEN|WINDOW|WITH|ZER|ZONEWIDTH)(?:\$|\b)/i,
+        operator: /<[=>]?|>=?|[+\-*\/^=&]|\b(?:AND|EQV|IMP|NOT|OR|XOR)\b/i,
+        punctuation: /[,;:()]/
+    };
+    (Prism.languages.c = Prism.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|[?:~]|[-+*/%&|^!=<>]=?/
+    })),
+        Prism.languages.insertBefore("c", "string", {
+            char: {
+                pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
+                greedy: !0
+            }
+        }),
+        Prism.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 },
+                        Prism.languages.c.string
+                    ],
+                    char: Prism.languages.c.char,
+                    comment: Prism.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: Prism.languages.c
+                    }
+                }
+            }
+        }),
+        Prism.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 Prism.languages.c.boolean;
+    !(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/,
+            n = "\\b(?!<keyword>)\\w+(?:\\s*\\.\\s*\\w+)*\\b".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+".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+)(?:"(?:\\\\(?:\r\n|[^])|[^"\\\\\r\n])*"|<[^<>\r\n]*>|' +
+                            "<mod-name>(?:\\s*:\\s*<mod-name>)?|:\\s*<mod-name>".replace(
+                                /<mod-name>/g,
+                                function () {
+                                    return n;
+                                }
+                            ) +
+                            ")"
+                    ),
+                    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"]
+            );
+    })(Prism);
+    !(function (e) {
+        var a,
+            n = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
+        (e.languages.css.selector = {
+            pattern: e.languages.css.selector.pattern,
+            lookbehind: !0,
+            inside: (a = {
+                "pseudo-element":
+                    /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
+                "pseudo-class": /:[-\w]+/,
+                class: /\.[-\w]+/,
+                id: /#[-\w]+/,
+                attribute: {
+                    pattern: RegExp("\\[(?:[^[\\]\"']|" + n.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": [
+                            n,
+                            {
+                                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 = a),
+            e.languages.insertBefore("css", "property", {
+                variable: {
+                    pattern:
+                        /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i,
+                    lookbehind: !0
+                }
+            });
+        var r = { pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/, lookbehind: !0 },
+            i = {
+                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: r,
+                        number: i,
+                        function: /[\w-]+(?=\()/,
+                        punctuation: /[(),]/
+                    }
+                }
+            ],
+            entity: /\\[\da-f]{1,8}/i,
+            unit: r,
+            number: i
+        });
+    })(Prism);
+    !(function (e) {
+        e.languages.dataweave = {
+            url: /\b[A-Za-z]+:\/\/[\w/:.?=&-]+|\burn:[\w:.?=&-]+/,
+            property: {
+                pattern:
+                    /(?:\b\w+#)?(?:"(?:\\.|[^\\"\r\n])*"|\b\w+)(?=\s*[:@])/,
+                greedy: !0
+            },
+            string: {
+                pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+                greedy: !0
+            },
+            "mime-type":
+                /\b(?:application|audio|image|multipart|text|video)\/[\w+-]+/,
+            date: { pattern: /\|[\w:+-]+\|/, greedy: !0 },
+            comment: [
+                {
+                    pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+                    lookbehind: !0,
+                    greedy: !0
+                },
+                { pattern: /(^|[^\\:])\/\/.*/, lookbehind: !0, greedy: !0 }
+            ],
+            regex: { pattern: /\/(?:[^\\\/\r\n]|\\[^\r\n])+\//, greedy: !0 },
+            keyword:
+                /\b(?:and|as|at|case|do|else|fun|if|input|is|match|not|ns|null|or|output|type|unless|update|using|var)\b/,
+            function: /\b[A-Z_]\w*(?=\s*\()/i,
+            number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+            punctuation: /[{}[\];(),.:@]/,
+            operator: /<<|>>|->|[<>~=]=?|!=|--?-?|\+\+?|!|\?/,
+            boolean: /\b(?:false|true)\b/
+        };
+    })(Prism);
+    (Prism.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: Prism.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+/
+    }),
+        Prism.hooks.add("after-tokenize", function (n) {
+            if ("graphql" === n.language)
+                for (
+                    var t = n.tokens.filter(function (n) {
+                            return (
+                                "string" != typeof n &&
+                                "comment" !== n.type &&
+                                "scalar" !== n.type
+                            );
+                        }),
+                        e = 0;
+                    e < t.length;
+
+                ) {
+                    var a = t[e++];
+                    if ("keyword" === a.type && "mutation" === a.content) {
+                        var r = [];
+                        if (
+                            c(["definition-mutation", "punctuation"]) &&
+                            "(" === l(1).content
+                        ) {
+                            e += 2;
+                            var i = f(/^\($/, /^\)$/);
+                            if (-1 === i) continue;
+                            for (; e < i; e++) {
+                                var o = l(0);
+                                "variable" === o.type &&
+                                    (b(o, "variable-input"), r.push(o.content));
+                            }
+                            e = i + 1;
+                        }
+                        if (
+                            c(["punctuation", "property-query"]) &&
+                            "{" === l(0).content &&
+                            (e++, b(l(0), "property-mutation"), r.length > 0)
+                        ) {
+                            var s = f(/^\{$/, /^\}$/);
+                            if (-1 === s) continue;
+                            for (var u = e; u < s; u++) {
+                                var p = t[u];
+                                "variable" === p.type &&
+                                    r.indexOf(p.content) >= 0 &&
+                                    b(p, "variable-input");
+                            }
+                        }
+                    }
+                }
+            function l(n) {
+                return t[e + n];
+            }
+            function c(n, t) {
+                t = t || 0;
+                for (var e = 0; e < n.length; e++) {
+                    var a = l(e + t);
+                    if (!a || a.type !== n[e]) return !1;
+                }
+                return !0;
+            }
+            function f(n, a) {
+                for (var r = 1, i = e; i < t.length; i++) {
+                    var o = t[i],
+                        s = o.content;
+                    if ("punctuation" === o.type && "string" == typeof s)
+                        if (n.test(s)) r++;
+                        else if (a.test(s) && 0 == --r) return i;
+                }
+                return -1;
+            }
+            function b(n, t) {
+                var e = n.alias;
+                e
+                    ? Array.isArray(e) || (n.alias = e = [e])
+                    : (n.alias = e = []),
+                    e.push(t);
+            }
+        });
+    !(function (e) {
+        function n(e, n) {
+            return "___" + e.toUpperCase() + n + "___";
+        }
+        Object.defineProperties((e.languages["markup-templating"] = {}), {
+            buildPlaceholders: {
+                value: function (t, a, r, o) {
+                    if (t.language === a) {
+                        var c = (t.tokenStack = []);
+                        (t.code = t.code.replace(r, function (e) {
+                            if ("function" == typeof o && !o(e)) return e;
+                            for (
+                                var r, i = c.length;
+                                -1 !== t.code.indexOf((r = n(a, i)));
+
+                            )
+                                ++i;
+                            return (c[i] = e), r;
+                        })),
+                            (t.grammar = e.languages.markup);
+                    }
+                }
+            },
+            tokenizePlaceholders: {
+                value: function (t, a) {
+                    if (t.language === a && t.tokenStack) {
+                        t.grammar = e.languages[a];
+                        var r = 0,
+                            o = Object.keys(t.tokenStack);
+                        !(function c(i) {
+                            for (
+                                var u = 0;
+                                u < i.length && !(r >= o.length);
+                                u++
+                            ) {
+                                var g = i[u];
+                                if (
+                                    "string" == typeof g ||
+                                    (g.content && "string" == typeof g.content)
+                                ) {
+                                    var l = o[r],
+                                        s = t.tokenStack[l],
+                                        f =
+                                            "string" == typeof g
+                                                ? g
+                                                : g.content,
+                                        p = n(a, l),
+                                        k = f.indexOf(p);
+                                    if (k > -1) {
+                                        ++r;
+                                        var m = f.substring(0, k),
+                                            d = new e.Token(
+                                                a,
+                                                e.tokenize(s, t.grammar),
+                                                "language-" + a,
+                                                s
+                                            ),
+                                            h = f.substring(k + p.length),
+                                            v = [];
+                                        m && v.push.apply(v, c([m])),
+                                            v.push(d),
+                                            h && v.push.apply(v, c([h])),
+                                            "string" == typeof g
+                                                ? i.splice.apply(
+                                                      i,
+                                                      [u, 1].concat(v)
+                                                  )
+                                                : (g.content = v);
+                                    }
+                                } else g.content && c(g.content);
+                            }
+                            return i;
+                        })(t.tokens);
+                    }
+                }
+            }
+        });
+    })(Prism);
+    !(function (a) {
+        (a.languages.handlebars = {
+            comment: /\{\{![\s\S]*?\}\}/,
+            delimiter: { pattern: /^\{\{\{?|\}\}\}?$/, alias: "punctuation" },
+            string: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+            number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,
+            boolean: /\b(?:false|true)\b/,
+            block: {
+                pattern: /^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,
+                lookbehind: !0,
+                alias: "keyword"
+            },
+            brackets: {
+                pattern: /\[[^\]]+\]/,
+                inside: { punctuation: /\[|\]/, variable: /[\s\S]+/ }
+            },
+            punctuation: /[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,
+            variable: /[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/
+        }),
+            a.hooks.add("before-tokenize", function (e) {
+                a.languages["markup-templating"].buildPlaceholders(
+                    e,
+                    "handlebars",
+                    /\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g
+                );
+            }),
+            a.hooks.add("after-tokenize", function (e) {
+                a.languages["markup-templating"].tokenizePlaceholders(
+                    e,
+                    "handlebars"
+                );
+            }),
+            (a.languages.hbs = a.languages.handlebars),
+            (a.languages.mustache = a.languages.handlebars);
+    })(Prism);
+    Prism.languages.hcl = {
+        comment: /(?:\/\/|#).*|\/\*[\s\S]*?(?:\*\/|$)/,
+        heredoc: {
+            pattern: /<<-?(\w+\b)[\s\S]*?^[ \t]*\1/m,
+            greedy: !0,
+            alias: "string"
+        },
+        keyword: [
+            {
+                pattern:
+                    /(?:data|resource)\s+(?:"(?:\\[\s\S]|[^\\"])*")(?=\s+"[\w-]+"\s+\{)/i,
+                inside: {
+                    type: {
+                        pattern:
+                            /(resource|data|\s+)(?:"(?:\\[\s\S]|[^\\"])*")/i,
+                        lookbehind: !0,
+                        alias: "variable"
+                    }
+                }
+            },
+            {
+                pattern:
+                    /(?:backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+(?=\{)/i,
+                inside: {
+                    type: {
+                        pattern:
+                            /(backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+/i,
+                        lookbehind: !0,
+                        alias: "variable"
+                    }
+                }
+            },
+            /[\w-]+(?=\s+\{)/
+        ],
+        property: [
+            /[-\w\.]+(?=\s*=(?!=))/,
+            /"(?:\\[\s\S]|[^\\"])+"(?=\s*[:=])/
+        ],
+        string: {
+            pattern:
+                /"(?:[^\\$"]|\\[\s\S]|\$(?:(?=")|\$+(?!\$)|[^"${])|\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\})*"/,
+            greedy: !0,
+            inside: {
+                interpolation: {
+                    pattern: /(^|[^$])\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\}/,
+                    lookbehind: !0,
+                    inside: {
+                        type: {
+                            pattern:
+                                /(\b(?:count|data|local|module|path|self|terraform|var)\b\.)[\w\*]+/i,
+                            lookbehind: !0,
+                            alias: "variable"
+                        },
+                        keyword:
+                            /\b(?:count|data|local|module|path|self|terraform|var)\b/i,
+                        function: /\w+(?=\()/,
+                        string: {
+                            pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+                            greedy: !0
+                        },
+                        number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,
+                        punctuation: /[!\$#%&'()*+,.\/;<=>@\[\\\]^`{|}~?:]/
+                    }
+                }
+            }
+        },
+        number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,
+        boolean: /\b(?:false|true)\b/i,
+        punctuation: /[=\[\]{}]/
+    };
+    !(function (e) {
+        var n =
+                /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/,
+            t = "(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*",
+            s = {
+                pattern: RegExp(
+                    "(^|[^\\w.])" + t + "[A-Z](?:[\\d_A-Z]*[a-z]\\w*)?\\b"
+                ),
+                lookbehind: !0,
+                inside: {
+                    namespace: {
+                        pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+                        inside: { punctuation: /\./ }
+                    },
+                    punctuation: /\./
+                }
+            };
+        (e.languages.java = e.languages.extend("clike", {
+            string: {
+                pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
+                lookbehind: !0,
+                greedy: !0
+            },
+            "class-name": [
+                s,
+                {
+                    pattern: RegExp(
+                        "(^|[^\\w.])" +
+                            t +
+                            "[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()]|\\s*(?:\\[[\\s,]*\\]\\s*)?::\\s*new\\b)"
+                    ),
+                    lookbehind: !0,
+                    inside: s.inside
+                },
+                {
+                    pattern: RegExp(
+                        "(\\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\\s+)" +
+                            t +
+                            "[A-Z]\\w*\\b"
+                    ),
+                    lookbehind: !0,
+                    inside: s.inside
+                }
+            ],
+            keyword: n,
+            function: [
+                e.languages.clike.function,
+                { pattern: /(::\s*)[a-z_]\w*/, lookbehind: !0 }
+            ],
+            number: /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
+            operator: {
+                pattern:
+                    /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
+                lookbehind: !0
+            },
+            constant: /\b[A-Z][A-Z_\d]+\b/
+        })),
+            e.languages.insertBefore("java", "string", {
+                "triple-quoted-string": {
+                    pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
+                    greedy: !0,
+                    alias: "string"
+                },
+                char: { pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/, greedy: !0 }
+            }),
+            e.languages.insertBefore("java", "class-name", {
+                annotation: {
+                    pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
+                    lookbehind: !0,
+                    alias: "punctuation"
+                },
+                generics: {
+                    pattern:
+                        /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
+                    inside: {
+                        "class-name": s,
+                        keyword: n,
+                        punctuation: /[<>(),.:]/,
+                        operator: /[?&|]/
+                    }
+                },
+                import: [
+                    {
+                        pattern: RegExp(
+                            "(\\bimport\\s+)" + t + "(?:[A-Z]\\w*|\\*)(?=\\s*;)"
+                        ),
+                        lookbehind: !0,
+                        inside: {
+                            namespace: s.inside.namespace,
+                            punctuation: /\./,
+                            operator: /\*/,
+                            "class-name": /\w+/
+                        }
+                    },
+                    {
+                        pattern: RegExp(
+                            "(\\bimport\\s+static\\s+)" +
+                                t +
+                                "(?:\\w+|\\*)(?=\\s*;)"
+                        ),
+                        lookbehind: !0,
+                        alias: "static",
+                        inside: {
+                            namespace: s.inside.namespace,
+                            static: /\b\w+$/,
+                            punctuation: /\./,
+                            operator: /\*/,
+                            "class-name": /\w+/
+                        }
+                    }
+                ],
+                namespace: {
+                    pattern: RegExp(
+                        "(\\b(?:exports|import(?:\\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\\s+)(?!<keyword>)[a-z]\\w*(?:\\.[a-z]\\w*)*\\.?".replace(
+                            /<keyword>/g,
+                            function () {
+                                return n.source;
+                            }
+                        )
+                    ),
+                    lookbehind: !0,
+                    inside: { punctuation: /\./ }
+                }
+            });
+    })(Prism);
+    !(function (e) {
+        var a = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/,
+            t = [
+                { pattern: /\b(?:false|true)\b/i, alias: "boolean" },
+                {
+                    pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                {
+                    pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                /\b(?:null)\b/i,
+                /\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/
+            ],
+            i =
+                /\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[\da-f]+(?:_[\da-f]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+            n =
+                /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/,
+            s = /[{}\[\](),:;]/;
+        e.languages.php = {
+            delimiter: {
+                pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
+                alias: "important"
+            },
+            comment: a,
+            variable: /\$+(?:\w+\b|(?=\{))/,
+            package: {
+                pattern:
+                    /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+                lookbehind: !0,
+                inside: { punctuation: /\\/ }
+            },
+            "class-name-definition": {
+                pattern:
+                    /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
+                lookbehind: !0,
+                alias: "class-name"
+            },
+            "function-definition": {
+                pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
+                lookbehind: !0,
+                alias: "function"
+            },
+            keyword: [
+                {
+                    pattern:
+                        /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
+                    alias: "type-casting",
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                {
+                    pattern:
+                        /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
+                    alias: "type-hint",
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                {
+                    pattern:
+                        /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|never|object|self|static|string|void)\b/i,
+                    alias: "return-type",
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                {
+                    pattern:
+                        /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
+                    alias: "type-declaration",
+                    greedy: !0
+                },
+                {
+                    pattern:
+                        /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
+                    alias: "type-declaration",
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                {
+                    pattern: /\b(?:parent|self|static)(?=\s*::)/i,
+                    alias: "static-context",
+                    greedy: !0
+                },
+                { pattern: /(\byield\s+)from\b/i, lookbehind: !0 },
+                /\bclass\b/i,
+                {
+                    pattern:
+                        /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|never|new|or|parent|print|private|protected|public|readonly|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i,
+                    lookbehind: !0
+                }
+            ],
+            "argument-name": {
+                pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i,
+                lookbehind: !0
+            },
+            "class-name": [
+                {
+                    pattern:
+                        /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                {
+                    pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                { pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i, greedy: !0 },
+                {
+                    pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
+                    alias: "class-name-fully-qualified",
+                    greedy: !0,
+                    lookbehind: !0,
+                    inside: { punctuation: /\\/ }
+                },
+                {
+                    pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
+                    alias: "class-name-fully-qualified",
+                    greedy: !0,
+                    inside: { punctuation: /\\/ }
+                },
+                {
+                    pattern:
+                        /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+                    alias: "class-name-fully-qualified",
+                    greedy: !0,
+                    lookbehind: !0,
+                    inside: { punctuation: /\\/ }
+                },
+                {
+                    pattern: /\b[a-z_]\w*(?=\s*\$)/i,
+                    alias: "type-declaration",
+                    greedy: !0
+                },
+                {
+                    pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+                    alias: ["class-name-fully-qualified", "type-declaration"],
+                    greedy: !0,
+                    inside: { punctuation: /\\/ }
+                },
+                {
+                    pattern: /\b[a-z_]\w*(?=\s*::)/i,
+                    alias: "static-context",
+                    greedy: !0
+                },
+                {
+                    pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
+                    alias: ["class-name-fully-qualified", "static-context"],
+                    greedy: !0,
+                    inside: { punctuation: /\\/ }
+                },
+                {
+                    pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
+                    alias: "type-hint",
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                {
+                    pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+                    alias: ["class-name-fully-qualified", "type-hint"],
+                    greedy: !0,
+                    lookbehind: !0,
+                    inside: { punctuation: /\\/ }
+                },
+                {
+                    pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
+                    alias: "return-type",
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                {
+                    pattern:
+                        /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+                    alias: ["class-name-fully-qualified", "return-type"],
+                    greedy: !0,
+                    lookbehind: !0,
+                    inside: { punctuation: /\\/ }
+                }
+            ],
+            constant: t,
+            function: {
+                pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
+                lookbehind: !0,
+                inside: { punctuation: /\\/ }
+            },
+            property: { pattern: /(->\s*)\w+/, lookbehind: !0 },
+            number: i,
+            operator: n,
+            punctuation: s
+        };
+        var l = {
+                pattern:
+                    /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
+                lookbehind: !0,
+                inside: e.languages.php
+            },
+            r = [
+                {
+                    pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
+                    alias: "nowdoc-string",
+                    greedy: !0,
+                    inside: {
+                        delimiter: {
+                            pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
+                            alias: "symbol",
+                            inside: { punctuation: /^<<<'?|[';]$/ }
+                        }
+                    }
+                },
+                {
+                    pattern:
+                        /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
+                    alias: "heredoc-string",
+                    greedy: !0,
+                    inside: {
+                        delimiter: {
+                            pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
+                            alias: "symbol",
+                            inside: { punctuation: /^<<<"?|[";]$/ }
+                        },
+                        interpolation: l
+                    }
+                },
+                {
+                    pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+                    alias: "backtick-quoted-string",
+                    greedy: !0
+                },
+                {
+                    pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+                    alias: "single-quoted-string",
+                    greedy: !0
+                },
+                {
+                    pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+                    alias: "double-quoted-string",
+                    greedy: !0,
+                    inside: { interpolation: l }
+                }
+            ];
+        e.languages.insertBefore("php", "variable", {
+            string: r,
+            attribute: {
+                pattern:
+                    /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
+                greedy: !0,
+                inside: {
+                    "attribute-content": {
+                        pattern: /^(#\[)[\s\S]+(?=\]$)/,
+                        lookbehind: !0,
+                        inside: {
+                            comment: a,
+                            string: r,
+                            "attribute-class-name": [
+                                {
+                                    pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
+                                    alias: "class-name",
+                                    greedy: !0,
+                                    lookbehind: !0
+                                },
+                                {
+                                    pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
+                                    alias: [
+                                        "class-name",
+                                        "class-name-fully-qualified"
+                                    ],
+                                    greedy: !0,
+                                    lookbehind: !0,
+                                    inside: { punctuation: /\\/ }
+                                }
+                            ],
+                            constant: t,
+                            number: i,
+                            operator: n,
+                            punctuation: s
+                        }
+                    },
+                    delimiter: { pattern: /^#\[|\]$/, alias: "punctuation" }
+                }
+            }
+        }),
+            e.hooks.add("before-tokenize", function (a) {
+                /<\?/.test(a.code) &&
+                    e.languages["markup-templating"].buildPlaceholders(
+                        a,
+                        "php",
+                        /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g
+                    );
+            }),
+            e.hooks.add("after-tokenize", function (a) {
+                e.languages["markup-templating"].tokenizePlaceholders(a, "php");
+            });
+    })(Prism);
+    !(function (a) {
+        var e = (a.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(e, "addSupport", {
+            value: function (e, n) {
+                "string" == typeof e && (e = [e]),
+                    e.forEach(function (e) {
+                        !(function (e, n) {
+                            var t = "doc-comment",
+                                r = a.languages[e];
+                            if (r) {
+                                var o = r[t];
+                                if (
+                                    (o ||
+                                        (o = (r = a.languages.insertBefore(
+                                            e,
+                                            "comment",
+                                            {
+                                                "doc-comment": {
+                                                    pattern:
+                                                        /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/,
+                                                    lookbehind: !0,
+                                                    alias: "comment"
+                                                }
+                                            }
+                                        ))[t]),
+                                    o instanceof RegExp &&
+                                        (o = r[t] = { pattern: o }),
+                                    Array.isArray(o))
+                                )
+                                    for (var i = 0, s = o.length; i < s; i++)
+                                        o[i] instanceof RegExp &&
+                                            (o[i] = { pattern: o[i] }),
+                                            n(o[i]);
+                                else n(o);
+                            }
+                        })(e, function (a) {
+                            a.inside || (a.inside = {}), (a.inside.rest = n);
+                        });
+                    });
+            }
+        }),
+            e.addSupport(["java", "javascript", "php"], e);
+    })(Prism);
+    !(function (a) {
+        var e = /(^(?:[\t ]*(?:\*\s*)*))[^*\s].*$/m,
+            n =
+                "(?:\\b[a-zA-Z]\\w+\\s*\\.\\s*)*\\b[A-Z]\\w*(?:\\s*<mem>)?|<mem>".replace(
+                    /<mem>/g,
+                    function () {
+                        return "#\\s*\\w+(?:\\s*\\([^()]*\\))?";
+                    }
+                );
+        (a.languages.javadoc = a.languages.extend("javadoclike", {})),
+            a.languages.insertBefore("javadoc", "keyword", {
+                reference: {
+                    pattern: RegExp(
+                        "(@(?:exception|link|linkplain|see|throws|value)\\s+(?:\\*\\s*)?)(?:" +
+                            n +
+                            ")"
+                    ),
+                    lookbehind: !0,
+                    inside: {
+                        function: {
+                            pattern: /(#\s*)\w+(?=\s*\()/,
+                            lookbehind: !0
+                        },
+                        field: { pattern: /(#\s*)\w+/, lookbehind: !0 },
+                        namespace: {
+                            pattern: /\b(?:[a-z]\w*\s*\.\s*)+/,
+                            inside: { punctuation: /\./ }
+                        },
+                        "class-name": /\b[A-Z]\w*/,
+                        keyword: a.languages.java.keyword,
+                        punctuation: /[#()[\],.]/
+                    }
+                },
+                "class-name": {
+                    pattern: /(@param\s+)<[A-Z]\w*>/,
+                    lookbehind: !0,
+                    inside: { punctuation: /[.<>]/ }
+                },
+                "code-section": [
+                    {
+                        pattern:
+                            /(\{@code\s+(?!\s))(?:[^\s{}]|\s+(?![\s}])|\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\})+(?=\s*\})/,
+                        lookbehind: !0,
+                        inside: {
+                            code: {
+                                pattern: e,
+                                lookbehind: !0,
+                                inside: a.languages.java,
+                                alias: "language-java"
+                            }
+                        }
+                    },
+                    {
+                        pattern:
+                            /(<(code|pre|tt)>(?!<code>)\s*)\S(?:\S|\s+\S)*?(?=\s*<\/\2>)/,
+                        lookbehind: !0,
+                        inside: {
+                            line: {
+                                pattern: e,
+                                lookbehind: !0,
+                                inside: {
+                                    tag: a.languages.markup.tag,
+                                    entity: a.languages.markup.entity,
+                                    code: {
+                                        pattern: /.+/,
+                                        inside: a.languages.java,
+                                        alias: "language-java"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                ],
+                tag: a.languages.markup.tag,
+                entity: a.languages.markup.entity
+            }),
+            a.languages.javadoclike.addSupport("java", a.languages.javadoc);
+    })(Prism);
+    !(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 s = e.languages.extend("typescript", {});
+        delete s["class-name"],
+            (e.languages.typescript["class-name"].inside = s),
+            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: s
+                        }
+                    }
+                }
+            }),
+            (e.languages.ts = e.languages.typescript);
+    })(Prism);
+    !(function (e) {
+        var a = e.languages.javascript,
+            n = "\\{(?:[^{}]|\\{(?:[^{}]|\\{[^{}]*\\})*\\})+\\}",
+            t = "(@(?:arg|argument|param|property)\\s+(?:" + n + "\\s+)?)";
+        (e.languages.jsdoc = e.languages.extend("javadoclike", {
+            parameter: {
+                pattern: RegExp(
+                    t + "(?:(?!\\s)[$\\w\\xA0-\\uFFFF.])+(?=\\s|$)"
+                ),
+                lookbehind: !0,
+                inside: { punctuation: /\./ }
+            }
+        })),
+            e.languages.insertBefore("jsdoc", "keyword", {
+                "optional-parameter": {
+                    pattern: RegExp(
+                        t +
+                            "\\[(?:(?!\\s)[$\\w\\xA0-\\uFFFF.])+(?:=[^[\\]]+)?\\](?=\\s|$)"
+                    ),
+                    lookbehind: !0,
+                    inside: {
+                        parameter: {
+                            pattern: /(^\[)[$\w\xA0-\uFFFF\.]+/,
+                            lookbehind: !0,
+                            inside: { punctuation: /\./ }
+                        },
+                        code: {
+                            pattern: /(=)[\s\S]*(?=\]$)/,
+                            lookbehind: !0,
+                            inside: a,
+                            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*)*".replace(
+                                /<TYPE>/g,
+                                function () {
+                                    return n;
+                                }
+                            )
+                        ),
+                        lookbehind: !0,
+                        inside: { punctuation: /\./ }
+                    },
+                    {
+                        pattern: RegExp("(@[a-z]+\\s+)" + n),
+                        lookbehind: !0,
+                        inside: {
+                            string: a.string,
+                            number: a.number,
+                            boolean: a.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: a,
+                            alias: "language-javascript"
+                        }
+                    }
+                }
+            }),
+            e.languages.javadoclike.addSupport("javascript", e.languages.jsdoc);
+    })(Prism);
+    !(function (a) {
+        function e(a, e) {
+            return RegExp(
+                a.replace(/<ID>/g, function () {
+                    return "(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*";
+                }),
+                e
+            );
+        }
+        a.languages.insertBefore("javascript", "function-variable", {
+            "method-variable": {
+                pattern: RegExp(
+                    "(\\.\\s*)" +
+                        a.languages.javascript["function-variable"].pattern
+                            .source
+                ),
+                lookbehind: !0,
+                alias: [
+                    "function-variable",
+                    "method",
+                    "function",
+                    "property-access"
+                ]
+            }
+        }),
+            a.languages.insertBefore("javascript", "function", {
+                method: {
+                    pattern: RegExp(
+                        "(\\.\\s*)" + a.languages.javascript.function.source
+                    ),
+                    lookbehind: !0,
+                    alias: ["function", "property-access"]
+                }
+            }),
+            a.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" }
+                ]
+            }),
+            a.languages.insertBefore("javascript", "keyword", {
+                imports: {
+                    pattern: e(
+                        "(\\bimport\\b\\s*)(?:<ID>(?:\\s*,\\s*(?:\\*\\s*as\\s+<ID>|\\{[^{}]*\\}))?|\\*\\s*as\\s+<ID>|\\{[^{}]*\\})(?=\\s*\\bfrom\\b)"
+                    ),
+                    lookbehind: !0,
+                    inside: a.languages.javascript
+                },
+                exports: {
+                    pattern: e(
+                        "(\\bexport\\b\\s*)(?:\\*(?:\\s*as\\s+<ID>)?(?=\\s*\\bfrom\\b)|\\{[^{}]*\\})"
+                    ),
+                    lookbehind: !0,
+                    inside: a.languages.javascript
+                }
+            }),
+            a.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" }
+            ),
+            a.languages.insertBefore("javascript", "operator", {
+                spread: { pattern: /\.{3}/, alias: "operator" },
+                arrow: { pattern: /=>/, alias: "operator" }
+            }),
+            a.languages.insertBefore("javascript", "punctuation", {
+                "property-access": {
+                    pattern: e("(\\.\\s*)#?<ID>"),
+                    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 t = [
+                    "function",
+                    "function-variable",
+                    "method",
+                    "method-variable",
+                    "property-access"
+                ],
+                r = 0;
+            r < t.length;
+            r++
+        ) {
+            var n = t[r],
+                s = a.languages.javascript[n];
+            "RegExp" === a.util.type(s) &&
+                (s = a.languages.javascript[n] = { pattern: s });
+            var o = s.inside || {};
+            (s.inside = o), (o["maybe-class-name"] = /^[A-Z][\s\S]*/);
+        }
+    })(Prism);
+    (Prism.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" }
+    }),
+        (Prism.languages.webmanifest = Prism.languages.json);
+    !(function (n) {
+        var e = /("|')(?:\\(?:\r\n?|\n|.)|(?!\1)[^\\\r\n])*\1/;
+        n.languages.json5 = n.languages.extend("json", {
+            property: [
+                { pattern: RegExp(e.source + "(?=\\s*:)"), greedy: !0 },
+                {
+                    pattern:
+                        /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/,
+                    alias: "unquoted"
+                }
+            ],
+            string: { pattern: e, greedy: !0 },
+            number: /[+-]?\b(?:NaN|Infinity|0x[a-fA-F\d]+)\b|[+-]?(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+\b)?/
+        });
+    })(Prism);
+    (Prism.languages.jsonp = Prism.languages.extend("json", {
+        punctuation: /[{}[\]();,.]/
+    })),
+        Prism.languages.insertBefore("jsonp", "punctuation", {
+            function:
+                /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*\()/
+        });
+    Prism.languages.jsstacktrace = {
+        "error-message": { pattern: /^\S.*/m, alias: "string" },
+        "stack-frame": {
+            pattern: /(^[ \t]+)at[ \t].*/m,
+            lookbehind: !0,
+            inside: {
+                "not-my-code": {
+                    pattern:
+                        /^at[ \t]+(?!\s)(?:node\.js|<unknown>|.*(?:node_modules|\(<anonymous>\)|\(<unknown>|<anonymous>$|\(internal\/|\(node\.js)).*/m,
+                    alias: "comment"
+                },
+                filename: {
+                    pattern: /(\bat\s+(?!\s)|\()(?:[a-zA-Z]:)?[^():]+(?=:)/,
+                    lookbehind: !0,
+                    alias: "url"
+                },
+                function: {
+                    pattern:
+                        /(\bat\s+(?:new\s+)?)(?!\s)[_$a-zA-Z\xA0-\uFFFF<][.$\w\xA0-\uFFFF<>]*/,
+                    lookbehind: !0,
+                    inside: { punctuation: /\./ }
+                },
+                punctuation: /[()]/,
+                keyword: /\b(?:at|new)\b/,
+                alias: {
+                    pattern:
+                        /\[(?:as\s+)?(?!\s)[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\]/,
+                    alias: "variable"
+                },
+                "line-number": {
+                    pattern: /:\d+(?::\d+)?\b/,
+                    alias: "number",
+                    inside: { punctuation: /:/ }
+                }
+            }
+        }
+    };
+    !(function (n) {
+        (n.languages.kotlin = n.languages.extend("clike", {
+            keyword: {
+                pattern:
+                    /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
+                lookbehind: !0
+            },
+            function: [
+                { pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/, greedy: !0 },
+                {
+                    pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/,
+                    lookbehind: !0,
+                    greedy: !0
+                }
+            ],
+            number: /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,
+            operator:
+                /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/
+        })),
+            delete n.languages.kotlin["class-name"];
+        var e = {
+            "interpolation-punctuation": {
+                pattern: /^\$\{?|\}$/,
+                alias: "punctuation"
+            },
+            expression: { pattern: /[\s\S]+/, inside: n.languages.kotlin }
+        };
+        n.languages.insertBefore("kotlin", "string", {
+            "string-literal": [
+                {
+                    pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
+                    alias: "multiline",
+                    inside: {
+                        interpolation: {
+                            pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+                            inside: e
+                        },
+                        string: /[\s\S]+/
+                    }
+                },
+                {
+                    pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/,
+                    alias: "singleline",
+                    inside: {
+                        interpolation: {
+                            pattern:
+                                /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+                            lookbehind: !0,
+                            inside: e
+                        },
+                        string: /[\s\S]+/
+                    }
+                }
+            ],
+            char: {
+                pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/,
+                greedy: !0
+            }
+        }),
+            delete n.languages.kotlin.string,
+            n.languages.insertBefore("kotlin", "keyword", {
+                annotation: {
+                    pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
+                    alias: "builtin"
+                }
+            }),
+            n.languages.insertBefore("kotlin", "function", {
+                label: { pattern: /\b\w+@|@\w+\b/, alias: "symbol" }
+            }),
+            (n.languages.kt = n.languages.kotlin),
+            (n.languages.kts = n.languages.kotlin);
+    })(Prism);
+    !(function (n) {
+        function e(n) {
+            return (
+                (n = n.replace(/<inner>/g, function () {
+                    return "(?:\\\\.|[^\\\\\n\r]|(?:\n|\r\n?)(?![\r\n]))";
+                })),
+                RegExp("((?:^|[^\\\\])(?:\\\\{2})*)(?:" + n + ")")
+            );
+        }
+        var t = "(?:\\\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\\\|\r\n`])+",
+            a = "\\|?__(?:\\|__)+\\|?(?:(?:\n|\r\n?)|(?![^]))".replace(
+                /__/g,
+                function () {
+                    return t;
+                }
+            ),
+            i =
+                "\\|?[ \t]*:?-{3,}:?[ \t]*(?:\\|[ \t]*:?-{3,}:?[ \t]*)+\\|?(?:\n|\r\n?)";
+        (n.languages.markdown = n.languages.extend("markup", {})),
+            n.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: n.languages.yaml
+                        }
+                    }
+                },
+                blockquote: {
+                    pattern: /^>(?:[\t ]*>)*/m,
+                    alias: "punctuation"
+                },
+                table: {
+                    pattern: RegExp("^" + a + i + "(?:" + a + ")*", "m"),
+                    inside: {
+                        "table-data-rows": {
+                            pattern: RegExp("^(" + a + i + ")(?:" + a + ")*$"),
+                            lookbehind: !0,
+                            inside: {
+                                "table-data": {
+                                    pattern: RegExp(t),
+                                    inside: n.languages.markdown
+                                },
+                                punctuation: /\|/
+                            }
+                        },
+                        "table-line": {
+                            pattern: RegExp("^(" + a + ")" + i + "$"),
+                            lookbehind: !0,
+                            inside: { punctuation: /\||:?-{3,}:?/ }
+                        },
+                        "table-header-row": {
+                            pattern: RegExp("^" + a + "$"),
+                            inside: {
+                                "table-header": {
+                                    pattern: RegExp(t),
+                                    alias: "important",
+                                    inside: n.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: e(
+                        "\\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\\b|\\*\\*(?:(?!\\*)<inner>|\\*(?:(?!\\*)<inner>)+\\*)+\\*\\*"
+                    ),
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: {
+                        content: {
+                            pattern: /(^..)[\s\S]+(?=..$)/,
+                            lookbehind: !0,
+                            inside: {}
+                        },
+                        punctuation: /\*\*|__/
+                    }
+                },
+                italic: {
+                    pattern: e(
+                        "\\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\\b|\\*(?:(?!\\*)<inner>|\\*\\*(?:(?!\\*)<inner>)+\\*\\*)+\\*"
+                    ),
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: {
+                        content: {
+                            pattern: /(^.)[\s\S]+(?=.$)/,
+                            lookbehind: !0,
+                            inside: {}
+                        },
+                        punctuation: /[*_]/
+                    }
+                },
+                strike: {
+                    pattern: e("(~~?)(?:(?!~)<inner>)+\\2"),
+                    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: e(
+                        '!?\\[(?:(?!\\])<inner>)+\\](?:\\([^\\s)]+(?:[\t ]+"(?:\\\\.|[^"\\\\])*")?\\)|[ \t]?\\[(?:(?!\\])<inner>)+\\])'
+                    ),
+                    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 (e) {
+                ["url", "bold", "italic", "strike", "code-snippet"].forEach(
+                    function (t) {
+                        e !== t &&
+                            (n.languages.markdown[e].inside.content.inside[t] =
+                                n.languages.markdown[t]);
+                    }
+                );
+            }),
+            n.hooks.add("after-tokenize", function (n) {
+                ("markdown" !== n.language && "md" !== n.language) ||
+                    (function n(e) {
+                        if (e && "string" != typeof e)
+                            for (var t = 0, a = e.length; t < a; t++) {
+                                var i = e[t];
+                                if ("code" === i.type) {
+                                    var r = i.content[1],
+                                        o = i.content[3];
+                                    if (
+                                        r &&
+                                        o &&
+                                        "code-language" === r.type &&
+                                        "code-block" === o.type &&
+                                        "string" == typeof r.content
+                                    ) {
+                                        var l = r.content
+                                                .replace(/\b#/g, "sharp")
+                                                .replace(/\b\+\+/g, "pp"),
+                                            s =
+                                                "language-" +
+                                                (l = (/[a-z][\w-]*/i.exec(
+                                                    l
+                                                ) || [""])[0].toLowerCase());
+                                        o.alias
+                                            ? "string" == typeof o.alias
+                                                ? (o.alias = [o.alias, s])
+                                                : o.alias.push(s)
+                                            : (o.alias = [s]);
+                                    }
+                                } else n(i.content);
+                            }
+                    })(n.tokens);
+            }),
+            n.hooks.add("wrap", function (e) {
+                if ("code-block" === e.type) {
+                    for (var t = "", a = 0, i = e.classes.length; a < i; a++) {
+                        var s = e.classes[a],
+                            d = /language-(.+)/.exec(s);
+                        if (d) {
+                            t = d[1];
+                            break;
+                        }
+                    }
+                    var p = n.languages[t];
+                    if (p)
+                        e.content = n.highlight(
+                            e.content
+                                .replace(r, "")
+                                .replace(
+                                    /&(\w{1,8}|#x?[\da-f]{1,8});/gi,
+                                    function (n, e) {
+                                        var t;
+                                        return "#" === (e = e.toLowerCase())[0]
+                                            ? ((t =
+                                                  "x" === e[1]
+                                                      ? parseInt(e.slice(2), 16)
+                                                      : Number(e.slice(1))),
+                                              l(t))
+                                            : o[e] || n;
+                                    }
+                                ),
+                            p,
+                            t
+                        );
+                    else if (t && "none" !== t && n.plugins.autoloader) {
+                        var u =
+                            "md-" +
+                            new Date().valueOf() +
+                            "-" +
+                            Math.floor(1e16 * Math.random());
+                        (e.attributes.id = u),
+                            n.plugins.autoloader.loadLanguages(t, function () {
+                                var e = document.getElementById(u);
+                                e &&
+                                    (e.innerHTML = n.highlight(
+                                        e.textContent,
+                                        n.languages[t],
+                                        t
+                                    ));
+                            });
+                    }
+                }
+            });
+        var r = RegExp(n.languages.markup.tag.pattern.source, "gi"),
+            o = { amp: "&", lt: "<", gt: ">", quot: '"' },
+            l = String.fromCodePoint || String.fromCharCode;
+        n.languages.md = n.languages.markdown;
+    })(Prism);
+    (Prism.languages.objectivec = Prism.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 Prism.languages.objectivec["class-name"],
+        (Prism.languages.objc = Prism.languages.objectivec);
+    !(function (a) {
+        var e = "(?:\\b[a-zA-Z]\\w*|[|\\\\[\\]])+";
+        (a.languages.phpdoc = a.languages.extend("javadoclike", {
+            parameter: {
+                pattern: RegExp(
+                    "(@(?:global|param|property(?:-read|-write)?|var)\\s+(?:" +
+                        e +
+                        "\\s+)?)\\$\\w+"
+                ),
+                lookbehind: !0
+            }
+        })),
+            a.languages.insertBefore("phpdoc", "keyword", {
+                "class-name": [
+                    {
+                        pattern: RegExp(
+                            "(@(?:global|package|param|property(?:-read|-write)?|return|subpackage|throws|var)\\s+)" +
+                                e
+                        ),
+                        lookbehind: !0,
+                        inside: {
+                            keyword:
+                                /\b(?:array|bool|boolean|callback|double|false|float|int|integer|mixed|null|object|resource|self|string|true|void)\b/,
+                            punctuation: /[|\\[\]()]/
+                        }
+                    }
+                ]
+            }),
+            a.languages.javadoclike.addSupport("php", a.languages.phpdoc);
+    })(Prism);
+    Prism.languages.insertBefore("php", "variable", {
+        this: { pattern: /\$this\b/, alias: "keyword" },
+        global: /\$(?:GLOBALS|HTTP_RAW_POST_DATA|_(?:COOKIE|ENV|FILES|GET|POST|REQUEST|SERVER|SESSION)|argc|argv|http_response_header|php_errormsg)\b/,
+        scope: {
+            pattern: /\b[\w\\]+::/,
+            inside: {
+                keyword: /\b(?:parent|self|static)\b/,
+                punctuation: /::|\\/
+            }
+        }
+    });
+    (Prism.languages.plsql = Prism.languages.extend("sql", {
+        comment: { pattern: /\/\*[\s\S]*?\*\/|--.*/, greedy: !0 },
+        keyword:
+            /\b(?:A|ACCESSIBLE|ADD|AGENT|AGGREGATE|ALL|ALTER|AND|ANY|ARRAY|AS|ASC|AT|ATTRIBUTE|AUTHID|AVG|BEGIN|BETWEEN|BFILE_BASE|BINARY|BLOB_BASE|BLOCK|BODY|BOTH|BOUND|BULK|BY|BYTE|C|CALL|CALLING|CASCADE|CASE|CHAR|CHARACTER|CHARSET|CHARSETFORM|CHARSETID|CHAR_BASE|CHECK|CLOB_BASE|CLONE|CLOSE|CLUSTER|CLUSTERS|COLAUTH|COLLECT|COLUMNS|COMMENT|COMMIT|COMMITTED|COMPILED|COMPRESS|CONNECT|CONSTANT|CONSTRUCTOR|CONTEXT|CONTINUE|CONVERT|COUNT|CRASH|CREATE|CREDENTIAL|CURRENT|CURSOR|CUSTOMDATUM|DANGLING|DATA|DATE|DATE_BASE|DAY|DECLARE|DEFAULT|DEFINE|DELETE|DESC|DETERMINISTIC|DIRECTORY|DISTINCT|DOUBLE|DROP|DURATION|ELEMENT|ELSE|ELSIF|EMPTY|END|ESCAPE|EXCEPT|EXCEPTION|EXCEPTIONS|EXCLUSIVE|EXECUTE|EXISTS|EXIT|EXTERNAL|FETCH|FINAL|FIRST|FIXED|FLOAT|FOR|FORALL|FORCE|FROM|FUNCTION|GENERAL|GOTO|GRANT|GROUP|HASH|HAVING|HEAP|HIDDEN|HOUR|IDENTIFIED|IF|IMMEDIATE|IMMUTABLE|IN|INCLUDING|INDEX|INDEXES|INDICATOR|INDICES|INFINITE|INSERT|INSTANTIABLE|INT|INTERFACE|INTERSECT|INTERVAL|INTO|INVALIDATE|IS|ISOLATION|JAVA|LANGUAGE|LARGE|LEADING|LENGTH|LEVEL|LIBRARY|LIKE|LIKE2|LIKE4|LIKEC|LIMIT|LIMITED|LOCAL|LOCK|LONG|LOOP|MAP|MAX|MAXLEN|MEMBER|MERGE|MIN|MINUS|MINUTE|MOD|MODE|MODIFY|MONTH|MULTISET|MUTABLE|NAME|NAN|NATIONAL|NATIVE|NCHAR|NEW|NOCOMPRESS|NOCOPY|NOT|NOWAIT|NULL|NUMBER_BASE|OBJECT|OCICOLL|OCIDATE|OCIDATETIME|OCIDURATION|OCIINTERVAL|OCILOBLOCATOR|OCINUMBER|OCIRAW|OCIREF|OCIREFCURSOR|OCIROWID|OCISTRING|OCITYPE|OF|OLD|ON|ONLY|OPAQUE|OPEN|OPERATOR|OPTION|OR|ORACLE|ORADATA|ORDER|ORGANIZATION|ORLANY|ORLVARY|OTHERS|OUT|OVERLAPS|OVERRIDING|PACKAGE|PARALLEL_ENABLE|PARAMETER|PARAMETERS|PARENT|PARTITION|PASCAL|PERSISTABLE|PIPE|PIPELINED|PLUGGABLE|POLYMORPHIC|PRAGMA|PRECISION|PRIOR|PRIVATE|PROCEDURE|PUBLIC|RAISE|RANGE|RAW|READ|RECORD|REF|REFERENCE|RELIES_ON|REM|REMAINDER|RENAME|RESOURCE|RESULT|RESULT_CACHE|RETURN|RETURNING|REVERSE|REVOKE|ROLLBACK|ROW|SAMPLE|SAVE|SAVEPOINT|SB1|SB2|SB4|SECOND|SEGMENT|SELECT|SELF|SEPARATE|SEQUENCE|SERIALIZABLE|SET|SHARE|SHORT|SIZE|SIZE_T|SOME|SPARSE|SQL|SQLCODE|SQLDATA|SQLNAME|SQLSTATE|STANDARD|START|STATIC|STDDEV|STORED|STRING|STRUCT|STYLE|SUBMULTISET|SUBPARTITION|SUBSTITUTABLE|SUBTYPE|SUM|SYNONYM|TABAUTH|TABLE|TDO|THE|THEN|TIME|TIMESTAMP|TIMEZONE_ABBR|TIMEZONE_HOUR|TIMEZONE_MINUTE|TIMEZONE_REGION|TO|TRAILING|TRANSACTION|TRANSACTIONAL|TRUSTED|TYPE|UB1|UB2|UB4|UNDER|UNION|UNIQUE|UNPLUG|UNSIGNED|UNTRUSTED|UPDATE|USE|USING|VALIST|VALUE|VALUES|VARIABLE|VARIANCE|VARRAY|VARYING|VIEW|VIEWS|VOID|WHEN|WHERE|WHILE|WITH|WORK|WRAPPED|WRITE|YEAR|ZONE)\b/i,
+        operator: /:=?|=>|[<>^~!]=|\.\.|\|\||\*\*|[-+*/%<>=@]/
+    })),
+        Prism.languages.insertBefore("plsql", "operator", {
+            label: { pattern: /<<\s*\w+\s*>>/, alias: "symbol" }
+        });
+    (Prism.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: /[{}[\];(),.:]/
+    }),
+        (Prism.languages.python[
+            "string-interpolation"
+        ].inside.interpolation.inside.rest = Prism.languages.python),
+        (Prism.languages.py = Prism.languages.python);
+    !(function (t) {
+        var n = t.util.clone(t.languages.javascript),
+            e = "(?:\\{<S>*\\.{3}(?:[^{}]|<BRACES>)*\\})";
+        function a(t, n) {
+            return (
+                (t = t
+                    .replace(/<S>/g, function () {
+                        return "(?:\\s|//.*(?!.)|/\\*(?:[^*]|\\*(?!/))\\*/)";
+                    })
+                    .replace(/<BRACES>/g, function () {
+                        return "(?:\\{(?:\\{(?:\\{[^{}]*\\}|[^{}])*\\}|[^{}])*\\})";
+                    })
+                    .replace(/<SPREAD>/g, function () {
+                        return e;
+                    })),
+                RegExp(t, n)
+            );
+        }
+        (e = a(e).source),
+            (t.languages.jsx = t.languages.extend("markup", n)),
+            (t.languages.jsx.tag.pattern = a(
+                "</?(?:[\\w.:-]+(?:<S>+(?:[\\w.:$-]+(?:=(?:\"(?:\\\\[^]|[^\\\\\"])*\"|'(?:\\\\[^]|[^\\\\'])*'|[^\\s{'\"/>=]+|<BRACES>))?|<SPREAD>))*<S>*/?)?>"
+            )),
+            (t.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/),
+            (t.languages.jsx.tag.inside["attr-value"].pattern =
+                /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/),
+            (t.languages.jsx.tag.inside.tag.inside["class-name"] =
+                /^[A-Z]\w*(?:\.[A-Z]\w*)*$/),
+            (t.languages.jsx.tag.inside.comment = n.comment),
+            t.languages.insertBefore(
+                "inside",
+                "attr-name",
+                { spread: { pattern: a("<SPREAD>"), inside: t.languages.jsx } },
+                t.languages.jsx.tag
+            ),
+            t.languages.insertBefore(
+                "inside",
+                "special-attr",
+                {
+                    script: {
+                        pattern: a("=<BRACES>"),
+                        alias: "language-javascript",
+                        inside: {
+                            "script-punctuation": {
+                                pattern: /^=(?=\{)/,
+                                alias: "punctuation"
+                            },
+                            rest: t.languages.jsx
+                        }
+                    }
+                },
+                t.languages.jsx.tag
+            );
+        var s = function (t) {
+                return t
+                    ? "string" == typeof t
+                        ? t
+                        : "string" == typeof t.content
+                        ? t.content
+                        : t.content.map(s).join("")
+                    : "";
+            },
+            g = function (n) {
+                for (var e = [], a = 0; a < n.length; a++) {
+                    var o = n[a],
+                        i = !1;
+                    if (
+                        ("string" != typeof o &&
+                            ("tag" === o.type &&
+                            o.content[0] &&
+                            "tag" === o.content[0].type
+                                ? "</" === o.content[0].content[0].content
+                                    ? e.length > 0 &&
+                                      e[e.length - 1].tagName ===
+                                          s(o.content[0].content[1]) &&
+                                      e.pop()
+                                    : "/>" ===
+                                          o.content[o.content.length - 1]
+                                              .content ||
+                                      e.push({
+                                          tagName: s(o.content[0].content[1]),
+                                          openedBraces: 0
+                                      })
+                                : e.length > 0 &&
+                                  "punctuation" === o.type &&
+                                  "{" === o.content
+                                ? e[e.length - 1].openedBraces++
+                                : e.length > 0 &&
+                                  e[e.length - 1].openedBraces > 0 &&
+                                  "punctuation" === o.type &&
+                                  "}" === o.content
+                                ? e[e.length - 1].openedBraces--
+                                : (i = !0)),
+                        (i || "string" == typeof o) &&
+                            e.length > 0 &&
+                            0 === e[e.length - 1].openedBraces)
+                    ) {
+                        var r = s(o);
+                        a < n.length - 1 &&
+                            ("string" == typeof n[a + 1] ||
+                                "plain-text" === n[a + 1].type) &&
+                            ((r += s(n[a + 1])), n.splice(a + 1, 1)),
+                            a > 0 &&
+                                ("string" == typeof n[a - 1] ||
+                                    "plain-text" === n[a - 1].type) &&
+                                ((r = s(n[a - 1]) + r),
+                                n.splice(a - 1, 1),
+                                a--),
+                            (n[a] = new t.Token("plain-text", r, null, r));
+                    }
+                    o.content && "string" != typeof o.content && g(o.content);
+                }
+            };
+        t.hooks.add("after-tokenize", function (t) {
+            ("jsx" !== t.language && "tsx" !== t.language) || g(t.tokens);
+        });
+    })(Prism);
+    !(function (a) {
+        var e = { pattern: /\\[\\(){}[\]^$+*?|.]/, alias: "escape" },
+            n =
+                /\\(?: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]|.)/,
+            t = "(?:[^\\\\-]|" + n.source + ")",
+            s = RegExp(t + "-" + t),
+            i = {
+                pattern: /(<|')[^<>']+(?=[>']$)/,
+                lookbehind: !0,
+                alias: "variable"
+            };
+        a.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: s,
+                        inside: {
+                            escape: n,
+                            "range-punctuation": {
+                                pattern: /-/,
+                                alias: "operator"
+                            }
+                        }
+                    },
+                    "special-escape": e,
+                    "char-set": {
+                        pattern: /\\[wsd]|\\p\{[^{}]+\}/i,
+                        alias: "class-name"
+                    },
+                    escape: n
+                }
+            },
+            "special-escape": e,
+            "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": i }
+                }
+            ],
+            anchor: { pattern: /[$^]|\\[ABbGZz]/, alias: "function" },
+            escape: n,
+            group: [
+                {
+                    pattern:
+                        /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,
+                    alias: "punctuation",
+                    inside: { "group-name": i }
+                },
+                { pattern: /\)/, alias: "punctuation" }
+            ],
+            quantifier: {
+                pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/,
+                alias: "number"
+            },
+            alternation: { pattern: /\|/, alias: "keyword" }
+        };
+    })(Prism);
+    (Prism.languages.swift = {
+        comment: {
+            pattern:
+                /(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/,
+            lookbehind: !0,
+            greedy: !0
+        },
+        "string-literal": [
+            {
+                pattern: RegExp(
+                    '(^|[^"#])(?:"(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|\r\n|[^(])|[^\\\\\r\n"])*"|"""(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|[^(])|[^\\\\"]|"(?!""))*""")(?!["#])'
+                ),
+                lookbehind: !0,
+                greedy: !0,
+                inside: {
+                    interpolation: {
+                        pattern: /(\\\()(?:[^()]|\([^()]*\))*(?=\))/,
+                        lookbehind: !0,
+                        inside: null
+                    },
+                    "interpolation-punctuation": {
+                        pattern: /^\)|\\\($/,
+                        alias: "punctuation"
+                    },
+                    punctuation: /\\(?=[\r\n])/,
+                    string: /[\s\S]+/
+                }
+            },
+            {
+                pattern: RegExp(
+                    '(^|[^"#])(#+)(?:"(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|\r\n|[^#])|[^\\\\\r\n])*?"|"""(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|[^#])|[^\\\\])*?""")\\2'
+                ),
+                lookbehind: !0,
+                greedy: !0,
+                inside: {
+                    interpolation: {
+                        pattern: /(\\#+\()(?:[^()]|\([^()]*\))*(?=\))/,
+                        lookbehind: !0,
+                        inside: null
+                    },
+                    "interpolation-punctuation": {
+                        pattern: /^\)|\\#+\($/,
+                        alias: "punctuation"
+                    },
+                    string: /[\s\S]+/
+                }
+            }
+        ],
+        directive: {
+            pattern: RegExp(
+                "#(?:(?:elseif|if)\\b(?:[ \t]*(?:![ \t]*)?(?:\\b\\w+\\b(?:[ \t]*\\((?:[^()]|\\([^()]*\\))*\\))?|\\((?:[^()]|\\([^()]*\\))*\\))(?:[ \t]*(?:&&|\\|\\|))?)+|(?:else|endif)\\b)"
+            ),
+            alias: "property",
+            inside: {
+                "directive-name": /^#\w+/,
+                boolean: /\b(?:false|true)\b/,
+                number: /\b\d+(?:\.\d+)*\b/,
+                operator: /!|&&|\|\||[<>]=?/,
+                punctuation: /[(),]/
+            }
+        },
+        literal: {
+            pattern:
+                /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/,
+            alias: "constant"
+        },
+        "other-directive": { pattern: /#\w+\b/, alias: "property" },
+        attribute: { pattern: /@\w+/, alias: "atrule" },
+        "function-definition": {
+            pattern: /(\bfunc\s+)\w+/,
+            lookbehind: !0,
+            alias: "function"
+        },
+        label: {
+            pattern:
+                /\b(break|continue)\s+\w+|\b[a-zA-Z_]\w*(?=\s*:\s*(?:for|repeat|while)\b)/,
+            lookbehind: !0,
+            alias: "important"
+        },
+        keyword:
+            /\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/,
+        boolean: /\b(?:false|true)\b/,
+        nil: { pattern: /\bnil\b/, alias: "constant" },
+        "short-argument": /\$\d+\b/,
+        omit: { pattern: /\b_\b/, alias: "keyword" },
+        number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f0-9_]+(?:\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
+        "class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/,
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
+        operator: /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/,
+        punctuation: /[{}[\]();,.:\\]/
+    }),
+        Prism.languages.swift["string-literal"].forEach(function (e) {
+            e.inside.interpolation.inside = Prism.languages.swift;
+        });
+    !(function (E) {
+        var n =
+            /\b(?:ACT|ACTIFSUB|CARRAY|CASE|CLEARGIF|COA|COA_INT|CONSTANTS|CONTENT|CUR|EDITPANEL|EFFECT|EXT|FILE|FLUIDTEMPLATE|FORM|FRAME|FRAMESET|GIFBUILDER|GMENU|GMENU_FOLDOUT|GMENU_LAYERS|GP|HMENU|HRULER|HTML|IENV|IFSUB|IMAGE|IMGMENU|IMGMENUITEM|IMGTEXT|IMG_RESOURCE|INCLUDE_TYPOSCRIPT|JSMENU|JSMENUITEM|LLL|LOAD_REGISTER|NO|PAGE|RECORDS|RESTORE_REGISTER|TEMPLATE|TEXT|TMENU|TMENUITEM|TMENU_LAYERS|USER|USER_INT|_GIFBUILDER|global|globalString|globalVar)\b/;
+        (E.languages.typoscript = {
+            comment: [
+                { pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/, lookbehind: !0 },
+                {
+                    pattern: /(^|[^\\:= \t]|(?:^|[^= \t])[ \t]+)\/\/.*/,
+                    lookbehind: !0,
+                    greedy: !0
+                },
+                { pattern: /(^|[^"'])#.*/, lookbehind: !0, greedy: !0 }
+            ],
+            function: [
+                {
+                    pattern:
+                        /<INCLUDE_TYPOSCRIPT:\s*source\s*=\s*(?:"[^"\r\n]*"|'[^'\r\n]*')\s*>/,
+                    inside: {
+                        string: {
+                            pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
+                            inside: { keyword: n }
+                        },
+                        keyword: { pattern: /INCLUDE_TYPOSCRIPT/ }
+                    }
+                },
+                {
+                    pattern: /@import\s*(?:"[^"\r\n]*"|'[^'\r\n]*')/,
+                    inside: { string: /"[^"\r\n]*"|'[^'\r\n]*'/ }
+                }
+            ],
+            string: {
+                pattern: /^([^=]*=[< ]?)(?:(?!\]\n).)*/,
+                lookbehind: !0,
+                inside: {
+                    function: /\{\$.*\}/,
+                    keyword: n,
+                    number: /^\d+$/,
+                    punctuation: /[,|:]/
+                }
+            },
+            keyword: n,
+            number: { pattern: /\b\d+\s*[.{=]/, inside: { operator: /[.{=]/ } },
+            tag: { pattern: /\.?[-\w\\]+\.?/, inside: { punctuation: /\./ } },
+            punctuation: /[{}[\];(),.:|]/,
+            operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/
+        }),
+            (E.languages.tsconfig = E.languages.typoscript);
+    })(Prism);
+    (Prism.languages.uri = {
+        scheme: {
+            pattern: /^[a-z][a-z0-9+.-]*:/im,
+            greedy: !0,
+            inside: { "scheme-delimiter": /:$/ }
+        },
+        fragment: {
+            pattern: /#[\w\-.~!$&'()*+,;=%:@/?]*/,
+            inside: { "fragment-delimiter": /^#/ }
+        },
+        query: {
+            pattern: /\?[\w\-.~!$&'()*+,;=%:@/?]*/,
+            inside: {
+                "query-delimiter": { pattern: /^\?/, greedy: !0 },
+                "pair-delimiter": /[&;]/,
+                pair: {
+                    pattern: /^[^=][\s\S]*/,
+                    inside: {
+                        key: /^[^=]+/,
+                        value: { pattern: /(^=)[\s\S]+/, lookbehind: !0 }
+                    }
+                }
+            }
+        },
+        authority: {
+            pattern: RegExp(
+                "^//(?:[\\w\\-.~!$&'()*+,;=%:]*@)?(?:\\[(?:[0-9a-fA-F:.]{2,48}|v[0-9a-fA-F]+\\.[\\w\\-.~!$&'()*+,;=]+)\\]|[\\w\\-.~!$&'()*+,;=%]*)(?::\\d*)?",
+                "m"
+            ),
+            inside: {
+                "authority-delimiter": /^\/\//,
+                "user-info-segment": {
+                    pattern: /^[\w\-.~!$&'()*+,;=%:]*@/,
+                    inside: {
+                        "user-info-delimiter": /@$/,
+                        "user-info": /^[\w\-.~!$&'()*+,;=%:]+/
+                    }
+                },
+                "port-segment": {
+                    pattern: /:\d*$/,
+                    inside: { "port-delimiter": /^:/, port: /^\d+/ }
+                },
+                host: {
+                    pattern: /[\s\S]+/,
+                    inside: {
+                        "ip-literal": {
+                            pattern: /^\[[\s\S]+\]$/,
+                            inside: {
+                                "ip-literal-delimiter": /^\[|\]$/,
+                                "ipv-future": /^v[\s\S]+/,
+                                "ipv6-address": /^[\s\S]+/
+                            }
+                        },
+                        "ipv4-address":
+                            /^(?:(?:[03-9]\d?|[12]\d{0,2})\.){3}(?:[03-9]\d?|[12]\d{0,2})$/
+                    }
+                }
+            }
+        },
+        path: {
+            pattern: /^[\w\-.~!$&'()*+,;=%:@/]+/m,
+            inside: { "path-separator": /\// }
+        }
+    }),
+        (Prism.languages.url = Prism.languages.uri);
+    Prism.languages.vbnet = Prism.languages.extend("basic", {
+        comment: [
+            { pattern: /(?:!|REM\b).+/i, inside: { keyword: /^REM/i } },
+            { pattern: /(^|[^\\:])'.*/, lookbehind: !0, greedy: !0 }
+        ],
+        string: {
+            pattern: /(^|[^"])"(?:""|[^"])*"(?!")/,
+            lookbehind: !0,
+            greedy: !0
+        },
+        keyword:
+            /(?:\b(?:ADDHANDLER|ADDRESSOF|ALIAS|AND|ANDALSO|AS|BEEP|BLOAD|BOOLEAN|BSAVE|BYREF|BYTE|BYVAL|CALL(?: ABSOLUTE)?|CASE|CATCH|CBOOL|CBYTE|CCHAR|CDATE|CDBL|CDEC|CHAIN|CHAR|CHDIR|CINT|CLASS|CLEAR|CLNG|CLOSE|CLS|COBJ|COM|COMMON|CONST|CONTINUE|CSBYTE|CSHORT|CSNG|CSTR|CTYPE|CUINT|CULNG|CUSHORT|DATA|DATE|DECIMAL|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DEFAULT|DELEGATE|DIM|DIRECTCAST|DO|DOUBLE|ELSE|ELSEIF|END|ENUM|ENVIRON|ERASE|ERROR|EVENT|EXIT|FALSE|FIELD|FILES|FINALLY|FOR(?: EACH)?|FRIEND|FUNCTION|GET|GETTYPE|GETXMLNAMESPACE|GLOBAL|GOSUB|GOTO|HANDLES|IF|IMPLEMENTS|IMPORTS|IN|INHERITS|INPUT|INTEGER|INTERFACE|IOCTL|IS|ISNOT|KEY|KILL|LET|LIB|LIKE|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|ME|MKDIR|MOD|MODULE|MUSTINHERIT|MUSTOVERRIDE|MYBASE|MYCLASS|NAME|NAMESPACE|NARROWING|NEW|NEXT|NOT|NOTHING|NOTINHERITABLE|NOTOVERRIDABLE|OBJECT|OF|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPERATOR|OPTION(?: BASE)?|OPTIONAL|OR|ORELSE|OUT|OVERLOADS|OVERRIDABLE|OVERRIDES|PARAMARRAY|PARTIAL|POKE|PRIVATE|PROPERTY|PROTECTED|PUBLIC|PUT|RAISEEVENT|READ|READONLY|REDIM|REM|REMOVEHANDLER|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SBYTE|SELECT(?: CASE)?|SET|SHADOWS|SHARED|SHELL|SHORT|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|STRUCTURE|SUB|SWAP|SYNCLOCK|SYSTEM|THEN|THROW|TIMER|TO|TROFF|TRON|TRUE|TRY|TRYCAST|TYPE|TYPEOF|UINTEGER|ULONG|UNLOCK|UNTIL|USHORT|USING|VIEW PRINT|WAIT|WEND|WHEN|WHILE|WIDENING|WITH|WITHEVENTS|WRITE|WRITEONLY|XOR)|\B(?:#CONST|#ELSE|#ELSEIF|#END|#IF))(?:\$|\b)/i,
+        punctuation: /[,;:(){}]/
+    });
+    !(function (e) {
+        var n = /[*&][^\s[\]{},]+/,
+            r =
+                /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/,
+            t =
+                "(?:" +
+                r.source +
+                "(?:[ \t]+" +
+                n.source +
+                ")?|" +
+                n.source +
+                "(?:[ \t]+" +
+                r.source +
+                ")?)",
+            a =
+                "(?:[^\\s\\x00-\\x08\\x0e-\\x1f!\"#%&'*,\\-:>?@[\\]`{|}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*".replace(
+                    /<PLAIN>/g,
+                    function () {
+                        return "[^\\s\\x00-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]";
+                    }
+                ),
+            d = "\"(?:[^\"\\\\\r\n]|\\\\.)*\"|'(?:[^'\\\\\r\n]|\\\\.)*'";
+        function o(e, n) {
+            n = (n || "").replace(/m/g, "") + "m";
+            var r =
+                "([:\\-,[{]\\s*(?:\\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\\]|\\}|(?:[\r\n]\\s*)?#))"
+                    .replace(/<<prop>>/g, function () {
+                        return t;
+                    })
+                    .replace(/<<value>>/g, function () {
+                        return e;
+                    });
+            return RegExp(r, n);
+        }
+        (e.languages.yaml = {
+            scalar: {
+                pattern: RegExp(
+                    "([\\-:]\\s*(?:\\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\\S[^\r\n]*(?:\\2[^\r\n]+)*)".replace(
+                        /<<prop>>/g,
+                        function () {
+                            return t;
+                        }
+                    )
+                ),
+                lookbehind: !0,
+                alias: "string"
+            },
+            comment: /#.*/,
+            key: {
+                pattern: RegExp(
+                    "((?:^|[:\\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\\s*:\\s)"
+                        .replace(/<<prop>>/g, function () {
+                            return t;
+                        })
+                        .replace(/<<key>>/g, function () {
+                            return "(?:" + a + "|" + d + ")";
+                        })
+                ),
+                lookbehind: !0,
+                greedy: !0,
+                alias: "atrule"
+            },
+            directive: {
+                pattern: /(^[ \t]*)%.+/m,
+                lookbehind: !0,
+                alias: "important"
+            },
+            datetime: {
+                pattern: o(
+                    "\\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*)?)?"
+                ),
+                lookbehind: !0,
+                alias: "number"
+            },
+            boolean: {
+                pattern: o("false|true", "i"),
+                lookbehind: !0,
+                alias: "important"
+            },
+            null: {
+                pattern: o("null|~", "i"),
+                lookbehind: !0,
+                alias: "important"
+            },
+            string: { pattern: o(d), lookbehind: !0, greedy: !0 },
+            number: {
+                pattern: o(
+                    "[+-]?(?:0x[\\da-f]+|0o[0-7]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)",
+                    "i"
+                ),
+                lookbehind: !0
+            },
+            tag: r,
+            important: n,
+            punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
+        }),
+            (e.languages.yml = e.languages.yaml);
+    })(Prism);
+    "undefined" != typeof Prism &&
+        "undefined" != typeof document &&
+        (Element.prototype.matches ||
+            (Element.prototype.matches =
+                Element.prototype.msMatchesSelector ||
+                Element.prototype.webkitMatchesSelector),
+        (Prism.plugins.UnescapedMarkup = !0),
+        Prism.hooks.add("before-highlightall", function (e) {
+            e.selector +=
+                ', [class*="lang-"] script[type="text/plain"], [class*="language-"] script[type="text/plain"], script[type="text/plain"][class*="lang-"], script[type="text/plain"][class*="language-"]';
+        }),
+        Prism.hooks.add("before-sanity-check", function (e) {
+            var t = e.element;
+            if (t.matches('script[type="text/plain"]')) {
+                var a = document.createElement("code"),
+                    c = document.createElement("pre");
+                c.className = a.className = t.className;
+                var n = t.dataset;
+                return (
+                    Object.keys(n || {}).forEach(function (e) {
+                        Object.prototype.hasOwnProperty.call(n, e) &&
+                            (c.dataset[e] = n[e]);
+                    }),
+                    (a.textContent = e.code =
+                        e.code.replace(
+                            /&lt;\/script(?:>|&gt;)/gi,
+                            "</script>"
+                        )),
+                    c.appendChild(a),
+                    t.parentNode.replaceChild(c, t),
+                    void (e.element = a)
+                );
+            }
+            if (!e.code) {
+                var o = t.childNodes;
+                1 === o.length &&
+                    "#comment" == o[0].nodeName &&
+                    (t.textContent = e.code = o[0].textContent);
+            }
+        }));
+    !(function () {
+        if ("undefined" != typeof Prism && "undefined" != typeof document) {
+            var e = { "(": ")", "[": "]", "{": "}" },
+                t = {
+                    "(": "brace-round",
+                    "[": "brace-square",
+                    "{": "brace-curly"
+                },
+                n = { "${": "{" },
+                r = 0,
+                c = /^(pair-\d+-)(close|open)$/;
+            Prism.hooks.add("complete", function (c) {
+                var i = c.element,
+                    d = i.parentElement;
+                if (d && "PRE" == d.tagName) {
+                    var u = [];
+                    if (
+                        (Prism.util.isActive(i, "match-braces") &&
+                            u.push("(", "[", "{"),
+                        0 != u.length)
+                    ) {
+                        d.__listenerAdded ||
+                            (d.addEventListener("mousedown", function () {
+                                var e = d.querySelector("code"),
+                                    t = s("brace-selected");
+                                Array.prototype.slice
+                                    .call(e.querySelectorAll("." + t))
+                                    .forEach(function (e) {
+                                        e.classList.remove(t);
+                                    });
+                            }),
+                            Object.defineProperty(d, "__listenerAdded", {
+                                value: !0
+                            }));
+                        var f = Array.prototype.slice.call(
+                                i.querySelectorAll(
+                                    "span." +
+                                        s("token") +
+                                        "." +
+                                        s("punctuation")
+                                )
+                            ),
+                            h = [];
+                        u.forEach(function (c) {
+                            for (
+                                var i = e[c],
+                                    d = s(t[c]),
+                                    u = [],
+                                    p = [],
+                                    v = 0;
+                                v < f.length;
+                                v++
+                            ) {
+                                var m = f[v];
+                                if (0 == m.childElementCount) {
+                                    var b = m.textContent;
+                                    (b = n[b] || b) === c
+                                        ? (h.push({
+                                              index: v,
+                                              open: !0,
+                                              element: m
+                                          }),
+                                          m.classList.add(d),
+                                          m.classList.add(s("brace-open")),
+                                          p.push(v))
+                                        : b === i &&
+                                          (h.push({
+                                              index: v,
+                                              open: !1,
+                                              element: m
+                                          }),
+                                          m.classList.add(d),
+                                          m.classList.add(s("brace-close")),
+                                          p.length && u.push([v, p.pop()]));
+                                }
+                            }
+                            u.forEach(function (e) {
+                                var t = "pair-" + r++ + "-",
+                                    n = f[e[0]],
+                                    c = f[e[1]];
+                                (n.id = t + "open"),
+                                    (c.id = t + "close"),
+                                    [n, c].forEach(function (e) {
+                                        e.addEventListener("mouseenter", a),
+                                            e.addEventListener("mouseleave", o),
+                                            e.addEventListener("click", l);
+                                    });
+                            });
+                        });
+                        var p = 0;
+                        h.sort(function (e, t) {
+                            return e.index - t.index;
+                        }),
+                            h.forEach(function (e) {
+                                e.open
+                                    ? (e.element.classList.add(
+                                          s("brace-level-" + ((p % 12) + 1))
+                                      ),
+                                      p++)
+                                    : ((p = Math.max(0, p - 1)),
+                                      e.element.classList.add(
+                                          s("brace-level-" + ((p % 12) + 1))
+                                      ));
+                            });
+                    }
+                }
+            });
+        }
+        function s(e) {
+            var t = Prism.plugins.customClass;
+            return t ? t.apply(e, "none") : e;
+        }
+        function i(e) {
+            var t = c.exec(e.id);
+            return document.querySelector(
+                "#" + t[1] + ("open" == t[2] ? "close" : "open")
+            );
+        }
+        function a() {
+            Prism.util.isActive(this, "brace-hover", !0) &&
+                [this, i(this)].forEach(function (e) {
+                    e.classList.add(s("brace-hover"));
+                });
+        }
+        function o() {
+            [this, i(this)].forEach(function (e) {
+                e.classList.remove(s("brace-hover"));
+            });
+        }
+        function l() {
+            Prism.util.isActive(this, "brace-select", !0) &&
+                [this, i(this)].forEach(function (e) {
+                    e.classList.add(s("brace-selected"));
+                });
+        }
+    })();
+});
+//End autogenerated code
+export default prism;