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

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

@@ -1,3225 +0,0 @@
-/* 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;