hermium 0.1.10 → 0.2.0

package/dist/web-server/_libs/refractor.mjs

@@ -1,2425 +0,0 @@
-import { h } from "./hastscript.mjs";
-import { p as parseEntities } from "./parse-entities.mjs";
-var uniqueId = 0;
-var plainTextGrammar = {};
-var _ = {
-  /**
-   * 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: {
-    /**
-     * 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(o) {
-      return Object.prototype.toString.call(o).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(obj) {
-      if (!obj["__id"]) {
-        Object.defineProperty(obj, "__id", { value: ++uniqueId });
-      }
-      return obj["__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 deepClone(o, visited) {
-      visited = visited || {};
-      var clone;
-      var id;
-      switch (_.util.type(o)) {
-        case "Object":
-          id = _.util.objId(o);
-          if (visited[id]) {
-            return visited[id];
-          }
-          clone = /** @type {Record<string, any>} */
-          {};
-          visited[id] = clone;
-          for (var key in o) {
-            if (o.hasOwnProperty(key)) {
-              clone[key] = deepClone(o[key], visited);
-            }
-          }
-          return (
-            /** @type {any} */
-            clone
-          );
-        case "Array":
-          id = _.util.objId(o);
-          if (visited[id]) {
-            return visited[id];
-          }
-          clone = [];
-          visited[id] = clone;
-          /** @type {any} */
-          o.forEach(
-            function(v, i) {
-              clone[i] = deepClone(v, visited);
-            }
-          );
-          return (
-            /** @type {any} */
-            clone
-          );
-        default:
-          return o;
-      }
-    }
-  },
-  /**
-   * 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: plainTextGrammar,
-    plaintext: plainTextGrammar,
-    text: plainTextGrammar,
-    txt: plainTextGrammar,
-    /**
-     * 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(id, redef) {
-      var lang = _.util.clone(_.languages[id]);
-      for (var key in redef) {
-        lang[key] = redef[key];
-      }
-      return lang;
-    },
-    /**
-     * 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(inside, before, insert, root) {
-      root = root || /** @type {any} */
-      _.languages;
-      var grammar = root[inside];
-      var ret = {};
-      for (var token in grammar) {
-        if (grammar.hasOwnProperty(token)) {
-          if (token == before) {
-            for (var newToken in insert) {
-              if (insert.hasOwnProperty(newToken)) {
-                ret[newToken] = insert[newToken];
-              }
-            }
-          }
-          if (!insert.hasOwnProperty(token)) {
-            ret[token] = grammar[token];
-          }
-        }
-      }
-      var old = root[inside];
-      root[inside] = ret;
-      _.languages.DFS(_.languages, function(key, value) {
-        if (value === old && key != inside) {
-          this[key] = ret;
-        }
-      });
-      return ret;
-    },
-    // Traverse a language definition with Depth First Search
-    DFS: function DFS(o, callback, type, visited) {
-      visited = visited || {};
-      var objId = _.util.objId;
-      for (var i in o) {
-        if (o.hasOwnProperty(i)) {
-          callback.call(o, i, o[i], type || i);
-          var property = o[i];
-          var propertyType = _.util.type(property);
-          if (propertyType === "Object" && !visited[objId(property)]) {
-            visited[objId(property)] = true;
-            DFS(property, callback, null, visited);
-          } else if (propertyType === "Array" && !visited[objId(property)]) {
-            visited[objId(property)] = true;
-            DFS(property, callback, i, visited);
-          }
-        }
-      }
-    }
-  },
-  plugins: {},
-  /**
-   * 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(text, grammar, language) {
-    var env = {
-      code: text,
-      grammar,
-      language
-    };
-    _.hooks.run("before-tokenize", env);
-    if (!env.grammar) {
-      throw new Error('The language "' + env.language + '" has no grammar.');
-    }
-    env.tokens = _.tokenize(env.code, env.grammar);
-    _.hooks.run("after-tokenize", env);
-    return Token.stringify(_.util.encode(env.tokens), env.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(text, grammar) {
-    var rest = grammar.rest;
-    if (rest) {
-      for (var token in rest) {
-        grammar[token] = rest[token];
-      }
-      delete grammar.rest;
-    }
-    var tokenList = new LinkedList();
-    addAfter(tokenList, tokenList.head, text);
-    matchGrammar(text, tokenList, grammar, tokenList.head, 0);
-    return toArray(tokenList);
-  },
-  /**
-   * @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(name, callback) {
-      var hooks = _.hooks.all;
-      hooks[name] = hooks[name] || [];
-      hooks[name].push(callback);
-    },
-    /**
-     * 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(name, env) {
-      var callbacks = _.hooks.all[name];
-      if (!callbacks || !callbacks.length) {
-        return;
-      }
-      for (var i = 0, callback; callback = callbacks[i++]; ) {
-        callback(env);
-      }
-    }
-  },
-  Token
-};
-function Token(type, content, alias2, matchedStr) {
-  this.type = type;
-  this.content = content;
-  this.alias = alias2;
-  this.length = (matchedStr || "").length | 0;
-}
-function matchPattern(pattern, pos, text, lookbehind) {
-  pattern.lastIndex = pos;
-  var match = pattern.exec(text);
-  if (match && lookbehind && match[1]) {
-    var lookbehindLength = match[1].length;
-    match.index += lookbehindLength;
-    match[0] = match[0].slice(lookbehindLength);
-  }
-  return match;
-}
-function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {
-  for (var token in grammar) {
-    if (!grammar.hasOwnProperty(token) || !grammar[token]) {
-      continue;
-    }
-    var patterns = grammar[token];
-    patterns = Array.isArray(patterns) ? patterns : [patterns];
-    for (var j = 0; j < patterns.length; ++j) {
-      if (rematch && rematch.cause == token + "," + j) {
-        return;
-      }
-      var patternObj = patterns[j];
-      var inside = patternObj.inside;
-      var lookbehind = !!patternObj.lookbehind;
-      var greedy = !!patternObj.greedy;
-      var alias2 = patternObj.alias;
-      if (greedy && !patternObj.pattern.global) {
-        var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];
-        patternObj.pattern = RegExp(patternObj.pattern.source, flags + "g");
-      }
-      var pattern = patternObj.pattern || patternObj;
-      for (var currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail; pos += currentNode.value.length, currentNode = currentNode.next) {
-        if (rematch && pos >= rematch.reach) {
-          break;
-        }
-        var str = currentNode.value;
-        if (tokenList.length > text.length) {
-          return;
-        }
-        if (str instanceof Token) {
-          continue;
-        }
-        var removeCount = 1;
-        var match;
-        if (greedy) {
-          match = matchPattern(pattern, pos, text, lookbehind);
-          if (!match || match.index >= text.length) {
-            break;
-          }
-          var from = match.index;
-          var to = match.index + match[0].length;
-          var p = pos;
-          p += currentNode.value.length;
-          while (from >= p) {
-            currentNode = currentNode.next;
-            p += currentNode.value.length;
-          }
-          p -= currentNode.value.length;
-          pos = p;
-          if (currentNode.value instanceof Token) {
-            continue;
-          }
-          for (var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value === "string"); k = k.next) {
-            removeCount++;
-            p += k.value.length;
-          }
-          removeCount--;
-          str = text.slice(pos, p);
-          match.index -= pos;
-        } else {
-          match = matchPattern(pattern, 0, str, lookbehind);
-          if (!match) {
-            continue;
-          }
-        }
-        var from = match.index;
-        var matchStr = match[0];
-        var before = str.slice(0, from);
-        var after = str.slice(from + matchStr.length);
-        var reach = pos + str.length;
-        if (rematch && reach > rematch.reach) {
-          rematch.reach = reach;
-        }
-        var removeFrom = currentNode.prev;
-        if (before) {
-          removeFrom = addAfter(tokenList, removeFrom, before);
-          pos += before.length;
-        }
-        removeRange(tokenList, removeFrom, removeCount);
-        var wrapped = new Token(
-          token,
-          inside ? _.tokenize(matchStr, inside) : matchStr,
-          alias2,
-          matchStr
-        );
-        currentNode = addAfter(tokenList, removeFrom, wrapped);
-        if (after) {
-          addAfter(tokenList, currentNode, after);
-        }
-        if (removeCount > 1) {
-          var nestedRematch = {
-            cause: token + "," + j,
-            reach
-          };
-          matchGrammar(
-            text,
-            tokenList,
-            grammar,
-            currentNode.prev,
-            pos,
-            nestedRematch
-          );
-          if (rematch && nestedRematch.reach > rematch.reach) {
-            rematch.reach = nestedRematch.reach;
-          }
-        }
-      }
-    }
-  }
-}
-function LinkedList() {
-  var head = { value: null, prev: null, next: null };
-  var tail = { value: null, prev: head, next: null };
-  head.next = tail;
-  this.head = head;
-  this.tail = tail;
-  this.length = 0;
-}
-function addAfter(list, node, value) {
-  var next = node.next;
-  var newNode = { value, prev: node, next };
-  node.next = newNode;
-  next.prev = newNode;
-  list.length++;
-  return newNode;
-}
-function removeRange(list, node, count) {
-  var next = node.next;
-  for (var i = 0; i < count && next !== list.tail; i++) {
-    next = next.next;
-  }
-  node.next = next;
-  next.prev = node;
-  list.length -= i;
-}
-function toArray(list) {
-  var array = [];
-  var node = list.head.next;
-  while (node !== list.tail) {
-    array.push(node.value);
-    node = node.next;
-  }
-  return array;
-}
-const Prism = _;
-function Refractor() {
-}
-Refractor.prototype = Prism;
-const refractor = new Refractor();
-refractor.highlight = highlight;
-refractor.register = register;
-refractor.alias = alias;
-refractor.registered = registered;
-refractor.listLanguages = listLanguages;
-refractor.util.encode = encode;
-refractor.Token.stringify = stringify;
-function highlight(value, language) {
-  if (typeof value !== "string") {
-    throw new TypeError("Expected `string` for `value`, got `" + value + "`");
-  }
-  let grammar;
-  let name;
-  if (language && typeof language === "object") {
-    grammar = language;
-  } else {
-    name = language;
-    if (typeof name !== "string") {
-      throw new TypeError("Expected `string` for `name`, got `" + name + "`");
-    }
-    if (Object.hasOwn(refractor.languages, name)) {
-      grammar = refractor.languages[name];
-    } else {
-      throw new Error("Unknown language: `" + name + "` is not registered");
-    }
-  }
-  return {
-    type: "root",
-    // @ts-expect-error: we hacked Prism to accept and return the things we want.
-    children: Prism.highlight.call(refractor, value, grammar, name)
-  };
-}
-function register(syntax) {
-  if (typeof syntax !== "function" || !syntax.displayName) {
-    throw new Error("Expected `function` for `syntax`, got `" + syntax + "`");
-  }
-  if (!Object.hasOwn(refractor.languages, syntax.displayName)) {
-    syntax(refractor);
-  }
-}
-function alias(language, alias2) {
-  const languages = refractor.languages;
-  let map = {};
-  if (typeof language === "string") {
-    if (alias2) {
-      map[language] = alias2;
-    }
-  } else {
-    map = language;
-  }
-  let key;
-  for (key in map) {
-    if (Object.hasOwn(map, key)) {
-      const value = map[key];
-      const list = typeof value === "string" ? [value] : value;
-      let index = -1;
-      while (++index < list.length) {
-        languages[list[index]] = languages[key];
-      }
-    }
-  }
-}
-function registered(aliasOrLanguage) {
-  if (typeof aliasOrLanguage !== "string") {
-    throw new TypeError(
-      "Expected `string` for `aliasOrLanguage`, got `" + aliasOrLanguage + "`"
-    );
-  }
-  return Object.hasOwn(refractor.languages, aliasOrLanguage);
-}
-function listLanguages() {
-  const languages = refractor.languages;
-  const list = [];
-  let language;
-  for (language in languages) {
-    if (Object.hasOwn(languages, language) && typeof languages[language] === "object") {
-      list.push(language);
-    }
-  }
-  return list;
-}
-function stringify(value, language) {
-  if (typeof value === "string") {
-    return { type: "text", value };
-  }
-  if (Array.isArray(value)) {
-    const result = [];
-    let index = -1;
-    while (++index < value.length) {
-      if (value[index] !== null && value[index] !== void 0 && value[index] !== "") {
-        result.push(
-          /** @type {Element | Text} */
-          stringify(value[index], language)
-        );
-      }
-    }
-    return result;
-  }
-  const env = {
-    attributes: {},
-    classes: ["token", value.type],
-    content: stringify(value.content, language),
-    language,
-    tag: "span",
-    type: value.type
-  };
-  if (value.alias) {
-    env.classes.push(
-      ...typeof value.alias === "string" ? [value.alias] : value.alias
-    );
-  }
-  refractor.hooks.run("wrap", env);
-  return h(
-    env.tag + "." + env.classes.join("."),
-    attributes(env.attributes),
-    env.content
-  );
-}
-function encode(tokens) {
-  return tokens;
-}
-function attributes(record) {
-  let key;
-  for (key in record) {
-    if (Object.hasOwn(record, key)) {
-      record[key] = parseEntities(record[key]);
-    }
-  }
-  return record;
-}
-markup.displayName = "markup";
-markup.aliases = ["atom", "html", "mathml", "rss", "ssml", "svg", "xml"];
-function markup(Prism2) {
-  Prism2.languages.markup = {
-    comment: {
-      pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
-      greedy: true
-    },
-    prolog: {
-      pattern: /<\?[\s\S]+?\?>/,
-      greedy: true
-    },
-    doctype: {
-      // https://www.w3.org/TR/xml/#NT-doctypedecl
-      pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
-      greedy: true,
-      inside: {
-        "internal-subset": {
-          pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
-          lookbehind: true,
-          greedy: true,
-          inside: null
-          // see below
-        },
-        string: {
-          pattern: /"[^"]*"|'[^']*'/,
-          greedy: true
-        },
-        punctuation: /^<!|>$|[[\]]/,
-        "doctype-tag": /^DOCTYPE/i,
-        name: /[^\s<>'"]+/
-      }
-    },
-    cdata: {
-      pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
-      greedy: true
-    },
-    tag: {
-      pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
-      greedy: true,
-      inside: {
-        tag: {
-          pattern: /^<\/?[^\s>\/]+/,
-          inside: {
-            punctuation: /^<\/?/,
-            namespace: /^[^\s>\/:]+:/
-          }
-        },
-        "special-attr": [],
-        "attr-value": {
-          pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
-          inside: {
-            punctuation: [
-              {
-                pattern: /^=/,
-                alias: "attr-equals"
-              },
-              {
-                pattern: /^(\s*)["']|["']$/,
-                lookbehind: true
-              }
-            ]
-          }
-        },
-        punctuation: /\/?>/,
-        "attr-name": {
-          pattern: /[^\s>\/]+/,
-          inside: {
-            namespace: /^[^\s>\/:]+:/
-          }
-        }
-      }
-    },
-    entity: [
-      {
-        pattern: /&[\da-z]{1,8};/i,
-        alias: "named-entity"
-      },
-      /&#x?[\da-f]{1,8};/i
-    ]
-  };
-  Prism2.languages.markup["tag"].inside["attr-value"].inside["entity"] = Prism2.languages.markup["entity"];
-  Prism2.languages.markup["doctype"].inside["internal-subset"].inside = Prism2.languages.markup;
-  Prism2.hooks.add("wrap", function(env) {
-    if (env.type === "entity") {
-      env.attributes["title"] = env.content.value.replace(/&amp;/, "&");
-    }
-  });
-  Object.defineProperty(Prism2.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 addInlined(tagName, lang) {
-      var includedCdataInside = {};
-      includedCdataInside["language-" + lang] = {
-        pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
-        lookbehind: true,
-        inside: Prism2.languages[lang]
-      };
-      includedCdataInside["cdata"] = /^<!\[CDATA\[|\]\]>$/i;
-      var inside = {
-        "included-cdata": {
-          pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
-          inside: includedCdataInside
-        }
-      };
-      inside["language-" + lang] = {
-        pattern: /[\s\S]+/,
-        inside: Prism2.languages[lang]
-      };
-      var def = {};
-      def[tagName] = {
-        pattern: RegExp(
-          /(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(
-            /__/g,
-            function() {
-              return tagName;
-            }
-          ),
-          "i"
-        ),
-        lookbehind: true,
-        greedy: true,
-        inside
-      };
-      Prism2.languages.insertBefore("markup", "cdata", def);
-    }
-  });
-  Object.defineProperty(Prism2.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(attrName, lang) {
-      Prism2.languages.markup.tag.inside["special-attr"].push({
-        pattern: RegExp(
-          /(^|["'\s])/.source + "(?:" + attrName + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
-          "i"
-        ),
-        lookbehind: true,
-        inside: {
-          "attr-name": /^[^\s=]+/,
-          "attr-value": {
-            pattern: /=[\s\S]+/,
-            inside: {
-              value: {
-                pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
-                lookbehind: true,
-                alias: [lang, "language-" + lang],
-                inside: Prism2.languages[lang]
-              },
-              punctuation: [
-                {
-                  pattern: /^=/,
-                  alias: "attr-equals"
-                },
-                /"|'/
-              ]
-            }
-          }
-        }
-      });
-    }
-  });
-  Prism2.languages.html = Prism2.languages.markup;
-  Prism2.languages.mathml = Prism2.languages.markup;
-  Prism2.languages.svg = Prism2.languages.markup;
-  Prism2.languages.xml = Prism2.languages.extend("markup", {});
-  Prism2.languages.ssml = Prism2.languages.xml;
-  Prism2.languages.atom = Prism2.languages.xml;
-  Prism2.languages.rss = Prism2.languages.xml;
-}
-css.displayName = "css";
-css.aliases = [];
-function css(Prism2) {
-  (function(Prism3) {
-    var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
-    Prism3.languages.css = {
-      comment: /\/\*[\s\S]*?\*\//,
-      atrule: {
-        pattern: RegExp(
-          "@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + string.source + ")*?" + /(?:;|(?=\s*\{))/.source
-        ),
-        inside: {
-          rule: /^@[\w-]+/,
-          "selector-function-argument": {
-            pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
-            lookbehind: true,
-            alias: "selector"
-          },
-          keyword: {
-            pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
-            lookbehind: true
-          }
-          // See rest below
-        }
-      },
-      url: {
-        // https://drafts.csswg.org/css-values-3/#urls
-        pattern: RegExp(
-          "\\burl\\((?:" + string.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)",
-          "i"
-        ),
-        greedy: true,
-        inside: {
-          function: /^url/i,
-          punctuation: /^\(|\)$/,
-          string: {
-            pattern: RegExp("^" + string.source + "$"),
-            alias: "url"
-          }
-        }
-      },
-      selector: {
-        pattern: RegExp(
-          `(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + string.source + ")*(?=\\s*\\{)"
-        ),
-        lookbehind: true
-      },
-      string: {
-        pattern: string,
-        greedy: true
-      },
-      property: {
-        pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
-        lookbehind: true
-      },
-      important: /!important\b/i,
-      function: {
-        pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
-        lookbehind: true
-      },
-      punctuation: /[(){};:,]/
-    };
-    Prism3.languages.css["atrule"].inside.rest = Prism3.languages.css;
-    var markup2 = Prism3.languages.markup;
-    if (markup2) {
-      markup2.tag.addInlined("style", "css");
-      markup2.tag.addAttribute("style", "css");
-    }
-  })(Prism2);
-}
-clike.displayName = "clike";
-clike.aliases = [];
-function clike(Prism2) {
-  Prism2.languages.clike = {
-    comment: [
-      {
-        pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
-        lookbehind: true,
-        greedy: true
-      },
-      {
-        pattern: /(^|[^\\:])\/\/.*/,
-        lookbehind: true,
-        greedy: true
-      }
-    ],
-    string: {
-      pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-      greedy: true
-    },
-    "class-name": {
-      pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
-      lookbehind: true,
-      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: /[{}[\];(),.:]/
-  };
-}
-javascript.displayName = "javascript";
-javascript.aliases = ["js"];
-function javascript(Prism2) {
-  Prism2.register(clike);
-  Prism2.languages.javascript = Prism2.languages.extend("clike", {
-    "class-name": [
-      Prism2.languages.clike["class-name"],
-      {
-        pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
-        lookbehind: true
-      }
-    ],
-    keyword: [
-      {
-        pattern: /((?:^|\})\s*)catch\b/,
-        lookbehind: true
-      },
-      {
-        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: true
-      }
-    ],
-    // 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: true
-    },
-    operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
-  });
-  Prism2.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
-  Prism2.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: true,
-      greedy: true,
-      inside: {
-        "regex-source": {
-          pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
-          lookbehind: true,
-          alias: "language-regex",
-          inside: Prism2.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: true,
-        inside: Prism2.languages.javascript
-      },
-      {
-        pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
-        lookbehind: true,
-        inside: Prism2.languages.javascript
-      },
-      {
-        pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
-        lookbehind: true,
-        inside: Prism2.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: true,
-        inside: Prism2.languages.javascript
-      }
-    ],
-    constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
-  });
-  Prism2.languages.insertBefore("javascript", "string", {
-    hashbang: {
-      pattern: /^#!.*/,
-      greedy: true,
-      alias: "comment"
-    },
-    "template-string": {
-      pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
-      greedy: true,
-      inside: {
-        "template-punctuation": {
-          pattern: /^`|`$/,
-          alias: "string"
-        },
-        interpolation: {
-          pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
-          lookbehind: true,
-          inside: {
-            "interpolation-punctuation": {
-              pattern: /^\$\{|\}$/,
-              alias: "punctuation"
-            },
-            rest: Prism2.languages.javascript
-          }
-        },
-        string: /[\s\S]+/
-      }
-    },
-    "string-property": {
-      pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
-      lookbehind: true,
-      greedy: true,
-      alias: "property"
-    }
-  });
-  Prism2.languages.insertBefore("javascript", "operator", {
-    "literal-property": {
-      pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
-      lookbehind: true,
-      alias: "property"
-    }
-  });
-  if (Prism2.languages.markup) {
-    Prism2.languages.markup.tag.addInlined("script", "javascript");
-    Prism2.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"
-    );
-  }
-  Prism2.languages.js = Prism2.languages.javascript;
-}
-sql.displayName = "sql";
-sql.aliases = [];
-function sql(Prism2) {
-  Prism2.languages.sql = {
-    comment: {
-      pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
-      lookbehind: true
-    },
-    variable: [
-      {
-        pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/,
-        greedy: true
-      },
-      /@[\w.$]+/
-    ],
-    string: {
-      pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/,
-      greedy: true,
-      lookbehind: true
-    },
-    identifier: {
-      pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/,
-      greedy: true,
-      lookbehind: true,
-      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: /[;[\]()`,.]/
-  };
-}
-bash.displayName = "bash";
-bash.aliases = ["sh", "shell"];
-function bash(Prism2) {
-  (function(Prism3) {
-    var envVars = "\\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";
-    var commandAfterHeredoc = {
-      pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
-      lookbehind: true,
-      alias: "punctuation",
-      // this looks reasonably well in all themes
-      inside: null
-      // see below
-    };
-    var insideString = {
-      bash: commandAfterHeredoc,
-      environment: {
-        pattern: RegExp("\\$" + envVars),
-        alias: "constant"
-      },
-      variable: [
-        // [0]: Arithmetic Environment
-        {
-          pattern: /\$?\(\([\s\S]+?\)\)/,
-          greedy: true,
-          inside: {
-            // If there is a $ sign at the beginning highlight $(( and )) as variable
-            variable: [
-              {
-                pattern: /(^\$\(\([\s\S]+)\)\)/,
-                lookbehind: true
-              },
-              /^\$\(\(/
-            ],
-            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: true,
-          inside: {
-            variable: /^\$\(|^`|\)$|`$/
-          }
-        },
-        // [2]: Brace expansion
-        {
-          pattern: /\$\{[^}]+\}/,
-          greedy: true,
-          inside: {
-            operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
-            punctuation: /[\[\]]/,
-            environment: {
-              pattern: RegExp("(\\{)" + envVars),
-              lookbehind: true,
-              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})/
-    };
-    Prism3.languages.bash = {
-      shebang: {
-        pattern: /^#!\s*\/.*/,
-        alias: "important"
-      },
-      comment: {
-        pattern: /(^|[^"{\\$])#.*/,
-        lookbehind: true
-      },
-      "function-name": [
-        // a) function foo {
-        // b) foo() {
-        // c) function foo() {
-        // but not “foo {”
-        {
-          // a) and c)
-          pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
-          lookbehind: true,
-          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: true
-      },
-      // Highlight variable names as variables in the left-hand part
-      // of assignments (“=” and “+=”).
-      "assign-left": {
-        pattern: /(^|[\s;|&]|[<>]\()\w+(?:\.\w+)*(?=\+?=)/,
-        inside: {
-          environment: {
-            pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + envVars),
-            lookbehind: true,
-            alias: "constant"
-          }
-        },
-        alias: "variable",
-        lookbehind: true
-      },
-      // Highlight parameter names as variables
-      parameter: {
-        pattern: /(^|\s)-{1,2}(?:\w+:[+-]?)?\w+(?:\.\w+)*(?=[=\s]|$)/,
-        alias: "variable",
-        lookbehind: true
-      },
-      string: [
-        // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
-        {
-          pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
-          lookbehind: true,
-          greedy: true,
-          inside: insideString
-        },
-        // Here-document with quotes around the tag
-        // → No expansion (so no “inside”).
-        {
-          pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
-          lookbehind: true,
-          greedy: true,
-          inside: {
-            bash: commandAfterHeredoc
-          }
-        },
-        // “Normal” string
-        {
-          // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
-          pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
-          lookbehind: true,
-          greedy: true,
-          inside: insideString
-        },
-        {
-          // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
-          pattern: /(^|[^$\\])'[^']*'/,
-          lookbehind: true,
-          greedy: true
-        },
-        {
-          // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
-          pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
-          greedy: true,
-          inside: {
-            entity: insideString.entity
-          }
-        }
-      ],
-      environment: {
-        pattern: RegExp("\\$?" + envVars),
-        alias: "constant"
-      },
-      variable: insideString.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: true
-      },
-      keyword: {
-        pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
-        lookbehind: true
-      },
-      // 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: true,
-        // Alias added to make those easier to distinguish from strings.
-        alias: "class-name"
-      },
-      boolean: {
-        pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
-        lookbehind: true
-      },
-      "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: true
-      }
-    };
-    commandAfterHeredoc.inside = Prism3.languages.bash;
-    var toBeCopied = [
-      "comment",
-      "function-name",
-      "for-or-select",
-      "assign-left",
-      "parameter",
-      "string",
-      "environment",
-      "function",
-      "keyword",
-      "builtin",
-      "boolean",
-      "file-descriptor",
-      "operator",
-      "punctuation",
-      "number"
-    ];
-    var inside = insideString.variable[1].inside;
-    for (var i = 0; i < toBeCopied.length; i++) {
-      inside[toBeCopied[i]] = Prism3.languages.bash[toBeCopied[i]];
-    }
-    Prism3.languages.sh = Prism3.languages.bash;
-    Prism3.languages.shell = Prism3.languages.bash;
-  })(Prism2);
-}
-yaml.displayName = "yaml";
-yaml.aliases = ["yml"];
-function yaml(Prism2) {
-  (function(Prism3) {
-    var anchorOrAlias = /[*&][^\s[\]{},]+/;
-    var tag = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/;
-    var properties = "(?:" + tag.source + "(?:[ 	]+" + anchorOrAlias.source + ")?|" + anchorOrAlias.source + "(?:[ 	]+" + tag.source + ")?)";
-    var plainKey = /(?:[^\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;
-      }
-    );
-    var string = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
-    function createValuePattern(value, flags) {
-      flags = (flags || "").replace(/m/g, "") + "m";
-      var pattern = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
-        return properties;
-      }).replace(/<<value>>/g, function() {
-        return value;
-      });
-      return RegExp(pattern, flags);
-    }
-    Prism3.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 properties;
-            }
-          )
-        ),
-        lookbehind: true,
-        alias: "string"
-      },
-      comment: /#.*/,
-      key: {
-        pattern: RegExp(
-          /((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
-            return properties;
-          }).replace(/<<key>>/g, function() {
-            return "(?:" + plainKey + "|" + string + ")";
-          })
-        ),
-        lookbehind: true,
-        greedy: true,
-        alias: "atrule"
-      },
-      directive: {
-        pattern: /(^[ \t]*)%.+/m,
-        lookbehind: true,
-        alias: "important"
-      },
-      datetime: {
-        pattern: createValuePattern(
-          /\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: true,
-        alias: "number"
-      },
-      boolean: {
-        pattern: createValuePattern(/false|true/.source, "i"),
-        lookbehind: true,
-        alias: "important"
-      },
-      null: {
-        pattern: createValuePattern(/null|~/.source, "i"),
-        lookbehind: true,
-        alias: "important"
-      },
-      string: {
-        pattern: createValuePattern(string),
-        lookbehind: true,
-        greedy: true
-      },
-      number: {
-        pattern: createValuePattern(
-          /[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source,
-          "i"
-        ),
-        lookbehind: true
-      },
-      tag,
-      important: anchorOrAlias,
-      punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
-    };
-    Prism3.languages.yml = Prism3.languages.yaml;
-  })(Prism2);
-}
-markdown.displayName = "markdown";
-markdown.aliases = ["md"];
-function markdown(Prism2) {
-  Prism2.register(markup);
-  (function(Prism3) {
-    var inner = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
-    function createInline(pattern) {
-      pattern = pattern.replace(/<inner>/g, function() {
-        return inner;
-      });
-      return RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + pattern + ")");
-    }
-    var tableCell = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source;
-    var tableRow = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(
-      /__/g,
-      function() {
-        return tableCell;
-      }
-    );
-    var tableLine = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
-    Prism3.languages.markdown = Prism3.languages.extend("markup", {});
-    Prism3.languages.insertBefore("markdown", "prolog", {
-      "front-matter-block": {
-        pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          punctuation: /^---|---$/,
-          "front-matter": {
-            pattern: /\S+(?:\s+\S+)*/,
-            alias: ["yaml", "language-yaml"],
-            inside: Prism3.languages.yaml
-          }
-        }
-      },
-      blockquote: {
-        // > ...
-        pattern: /^>(?:[\t ]*>)*/m,
-        alias: "punctuation"
-      },
-      table: {
-        pattern: RegExp(
-          "^" + tableRow + tableLine + "(?:" + tableRow + ")*",
-          "m"
-        ),
-        inside: {
-          "table-data-rows": {
-            pattern: RegExp(
-              "^(" + tableRow + tableLine + ")(?:" + tableRow + ")*$"
-            ),
-            lookbehind: true,
-            inside: {
-              "table-data": {
-                pattern: RegExp(tableCell),
-                inside: Prism3.languages.markdown
-              },
-              punctuation: /\|/
-            }
-          },
-          "table-line": {
-            pattern: RegExp("^(" + tableRow + ")" + tableLine + "$"),
-            lookbehind: true,
-            inside: {
-              punctuation: /\||:?-{3,}:?/
-            }
-          },
-          "table-header-row": {
-            pattern: RegExp("^" + tableRow + "$"),
-            inside: {
-              "table-header": {
-                pattern: RegExp(tableCell),
-                alias: "important",
-                inside: Prism3.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: true,
-          alias: "keyword"
-        },
-        {
-          // ```optional language
-          // code block
-          // ```
-          pattern: /^```[\s\S]*?^```$/m,
-          greedy: true,
-          inside: {
-            "code-block": {
-              pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
-              lookbehind: true
-            },
-            "code-language": {
-              pattern: /^(```).+/,
-              lookbehind: true
-            },
-            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: true,
-          alias: "important",
-          inside: {
-            punctuation: /^#+|#+$/
-          }
-        }
-      ],
-      hr: {
-        // ***
-        // ---
-        // * * *
-        // -----------
-        pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
-        lookbehind: true,
-        alias: "punctuation"
-      },
-      list: {
-        // * item
-        // + item
-        // - item
-        // 1. item
-        pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
-        lookbehind: true,
-        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: true
-          },
-          string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
-          punctuation: /^[\[\]!:]|[<>]/
-        },
-        alias: "url"
-      },
-      bold: {
-        // **strong**
-        // __strong__
-        // allow one nested instance of italic text using the same delimiter
-        pattern: createInline(
-          /\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source
-        ),
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          content: {
-            pattern: /(^..)[\s\S]+(?=..$)/,
-            lookbehind: true,
-            inside: {}
-            // see below
-          },
-          punctuation: /\*\*|__/
-        }
-      },
-      italic: {
-        // *em*
-        // _em_
-        // allow one nested instance of bold text using the same delimiter
-        pattern: createInline(
-          /\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source
-        ),
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          content: {
-            pattern: /(^.)[\s\S]+(?=.$)/,
-            lookbehind: true,
-            inside: {}
-            // see below
-          },
-          punctuation: /[*_]/
-        }
-      },
-      strike: {
-        // ~~strike through~~
-        // ~strike~
-        // eslint-disable-next-line regexp/strict
-        pattern: createInline(/(~~?)(?:(?!~)<inner>)+\2/.source),
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          content: {
-            pattern: /(^~~?)[\s\S]+(?=\1$)/,
-            lookbehind: true,
-            inside: {}
-            // see below
-          },
-          punctuation: /~~?/
-        }
-      },
-      "code-snippet": {
-        // `code`
-        // ``code``
-        pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
-        lookbehind: true,
-        greedy: true,
-        alias: ["code", "keyword"]
-      },
-      url: {
-        // [example](http://example.com "Optional title")
-        // [example][id]
-        // [example] [id]
-        pattern: createInline(
-          /!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source
-        ),
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          operator: /^!/,
-          content: {
-            pattern: /(^\[)[^\]]+(?=\])/,
-            lookbehind: true,
-            inside: {}
-            // see below
-          },
-          variable: {
-            pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
-            lookbehind: true
-          },
-          url: {
-            pattern: /(^\]\()[^\s)]+/,
-            lookbehind: true
-          },
-          string: {
-            pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
-            lookbehind: true
-          }
-        }
-      }
-    });
-    ["url", "bold", "italic", "strike"].forEach(function(token) {
-      ["url", "bold", "italic", "strike", "code-snippet"].forEach(
-        function(inside) {
-          if (token !== inside) {
-            Prism3.languages.markdown[token].inside.content.inside[inside] = Prism3.languages.markdown[inside];
-          }
-        }
-      );
-    });
-    Prism3.hooks.add("after-tokenize", function(env) {
-      if (env.language !== "markdown" && env.language !== "md") {
-        return;
-      }
-      function walkTokens(tokens) {
-        if (!tokens || typeof tokens === "string") {
-          return;
-        }
-        for (var i = 0, l = tokens.length; i < l; i++) {
-          var token = tokens[i];
-          if (token.type !== "code") {
-            walkTokens(token.content);
-            continue;
-          }
-          var codeLang = token.content[1];
-          var codeBlock = token.content[3];
-          if (codeLang && codeBlock && codeLang.type === "code-language" && codeBlock.type === "code-block" && typeof codeLang.content === "string") {
-            var lang = codeLang.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
-            lang = (/[a-z][\w-]*/i.exec(lang) || [""])[0].toLowerCase();
-            var alias2 = "language-" + lang;
-            if (!codeBlock.alias) {
-              codeBlock.alias = [alias2];
-            } else if (typeof codeBlock.alias === "string") {
-              codeBlock.alias = [codeBlock.alias, alias2];
-            } else {
-              codeBlock.alias.push(alias2);
-            }
-          }
-        }
-      }
-      walkTokens(env.tokens);
-    });
-    Prism3.hooks.add("wrap", function(env) {
-      if (env.type !== "code-block") {
-        return;
-      }
-      var codeLang = "";
-      for (var i = 0, l = env.classes.length; i < l; i++) {
-        var cls = env.classes[i];
-        var match = /language-(.+)/.exec(cls);
-        if (match) {
-          codeLang = match[1];
-          break;
-        }
-      }
-      var grammar = Prism3.languages[codeLang];
-      if (!grammar) {
-        if (codeLang && codeLang !== "none" && Prism3.plugins.autoloader) {
-          var id = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 1e16);
-          env.attributes["id"] = id;
-          Prism3.plugins.autoloader.loadLanguages(codeLang, function() {
-            var ele = document.getElementById(id);
-            if (ele) {
-              ele.innerHTML = Prism3.highlight(
-                ele.textContent,
-                Prism3.languages[codeLang],
-                codeLang
-              );
-            }
-          });
-        }
-      } else {
-        env.content = Prism3.highlight(env.content.value, grammar, codeLang);
-      }
-    });
-    RegExp(Prism3.languages.markup.tag.pattern.source, "gi");
-    Prism3.languages.md = Prism3.languages.markdown;
-  })(Prism2);
-}
-go.displayName = "go";
-go.aliases = [];
-function go(Prism2) {
-  Prism2.register(clike);
-  Prism2.languages.go = Prism2.languages.extend("clike", {
-    string: {
-      pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/,
-      lookbehind: true,
-      greedy: true
-    },
-    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/
-  });
-  Prism2.languages.insertBefore("go", "string", {
-    char: {
-      pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/,
-      greedy: true
-    }
-  });
-  delete Prism2.languages.go["class-name"];
-}
-json.displayName = "json";
-json.aliases = ["webmanifest"];
-function json(Prism2) {
-  Prism2.languages.json = {
-    property: {
-      pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
-      lookbehind: true,
-      greedy: true
-    },
-    string: {
-      pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
-      lookbehind: true,
-      greedy: true
-    },
-    comment: {
-      pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
-      greedy: true
-    },
-    number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
-    punctuation: /[{}[\],]/,
-    operator: /:/,
-    boolean: /\b(?:false|true)\b/,
-    null: {
-      pattern: /\bnull\b/,
-      alias: "keyword"
-    }
-  };
-  Prism2.languages.webmanifest = Prism2.languages.json;
-}
-java.displayName = "java";
-java.aliases = [];
-function java(Prism2) {
-  Prism2.register(clike);
-  (function(Prism3) {
-    var keywords = /\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/;
-    var classNamePrefix = /(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source;
-    var className = {
-      pattern: RegExp(
-        /(^|[^\w.])/.source + classNamePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source
-      ),
-      lookbehind: true,
-      inside: {
-        namespace: {
-          pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
-          inside: {
-            punctuation: /\./
-          }
-        },
-        punctuation: /\./
-      }
-    };
-    Prism3.languages.java = Prism3.languages.extend("clike", {
-      string: {
-        pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
-        lookbehind: true,
-        greedy: true
-      },
-      "class-name": [
-        className,
-        {
-          // 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 + classNamePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()]|\s*(?:\[[\s,]*\]\s*)?::\s*new\b)/.source
-          ),
-          lookbehind: true,
-          inside: className.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 + classNamePrefix + /[A-Z]\w*\b/.source
-          ),
-          lookbehind: true,
-          inside: className.inside
-        }
-      ],
-      keyword: keywords,
-      function: [
-        Prism3.languages.clike.function,
-        {
-          pattern: /(::\s*)[a-z_]\w*/,
-          lookbehind: true
-        }
-      ],
-      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: true
-      },
-      constant: /\b[A-Z][A-Z_\d]+\b/
-    });
-    Prism3.languages.insertBefore("java", "string", {
-      "triple-quoted-string": {
-        // http://openjdk.java.net/jeps/355#Description
-        pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
-        greedy: true,
-        alias: "string"
-      },
-      char: {
-        pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
-        greedy: true
-      }
-    });
-    Prism3.languages.insertBefore("java", "class-name", {
-      annotation: {
-        pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
-        lookbehind: true,
-        alias: "punctuation"
-      },
-      generics: {
-        pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
-        inside: {
-          "class-name": className,
-          keyword: keywords,
-          punctuation: /[<>(),.:]/,
-          operator: /[?&|]/
-        }
-      },
-      import: [
-        {
-          pattern: RegExp(
-            /(\bimport\s+)/.source + classNamePrefix + /(?:[A-Z]\w*|\*)(?=\s*;)/.source
-          ),
-          lookbehind: true,
-          inside: {
-            namespace: className.inside.namespace,
-            punctuation: /\./,
-            operator: /\*/,
-            "class-name": /\w+/
-          }
-        },
-        {
-          pattern: RegExp(
-            /(\bimport\s+static\s+)/.source + classNamePrefix + /(?:\w+|\*)(?=\s*;)/.source
-          ),
-          lookbehind: true,
-          alias: "static",
-          inside: {
-            namespace: className.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 keywords.source;
-            }
-          )
-        ),
-        lookbehind: true,
-        inside: {
-          punctuation: /\./
-        }
-      }
-    });
-  })(Prism2);
-}
-typescript.displayName = "typescript";
-typescript.aliases = ["ts"];
-function typescript(Prism2) {
-  Prism2.register(javascript);
-  (function(Prism3) {
-    Prism3.languages.typescript = Prism3.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: true,
-        greedy: true,
-        inside: null
-        // see below
-      },
-      builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
-    });
-    Prism3.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 Prism3.languages.typescript["parameter"];
-    delete Prism3.languages.typescript["literal-property"];
-    var typeInside = Prism3.languages.extend("typescript", {});
-    delete typeInside["class-name"];
-    Prism3.languages.typescript["class-name"].inside = typeInside;
-    Prism3.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: true,
-        inside: {
-          function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
-          generic: {
-            pattern: /<[\s\S]+/,
-            // everything after the first <
-            alias: "class-name",
-            inside: typeInside
-          }
-        }
-      }
-    });
-    Prism3.languages.ts = Prism3.languages.typescript;
-  })(Prism2);
-}
-python.displayName = "python";
-python.aliases = ["py"];
-function python(Prism2) {
-  Prism2.languages.python = {
-    comment: {
-      pattern: /(^|[^\\])#.*/,
-      lookbehind: true,
-      greedy: true
-    },
-    "string-interpolation": {
-      pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
-      greedy: true,
-      inside: {
-        interpolation: {
-          // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
-          pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
-          lookbehind: true,
-          inside: {
-            "format-spec": {
-              pattern: /(:)[^:(){}]+(?=\}$)/,
-              lookbehind: true
-            },
-            "conversion-option": {
-              pattern: /![sra](?=[:}]$)/,
-              alias: "punctuation"
-            },
-            rest: null
-          }
-        },
-        string: /[\s\S]+/
-      }
-    },
-    "triple-quoted-string": {
-      pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
-      greedy: true,
-      alias: "string"
-    },
-    string: {
-      pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
-      greedy: true
-    },
-    function: {
-      pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
-      lookbehind: true
-    },
-    "class-name": {
-      pattern: /(\bclass\s+)\w+/i,
-      lookbehind: true
-    },
-    decorator: {
-      pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
-      lookbehind: true,
-      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: /[{}[\];(),.:]/
-  };
-  Prism2.languages.python["string-interpolation"].inside["interpolation"].inside.rest = Prism2.languages.python;
-  Prism2.languages.py = Prism2.languages.python;
-}
-jsx.displayName = "jsx";
-jsx.aliases = [];
-function jsx(Prism2) {
-  Prism2.register(javascript);
-  Prism2.register(markup);
-  (function(Prism3) {
-    var javascript2 = Prism3.util.clone(Prism3.languages.javascript);
-    var space = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source;
-    var braces = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source;
-    var spread = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
-    function re(source, flags) {
-      source = source.replace(/<S>/g, function() {
-        return space;
-      }).replace(/<BRACES>/g, function() {
-        return braces;
-      }).replace(/<SPREAD>/g, function() {
-        return spread;
-      });
-      return RegExp(source, flags);
-    }
-    spread = re(spread).source;
-    Prism3.languages.jsx = Prism3.languages.extend("markup", javascript2);
-    Prism3.languages.jsx.tag.pattern = re(
-      /<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source
-    );
-    Prism3.languages.jsx.tag.inside["tag"].pattern = /^<\/?[^\s>\/]*/;
-    Prism3.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/;
-    Prism3.languages.jsx.tag.inside["tag"].inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/;
-    Prism3.languages.jsx.tag.inside["comment"] = javascript2["comment"];
-    Prism3.languages.insertBefore(
-      "inside",
-      "attr-name",
-      {
-        spread: {
-          pattern: re(/<SPREAD>/.source),
-          inside: Prism3.languages.jsx
-        }
-      },
-      Prism3.languages.jsx.tag
-    );
-    Prism3.languages.insertBefore(
-      "inside",
-      "special-attr",
-      {
-        script: {
-          // Allow for two levels of nesting
-          pattern: re(/=<BRACES>/.source),
-          alias: "language-javascript",
-          inside: {
-            "script-punctuation": {
-              pattern: /^=(?=\{)/,
-              alias: "punctuation"
-            },
-            rest: Prism3.languages.jsx
-          }
-        }
-      },
-      Prism3.languages.jsx.tag
-    );
-    var stringifyToken = function(token) {
-      if (!token) {
-        return "";
-      }
-      if (typeof token === "string") {
-        return token;
-      }
-      if (typeof token.content === "string") {
-        return token.content;
-      }
-      return token.content.map(stringifyToken).join("");
-    };
-    var walkTokens = function(tokens) {
-      var openedTags = [];
-      for (var i = 0; i < tokens.length; i++) {
-        var token = tokens[i];
-        var notTagNorBrace = false;
-        if (typeof token !== "string") {
-          if (token.type === "tag" && token.content[0] && token.content[0].type === "tag") {
-            if (token.content[0].content[0].content === "</") {
-              if (openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1])) {
-                openedTags.pop();
-              }
-            } else {
-              if (token.content[token.content.length - 1].content === "/>") ;
-              else {
-                openedTags.push({
-                  tagName: stringifyToken(token.content[0].content[1]),
-                  openedBraces: 0
-                });
-              }
-            }
-          } else if (openedTags.length > 0 && token.type === "punctuation" && token.content === "{") {
-            openedTags[openedTags.length - 1].openedBraces++;
-          } else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === "punctuation" && token.content === "}") {
-            openedTags[openedTags.length - 1].openedBraces--;
-          } else {
-            notTagNorBrace = true;
-          }
-        }
-        if (notTagNorBrace || typeof token === "string") {
-          if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {
-            var plainText = stringifyToken(token);
-            if (i < tokens.length - 1 && (typeof tokens[i + 1] === "string" || tokens[i + 1].type === "plain-text")) {
-              plainText += stringifyToken(tokens[i + 1]);
-              tokens.splice(i + 1, 1);
-            }
-            if (i > 0 && (typeof tokens[i - 1] === "string" || tokens[i - 1].type === "plain-text")) {
-              plainText = stringifyToken(tokens[i - 1]) + plainText;
-              tokens.splice(i - 1, 1);
-              i--;
-            }
-            tokens[i] = new Prism3.Token(
-              "plain-text",
-              plainText,
-              null,
-              plainText
-            );
-          }
-        }
-        if (token.content && typeof token.content !== "string") {
-          walkTokens(token.content);
-        }
-      }
-    };
-    Prism3.hooks.add("after-tokenize", function(env) {
-      if (env.language !== "jsx" && env.language !== "tsx") {
-        return;
-      }
-      walkTokens(env.tokens);
-    });
-  })(Prism2);
-}
-tsx.displayName = "tsx";
-tsx.aliases = [];
-function tsx(Prism2) {
-  Prism2.register(jsx);
-  Prism2.register(typescript);
-  (function(Prism3) {
-    var typescript2 = Prism3.util.clone(Prism3.languages.typescript);
-    Prism3.languages.tsx = Prism3.languages.extend("jsx", typescript2);
-    delete Prism3.languages.tsx["parameter"];
-    delete Prism3.languages.tsx["literal-property"];
-    var tag = Prism3.languages.tsx.tag;
-    tag.pattern = RegExp(
-      /(^|[^\w$]|(?=<\/))/.source + "(?:" + tag.pattern.source + ")",
-      tag.pattern.flags
-    );
-    tag.lookbehind = true;
-  })(Prism2);
-}
-rust.displayName = "rust";
-rust.aliases = [];
-function rust(Prism2) {
-  (function(Prism3) {
-    var multilineComment = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source;
-    for (var i = 0; i < 2; i++) {
-      multilineComment = multilineComment.replace(/<self>/g, function() {
-        return multilineComment;
-      });
-    }
-    multilineComment = multilineComment.replace(/<self>/g, function() {
-      return /[^\s\S]/.source;
-    });
-    Prism3.languages.rust = {
-      comment: [
-        {
-          pattern: RegExp(/(^|[^\\])/.source + multilineComment),
-          lookbehind: true,
-          greedy: true
-        },
-        {
-          pattern: /(^|[^\\:])\/\/.*/,
-          lookbehind: true,
-          greedy: true
-        }
-      ],
-      string: {
-        pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
-        greedy: true
-      },
-      char: {
-        pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
-        greedy: true
-      },
-      attribute: {
-        pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
-        greedy: true,
-        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: true,
-        greedy: true,
-        inside: {
-          "closure-punctuation": {
-            pattern: /^\||\|$/,
-            alias: "punctuation"
-          },
-          rest: null
-          // see below
-        }
-      },
-      "lifetime-annotation": {
-        pattern: /'\w+/,
-        alias: "symbol"
-      },
-      "fragment-specifier": {
-        pattern: /(\$\w+:)[a-z]+/,
-        lookbehind: true,
-        alias: "punctuation"
-      },
-      variable: /\$\w+/,
-      "function-definition": {
-        pattern: /(\bfn\s+)\w+/,
-        lookbehind: true,
-        alias: "function"
-      },
-      "type-definition": {
-        pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
-        lookbehind: true,
-        alias: "class-name"
-      },
-      "module-declaration": [
-        {
-          pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
-          lookbehind: true,
-          alias: "namespace"
-        },
-        {
-          pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
-          lookbehind: true,
-          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: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
-    };
-    Prism3.languages.rust["closure-params"].inside.rest = Prism3.languages.rust;
-    Prism3.languages.rust["attribute"].inside["string"] = Prism3.languages.rust["string"];
-  })(Prism2);
-}
-export {
-  jsx as a,
-  tsx as b,
-  bash as c,
-  json as d,
-  css as e,
-  rust as f,
-  go as g,
-  java as h,
-  javascript as j,
-  markdown as m,
-  python as p,
-  refractor as r,
-  sql as s,
-  typescript as t,
-  yaml as y
-};