mio-previewer 0.1.2 → 0.1.4

package/dist/entries/plugin-codeblock.es.js

@@ -1,3441 +0,0 @@
-import { defineComponent as Ae, ref as Z, watch as ve, createElementBlock as $, openBlock as D, createElementVNode as L, withDirectives as we, createCommentVNode as Y, toDisplayString as _e, normalizeClass as X, vShow as ke, h as ee } from "vue";
-import { c as te, g as xe } from "../_commonjsHelpers-DaMA6jEr.js";
-import { _ as Te } from "../_plugin-vue_export-helper-CHgC5LLL.js";
-var V = { exports: {} }, ae;
-function Fe() {
-  return ae || (ae = 1, (function(e) {
-    var o = typeof window < "u" ? window : typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? self : {};
-    /**
-     * Prism: Lightweight, robust, elegant syntax highlighting
-     *
-     * @license MIT <https://opensource.org/licenses/MIT>
-     * @author Lea Verou <https://lea.verou.me>
-     * @namespace
-     * @public
-     */
-    var t = (function(s) {
-      var b = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, E = 0, h = {}, r = {
-        /**
-         * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the
-         * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load
-         * additional languages or plugins yourself.
-         *
-         * By setting this value to `true`, Prism will not automatically highlight all code elements on the page.
-         *
-         * You obviously have to change this value before the automatic highlighting started. To do this, you can add an
-         * empty Prism object into the global scope before loading the Prism script like this:
-         *
-         * ```js
-         * window.Prism = window.Prism || {};
-         * Prism.manual = true;
-         * // add a new <script> to load Prism's script
-         * ```
-         *
-         * @default false
-         * @type {boolean}
-         * @memberof Prism
-         * @public
-         */
-        manual: s.Prism && s.Prism.manual,
-        /**
-         * By default, if Prism is in a web worker, it assumes that it is in a worker it created itself, so it uses
-         * `addEventListener` to communicate with its parent instance. However, if you're using Prism manually in your
-         * own worker, you don't want it to do this.
-         *
-         * By setting this value to `true`, Prism will not add its own listeners to the worker.
-         *
-         * You obviously have to change this value before Prism executes. To do this, you can add an
-         * empty Prism object into the global scope before loading the Prism script like this:
-         *
-         * ```js
-         * window.Prism = window.Prism || {};
-         * Prism.disableWorkerMessageHandler = true;
-         * // Load Prism's script
-         * ```
-         *
-         * @default false
-         * @type {boolean}
-         * @memberof Prism
-         * @public
-         */
-        disableWorkerMessageHandler: s.Prism && s.Prism.disableWorkerMessageHandler,
-        /**
-         * A namespace for utility methods.
-         *
-         * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
-         * change or disappear at any time.
-         *
-         * @namespace
-         * @memberof Prism
-         */
-        util: {
-          encode: function a(n) {
-            return n instanceof c ? new c(n.type, a(n.content), n.alias) : Array.isArray(n) ? n.map(a) : n.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\u00a0/g, " ");
-          },
-          /**
-           * Returns the name of the type of the given value.
-           *
-           * @param {any} o
-           * @returns {string}
-           * @example
-           * type(null)      === 'Null'
-           * type(undefined) === 'Undefined'
-           * type(123)       === 'Number'
-           * type('foo')     === 'String'
-           * type(true)      === 'Boolean'
-           * type([1, 2])    === 'Array'
-           * type({})        === 'Object'
-           * type(String)    === 'Function'
-           * type(/abc+/)    === 'RegExp'
-           */
-          type: function(a) {
-            return Object.prototype.toString.call(a).slice(8, -1);
-          },
-          /**
-           * Returns a unique number for the given object. Later calls will still return the same number.
-           *
-           * @param {Object} obj
-           * @returns {number}
-           */
-          objId: function(a) {
-            return a.__id || Object.defineProperty(a, "__id", { value: ++E }), a.__id;
-          },
-          /**
-           * Creates a deep clone of the given object.
-           *
-           * The main intended use of this function is to clone language definitions.
-           *
-           * @param {T} o
-           * @param {Record<number, any>} [visited]
-           * @returns {T}
-           * @template T
-           */
-          clone: function a(n, i) {
-            i = i || {};
-            var u, l;
-            switch (r.util.type(n)) {
-              case "Object":
-                if (l = r.util.objId(n), i[l])
-                  return i[l];
-                u = /** @type {Record<string, any>} */
-                {}, i[l] = u;
-                for (var f in n)
-                  n.hasOwnProperty(f) && (u[f] = a(n[f], i));
-                return (
-                  /** @type {any} */
-                  u
-                );
-              case "Array":
-                return l = r.util.objId(n), i[l] ? i[l] : (u = [], i[l] = u, /** @type {Array} */
-                /** @type {any} */
-                n.forEach(function(A, g) {
-                  u[g] = a(A, i);
-                }), /** @type {any} */
-                u);
-              default:
-                return n;
-            }
-          },
-          /**
-           * Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.
-           *
-           * If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.
-           *
-           * @param {Element} element
-           * @returns {string}
-           */
-          getLanguage: function(a) {
-            for (; a; ) {
-              var n = b.exec(a.className);
-              if (n)
-                return n[1].toLowerCase();
-              a = a.parentElement;
-            }
-            return "none";
-          },
-          /**
-           * Sets the Prism `language-xxxx` class of the given element.
-           *
-           * @param {Element} element
-           * @param {string} language
-           * @returns {void}
-           */
-          setLanguage: function(a, n) {
-            a.className = a.className.replace(RegExp(b, "gi"), ""), a.classList.add("language-" + n);
-          },
-          /**
-           * Returns the script element that is currently executing.
-           *
-           * This does __not__ work for line script element.
-           *
-           * @returns {HTMLScriptElement | null}
-           */
-          currentScript: function() {
-            if (typeof document > "u")
-              return null;
-            if (document.currentScript && document.currentScript.tagName === "SCRIPT")
-              return (
-                /** @type {any} */
-                document.currentScript
-              );
-            try {
-              throw new Error();
-            } catch (u) {
-              var a = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(u.stack) || [])[1];
-              if (a) {
-                var n = document.getElementsByTagName("script");
-                for (var i in n)
-                  if (n[i].src == a)
-                    return n[i];
-              }
-              return null;
-            }
-          },
-          /**
-           * Returns whether a given class is active for `element`.
-           *
-           * The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated
-           * if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the
-           * given class is just the given class with a `no-` prefix.
-           *
-           * Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is
-           * closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its
-           * ancestors have the given class or the negated version of it, then the default activation will be returned.
-           *
-           * In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated
-           * version of it, the class is considered active.
-           *
-           * @param {Element} element
-           * @param {string} className
-           * @param {boolean} [defaultActivation=false]
-           * @returns {boolean}
-           */
-          isActive: function(a, n, i) {
-            for (var u = "no-" + n; a; ) {
-              var l = a.classList;
-              if (l.contains(n))
-                return !0;
-              if (l.contains(u))
-                return !1;
-              a = a.parentElement;
-            }
-            return !!i;
-          }
-        },
-        /**
-         * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
-         *
-         * @namespace
-         * @memberof Prism
-         * @public
-         */
-        languages: {
-          /**
-           * The grammar for plain, unformatted text.
-           */
-          plain: h,
-          plaintext: h,
-          text: h,
-          txt: h,
-          /**
-           * Creates a deep copy of the language with the given id and appends the given tokens.
-           *
-           * If a token in `redef` also appears in the copied language, then the existing token in the copied language
-           * will be overwritten at its original position.
-           *
-           * ## Best practices
-           *
-           * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
-           * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
-           * understand the language definition because, normally, the order of tokens matters in Prism grammars.
-           *
-           * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
-           * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
-           *
-           * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
-           * @param {Grammar} redef The new tokens to append.
-           * @returns {Grammar} The new language created.
-           * @public
-           * @example
-           * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
-           *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
-           *     // at its original position
-           *     'comment': { ... },
-           *     // CSS doesn't have a 'color' token, so this token will be appended
-           *     'color': /\b(?:red|green|blue)\b/
-           * });
-           */
-          extend: function(a, n) {
-            var i = r.util.clone(r.languages[a]);
-            for (var u in n)
-              i[u] = n[u];
-            return i;
-          },
-          /**
-           * Inserts tokens _before_ another token in a language definition or any other grammar.
-           *
-           * ## Usage
-           *
-           * This helper method makes it easy to modify existing languages. For example, the CSS language definition
-           * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
-           * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
-           * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
-           * this:
-           *
-           * ```js
-           * Prism.languages.markup.style = {
-           *     // token
-           * };
-           * ```
-           *
-           * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
-           * before existing tokens. For the CSS example above, you would use it like this:
-           *
-           * ```js
-           * Prism.languages.insertBefore('markup', 'cdata', {
-           *     'style': {
-           *         // token
-           *     }
-           * });
-           * ```
-           *
-           * ## Special cases
-           *
-           * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
-           * will be ignored.
-           *
-           * This behavior can be used to insert tokens after `before`:
-           *
-           * ```js
-           * Prism.languages.insertBefore('markup', 'comment', {
-           *     'comment': Prism.languages.markup.comment,
-           *     // tokens after 'comment'
-           * });
-           * ```
-           *
-           * ## Limitations
-           *
-           * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
-           * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
-           * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
-           * deleting properties which is necessary to insert at arbitrary positions.
-           *
-           * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
-           * Instead, it will create a new object and replace all references to the target object with the new one. This
-           * can be done without temporarily deleting properties, so the iteration order is well-defined.
-           *
-           * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
-           * you hold the target object in a variable, then the value of the variable will not change.
-           *
-           * ```js
-           * var oldMarkup = Prism.languages.markup;
-           * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
-           *
-           * assert(oldMarkup !== Prism.languages.markup);
-           * assert(newMarkup === Prism.languages.markup);
-           * ```
-           *
-           * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
-           * object to be modified.
-           * @param {string} before The key to insert before.
-           * @param {Grammar} insert An object containing the key-value pairs to be inserted.
-           * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
-           * object to be modified.
-           *
-           * Defaults to `Prism.languages`.
-           * @returns {Grammar} The new grammar object.
-           * @public
-           */
-          insertBefore: function(a, n, i, u) {
-            u = u || /** @type {any} */
-            r.languages;
-            var l = u[a], f = {};
-            for (var A in l)
-              if (l.hasOwnProperty(A)) {
-                if (A == n)
-                  for (var g in i)
-                    i.hasOwnProperty(g) && (f[g] = i[g]);
-                i.hasOwnProperty(A) || (f[A] = l[A]);
-              }
-            var k = u[a];
-            return u[a] = f, r.languages.DFS(r.languages, function(T, N) {
-              N === k && T != a && (this[T] = f);
-            }), f;
-          },
-          // Traverse a language definition with Depth First Search
-          DFS: function a(n, i, u, l) {
-            l = l || {};
-            var f = r.util.objId;
-            for (var A in n)
-              if (n.hasOwnProperty(A)) {
-                i.call(n, A, n[A], u || A);
-                var g = n[A], k = r.util.type(g);
-                k === "Object" && !l[f(g)] ? (l[f(g)] = !0, a(g, i, null, l)) : k === "Array" && !l[f(g)] && (l[f(g)] = !0, a(g, i, A, l));
-              }
-          }
-        },
-        plugins: {},
-        /**
-         * This is the most high-level function in Prism’s API.
-         * It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on
-         * each one of them.
-         *
-         * This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.
-         *
-         * @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.
-         * @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.
-         * @memberof Prism
-         * @public
-         */
-        highlightAll: function(a, n) {
-          r.highlightAllUnder(document, a, n);
-        },
-        /**
-         * Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls
-         * {@link Prism.highlightElement} on each one of them.
-         *
-         * The following hooks will be run:
-         * 1. `before-highlightall`
-         * 2. `before-all-elements-highlight`
-         * 3. All hooks of {@link Prism.highlightElement} for each element.
-         *
-         * @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted.
-         * @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers.
-         * @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done.
-         * @memberof Prism
-         * @public
-         */
-        highlightAllUnder: function(a, n, i) {
-          var u = {
-            callback: i,
-            container: a,
-            selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
-          };
-          r.hooks.run("before-highlightall", u), u.elements = Array.prototype.slice.apply(u.container.querySelectorAll(u.selector)), r.hooks.run("before-all-elements-highlight", u);
-          for (var l = 0, f; f = u.elements[l++]; )
-            r.highlightElement(f, n === !0, u.callback);
-        },
-        /**
-         * Highlights the code inside a single element.
-         *
-         * The following hooks will be run:
-         * 1. `before-sanity-check`
-         * 2. `before-highlight`
-         * 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.
-         * 4. `before-insert`
-         * 5. `after-highlight`
-         * 6. `complete`
-         *
-         * Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for
-         * the element's language.
-         *
-         * @param {Element} element The element containing the code.
-         * It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.
-         * @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers
-         * to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is
-         * [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default).
-         *
-         * Note: All language definitions required to highlight the code must be included in the main `prism.js` file for
-         * asynchronous highlighting to work. You can build your own bundle on the
-         * [Download page](https://prismjs.com/download.html).
-         * @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done.
-         * Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.
-         * @memberof Prism
-         * @public
-         */
-        highlightElement: function(a, n, i) {
-          var u = r.util.getLanguage(a), l = r.languages[u];
-          r.util.setLanguage(a, u);
-          var f = a.parentElement;
-          f && f.nodeName.toLowerCase() === "pre" && r.util.setLanguage(f, u);
-          var A = a.textContent, g = {
-            element: a,
-            language: u,
-            grammar: l,
-            code: A
-          };
-          function k(N) {
-            g.highlightedCode = N, r.hooks.run("before-insert", g), g.element.innerHTML = g.highlightedCode, r.hooks.run("after-highlight", g), r.hooks.run("complete", g), i && i.call(g.element);
-          }
-          if (r.hooks.run("before-sanity-check", g), f = g.element.parentElement, f && f.nodeName.toLowerCase() === "pre" && !f.hasAttribute("tabindex") && f.setAttribute("tabindex", "0"), !g.code) {
-            r.hooks.run("complete", g), i && i.call(g.element);
-            return;
-          }
-          if (r.hooks.run("before-highlight", g), !g.grammar) {
-            k(r.util.encode(g.code));
-            return;
-          }
-          if (n && s.Worker) {
-            var T = new Worker(r.filename);
-            T.onmessage = function(N) {
-              k(N.data);
-            }, T.postMessage(JSON.stringify({
-              language: g.language,
-              code: g.code,
-              immediateClose: !0
-            }));
-          } else
-            k(r.highlight(g.code, g.grammar, g.language));
-        },
-        /**
-         * Low-level function, only use if you know what you’re doing. It accepts a string of text as input
-         * and the language definitions to use, and returns a string with the HTML produced.
-         *
-         * The following hooks will be run:
-         * 1. `before-tokenize`
-         * 2. `after-tokenize`
-         * 3. `wrap`: On each {@link Token}.
-         *
-         * @param {string} text A string with the code to be highlighted.
-         * @param {Grammar} grammar An object containing the tokens to use.
-         *
-         * Usually a language definition like `Prism.languages.markup`.
-         * @param {string} language The name of the language definition passed to `grammar`.
-         * @returns {string} The highlighted HTML.
-         * @memberof Prism
-         * @public
-         * @example
-         * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
-         */
-        highlight: function(a, n, i) {
-          var u = {
-            code: a,
-            grammar: n,
-            language: i
-          };
-          if (r.hooks.run("before-tokenize", u), !u.grammar)
-            throw new Error('The language "' + u.language + '" has no grammar.');
-          return u.tokens = r.tokenize(u.code, u.grammar), r.hooks.run("after-tokenize", u), c.stringify(r.util.encode(u.tokens), u.language);
-        },
-        /**
-         * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
-         * and the language definitions to use, and returns an array with the tokenized code.
-         *
-         * When the language definition includes nested tokens, the function is called recursively on each of these tokens.
-         *
-         * This method could be useful in other contexts as well, as a very crude parser.
-         *
-         * @param {string} text A string with the code to be highlighted.
-         * @param {Grammar} grammar An object containing the tokens to use.
-         *
-         * Usually a language definition like `Prism.languages.markup`.
-         * @returns {TokenStream} An array of strings and tokens, a token stream.
-         * @memberof Prism
-         * @public
-         * @example
-         * let code = `var foo = 0;`;
-         * let tokens = Prism.tokenize(code, Prism.languages.javascript);
-         * tokens.forEach(token => {
-         *     if (token instanceof Prism.Token && token.type === 'number') {
-         *         console.log(`Found numeric literal: ${token.content}`);
-         *     }
-         * });
-         */
-        tokenize: function(a, n) {
-          var i = n.rest;
-          if (i) {
-            for (var u in i)
-              n[u] = i[u];
-            delete n.rest;
-          }
-          var l = new p();
-          return _(l, l.head, a), m(a, l, n, l.head, 0), x(l);
-        },
-        /**
-         * @namespace
-         * @memberof Prism
-         * @public
-         */
-        hooks: {
-          all: {},
-          /**
-           * Adds the given callback to the list of callbacks for the given hook.
-           *
-           * The callback will be invoked when the hook it is registered for is run.
-           * Hooks are usually directly run by a highlight function but you can also run hooks yourself.
-           *
-           * One callback function can be registered to multiple hooks and the same hook multiple times.
-           *
-           * @param {string} name The name of the hook.
-           * @param {HookCallback} callback The callback function which is given environment variables.
-           * @public
-           */
-          add: function(a, n) {
-            var i = r.hooks.all;
-            i[a] = i[a] || [], i[a].push(n);
-          },
-          /**
-           * Runs a hook invoking all registered callbacks with the given environment variables.
-           *
-           * Callbacks will be invoked synchronously and in the order in which they were registered.
-           *
-           * @param {string} name The name of the hook.
-           * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
-           * @public
-           */
-          run: function(a, n) {
-            var i = r.hooks.all[a];
-            if (!(!i || !i.length))
-              for (var u = 0, l; l = i[u++]; )
-                l(n);
-          }
-        },
-        Token: c
-      };
-      s.Prism = r;
-      function c(a, n, i, u) {
-        this.type = a, this.content = n, this.alias = i, this.length = (u || "").length | 0;
-      }
-      c.stringify = function a(n, i) {
-        if (typeof n == "string")
-          return n;
-        if (Array.isArray(n)) {
-          var u = "";
-          return n.forEach(function(k) {
-            u += a(k, i);
-          }), u;
-        }
-        var l = {
-          type: n.type,
-          content: a(n.content, i),
-          tag: "span",
-          classes: ["token", n.type],
-          attributes: {},
-          language: i
-        }, f = n.alias;
-        f && (Array.isArray(f) ? Array.prototype.push.apply(l.classes, f) : l.classes.push(f)), r.hooks.run("wrap", l);
-        var A = "";
-        for (var g in l.attributes)
-          A += " " + g + '="' + (l.attributes[g] || "").replace(/"/g, "&quot;") + '"';
-        return "<" + l.tag + ' class="' + l.classes.join(" ") + '"' + A + ">" + l.content + "</" + l.tag + ">";
-      };
-      function d(a, n, i, u) {
-        a.lastIndex = n;
-        var l = a.exec(i);
-        if (l && u && l[1]) {
-          var f = l[1].length;
-          l.index += f, l[0] = l[0].slice(f);
-        }
-        return l;
-      }
-      function m(a, n, i, u, l, f) {
-        for (var A in i)
-          if (!(!i.hasOwnProperty(A) || !i[A])) {
-            var g = i[A];
-            g = Array.isArray(g) ? g : [g];
-            for (var k = 0; k < g.length; ++k) {
-              if (f && f.cause == A + "," + k)
-                return;
-              var T = g[k], N = T.inside, K = !!T.lookbehind, W = !!T.greedy, me = T.alias;
-              if (W && !T.pattern.global) {
-                var Ee = T.pattern.toString().match(/[imsuy]*$/)[0];
-                T.pattern = RegExp(T.pattern.source, Ee + "g");
-              }
-              for (var J = T.pattern || T, F = u.next, I = l; F !== n.tail && !(f && I >= f.reach); I += F.value.length, F = F.next) {
-                var C = F.value;
-                if (n.length > a.length)
-                  return;
-                if (!(C instanceof c)) {
-                  var z = 1, R;
-                  if (W) {
-                    if (R = d(J, I, a, K), !R || R.index >= a.length)
-                      break;
-                    var M = R.index, ye = R.index + R[0].length, O = I;
-                    for (O += F.value.length; M >= O; )
-                      F = F.next, O += F.value.length;
-                    if (O -= F.value.length, I = O, F.value instanceof c)
-                      continue;
-                    for (var P = F; P !== n.tail && (O < ye || typeof P.value == "string"); P = P.next)
-                      z++, O += P.value.length;
-                    z--, C = a.slice(I, O), R.index -= I;
-                  } else if (R = d(J, 0, C, K), !R)
-                    continue;
-                  var M = R.index, B = R[0], G = C.slice(0, M), Q = C.slice(M + B.length), j = I + C.length;
-                  f && j > f.reach && (f.reach = j);
-                  var U = F.prev;
-                  G && (U = _(n, U, G), I += G.length), w(n, U, z);
-                  var Se = new c(A, N ? r.tokenize(B, N) : B, me, B);
-                  if (F = _(n, U, Se), Q && _(n, F, Q), z > 1) {
-                    var q = {
-                      cause: A + "," + k,
-                      reach: j
-                    };
-                    m(a, n, i, F.prev, I, q), f && q.reach > f.reach && (f.reach = q.reach);
-                  }
-                }
-              }
-            }
-          }
-      }
-      function p() {
-        var a = { value: null, prev: null, next: null }, n = { value: null, prev: a, next: null };
-        a.next = n, this.head = a, this.tail = n, this.length = 0;
-      }
-      function _(a, n, i) {
-        var u = n.next, l = { value: i, prev: n, next: u };
-        return n.next = l, u.prev = l, a.length++, l;
-      }
-      function w(a, n, i) {
-        for (var u = n.next, l = 0; l < i && u !== a.tail; l++)
-          u = u.next;
-        n.next = u, u.prev = n, a.length -= l;
-      }
-      function x(a) {
-        for (var n = [], i = a.head.next; i !== a.tail; )
-          n.push(i.value), i = i.next;
-        return n;
-      }
-      if (!s.document)
-        return s.addEventListener && (r.disableWorkerMessageHandler || s.addEventListener("message", function(a) {
-          var n = JSON.parse(a.data), i = n.language, u = n.code, l = n.immediateClose;
-          s.postMessage(r.highlight(u, r.languages[i], i)), l && s.close();
-        }, !1)), r;
-      var v = r.util.currentScript();
-      v && (r.filename = v.src, v.hasAttribute("data-manual") && (r.manual = !0));
-      function y() {
-        r.manual || r.highlightAll();
-      }
-      if (!r.manual) {
-        var S = document.readyState;
-        S === "loading" || S === "interactive" && v && v.defer ? document.addEventListener("DOMContentLoaded", y) : window.requestAnimationFrame ? window.requestAnimationFrame(y) : window.setTimeout(y, 16);
-      }
-      return r;
-    })(o);
-    e.exports && (e.exports = t), typeof te < "u" && (te.Prism = t), t.languages.markup = {
-      comment: {
-        pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
-        greedy: !0
-      },
-      prolog: {
-        pattern: /<\?[\s\S]+?\?>/,
-        greedy: !0
-      },
-      doctype: {
-        // https://www.w3.org/TR/xml/#NT-doctypedecl
-        pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
-        greedy: !0,
-        inside: {
-          "internal-subset": {
-            pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
-            lookbehind: !0,
-            greedy: !0,
-            inside: null
-            // see below
-          },
-          string: {
-            pattern: /"[^"]*"|'[^']*'/,
-            greedy: !0
-          },
-          punctuation: /^<!|>$|[[\]]/,
-          "doctype-tag": /^DOCTYPE/i,
-          name: /[^\s<>'"]+/
-        }
-      },
-      cdata: {
-        pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
-        greedy: !0
-      },
-      tag: {
-        pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
-        greedy: !0,
-        inside: {
-          tag: {
-            pattern: /^<\/?[^\s>\/]+/,
-            inside: {
-              punctuation: /^<\/?/,
-              namespace: /^[^\s>\/:]+:/
-            }
-          },
-          "special-attr": [],
-          "attr-value": {
-            pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
-            inside: {
-              punctuation: [
-                {
-                  pattern: /^=/,
-                  alias: "attr-equals"
-                },
-                {
-                  pattern: /^(\s*)["']|["']$/,
-                  lookbehind: !0
-                }
-              ]
-            }
-          },
-          punctuation: /\/?>/,
-          "attr-name": {
-            pattern: /[^\s>\/]+/,
-            inside: {
-              namespace: /^[^\s>\/:]+:/
-            }
-          }
-        }
-      },
-      entity: [
-        {
-          pattern: /&[\da-z]{1,8};/i,
-          alias: "named-entity"
-        },
-        /&#x?[\da-f]{1,8};/i
-      ]
-    }, t.languages.markup.tag.inside["attr-value"].inside.entity = t.languages.markup.entity, t.languages.markup.doctype.inside["internal-subset"].inside = t.languages.markup, t.hooks.add("wrap", function(s) {
-      s.type === "entity" && (s.attributes.title = s.content.replace(/&amp;/, "&"));
-    }), Object.defineProperty(t.languages.markup.tag, "addInlined", {
-      /**
-       * Adds an inlined language to markup.
-       *
-       * An example of an inlined language is CSS with `<style>` tags.
-       *
-       * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
-       * case insensitive.
-       * @param {string} lang The language key.
-       * @example
-       * addInlined('style', 'css');
-       */
-      value: function(b, E) {
-        var h = {};
-        h["language-" + E] = {
-          pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
-          lookbehind: !0,
-          inside: t.languages[E]
-        }, h.cdata = /^<!\[CDATA\[|\]\]>$/i;
-        var r = {
-          "included-cdata": {
-            pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
-            inside: h
-          }
-        };
-        r["language-" + E] = {
-          pattern: /[\s\S]+/,
-          inside: t.languages[E]
-        };
-        var c = {};
-        c[b] = {
-          pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
-            return b;
-          }), "i"),
-          lookbehind: !0,
-          greedy: !0,
-          inside: r
-        }, t.languages.insertBefore("markup", "cdata", c);
-      }
-    }), Object.defineProperty(t.languages.markup.tag, "addAttribute", {
-      /**
-       * Adds an pattern to highlight languages embedded in HTML attributes.
-       *
-       * An example of an inlined language is CSS with `style` attributes.
-       *
-       * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
-       * case insensitive.
-       * @param {string} lang The language key.
-       * @example
-       * addAttribute('style', 'css');
-       */
-      value: function(s, b) {
-        t.languages.markup.tag.inside["special-attr"].push({
-          pattern: RegExp(
-            /(^|["'\s])/.source + "(?:" + s + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
-            "i"
-          ),
-          lookbehind: !0,
-          inside: {
-            "attr-name": /^[^\s=]+/,
-            "attr-value": {
-              pattern: /=[\s\S]+/,
-              inside: {
-                value: {
-                  pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
-                  lookbehind: !0,
-                  alias: [b, "language-" + b],
-                  inside: t.languages[b]
-                },
-                punctuation: [
-                  {
-                    pattern: /^=/,
-                    alias: "attr-equals"
-                  },
-                  /"|'/
-                ]
-              }
-            }
-          }
-        });
-      }
-    }), t.languages.html = t.languages.markup, t.languages.mathml = t.languages.markup, t.languages.svg = t.languages.markup, t.languages.xml = t.languages.extend("markup", {}), t.languages.ssml = t.languages.xml, t.languages.atom = t.languages.xml, t.languages.rss = t.languages.xml, (function(s) {
-      var b = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
-      s.languages.css = {
-        comment: /\/\*[\s\S]*?\*\//,
-        atrule: {
-          pattern: RegExp("@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + b.source + ")*?" + /(?:;|(?=\s*\{))/.source),
-          inside: {
-            rule: /^@[\w-]+/,
-            "selector-function-argument": {
-              pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
-              lookbehind: !0,
-              alias: "selector"
-            },
-            keyword: {
-              pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
-              lookbehind: !0
-            }
-            // See rest below
-          }
-        },
-        url: {
-          // https://drafts.csswg.org/css-values-3/#urls
-          pattern: RegExp("\\burl\\((?:" + b.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"),
-          greedy: !0,
-          inside: {
-            function: /^url/i,
-            punctuation: /^\(|\)$/,
-            string: {
-              pattern: RegExp("^" + b.source + "$"),
-              alias: "url"
-            }
-          }
-        },
-        selector: {
-          pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + b.source + ")*(?=\\s*\\{)"),
-          lookbehind: !0
-        },
-        string: {
-          pattern: b,
-          greedy: !0
-        },
-        property: {
-          pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
-          lookbehind: !0
-        },
-        important: /!important\b/i,
-        function: {
-          pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
-          lookbehind: !0
-        },
-        punctuation: /[(){};:,]/
-      }, s.languages.css.atrule.inside.rest = s.languages.css;
-      var E = s.languages.markup;
-      E && (E.tag.addInlined("style", "css"), E.tag.addAttribute("style", "css"));
-    })(t), t.languages.clike = {
-      comment: [
-        {
-          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
-          lookbehind: !0,
-          greedy: !0
-        },
-        {
-          pattern: /(^|[^\\:])\/\/.*/,
-          lookbehind: !0,
-          greedy: !0
-        }
-      ],
-      string: {
-        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-        greedy: !0
-      },
-      "class-name": {
-        pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
-        lookbehind: !0,
-        inside: {
-          punctuation: /[.\\]/
-        }
-      },
-      keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
-      boolean: /\b(?:false|true)\b/,
-      function: /\b\w+(?=\()/,
-      number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
-      operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
-      punctuation: /[{}[\];(),.:]/
-    }, t.languages.javascript = t.languages.extend("clike", {
-      "class-name": [
-        t.languages.clike["class-name"],
-        {
-          pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
-          lookbehind: !0
-        }
-      ],
-      keyword: [
-        {
-          pattern: /((?:^|\})\s*)catch\b/,
-          lookbehind: !0
-        },
-        {
-          pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
-          lookbehind: !0
-        }
-      ],
-      // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
-      function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
-      number: {
-        pattern: RegExp(
-          /(^|[^\w$])/.source + "(?:" + // constant
-          (/NaN|Infinity/.source + "|" + // binary integer
-          /0[bB][01]+(?:_[01]+)*n?/.source + "|" + // octal integer
-          /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + // hexadecimal integer
-          /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + // decimal bigint
-          /\d+(?:_\d+)*n/.source + "|" + // decimal number (integer or float) but no bigint
-          /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source
-        ),
-        lookbehind: !0
-      },
-      operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
-    }), t.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, t.languages.insertBefore("javascript", "keyword", {
-      regex: {
-        pattern: RegExp(
-          // lookbehind
-          // eslint-disable-next-line regexp/no-dupe-characters-character-class
-          /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + // Regex pattern:
-          // There are 2 regex patterns here. The RegExp set notation proposal added support for nested character
-          // classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible
-          // with the only syntax, so we have to define 2 different regex patterns.
-          /\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + // `v` flag syntax. This supports 3 levels of nested character classes.
-          /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + // lookahead
-          /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source
-        ),
-        lookbehind: !0,
-        greedy: !0,
-        inside: {
-          "regex-source": {
-            pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
-            lookbehind: !0,
-            alias: "language-regex",
-            inside: t.languages.regex
-          },
-          "regex-delimiter": /^\/|\/$/,
-          "regex-flags": /^[a-z]+$/
-        }
-      },
-      // This must be declared before keyword because we use "function" inside the look-forward
-      "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: t.languages.javascript
-        },
-        {
-          pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
-          lookbehind: !0,
-          inside: t.languages.javascript
-        },
-        {
-          pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
-          lookbehind: !0,
-          inside: t.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: t.languages.javascript
-        }
-      ],
-      constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
-    }), t.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: t.languages.javascript
-            }
-          },
-          string: /[\s\S]+/
-        }
-      },
-      "string-property": {
-        pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
-        lookbehind: !0,
-        greedy: !0,
-        alias: "property"
-      }
-    }), t.languages.insertBefore("javascript", "operator", {
-      "literal-property": {
-        pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
-        lookbehind: !0,
-        alias: "property"
-      }
-    }), t.languages.markup && (t.languages.markup.tag.addInlined("script", "javascript"), t.languages.markup.tag.addAttribute(
-      /on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source,
-      "javascript"
-    )), t.languages.js = t.languages.javascript, (function() {
-      if (typeof t > "u" || typeof document > "u")
-        return;
-      Element.prototype.matches || (Element.prototype.matches = Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector);
-      var s = "Loading…", b = function(v, y) {
-        return "✖ Error " + v + " while fetching file: " + y;
-      }, E = "✖ Error: File does not exist or is empty", h = {
-        js: "javascript",
-        py: "python",
-        rb: "ruby",
-        ps1: "powershell",
-        psm1: "powershell",
-        sh: "bash",
-        bat: "batch",
-        h: "c",
-        tex: "latex"
-      }, r = "data-src-status", c = "loading", d = "loaded", m = "failed", p = "pre[data-src]:not([" + r + '="' + d + '"]):not([' + r + '="' + c + '"])';
-      function _(v, y, S) {
-        var a = new XMLHttpRequest();
-        a.open("GET", v, !0), a.onreadystatechange = function() {
-          a.readyState == 4 && (a.status < 400 && a.responseText ? y(a.responseText) : a.status >= 400 ? S(b(a.status, a.statusText)) : S(E));
-        }, a.send(null);
-      }
-      function w(v) {
-        var y = /^\s*(\d+)\s*(?:(,)\s*(?:(\d+)\s*)?)?$/.exec(v || "");
-        if (y) {
-          var S = Number(y[1]), a = y[2], n = y[3];
-          return a ? n ? [S, Number(n)] : [S, void 0] : [S, S];
-        }
-      }
-      t.hooks.add("before-highlightall", function(v) {
-        v.selector += ", " + p;
-      }), t.hooks.add("before-sanity-check", function(v) {
-        var y = (
-          /** @type {HTMLPreElement} */
-          v.element
-        );
-        if (y.matches(p)) {
-          v.code = "", y.setAttribute(r, c);
-          var S = y.appendChild(document.createElement("CODE"));
-          S.textContent = s;
-          var a = y.getAttribute("data-src"), n = v.language;
-          if (n === "none") {
-            var i = (/\.(\w+)$/.exec(a) || [, "none"])[1];
-            n = h[i] || i;
-          }
-          t.util.setLanguage(S, n), t.util.setLanguage(y, n);
-          var u = t.plugins.autoloader;
-          u && u.loadLanguages(n), _(
-            a,
-            function(l) {
-              y.setAttribute(r, d);
-              var f = w(y.getAttribute("data-range"));
-              if (f) {
-                var A = l.split(/\r\n?|\n/g), g = f[0], k = f[1] == null ? A.length : f[1];
-                g < 0 && (g += A.length), g = Math.max(0, Math.min(g - 1, A.length)), k < 0 && (k += A.length), k = Math.max(0, Math.min(k, A.length)), l = A.slice(g, k).join(`
-`), y.hasAttribute("data-start") || y.setAttribute("data-start", String(g + 1));
-              }
-              S.textContent = l, t.highlightElement(S);
-            },
-            function(l) {
-              y.setAttribute(r, m), S.textContent = l;
-            }
-          );
-        }
-      }), t.plugins.fileHighlight = {
-        /**
-         * Executes the File Highlight plugin for all matching `pre` elements under the given container.
-         *
-         * Note: Elements which are already loaded or currently loading will not be touched by this method.
-         *
-         * @param {ParentNode} [container=document]
-         */
-        highlight: function(y) {
-          for (var S = (y || document).querySelectorAll(p), a = 0, n; n = S[a++]; )
-            t.highlightElement(n);
-        }
-      };
-      var x = !1;
-      t.fileHighlight = function() {
-        x || (console.warn("Prism.fileHighlight is deprecated. Use `Prism.plugins.fileHighlight.highlight` instead."), x = !0), t.plugins.fileHighlight.highlight.apply(this, arguments);
-      };
-    })();
-  })(V)), V.exports;
-}
-var Re = Fe();
-const H = /* @__PURE__ */ xe(Re);
-var ne = {}, re;
-function Ie() {
-  return re || (re = 1, (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
-        // see below
-      },
-      builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
-    }), e.languages.typescript.keyword.push(
-      /\b(?:abstract|declare|is|keyof|readonly|require)\b/,
-      // keywords that have to be followed by an identifier
-      /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
-      // This is for `import type *, {}`
-      /\btype\b(?=\s*(?:[\{*]|$))/
-    ), delete e.languages.typescript.parameter, delete e.languages.typescript["literal-property"];
-    var o = e.languages.extend("typescript", {});
-    delete o["class-name"], e.languages.typescript["class-name"].inside = o, e.languages.insertBefore("typescript", "function", {
-      decorator: {
-        pattern: /@[$\w\xA0-\uFFFF]+/,
-        inside: {
-          at: {
-            pattern: /^@/,
-            alias: "operator"
-          },
-          function: /^[\s\S]+/
-        }
-      },
-      "generic-function": {
-        // e.g. foo<T extends "bar" | "baz">( ...
-        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]+/,
-            // everything after the first <
-            alias: "class-name",
-            inside: o
-          }
-        }
-      }
-    }), e.languages.ts = e.languages.typescript;
-  })(Prism)), ne;
-}
-Ie();
-Prism.languages.javascript = Prism.languages.extend("clike", {
-  "class-name": [
-    Prism.languages.clike["class-name"],
-    {
-      pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
-      lookbehind: !0
-    }
-  ],
-  keyword: [
-    {
-      pattern: /((?:^|\})\s*)catch\b/,
-      lookbehind: !0
-    },
-    {
-      pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
-      lookbehind: !0
-    }
-  ],
-  // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
-  function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
-  number: {
-    pattern: RegExp(
-      /(^|[^\w$])/.source + "(?:" + // constant
-      (/NaN|Infinity/.source + "|" + // binary integer
-      /0[bB][01]+(?:_[01]+)*n?/.source + "|" + // octal integer
-      /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + // hexadecimal integer
-      /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + // decimal bigint
-      /\d+(?:_\d+)*n/.source + "|" + // decimal number (integer or float) but no bigint
-      /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source
-    ),
-    lookbehind: !0
-  },
-  operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
-});
-Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
-Prism.languages.insertBefore("javascript", "keyword", {
-  regex: {
-    pattern: RegExp(
-      // lookbehind
-      // eslint-disable-next-line regexp/no-dupe-characters-character-class
-      /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + // Regex pattern:
-      // There are 2 regex patterns here. The RegExp set notation proposal added support for nested character
-      // classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible
-      // with the only syntax, so we have to define 2 different regex patterns.
-      /\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + // `v` flag syntax. This supports 3 levels of nested character classes.
-      /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + // lookahead
-      /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source
-    ),
-    lookbehind: !0,
-    greedy: !0,
-    inside: {
-      "regex-source": {
-        pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
-        lookbehind: !0,
-        alias: "language-regex",
-        inside: Prism.languages.regex
-      },
-      "regex-delimiter": /^\/|\/$/,
-      "regex-flags": /^[a-z]+$/
-    }
-  },
-  // This must be declared before keyword because we use "function" inside the look-forward
-  "function-variable": {
-    pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
-    alias: "function"
-  },
-  parameter: [
-    {
-      pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
-      lookbehind: !0,
-      inside: Prism.languages.javascript
-    },
-    {
-      pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
-      lookbehind: !0,
-      inside: Prism.languages.javascript
-    },
-    {
-      pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
-      lookbehind: !0,
-      inside: Prism.languages.javascript
-    },
-    {
-      pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
-      lookbehind: !0,
-      inside: Prism.languages.javascript
-    }
-  ],
-  constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
-});
-Prism.languages.insertBefore("javascript", "string", {
-  hashbang: {
-    pattern: /^#!.*/,
-    greedy: !0,
-    alias: "comment"
-  },
-  "template-string": {
-    pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
-    greedy: !0,
-    inside: {
-      "template-punctuation": {
-        pattern: /^`|`$/,
-        alias: "string"
-      },
-      interpolation: {
-        pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
-        lookbehind: !0,
-        inside: {
-          "interpolation-punctuation": {
-            pattern: /^\$\{|\}$/,
-            alias: "punctuation"
-          },
-          rest: Prism.languages.javascript
-        }
-      },
-      string: /[\s\S]+/
-    }
-  },
-  "string-property": {
-    pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
-    lookbehind: !0,
-    greedy: !0,
-    alias: "property"
-  }
-});
-Prism.languages.insertBefore("javascript", "operator", {
-  "literal-property": {
-    pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
-    lookbehind: !0,
-    alias: "property"
-  }
-});
-Prism.languages.markup && (Prism.languages.markup.tag.addInlined("script", "javascript"), Prism.languages.markup.tag.addAttribute(
-  /on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source,
-  "javascript"
-));
-Prism.languages.js = Prism.languages.javascript;
-(function(e) {
-  var o = e.util.clone(e.languages.javascript), t = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source, s = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source, b = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
-  function E(c, d) {
-    return c = c.replace(/<S>/g, function() {
-      return t;
-    }).replace(/<BRACES>/g, function() {
-      return s;
-    }).replace(/<SPREAD>/g, function() {
-      return b;
-    }), RegExp(c, d);
-  }
-  b = E(b).source, e.languages.jsx = e.languages.extend("markup", o), e.languages.jsx.tag.pattern = E(
-    /<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source
-  ), e.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/, e.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/, e.languages.jsx.tag.inside.tag.inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/, e.languages.jsx.tag.inside.comment = o.comment, e.languages.insertBefore("inside", "attr-name", {
-    spread: {
-      pattern: E(/<SPREAD>/.source),
-      inside: e.languages.jsx
-    }
-  }, e.languages.jsx.tag), e.languages.insertBefore("inside", "special-attr", {
-    script: {
-      // Allow for two levels of nesting
-      pattern: E(/=<BRACES>/.source),
-      alias: "language-javascript",
-      inside: {
-        "script-punctuation": {
-          pattern: /^=(?=\{)/,
-          alias: "punctuation"
-        },
-        rest: e.languages.jsx
-      }
-    }
-  }, e.languages.jsx.tag);
-  var h = function(c) {
-    return c ? typeof c == "string" ? c : typeof c.content == "string" ? c.content : c.content.map(h).join("") : "";
-  }, r = function(c) {
-    for (var d = [], m = 0; m < c.length; m++) {
-      var p = c[m], _ = !1;
-      if (typeof p != "string" && (p.type === "tag" && p.content[0] && p.content[0].type === "tag" ? p.content[0].content[0].content === "</" ? d.length > 0 && d[d.length - 1].tagName === h(p.content[0].content[1]) && d.pop() : p.content[p.content.length - 1].content === "/>" || d.push({
-        tagName: h(p.content[0].content[1]),
-        openedBraces: 0
-      }) : d.length > 0 && p.type === "punctuation" && p.content === "{" ? d[d.length - 1].openedBraces++ : d.length > 0 && d[d.length - 1].openedBraces > 0 && p.type === "punctuation" && p.content === "}" ? d[d.length - 1].openedBraces-- : _ = !0), (_ || typeof p == "string") && d.length > 0 && d[d.length - 1].openedBraces === 0) {
-        var w = h(p);
-        m < c.length - 1 && (typeof c[m + 1] == "string" || c[m + 1].type === "plain-text") && (w += h(c[m + 1]), c.splice(m + 1, 1)), m > 0 && (typeof c[m - 1] == "string" || c[m - 1].type === "plain-text") && (w = h(c[m - 1]) + w, c.splice(m - 1, 1), m--), c[m] = new e.Token("plain-text", w, null, w);
-      }
-      p.content && typeof p.content != "string" && r(p.content);
-    }
-  };
-  e.hooks.add("after-tokenize", function(c) {
-    c.language !== "jsx" && c.language !== "tsx" || r(c.tokens);
-  });
-})(Prism);
-(function(e) {
-  var o = e.util.clone(e.languages.typescript);
-  e.languages.tsx = e.languages.extend("jsx", o), delete e.languages.tsx.parameter, delete e.languages.tsx["literal-property"];
-  var t = e.languages.tsx.tag;
-  t.pattern = RegExp(/(^|[^\w$]|(?=<\/))/.source + "(?:" + t.pattern.source + ")", t.pattern.flags), t.lookbehind = !0;
-})(Prism);
-Prism.languages.json = {
-  property: {
-    pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
-    lookbehind: !0,
-    greedy: !0
-  },
-  string: {
-    pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
-    lookbehind: !0,
-    greedy: !0
-  },
-  comment: {
-    pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
-    greedy: !0
-  },
-  number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
-  punctuation: /[{}[\],]/,
-  operator: /:/,
-  boolean: /\b(?:false|true)\b/,
-  null: {
-    pattern: /\bnull\b/,
-    alias: "keyword"
-  }
-};
-Prism.languages.webmanifest = Prism.languages.json;
-var se = {}, ie;
-function Ne() {
-  return ie || (ie = 1, Prism.languages.python = {
-    comment: {
-      pattern: /(^|[^\\])#.*/,
-      lookbehind: !0,
-      greedy: !0
-    },
-    "string-interpolation": {
-      pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
-      greedy: !0,
-      inside: {
-        interpolation: {
-          // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
-          pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
-          lookbehind: !0,
-          inside: {
-            "format-spec": {
-              pattern: /(:)[^:(){}]+(?=\}$)/,
-              lookbehind: !0
-            },
-            "conversion-option": {
-              pattern: /![sra](?=[:}]$)/,
-              alias: "punctuation"
-            },
-            rest: null
-          }
-        },
-        string: /[\s\S]+/
-      }
-    },
-    "triple-quoted-string": {
-      pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
-      greedy: !0,
-      alias: "string"
-    },
-    string: {
-      pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
-      greedy: !0
-    },
-    function: {
-      pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
-      lookbehind: !0
-    },
-    "class-name": {
-      pattern: /(\bclass\s+)\w+/i,
-      lookbehind: !0
-    },
-    decorator: {
-      pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
-      lookbehind: !0,
-      alias: ["annotation", "punctuation"],
-      inside: {
-        punctuation: /\./
-      }
-    },
-    keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
-    builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
-    boolean: /\b(?:False|None|True)\b/,
-    number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
-    operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
-    punctuation: /[{}[\];(),.:]/
-  }, Prism.languages.python["string-interpolation"].inside.interpolation.inside.rest = Prism.languages.python, Prism.languages.py = Prism.languages.python), se;
-}
-Ne();
-(function(e) {
-  var o = "\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b", t = {
-    pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
-    lookbehind: !0,
-    alias: "punctuation",
-    // this looks reasonably well in all themes
-    inside: null
-    // see below
-  }, s = {
-    bash: t,
-    environment: {
-      pattern: RegExp("\\$" + o),
-      alias: "constant"
-    },
-    variable: [
-      // [0]: Arithmetic Environment
-      {
-        pattern: /\$?\(\([\s\S]+?\)\)/,
-        greedy: !0,
-        inside: {
-          // If there is a $ sign at the beginning highlight $(( and )) as variable
-          variable: [
-            {
-              pattern: /(^\$\(\([\s\S]+)\)\)/,
-              lookbehind: !0
-            },
-            /^\$\(\(/
-          ],
-          number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
-          // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
-          operator: /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
-          // If there is no $ sign at the beginning highlight (( and )) as punctuation
-          punctuation: /\(\(?|\)\)?|,|;/
-        }
-      },
-      // [1]: Command Substitution
-      {
-        pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
-        greedy: !0,
-        inside: {
-          variable: /^\$\(|^`|\)$|`$/
-        }
-      },
-      // [2]: Brace expansion
-      {
-        pattern: /\$\{[^}]+\}/,
-        greedy: !0,
-        inside: {
-          operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
-          punctuation: /[\[\]]/,
-          environment: {
-            pattern: RegExp("(\\{)" + o),
-            lookbehind: !0,
-            alias: "constant"
-          }
-        }
-      },
-      /\$(?:\w+|[#?*!@$])/
-    ],
-    // Escape sequences from echo and printf's manuals, and escaped quotes.
-    entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
-  };
-  e.languages.bash = {
-    shebang: {
-      pattern: /^#!\s*\/.*/,
-      alias: "important"
-    },
-    comment: {
-      pattern: /(^|[^"{\\$])#.*/,
-      lookbehind: !0
-    },
-    "function-name": [
-      // a) function foo {
-      // b) foo() {
-      // c) function foo() {
-      // but not “foo {”
-      {
-        // a) and c)
-        pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
-        lookbehind: !0,
-        alias: "function"
-      },
-      {
-        // b)
-        pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
-        alias: "function"
-      }
-    ],
-    // Highlight variable names as variables in for and select beginnings.
-    "for-or-select": {
-      pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
-      alias: "variable",
-      lookbehind: !0
-    },
-    // Highlight variable names as variables in the left-hand part
-    // of assignments (“=” and “+=”).
-    "assign-left": {
-      pattern: /(^|[\s;|&]|[<>]\()\w+(?:\.\w+)*(?=\+?=)/,
-      inside: {
-        environment: {
-          pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + o),
-          lookbehind: !0,
-          alias: "constant"
-        }
-      },
-      alias: "variable",
-      lookbehind: !0
-    },
-    // Highlight parameter names as variables
-    parameter: {
-      pattern: /(^|\s)-{1,2}(?:\w+:[+-]?)?\w+(?:\.\w+)*(?=[=\s]|$)/,
-      alias: "variable",
-      lookbehind: !0
-    },
-    string: [
-      // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
-      {
-        pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: s
-      },
-      // Here-document with quotes around the tag
-      // → No expansion (so no “inside”).
-      {
-        pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: {
-          bash: t
-        }
-      },
-      // “Normal” string
-      {
-        // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
-        pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: s
-      },
-      {
-        // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
-        pattern: /(^|[^$\\])'[^']*'/,
-        lookbehind: !0,
-        greedy: !0
-      },
-      {
-        // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
-        pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
-        greedy: !0,
-        inside: {
-          entity: s.entity
-        }
-      }
-    ],
-    environment: {
-      pattern: RegExp("\\$?" + o),
-      alias: "constant"
-    },
-    variable: s.variable,
-    function: {
-      pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cargo|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|java|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|sysctl|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
-      lookbehind: !0
-    },
-    keyword: {
-      pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
-      lookbehind: !0
-    },
-    // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
-    builtin: {
-      pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
-      lookbehind: !0,
-      // Alias added to make those easier to distinguish from strings.
-      alias: "class-name"
-    },
-    boolean: {
-      pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
-      lookbehind: !0
-    },
-    "file-descriptor": {
-      pattern: /\B&\d\b/,
-      alias: "important"
-    },
-    operator: {
-      // Lots of redirections here, but not just that.
-      pattern: /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
-      inside: {
-        "file-descriptor": {
-          pattern: /^\d/,
-          alias: "important"
-        }
-      }
-    },
-    punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
-    number: {
-      pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
-      lookbehind: !0
-    }
-  }, t.inside = e.languages.bash;
-  for (var b = [
-    "comment",
-    "function-name",
-    "for-or-select",
-    "assign-left",
-    "parameter",
-    "string",
-    "environment",
-    "function",
-    "keyword",
-    "builtin",
-    "boolean",
-    "file-descriptor",
-    "operator",
-    "punctuation",
-    "number"
-  ], E = s.variable[1].inside, h = 0; h < b.length; h++)
-    E[b[h]] = e.languages.bash[b[h]];
-  e.languages.sh = e.languages.bash, e.languages.shell = e.languages.bash;
-})(Prism);
-Prism.languages.markup = {
-  comment: {
-    pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
-    greedy: !0
-  },
-  prolog: {
-    pattern: /<\?[\s\S]+?\?>/,
-    greedy: !0
-  },
-  doctype: {
-    // https://www.w3.org/TR/xml/#NT-doctypedecl
-    pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
-    greedy: !0,
-    inside: {
-      "internal-subset": {
-        pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: null
-        // see below
-      },
-      string: {
-        pattern: /"[^"]*"|'[^']*'/,
-        greedy: !0
-      },
-      punctuation: /^<!|>$|[[\]]/,
-      "doctype-tag": /^DOCTYPE/i,
-      name: /[^\s<>'"]+/
-    }
-  },
-  cdata: {
-    pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
-    greedy: !0
-  },
-  tag: {
-    pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
-    greedy: !0,
-    inside: {
-      tag: {
-        pattern: /^<\/?[^\s>\/]+/,
-        inside: {
-          punctuation: /^<\/?/,
-          namespace: /^[^\s>\/:]+:/
-        }
-      },
-      "special-attr": [],
-      "attr-value": {
-        pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
-        inside: {
-          punctuation: [
-            {
-              pattern: /^=/,
-              alias: "attr-equals"
-            },
-            {
-              pattern: /^(\s*)["']|["']$/,
-              lookbehind: !0
-            }
-          ]
-        }
-      },
-      punctuation: /\/?>/,
-      "attr-name": {
-        pattern: /[^\s>\/]+/,
-        inside: {
-          namespace: /^[^\s>\/:]+:/
-        }
-      }
-    }
-  },
-  entity: [
-    {
-      pattern: /&[\da-z]{1,8};/i,
-      alias: "named-entity"
-    },
-    /&#x?[\da-f]{1,8};/i
-  ]
-};
-Prism.languages.markup.tag.inside["attr-value"].inside.entity = Prism.languages.markup.entity;
-Prism.languages.markup.doctype.inside["internal-subset"].inside = Prism.languages.markup;
-Prism.hooks.add("wrap", function(e) {
-  e.type === "entity" && (e.attributes.title = e.content.replace(/&amp;/, "&"));
-});
-Object.defineProperty(Prism.languages.markup.tag, "addInlined", {
-  /**
-   * Adds an inlined language to markup.
-   *
-   * An example of an inlined language is CSS with `<style>` tags.
-   *
-   * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
-   * case insensitive.
-   * @param {string} lang The language key.
-   * @example
-   * addInlined('style', 'css');
-   */
-  value: function(o, t) {
-    var s = {};
-    s["language-" + t] = {
-      pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
-      lookbehind: !0,
-      inside: Prism.languages[t]
-    }, s.cdata = /^<!\[CDATA\[|\]\]>$/i;
-    var b = {
-      "included-cdata": {
-        pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
-        inside: s
-      }
-    };
-    b["language-" + t] = {
-      pattern: /[\s\S]+/,
-      inside: Prism.languages[t]
-    };
-    var E = {};
-    E[o] = {
-      pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
-        return o;
-      }), "i"),
-      lookbehind: !0,
-      greedy: !0,
-      inside: b
-    }, Prism.languages.insertBefore("markup", "cdata", E);
-  }
-});
-Object.defineProperty(Prism.languages.markup.tag, "addAttribute", {
-  /**
-   * Adds an pattern to highlight languages embedded in HTML attributes.
-   *
-   * An example of an inlined language is CSS with `style` attributes.
-   *
-   * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
-   * case insensitive.
-   * @param {string} lang The language key.
-   * @example
-   * addAttribute('style', 'css');
-   */
-  value: function(e, o) {
-    Prism.languages.markup.tag.inside["special-attr"].push({
-      pattern: RegExp(
-        /(^|["'\s])/.source + "(?:" + e + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
-        "i"
-      ),
-      lookbehind: !0,
-      inside: {
-        "attr-name": /^[^\s=]+/,
-        "attr-value": {
-          pattern: /=[\s\S]+/,
-          inside: {
-            value: {
-              pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
-              lookbehind: !0,
-              alias: [o, "language-" + o],
-              inside: Prism.languages[o]
-            },
-            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(e) {
-  var o = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
-  e.languages.css = {
-    comment: /\/\*[\s\S]*?\*\//,
-    atrule: {
-      pattern: RegExp("@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + o.source + ")*?" + /(?:;|(?=\s*\{))/.source),
-      inside: {
-        rule: /^@[\w-]+/,
-        "selector-function-argument": {
-          pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
-          lookbehind: !0,
-          alias: "selector"
-        },
-        keyword: {
-          pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
-          lookbehind: !0
-        }
-        // See rest below
-      }
-    },
-    url: {
-      // https://drafts.csswg.org/css-values-3/#urls
-      pattern: RegExp("\\burl\\((?:" + o.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"),
-      greedy: !0,
-      inside: {
-        function: /^url/i,
-        punctuation: /^\(|\)$/,
-        string: {
-          pattern: RegExp("^" + o.source + "$"),
-          alias: "url"
-        }
-      }
-    },
-    selector: {
-      pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + o.source + ")*(?=\\s*\\{)"),
-      lookbehind: !0
-    },
-    string: {
-      pattern: o,
-      greedy: !0
-    },
-    property: {
-      pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
-      lookbehind: !0
-    },
-    important: /!important\b/i,
-    function: {
-      pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
-      lookbehind: !0
-    },
-    punctuation: /[(){};:,]/
-  }, e.languages.css.atrule.inside.rest = e.languages.css;
-  var t = e.languages.markup;
-  t && (t.tag.addInlined("style", "css"), t.tag.addAttribute("style", "css"));
-})(Prism);
-var oe = {}, ue;
-function Oe() {
-  return ue || (ue = 1, (function(e) {
-    var o = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/, t = /(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source, s = {
-      pattern: RegExp(/(^|[^\w.])/.source + t + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
-      lookbehind: !0,
-      inside: {
-        namespace: {
-          pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
-          inside: {
-            punctuation: /\./
-          }
-        },
-        punctuation: /\./
-      }
-    };
-    e.languages.java = e.languages.extend("clike", {
-      string: {
-        pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
-        lookbehind: !0,
-        greedy: !0
-      },
-      "class-name": [
-        s,
-        {
-          // variables, parameters, and constructor references
-          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
-          pattern: RegExp(/(^|[^\w.])/.source + t + /[A-Z]\w*(?=\s+\w+\s*[;,=()]|\s*(?:\[[\s,]*\]\s*)?::\s*new\b)/.source),
-          lookbehind: !0,
-          inside: s.inside
-        },
-        {
-          // class names based on keyword
-          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
-          pattern: RegExp(/(\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\s+)/.source + t + /[A-Z]\w*\b/.source),
-          lookbehind: !0,
-          inside: s.inside
-        }
-      ],
-      keyword: o,
-      function: [
-        e.languages.clike.function,
-        {
-          pattern: /(::\s*)[a-z_]\w*/,
-          lookbehind: !0
-        }
-      ],
-      number: /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
-      operator: {
-        pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
-        lookbehind: !0
-      },
-      constant: /\b[A-Z][A-Z_\d]+\b/
-    }), e.languages.insertBefore("java", "string", {
-      "triple-quoted-string": {
-        // http://openjdk.java.net/jeps/355#Description
-        pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
-        greedy: !0,
-        alias: "string"
-      },
-      char: {
-        pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
-        greedy: !0
-      }
-    }), e.languages.insertBefore("java", "class-name", {
-      annotation: {
-        pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
-        lookbehind: !0,
-        alias: "punctuation"
-      },
-      generics: {
-        pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
-        inside: {
-          "class-name": s,
-          keyword: o,
-          punctuation: /[<>(),.:]/,
-          operator: /[?&|]/
-        }
-      },
-      import: [
-        {
-          pattern: RegExp(/(\bimport\s+)/.source + t + /(?:[A-Z]\w*|\*)(?=\s*;)/.source),
-          lookbehind: !0,
-          inside: {
-            namespace: s.inside.namespace,
-            punctuation: /\./,
-            operator: /\*/,
-            "class-name": /\w+/
-          }
-        },
-        {
-          pattern: RegExp(/(\bimport\s+static\s+)/.source + t + /(?:\w+|\*)(?=\s*;)/.source),
-          lookbehind: !0,
-          alias: "static",
-          inside: {
-            namespace: s.inside.namespace,
-            static: /\b\w+$/,
-            punctuation: /\./,
-            operator: /\*/,
-            "class-name": /\w+/
-          }
-        }
-      ],
-      namespace: {
-        pattern: RegExp(
-          /(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!<keyword>)[a-z]\w*(?:\.[a-z]\w*)*\.?/.source.replace(/<keyword>/g, function() {
-            return o.source;
-          })
-        ),
-        lookbehind: !0,
-        inside: {
-          punctuation: /\./
-        }
-      }
-    });
-  })(Prism)), oe;
-}
-Oe();
-Prism.languages.c = Prism.languages.extend("clike", {
-  comment: {
-    pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
-    greedy: !0
-  },
-  string: {
-    // https://en.cppreference.com/w/c/language/string_literal
-    pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
-    greedy: !0
-  },
-  "class-name": {
-    pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
-    lookbehind: !0
-  },
-  keyword: /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
-  function: /\b[a-z_]\w*(?=\s*\()/i,
-  number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
-  operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
-});
-Prism.languages.insertBefore("c", "string", {
-  char: {
-    // https://en.cppreference.com/w/c/language/character_constant
-    pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
-    greedy: !0
-  }
-});
-Prism.languages.insertBefore("c", "string", {
-  macro: {
-    // allow for multiline macro definitions
-    // spaces after the # character compile fine with gcc
-    pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
-    lookbehind: !0,
-    greedy: !0,
-    alias: "property",
-    inside: {
-      string: [
-        {
-          // highlight the path of the include statement as a string
-          pattern: /^(#\s*include\s*)<[^>]+>/,
-          lookbehind: !0
-        },
-        Prism.languages.c.string
-      ],
-      char: Prism.languages.c.char,
-      comment: Prism.languages.c.comment,
-      "macro-name": [
-        {
-          pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
-          lookbehind: !0
-        },
-        {
-          pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
-          lookbehind: !0,
-          alias: "function"
-        }
-      ],
-      // highlight macro directives as keywords
-      directive: {
-        pattern: /^(#\s*)[a-z]+/,
-        lookbehind: !0,
-        alias: "keyword"
-      },
-      "directive-hash": /^#/,
-      punctuation: /##|\\(?=[\r\n])/,
-      expression: {
-        pattern: /\S[\s\S]*/,
-        inside: Prism.languages.c
-      }
-    }
-  }
-});
-Prism.languages.insertBefore("c", "function", {
-  // highlight predefined macros as constants
-  constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/
-});
-delete Prism.languages.c.boolean;
-var le = {}, ce;
-function Le() {
-  return ce || (ce = 1, (function(e) {
-    var o = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/, t = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(/<keyword>/g, function() {
-      return o.source;
-    });
-    e.languages.cpp = e.languages.extend("c", {
-      "class-name": [
-        {
-          pattern: RegExp(/(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(/<keyword>/g, function() {
-            return o.source;
-          })),
-          lookbehind: !0
-        },
-        // This is intended to capture the class name of method implementations like:
-        //   void foo::bar() const {}
-        // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
-        // it starts with an uppercase letter. This approximation should give decent results.
-        /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,
-        // This will capture the class name before destructors like:
-        //   Foo::~Foo() {}
-        /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i,
-        // This also intends to capture the class name of method implementations but here the class has template
-        // parameters, so it can't be a namespace (until C++ adds generic namespaces).
-        /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
-      ],
-      keyword: o,
-      number: {
-        pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
-        greedy: !0
-      },
-      operator: />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
-      boolean: /\b(?:false|true)\b/
-    }), e.languages.insertBefore("cpp", "string", {
-      module: {
-        // https://en.cppreference.com/w/cpp/language/modules
-        pattern: RegExp(
-          /(\b(?:import|module)\s+)/.source + "(?:" + // header-name
-          /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + "|" + // module name or partition or both
-          /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(/<mod-name>/g, function() {
-            return t;
-          }) + ")"
-        ),
-        lookbehind: !0,
-        greedy: !0,
-        inside: {
-          string: /^[<"][\s\S]+/,
-          operator: /:/,
-          punctuation: /\./
-        }
-      },
-      "raw-string": {
-        pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
-        alias: "string",
-        greedy: !0
-      }
-    }), e.languages.insertBefore("cpp", "keyword", {
-      "generic-function": {
-        pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
-        inside: {
-          function: /^\w+/,
-          generic: {
-            pattern: /<[\s\S]+/,
-            alias: "class-name",
-            inside: e.languages.cpp
-          }
-        }
-      }
-    }), e.languages.insertBefore("cpp", "operator", {
-      "double-colon": {
-        pattern: /::/,
-        alias: "punctuation"
-      }
-    }), e.languages.insertBefore("cpp", "class-name", {
-      // the base clause is an optional list of parent classes
-      // https://en.cppreference.com/w/cpp/language/class
-      "base-clause": {
-        pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: e.languages.extend("cpp", {})
-      }
-    }), e.languages.insertBefore("inside", "double-colon", {
-      // All untokenized words that are not namespaces should be class names
-      "class-name": /\b[a-z_]\w*\b(?!\s*::)/i
-    }, e.languages.cpp["base-clause"]);
-  })(Prism)), le;
-}
-Le();
-Prism.languages.go = Prism.languages.extend("clike", {
-  string: {
-    pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/,
-    lookbehind: !0,
-    greedy: !0
-  },
-  keyword: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,
-  boolean: /\b(?:_|false|iota|nil|true)\b/,
-  number: [
-    // binary and octal integers
-    /\b0(?:b[01_]+|o[0-7_]+)i?\b/i,
-    // hexadecimal integers and floats
-    /\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i,
-    // decimal integers and floats
-    /(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i
-  ],
-  operator: /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
-  builtin: /\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/
-});
-Prism.languages.insertBefore("go", "string", {
-  char: {
-    pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/,
-    greedy: !0
-  }
-});
-delete Prism.languages.go["class-name"];
-var de = {}, pe;
-function Ce() {
-  return pe || (pe = 1, (function(e) {
-    for (var o = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source, t = 0; t < 2; t++)
-      o = o.replace(/<self>/g, function() {
-        return o;
-      });
-    o = o.replace(/<self>/g, function() {
-      return /[^\s\S]/.source;
-    }), e.languages.rust = {
-      comment: [
-        {
-          pattern: RegExp(/(^|[^\\])/.source + o),
-          lookbehind: !0,
-          greedy: !0
-        },
-        {
-          pattern: /(^|[^\\:])\/\/.*/,
-          lookbehind: !0,
-          greedy: !0
-        }
-      ],
-      string: {
-        pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
-        greedy: !0
-      },
-      char: {
-        pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
-        greedy: !0
-      },
-      attribute: {
-        pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
-        greedy: !0,
-        alias: "attr-name",
-        inside: {
-          string: null
-          // see below
-        }
-      },
-      // Closure params should not be confused with bitwise OR |
-      "closure-params": {
-        pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: {
-          "closure-punctuation": {
-            pattern: /^\||\|$/,
-            alias: "punctuation"
-          },
-          rest: null
-          // see below
-        }
-      },
-      "lifetime-annotation": {
-        pattern: /'\w+/,
-        alias: "symbol"
-      },
-      "fragment-specifier": {
-        pattern: /(\$\w+:)[a-z]+/,
-        lookbehind: !0,
-        alias: "punctuation"
-      },
-      variable: /\$\w+/,
-      "function-definition": {
-        pattern: /(\bfn\s+)\w+/,
-        lookbehind: !0,
-        alias: "function"
-      },
-      "type-definition": {
-        pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
-        lookbehind: !0,
-        alias: "class-name"
-      },
-      "module-declaration": [
-        {
-          pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
-          lookbehind: !0,
-          alias: "namespace"
-        },
-        {
-          pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
-          lookbehind: !0,
-          alias: "namespace",
-          inside: {
-            punctuation: /::/
-          }
-        }
-      ],
-      keyword: [
-        // https://github.com/rust-lang/reference/blob/master/src/keywords.md
-        /\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/,
-        // primitives and str
-        // https://doc.rust-lang.org/stable/rust-by-example/primitives.html
-        /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/
-      ],
-      // functions can technically start with an upper-case letter, but this will introduce a lot of false positives
-      // and Rust's naming conventions recommend snake_case anyway.
-      // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html
-      function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
-      macro: {
-        pattern: /\b\w+!/,
-        alias: "property"
-      },
-      constant: /\b[A-Z_][A-Z_\d]+\b/,
-      "class-name": /\b[A-Z]\w*\b/,
-      namespace: {
-        pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
-        inside: {
-          punctuation: /::/
-        }
-      },
-      // Hex, oct, bin, dec numbers with visual separators and type suffix
-      number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
-      boolean: /\b(?:false|true)\b/,
-      punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
-      operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
-    }, e.languages.rust["closure-params"].inside.rest = e.languages.rust, e.languages.rust.attribute.inside.string = e.languages.rust.string;
-  })(Prism)), de;
-}
-Ce();
-(function(e) {
-  function o(t, s) {
-    return "___" + t.toUpperCase() + s + "___";
-  }
-  Object.defineProperties(e.languages["markup-templating"] = {}, {
-    buildPlaceholders: {
-      /**
-       * Tokenize all inline templating expressions matching `placeholderPattern`.
-       *
-       * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns
-       * `true` will be replaced.
-       *
-       * @param {object} env The environment of the `before-tokenize` hook.
-       * @param {string} language The language id.
-       * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.
-       * @param {(match: string) => boolean} [replaceFilter]
-       */
-      value: function(t, s, b, E) {
-        if (t.language === s) {
-          var h = t.tokenStack = [];
-          t.code = t.code.replace(b, function(r) {
-            if (typeof E == "function" && !E(r))
-              return r;
-            for (var c = h.length, d; t.code.indexOf(d = o(s, c)) !== -1; )
-              ++c;
-            return h[c] = r, d;
-          }), t.grammar = e.languages.markup;
-        }
-      }
-    },
-    tokenizePlaceholders: {
-      /**
-       * Replace placeholders with proper tokens after tokenizing.
-       *
-       * @param {object} env The environment of the `after-tokenize` hook.
-       * @param {string} language The language id.
-       */
-      value: function(t, s) {
-        if (t.language !== s || !t.tokenStack)
-          return;
-        t.grammar = e.languages[s];
-        var b = 0, E = Object.keys(t.tokenStack);
-        function h(r) {
-          for (var c = 0; c < r.length && !(b >= E.length); c++) {
-            var d = r[c];
-            if (typeof d == "string" || d.content && typeof d.content == "string") {
-              var m = E[b], p = t.tokenStack[m], _ = typeof d == "string" ? d : d.content, w = o(s, m), x = _.indexOf(w);
-              if (x > -1) {
-                ++b;
-                var v = _.substring(0, x), y = new e.Token(s, e.tokenize(p, t.grammar), "language-" + s, p), S = _.substring(x + w.length), a = [];
-                v && a.push.apply(a, h([v])), a.push(y), S && a.push.apply(a, h([S])), typeof d == "string" ? r.splice.apply(r, [c, 1].concat(a)) : d.content = a;
-              }
-            } else d.content && h(d.content);
-          }
-          return r;
-        }
-        h(t.tokens);
-      }
-    }
-  });
-})(Prism);
-var ge = {}, fe;
-function $e() {
-  return fe || (fe = 1, (function(e) {
-    var o = /\/\*[\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*\()/
-    ], s = /\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, b = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/, E = /[{}\[\](),:;]/;
-    e.languages.php = {
-      delimiter: {
-        pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
-        alias: "important"
-      },
-      comment: o,
-      variable: /\$+(?:\w+\b|(?=\{))/,
-      package: {
-        pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
-        lookbehind: !0,
-        inside: {
-          punctuation: /\\/
-        }
-      },
-      "class-name-definition": {
-        pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
-        lookbehind: !0,
-        alias: "class-name"
-      },
-      "function-definition": {
-        pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
-        lookbehind: !0,
-        alias: "function"
-      },
-      keyword: [
-        {
-          pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
-          alias: "type-casting",
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
-          alias: "type-hint",
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|never|object|self|static|string|void)\b/i,
-          alias: "return-type",
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
-          alias: "type-declaration",
-          greedy: !0
-        },
-        {
-          pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
-          alias: "type-declaration",
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /\b(?:parent|self|static)(?=\s*::)/i,
-          alias: "static-context",
-          greedy: !0
-        },
-        {
-          // yield from
-          pattern: /(\byield\s+)from\b/i,
-          lookbehind: !0
-        },
-        // `class` is always a keyword unlike other keywords
-        /\bclass\b/i,
-        {
-          // https://www.php.net/manual/en/reserved.keywords.php
-          //
-          // keywords cannot be preceded by "->"
-          // the complex lookbehind means `(?<!(?:->|::)\s*)`
-          pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|never|new|or|parent|print|private|protected|public|readonly|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i,
-          lookbehind: !0
-        }
-      ],
-      "argument-name": {
-        pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i,
-        lookbehind: !0
-      },
-      "class-name": [
-        {
-          pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
-          greedy: !0
-        },
-        {
-          pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
-          alias: "class-name-fully-qualified",
-          greedy: !0,
-          lookbehind: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        },
-        {
-          pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
-          alias: "class-name-fully-qualified",
-          greedy: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        },
-        {
-          pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
-          alias: "class-name-fully-qualified",
-          greedy: !0,
-          lookbehind: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        },
-        {
-          pattern: /\b[a-z_]\w*(?=\s*\$)/i,
-          alias: "type-declaration",
-          greedy: !0
-        },
-        {
-          pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
-          alias: ["class-name-fully-qualified", "type-declaration"],
-          greedy: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        },
-        {
-          pattern: /\b[a-z_]\w*(?=\s*::)/i,
-          alias: "static-context",
-          greedy: !0
-        },
-        {
-          pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
-          alias: ["class-name-fully-qualified", "static-context"],
-          greedy: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        },
-        {
-          pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
-          alias: "type-hint",
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
-          alias: ["class-name-fully-qualified", "type-hint"],
-          greedy: !0,
-          lookbehind: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        },
-        {
-          pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
-          alias: "return-type",
-          greedy: !0,
-          lookbehind: !0
-        },
-        {
-          pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
-          alias: ["class-name-fully-qualified", "return-type"],
-          greedy: !0,
-          lookbehind: !0,
-          inside: {
-            punctuation: /\\/
-          }
-        }
-      ],
-      constant: t,
-      function: {
-        pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
-        lookbehind: !0,
-        inside: {
-          punctuation: /\\/
-        }
-      },
-      property: {
-        pattern: /(->\s*)\w+/,
-        lookbehind: !0
-      },
-      number: s,
-      operator: b,
-      punctuation: E
-    };
-    var h = {
-      pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
-      lookbehind: !0,
-      inside: e.languages.php
-    }, r = [
-      {
-        pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
-        alias: "nowdoc-string",
-        greedy: !0,
-        inside: {
-          delimiter: {
-            pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
-            alias: "symbol",
-            inside: {
-              punctuation: /^<<<'?|[';]$/
-            }
-          }
-        }
-      },
-      {
-        pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
-        alias: "heredoc-string",
-        greedy: !0,
-        inside: {
-          delimiter: {
-            pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
-            alias: "symbol",
-            inside: {
-              punctuation: /^<<<"?|[";]$/
-            }
-          },
-          interpolation: h
-        }
-      },
-      {
-        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: h
-        }
-      }
-    ];
-    e.languages.insertBefore("php", "variable", {
-      string: r,
-      attribute: {
-        pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
-        greedy: !0,
-        inside: {
-          "attribute-content": {
-            pattern: /^(#\[)[\s\S]+(?=\]$)/,
-            lookbehind: !0,
-            // inside can appear subset of php
-            inside: {
-              comment: o,
-              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: s,
-              operator: b,
-              punctuation: E
-            }
-          },
-          delimiter: {
-            pattern: /^#\[|\]$/,
-            alias: "punctuation"
-          }
-        }
-      }
-    }), e.hooks.add("before-tokenize", function(c) {
-      if (/<\?/.test(c.code)) {
-        var d = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g;
-        e.languages["markup-templating"].buildPlaceholders(c, "php", d);
-      }
-    }), e.hooks.add("after-tokenize", function(c) {
-      e.languages["markup-templating"].tokenizePlaceholders(c, "php");
-    });
-  })(Prism)), ge;
-}
-$e();
-var be = {}, he;
-function De() {
-  return he || (he = 1, (function(e) {
-    e.languages.ruby = e.languages.extend("clike", {
-      comment: {
-        pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
-        greedy: !0
-      },
-      "class-name": {
-        pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
-        lookbehind: !0,
-        inside: {
-          punctuation: /[.\\]/
-        }
-      },
-      keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
-      operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
-      punctuation: /[(){}[\].,;]/
-    }), e.languages.insertBefore("ruby", "operator", {
-      "double-colon": {
-        pattern: /::/,
-        alias: "punctuation"
-      }
-    });
-    var o = {
-      pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
-      lookbehind: !0,
-      inside: {
-        content: {
-          pattern: /^(#\{)[\s\S]+(?=\}$)/,
-          lookbehind: !0,
-          inside: e.languages.ruby
-        },
-        delimiter: {
-          pattern: /^#\{|\}$/,
-          alias: "punctuation"
-        }
-      }
-    };
-    delete e.languages.ruby.function;
-    var t = "(?:" + [
-      /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
-      /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
-      /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
-      /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
-      /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
-    ].join("|") + ")", s = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source;
-    e.languages.insertBefore("ruby", "keyword", {
-      "regex-literal": [
-        {
-          pattern: RegExp(/%r/.source + t + /[egimnosux]{0,6}/.source),
-          greedy: !0,
-          inside: {
-            interpolation: o,
-            regex: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
-          lookbehind: !0,
-          greedy: !0,
-          inside: {
-            interpolation: o,
-            regex: /[\s\S]+/
-          }
-        }
-      ],
-      variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
-      symbol: [
-        {
-          pattern: RegExp(/(^|[^:]):/.source + s),
-          lookbehind: !0,
-          greedy: !0
-        },
-        {
-          pattern: RegExp(/([\r\n{(,][ \t]*)/.source + s + /(?=:(?!:))/.source),
-          lookbehind: !0,
-          greedy: !0
-        }
-      ],
-      "method-definition": {
-        pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
-        lookbehind: !0,
-        inside: {
-          function: /\b\w+$/,
-          keyword: /^self\b/,
-          "class-name": /^\w+/,
-          punctuation: /\./
-        }
-      }
-    }), e.languages.insertBefore("ruby", "string", {
-      "string-literal": [
-        {
-          pattern: RegExp(/%[qQiIwWs]?/.source + t),
-          greedy: !0,
-          inside: {
-            interpolation: o,
-            string: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
-          greedy: !0,
-          inside: {
-            interpolation: o,
-            string: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
-          alias: "heredoc-string",
-          greedy: !0,
-          inside: {
-            delimiter: {
-              pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
-              inside: {
-                symbol: /\b\w+/,
-                punctuation: /^<<[-~]?/
-              }
-            },
-            interpolation: o,
-            string: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
-          alias: "heredoc-string",
-          greedy: !0,
-          inside: {
-            delimiter: {
-              pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
-              inside: {
-                symbol: /\b\w+/,
-                punctuation: /^<<[-~]?'|'$/
-              }
-            },
-            string: /[\s\S]+/
-          }
-        }
-      ],
-      "command-literal": [
-        {
-          pattern: RegExp(/%x/.source + t),
-          greedy: !0,
-          inside: {
-            interpolation: o,
-            command: {
-              pattern: /[\s\S]+/,
-              alias: "string"
-            }
-          }
-        },
-        {
-          pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
-          greedy: !0,
-          inside: {
-            interpolation: o,
-            command: {
-              pattern: /[\s\S]+/,
-              alias: "string"
-            }
-          }
-        }
-      ]
-    }), delete e.languages.ruby.string, e.languages.insertBefore("ruby", "number", {
-      builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
-      constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
-    }), e.languages.rb = e.languages.ruby;
-  })(Prism)), be;
-}
-De();
-Prism.languages.sql = {
-  comment: {
-    pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
-    lookbehind: !0
-  },
-  variable: [
-    {
-      pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/,
-      greedy: !0
-    },
-    /@[\w.$]+/
-  ],
-  string: {
-    pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/,
-    greedy: !0,
-    lookbehind: !0
-  },
-  identifier: {
-    pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/,
-    greedy: !0,
-    lookbehind: !0,
-    inside: {
-      punctuation: /^`|`$/
-    }
-  },
-  function: /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i,
-  // Should we highlight user defined functions too?
-  keyword: /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i,
-  boolean: /\b(?:FALSE|NULL|TRUE)\b/i,
-  number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
-  operator: /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,
-  punctuation: /[;[\]()`,.]/
-};
-(function(e) {
-  var o = /[*&][^\s[\]{},]+/, t = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, s = "(?:" + t.source + "(?:[ 	]+" + o.source + ")?|" + o.source + "(?:[ 	]+" + t.source + ")?)", b = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(/<PLAIN>/g, function() {
-    return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
-  }), E = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
-  function h(r, c) {
-    c = (c || "").replace(/m/g, "") + "m";
-    var d = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
-      return s;
-    }).replace(/<<value>>/g, function() {
-      return r;
-    });
-    return RegExp(d, c);
-  }
-  e.languages.yaml = {
-    scalar: {
-      pattern: RegExp(/([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(/<<prop>>/g, function() {
-        return s;
-      })),
-      lookbehind: !0,
-      alias: "string"
-    },
-    comment: /#.*/,
-    key: {
-      pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
-        return s;
-      }).replace(/<<key>>/g, function() {
-        return "(?:" + b + "|" + E + ")";
-      })),
-      lookbehind: !0,
-      greedy: !0,
-      alias: "atrule"
-    },
-    directive: {
-      pattern: /(^[ \t]*)%.+/m,
-      lookbehind: !0,
-      alias: "important"
-    },
-    datetime: {
-      pattern: h(/\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source),
-      lookbehind: !0,
-      alias: "number"
-    },
-    boolean: {
-      pattern: h(/false|true/.source, "i"),
-      lookbehind: !0,
-      alias: "important"
-    },
-    null: {
-      pattern: h(/null|~/.source, "i"),
-      lookbehind: !0,
-      alias: "important"
-    },
-    string: {
-      pattern: h(E),
-      lookbehind: !0,
-      greedy: !0
-    },
-    number: {
-      pattern: h(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, "i"),
-      lookbehind: !0
-    },
-    tag: t,
-    important: o,
-    punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
-  }, e.languages.yml = e.languages.yaml;
-})(Prism);
-(function(e) {
-  var o = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
-  function t(m) {
-    return m = m.replace(/<inner>/g, function() {
-      return o;
-    }), RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + m + ")");
-  }
-  var s = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source, b = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function() {
-    return s;
-  }), E = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
-  e.languages.markdown = e.languages.extend("markup", {}), e.languages.insertBefore("markdown", "prolog", {
-    "front-matter-block": {
-      pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        punctuation: /^---|---$/,
-        "front-matter": {
-          pattern: /\S+(?:\s+\S+)*/,
-          alias: ["yaml", "language-yaml"],
-          inside: e.languages.yaml
-        }
-      }
-    },
-    blockquote: {
-      // > ...
-      pattern: /^>(?:[\t ]*>)*/m,
-      alias: "punctuation"
-    },
-    table: {
-      pattern: RegExp("^" + b + E + "(?:" + b + ")*", "m"),
-      inside: {
-        "table-data-rows": {
-          pattern: RegExp("^(" + b + E + ")(?:" + b + ")*$"),
-          lookbehind: !0,
-          inside: {
-            "table-data": {
-              pattern: RegExp(s),
-              inside: e.languages.markdown
-            },
-            punctuation: /\|/
-          }
-        },
-        "table-line": {
-          pattern: RegExp("^(" + b + ")" + E + "$"),
-          lookbehind: !0,
-          inside: {
-            punctuation: /\||:?-{3,}:?/
-          }
-        },
-        "table-header-row": {
-          pattern: RegExp("^" + b + "$"),
-          inside: {
-            "table-header": {
-              pattern: RegExp(s),
-              alias: "important",
-              inside: e.languages.markdown
-            },
-            punctuation: /\|/
-          }
-        }
-      }
-    },
-    code: [
-      {
-        // Prefixed by 4 spaces or 1 tab and preceded by an empty line
-        pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
-        lookbehind: !0,
-        alias: "keyword"
-      },
-      {
-        // ```optional language
-        // code block
-        // ```
-        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: [
-      {
-        // title 1
-        // =======
-        // title 2
-        // -------
-        pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
-        alias: "important",
-        inside: {
-          punctuation: /==+$|--+$/
-        }
-      },
-      {
-        // # title 1
-        // ###### title 6
-        pattern: /(^\s*)#.+/m,
-        lookbehind: !0,
-        alias: "important",
-        inside: {
-          punctuation: /^#+|#+$/
-        }
-      }
-    ],
-    hr: {
-      // ***
-      // ---
-      // * * *
-      // -----------
-      pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
-      lookbehind: !0,
-      alias: "punctuation"
-    },
-    list: {
-      // * item
-      // + item
-      // - item
-      // 1. item
-      pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
-      lookbehind: !0,
-      alias: "punctuation"
-    },
-    "url-reference": {
-      // [id]: http://example.com "Optional title"
-      // [id]: http://example.com 'Optional title'
-      // [id]: http://example.com (Optional title)
-      // [id]: <http://example.com> "Optional title"
-      pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
-      inside: {
-        variable: {
-          pattern: /^(!?\[)[^\]]+/,
-          lookbehind: !0
-        },
-        string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
-        punctuation: /^[\[\]!:]|[<>]/
-      },
-      alias: "url"
-    },
-    bold: {
-      // **strong**
-      // __strong__
-      // allow one nested instance of italic text using the same delimiter
-      pattern: t(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        content: {
-          pattern: /(^..)[\s\S]+(?=..$)/,
-          lookbehind: !0,
-          inside: {}
-          // see below
-        },
-        punctuation: /\*\*|__/
-      }
-    },
-    italic: {
-      // *em*
-      // _em_
-      // allow one nested instance of bold text using the same delimiter
-      pattern: t(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        content: {
-          pattern: /(^.)[\s\S]+(?=.$)/,
-          lookbehind: !0,
-          inside: {}
-          // see below
-        },
-        punctuation: /[*_]/
-      }
-    },
-    strike: {
-      // ~~strike through~~
-      // ~strike~
-      // eslint-disable-next-line regexp/strict
-      pattern: t(/(~~?)(?:(?!~)<inner>)+\2/.source),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        content: {
-          pattern: /(^~~?)[\s\S]+(?=\1$)/,
-          lookbehind: !0,
-          inside: {}
-          // see below
-        },
-        punctuation: /~~?/
-      }
-    },
-    "code-snippet": {
-      // `code`
-      // ``code``
-      pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
-      lookbehind: !0,
-      greedy: !0,
-      alias: ["code", "keyword"]
-    },
-    url: {
-      // [example](http://example.com "Optional title")
-      // [example][id]
-      // [example] [id]
-      pattern: t(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        operator: /^!/,
-        content: {
-          pattern: /(^\[)[^\]]+(?=\])/,
-          lookbehind: !0,
-          inside: {}
-          // see below
-        },
-        variable: {
-          pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
-          lookbehind: !0
-        },
-        url: {
-          pattern: /(^\]\()[^\s)]+/,
-          lookbehind: !0
-        },
-        string: {
-          pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
-          lookbehind: !0
-        }
-      }
-    }
-  }), ["url", "bold", "italic", "strike"].forEach(function(m) {
-    ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(p) {
-      m !== p && (e.languages.markdown[m].inside.content.inside[p] = e.languages.markdown[p]);
-    });
-  }), e.hooks.add("after-tokenize", function(m) {
-    if (m.language !== "markdown" && m.language !== "md")
-      return;
-    function p(_) {
-      if (!(!_ || typeof _ == "string"))
-        for (var w = 0, x = _.length; w < x; w++) {
-          var v = _[w];
-          if (v.type !== "code") {
-            p(v.content);
-            continue;
-          }
-          var y = v.content[1], S = v.content[3];
-          if (y && S && y.type === "code-language" && S.type === "code-block" && typeof y.content == "string") {
-            var a = y.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
-            a = (/[a-z][\w-]*/i.exec(a) || [""])[0].toLowerCase();
-            var n = "language-" + a;
-            S.alias ? typeof S.alias == "string" ? S.alias = [S.alias, n] : S.alias.push(n) : S.alias = [n];
-          }
-        }
-    }
-    p(m.tokens);
-  }), e.hooks.add("wrap", function(m) {
-    if (m.type === "code-block") {
-      for (var p = "", _ = 0, w = m.classes.length; _ < w; _++) {
-        var x = m.classes[_], v = /language-(.+)/.exec(x);
-        if (v) {
-          p = v[1];
-          break;
-        }
-      }
-      var y = e.languages[p];
-      if (y)
-        m.content = e.highlight(d(m.content), y, p);
-      else if (p && p !== "none" && e.plugins.autoloader) {
-        var S = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 1e16);
-        m.attributes.id = S, e.plugins.autoloader.loadLanguages(p, function() {
-          var a = document.getElementById(S);
-          a && (a.innerHTML = e.highlight(a.textContent, e.languages[p], p));
-        });
-      }
-    }
-  });
-  var h = RegExp(e.languages.markup.tag.pattern.source, "gi"), r = {
-    amp: "&",
-    lt: "<",
-    gt: ">",
-    quot: '"'
-  }, c = String.fromCodePoint || String.fromCharCode;
-  function d(m) {
-    var p = m.replace(h, "");
-    return p = p.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(_, w) {
-      if (w = w.toLowerCase(), w[0] === "#") {
-        var x;
-        return w[1] === "x" ? x = parseInt(w.slice(2), 16) : x = Number(w.slice(1)), c(x);
-      } else {
-        var v = r[w];
-        return v || _;
-      }
-    }), p;
-  }
-  e.languages.md = e.languages.markdown;
-})(Prism);
-const Pe = ["data-lang"], ze = { class: "code-block-header" }, Me = { class: "lang-label" }, Be = { class: "op-btn-group" }, Ue = { key: 1 }, He = ["innerHTML"], Ge = {
-  key: 0,
-  class: "iframe-wrapper"
-}, je = ["srcdoc"], qe = '<svg width="16" height="16" viewBox="0 0 16 16"><path fill="currentColor" d="M4 2a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V2zm2 0v10h6V2H6zm-1 2V2a1 1 0 0 1 1-1h6a1 1 0 0 1 1 1v10a1 1 0 0 1-1 1H7a1 1 0 0 1-1-1v-8zm-2 2H2V14a2 2 0 0 0 2 2h6v-2a2 2 0 0 0-2-2H4V4zm0 0v10a1 1 0 0 0 1 1h6a1 1 0 0 0 1-1V4H4z"/></svg>', Ze = '<svg width="17" height="17" viewBox="0 0 20 20"><path fill="currentColor" d="M2 5a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5zm2 0v10h12V5H4zm3.6 3.55l1.4 1.45l-1.4 1.45L7 11.38l2-2l-2-2zm5.4.83l-1.4-1.45L13 6.62l2 2l-2 2z"/></svg>', Ye = '<svg width="17" height="17" viewBox="0 0 20 20"><path fill="currentColor" d="M6.23 4.81a1 1 0 0 1 1.41 0L10 7.17l2.36-2.36a1 1 0 0 1 1.41 1.41L11.41 8.59l2.36 2.36a1 1 0 1 1-1.41 1.41L10 10l-2.36 2.36a1 1 0 0 1-1.41-1.41L8.59 8.59 6.23 6.23a1 1 0 0 1 0-1.41z"/></svg>', Xe = /* @__PURE__ */ Ae({
-  __name: "CodeBlock",
-  props: {
-    code: {},
-    language: {}
-  },
-  setup(e) {
-    const o = e, t = Z(!1), s = Z(!1);
-    function b() {
-      return o.language.toLowerCase() === "html" || o.language.toLowerCase() === "markup";
-    }
-    function E() {
-      const p = o.language || "plaintext";
-      return H.languages[p] ? H.highlight(o.code, H.languages[p], p) : H.util.encode(o.code);
-    }
-    const h = Z(""), r = () => {
-      h.value = E();
-    };
-    r(), ve(() => [o.code, o.language], () => {
-      r();
-    });
-    const c = async () => {
-      try {
-        await navigator.clipboard.writeText(o.code), t.value = !0, setTimeout(() => {
-          t.value = !1;
-        }, 1700);
-      } catch (p) {
-        console.error("复制失败:", p);
-      }
-    }, d = () => {
-      s.value = !0;
-    }, m = () => {
-      s.value = !1;
-    };
-    return (p, _) => (D(), $("div", {
-      class: "code-block-wrapper",
-      "data-lang": e.language
-    }, [
-      L("div", ze, [
-        L("span", Me, _e(e.language.toUpperCase()), 1),
-        L("div", Be, [
-          L("button", {
-            class: X(["copy-code-button", { copied: t.value }]),
-            type: "button",
-            title: "复制代码",
-            onClick: c
-          }, [
-            t.value ? (D(), $("span", Ue, "已复制")) : (D(), $("span", {
-              key: 0,
-              innerHTML: qe
-            }))
-          ], 2),
-          b() && !s.value ? (D(), $("button", {
-            key: 0,
-            class: "preview-html-button",
-            type: "button",
-            title: "预览 HTML",
-            onClick: d,
-            innerHTML: Ze
-          })) : Y("", !0),
-          s.value ? (D(), $("button", {
-            key: 1,
-            class: "close-preview-button",
-            type: "button",
-            title: "关闭预览",
-            onClick: m,
-            innerHTML: Ye
-          })) : Y("", !0)
-        ])
-      ]),
-      we(L("pre", {
-        class: X(`language-${e.language}`)
-      }, [
-        L("code", {
-          class: X(`language-${e.language}`),
-          innerHTML: h.value
-        }, null, 10, He)
-      ], 2), [
-        [ke, !s.value]
-      ]),
-      s.value ? (D(), $("div", Ge, [
-        L("iframe", {
-          class: "html-preview-iframe",
-          srcdoc: e.code,
-          sandbox: "allow-scripts allow-forms allow-popups allow-modals allow-same-origin"
-        }, null, 8, je)
-      ])) : Y("", !0)
-    ], 8, Pe));
-  }
-}), Ve = /* @__PURE__ */ Te(Xe, [["__scopeId", "data-v-a3e86bb9"]]), Qe = {
-  name: "codeblock",
-  priority: 70,
-  test: (e) => e.type !== "tag" || e.name !== "pre" ? !1 : !!e.children?.some(
-    (t) => t.type === "tag" && t.name === "code"
-  ),
-  render: (e, o, t) => {
-    const s = e.children?.find(
-      (d) => d.type === "tag" && d.name === "code"
-    );
-    if (!s)
-      return ee("pre", {}, "");
-    const E = (s.attribs?.class || "").match(/language-(\w+)/), h = E ? E[1] : "plaintext", r = (d) => d.type === "text" ? d.data || "" : d.children ? d.children.map(r).join("") : "", c = r(s);
-    return ee(Ve, {
-      code: c,
-      language: h
-    });
-  }
-};
-export {
-  Qe as CodeBlockPlugin
-};