@salesforcedevs/dx-components 0.26.1-alpha0.5 → 0.26.3

package/src/modules/utils/prismjs/prismjs.ts

@@ -0,0 +1,3321 @@
+/* eslint-disable */
+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"
+    );
+}
+/* eslint-disable */
+var prism = createCommonjsModule(function (module) {
+    /* PrismJS 1.23.0
+https://prismjs.com/download.html#themes=prism&languages=markup+css+clike+javascript+apex+aspnet+basic+c+csharp+cpp+css-extras+java+javadoc+javadoclike+jsdoc+js-extras+json+json5+jsonp+jsstacktrace+markdown+markup-templating+php+phpdoc+php-extras+plsql+regex+sql+typescript+typoscript+uri+vbnet&plugins=line-numbers+unescaped-markup+match-braces */
+    var _self =
+            "undefined" != typeof window
+                ? window
+                : "undefined" != typeof WorkerGlobalScope &&
+                  self instanceof WorkerGlobalScope
+                ? self
+                : {},
+        Prism = (function (u) {
+            var c = /\blang(?:uage)?-([\w-]+)\b/i,
+                n = 0,
+                e = {},
+                M = {
+                    manual: u.Prism && u.Prism.manual,
+                    disableWorkerMessageHandler:
+                        u.Prism && u.Prism.disableWorkerMessageHandler,
+                    util: {
+                        encode: function e(n) {
+                            return n instanceof W
+                                ? new W(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: ++n
+                                    }),
+                                e.__id
+                            );
+                        },
+                        clone: function t(e, r) {
+                            var a, n;
+                            switch (((r = r || {}), M.util.type(e))) {
+                                case "Object":
+                                    if (((n = M.util.objId(e)), r[n]))
+                                        return r[n];
+                                    for (var i in ((a = {}), (r[n] = a), e))
+                                        e.hasOwnProperty(i) &&
+                                            (a[i] = t(e[i], r));
+                                    return a;
+                                case "Array":
+                                    return (
+                                        (n = M.util.objId(e)),
+                                        r[n]
+                                            ? r[n]
+                                            : ((a = []),
+                                              (r[n] = a),
+                                              e.forEach(function (e, n) {
+                                                  a[n] = t(e, r);
+                                              }),
+                                              a)
+                                    );
+                                default:
+                                    return e;
+                            }
+                        },
+                        getLanguage: function (e) {
+                            for (; e && !c.test(e.className); )
+                                e = e.parentElement;
+                            return e
+                                ? (e.className.match(c) || [
+                                      ,
+                                      "none"
+                                  ])[1].toLowerCase()
+                                : "none";
+                        },
+                        currentScript: function () {
+                            if ("undefined" == typeof document) return null;
+                            if ("currentScript" in document)
+                                return document.currentScript;
+                            try {
+                                throw new Error();
+                            } catch (e) {
+                                var n = (/at [^(\r\n]*\((.*):.+:.+\)$/i.exec(
+                                    e.stack
+                                ) || [])[1];
+                                if (n) {
+                                    var t =
+                                        document.getElementsByTagName("script");
+                                    for (var r in t)
+                                        if (t[r].src == n) return t[r];
+                                }
+                                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: e,
+                        plaintext: e,
+                        text: e,
+                        txt: e,
+                        extend: function (e, n) {
+                            var t = M.util.clone(M.languages[e]);
+                            for (var r in n) t[r] = n[r];
+                            return t;
+                        },
+                        insertBefore: function (t, e, n, r) {
+                            var a = (r = r || M.languages)[t],
+                                i = {};
+                            for (var l in a)
+                                if (a.hasOwnProperty(l)) {
+                                    if (l == e)
+                                        for (var o in n)
+                                            n.hasOwnProperty(o) &&
+                                                (i[o] = n[o]);
+                                    n.hasOwnProperty(l) || (i[l] = a[l]);
+                                }
+                            var s = r[t];
+                            return (
+                                (r[t] = i),
+                                M.languages.DFS(M.languages, function (e, n) {
+                                    n === s && e != t && (this[e] = i);
+                                }),
+                                i
+                            );
+                        },
+                        DFS: function e(n, t, r, a) {
+                            a = a || {};
+                            var i = M.util.objId;
+                            for (var l in n)
+                                if (n.hasOwnProperty(l)) {
+                                    t.call(n, l, n[l], r || l);
+                                    var o = n[l],
+                                        s = M.util.type(o);
+                                    "Object" !== s || a[i(o)]
+                                        ? "Array" !== s ||
+                                          a[i(o)] ||
+                                          ((a[i(o)] = !0), e(o, t, l, a))
+                                        : ((a[i(o)] = !0), e(o, t, null, a));
+                                }
+                        }
+                    },
+                    plugins: {},
+                    highlightAll: function (e, n) {
+                        M.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'
+                        };
+                        M.hooks.run("before-highlightall", r),
+                            (r.elements = Array.prototype.slice.apply(
+                                r.container.querySelectorAll(r.selector)
+                            )),
+                            M.hooks.run("before-all-elements-highlight", r);
+                        for (var a, i = 0; (a = r.elements[i++]); )
+                            M.highlightElement(a, !0 === n, r.callback);
+                    },
+                    highlightElement: function (e, n, t) {
+                        var r = M.util.getLanguage(e),
+                            a = M.languages[r];
+                        e.className =
+                            e.className.replace(c, "").replace(/\s+/g, " ") +
+                            " language-" +
+                            r;
+                        var i = e.parentElement;
+                        i &&
+                            "pre" === i.nodeName.toLowerCase() &&
+                            (i.className =
+                                i.className
+                                    .replace(c, "")
+                                    .replace(/\s+/g, " ") +
+                                " language-" +
+                                r);
+                        var l = {
+                            element: e,
+                            language: r,
+                            grammar: a,
+                            code: e.textContent
+                        };
+                        function o(e) {
+                            (l.highlightedCode = e),
+                                M.hooks.run("before-insert", l),
+                                (l.element.innerHTML = l.highlightedCode),
+                                M.hooks.run("after-highlight", l),
+                                M.hooks.run("complete", l),
+                                t && t.call(l.element);
+                        }
+                        if (
+                            (M.hooks.run("before-sanity-check", l),
+                            (i = l.element.parentElement) &&
+                                "pre" === i.nodeName.toLowerCase() &&
+                                !i.hasAttribute("tabindex") &&
+                                i.setAttribute("tabindex", "0"),
+                            !l.code)
+                        )
+                            return (
+                                M.hooks.run("complete", l),
+                                void (t && t.call(l.element))
+                            );
+                        if ((M.hooks.run("before-highlight", l), l.grammar))
+                            if (n && u.Worker) {
+                                var s = new Worker(M.filename);
+                                (s.onmessage = function (e) {
+                                    o(e.data);
+                                }),
+                                    s.postMessage(
+                                        JSON.stringify({
+                                            language: l.language,
+                                            code: l.code,
+                                            immediateClose: !0
+                                        })
+                                    );
+                            } else
+                                o(M.highlight(l.code, l.grammar, l.language));
+                        else o(M.util.encode(l.code));
+                    },
+                    highlight: function (e, n, t) {
+                        var r = { code: e, grammar: n, language: t };
+                        return (
+                            M.hooks.run("before-tokenize", r),
+                            (r.tokens = M.tokenize(r.code, r.grammar)),
+                            M.hooks.run("after-tokenize", r),
+                            W.stringify(M.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 i();
+                        return (
+                            I(a, a.head, e),
+                            (function e(n, t, r, a, i, l) {
+                                for (var o in r)
+                                    if (r.hasOwnProperty(o) && r[o]) {
+                                        var s = r[o];
+                                        s = Array.isArray(s) ? s : [s];
+                                        for (var u = 0; u < s.length; ++u) {
+                                            if (l && l.cause == o + "," + u)
+                                                return;
+                                            var c = s[u],
+                                                g = c.inside,
+                                                f = !!c.lookbehind,
+                                                h = !!c.greedy,
+                                                d = c.alias;
+                                            if (h && !c.pattern.global) {
+                                                var p = c.pattern
+                                                    .toString()
+                                                    .match(/[imsuy]*$/)[0];
+                                                c.pattern = RegExp(
+                                                    c.pattern.source,
+                                                    p + "g"
+                                                );
+                                            }
+                                            for (
+                                                var v = c.pattern || c,
+                                                    m = a.next,
+                                                    y = i;
+                                                m !== t.tail &&
+                                                !(l && y >= l.reach);
+                                                y += m.value.length, m = m.next
+                                            ) {
+                                                var b = m.value;
+                                                if (t.length > n.length) return;
+                                                if (!(b instanceof W)) {
+                                                    var k,
+                                                        x = 1;
+                                                    if (h) {
+                                                        if (
+                                                            !(k = z(v, y, n, f))
+                                                        )
+                                                            break;
+                                                        var w = k.index,
+                                                            A =
+                                                                k.index +
+                                                                k[0].length,
+                                                            P = y;
+                                                        for (
+                                                            P += m.value.length;
+                                                            P <= w;
+
+                                                        )
+                                                            (m = m.next),
+                                                                (P +=
+                                                                    m.value
+                                                                        .length);
+                                                        if (
+                                                            ((P -=
+                                                                m.value.length),
+                                                            (y = P),
+                                                            m.value instanceof
+                                                                W)
+                                                        )
+                                                            continue;
+                                                        for (
+                                                            var E = m;
+                                                            E !== t.tail &&
+                                                            (P < A ||
+                                                                "string" ==
+                                                                    typeof E.value);
+                                                            E = E.next
+                                                        )
+                                                            x++,
+                                                                (P +=
+                                                                    E.value
+                                                                        .length);
+                                                        x--,
+                                                            (b = n.slice(y, P)),
+                                                            (k.index -= y);
+                                                    } else if (
+                                                        !(k = z(v, 0, b, f))
+                                                    )
+                                                        continue;
+                                                    var w = k.index,
+                                                        S = k[0],
+                                                        O = b.slice(0, w),
+                                                        L = b.slice(
+                                                            w + S.length
+                                                        ),
+                                                        N = y + b.length;
+                                                    l &&
+                                                        N > l.reach &&
+                                                        (l.reach = N);
+                                                    var j = m.prev;
+                                                    O &&
+                                                        ((j = I(t, j, O)),
+                                                        (y += O.length)),
+                                                        q(t, j, x);
+                                                    var C = new W(
+                                                        o,
+                                                        g
+                                                            ? M.tokenize(S, g)
+                                                            : S,
+                                                        d,
+                                                        S
+                                                    );
+                                                    if (
+                                                        ((m = I(t, j, C)),
+                                                        L && I(t, m, L),
+                                                        1 < x)
+                                                    ) {
+                                                        var _ = {
+                                                            cause: o + "," + u,
+                                                            reach: N
+                                                        };
+                                                        e(
+                                                            n,
+                                                            t,
+                                                            r,
+                                                            m.prev,
+                                                            y,
+                                                            _
+                                                        ),
+                                                            l &&
+                                                                _.reach >
+                                                                    l.reach &&
+                                                                (l.reach =
+                                                                    _.reach);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                            })(e, a, n, a.head, 0),
+                            (function (e) {
+                                var n = [],
+                                    t = e.head.next;
+                                for (; t !== e.tail; )
+                                    n.push(t.value), (t = t.next);
+                                return n;
+                            })(a)
+                        );
+                    },
+                    hooks: {
+                        all: {},
+                        add: function (e, n) {
+                            var t = M.hooks.all;
+                            (t[e] = t[e] || []), t[e].push(n);
+                        },
+                        run: function (e, n) {
+                            var t = M.hooks.all[e];
+                            if (t && t.length)
+                                for (var r, a = 0; (r = t[a++]); ) r(n);
+                        }
+                    },
+                    Token: W
+                };
+            function W(e, n, t, r) {
+                (this.type = e),
+                    (this.content = n),
+                    (this.alias = t),
+                    (this.length = 0 | (r || "").length);
+            }
+            function z(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 i() {
+                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 I(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 q(e, n, t) {
+                for (var r = n.next, a = 0; a < t && r !== e.tail; a++)
+                    r = r.next;
+                ((n.next = r).prev = n), (e.length -= a);
+            }
+            if (
+                ((u.Prism = M),
+                (W.stringify = function n(e, t) {
+                    if ("string" == typeof e) return e;
+                    if (Array.isArray(e)) {
+                        var r = "";
+                        return (
+                            e.forEach(function (e) {
+                                r += n(e, t);
+                            }),
+                            r
+                        );
+                    }
+                    var a = {
+                            type: e.type,
+                            content: n(e.content, t),
+                            tag: "span",
+                            classes: ["token", e.type],
+                            attributes: {},
+                            language: t
+                        },
+                        i = e.alias;
+                    i &&
+                        (Array.isArray(i)
+                            ? Array.prototype.push.apply(a.classes, i)
+                            : a.classes.push(i)),
+                        M.hooks.run("wrap", a);
+                    var l = "";
+                    for (var o in a.attributes)
+                        l +=
+                            " " +
+                            o +
+                            '="' +
+                            (a.attributes[o] || "").replace(/"/g, "&quot;") +
+                            '"';
+                    return (
+                        "<" +
+                        a.tag +
+                        ' class="' +
+                        a.classes.join(" ") +
+                        '"' +
+                        l +
+                        ">" +
+                        a.content +
+                        "</" +
+                        a.tag +
+                        ">"
+                    );
+                }),
+                !u.document)
+            )
+                return (
+                    u.addEventListener &&
+                        (M.disableWorkerMessageHandler ||
+                            u.addEventListener(
+                                "message",
+                                function (e) {
+                                    var n = JSON.parse(e.data),
+                                        t = n.language,
+                                        r = n.code,
+                                        a = n.immediateClose;
+                                    u.postMessage(
+                                        M.highlight(r, M.languages[t], t)
+                                    ),
+                                        a && u.close();
+                                },
+                                !1
+                            )),
+                    M
+                );
+            var t = M.util.currentScript();
+            function r() {
+                M.manual || M.highlightAll();
+            }
+            if (
+                (t &&
+                    ((M.filename = t.src),
+                    t.hasAttribute("data-manual") && (M.manual = !0)),
+                !M.manual)
+            ) {
+                var a = document.readyState;
+                "loading" === a || ("interactive" === a && t && t.defer)
+                    ? document.addEventListener("DOMContentLoaded", r)
+                    : window.requestAnimationFrame
+                    ? window.requestAnimationFrame(r)
+                    : window.setTimeout(r, 16);
+            }
+            return M;
+        })(_self);
+    "undefined" != typeof module && module.exports && (module.exports = Prism),
+        "undefined" != typeof global && (global.Prism = Prism);
+    (Prism.languages.markup = {
+        comment: /<!--[\s\S]*?-->/,
+        prolog: /<\?[\s\S]+?\?>/,
+        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/,
+                name: /[^\s<>'"]+/
+            }
+        },
+        cdata: /<!\[CDATA\[[\s\S]*?]]>/i,
+        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" },
+                            /"|'/
+                        ]
+                    }
+                },
+                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])|(?!\1)[^\\\r\n])*\1/;
+        (s.languages.css = {
+            comment: /\/\*[\s\S]*?\*\//,
+            atrule: {
+                pattern: /@[\w-](?:[^;{\s]|\s+(?![\s{]))*(?:;|(?=\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: RegExp(
+                "[^{}\\s](?:[^{};\"'\\s]|\\s+(?![\\s{])|" +
+                    e.source +
+                    ")*(?=\\s*\\{)"
+            ),
+            string: { pattern: e, greedy: !0 },
+            property:
+                /(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+            important: /!important\b/i,
+            function: /[-a-z0-9]+(?=\()/i,
+            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|interface|extends|implements|trait|instanceof|new)\s+|\bcatch\s+\()[\w.\\]+/i,
+            lookbehind: !0,
+            inside: { punctuation: /[.\\]/ }
+        },
+        keyword:
+            /\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,
+        boolean: /\b(?:true|false)\b/,
+        function: /\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])*(?=\.(?:prototype|constructor))/,
+                lookbehind: !0
+            }
+        ],
+        keyword: [
+            { pattern: /((?:^|})\s*)catch\b/, lookbehind: !0 },
+            {
+                pattern:
+                    /(^|[^.]|\.\.\.\s*)\b(?:as|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: /\b(?:(?:0[xX](?:[\dA-Fa-f](?:_[\dA-Fa-f])?)+|0[bB](?:[01](?:_[01])?)+|0[oO](?:[0-7](?:_[0-7])?)+)n?|(?:\d(?:_\d)?)+n|NaN|Infinity)\b|(?:\b(?:\d(?:_\d)?)+\.?(?:\d(?:_\d)?)*|\B\.(?:\d(?:_\d)?)+)(?:[Ee][+-]?(?:\d(?:_\d)?)+)?/,
+        operator:
+            /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
+    })),
+        (Prism.languages.javascript["class-name"][0].pattern =
+            /(\b(?:class|interface|extends|implements|instanceof|new)\s+)[\w.\\]+/),
+        Prism.languages.insertBefore("javascript", "keyword", {
+            regex: {
+                pattern:
+                    /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)\/(?:\[(?:[^\]\\\r\n]|\\.)*]|\\.|[^/\\\[\r\n])+\/[gimyus]{0,6}(?=(?:\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-flags": /[a-z]+$/,
+                    "regex-delimiter": /^\/|\/$/
+                }
+            },
+            "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:
+                        /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+                    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]+/
+                }
+            }
+        }),
+        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
+        },
+        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(?:_INSERT|COL)?|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(?:S|ING)?|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(?:TRUE|FALSE|NULL)\b/i,
+        number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
+        operator:
+            /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|IN|ILIKE|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,
+        punctuation: /[;[\]()`,.]/
+    };
+    !(function (e) {
+        var t =
+                /\b(?: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|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|get(?=\s*[{};])|(?:after|before)(?=\s+[a-z])|(?: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 (s) {
+        function a(e, s) {
+            return e.replace(/<<(\d+)>>/g, function (e, n) {
+                return "(?:" + s[+n] + ")";
+            });
+        }
+        function t(e, n, s) {
+            return RegExp(a(e, n), s || "");
+        }
+        function e(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 n =
+                "bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void",
+            i = "class enum interface struct",
+            r =
+                "add alias and ascending async await by descending from get global group into join let nameof not notnull on or orderby partial remove select set unmanaged value when where",
+            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(i),
+            p = RegExp(l(n + " " + i + " " + r + " " + o)),
+            c = l(i + " " + r + " " + o),
+            u = l(n + " " + i + " " + o),
+            g = e("<(?:[^<>;=+\\-*/%&|^]|<<self>>)*>", 2),
+            b = e("\\((?:[^()]|<<self>>)*\\)", 2),
+            h = "@?\\b[A-Za-z_]\\w*\\b",
+            f = a("<<0>>(?:\\s*<<1>>)?", [h, g]),
+            m = a("(?!<<0>>)<<1>>(?:\\s*\\.\\s*<<1>>)*", [c, f]),
+            k = "\\[\\s*(?:,\\s*)*\\]",
+            y = a("<<0>>(?:\\s*(?:\\?\\s*)?<<1>>)*(?:\\s*\\?)?", [m, k]),
+            w = a("(?:<<0>>|<<1>>)(?:\\s*(?:\\?\\s*)?<<2>>)*(?:\\s*\\?)?", [
+                a("\\(<<0>>+(?:,<<0>>+)+\\)", [
+                    a("[^,()<>[\\];=+\\-*/%&|^]|<<0>>|<<1>>|<<2>>", [g, b, k])
+                ]),
+                m,
+                k
+            ]),
+            v = { keyword: p, punctuation: /[<>()?,.:[\]]/ },
+            x = "'(?:[^\r\n'\\\\]|\\\\.|\\\\[Uux][\\da-fA-F]{1,8})'",
+            $ = '"(?:\\\\.|[^\\\\"\r\n])*"';
+        (s.languages.csharp = s.languages.extend("clike", {
+            string: [
+                {
+                    pattern: t("(^|[^$\\\\])<<0>>", [
+                        '@"(?:""|\\\\[^]|[^\\\\"])*"(?!")'
+                    ]),
+                    lookbehind: !0,
+                    greedy: !0
+                },
+                {
+                    pattern: t("(^|[^@$\\\\])<<0>>", [$]),
+                    lookbehind: !0,
+                    greedy: !0
+                },
+                { pattern: RegExp(x), greedy: !0, alias: "character" }
+            ],
+            "class-name": [
+                {
+                    pattern: t("(\\busing\\s+static\\s+)<<0>>(?=\\s*;)", [m]),
+                    lookbehind: !0,
+                    inside: v
+                },
+                {
+                    pattern: t("(\\busing\\s+<<0>>\\s*=\\s*)<<1>>(?=\\s*;)", [
+                        h,
+                        w
+                    ]),
+                    lookbehind: !0,
+                    inside: v
+                },
+                {
+                    pattern: t("(\\busing\\s+)<<0>>(?=\\s*=)", [h]),
+                    lookbehind: !0
+                },
+                {
+                    pattern: t("(\\b<<0>>\\s+)<<1>>", [d, f]),
+                    lookbehind: !0,
+                    inside: v
+                },
+                {
+                    pattern: t("(\\bcatch\\s*\\(\\s*)<<0>>", [m]),
+                    lookbehind: !0,
+                    inside: v
+                },
+                { pattern: t("(\\bwhere\\s+)<<0>>", [h]), lookbehind: !0 },
+                {
+                    pattern: t("(\\b(?:is(?:\\s+not)?|as)\\s+)<<0>>", [y]),
+                    lookbehind: !0,
+                    inside: v
+                },
+                {
+                    pattern: t(
+                        "\\b<<0>>(?=\\s+(?!<<1>>)<<2>>(?:\\s*[=,;:{)\\]]|\\s+(?:in|when)\\b))",
+                        [w, u, h]
+                    ),
+                    inside: v
+                }
+            ],
+            keyword: p,
+            number: /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:ul|lu|[dflmu])?\b/i,
+            operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
+            punctuation: /\?\.?|::|[{}[\];(),.:]/
+        })),
+            s.languages.insertBefore("csharp", "number", {
+                range: { pattern: /\.\./, alias: "operator" }
+            }),
+            s.languages.insertBefore("csharp", "punctuation", {
+                "named-parameter": {
+                    pattern: t("([(,]\\s*)<<0>>(?=\\s*:)", [h]),
+                    lookbehind: !0,
+                    alias: "punctuation"
+                }
+            }),
+            s.languages.insertBefore("csharp", "class-name", {
+                namespace: {
+                    pattern: t(
+                        "(\\b(?:namespace|using)\\s+)<<0>>(?:\\s*\\.\\s*<<0>>)*(?=\\s*[;{])",
+                        [h]
+                    ),
+                    lookbehind: !0,
+                    inside: { punctuation: /\./ }
+                },
+                "type-expression": {
+                    pattern: t(
+                        "(\\b(?:default|typeof|sizeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<<0>>)*(?=\\s*\\))",
+                        [b]
+                    ),
+                    lookbehind: !0,
+                    alias: "class-name",
+                    inside: v
+                },
+                "return-type": {
+                    pattern: t(
+                        "<<0>>(?=\\s+(?:<<1>>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))",
+                        [w, m]
+                    ),
+                    inside: v,
+                    alias: "class-name"
+                },
+                "constructor-invocation": {
+                    pattern: t("(\\bnew\\s+)<<0>>(?=\\s*[[({])", [w]),
+                    lookbehind: !0,
+                    inside: v,
+                    alias: "class-name"
+                },
+                "generic-method": {
+                    pattern: t("<<0>>\\s*<<1>>(?=\\s*\\()", [h, g]),
+                    inside: {
+                        function: t("^<<0>>", [h]),
+                        generic: {
+                            pattern: RegExp(g),
+                            alias: "class-name",
+                            inside: v
+                        }
+                    }
+                },
+                "type-list": {
+                    pattern: t(
+                        "\\b((?:<<0>>\\s+<<1>>|where\\s+<<2>>)\\s*:\\s*)(?:<<3>>|<<4>>)(?:\\s*,\\s*(?:<<3>>|<<4>>))*(?=\\s*(?:where|[{;]|=>|$))",
+                        [d, f, h, w, p.source]
+                    ),
+                    lookbehind: !0,
+                    inside: {
+                        keyword: p,
+                        "class-name": {
+                            pattern: RegExp(w),
+                            greedy: !0,
+                            inside: v
+                        },
+                        punctuation: /,/
+                    }
+                },
+                preprocessor: {
+                    pattern: /(^\s*)#.*/m,
+                    lookbehind: !0,
+                    alias: "property",
+                    inside: {
+                        directive: {
+                            pattern:
+                                /(\s*#)\b(?:define|elif|else|endif|endregion|error|if|line|pragma|region|undef|warning)\b/,
+                            lookbehind: !0,
+                            alias: "keyword"
+                        }
+                    }
+                }
+            });
+        var _ = $ + "|" + x,
+            B = a(
+                "/(?![*/])|//[^\r\n]*[\r\n]|/\\*(?:[^*]|\\*(?!/))*\\*/|<<0>>",
+                [_]
+            ),
+            E = e(a("[^\"'/()]|<<0>>|\\(<<self>>*\\)", [B]), 2),
+            R =
+                "\\b(?:assembly|event|field|method|module|param|property|return|type)\\b",
+            P = a("<<0>>(?:\\s*\\(<<1>>*\\))?", [m, E]);
+        s.languages.insertBefore("csharp", "class-name", {
+            attribute: {
+                pattern: t(
+                    "((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<<0>>\\s*:\\s*)?<<1>>(?:\\s*,\\s*<<1>>)*(?=\\s*\\])",
+                    [R, P]
+                ),
+                lookbehind: !0,
+                greedy: !0,
+                inside: {
+                    target: {
+                        pattern: t("^<<0>>(?=\\s*:)", [R]),
+                        alias: "keyword"
+                    },
+                    "attribute-arguments": {
+                        pattern: t("\\(<<0>>*\\)", [E]),
+                        inside: s.languages.csharp
+                    },
+                    "class-name": {
+                        pattern: RegExp(m),
+                        inside: { punctuation: /\./ }
+                    },
+                    punctuation: /[:,]/
+                }
+            }
+        });
+        var z = ":[^}\r\n]+",
+            S = e(a("[^\"'/()]|<<0>>|\\(<<self>>*\\)", [B]), 2),
+            j = a("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [S, z]),
+            A = e(
+                a(
+                    "[^\"'/()]|/(?!\\*)|/\\*(?:[^*]|\\*(?!/))*\\*/|<<0>>|\\(<<self>>*\\)",
+                    [_]
+                ),
+                2
+            ),
+            F = a("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [A, z]);
+        function U(e, n) {
+            return {
+                interpolation: {
+                    pattern: t("((?:^|[^{])(?:\\{\\{)*)<<0>>", [e]),
+                    lookbehind: !0,
+                    inside: {
+                        "format-string": {
+                            pattern: t(
+                                "(^\\{(?:(?![}:])<<0>>)*)<<1>>(?=\\}$)",
+                                [n, z]
+                            ),
+                            lookbehind: !0,
+                            inside: { punctuation: /^:/ }
+                        },
+                        punctuation: /^\{|\}$/,
+                        expression: {
+                            pattern: /[\s\S]+/,
+                            alias: "language-csharp",
+                            inside: s.languages.csharp
+                        }
+                    }
+                },
+                string: /[\s\S]+/
+            };
+        }
+        s.languages.insertBefore("csharp", "string", {
+            "interpolation-string": [
+                {
+                    pattern: t(
+                        '(^|[^\\\\])(?:\\$@|@\\$)"(?:""|\\\\[^]|\\{\\{|<<0>>|[^\\\\{"])*"',
+                        [j]
+                    ),
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: U(j, S)
+                },
+                {
+                    pattern: t(
+                        '(^|[^@\\\\])\\$"(?:\\\\.|\\{\\{|<<0>>|[^\\\\"{])*"',
+                        [F]
+                    ),
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: U(F, A)
+                }
+            ]
+        });
+    })(Prism),
+        (Prism.languages.dotnet = Prism.languages.cs = Prism.languages.csharp);
+    (Prism.languages.aspnet = Prism.languages.extend("markup", {
+        "page-directive": {
+            pattern: /<%\s*@.*%>/i,
+            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: /<%.*%>/i,
+            alias: "tag",
+            inside: {
+                directive: { pattern: /<%\s*?[$=%#:]{0,2}|%>/i, alias: "tag" },
+                rest: Prism.languages.csharp
+            }
+        }
+    })),
+        (Prism.languages.aspnet.tag.pattern =
+            /<(?!%)\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/i),
+        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['"]?)[^>]*>)[\s\S]*?(?=<\/script>)/i,
+                    lookbehind: !0,
+                    alias: ["asp", "script"],
+                    inside: Prism.languages.csharp || {}
+                }
+            }
+        );
+    Prism.languages.basic = {
+        comment: { pattern: /(?:!|REM\b).+/i, inside: { keyword: /^REM/i } },
+        string: {
+            pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^_ +\-.A-Z\d])*"/i,
+            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|SHARED|SINGLE|SELECT CASE|SHELL|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
+        },
+        "class-name": {
+            pattern:
+                /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
+            lookbehind: !0
+        },
+        keyword:
+            /\b(?:__attribute__|_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|asm|typeof|inline|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while)\b/,
+        function: /[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", {
+            macro: {
+                pattern:
+                    /(^\s*)#\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
+                    ],
+                    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
+                    }
+                }
+            },
+            constant:
+                /\b(?:__FILE__|__LINE__|__DATE__|__TIME__|__TIMESTAMP__|__func__|EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|stdin|stdout|stderr)\b/
+        }),
+        delete Prism.languages.c.boolean;
+    !(function (e) {
+        var t =
+                /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char8_t|char16_t|char32_t|class|compl|concept|const|consteval|constexpr|constinit|const_cast|continue|co_await|co_return|co_yield|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int8_t|int16_t|int32_t|int64_t|uint8_t|uint16_t|uint32_t|uint64_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|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,
+                /\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(?:true|false)\b/
+        })),
+            e.languages.insertBefore("cpp", "string", {
+                module: {
+                    pattern: RegExp(
+                        '(\\b(?:module|import)\\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[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,
+            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]+\b)/, 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]{1,2}){3,4}\b/i, alias: "color" },
+            color: [
+                /\b(?: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|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)\b/i,
+                {
+                    pattern:
+                        /\b(?:rgb|hsl)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:rgb|hsl)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) {
+        var t =
+                /\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|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/,
+            n = "(^|[^\\w.])(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*",
+            a = {
+                pattern: RegExp(n + "[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", {
+            "class-name": [
+                a,
+                {
+                    pattern: RegExp(n + "[A-Z]\\w*(?=\\s+\\w+\\s*[;,=())])"),
+                    lookbehind: !0,
+                    inside: a.inside
+                }
+            ],
+            keyword: t,
+            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
+            }
+        })),
+            e.languages.insertBefore("java", "string", {
+                "triple-quoted-string": {
+                    pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
+                    greedy: !0,
+                    alias: "string"
+                }
+            }),
+            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": a,
+                        keyword: t,
+                        punctuation: /[<>(),.:]/,
+                        operator: /[?&|]/
+                    }
+                },
+                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 t.source;
+                            }
+                        )
+                    ),
+                    lookbehind: !0,
+                    inside: { punctuation: /\./ }
+                }
+            });
+    })(Prism);
+    !(function (h) {
+        function v(e, n) {
+            return "___" + e.toUpperCase() + n + "___";
+        }
+        Object.defineProperties((h.languages["markup-templating"] = {}), {
+            buildPlaceholders: {
+                value: function (a, r, e, o) {
+                    if (a.language === r) {
+                        var c = (a.tokenStack = []);
+                        (a.code = a.code.replace(e, function (e) {
+                            if ("function" == typeof o && !o(e)) return e;
+                            for (
+                                var n, t = c.length;
+                                -1 !== a.code.indexOf((n = v(r, t)));
+
+                            )
+                                ++t;
+                            return (c[t] = e), n;
+                        })),
+                            (a.grammar = h.languages.markup);
+                    }
+                }
+            },
+            tokenizePlaceholders: {
+                value: function (p, k) {
+                    if (p.language === k && p.tokenStack) {
+                        p.grammar = h.languages[k];
+                        var m = 0,
+                            d = Object.keys(p.tokenStack);
+                        !(function e(n) {
+                            for (
+                                var t = 0;
+                                t < n.length && !(m >= d.length);
+                                t++
+                            ) {
+                                var a = n[t];
+                                if (
+                                    "string" == typeof a ||
+                                    (a.content && "string" == typeof a.content)
+                                ) {
+                                    var r = d[m],
+                                        o = p.tokenStack[r],
+                                        c =
+                                            "string" == typeof a
+                                                ? a
+                                                : a.content,
+                                        i = v(k, r),
+                                        u = c.indexOf(i);
+                                    if (-1 < u) {
+                                        ++m;
+                                        var g = c.substring(0, u),
+                                            l = new h.Token(
+                                                k,
+                                                h.tokenize(o, p.grammar),
+                                                "language-" + k,
+                                                o
+                                            ),
+                                            s = c.substring(u + i.length),
+                                            f = [];
+                                        g && f.push.apply(f, e([g])),
+                                            f.push(l),
+                                            s && f.push.apply(f, e([s])),
+                                            "string" == typeof a
+                                                ? n.splice.apply(
+                                                      n,
+                                                      [t, 1].concat(f)
+                                                  )
+                                                : (a.content = f);
+                                    }
+                                } else a.content && e(a.content);
+                            }
+                            return n;
+                        })(p.tokens);
+                    }
+                }
+            }
+        });
+    })(Prism);
+    !(function (a) {
+        var e = /\/\*[\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 = /[{}\[\](),:;]/;
+        a.languages.php = {
+            delimiter: {
+                pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
+                alias: "important"
+            },
+            comment: e,
+            variable: /\$+(?:\w+\b|(?={))/i,
+            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(?:bool|boolean|int|integer|float|string|object|array)\b(?=\s*\))/i,
+                    alias: "type-casting",
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                {
+                    pattern:
+                        /([(,?]\s*)\b(?:bool|int|float|string|object|array(?!\s*\()|mixed|self|static|callable|iterable|(?:null|false)(?=\s*\|))\b(?=\s*\$)/i,
+                    alias: "type-hint",
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                {
+                    pattern:
+                        /([(,?]\s*[a-z0-9_|]\|\s*)(?:null|false)\b(?=\s*\$)/i,
+                    alias: "type-hint",
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                {
+                    pattern:
+                        /(\)\s*:\s*(?:\?\s*)?)\b(?:bool|int|float|string|object|void|array(?!\s*\()|mixed|self|static|callable|iterable|(?:null|false)(?=\s*\|))\b/i,
+                    alias: "return-type",
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                {
+                    pattern:
+                        /(\)\s*:\s*(?:\?\s*)?[a-z0-9_|]\|\s*)(?:null|false)\b/i,
+                    alias: "return-type",
+                    greedy: !0,
+                    lookbehind: !0
+                },
+                {
+                    pattern:
+                        /\b(?:bool|int|float|string|object|void|array(?!\s*\()|mixed|iterable|(?:null|false)(?=\s*\|))\b/i,
+                    alias: "type-declaration",
+                    greedy: !0
+                },
+                {
+                    pattern: /(\|\s*)(?:null|false)\b/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(?:__halt_compiler|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|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|namespace|match|new|or|parent|print|private|protected|public|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield)\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: /\b\w+(?=\s*\()/,
+            property: { pattern: /(->\s*)\w+/, lookbehind: !0 },
+            number: i,
+            operator: n,
+            punctuation: s
+        };
+        var l = {
+                pattern:
+                    /{\$(?:{(?:{[^{}]+}|[^{}]+)}|[^{}])+}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)*)/,
+                lookbehind: !0,
+                inside: a.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 }
+                }
+            ];
+        a.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: e,
+                            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" }
+                }
+            }
+        }),
+            a.hooks.add("before-tokenize", function (e) {
+                if (/<\?/.test(e.code)) {
+                    a.languages["markup-templating"].buildPlaceholders(
+                        e,
+                        "php",
+                        /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/gi
+                    );
+                }
+            }),
+            a.hooks.add("after-tokenize", function (e) {
+                a.languages["markup-templating"].tokenizePlaceholders(e, "php");
+            });
+    })(Prism);
+    !(function (p) {
+        var a = (p.languages.javadoclike = {
+            parameter: {
+                pattern:
+                    /(^\s*(?:\/{3}|\*|\/\*\*)\s*@(?:param|arg|arguments)\s+)\w+/m,
+                lookbehind: !0
+            },
+            keyword: {
+                pattern: /(^\s*(?:\/{3}|\*|\/\*\*)\s*|\{)@[a-z][a-zA-Z-]+\b/m,
+                lookbehind: !0
+            },
+            punctuation: /[{}]/
+        });
+        Object.defineProperty(a, "addSupport", {
+            value: function (a, e) {
+                "string" == typeof a && (a = [a]),
+                    a.forEach(function (a) {
+                        !(function (a, e) {
+                            var n = "doc-comment",
+                                t = p.languages[a];
+                            if (t) {
+                                var r = t[n];
+                                if (!r) {
+                                    var o = {
+                                        "doc-comment": {
+                                            pattern:
+                                                /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/,
+                                            lookbehind: !0,
+                                            alias: "comment"
+                                        }
+                                    };
+                                    r = (t = p.languages.insertBefore(
+                                        a,
+                                        "comment",
+                                        o
+                                    ))[n];
+                                }
+                                if (
+                                    (r instanceof RegExp &&
+                                        (r = t[n] = { pattern: r }),
+                                    Array.isArray(r))
+                                )
+                                    for (var i = 0, s = r.length; i < s; i++)
+                                        r[i] instanceof RegExp &&
+                                            (r[i] = { pattern: r[i] }),
+                                            e(r[i]);
+                                else e(r);
+                            }
+                        })(a, function (a) {
+                            a.inside || (a.inside = {}), (a.inside.rest = e);
+                        });
+                    });
+            }
+        }),
+            a.addSupport(["java", "javascript", "php"], a);
+    })(Prism);
+    !(function (a) {
+        var e = /(^(?:\s*(?:\*\s*)*))[^*\s].*$/m,
+            n =
+                "(?:[a-zA-Z]\\w+\\s*\\.\\s*)*[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|throws|see|link|linkplain|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
+            },
+            keyword:
+                /\b(?:abstract|as|asserts|async|await|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|is|keyof|let|module|namespace|new|null|of|package|private|protected|public|readonly|return|require|set|static|super|switch|this|throw|try|type|typeof|undefined|var|void|while|with|yield)\b/,
+            builtin:
+                /\b(?:string|Function|any|number|boolean|Array|symbol|console|Promise|unknown|never)\b/
+        })),
+            delete e.languages.typescript.parameter;
+        var t = e.languages.extend("typescript", {});
+        delete t["class-name"],
+            (e.languages.typescript["class-name"].inside = t),
+            e.languages.insertBefore("typescript", "function", {
+                decorator: {
+                    pattern: /@[$\w\xA0-\uFFFF]+/,
+                    inside: {
+                        at: { pattern: /^@/, alias: "operator" },
+                        function: /^[\s\S]+/
+                    }
+                },
+                "generic-function": {
+                    pattern:
+                        /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
+                    greedy: !0,
+                    inside: {
+                        function:
+                            /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
+                        generic: {
+                            pattern: /<[\s\S]+/,
+                            alias: "class-name",
+                            inside: t
+                        }
+                    }
+                }
+            }),
+            (e.languages.ts = e.languages.typescript);
+    })(Prism);
+    !(function (e) {
+        var a = e.languages.javascript,
+            n = "{(?:[^{}]|{(?:[^{}]|{[^{}]*})*})+}",
+            s = "(@(?:param|arg|argument|property)\\s+(?:" + n + "\\s+)?)";
+        (e.languages.jsdoc = e.languages.extend("javadoclike", {
+            parameter: {
+                pattern: RegExp(
+                    s + "(?:(?!\\s)[$\\w\\xA0-\\uFFFF.])+(?=\\s|$)"
+                ),
+                lookbehind: !0,
+                inside: { punctuation: /\./ }
+            }
+        })),
+            e.languages.insertBefore("jsdoc", "keyword", {
+                "optional-parameter": {
+                    pattern: RegExp(
+                        s +
+                            "\\[(?:(?!\\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|extends|class|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: /^(\s*(?:\*\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(?:(?:(?:Uint|Int)(?:8|16|32)|Uint8Clamped|Float(?:32|64))?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|(?:Weak)?(?:Set|Map)|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|for|finally|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|location|navigator|performance|(?:local|session)Storage|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)["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(?:true|false)\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,
+            inside: {
+                "not-my-code": {
+                    pattern:
+                        /[ \t]+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:
+                        /(at\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: /:[0-9]+(?::[0-9]+)?\b/,
+                    alias: "number",
+                    inside: { punctuation: /:/ }
+                }
+            }
+        }
+    };
+    !(function (u) {
+        function n(n) {
+            return (
+                (n = n.replace(/<inner>/g, function () {
+                    return "(?:\\\\.|[^\\\\\n\r]|(?:\n|\r\n?)(?!\n|\r\n?))";
+                })),
+                RegExp("((?:^|[^\\\\])(?:\\\\{2})*)(?:" + n + ")")
+            );
+        }
+        var e = "(?:\\\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\\\|\r\n`])+",
+            t = "\\|?__(?:\\|__)+\\|?(?:(?:\n|\r\n?)|(?![^]))".replace(
+                /__/g,
+                function () {
+                    return e;
+                }
+            ),
+            a =
+                "\\|?[ \t]*:?-{3,}:?[ \t]*(?:\\|[ \t]*:?-{3,}:?[ \t]*)+\\|?(?:\n|\r\n?)";
+        (u.languages.markdown = u.languages.extend("markup", {})),
+            u.languages.insertBefore("markdown", "prolog", {
+                "front-matter-block": {
+                    pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: {
+                        punctuation: /^---|---$/,
+                        "font-matter": {
+                            pattern: /\S+(?:\s+\S+)*/,
+                            alias: ["yaml", "language-yaml"],
+                            inside: u.languages.yaml
+                        }
+                    }
+                },
+                blockquote: {
+                    pattern: /^>(?:[\t ]*>)*/m,
+                    alias: "punctuation"
+                },
+                table: {
+                    pattern: RegExp("^" + t + a + "(?:" + t + ")*", "m"),
+                    inside: {
+                        "table-data-rows": {
+                            pattern: RegExp("^(" + t + a + ")(?:" + t + ")*$"),
+                            lookbehind: !0,
+                            inside: {
+                                "table-data": {
+                                    pattern: RegExp(e),
+                                    inside: u.languages.markdown
+                                },
+                                punctuation: /\|/
+                            }
+                        },
+                        "table-line": {
+                            pattern: RegExp("^(" + t + ")" + a + "$"),
+                            lookbehind: !0,
+                            inside: { punctuation: /\||:?-{3,}:?/ }
+                        },
+                        "table-header-row": {
+                            pattern: RegExp("^" + t + "$"),
+                            inside: {
+                                "table-header": {
+                                    pattern: RegExp(e),
+                                    alias: "important",
+                                    inside: u.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: /``.+?``|`[^`\r\n]+`/, 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: n(
+                        "\\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\\b|\\*\\*(?:(?!\\*)<inner>|\\*(?:(?!\\*)<inner>)+\\*)+\\*\\*"
+                    ),
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: {
+                        content: {
+                            pattern: /(^..)[\s\S]+(?=..$)/,
+                            lookbehind: !0,
+                            inside: {}
+                        },
+                        punctuation: /\*\*|__/
+                    }
+                },
+                italic: {
+                    pattern: n(
+                        "\\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\\b|\\*(?:(?!\\*)<inner>|\\*\\*(?:(?!\\*)<inner>)+\\*\\*)+\\*"
+                    ),
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: {
+                        content: {
+                            pattern: /(^.)[\s\S]+(?=.$)/,
+                            lookbehind: !0,
+                            inside: {}
+                        },
+                        punctuation: /[*_]/
+                    }
+                },
+                strike: {
+                    pattern: n("(~~?)(?:(?!~)<inner>)+?\\2"),
+                    lookbehind: !0,
+                    greedy: !0,
+                    inside: {
+                        content: {
+                            pattern: /(^~~?)[\s\S]+(?=\1$)/,
+                            lookbehind: !0,
+                            inside: {}
+                        },
+                        punctuation: /~~?/
+                    }
+                },
+                url: {
+                    pattern: n(
+                        '!?\\[(?:(?!\\])<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"].forEach(function (n) {
+                    e !== n &&
+                        (u.languages.markdown[e].inside.content.inside[n] =
+                            u.languages.markdown[n]);
+                });
+            }),
+            u.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);
+            }),
+            u.hooks.add("wrap", function (n) {
+                if ("code-block" === n.type) {
+                    for (var e = "", t = 0, a = n.classes.length; t < a; t++) {
+                        var i = n.classes[t],
+                            r = /language-(.+)/.exec(i);
+                        if (r) {
+                            e = r[1];
+                            break;
+                        }
+                    }
+                    var o = u.languages[e];
+                    if (o) {
+                        var l = document.createElement("div");
+                        l.innerHTML = n.content;
+                        var s = l.textContent;
+                        n.content = u.highlight(s, o, e);
+                    } else if (e && "none" !== e && u.plugins.autoloader) {
+                        var d =
+                            "md-" +
+                            new Date().valueOf() +
+                            "-" +
+                            Math.floor(1e16 * Math.random());
+                        (n.attributes.id = d),
+                            u.plugins.autoloader.loadLanguages(e, function () {
+                                var n = document.getElementById(d);
+                                n &&
+                                    (n.innerHTML = u.highlight(
+                                        n.textContent,
+                                        u.languages[e],
+                                        e
+                                    ));
+                            });
+                    }
+                }
+            }),
+            (u.languages.md = u.languages.markdown);
+    })(Prism);
+    !(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(?:callback|resource|boolean|integer|double|object|string|array|false|float|mixed|bool|null|self|true|void|int)\b/,
+                            punctuation: /[|\\[\]()]/
+                        }
+                    }
+                ]
+            }),
+            a.languages.javadoclike.addSupport("php", a.languages.phpdoc);
+    })(Prism);
+    Prism.languages.insertBefore("php", "variable", {
+        this: /\$this\b/,
+        global: /\$(?:_(?:SERVER|GET|POST|FILES|REQUEST|SESSION|ENV|COOKIE)|GLOBALS|HTTP_RAW_POST_DATA|argc|argv|php_errormsg|http_response_header)\b/,
+        scope: {
+            pattern: /\b[\w\\]+::/,
+            inside: { keyword: /static|self|parent/, punctuation: /::|\\/ }
+        }
+    });
+    !(function (E) {
+        var A = (E.languages.plsql = E.languages.extend("sql", {
+                comment: [/\/\*[\s\S]*?\*\//, /--.*/]
+            })),
+            T = A.keyword;
+        Array.isArray(T) || (T = A.keyword = [T]),
+            T.unshift(
+                /\b(?:ACCESS|AGENT|AGGREGATE|ARRAY|ARROW|AT|ATTRIBUTE|AUDIT|AUTHID|BFILE_BASE|BLOB_BASE|BLOCK|BODY|BOTH|BOUND|BYTE|CALLING|CHAR_BASE|CHARSET(?:FORM|ID)|CLOB_BASE|COLAUTH|COLLECT|CLUSTERS?|COMPILED|COMPRESS|CONSTANT|CONSTRUCTOR|CONTEXT|CRASH|CUSTOMDATUM|DANGLING|DATE_BASE|DEFINE|DETERMINISTIC|DURATION|ELEMENT|EMPTY|EXCEPTIONS?|EXCLUSIVE|EXTERNAL|FINAL|FORALL|FORM|FOUND|GENERAL|HEAP|HIDDEN|IDENTIFIED|IMMEDIATE|INCLUDING|INCREMENT|INDICATOR|INDEXES|INDICES|INFINITE|INITIAL|ISOPEN|INSTANTIABLE|INTERFACE|INVALIDATE|JAVA|LARGE|LEADING|LENGTH|LIBRARY|LIKE[24C]|LIMITED|LONG|LOOP|MAP|MAXEXTENTS|MAXLEN|MEMBER|MINUS|MLSLABEL|MULTISET|NAME|NAN|NATIVE|NEW|NOAUDIT|NOCOMPRESS|NOCOPY|NOTFOUND|NOWAIT|NUMBER(?:_BASE)?|OBJECT|OCI(?:COLL|DATE|DATETIME|DURATION|INTERVAL|LOBLOCATOR|NUMBER|RAW|REF|REFCURSOR|ROWID|STRING|TYPE)|OFFLINE|ONLINE|ONLY|OPAQUE|OPERATOR|ORACLE|ORADATA|ORGANIZATION|ORL(?:ANY|VARY)|OTHERS|OVERLAPS|OVERRIDING|PACKAGE|PARALLEL_ENABLE|PARAMETERS?|PASCAL|PCTFREE|PIPE(?:LINED)?|PRAGMA|PRIOR|PRIVATE|RAISE|RANGE|RAW|RECORD|REF|REFERENCE|REM|REMAINDER|RESULT|RESOURCE|RETURNING|REVERSE|ROW(?:ID|NUM|TYPE)|SAMPLE|SB[124]|SEGMENT|SELF|SEPARATE|SEQUENCE|SHORT|SIZE(?:_T)?|SPARSE|SQL(?:CODE|DATA|NAME|STATE)|STANDARD|STATIC|STDDEV|STORED|STRING|STRUCT|STYLE|SUBMULTISET|SUBPARTITION|SUBSTITUTABLE|SUBTYPE|SUCCESSFUL|SYNONYM|SYSDATE|TABAUTH|TDO|THE|TIMEZONE_(?:ABBR|HOUR|MINUTE|REGION)|TRAILING|TRANSAC(?:TIONAL)?|TRUSTED|UB[124]|UID|UNDER|UNTRUSTED|VALIDATE|VALIST|VARCHAR2|VARIABLE|VARIANCE|VARRAY|VIEWS|VOID|WHENEVER|WRAPPED|ZONE)\b/i
+            );
+        var R = A.operator;
+        Array.isArray(R) || (R = A.operator = [R]), R.unshift(/:=/);
+    })(Prism);
+    !(function (a) {
+        var e = { pattern: /\\[\\(){}[\]^$+*?|.]/, alias: "escape" },
+            n =
+                /\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|c[a-zA-Z]|0[0-7]{0,2}|[123][0-7]{2}|.)/,
+            t = "(?:[^\\\\-]|" + n.source + ")",
+            s = RegExp(t + "-" + t),
+            i = {
+                pattern: /(<|')[^<>']+(?=[>']$)/,
+                lookbehind: !0,
+                alias: "variable"
+            };
+        a.languages.regex = {
+            charset: {
+                pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/,
+                lookbehind: !0,
+                inside: {
+                    "charset-negation": {
+                        pattern: /(^\[)\^/,
+                        lookbehind: !0,
+                        alias: "operator"
+                    },
+                    "charset-punctuation": {
+                        pattern: /^\[|\]$/,
+                        alias: "punctuation"
+                    },
+                    range: {
+                        pattern: s,
+                        inside: {
+                            escape: n,
+                            "range-punctuation": {
+                                pattern: /-/,
+                                alias: "operator"
+                            }
+                        }
+                    },
+                    "special-escape": e,
+                    charclass: {
+                        pattern: /\\[wsd]|\\p{[^{}]+}/i,
+                        alias: "class-name"
+                    },
+                    escape: n
+                }
+            },
+            "special-escape": e,
+            charclass: {
+                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);
+    !(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: /^[0-9]+$/,
+                    punctuation: /[,|:]/
+                }
+            },
+            keyword: n,
+            number: {
+                pattern: /[0-9]+\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]{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: /(^|[^"])"(?:""|[^"])*"(?!")/i,
+            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|CDEC|CDBL|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|DEFAULT|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|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|LINE INPUT|LET|LIB|LIKE|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)?|OPERATOR|OPEN|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|SHORT|SINGLE|SHELL|SLEEP|STATIC|STEP|STOP|STRING|STRUCTURE|SUB|SYNCLOCK|SWAP|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 () {
+        if ("undefined" != typeof Prism && "undefined" != typeof document) {
+            var o = "line-numbers",
+                a = /\n(?!$)/g,
+                e = (Prism.plugins.lineNumbers = {
+                    getLine: function (e, n) {
+                        if ("PRE" === e.tagName && e.classList.contains(o)) {
+                            var t = e.querySelector(".line-numbers-rows");
+                            if (t) {
+                                var i =
+                                        parseInt(
+                                            e.getAttribute("data-start"),
+                                            10
+                                        ) || 1,
+                                    r = i + (t.children.length - 1);
+                                n < i && (n = i), r < n && (n = r);
+                                var s = n - i;
+                                return t.children[s];
+                            }
+                        }
+                    },
+                    resize: function (e) {
+                        u([e]);
+                    },
+                    assumeViewportIndependence: !0
+                }),
+                t = function (e) {
+                    return e
+                        ? window.getComputedStyle
+                            ? getComputedStyle(e)
+                            : e.currentStyle || null
+                        : null;
+                },
+                n = void 0;
+            window.addEventListener("resize", function () {
+                (e.assumeViewportIndependence && n === window.innerWidth) ||
+                    ((n = window.innerWidth),
+                    u(
+                        Array.prototype.slice.call(
+                            document.querySelectorAll("pre." + o)
+                        )
+                    ));
+            }),
+                Prism.hooks.add("complete", function (e) {
+                    if (e.code) {
+                        var n = e.element,
+                            t = n.parentNode;
+                        if (
+                            t &&
+                            /pre/i.test(t.nodeName) &&
+                            !n.querySelector(".line-numbers-rows") &&
+                            Prism.util.isActive(n, o)
+                        ) {
+                            n.classList.remove(o), t.classList.add(o);
+                            var i,
+                                r = e.code.match(a),
+                                s = r ? r.length + 1 : 1,
+                                l = new Array(s + 1).join("<span></span>");
+                            (i = document.createElement("span")).setAttribute(
+                                "aria-hidden",
+                                "true"
+                            ),
+                                (i.className = "line-numbers-rows"),
+                                (i.innerHTML = l),
+                                t.hasAttribute("data-start") &&
+                                    (t.style.counterReset =
+                                        "linenumber " +
+                                        (parseInt(
+                                            t.getAttribute("data-start"),
+                                            10
+                                        ) -
+                                            1)),
+                                e.element.appendChild(i),
+                                u([t]),
+                                Prism.hooks.run("line-numbers", e);
+                        }
+                    }
+                }),
+                Prism.hooks.add("line-numbers", function (e) {
+                    (e.plugins = e.plugins || {}), (e.plugins.lineNumbers = !0);
+                });
+        }
+        function u(e) {
+            if (
+                0 !=
+                (e = e.filter(function (e) {
+                    var n = t(e)["white-space"];
+                    return "pre-wrap" === n || "pre-line" === n;
+                })).length
+            ) {
+                var n = e
+                    .map(function (e) {
+                        var n = e.querySelector("code"),
+                            t = e.querySelector(".line-numbers-rows");
+                        if (n && t) {
+                            var i = e.querySelector(".line-numbers-sizer"),
+                                r = n.textContent.split(a);
+                            i ||
+                                (((i =
+                                    document.createElement("span")).className =
+                                    "line-numbers-sizer"),
+                                n.appendChild(i)),
+                                (i.innerHTML = "0"),
+                                (i.style.display = "block");
+                            var s = i.getBoundingClientRect().height;
+                            return (
+                                (i.innerHTML = ""),
+                                {
+                                    element: e,
+                                    lines: r,
+                                    lineHeights: [],
+                                    oneLinerHeight: s,
+                                    sizer: i
+                                }
+                            );
+                        }
+                    })
+                    .filter(Boolean);
+                n.forEach(function (e) {
+                    var i = e.sizer,
+                        n = e.lines,
+                        r = e.lineHeights,
+                        s = e.oneLinerHeight;
+                    (r[n.length - 1] = void 0),
+                        n.forEach(function (e, n) {
+                            if (e && 1 < e.length) {
+                                var t = i.appendChild(
+                                    document.createElement("span")
+                                );
+                                (t.style.display = "block"),
+                                    (t.textContent = e);
+                            } else r[n] = s;
+                        });
+                }),
+                    n.forEach(function (e) {
+                        for (
+                            var n = e.sizer, t = e.lineHeights, i = 0, r = 0;
+                            r < t.length;
+                            r++
+                        )
+                            void 0 === t[r] &&
+                                (t[r] =
+                                    n.children[
+                                        i++
+                                    ].getBoundingClientRect().height);
+                    }),
+                    n.forEach(function (e) {
+                        var n = e.sizer,
+                            t = e.element.querySelector(".line-numbers-rows");
+                        (n.style.display = "none"),
+                            (n.innerHTML = ""),
+                            e.lineHeights.forEach(function (e, n) {
+                                t.children[n].style.height = e + "px";
+                            });
+                    });
+            }
+        }
+    })();
+    "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 d = { "(": ")", "[": "]", "{": "}" },
+                u = {
+                    "(": "brace-round",
+                    "[": "brace-square",
+                    "{": "brace-curly"
+                },
+                f = { "${": "{" },
+                h = 0,
+                n = /^(pair-\d+-)(open|close)$/;
+            Prism.hooks.add("complete", function (e) {
+                var t = e.element,
+                    n = t.parentElement;
+                if (n && "PRE" == n.tagName) {
+                    var c = [];
+                    if (
+                        (Prism.util.isActive(t, "match-braces") &&
+                            c.push("(", "[", "{"),
+                        0 != c.length)
+                    ) {
+                        n.__listenerAdded ||
+                            (n.addEventListener("mousedown", function () {
+                                var e = n.querySelector("code");
+                                Array.prototype.slice
+                                    .call(e.querySelectorAll(".brace-selected"))
+                                    .forEach(function (e) {
+                                        e.classList.remove("brace-selected");
+                                    });
+                            }),
+                            Object.defineProperty(n, "__listenerAdded", {
+                                value: !0
+                            }));
+                        var o = Array.prototype.slice.call(
+                                t.querySelectorAll("span.token.punctuation")
+                            ),
+                            l = [];
+                        c.forEach(function (e) {
+                            for (
+                                var t = d[e], n = u[e], c = [], r = [], i = 0;
+                                i < o.length;
+                                i++
+                            ) {
+                                var s = o[i];
+                                if (0 == s.childElementCount) {
+                                    var a = s.textContent;
+                                    (a = f[a] || a) === e
+                                        ? (l.push({
+                                              index: i,
+                                              open: !0,
+                                              element: s
+                                          }),
+                                          s.classList.add(n),
+                                          s.classList.add("brace-open"),
+                                          r.push(i))
+                                        : a === t &&
+                                          (l.push({
+                                              index: i,
+                                              open: !1,
+                                              element: s
+                                          }),
+                                          s.classList.add(n),
+                                          s.classList.add("brace-close"),
+                                          r.length && c.push([i, r.pop()]));
+                                }
+                            }
+                            c.forEach(function (e) {
+                                var t = "pair-" + h++ + "-",
+                                    n = o[e[0]],
+                                    c = o[e[1]];
+                                (n.id = t + "open"),
+                                    (c.id = t + "close"),
+                                    [n, c].forEach(function (e) {
+                                        e.addEventListener("mouseenter", p),
+                                            e.addEventListener("mouseleave", v),
+                                            e.addEventListener("click", m);
+                                    });
+                            });
+                        });
+                        var r = 0;
+                        l.sort(function (e, t) {
+                            return e.index - t.index;
+                        }),
+                            l.forEach(function (e) {
+                                e.open
+                                    ? (e.element.classList.add(
+                                          "brace-level-" + ((r % 12) + 1)
+                                      ),
+                                      r++)
+                                    : ((r = Math.max(0, r - 1)),
+                                      e.element.classList.add(
+                                          "brace-level-" + ((r % 12) + 1)
+                                      ));
+                            });
+                    }
+                }
+            });
+        }
+        function e(e) {
+            var t = n.exec(e.id);
+            return document.querySelector(
+                "#" + t[1] + ("open" == t[2] ? "close" : "open")
+            );
+        }
+        function p() {
+            Prism.util.isActive(this, "brace-hover", !0) &&
+                [this, e(this)].forEach(function (e) {
+                    e.classList.add("brace-hover");
+                });
+        }
+        function v() {
+            [this, e(this)].forEach(function (e) {
+                e.classList.remove("brace-hover");
+            });
+        }
+        function m() {
+            Prism.util.isActive(this, "brace-select", !0) &&
+                [this, e(this)].forEach(function (e) {
+                    e.classList.add("brace-selected");
+                });
+        }
+    })();
+});
+
+export default prism;