@bigbinary/neeto-molecules 1.0.16 → 1.0.17

package/dist/NeetoWidget.cjs.js

@@ -4727,11 +4727,11 @@ function require_1c () {
  * */
 
 var abnf_1$1;
-var hasRequiredAbnf;
+var hasRequiredAbnf$1;
 
-function requireAbnf () {
-	if (hasRequiredAbnf) return abnf_1$1;
-	hasRequiredAbnf = 1;
+function requireAbnf$1 () {
+	if (hasRequiredAbnf$1) return abnf_1$1;
+	hasRequiredAbnf$1 = 1;
 	/**
 	 * @param {RegExp | string } re
 	 * @returns {string}
@@ -8074,11 +8074,11 @@ function requireAxapta () {
  * */
 
 var bash_1$1;
-var hasRequiredBash$1;
+var hasRequiredBash;
 
-function requireBash$1 () {
-	if (hasRequiredBash$1) return bash_1$1;
-	hasRequiredBash$1 = 1;
+function requireBash () {
+	if (hasRequiredBash) return bash_1$1;
+	hasRequiredBash = 1;
 	/**
 	 * @param {RegExp | string } re
 	 * @returns {string}
@@ -8254,11 +8254,11 @@ Website: https://en.wikipedia.org/wiki/Tandy_1000
 */
 
 var basic_1$1;
-var hasRequiredBasic$1;
+var hasRequiredBasic;
 
-function requireBasic$1 () {
-	if (hasRequiredBasic$1) return basic_1$1;
-	hasRequiredBasic$1 = 1;
+function requireBasic () {
+	if (hasRequiredBasic) return basic_1$1;
+	hasRequiredBasic = 1;
 	/** @type LanguageFn */
 	function basic(hljs) {
 	  return {
@@ -8327,11 +8327,11 @@ Author: Oleg Efimov <efimovov@gmail.com>
 */
 
 var bnf_1$1;
-var hasRequiredBnf$1;
+var hasRequiredBnf;
 
-function requireBnf$1 () {
-	if (hasRequiredBnf$1) return bnf_1$1;
-	hasRequiredBnf$1 = 1;
+function requireBnf () {
+	if (hasRequiredBnf) return bnf_1$1;
+	hasRequiredBnf = 1;
 	/** @type LanguageFn */
 	function bnf(hljs) {
 	  return {
@@ -8374,11 +8374,11 @@ Website: https://esolangs.org/wiki/Brainfuck
 */
 
 var brainfuck_1$1;
-var hasRequiredBrainfuck$1;
+var hasRequiredBrainfuck;
 
-function requireBrainfuck$1 () {
-	if (hasRequiredBrainfuck$1) return brainfuck_1$1;
-	hasRequiredBrainfuck$1 = 1;
+function requireBrainfuck () {
+	if (hasRequiredBrainfuck) return brainfuck_1$1;
+	hasRequiredBrainfuck = 1;
 	/** @type LanguageFn */
 	function brainfuck(hljs) {
 	  const LITERAL = {
@@ -8938,11 +8938,11 @@ function requireCLike () {
  * */
 
 var c_1$1;
-var hasRequiredC$1;
+var hasRequiredC;
 
-function requireC$1 () {
-	if (hasRequiredC$1) return c_1$1;
-	hasRequiredC$1 = 1;
+function requireC () {
+	if (hasRequiredC) return c_1$1;
+	hasRequiredC = 1;
 	/**
 	 * @param {RegExp | string } re
 	 * @returns {string}
@@ -9585,11 +9585,11 @@ Category: lisp
 */
 
 var clojure_1$1;
-var hasRequiredClojure$1;
+var hasRequiredClojure;
 
-function requireClojure$1 () {
-	if (hasRequiredClojure$1) return clojure_1$1;
-	hasRequiredClojure$1 = 1;
+function requireClojure () {
+	if (hasRequiredClojure) return clojure_1$1;
+	hasRequiredClojure = 1;
 	/** @type LanguageFn */
 	function clojure(hljs) {
 	  const SYMBOLSTART = 'a-zA-Z_\\-!.?+*=<>&#\'';
@@ -48781,7 +48781,7 @@ var low = core$4;
 var lowlight = low;
 
 low.registerLanguage('1c', require_1c());
-low.registerLanguage('abnf', requireAbnf());
+low.registerLanguage('abnf', requireAbnf$1());
 low.registerLanguage(
   'accesslog',
   requireAccesslog()
@@ -48814,15 +48814,15 @@ low.registerLanguage('autoit', requireAutoit());
 low.registerLanguage('avrasm', requireAvrasm());
 low.registerLanguage('awk', requireAwk());
 low.registerLanguage('axapta', requireAxapta());
-low.registerLanguage('bash', requireBash$1());
-low.registerLanguage('basic', requireBasic$1());
-low.registerLanguage('bnf', requireBnf$1());
+low.registerLanguage('bash', requireBash());
+low.registerLanguage('basic', requireBasic());
+low.registerLanguage('bnf', requireBnf());
 low.registerLanguage(
   'brainfuck',
-  requireBrainfuck$1()
+  requireBrainfuck()
 );
 low.registerLanguage('c-like', requireCLike());
-low.registerLanguage('c', requireC$1());
+low.registerLanguage('c', requireC());
 low.registerLanguage('cal', requireCal());
 low.registerLanguage(
   'capnproto',
@@ -48830,7 +48830,7 @@ low.registerLanguage(
 );
 low.registerLanguage('ceylon', requireCeylon());
 low.registerLanguage('clean', requireClean());
-low.registerLanguage('clojure', requireClojure$1());
+low.registerLanguage('clojure', requireClojure());
 low.registerLanguage(
   'clojure-repl',
   requireClojureRepl()
@@ -49739,7 +49739,7 @@ var languageLoaders$1 = {
     return Promise.resolve().then(function () { return _1c; });
   }),
   abnf: createLanguageAsyncLoader("abnf", function () {
-    return Promise.resolve().then(function () { return abnf; });
+    return Promise.resolve().then(function () { return abnf$1; });
   }),
   accesslog: createLanguageAsyncLoader("accesslog", function () {
     return Promise.resolve().then(function () { return accesslog; });
@@ -49790,22 +49790,22 @@ var languageLoaders$1 = {
     return Promise.resolve().then(function () { return axapta; });
   }),
   bash: createLanguageAsyncLoader("bash", function () {
-    return Promise.resolve().then(function () { return bash$1; });
+    return Promise.resolve().then(function () { return bash; });
   }),
   basic: createLanguageAsyncLoader("basic", function () {
-    return Promise.resolve().then(function () { return basic$1; });
+    return Promise.resolve().then(function () { return basic; });
   }),
   bnf: createLanguageAsyncLoader("bnf", function () {
-    return Promise.resolve().then(function () { return bnf$1; });
+    return Promise.resolve().then(function () { return bnf; });
   }),
   brainfuck: createLanguageAsyncLoader("brainfuck", function () {
-    return Promise.resolve().then(function () { return brainfuck$1; });
+    return Promise.resolve().then(function () { return brainfuck; });
   }),
   cLike: createLanguageAsyncLoader("cLike", function () {
     return Promise.resolve().then(function () { return cLike; });
   }),
   c: createLanguageAsyncLoader("c", function () {
-    return Promise.resolve().then(function () { return c$1; });
+    return Promise.resolve().then(function () { return c; });
   }),
   cal: createLanguageAsyncLoader("cal", function () {
     return Promise.resolve().then(function () { return cal; });
@@ -49823,7 +49823,7 @@ var languageLoaders$1 = {
     return Promise.resolve().then(function () { return clojureRepl; });
   }),
   clojure: createLanguageAsyncLoader("clojure", function () {
-    return Promise.resolve().then(function () { return clojure$1; });
+    return Promise.resolve().then(function () { return clojure; });
   }),
   cmake: createLanguageAsyncLoader("cmake", function () {
     return Promise.resolve().then(function () { return cmake$1; });
@@ -50334,7 +50334,7 @@ var languageLoaders = {
     return Promise.resolve().then(function () { return abap$1; });
   }),
   abnf: createLanguageAsyncLoader("abnf", function () {
-    return Promise.resolve().then(function () { return abnf$2; });
+    return Promise.resolve().then(function () { return abnf; });
   }),
   actionscript: createLanguageAsyncLoader("actionscript", function () {
     return Promise.resolve().then(function () { return actionscript$2; });
@@ -50391,55 +50391,55 @@ var languageLoaders = {
     return Promise.resolve().then(function () { return autoit$2; });
   }),
   avisynth: createLanguageAsyncLoader("avisynth", function () {
-    return Promise.resolve().then(function () { return avisynth; });
+    return Promise.resolve().then(function () { return avisynth$1; });
   }),
   avroIdl: createLanguageAsyncLoader("avroIdl", function () {
-    return Promise.resolve().then(function () { return avroIdl; });
+    return Promise.resolve().then(function () { return avroIdl$1; });
   }),
   bash: createLanguageAsyncLoader("bash", function () {
-    return Promise.resolve().then(function () { return bash; });
+    return Promise.resolve().then(function () { return bash$2; });
   }),
   basic: createLanguageAsyncLoader("basic", function () {
-    return Promise.resolve().then(function () { return basic; });
+    return Promise.resolve().then(function () { return basic$2; });
   }),
   batch: createLanguageAsyncLoader("batch", function () {
-    return Promise.resolve().then(function () { return batch; });
+    return Promise.resolve().then(function () { return batch$1; });
   }),
   bbcode: createLanguageAsyncLoader("bbcode", function () {
-    return Promise.resolve().then(function () { return bbcode; });
+    return Promise.resolve().then(function () { return bbcode$1; });
   }),
   bicep: createLanguageAsyncLoader("bicep", function () {
-    return Promise.resolve().then(function () { return bicep; });
+    return Promise.resolve().then(function () { return bicep$1; });
   }),
   birb: createLanguageAsyncLoader("birb", function () {
-    return Promise.resolve().then(function () { return birb; });
+    return Promise.resolve().then(function () { return birb$1; });
   }),
   bison: createLanguageAsyncLoader("bison", function () {
-    return Promise.resolve().then(function () { return bison; });
+    return Promise.resolve().then(function () { return bison$1; });
   }),
   bnf: createLanguageAsyncLoader("bnf", function () {
-    return Promise.resolve().then(function () { return bnf; });
+    return Promise.resolve().then(function () { return bnf$2; });
   }),
   brainfuck: createLanguageAsyncLoader("brainfuck", function () {
-    return Promise.resolve().then(function () { return brainfuck; });
+    return Promise.resolve().then(function () { return brainfuck$2; });
   }),
   brightscript: createLanguageAsyncLoader("brightscript", function () {
-    return Promise.resolve().then(function () { return brightscript; });
+    return Promise.resolve().then(function () { return brightscript$1; });
   }),
   bro: createLanguageAsyncLoader("bro", function () {
-    return Promise.resolve().then(function () { return bro; });
+    return Promise.resolve().then(function () { return bro$1; });
   }),
   bsl: createLanguageAsyncLoader("bsl", function () {
-    return Promise.resolve().then(function () { return bsl; });
+    return Promise.resolve().then(function () { return bsl$1; });
   }),
   c: createLanguageAsyncLoader("c", function () {
-    return Promise.resolve().then(function () { return c; });
+    return Promise.resolve().then(function () { return c$2; });
   }),
   cfscript: createLanguageAsyncLoader("cfscript", function () {
-    return Promise.resolve().then(function () { return cfscript; });
+    return Promise.resolve().then(function () { return cfscript$1; });
   }),
   chaiscript: createLanguageAsyncLoader("chaiscript", function () {
-    return Promise.resolve().then(function () { return chaiscript; });
+    return Promise.resolve().then(function () { return chaiscript$1; });
   }),
   cil: createLanguageAsyncLoader("cil", function () {
     return Promise.resolve().then(function () { return cil; });
@@ -50448,7 +50448,7 @@ var languageLoaders = {
     return Promise.resolve().then(function () { return clike$2; });
   }),
   clojure: createLanguageAsyncLoader("clojure", function () {
-    return Promise.resolve().then(function () { return clojure; });
+    return Promise.resolve().then(function () { return clojure$2; });
   }),
   cmake: createLanguageAsyncLoader("cmake", function () {
     return Promise.resolve().then(function () { return cmake; });
@@ -59703,73 +59703,77 @@ var abap$1 = /*#__PURE__*/_mergeNamespaces({
   'default': abap_1
 }, [abap_1]);
 
-var abnf_1 = abnf$1;
-abnf$1.displayName = 'abnf';
-abnf$1.aliases = [];
-function abnf$1(Prism) {
+var abnf_1;
+var hasRequiredAbnf;
+
+function requireAbnf () {
+	if (hasRequiredAbnf) return abnf_1;
+	hasRequiredAbnf = 1;
+
+	abnf_1 = abnf;
+	abnf.displayName = 'abnf';
+	abnf.aliases = [];
+	function abnf(Prism) {
 (function (Prism) {
-    var coreRules =
-      '(?:ALPHA|BIT|CHAR|CR|CRLF|CTL|DIGIT|DQUOTE|HEXDIG|HTAB|LF|LWSP|OCTET|SP|VCHAR|WSP)';
-    Prism.languages.abnf = {
-      comment: /;.*/,
-      string: {
-        pattern: /(?:%[is])?"[^"\n\r]*"/,
-        greedy: true,
-        inside: {
-          punctuation: /^%[is]/
-        }
-      },
-      range: {
-        pattern: /%(?:b[01]+-[01]+|d\d+-\d+|x[A-F\d]+-[A-F\d]+)/i,
-        alias: 'number'
-      },
-      terminal: {
-        pattern:
-          /%(?:b[01]+(?:\.[01]+)*|d\d+(?:\.\d+)*|x[A-F\d]+(?:\.[A-F\d]+)*)/i,
-        alias: 'number'
-      },
-      repetition: {
-        pattern: /(^|[^\w-])(?:\d*\*\d*|\d+)/,
-        lookbehind: true,
-        alias: 'operator'
-      },
-      definition: {
-        pattern: /(^[ \t]*)(?:[a-z][\w-]*|<[^<>\r\n]*>)(?=\s*=)/m,
-        lookbehind: true,
-        alias: 'keyword',
-        inside: {
-          punctuation: /<|>/
-        }
-      },
-      'core-rule': {
-        pattern: RegExp(
-          '(?:(^|[^<\\w-])' + coreRules + '|<' + coreRules + '>)(?![\\w-])',
-          'i'
-        ),
-        lookbehind: true,
-        alias: ['rule', 'constant'],
-        inside: {
-          punctuation: /<|>/
-        }
-      },
-      rule: {
-        pattern: /(^|[^<\w-])[a-z][\w-]*|<[^<>\r\n]*>/i,
-        lookbehind: true,
-        inside: {
-          punctuation: /<|>/
-        }
-      },
-      operator: /=\/?|\//,
-      punctuation: /[()\[\]]/
-    };
-  })(Prism);
+	    var coreRules =
+	      '(?:ALPHA|BIT|CHAR|CR|CRLF|CTL|DIGIT|DQUOTE|HEXDIG|HTAB|LF|LWSP|OCTET|SP|VCHAR|WSP)';
+	    Prism.languages.abnf = {
+	      comment: /;.*/,
+	      string: {
+	        pattern: /(?:%[is])?"[^"\n\r]*"/,
+	        greedy: true,
+	        inside: {
+	          punctuation: /^%[is]/
+	        }
+	      },
+	      range: {
+	        pattern: /%(?:b[01]+-[01]+|d\d+-\d+|x[A-F\d]+-[A-F\d]+)/i,
+	        alias: 'number'
+	      },
+	      terminal: {
+	        pattern:
+	          /%(?:b[01]+(?:\.[01]+)*|d\d+(?:\.\d+)*|x[A-F\d]+(?:\.[A-F\d]+)*)/i,
+	        alias: 'number'
+	      },
+	      repetition: {
+	        pattern: /(^|[^\w-])(?:\d*\*\d*|\d+)/,
+	        lookbehind: true,
+	        alias: 'operator'
+	      },
+	      definition: {
+	        pattern: /(^[ \t]*)(?:[a-z][\w-]*|<[^<>\r\n]*>)(?=\s*=)/m,
+	        lookbehind: true,
+	        alias: 'keyword',
+	        inside: {
+	          punctuation: /<|>/
+	        }
+	      },
+	      'core-rule': {
+	        pattern: RegExp(
+	          '(?:(^|[^<\\w-])' + coreRules + '|<' + coreRules + '>)(?![\\w-])',
+	          'i'
+	        ),
+	        lookbehind: true,
+	        alias: ['rule', 'constant'],
+	        inside: {
+	          punctuation: /<|>/
+	        }
+	      },
+	      rule: {
+	        pattern: /(^|[^<\w-])[a-z][\w-]*|<[^<>\r\n]*>/i,
+	        lookbehind: true,
+	        inside: {
+	          punctuation: /<|>/
+	        }
+	      },
+	      operator: /=\/?|\//,
+	      punctuation: /[()\[\]]/
+	    };
+	  })(Prism);
+	}
+	return abnf_1;
 }
 
-var abnf$2 = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': abnf_1
-}, [abnf_1]);
-
 var actionscript_1 = actionscript$1;
 actionscript$1.displayName = 'actionscript';
 actionscript$1.aliases = [];
@@ -60309,110 +60313,106 @@ var aql$1 = /*#__PURE__*/_mergeNamespaces({
   'default': aql_1
 }, [aql_1]);
 
-var c_1;
-var hasRequiredC;
-
-function requireC () {
-	if (hasRequiredC) return c_1;
-	hasRequiredC = 1;
-
-	c_1 = c;
-	c.displayName = 'c';
-	c.aliases = [];
-	function c(Prism) {
-	  Prism.languages.c = Prism.languages.extend('clike', {
-	    comment: {
-	      pattern:
-	        /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
-	      greedy: true
-	    },
-	    string: {
-	      // https://en.cppreference.com/w/c/language/string_literal
-	      pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
-	      greedy: true
-	    },
-	    'class-name': {
-	      pattern:
-	        /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
-	      lookbehind: true
-	    },
-	    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: true
-	    }
-	  });
-	  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: true,
-	      greedy: true,
-	      alias: 'property',
-	      inside: {
-	        string: [
-	          {
-	            // highlight the path of the include statement as a string
-	            pattern: /^(#\s*include\s*)<[^>]+>/,
-	            lookbehind: true
-	          },
-	          Prism.languages.c['string']
-	        ],
-	        char: Prism.languages.c['char'],
-	        comment: Prism.languages.c['comment'],
-	        'macro-name': [
-	          {
-	            pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
-	            lookbehind: true
-	          },
-	          {
-	            pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
-	            lookbehind: true,
-	            alias: 'function'
-	          }
-	        ],
-	        // highlight macro directives as keywords
-	        directive: {
-	          pattern: /^(#\s*)[a-z]+/,
-	          lookbehind: true,
-	          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'];
-	}
-	return c_1;
+var c_1 = c$1;
+c$1.displayName = 'c';
+c$1.aliases = [];
+function c$1(Prism) {
+  Prism.languages.c = Prism.languages.extend('clike', {
+    comment: {
+      pattern:
+        /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
+      greedy: true
+    },
+    string: {
+      // https://en.cppreference.com/w/c/language/string_literal
+      pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+      greedy: true
+    },
+    'class-name': {
+      pattern:
+        /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
+      lookbehind: true
+    },
+    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: true
+    }
+  });
+  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: true,
+      greedy: true,
+      alias: 'property',
+      inside: {
+        string: [
+          {
+            // highlight the path of the include statement as a string
+            pattern: /^(#\s*include\s*)<[^>]+>/,
+            lookbehind: true
+          },
+          Prism.languages.c['string']
+        ],
+        char: Prism.languages.c['char'],
+        comment: Prism.languages.c['comment'],
+        'macro-name': [
+          {
+            pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
+            lookbehind: true
+          },
+          {
+            pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
+            lookbehind: true,
+            alias: 'function'
+          }
+        ],
+        // highlight macro directives as keywords
+        directive: {
+          pattern: /^(#\s*)[a-z]+/,
+          lookbehind: true,
+          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 c$2 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': c_1
+}, [c_1]);
+
 var cpp_1;
 var hasRequiredCpp;
 
 function requireCpp () {
 	if (hasRequiredCpp) return cpp_1;
 	hasRequiredCpp = 1;
-	var refractorC = requireC();
+	var refractorC = c_1;
 	cpp_1 = cpp;
 	cpp.displayName = 'cpp';
 	cpp.aliases = [];
@@ -60533,12 +60533,12 @@ function requireCpp () {
 	return cpp_1;
 }
 
-var refractorCpp = requireCpp();
+var refractorCpp$1 = requireCpp();
 var arduino_1 = arduino$1;
 arduino$1.displayName = 'arduino';
 arduino$1.aliases = ['ino'];
 function arduino$1(Prism) {
-  Prism.register(refractorCpp);
+  Prism.register(refractorCpp$1);
   Prism.languages.arduino = Prism.languages.extend('cpp', {
     keyword:
       /\b(?:String|array|bool|boolean|break|byte|case|catch|continue|default|do|double|else|finally|for|function|goto|if|in|instanceof|int|integer|long|loop|new|null|return|setup|string|switch|throw|try|void|while|word)\b/,
@@ -61539,1258 +61539,1196 @@ var autoit$2 = /*#__PURE__*/_mergeNamespaces({
   'default': autoit_1
 }, [autoit_1]);
 
-var avisynth_1;
-var hasRequiredAvisynth;
-
-function requireAvisynth () {
-	if (hasRequiredAvisynth) return avisynth_1;
-	hasRequiredAvisynth = 1;
-
-	avisynth_1 = avisynth;
-	avisynth.displayName = 'avisynth';
-	avisynth.aliases = ['avs'];
-	function avisynth(Prism) {
+var avisynth_1 = avisynth;
+avisynth.displayName = 'avisynth';
+avisynth.aliases = ['avs'];
+function avisynth(Prism) {
 (function (Prism) {
-	    function replace(pattern, replacements) {
-	      return pattern.replace(/<<(\d+)>>/g, function (m, index) {
-	        return replacements[+index]
-	      })
-	    }
-	    function re(pattern, replacements, flags) {
-	      return RegExp(replace(pattern, replacements), flags || '')
-	    }
-	    var types = /bool|clip|float|int|string|val/.source;
-	    var internals = [
-	      // bools
-	      /is(?:bool|clip|float|int|string)|defined|(?:(?:internal)?function|var)?exists?/
-	        .source, // control
-	      /apply|assert|default|eval|import|nop|select|undefined/.source, // global
-	      /opt_(?:allowfloataudio|avipadscanlines|dwchannelmask|enable_(?:b64a|planartopackedrgb|v210|y3_10_10|y3_10_16)|usewaveextensible|vdubplanarhack)|set(?:cachemode|maxcpu|memorymax|planarlegacyalignment|workingdir)/
-	        .source, // conv
-	      /hex(?:value)?|value/.source, // numeric
-	      /abs|ceil|continued(?:denominator|numerator)?|exp|floor|fmod|frac|log(?:10)?|max|min|muldiv|pi|pow|rand|round|sign|spline|sqrt/
-	        .source, // trig
-	      /a?sinh?|a?cosh?|a?tan[2h]?/.source, // bit
-	      /(?:bit(?:and|not|x?or|[lr]?shift[aslu]?|sh[lr]|sa[lr]|[lr]rotatel?|ro[rl]|te?st|set(?:count)?|cl(?:ea)?r|ch(?:an)?ge?))/
-	        .source, // runtime
-	      /average(?:[bgr]|chroma[uv]|luma)|(?:[rgb]|chroma[uv]|luma|rgb|[yuv](?=difference(?:fromprevious|tonext)))difference(?:fromprevious|tonext)?|[yuvrgb]plane(?:median|min|max|minmaxdifference)/
-	        .source, // script
-	      /getprocessinfo|logmsg|script(?:dir(?:utf8)?|file(?:utf8)?|name(?:utf8)?)|setlogparams/
-	        .source, // string
-	      /chr|(?:fill|find|left|mid|replace|rev|right)str|format|[lu]case|ord|str(?:cmpi?|fromutf8|len|toutf8)|time|trim(?:all|left|right)/
-	        .source, // version
-	      /isversionorgreater|version(?:number|string)/.source, // helper
-	      /buildpixeltype|colorspacenametopixeltype/.source, // avsplus
-	      /addautoloaddir|on(?:cpu|cuda)|prefetch|setfiltermtmode/.source
-	    ].join('|');
-	    var properties = [
-	      // content
-	      /has(?:audio|video)/.source, // resolution
-	      /height|width/.source, // framerate
-	      /frame(?:count|rate)|framerate(?:denominator|numerator)/.source, // interlacing
-	      /getparity|is(?:field|frame)based/.source, // color format
-	      /bitspercomponent|componentsize|hasalpha|is(?:planar(?:rgba?)?|interleaved|rgb(?:24|32|48|64)?|y(?:8|u(?:va?|y2))?|yv(?:12|16|24|411)|420|422|444|packedrgb)|numcomponents|pixeltype/
-	        .source, // audio
-	      /audio(?:bits|channels|duration|length(?:[fs]|hi|lo)?|rate)|isaudio(?:float|int)/
-	        .source
-	    ].join('|');
-	    var filters = [
-	      // source
-	      /avi(?:file)?source|directshowsource|image(?:reader|source|sourceanim)|opendmlsource|segmented(?:avisource|directshowsource)|wavsource/
-	        .source, // color
-	      /coloryuv|convertbacktoyuy2|convertto(?:RGB(?:24|32|48|64)|(?:planar)?RGBA?|Y8?|YV(?:12|16|24|411)|YUVA?(?:411|420|422|444)|YUY2)|fixluminance|gr[ae]yscale|invert|levels|limiter|mergea?rgb|merge(?:chroma|luma)|rgbadjust|show(?:alpha|blue|green|red)|swapuv|tweak|[uv]toy8?|ytouv/
-	        .source, // overlay
-	      /(?:colorkey|reset)mask|layer|mask(?:hs)?|merge|overlay|subtract/.source, // geometry
-	      /addborders|(?:bicubic|bilinear|blackman|gauss|lanczos4|lanczos|point|sinc|spline(?:16|36|64))resize|crop(?:bottom)?|flip(?:horizontal|vertical)|(?:horizontal|vertical)?reduceby2|letterbox|skewrows|turn(?:180|left|right)/
-	        .source, // pixel
-	      /blur|fixbrokenchromaupsampling|generalconvolution|(?:spatial|temporal)soften|sharpen/
-	        .source, // timeline
-	      /trim|(?:un)?alignedsplice|(?:assume|assumescaled|change|convert)FPS|(?:delete|duplicate)frame|dissolve|fade(?:in|io|out)[02]?|freezeframe|interleave|loop|reverse|select(?:even|odd|(?:range)?every)/
-	        .source, // interlace
-	      /assume[bt]ff|assume(?:field|frame)based|bob|complementparity|doubleweave|peculiarblend|pulldown|separate(?:columns|fields|rows)|swapfields|weave(?:columns|rows)?/
-	        .source, // audio
-	      /amplify(?:db)?|assumesamplerate|audiodub(?:ex)?|audiotrim|convertaudioto(?:(?:8|16|24|32)bit|float)|converttomono|delayaudio|ensurevbrmp3sync|get(?:left|right)?channel|kill(?:audio|video)|mergechannels|mixaudio|monotostereo|normalize|resampleaudio|ssrc|supereq|timestretch/
-	        .source, // conditional
-	      /animate|applyrange|conditional(?:filter|reader|select)|frameevaluate|scriptclip|tcp(?:server|source)|writefile(?:end|if|start)?/
-	        .source, // export
-	      /imagewriter/.source, // debug
-	      /blackness|blankclip|colorbars(?:hd)?|compare|dumpfiltergraph|echo|histogram|info|messageclip|preroll|setgraphanalysis|show(?:framenumber|smpte|time)|showfiveversions|stack(?:horizontal|vertical)|subtitle|tone|version/
-	        .source
-	    ].join('|');
-	    var allinternals = [internals, properties, filters].join('|');
-	    Prism.languages.avisynth = {
-	      comment: [
-	        {
-	          // Matches [* *] nestable block comments, but only supports 1 level of nested comments
-	          // /\[\*(?:[^\[*]|\[(?!\*)|\*(?!\])|<self>)*\*\]/
-	          pattern:
-	            /(^|[^\\])\[\*(?:[^\[*]|\[(?!\*)|\*(?!\])|\[\*(?:[^\[*]|\[(?!\*)|\*(?!\]))*\*\])*\*\]/,
-	          lookbehind: true,
-	          greedy: true
-	        },
-	        {
-	          // Matches /* */ block comments
-	          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
-	          lookbehind: true,
-	          greedy: true
-	        },
-	        {
-	          // Matches # comments
-	          pattern: /(^|[^\\$])#.*/,
-	          lookbehind: true,
-	          greedy: true
-	        }
-	      ],
-	      // Handle before strings because optional arguments are surrounded by double quotes
-	      argument: {
-	        pattern: re(/\b(?:<<0>>)\s+("?)\w+\1/.source, [types], 'i'),
-	        inside: {
-	          keyword: /^\w+/
-	        }
-	      },
-	      // Optional argument assignment
-	      'argument-label': {
-	        pattern: /([,(][\s\\]*)\w+\s*=(?!=)/,
-	        lookbehind: true,
-	        inside: {
-	          'argument-name': {
-	            pattern: /^\w+/,
-	            alias: 'punctuation'
-	          },
-	          punctuation: /=$/
-	        }
-	      },
-	      string: [
-	        {
-	          // triple double-quoted
-	          pattern: /"""[\s\S]*?"""/,
-	          greedy: true
-	        },
-	        {
-	          // single double-quoted
-	          pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
-	          greedy: true,
-	          inside: {
-	            constant: {
-	              // These *are* case-sensitive!
-	              pattern:
-	                /\b(?:DEFAULT_MT_MODE|(?:MAINSCRIPT|PROGRAM|SCRIPT)DIR|(?:MACHINE|USER)_(?:CLASSIC|PLUS)_PLUGINS)\b/
-	            }
-	          }
-	        }
-	      ],
-	      // The special "last" variable that takes the value of the last implicitly returned clip
-	      variable: /\b(?:last)\b/i,
-	      boolean: /\b(?:false|no|true|yes)\b/i,
-	      keyword:
-	        /\b(?:catch|else|for|function|global|if|return|try|while|__END__)\b/i,
-	      constant: /\bMT_(?:MULTI_INSTANCE|NICE_FILTER|SERIALIZED|SPECIAL_MT)\b/,
-	      // AviSynth's internal functions, filters, and properties
-	      'builtin-function': {
-	        pattern: re(/\b(?:<<0>>)\b/.source, [allinternals], 'i'),
-	        alias: 'function'
-	      },
-	      'type-cast': {
-	        pattern: re(/\b(?:<<0>>)(?=\s*\()/.source, [types], 'i'),
-	        alias: 'keyword'
-	      },
-	      // External/user-defined filters
-	      function: {
-	        pattern: /\b[a-z_]\w*(?=\s*\()|(\.)[a-z_]\w*\b/i,
-	        lookbehind: true
-	      },
-	      // Matches a \ as the first or last character on a line
-	      'line-continuation': {
-	        pattern: /(^[ \t]*)\\|\\(?=[ \t]*$)/m,
-	        lookbehind: true,
-	        alias: 'punctuation'
-	      },
-	      number:
-	        /\B\$(?:[\da-f]{6}|[\da-f]{8})\b|(?:(?:\b|\B-)\d+(?:\.\d*)?\b|\B\.\d+\b)/i,
-	      operator: /\+\+?|[!=<>]=?|&&|\|\||[?:*/%-]/,
-	      punctuation: /[{}\[\]();,.]/
-	    };
-	    Prism.languages.avs = Prism.languages.avisynth;
-	  })(Prism);
-	}
-	return avisynth_1;
+    function replace(pattern, replacements) {
+      return pattern.replace(/<<(\d+)>>/g, function (m, index) {
+        return replacements[+index]
+      })
+    }
+    function re(pattern, replacements, flags) {
+      return RegExp(replace(pattern, replacements), flags || '')
+    }
+    var types = /bool|clip|float|int|string|val/.source;
+    var internals = [
+      // bools
+      /is(?:bool|clip|float|int|string)|defined|(?:(?:internal)?function|var)?exists?/
+        .source, // control
+      /apply|assert|default|eval|import|nop|select|undefined/.source, // global
+      /opt_(?:allowfloataudio|avipadscanlines|dwchannelmask|enable_(?:b64a|planartopackedrgb|v210|y3_10_10|y3_10_16)|usewaveextensible|vdubplanarhack)|set(?:cachemode|maxcpu|memorymax|planarlegacyalignment|workingdir)/
+        .source, // conv
+      /hex(?:value)?|value/.source, // numeric
+      /abs|ceil|continued(?:denominator|numerator)?|exp|floor|fmod|frac|log(?:10)?|max|min|muldiv|pi|pow|rand|round|sign|spline|sqrt/
+        .source, // trig
+      /a?sinh?|a?cosh?|a?tan[2h]?/.source, // bit
+      /(?:bit(?:and|not|x?or|[lr]?shift[aslu]?|sh[lr]|sa[lr]|[lr]rotatel?|ro[rl]|te?st|set(?:count)?|cl(?:ea)?r|ch(?:an)?ge?))/
+        .source, // runtime
+      /average(?:[bgr]|chroma[uv]|luma)|(?:[rgb]|chroma[uv]|luma|rgb|[yuv](?=difference(?:fromprevious|tonext)))difference(?:fromprevious|tonext)?|[yuvrgb]plane(?:median|min|max|minmaxdifference)/
+        .source, // script
+      /getprocessinfo|logmsg|script(?:dir(?:utf8)?|file(?:utf8)?|name(?:utf8)?)|setlogparams/
+        .source, // string
+      /chr|(?:fill|find|left|mid|replace|rev|right)str|format|[lu]case|ord|str(?:cmpi?|fromutf8|len|toutf8)|time|trim(?:all|left|right)/
+        .source, // version
+      /isversionorgreater|version(?:number|string)/.source, // helper
+      /buildpixeltype|colorspacenametopixeltype/.source, // avsplus
+      /addautoloaddir|on(?:cpu|cuda)|prefetch|setfiltermtmode/.source
+    ].join('|');
+    var properties = [
+      // content
+      /has(?:audio|video)/.source, // resolution
+      /height|width/.source, // framerate
+      /frame(?:count|rate)|framerate(?:denominator|numerator)/.source, // interlacing
+      /getparity|is(?:field|frame)based/.source, // color format
+      /bitspercomponent|componentsize|hasalpha|is(?:planar(?:rgba?)?|interleaved|rgb(?:24|32|48|64)?|y(?:8|u(?:va?|y2))?|yv(?:12|16|24|411)|420|422|444|packedrgb)|numcomponents|pixeltype/
+        .source, // audio
+      /audio(?:bits|channels|duration|length(?:[fs]|hi|lo)?|rate)|isaudio(?:float|int)/
+        .source
+    ].join('|');
+    var filters = [
+      // source
+      /avi(?:file)?source|directshowsource|image(?:reader|source|sourceanim)|opendmlsource|segmented(?:avisource|directshowsource)|wavsource/
+        .source, // color
+      /coloryuv|convertbacktoyuy2|convertto(?:RGB(?:24|32|48|64)|(?:planar)?RGBA?|Y8?|YV(?:12|16|24|411)|YUVA?(?:411|420|422|444)|YUY2)|fixluminance|gr[ae]yscale|invert|levels|limiter|mergea?rgb|merge(?:chroma|luma)|rgbadjust|show(?:alpha|blue|green|red)|swapuv|tweak|[uv]toy8?|ytouv/
+        .source, // overlay
+      /(?:colorkey|reset)mask|layer|mask(?:hs)?|merge|overlay|subtract/.source, // geometry
+      /addborders|(?:bicubic|bilinear|blackman|gauss|lanczos4|lanczos|point|sinc|spline(?:16|36|64))resize|crop(?:bottom)?|flip(?:horizontal|vertical)|(?:horizontal|vertical)?reduceby2|letterbox|skewrows|turn(?:180|left|right)/
+        .source, // pixel
+      /blur|fixbrokenchromaupsampling|generalconvolution|(?:spatial|temporal)soften|sharpen/
+        .source, // timeline
+      /trim|(?:un)?alignedsplice|(?:assume|assumescaled|change|convert)FPS|(?:delete|duplicate)frame|dissolve|fade(?:in|io|out)[02]?|freezeframe|interleave|loop|reverse|select(?:even|odd|(?:range)?every)/
+        .source, // interlace
+      /assume[bt]ff|assume(?:field|frame)based|bob|complementparity|doubleweave|peculiarblend|pulldown|separate(?:columns|fields|rows)|swapfields|weave(?:columns|rows)?/
+        .source, // audio
+      /amplify(?:db)?|assumesamplerate|audiodub(?:ex)?|audiotrim|convertaudioto(?:(?:8|16|24|32)bit|float)|converttomono|delayaudio|ensurevbrmp3sync|get(?:left|right)?channel|kill(?:audio|video)|mergechannels|mixaudio|monotostereo|normalize|resampleaudio|ssrc|supereq|timestretch/
+        .source, // conditional
+      /animate|applyrange|conditional(?:filter|reader|select)|frameevaluate|scriptclip|tcp(?:server|source)|writefile(?:end|if|start)?/
+        .source, // export
+      /imagewriter/.source, // debug
+      /blackness|blankclip|colorbars(?:hd)?|compare|dumpfiltergraph|echo|histogram|info|messageclip|preroll|setgraphanalysis|show(?:framenumber|smpte|time)|showfiveversions|stack(?:horizontal|vertical)|subtitle|tone|version/
+        .source
+    ].join('|');
+    var allinternals = [internals, properties, filters].join('|');
+    Prism.languages.avisynth = {
+      comment: [
+        {
+          // Matches [* *] nestable block comments, but only supports 1 level of nested comments
+          // /\[\*(?:[^\[*]|\[(?!\*)|\*(?!\])|<self>)*\*\]/
+          pattern:
+            /(^|[^\\])\[\*(?:[^\[*]|\[(?!\*)|\*(?!\])|\[\*(?:[^\[*]|\[(?!\*)|\*(?!\]))*\*\])*\*\]/,
+          lookbehind: true,
+          greedy: true
+        },
+        {
+          // Matches /* */ block comments
+          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+          lookbehind: true,
+          greedy: true
+        },
+        {
+          // Matches # comments
+          pattern: /(^|[^\\$])#.*/,
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      // Handle before strings because optional arguments are surrounded by double quotes
+      argument: {
+        pattern: re(/\b(?:<<0>>)\s+("?)\w+\1/.source, [types], 'i'),
+        inside: {
+          keyword: /^\w+/
+        }
+      },
+      // Optional argument assignment
+      'argument-label': {
+        pattern: /([,(][\s\\]*)\w+\s*=(?!=)/,
+        lookbehind: true,
+        inside: {
+          'argument-name': {
+            pattern: /^\w+/,
+            alias: 'punctuation'
+          },
+          punctuation: /=$/
+        }
+      },
+      string: [
+        {
+          // triple double-quoted
+          pattern: /"""[\s\S]*?"""/,
+          greedy: true
+        },
+        {
+          // single double-quoted
+          pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+          greedy: true,
+          inside: {
+            constant: {
+              // These *are* case-sensitive!
+              pattern:
+                /\b(?:DEFAULT_MT_MODE|(?:MAINSCRIPT|PROGRAM|SCRIPT)DIR|(?:MACHINE|USER)_(?:CLASSIC|PLUS)_PLUGINS)\b/
+            }
+          }
+        }
+      ],
+      // The special "last" variable that takes the value of the last implicitly returned clip
+      variable: /\b(?:last)\b/i,
+      boolean: /\b(?:false|no|true|yes)\b/i,
+      keyword:
+        /\b(?:catch|else|for|function|global|if|return|try|while|__END__)\b/i,
+      constant: /\bMT_(?:MULTI_INSTANCE|NICE_FILTER|SERIALIZED|SPECIAL_MT)\b/,
+      // AviSynth's internal functions, filters, and properties
+      'builtin-function': {
+        pattern: re(/\b(?:<<0>>)\b/.source, [allinternals], 'i'),
+        alias: 'function'
+      },
+      'type-cast': {
+        pattern: re(/\b(?:<<0>>)(?=\s*\()/.source, [types], 'i'),
+        alias: 'keyword'
+      },
+      // External/user-defined filters
+      function: {
+        pattern: /\b[a-z_]\w*(?=\s*\()|(\.)[a-z_]\w*\b/i,
+        lookbehind: true
+      },
+      // Matches a \ as the first or last character on a line
+      'line-continuation': {
+        pattern: /(^[ \t]*)\\|\\(?=[ \t]*$)/m,
+        lookbehind: true,
+        alias: 'punctuation'
+      },
+      number:
+        /\B\$(?:[\da-f]{6}|[\da-f]{8})\b|(?:(?:\b|\B-)\d+(?:\.\d*)?\b|\B\.\d+\b)/i,
+      operator: /\+\+?|[!=<>]=?|&&|\|\||[?:*/%-]/,
+      punctuation: /[{}\[\]();,.]/
+    };
+    Prism.languages.avs = Prism.languages.avisynth;
+  })(Prism);
 }
 
-var avroIdl_1;
-var hasRequiredAvroIdl;
+var avisynth$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': avisynth_1
+}, [avisynth_1]);
+
+var avroIdl_1 = avroIdl;
+avroIdl.displayName = 'avroIdl';
+avroIdl.aliases = [];
+function avroIdl(Prism) {
+  // GitHub: https://github.com/apache/avro
+  // Docs: https://avro.apache.org/docs/current/idl.html
+  Prism.languages['avro-idl'] = {
+    comment: {
+      pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+      greedy: true
+    },
+    string: {
+      pattern: /(^|[^\\])"(?:[^\r\n"\\]|\\.)*"/,
+      lookbehind: true,
+      greedy: true
+    },
+    annotation: {
+      pattern: /@(?:[$\w.-]|`[^\r\n`]+`)+/,
+      greedy: true,
+      alias: 'function'
+    },
+    'function-identifier': {
+      pattern: /`[^\r\n`]+`(?=\s*\()/,
+      greedy: true,
+      alias: 'function'
+    },
+    identifier: {
+      pattern: /`[^\r\n`]+`/,
+      greedy: true
+    },
+    'class-name': {
+      pattern: /(\b(?:enum|error|protocol|record|throws)\b\s+)[$\w]+/,
+      lookbehind: true,
+      greedy: true
+    },
+    keyword:
+      /\b(?:array|boolean|bytes|date|decimal|double|enum|error|false|fixed|float|idl|import|int|local_timestamp_ms|long|map|null|oneway|protocol|record|schema|string|throws|time_ms|timestamp_ms|true|union|uuid|void)\b/,
+    function: /\b[a-z_]\w*(?=\s*\()/i,
+    number: [
+      {
+        pattern:
+          /(^|[^\w.])-?(?:(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|0x(?:[a-f0-9]+(?:\.[a-f0-9]*)?|\.[a-f0-9]+)(?:p[+-]?\d+)?)[dfl]?(?![\w.])/i,
+        lookbehind: true
+      },
+      /-?\b(?:Infinity|NaN)\b/
+    ],
+    operator: /=/,
+    punctuation: /[()\[\]{}<>.:,;-]/
+  };
+  Prism.languages.avdl = Prism.languages['avro-idl'];
+}
 
-function requireAvroIdl () {
-	if (hasRequiredAvroIdl) return avroIdl_1;
-	hasRequiredAvroIdl = 1;
+var avroIdl$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': avroIdl_1
+}, [avroIdl_1]);
 
-	avroIdl_1 = avroIdl;
-	avroIdl.displayName = 'avroIdl';
-	avroIdl.aliases = [];
-	function avroIdl(Prism) {
-	  // GitHub: https://github.com/apache/avro
-	  // Docs: https://avro.apache.org/docs/current/idl.html
-	  Prism.languages['avro-idl'] = {
-	    comment: {
-	      pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
-	      greedy: true
-	    },
-	    string: {
-	      pattern: /(^|[^\\])"(?:[^\r\n"\\]|\\.)*"/,
-	      lookbehind: true,
-	      greedy: true
-	    },
-	    annotation: {
-	      pattern: /@(?:[$\w.-]|`[^\r\n`]+`)+/,
-	      greedy: true,
-	      alias: 'function'
-	    },
-	    'function-identifier': {
-	      pattern: /`[^\r\n`]+`(?=\s*\()/,
-	      greedy: true,
-	      alias: 'function'
-	    },
-	    identifier: {
-	      pattern: /`[^\r\n`]+`/,
-	      greedy: true
-	    },
-	    'class-name': {
-	      pattern: /(\b(?:enum|error|protocol|record|throws)\b\s+)[$\w]+/,
-	      lookbehind: true,
-	      greedy: true
-	    },
-	    keyword:
-	      /\b(?:array|boolean|bytes|date|decimal|double|enum|error|false|fixed|float|idl|import|int|local_timestamp_ms|long|map|null|oneway|protocol|record|schema|string|throws|time_ms|timestamp_ms|true|union|uuid|void)\b/,
-	    function: /\b[a-z_]\w*(?=\s*\()/i,
-	    number: [
-	      {
-	        pattern:
-	          /(^|[^\w.])-?(?:(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|0x(?:[a-f0-9]+(?:\.[a-f0-9]*)?|\.[a-f0-9]+)(?:p[+-]?\d+)?)[dfl]?(?![\w.])/i,
-	        lookbehind: true
-	      },
-	      /-?\b(?:Infinity|NaN)\b/
-	    ],
-	    operator: /=/,
-	    punctuation: /[()\[\]{}<>.:,;-]/
-	  };
-	  Prism.languages.avdl = Prism.languages['avro-idl'];
-	}
-	return avroIdl_1;
+var bash_1 = bash$1;
+bash$1.displayName = 'bash';
+bash$1.aliases = ['shell'];
+function bash$1(Prism) {
+(function (Prism) {
+    // $ set | grep '^[A-Z][^[:space:]]*=' | cut -d= -f1 | tr '\n' '|'
+    // + LC_ALL, RANDOM, REPLY, SECONDS.
+    // + make sure PS1..4 are here as they are not always set,
+    // - some useless things.
+    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})/
+    };
+    Prism.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+(?=\+?=)/,
+        inside: {
+          environment: {
+            pattern: RegExp('(^|[\\s;|&]|[<>]\\()' + envVars),
+            lookbehind: true,
+            alias: 'constant'
+          }
+        },
+        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|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|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|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 = Prism.languages.bash;
+    /* Patterns in command substitution. */
+    var toBeCopied = [
+      'comment',
+      'function-name',
+      'for-or-select',
+      'assign-left',
+      '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]] = Prism.languages.bash[toBeCopied[i]];
+    }
+    Prism.languages.shell = Prism.languages.bash;
+  })(Prism);
 }
 
-var bash_1;
-var hasRequiredBash;
+var bash$2 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': bash_1
+}, [bash_1]);
+
+var basic_1 = basic$1;
+basic$1.displayName = 'basic';
+basic$1.aliases = [];
+function basic$1(Prism) {
+  Prism.languages.basic = {
+    comment: {
+      pattern: /(?:!|REM\b).+/i,
+      inside: {
+        keyword: /^REM/i
+      }
+    },
+    string: {
+      pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
+      greedy: true
+    },
+    number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
+    keyword:
+      /\b(?:AS|BEEP|BLOAD|BSAVE|CALL(?: ABSOLUTE)?|CASE|CHAIN|CHDIR|CLEAR|CLOSE|CLS|COM|COMMON|CONST|DATA|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DIM|DO|DOUBLE|ELSE|ELSEIF|END|ENVIRON|ERASE|ERROR|EXIT|FIELD|FILES|FOR|FUNCTION|GET|GOSUB|GOTO|IF|INPUT|INTEGER|IOCTL|KEY|KILL|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|MKDIR|NAME|NEXT|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPTION BASE|OUT|POKE|PUT|READ|REDIM|REM|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SELECT CASE|SHARED|SHELL|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|SUB|SWAP|SYSTEM|THEN|TIMER|TO|TROFF|TRON|TYPE|UNLOCK|UNTIL|USING|VIEW PRINT|WAIT|WEND|WHILE|WRITE)(?:\$|\b)/i,
+    function:
+      /\b(?:ABS|ACCESS|ACOS|ANGLE|AREA|ARITHMETIC|ARRAY|ASIN|ASK|AT|ATN|BASE|BEGIN|BREAK|CAUSE|CEIL|CHR|CLIP|COLLATE|COLOR|CON|COS|COSH|COT|CSC|DATE|DATUM|DEBUG|DECIMAL|DEF|DEG|DEGREES|DELETE|DET|DEVICE|DISPLAY|DOT|ELAPSED|EPS|ERASABLE|EXLINE|EXP|EXTERNAL|EXTYPE|FILETYPE|FIXED|FP|GO|GRAPH|HANDLER|IDN|IMAGE|IN|INT|INTERNAL|IP|IS|KEYED|LBOUND|LCASE|LEFT|LEN|LENGTH|LET|LINE|LINES|LOG|LOG10|LOG2|LTRIM|MARGIN|MAT|MAX|MAXNUM|MID|MIN|MISSING|MOD|NATIVE|NUL|NUMERIC|OF|OPTION|ORD|ORGANIZATION|OUTIN|OUTPUT|PI|POINT|POINTER|POINTS|POS|PRINT|PROGRAM|PROMPT|RAD|RADIANS|RANDOMIZE|RECORD|RECSIZE|RECTYPE|RELATIVE|REMAINDER|REPEAT|REST|RETRY|REWRITE|RIGHT|RND|ROUND|RTRIM|SAME|SEC|SELECT|SEQUENTIAL|SET|SETTER|SGN|SIN|SINH|SIZE|SKIP|SQR|STANDARD|STATUS|STR|STREAM|STYLE|TAB|TAN|TANH|TEMPLATE|TEXT|THERE|TIME|TIMEOUT|TRACE|TRANSFORM|TRUNCATE|UBOUND|UCASE|USE|VAL|VARIABLE|VIEWPORT|WHEN|WINDOW|WITH|ZER|ZONEWIDTH)(?:\$|\b)/i,
+    operator: /<[=>]?|>=?|[+\-*\/^=&]|\b(?:AND|EQV|IMP|NOT|OR|XOR)\b/i,
+    punctuation: /[,;:()]/
+  };
+}
 
-function requireBash () {
-	if (hasRequiredBash) return bash_1;
-	hasRequiredBash = 1;
+var basic$2 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': basic_1
+}, [basic_1]);
 
-	bash_1 = bash;
-	bash.displayName = 'bash';
-	bash.aliases = ['shell'];
-	function bash(Prism) {
+var batch_1 = batch;
+batch.displayName = 'batch';
+batch.aliases = [];
+function batch(Prism) {
 (function (Prism) {
-	    // $ set | grep '^[A-Z][^[:space:]]*=' | cut -d= -f1 | tr '\n' '|'
-	    // + LC_ALL, RANDOM, REPLY, SECONDS.
-	    // + make sure PS1..4 are here as they are not always set,
-	    // - some useless things.
-	    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})/
-	    };
-	    Prism.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+(?=\+?=)/,
-	        inside: {
-	          environment: {
-	            pattern: RegExp('(^|[\\s;|&]|[<>]\\()' + envVars),
-	            lookbehind: true,
-	            alias: 'constant'
-	          }
-	        },
-	        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|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|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|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 = Prism.languages.bash;
-	    /* Patterns in command substitution. */
-	    var toBeCopied = [
-	      'comment',
-	      'function-name',
-	      'for-or-select',
-	      'assign-left',
-	      '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]] = Prism.languages.bash[toBeCopied[i]];
-	    }
-	    Prism.languages.shell = Prism.languages.bash;
-	  })(Prism);
-	}
-	return bash_1;
-}
-
-var basic_1;
-var hasRequiredBasic;
-
-function requireBasic () {
-	if (hasRequiredBasic) return basic_1;
-	hasRequiredBasic = 1;
-
-	basic_1 = basic;
-	basic.displayName = 'basic';
-	basic.aliases = [];
-	function basic(Prism) {
-	  Prism.languages.basic = {
-	    comment: {
-	      pattern: /(?:!|REM\b).+/i,
-	      inside: {
-	        keyword: /^REM/i
-	      }
-	    },
-	    string: {
-	      pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
-	      greedy: true
-	    },
-	    number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
-	    keyword:
-	      /\b(?:AS|BEEP|BLOAD|BSAVE|CALL(?: ABSOLUTE)?|CASE|CHAIN|CHDIR|CLEAR|CLOSE|CLS|COM|COMMON|CONST|DATA|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DIM|DO|DOUBLE|ELSE|ELSEIF|END|ENVIRON|ERASE|ERROR|EXIT|FIELD|FILES|FOR|FUNCTION|GET|GOSUB|GOTO|IF|INPUT|INTEGER|IOCTL|KEY|KILL|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|MKDIR|NAME|NEXT|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPTION BASE|OUT|POKE|PUT|READ|REDIM|REM|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SELECT CASE|SHARED|SHELL|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|SUB|SWAP|SYSTEM|THEN|TIMER|TO|TROFF|TRON|TYPE|UNLOCK|UNTIL|USING|VIEW PRINT|WAIT|WEND|WHILE|WRITE)(?:\$|\b)/i,
-	    function:
-	      /\b(?:ABS|ACCESS|ACOS|ANGLE|AREA|ARITHMETIC|ARRAY|ASIN|ASK|AT|ATN|BASE|BEGIN|BREAK|CAUSE|CEIL|CHR|CLIP|COLLATE|COLOR|CON|COS|COSH|COT|CSC|DATE|DATUM|DEBUG|DECIMAL|DEF|DEG|DEGREES|DELETE|DET|DEVICE|DISPLAY|DOT|ELAPSED|EPS|ERASABLE|EXLINE|EXP|EXTERNAL|EXTYPE|FILETYPE|FIXED|FP|GO|GRAPH|HANDLER|IDN|IMAGE|IN|INT|INTERNAL|IP|IS|KEYED|LBOUND|LCASE|LEFT|LEN|LENGTH|LET|LINE|LINES|LOG|LOG10|LOG2|LTRIM|MARGIN|MAT|MAX|MAXNUM|MID|MIN|MISSING|MOD|NATIVE|NUL|NUMERIC|OF|OPTION|ORD|ORGANIZATION|OUTIN|OUTPUT|PI|POINT|POINTER|POINTS|POS|PRINT|PROGRAM|PROMPT|RAD|RADIANS|RANDOMIZE|RECORD|RECSIZE|RECTYPE|RELATIVE|REMAINDER|REPEAT|REST|RETRY|REWRITE|RIGHT|RND|ROUND|RTRIM|SAME|SEC|SELECT|SEQUENTIAL|SET|SETTER|SGN|SIN|SINH|SIZE|SKIP|SQR|STANDARD|STATUS|STR|STREAM|STYLE|TAB|TAN|TANH|TEMPLATE|TEXT|THERE|TIME|TIMEOUT|TRACE|TRANSFORM|TRUNCATE|UBOUND|UCASE|USE|VAL|VARIABLE|VIEWPORT|WHEN|WINDOW|WITH|ZER|ZONEWIDTH)(?:\$|\b)/i,
-	    operator: /<[=>]?|>=?|[+\-*\/^=&]|\b(?:AND|EQV|IMP|NOT|OR|XOR)\b/i,
-	    punctuation: /[,;:()]/
-	  };
-	}
-	return basic_1;
+    var variable = /%%?[~:\w]+%?|!\S+!/;
+    var parameter = {
+      pattern: /\/[a-z?]+(?=[ :]|$):?|-[a-z]\b|--[a-z-]+\b/im,
+      alias: 'attr-name',
+      inside: {
+        punctuation: /:/
+      }
+    };
+    var string = /"(?:[\\"]"|[^"])*"(?!")/;
+    var number = /(?:\b|-)\d+\b/;
+    Prism.languages.batch = {
+      comment: [
+        /^::.*/m,
+        {
+          pattern: /((?:^|[&(])[ \t]*)rem\b(?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
+          lookbehind: true
+        }
+      ],
+      label: {
+        pattern: /^:.*/m,
+        alias: 'property'
+      },
+      command: [
+        {
+          // FOR command
+          pattern:
+            /((?:^|[&(])[ \t]*)for(?: \/[a-z?](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* \S+ in \([^)]+\) do/im,
+          lookbehind: true,
+          inside: {
+            keyword: /\b(?:do|in)\b|^for\b/i,
+            string: string,
+            parameter: parameter,
+            variable: variable,
+            number: number,
+            punctuation: /[()',]/
+          }
+        },
+        {
+          // IF command
+          pattern:
+            /((?:^|[&(])[ \t]*)if(?: \/[a-z?](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* (?:not )?(?:cmdextversion \d+|defined \w+|errorlevel \d+|exist \S+|(?:"[^"]*"|(?!")(?:(?!==)\S)+)?(?:==| (?:equ|geq|gtr|leq|lss|neq) )(?:"[^"]*"|[^\s"]\S*))/im,
+          lookbehind: true,
+          inside: {
+            keyword:
+              /\b(?:cmdextversion|defined|errorlevel|exist|not)\b|^if\b/i,
+            string: string,
+            parameter: parameter,
+            variable: variable,
+            number: number,
+            operator: /\^|==|\b(?:equ|geq|gtr|leq|lss|neq)\b/i
+          }
+        },
+        {
+          // ELSE command
+          pattern: /((?:^|[&()])[ \t]*)else\b/im,
+          lookbehind: true,
+          inside: {
+            keyword: /^else\b/i
+          }
+        },
+        {
+          // SET command
+          pattern:
+            /((?:^|[&(])[ \t]*)set(?: \/[a-z](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* (?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
+          lookbehind: true,
+          inside: {
+            keyword: /^set\b/i,
+            string: string,
+            parameter: parameter,
+            variable: [variable, /\w+(?=(?:[*\/%+\-&^|]|<<|>>)?=)/],
+            number: number,
+            operator: /[*\/%+\-&^|]=?|<<=?|>>=?|[!~_=]/,
+            punctuation: /[()',]/
+          }
+        },
+        {
+          // Other commands
+          pattern:
+            /((?:^|[&(])[ \t]*@?)\w+\b(?:"(?:[\\"]"|[^"])*"(?!")|[^"^&)\r\n]|\^(?:\r\n|[\s\S]))*/m,
+          lookbehind: true,
+          inside: {
+            keyword: /^\w+\b/,
+            string: string,
+            parameter: parameter,
+            label: {
+              pattern: /(^\s*):\S+/m,
+              lookbehind: true,
+              alias: 'property'
+            },
+            variable: variable,
+            number: number,
+            operator: /\^/
+          }
+        }
+      ],
+      operator: /[&@]/,
+      punctuation: /[()']/
+    };
+  })(Prism);
 }
 
-var batch_1;
-var hasRequiredBatch;
-
-function requireBatch () {
-	if (hasRequiredBatch) return batch_1;
-	hasRequiredBatch = 1;
-
-	batch_1 = batch;
-	batch.displayName = 'batch';
-	batch.aliases = [];
-	function batch(Prism) {
-(function (Prism) {
-	    var variable = /%%?[~:\w]+%?|!\S+!/;
-	    var parameter = {
-	      pattern: /\/[a-z?]+(?=[ :]|$):?|-[a-z]\b|--[a-z-]+\b/im,
-	      alias: 'attr-name',
-	      inside: {
-	        punctuation: /:/
-	      }
-	    };
-	    var string = /"(?:[\\"]"|[^"])*"(?!")/;
-	    var number = /(?:\b|-)\d+\b/;
-	    Prism.languages.batch = {
-	      comment: [
-	        /^::.*/m,
-	        {
-	          pattern: /((?:^|[&(])[ \t]*)rem\b(?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
-	          lookbehind: true
-	        }
-	      ],
-	      label: {
-	        pattern: /^:.*/m,
-	        alias: 'property'
-	      },
-	      command: [
-	        {
-	          // FOR command
-	          pattern:
-	            /((?:^|[&(])[ \t]*)for(?: \/[a-z?](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* \S+ in \([^)]+\) do/im,
-	          lookbehind: true,
-	          inside: {
-	            keyword: /\b(?:do|in)\b|^for\b/i,
-	            string: string,
-	            parameter: parameter,
-	            variable: variable,
-	            number: number,
-	            punctuation: /[()',]/
-	          }
-	        },
-	        {
-	          // IF command
-	          pattern:
-	            /((?:^|[&(])[ \t]*)if(?: \/[a-z?](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* (?:not )?(?:cmdextversion \d+|defined \w+|errorlevel \d+|exist \S+|(?:"[^"]*"|(?!")(?:(?!==)\S)+)?(?:==| (?:equ|geq|gtr|leq|lss|neq) )(?:"[^"]*"|[^\s"]\S*))/im,
-	          lookbehind: true,
-	          inside: {
-	            keyword:
-	              /\b(?:cmdextversion|defined|errorlevel|exist|not)\b|^if\b/i,
-	            string: string,
-	            parameter: parameter,
-	            variable: variable,
-	            number: number,
-	            operator: /\^|==|\b(?:equ|geq|gtr|leq|lss|neq)\b/i
-	          }
-	        },
-	        {
-	          // ELSE command
-	          pattern: /((?:^|[&()])[ \t]*)else\b/im,
-	          lookbehind: true,
-	          inside: {
-	            keyword: /^else\b/i
-	          }
-	        },
-	        {
-	          // SET command
-	          pattern:
-	            /((?:^|[&(])[ \t]*)set(?: \/[a-z](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* (?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
-	          lookbehind: true,
-	          inside: {
-	            keyword: /^set\b/i,
-	            string: string,
-	            parameter: parameter,
-	            variable: [variable, /\w+(?=(?:[*\/%+\-&^|]|<<|>>)?=)/],
-	            number: number,
-	            operator: /[*\/%+\-&^|]=?|<<=?|>>=?|[!~_=]/,
-	            punctuation: /[()',]/
-	          }
-	        },
-	        {
-	          // Other commands
-	          pattern:
-	            /((?:^|[&(])[ \t]*@?)\w+\b(?:"(?:[\\"]"|[^"])*"(?!")|[^"^&)\r\n]|\^(?:\r\n|[\s\S]))*/m,
-	          lookbehind: true,
-	          inside: {
-	            keyword: /^\w+\b/,
-	            string: string,
-	            parameter: parameter,
-	            label: {
-	              pattern: /(^\s*):\S+/m,
-	              lookbehind: true,
-	              alias: 'property'
-	            },
-	            variable: variable,
-	            number: number,
-	            operator: /\^/
-	          }
-	        }
-	      ],
-	      operator: /[&@]/,
-	      punctuation: /[()']/
-	    };
-	  })(Prism);
-	}
-	return batch_1;
+var batch$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': batch_1
+}, [batch_1]);
+
+var bbcode_1 = bbcode;
+bbcode.displayName = 'bbcode';
+bbcode.aliases = ['shortcode'];
+function bbcode(Prism) {
+  Prism.languages.bbcode = {
+    tag: {
+      pattern:
+        /\[\/?[^\s=\]]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+))?(?:\s+[^\s=\]]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+))*\s*\]/,
+      inside: {
+        tag: {
+          pattern: /^\[\/?[^\s=\]]+/,
+          inside: {
+            punctuation: /^\[\/?/
+          }
+        },
+        'attr-value': {
+          pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+)/,
+          inside: {
+            punctuation: [
+              /^=/,
+              {
+                pattern: /^(\s*)["']|["']$/,
+                lookbehind: true
+              }
+            ]
+          }
+        },
+        punctuation: /\]/,
+        'attr-name': /[^\s=\]]+/
+      }
+    }
+  };
+  Prism.languages.shortcode = Prism.languages.bbcode;
 }
 
-var bbcode_1;
-var hasRequiredBbcode;
-
-function requireBbcode () {
-	if (hasRequiredBbcode) return bbcode_1;
-	hasRequiredBbcode = 1;
-
-	bbcode_1 = bbcode;
-	bbcode.displayName = 'bbcode';
-	bbcode.aliases = ['shortcode'];
-	function bbcode(Prism) {
-	  Prism.languages.bbcode = {
-	    tag: {
-	      pattern:
-	        /\[\/?[^\s=\]]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+))?(?:\s+[^\s=\]]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+))*\s*\]/,
-	      inside: {
-	        tag: {
-	          pattern: /^\[\/?[^\s=\]]+/,
-	          inside: {
-	            punctuation: /^\[\/?/
-	          }
-	        },
-	        'attr-value': {
-	          pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+)/,
-	          inside: {
-	            punctuation: [
-	              /^=/,
-	              {
-	                pattern: /^(\s*)["']|["']$/,
-	                lookbehind: true
-	              }
-	            ]
-	          }
-	        },
-	        punctuation: /\]/,
-	        'attr-name': /[^\s=\]]+/
-	      }
-	    }
-	  };
-	  Prism.languages.shortcode = Prism.languages.bbcode;
-	}
-	return bbcode_1;
+var bbcode$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': bbcode_1
+}, [bbcode_1]);
+
+var bicep_1 = bicep;
+bicep.displayName = 'bicep';
+bicep.aliases = [];
+function bicep(Prism) {
+  // based loosely upon: https://github.com/Azure/bicep/blob/main/src/textmate/bicep.tmlanguage
+  Prism.languages.bicep = {
+    comment: [
+      {
+        // multiline comments eg /* ASDF */
+        pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+        lookbehind: true,
+        greedy: true
+      },
+      {
+        // singleline comments eg // ASDF
+        pattern: /(^|[^\\:])\/\/.*/,
+        lookbehind: true,
+        greedy: true
+      }
+    ],
+    property: [
+      {
+        pattern: /([\r\n][ \t]*)[a-z_]\w*(?=[ \t]*:)/i,
+        lookbehind: true
+      },
+      {
+        pattern: /([\r\n][ \t]*)'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'(?=[ \t]*:)/,
+        lookbehind: true,
+        greedy: true
+      }
+    ],
+    string: [
+      {
+        pattern: /'''[^'][\s\S]*?'''/,
+        greedy: true
+      },
+      {
+        pattern: /(^|[^\\'])'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'/,
+        lookbehind: true,
+        greedy: true
+      }
+    ],
+    'interpolated-string': {
+      pattern: /(^|[^\\'])'(?:\\.|\$(?:(?!\{)|\{[^{}\r\n]*\})|[^'\\\r\n$])*'/,
+      lookbehind: true,
+      greedy: true,
+      inside: {
+        interpolation: {
+          pattern: /\$\{[^{}\r\n]*\}/,
+          inside: {
+            expression: {
+              pattern: /(^\$\{)[\s\S]+(?=\}$)/,
+              lookbehind: true
+            },
+            punctuation: /^\$\{|\}$/
+          }
+        },
+        string: /[\s\S]+/
+      }
+    },
+    datatype: {
+      pattern: /(\b(?:output|param)\b[ \t]+\w+[ \t]+)\w+\b/,
+      lookbehind: true,
+      alias: 'class-name'
+    },
+    boolean: /\b(?:false|true)\b/,
+    // https://github.com/Azure/bicep/blob/114a3251b4e6e30082a58729f19a8cc4e374ffa6/src/textmate/bicep.tmlanguage#L184
+    keyword:
+      /\b(?:existing|for|if|in|module|null|output|param|resource|targetScope|var)\b/,
+    decorator: /@\w+\b/,
+    function: /\b[a-z_]\w*(?=[ \t]*\()/i,
+    number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
+    operator:
+      /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/,
+    punctuation: /[{}[\];(),.:]/
+  };
+  Prism.languages.bicep['interpolated-string'].inside['interpolation'].inside[
+    'expression'
+  ].inside = Prism.languages.bicep;
 }
 
-var bicep_1;
-var hasRequiredBicep;
-
-function requireBicep () {
-	if (hasRequiredBicep) return bicep_1;
-	hasRequiredBicep = 1;
-
-	bicep_1 = bicep;
-	bicep.displayName = 'bicep';
-	bicep.aliases = [];
-	function bicep(Prism) {
-	  // based loosely upon: https://github.com/Azure/bicep/blob/main/src/textmate/bicep.tmlanguage
-	  Prism.languages.bicep = {
-	    comment: [
-	      {
-	        // multiline comments eg /* ASDF */
-	        pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
-	        lookbehind: true,
-	        greedy: true
-	      },
-	      {
-	        // singleline comments eg // ASDF
-	        pattern: /(^|[^\\:])\/\/.*/,
-	        lookbehind: true,
-	        greedy: true
-	      }
-	    ],
-	    property: [
-	      {
-	        pattern: /([\r\n][ \t]*)[a-z_]\w*(?=[ \t]*:)/i,
-	        lookbehind: true
-	      },
-	      {
-	        pattern: /([\r\n][ \t]*)'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'(?=[ \t]*:)/,
-	        lookbehind: true,
-	        greedy: true
-	      }
-	    ],
-	    string: [
-	      {
-	        pattern: /'''[^'][\s\S]*?'''/,
-	        greedy: true
-	      },
-	      {
-	        pattern: /(^|[^\\'])'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'/,
-	        lookbehind: true,
-	        greedy: true
-	      }
-	    ],
-	    'interpolated-string': {
-	      pattern: /(^|[^\\'])'(?:\\.|\$(?:(?!\{)|\{[^{}\r\n]*\})|[^'\\\r\n$])*'/,
-	      lookbehind: true,
-	      greedy: true,
-	      inside: {
-	        interpolation: {
-	          pattern: /\$\{[^{}\r\n]*\}/,
-	          inside: {
-	            expression: {
-	              pattern: /(^\$\{)[\s\S]+(?=\}$)/,
-	              lookbehind: true
-	            },
-	            punctuation: /^\$\{|\}$/
-	          }
-	        },
-	        string: /[\s\S]+/
-	      }
-	    },
-	    datatype: {
-	      pattern: /(\b(?:output|param)\b[ \t]+\w+[ \t]+)\w+\b/,
-	      lookbehind: true,
-	      alias: 'class-name'
-	    },
-	    boolean: /\b(?:false|true)\b/,
-	    // https://github.com/Azure/bicep/blob/114a3251b4e6e30082a58729f19a8cc4e374ffa6/src/textmate/bicep.tmlanguage#L184
-	    keyword:
-	      /\b(?:existing|for|if|in|module|null|output|param|resource|targetScope|var)\b/,
-	    decorator: /@\w+\b/,
-	    function: /\b[a-z_]\w*(?=[ \t]*\()/i,
-	    number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
-	    operator:
-	      /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/,
-	    punctuation: /[{}[\];(),.:]/
-	  };
-	  Prism.languages.bicep['interpolated-string'].inside['interpolation'].inside[
-	    'expression'
-	  ].inside = Prism.languages.bicep;
-	}
-	return bicep_1;
+var bicep$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': bicep_1
+}, [bicep_1]);
+
+var birb_1 = birb;
+birb.displayName = 'birb';
+birb.aliases = [];
+function birb(Prism) {
+  Prism.languages.birb = Prism.languages.extend('clike', {
+    string: {
+      pattern: /r?("|')(?:\\.|(?!\1)[^\\])*\1/,
+      greedy: true
+    },
+    'class-name': [
+      /\b[A-Z](?:[\d_]*[a-zA-Z]\w*)?\b/, // matches variable and function return types (parameters as well).
+      /\b(?:[A-Z]\w*|(?!(?:var|void)\b)[a-z]\w*)(?=\s+\w+\s*[;,=()])/
+    ],
+    keyword:
+      /\b(?:assert|break|case|class|const|default|else|enum|final|follows|for|grab|if|nest|new|next|noSeeb|return|static|switch|throw|var|void|while)\b/,
+    operator: /\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?|:/,
+    variable: /\b[a-z_]\w*\b/
+  });
+  Prism.languages.insertBefore('birb', 'function', {
+    metadata: {
+      pattern: /<\w+>/,
+      greedy: true,
+      alias: 'symbol'
+    }
+  });
 }
 
-var birb_1;
-var hasRequiredBirb;
-
-function requireBirb () {
-	if (hasRequiredBirb) return birb_1;
-	hasRequiredBirb = 1;
-
-	birb_1 = birb;
-	birb.displayName = 'birb';
-	birb.aliases = [];
-	function birb(Prism) {
-	  Prism.languages.birb = Prism.languages.extend('clike', {
-	    string: {
-	      pattern: /r?("|')(?:\\.|(?!\1)[^\\])*\1/,
-	      greedy: true
-	    },
-	    'class-name': [
-	      /\b[A-Z](?:[\d_]*[a-zA-Z]\w*)?\b/, // matches variable and function return types (parameters as well).
-	      /\b(?:[A-Z]\w*|(?!(?:var|void)\b)[a-z]\w*)(?=\s+\w+\s*[;,=()])/
-	    ],
-	    keyword:
-	      /\b(?:assert|break|case|class|const|default|else|enum|final|follows|for|grab|if|nest|new|next|noSeeb|return|static|switch|throw|var|void|while)\b/,
-	    operator: /\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?|:/,
-	    variable: /\b[a-z_]\w*\b/
-	  });
-	  Prism.languages.insertBefore('birb', 'function', {
-	    metadata: {
-	      pattern: /<\w+>/,
-	      greedy: true,
-	      alias: 'symbol'
-	    }
-	  });
-	}
-	return birb_1;
+var birb$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': birb_1
+}, [birb_1]);
+
+var refractorC = c_1;
+var bison_1 = bison;
+bison.displayName = 'bison';
+bison.aliases = [];
+function bison(Prism) {
+  Prism.register(refractorC);
+  Prism.languages.bison = Prism.languages.extend('c', {});
+  Prism.languages.insertBefore('bison', 'comment', {
+    bison: {
+      // This should match all the beginning of the file
+      // including the prologue(s), the bison declarations and
+      // the grammar rules.
+      pattern: /^(?:[^%]|%(?!%))*%%[\s\S]*?%%/,
+      inside: {
+        c: {
+          // Allow for one level of nested braces
+          pattern: /%\{[\s\S]*?%\}|\{(?:\{[^}]*\}|[^{}])*\}/,
+          inside: {
+            delimiter: {
+              pattern: /^%?\{|%?\}$/,
+              alias: 'punctuation'
+            },
+            'bison-variable': {
+              pattern: /[$@](?:<[^\s>]+>)?[\w$]+/,
+              alias: 'variable',
+              inside: {
+                punctuation: /<|>/
+              }
+            },
+            rest: Prism.languages.c
+          }
+        },
+        comment: Prism.languages.c.comment,
+        string: Prism.languages.c.string,
+        property: /\S+(?=:)/,
+        keyword: /%\w+/,
+        number: {
+          pattern: /(^|[^@])\b(?:0x[\da-f]+|\d+)/i,
+          lookbehind: true
+        },
+        punctuation: /%[%?]|[|:;\[\]<>]/
+      }
+    }
+  });
 }
 
-var bison_1;
-var hasRequiredBison;
-
-function requireBison () {
-	if (hasRequiredBison) return bison_1;
-	hasRequiredBison = 1;
-	var refractorC = requireC();
-	bison_1 = bison;
-	bison.displayName = 'bison';
-	bison.aliases = [];
-	function bison(Prism) {
-	  Prism.register(refractorC);
-	  Prism.languages.bison = Prism.languages.extend('c', {});
-	  Prism.languages.insertBefore('bison', 'comment', {
-	    bison: {
-	      // This should match all the beginning of the file
-	      // including the prologue(s), the bison declarations and
-	      // the grammar rules.
-	      pattern: /^(?:[^%]|%(?!%))*%%[\s\S]*?%%/,
-	      inside: {
-	        c: {
-	          // Allow for one level of nested braces
-	          pattern: /%\{[\s\S]*?%\}|\{(?:\{[^}]*\}|[^{}])*\}/,
-	          inside: {
-	            delimiter: {
-	              pattern: /^%?\{|%?\}$/,
-	              alias: 'punctuation'
-	            },
-	            'bison-variable': {
-	              pattern: /[$@](?:<[^\s>]+>)?[\w$]+/,
-	              alias: 'variable',
-	              inside: {
-	                punctuation: /<|>/
-	              }
-	            },
-	            rest: Prism.languages.c
-	          }
-	        },
-	        comment: Prism.languages.c.comment,
-	        string: Prism.languages.c.string,
-	        property: /\S+(?=:)/,
-	        keyword: /%\w+/,
-	        number: {
-	          pattern: /(^|[^@])\b(?:0x[\da-f]+|\d+)/i,
-	          lookbehind: true
-	        },
-	        punctuation: /%[%?]|[|:;\[\]<>]/
-	      }
-	    }
-	  });
-	}
-	return bison_1;
+var bison$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': bison_1
+}, [bison_1]);
+
+var bnf_1 = bnf$1;
+bnf$1.displayName = 'bnf';
+bnf$1.aliases = ['rbnf'];
+function bnf$1(Prism) {
+  Prism.languages.bnf = {
+    string: {
+      pattern: /"[^\r\n"]*"|'[^\r\n']*'/
+    },
+    definition: {
+      pattern: /<[^<>\r\n\t]+>(?=\s*::=)/,
+      alias: ['rule', 'keyword'],
+      inside: {
+        punctuation: /^<|>$/
+      }
+    },
+    rule: {
+      pattern: /<[^<>\r\n\t]+>/,
+      inside: {
+        punctuation: /^<|>$/
+      }
+    },
+    operator: /::=|[|()[\]{}*+?]|\.{3}/
+  };
+  Prism.languages.rbnf = Prism.languages.bnf;
 }
 
-var bnf_1;
-var hasRequiredBnf;
-
-function requireBnf () {
-	if (hasRequiredBnf) return bnf_1;
-	hasRequiredBnf = 1;
-
-	bnf_1 = bnf;
-	bnf.displayName = 'bnf';
-	bnf.aliases = ['rbnf'];
-	function bnf(Prism) {
-	  Prism.languages.bnf = {
-	    string: {
-	      pattern: /"[^\r\n"]*"|'[^\r\n']*'/
-	    },
-	    definition: {
-	      pattern: /<[^<>\r\n\t]+>(?=\s*::=)/,
-	      alias: ['rule', 'keyword'],
-	      inside: {
-	        punctuation: /^<|>$/
-	      }
-	    },
-	    rule: {
-	      pattern: /<[^<>\r\n\t]+>/,
-	      inside: {
-	        punctuation: /^<|>$/
-	      }
-	    },
-	    operator: /::=|[|()[\]{}*+?]|\.{3}/
-	  };
-	  Prism.languages.rbnf = Prism.languages.bnf;
-	}
-	return bnf_1;
+var bnf$2 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': bnf_1
+}, [bnf_1]);
+
+var brainfuck_1 = brainfuck$1;
+brainfuck$1.displayName = 'brainfuck';
+brainfuck$1.aliases = [];
+function brainfuck$1(Prism) {
+  Prism.languages.brainfuck = {
+    pointer: {
+      pattern: /<|>/,
+      alias: 'keyword'
+    },
+    increment: {
+      pattern: /\+/,
+      alias: 'inserted'
+    },
+    decrement: {
+      pattern: /-/,
+      alias: 'deleted'
+    },
+    branching: {
+      pattern: /\[|\]/,
+      alias: 'important'
+    },
+    operator: /[.,]/,
+    comment: /\S+/
+  };
 }
 
-var brainfuck_1;
-var hasRequiredBrainfuck;
-
-function requireBrainfuck () {
-	if (hasRequiredBrainfuck) return brainfuck_1;
-	hasRequiredBrainfuck = 1;
-
-	brainfuck_1 = brainfuck;
-	brainfuck.displayName = 'brainfuck';
-	brainfuck.aliases = [];
-	function brainfuck(Prism) {
-	  Prism.languages.brainfuck = {
-	    pointer: {
-	      pattern: /<|>/,
-	      alias: 'keyword'
-	    },
-	    increment: {
-	      pattern: /\+/,
-	      alias: 'inserted'
-	    },
-	    decrement: {
-	      pattern: /-/,
-	      alias: 'deleted'
-	    },
-	    branching: {
-	      pattern: /\[|\]/,
-	      alias: 'important'
-	    },
-	    operator: /[.,]/,
-	    comment: /\S+/
-	  };
-	}
-	return brainfuck_1;
+var brainfuck$2 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': brainfuck_1
+}, [brainfuck_1]);
+
+var brightscript_1 = brightscript;
+brightscript.displayName = 'brightscript';
+brightscript.aliases = [];
+function brightscript(Prism) {
+  Prism.languages.brightscript = {
+    comment: /(?:\brem|').*/i,
+    'directive-statement': {
+      pattern: /(^[\t ]*)#(?:const|else(?:[\t ]+if)?|end[\t ]+if|error|if).*/im,
+      lookbehind: true,
+      alias: 'property',
+      inside: {
+        'error-message': {
+          pattern: /(^#error).+/,
+          lookbehind: true
+        },
+        directive: {
+          pattern: /^#(?:const|else(?:[\t ]+if)?|end[\t ]+if|error|if)/,
+          alias: 'keyword'
+        },
+        expression: {
+          pattern: /[\s\S]+/,
+          inside: null // see below
+        }
+      }
+    },
+    property: {
+      pattern:
+        /([\r\n{,][\t ]*)(?:(?!\d)\w+|"(?:[^"\r\n]|"")*"(?!"))(?=[ \t]*:)/,
+      lookbehind: true,
+      greedy: true
+    },
+    string: {
+      pattern: /"(?:[^"\r\n]|"")*"(?!")/,
+      greedy: true
+    },
+    'class-name': {
+      pattern: /(\bAs[\t ]+)\w+/i,
+      lookbehind: true
+    },
+    keyword:
+      /\b(?:As|Dim|Each|Else|Elseif|End|Exit|For|Function|Goto|If|In|Print|Return|Step|Stop|Sub|Then|To|While)\b/i,
+    boolean: /\b(?:false|true)\b/i,
+    function: /\b(?!\d)\w+(?=[\t ]*\()/,
+    number: /(?:\b\d+(?:\.\d+)?(?:[ed][+-]\d+)?|&h[a-f\d]+)\b[%&!#]?/i,
+    operator:
+      /--|\+\+|>>=?|<<=?|<>|[-+*/\\<>]=?|[:^=?]|\b(?:and|mod|not|or)\b/i,
+    punctuation: /[.,;()[\]{}]/,
+    constant: /\b(?:LINE_NUM)\b/i
+  };
+  Prism.languages.brightscript['directive-statement'].inside.expression.inside =
+    Prism.languages.brightscript;
 }
 
-var brightscript_1;
-var hasRequiredBrightscript;
-
-function requireBrightscript () {
-	if (hasRequiredBrightscript) return brightscript_1;
-	hasRequiredBrightscript = 1;
-
-	brightscript_1 = brightscript;
-	brightscript.displayName = 'brightscript';
-	brightscript.aliases = [];
-	function brightscript(Prism) {
-	  Prism.languages.brightscript = {
-	    comment: /(?:\brem|').*/i,
-	    'directive-statement': {
-	      pattern: /(^[\t ]*)#(?:const|else(?:[\t ]+if)?|end[\t ]+if|error|if).*/im,
-	      lookbehind: true,
-	      alias: 'property',
-	      inside: {
-	        'error-message': {
-	          pattern: /(^#error).+/,
-	          lookbehind: true
-	        },
-	        directive: {
-	          pattern: /^#(?:const|else(?:[\t ]+if)?|end[\t ]+if|error|if)/,
-	          alias: 'keyword'
-	        },
-	        expression: {
-	          pattern: /[\s\S]+/,
-	          inside: null // see below
-	        }
-	      }
-	    },
-	    property: {
-	      pattern:
-	        /([\r\n{,][\t ]*)(?:(?!\d)\w+|"(?:[^"\r\n]|"")*"(?!"))(?=[ \t]*:)/,
-	      lookbehind: true,
-	      greedy: true
-	    },
-	    string: {
-	      pattern: /"(?:[^"\r\n]|"")*"(?!")/,
-	      greedy: true
-	    },
-	    'class-name': {
-	      pattern: /(\bAs[\t ]+)\w+/i,
-	      lookbehind: true
-	    },
-	    keyword:
-	      /\b(?:As|Dim|Each|Else|Elseif|End|Exit|For|Function|Goto|If|In|Print|Return|Step|Stop|Sub|Then|To|While)\b/i,
-	    boolean: /\b(?:false|true)\b/i,
-	    function: /\b(?!\d)\w+(?=[\t ]*\()/,
-	    number: /(?:\b\d+(?:\.\d+)?(?:[ed][+-]\d+)?|&h[a-f\d]+)\b[%&!#]?/i,
-	    operator:
-	      /--|\+\+|>>=?|<<=?|<>|[-+*/\\<>]=?|[:^=?]|\b(?:and|mod|not|or)\b/i,
-	    punctuation: /[.,;()[\]{}]/,
-	    constant: /\b(?:LINE_NUM)\b/i
-	  };
-	  Prism.languages.brightscript['directive-statement'].inside.expression.inside =
-	    Prism.languages.brightscript;
-	}
-	return brightscript_1;
+var brightscript$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': brightscript_1
+}, [brightscript_1]);
+
+var bro_1 = bro;
+bro.displayName = 'bro';
+bro.aliases = [];
+function bro(Prism) {
+  Prism.languages.bro = {
+    comment: {
+      pattern: /(^|[^\\$])#.*/,
+      lookbehind: true,
+      inside: {
+        italic: /\b(?:FIXME|TODO|XXX)\b/
+      }
+    },
+    string: {
+      pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+      greedy: true
+    },
+    boolean: /\b[TF]\b/,
+    function: {
+      pattern: /(\b(?:event|function|hook)[ \t]+)\w+(?:::\w+)?/,
+      lookbehind: true
+    },
+    builtin:
+      /(?:@(?:load(?:-(?:plugin|sigs))?|unload|prefixes|ifn?def|else|(?:end)?if|DIR|FILENAME))|(?:&?(?:add_func|create_expire|default|delete_func|encrypt|error_handler|expire_func|group|log|mergeable|optional|persistent|priority|raw_output|read_expire|redef|rotate_interval|rotate_size|synchronized|type_column|write_expire))/,
+    constant: {
+      pattern: /(\bconst[ \t]+)\w+/i,
+      lookbehind: true
+    },
+    keyword:
+      /\b(?:add|addr|alarm|any|bool|break|const|continue|count|delete|double|else|enum|event|export|file|for|function|global|hook|if|in|int|interval|local|module|next|of|opaque|pattern|port|print|record|return|schedule|set|string|subnet|table|time|timeout|using|vector|when)\b/,
+    operator: /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&|\|\|?|\?|\*|\/|~|\^|%/,
+    number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+    punctuation: /[{}[\];(),.:]/
+  };
 }
 
-var bro_1;
-var hasRequiredBro;
-
-function requireBro () {
-	if (hasRequiredBro) return bro_1;
-	hasRequiredBro = 1;
-
-	bro_1 = bro;
-	bro.displayName = 'bro';
-	bro.aliases = [];
-	function bro(Prism) {
-	  Prism.languages.bro = {
-	    comment: {
-	      pattern: /(^|[^\\$])#.*/,
-	      lookbehind: true,
-	      inside: {
-	        italic: /\b(?:FIXME|TODO|XXX)\b/
-	      }
-	    },
-	    string: {
-	      pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-	      greedy: true
-	    },
-	    boolean: /\b[TF]\b/,
-	    function: {
-	      pattern: /(\b(?:event|function|hook)[ \t]+)\w+(?:::\w+)?/,
-	      lookbehind: true
-	    },
-	    builtin:
-	      /(?:@(?:load(?:-(?:plugin|sigs))?|unload|prefixes|ifn?def|else|(?:end)?if|DIR|FILENAME))|(?:&?(?:add_func|create_expire|default|delete_func|encrypt|error_handler|expire_func|group|log|mergeable|optional|persistent|priority|raw_output|read_expire|redef|rotate_interval|rotate_size|synchronized|type_column|write_expire))/,
-	    constant: {
-	      pattern: /(\bconst[ \t]+)\w+/i,
-	      lookbehind: true
-	    },
-	    keyword:
-	      /\b(?:add|addr|alarm|any|bool|break|const|continue|count|delete|double|else|enum|event|export|file|for|function|global|hook|if|in|int|interval|local|module|next|of|opaque|pattern|port|print|record|return|schedule|set|string|subnet|table|time|timeout|using|vector|when)\b/,
-	    operator: /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&|\|\|?|\?|\*|\/|~|\^|%/,
-	    number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
-	    punctuation: /[{}[\];(),.:]/
-	  };
-	}
-	return bro_1;
+var bro$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': bro_1
+}, [bro_1]);
+
+var bsl_1 = bsl;
+bsl.displayName = 'bsl';
+bsl.aliases = [];
+function bsl(Prism) {
+  /* eslint-disable no-misleading-character-class */
+  // 1C:Enterprise
+  // https://github.com/Diversus23/
+  //
+  Prism.languages.bsl = {
+    comment: /\/\/.*/,
+    string: [
+      // Строки
+      // Strings
+      {
+        pattern: /"(?:[^"]|"")*"(?!")/,
+        greedy: true
+      }, // Дата и время
+      // Date & time
+      {
+        pattern: /'(?:[^'\r\n\\]|\\.)*'/
+      }
+    ],
+    keyword: [
+      {
+        // RU
+        pattern:
+          /(^|[^\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])(?:пока|для|новый|прервать|попытка|исключение|вызватьисключение|иначе|конецпопытки|неопределено|функция|перем|возврат|конецфункции|если|иначеесли|процедура|конецпроцедуры|тогда|знач|экспорт|конецесли|из|каждого|истина|ложь|по|цикл|конеццикла|выполнить)(?![\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])/i,
+        lookbehind: true
+      },
+      {
+        // EN
+        pattern:
+          /\b(?:break|do|each|else|elseif|enddo|endfunction|endif|endprocedure|endtry|except|execute|export|false|for|function|if|in|new|null|procedure|raise|return|then|to|true|try|undefined|val|var|while)\b/i
+      }
+    ],
+    number: {
+      pattern:
+        /(^(?=\d)|[^\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])(?:\d+(?:\.\d*)?|\.\d+)(?:E[+-]?\d+)?/i,
+      lookbehind: true
+    },
+    operator: [
+      /[<>+\-*/]=?|[%=]/, // RU
+      {
+        pattern:
+          /(^|[^\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])(?:и|или|не)(?![\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])/i,
+        lookbehind: true
+      }, // EN
+      {
+        pattern: /\b(?:and|not|or)\b/i
+      }
+    ],
+    punctuation: /\(\.|\.\)|[()\[\]:;,.]/,
+    directive: [
+      // Теги препроцессора вида &Клиент, &Сервер, ...
+      // Preprocessor tags of the type &Client, &Server, ...
+      {
+        pattern: /^([ \t]*)&.*/m,
+        lookbehind: true,
+        greedy: true,
+        alias: 'important'
+      }, // Инструкции препроцессора вида:
+      // #Если Сервер Тогда
+      // ...
+      // #КонецЕсли
+      // Preprocessor instructions of the form:
+      // #If Server Then
+      // ...
+      // #EndIf
+      {
+        pattern: /^([ \t]*)#.*/gm,
+        lookbehind: true,
+        greedy: true,
+        alias: 'important'
+      }
+    ]
+  };
+  Prism.languages.oscript = Prism.languages['bsl'];
 }
 
-var bsl_1;
-var hasRequiredBsl;
-
-function requireBsl () {
-	if (hasRequiredBsl) return bsl_1;
-	hasRequiredBsl = 1;
-
-	bsl_1 = bsl;
-	bsl.displayName = 'bsl';
-	bsl.aliases = [];
-	function bsl(Prism) {
-	  /* eslint-disable no-misleading-character-class */
-	  // 1C:Enterprise
-	  // https://github.com/Diversus23/
-	  //
-	  Prism.languages.bsl = {
-	    comment: /\/\/.*/,
-	    string: [
-	      // Строки
-	      // Strings
-	      {
-	        pattern: /"(?:[^"]|"")*"(?!")/,
-	        greedy: true
-	      }, // Дата и время
-	      // Date & time
-	      {
-	        pattern: /'(?:[^'\r\n\\]|\\.)*'/
-	      }
-	    ],
-	    keyword: [
-	      {
-	        // RU
-	        pattern:
-	          /(^|[^\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])(?:пока|для|новый|прервать|попытка|исключение|вызватьисключение|иначе|конецпопытки|неопределено|функция|перем|возврат|конецфункции|если|иначеесли|процедура|конецпроцедуры|тогда|знач|экспорт|конецесли|из|каждого|истина|ложь|по|цикл|конеццикла|выполнить)(?![\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])/i,
-	        lookbehind: true
-	      },
-	      {
-	        // EN
-	        pattern:
-	          /\b(?:break|do|each|else|elseif|enddo|endfunction|endif|endprocedure|endtry|except|execute|export|false|for|function|if|in|new|null|procedure|raise|return|then|to|true|try|undefined|val|var|while)\b/i
-	      }
-	    ],
-	    number: {
-	      pattern:
-	        /(^(?=\d)|[^\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])(?:\d+(?:\.\d*)?|\.\d+)(?:E[+-]?\d+)?/i,
-	      lookbehind: true
-	    },
-	    operator: [
-	      /[<>+\-*/]=?|[%=]/, // RU
-	      {
-	        pattern:
-	          /(^|[^\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])(?:и|или|не)(?![\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])/i,
-	        lookbehind: true
-	      }, // EN
-	      {
-	        pattern: /\b(?:and|not|or)\b/i
-	      }
-	    ],
-	    punctuation: /\(\.|\.\)|[()\[\]:;,.]/,
-	    directive: [
-	      // Теги препроцессора вида &Клиент, &Сервер, ...
-	      // Preprocessor tags of the type &Client, &Server, ...
-	      {
-	        pattern: /^([ \t]*)&.*/m,
-	        lookbehind: true,
-	        greedy: true,
-	        alias: 'important'
-	      }, // Инструкции препроцессора вида:
-	      // #Если Сервер Тогда
-	      // ...
-	      // #КонецЕсли
-	      // Preprocessor instructions of the form:
-	      // #If Server Then
-	      // ...
-	      // #EndIf
-	      {
-	        pattern: /^([ \t]*)#.*/gm,
-	        lookbehind: true,
-	        greedy: true,
-	        alias: 'important'
-	      }
-	    ]
-	  };
-	  Prism.languages.oscript = Prism.languages['bsl'];
-	}
-	return bsl_1;
+var bsl$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': bsl_1
+}, [bsl_1]);
+
+var cfscript_1 = cfscript;
+cfscript.displayName = 'cfscript';
+cfscript.aliases = [];
+function cfscript(Prism) {
+  // https://cfdocs.org/script
+  Prism.languages.cfscript = Prism.languages.extend('clike', {
+    comment: [
+      {
+        pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+        lookbehind: true,
+        inside: {
+          annotation: {
+            pattern: /(?:^|[^.])@[\w\.]+/,
+            alias: 'punctuation'
+          }
+        }
+      },
+      {
+        pattern: /(^|[^\\:])\/\/.*/,
+        lookbehind: true,
+        greedy: true
+      }
+    ],
+    keyword:
+      /\b(?:abstract|break|catch|component|continue|default|do|else|extends|final|finally|for|function|if|in|include|package|private|property|public|remote|required|rethrow|return|static|switch|throw|try|var|while|xml)\b(?!\s*=)/,
+    operator: [
+      /\+\+|--|&&|\|\||::|=>|[!=]==|<=?|>=?|[-+*/%&|^!=<>]=?|\?(?:\.|:)?|[?:]/,
+      /\b(?:and|contains|eq|equal|eqv|gt|gte|imp|is|lt|lte|mod|not|or|xor)\b/
+    ],
+    scope: {
+      pattern:
+        /\b(?:application|arguments|cgi|client|cookie|local|session|super|this|variables)\b/,
+      alias: 'global'
+    },
+    type: {
+      pattern:
+        /\b(?:any|array|binary|boolean|date|guid|numeric|query|string|struct|uuid|void|xml)\b/,
+      alias: 'builtin'
+    }
+  });
+  Prism.languages.insertBefore('cfscript', 'keyword', {
+    // This must be declared before keyword because we use "function" inside the lookahead
+    'function-variable': {
+      pattern:
+        /[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
+      alias: 'function'
+    }
+  });
+  delete Prism.languages.cfscript['class-name'];
+  Prism.languages.cfc = Prism.languages['cfscript'];
 }
 
-var cfscript_1;
-var hasRequiredCfscript;
-
-function requireCfscript () {
-	if (hasRequiredCfscript) return cfscript_1;
-	hasRequiredCfscript = 1;
+var cfscript$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': cfscript_1
+}, [cfscript_1]);
 
-	cfscript_1 = cfscript;
-	cfscript.displayName = 'cfscript';
-	cfscript.aliases = [];
-	function cfscript(Prism) {
-	  // https://cfdocs.org/script
-	  Prism.languages.cfscript = Prism.languages.extend('clike', {
-	    comment: [
-	      {
-	        pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
-	        lookbehind: true,
-	        inside: {
-	          annotation: {
-	            pattern: /(?:^|[^.])@[\w\.]+/,
-	            alias: 'punctuation'
-	          }
-	        }
-	      },
-	      {
-	        pattern: /(^|[^\\:])\/\/.*/,
-	        lookbehind: true,
-	        greedy: true
-	      }
-	    ],
-	    keyword:
-	      /\b(?:abstract|break|catch|component|continue|default|do|else|extends|final|finally|for|function|if|in|include|package|private|property|public|remote|required|rethrow|return|static|switch|throw|try|var|while|xml)\b(?!\s*=)/,
-	    operator: [
-	      /\+\+|--|&&|\|\||::|=>|[!=]==|<=?|>=?|[-+*/%&|^!=<>]=?|\?(?:\.|:)?|[?:]/,
-	      /\b(?:and|contains|eq|equal|eqv|gt|gte|imp|is|lt|lte|mod|not|or|xor)\b/
-	    ],
-	    scope: {
-	      pattern:
-	        /\b(?:application|arguments|cgi|client|cookie|local|session|super|this|variables)\b/,
-	      alias: 'global'
-	    },
-	    type: {
-	      pattern:
-	        /\b(?:any|array|binary|boolean|date|guid|numeric|query|string|struct|uuid|void|xml)\b/,
-	      alias: 'builtin'
-	    }
-	  });
-	  Prism.languages.insertBefore('cfscript', 'keyword', {
-	    // This must be declared before keyword because we use "function" inside the lookahead
-	    'function-variable': {
-	      pattern:
-	        /[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
-	      alias: 'function'
-	    }
-	  });
-	  delete Prism.languages.cfscript['class-name'];
-	  Prism.languages.cfc = Prism.languages['cfscript'];
-	}
-	return cfscript_1;
+var refractorCpp = requireCpp();
+var chaiscript_1 = chaiscript;
+chaiscript.displayName = 'chaiscript';
+chaiscript.aliases = [];
+function chaiscript(Prism) {
+  Prism.register(refractorCpp);
+  Prism.languages.chaiscript = Prism.languages.extend('clike', {
+    string: {
+      pattern: /(^|[^\\])'(?:[^'\\]|\\[\s\S])*'/,
+      lookbehind: true,
+      greedy: true
+    },
+    'class-name': [
+      {
+        // e.g. class Rectangle { ... }
+        pattern: /(\bclass\s+)\w+/,
+        lookbehind: true
+      },
+      {
+        // e.g. attr Rectangle::height, def Rectangle::area() { ... }
+        pattern: /(\b(?:attr|def)\s+)\w+(?=\s*::)/,
+        lookbehind: true
+      }
+    ],
+    keyword:
+      /\b(?:attr|auto|break|case|catch|class|continue|def|default|else|finally|for|fun|global|if|return|switch|this|try|var|while)\b/,
+    number: [Prism.languages.cpp.number, /\b(?:Infinity|NaN)\b/],
+    operator:
+      />>=?|<<=?|\|\||&&|:[:=]?|--|\+\+|[=!<>+\-*/%|&^]=?|[?~]|`[^`\r\n]{1,4}`/
+  });
+  Prism.languages.insertBefore('chaiscript', 'operator', {
+    'parameter-type': {
+      // e.g. def foo(int x, Vector y) {...}
+      pattern: /([,(]\s*)\w+(?=\s+\w)/,
+      lookbehind: true,
+      alias: 'class-name'
+    }
+  });
+  Prism.languages.insertBefore('chaiscript', 'string', {
+    'string-interpolation': {
+      pattern:
+        /(^|[^\\])"(?:[^"$\\]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*"/,
+      lookbehind: true,
+      greedy: true,
+      inside: {
+        interpolation: {
+          pattern:
+            /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}/,
+          lookbehind: true,
+          inside: {
+            'interpolation-expression': {
+              pattern: /(^\$\{)[\s\S]+(?=\}$)/,
+              lookbehind: true,
+              inside: Prism.languages.chaiscript
+            },
+            'interpolation-punctuation': {
+              pattern: /^\$\{|\}$/,
+              alias: 'punctuation'
+            }
+          }
+        },
+        string: /[\s\S]+/
+      }
+    }
+  });
 }
 
-var chaiscript_1;
-var hasRequiredChaiscript;
-
-function requireChaiscript () {
-	if (hasRequiredChaiscript) return chaiscript_1;
-	hasRequiredChaiscript = 1;
-	var refractorCpp = requireCpp();
-	chaiscript_1 = chaiscript;
-	chaiscript.displayName = 'chaiscript';
-	chaiscript.aliases = [];
-	function chaiscript(Prism) {
-	  Prism.register(refractorCpp);
-	  Prism.languages.chaiscript = Prism.languages.extend('clike', {
-	    string: {
-	      pattern: /(^|[^\\])'(?:[^'\\]|\\[\s\S])*'/,
-	      lookbehind: true,
-	      greedy: true
-	    },
-	    'class-name': [
-	      {
-	        // e.g. class Rectangle { ... }
-	        pattern: /(\bclass\s+)\w+/,
-	        lookbehind: true
-	      },
-	      {
-	        // e.g. attr Rectangle::height, def Rectangle::area() { ... }
-	        pattern: /(\b(?:attr|def)\s+)\w+(?=\s*::)/,
-	        lookbehind: true
-	      }
-	    ],
-	    keyword:
-	      /\b(?:attr|auto|break|case|catch|class|continue|def|default|else|finally|for|fun|global|if|return|switch|this|try|var|while)\b/,
-	    number: [Prism.languages.cpp.number, /\b(?:Infinity|NaN)\b/],
-	    operator:
-	      />>=?|<<=?|\|\||&&|:[:=]?|--|\+\+|[=!<>+\-*/%|&^]=?|[?~]|`[^`\r\n]{1,4}`/
-	  });
-	  Prism.languages.insertBefore('chaiscript', 'operator', {
-	    'parameter-type': {
-	      // e.g. def foo(int x, Vector y) {...}
-	      pattern: /([,(]\s*)\w+(?=\s+\w)/,
-	      lookbehind: true,
-	      alias: 'class-name'
-	    }
-	  });
-	  Prism.languages.insertBefore('chaiscript', 'string', {
-	    'string-interpolation': {
-	      pattern:
-	        /(^|[^\\])"(?:[^"$\\]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*"/,
-	      lookbehind: true,
-	      greedy: true,
-	      inside: {
-	        interpolation: {
-	          pattern:
-	            /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}/,
-	          lookbehind: true,
-	          inside: {
-	            'interpolation-expression': {
-	              pattern: /(^\$\{)[\s\S]+(?=\}$)/,
-	              lookbehind: true,
-	              inside: Prism.languages.chaiscript
-	            },
-	            'interpolation-punctuation': {
-	              pattern: /^\$\{|\}$/,
-	              alias: 'punctuation'
-	            }
-	          }
-	        },
-	        string: /[\s\S]+/
-	      }
-	    }
-	  });
-	}
-	return chaiscript_1;
-}
+var chaiscript$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': chaiscript_1
+}, [chaiscript_1]);
 
 var cil_1;
 var hasRequiredCil;
@@ -62828,54 +62766,50 @@ function requireCil () {
 	return cil_1;
 }
 
-var clojure_1;
-var hasRequiredClojure;
-
-function requireClojure () {
-	if (hasRequiredClojure) return clojure_1;
-	hasRequiredClojure = 1;
-
-	clojure_1 = clojure;
-	clojure.displayName = 'clojure';
-	clojure.aliases = [];
-	function clojure(Prism) {
-	  // Copied from https://github.com/jeluard/prism-clojure
-	  Prism.languages.clojure = {
-	    comment: {
-	      pattern: /;.*/,
-	      greedy: true
-	    },
-	    string: {
-	      pattern: /"(?:[^"\\]|\\.)*"/,
-	      greedy: true
-	    },
-	    char: /\\\w+/,
-	    symbol: {
-	      pattern: /(^|[\s()\[\]{},])::?[\w*+!?'<>=/.-]+/,
-	      lookbehind: true
-	    },
-	    keyword: {
-	      pattern:
-	        /(\()(?:-|->|->>|\.|\.\.|\*|\/|\+|<|<=|=|==|>|>=|accessor|agent|agent-errors|aget|alength|all-ns|alter|and|append-child|apply|array-map|aset|aset-boolean|aset-byte|aset-char|aset-double|aset-float|aset-int|aset-long|aset-short|assert|assoc|await|await-for|bean|binding|bit-and|bit-not|bit-or|bit-shift-left|bit-shift-right|bit-xor|boolean|branch\?|butlast|byte|cast|char|children|class|clear-agent-errors|comment|commute|comp|comparator|complement|concat|cond|conj|cons|constantly|construct-proxy|contains\?|count|create-ns|create-struct|cycle|dec|declare|def|def-|definline|definterface|defmacro|defmethod|defmulti|defn|defn-|defonce|defproject|defprotocol|defrecord|defstruct|deftype|deref|difference|disj|dissoc|distinct|do|doall|doc|dorun|doseq|dosync|dotimes|doto|double|down|drop|drop-while|edit|end\?|ensure|eval|every\?|false\?|ffirst|file-seq|filter|find|find-doc|find-ns|find-var|first|float|flush|fn|fnseq|for|frest|gensym|get|get-proxy-class|hash-map|hash-set|identical\?|identity|if|if-let|if-not|import|in-ns|inc|index|insert-child|insert-left|insert-right|inspect-table|inspect-tree|instance\?|int|interleave|intersection|into|into-array|iterate|join|key|keys|keyword|keyword\?|last|lazy-cat|lazy-cons|left|lefts|let|line-seq|list|list\*|load|load-file|locking|long|loop|macroexpand|macroexpand-1|make-array|make-node|map|map-invert|map\?|mapcat|max|max-key|memfn|merge|merge-with|meta|min|min-key|monitor-enter|name|namespace|neg\?|new|newline|next|nil\?|node|not|not-any\?|not-every\?|not=|ns|ns-imports|ns-interns|ns-map|ns-name|ns-publics|ns-refers|ns-resolve|ns-unmap|nth|nthrest|or|parse|partial|path|peek|pop|pos\?|pr|pr-str|print|print-str|println|println-str|prn|prn-str|project|proxy|proxy-mappings|quot|quote|rand|rand-int|range|re-find|re-groups|re-matcher|re-matches|re-pattern|re-seq|read|read-line|recur|reduce|ref|ref-set|refer|rem|remove|remove-method|remove-ns|rename|rename-keys|repeat|replace|replicate|resolve|rest|resultset-seq|reverse|rfirst|right|rights|root|rrest|rseq|second|select|select-keys|send|send-off|seq|seq-zip|seq\?|set|set!|short|slurp|some|sort|sort-by|sorted-map|sorted-map-by|sorted-set|special-symbol\?|split-at|split-with|str|string\?|struct|struct-map|subs|subvec|symbol|symbol\?|sync|take|take-nth|take-while|test|throw|time|to-array|to-array-2d|tree-seq|true\?|try|union|up|update-proxy|val|vals|var|var-get|var-set|var\?|vector|vector-zip|vector\?|when|when-first|when-let|when-not|with-local-vars|with-meta|with-open|with-out-str|xml-seq|xml-zip|zero\?|zipmap|zipper)(?=[\s)]|$)/,
-	      lookbehind: true
-	    },
-	    boolean: /\b(?:false|nil|true)\b/,
-	    number: {
-	      pattern:
-	        /(^|[^\w$@])(?:\d+(?:[/.]\d+)?(?:e[+-]?\d+)?|0x[a-f0-9]+|[1-9]\d?r[a-z0-9]+)[lmn]?(?![\w$@])/i,
-	      lookbehind: true
-	    },
-	    function: {
-	      pattern: /((?:^|[^'])\()[\w*+!?'<>=/.-]+(?=[\s)]|$)/,
-	      lookbehind: true
-	    },
-	    operator: /[#@^`~]/,
-	    punctuation: /[{}\[\](),]/
-	  };
-	}
-	return clojure_1;
+var clojure_1 = clojure$1;
+clojure$1.displayName = 'clojure';
+clojure$1.aliases = [];
+function clojure$1(Prism) {
+  // Copied from https://github.com/jeluard/prism-clojure
+  Prism.languages.clojure = {
+    comment: {
+      pattern: /;.*/,
+      greedy: true
+    },
+    string: {
+      pattern: /"(?:[^"\\]|\\.)*"/,
+      greedy: true
+    },
+    char: /\\\w+/,
+    symbol: {
+      pattern: /(^|[\s()\[\]{},])::?[\w*+!?'<>=/.-]+/,
+      lookbehind: true
+    },
+    keyword: {
+      pattern:
+        /(\()(?:-|->|->>|\.|\.\.|\*|\/|\+|<|<=|=|==|>|>=|accessor|agent|agent-errors|aget|alength|all-ns|alter|and|append-child|apply|array-map|aset|aset-boolean|aset-byte|aset-char|aset-double|aset-float|aset-int|aset-long|aset-short|assert|assoc|await|await-for|bean|binding|bit-and|bit-not|bit-or|bit-shift-left|bit-shift-right|bit-xor|boolean|branch\?|butlast|byte|cast|char|children|class|clear-agent-errors|comment|commute|comp|comparator|complement|concat|cond|conj|cons|constantly|construct-proxy|contains\?|count|create-ns|create-struct|cycle|dec|declare|def|def-|definline|definterface|defmacro|defmethod|defmulti|defn|defn-|defonce|defproject|defprotocol|defrecord|defstruct|deftype|deref|difference|disj|dissoc|distinct|do|doall|doc|dorun|doseq|dosync|dotimes|doto|double|down|drop|drop-while|edit|end\?|ensure|eval|every\?|false\?|ffirst|file-seq|filter|find|find-doc|find-ns|find-var|first|float|flush|fn|fnseq|for|frest|gensym|get|get-proxy-class|hash-map|hash-set|identical\?|identity|if|if-let|if-not|import|in-ns|inc|index|insert-child|insert-left|insert-right|inspect-table|inspect-tree|instance\?|int|interleave|intersection|into|into-array|iterate|join|key|keys|keyword|keyword\?|last|lazy-cat|lazy-cons|left|lefts|let|line-seq|list|list\*|load|load-file|locking|long|loop|macroexpand|macroexpand-1|make-array|make-node|map|map-invert|map\?|mapcat|max|max-key|memfn|merge|merge-with|meta|min|min-key|monitor-enter|name|namespace|neg\?|new|newline|next|nil\?|node|not|not-any\?|not-every\?|not=|ns|ns-imports|ns-interns|ns-map|ns-name|ns-publics|ns-refers|ns-resolve|ns-unmap|nth|nthrest|or|parse|partial|path|peek|pop|pos\?|pr|pr-str|print|print-str|println|println-str|prn|prn-str|project|proxy|proxy-mappings|quot|quote|rand|rand-int|range|re-find|re-groups|re-matcher|re-matches|re-pattern|re-seq|read|read-line|recur|reduce|ref|ref-set|refer|rem|remove|remove-method|remove-ns|rename|rename-keys|repeat|replace|replicate|resolve|rest|resultset-seq|reverse|rfirst|right|rights|root|rrest|rseq|second|select|select-keys|send|send-off|seq|seq-zip|seq\?|set|set!|short|slurp|some|sort|sort-by|sorted-map|sorted-map-by|sorted-set|special-symbol\?|split-at|split-with|str|string\?|struct|struct-map|subs|subvec|symbol|symbol\?|sync|take|take-nth|take-while|test|throw|time|to-array|to-array-2d|tree-seq|true\?|try|union|up|update-proxy|val|vals|var|var-get|var-set|var\?|vector|vector-zip|vector\?|when|when-first|when-let|when-not|with-local-vars|with-meta|with-open|with-out-str|xml-seq|xml-zip|zero\?|zipmap|zipper)(?=[\s)]|$)/,
+      lookbehind: true
+    },
+    boolean: /\b(?:false|nil|true)\b/,
+    number: {
+      pattern:
+        /(^|[^\w$@])(?:\d+(?:[/.]\d+)?(?:e[+-]?\d+)?|0x[a-f0-9]+|[1-9]\d?r[a-z0-9]+)[lmn]?(?![\w$@])/i,
+      lookbehind: true
+    },
+    function: {
+      pattern: /((?:^|[^'])\()[\w*+!?'<>=/.-]+(?=[\s)]|$)/,
+      lookbehind: true
+    },
+    operator: /[#@^`~]/,
+    punctuation: /[{}\[\](),]/
+  };
 }
 
+var clojure$2 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': clojure_1
+}, [clojure_1]);
+
 var cmake_1;
 var hasRequiredCmake;
 
@@ -67278,7 +67212,7 @@ var hasRequiredGlsl;
 function requireGlsl () {
 	if (hasRequiredGlsl) return glsl_1;
 	hasRequiredGlsl = 1;
-	var refractorC = requireC();
+	var refractorC = c_1;
 	glsl_1 = glsl;
 	glsl.displayName = 'glsl';
 	glsl.aliases = [];
@@ -68252,7 +68186,7 @@ var hasRequiredHlsl;
 function requireHlsl () {
 	if (hasRequiredHlsl) return hlsl_1;
 	hasRequiredHlsl = 1;
-	var refractorC = requireC();
+	var refractorC = c_1;
 	hlsl_1 = hlsl;
 	hlsl.displayName = 'hlsl';
 	hlsl.aliases = [];
@@ -74785,7 +74719,7 @@ var hasRequiredObjectivec;
 function requireObjectivec () {
 	if (hasRequiredObjectivec) return objectivec_1;
 	hasRequiredObjectivec = 1;
-	var refractorC = requireC();
+	var refractorC = c_1;
 	objectivec_1 = objectivec;
 	objectivec.displayName = 'objectivec';
 	objectivec.aliases = ['objc'];
@@ -74883,7 +74817,7 @@ var hasRequiredOpencl;
 function requireOpencl () {
 	if (hasRequiredOpencl) return opencl_1;
 	hasRequiredOpencl = 1;
-	var refractorC = requireC();
+	var refractorC = c_1;
 	opencl_1 = opencl;
 	opencl.displayName = 'opencl';
 	opencl.aliases = [];
@@ -78755,7 +78689,7 @@ var hasRequiredShellSession;
 function requireShellSession () {
 	if (hasRequiredShellSession) return shellSession_1;
 	hasRequiredShellSession = 1;
-	var refractorBash = requireBash();
+	var refractorBash = bash_1;
 	shellSession_1 = shellSession;
 	shellSession.displayName = 'shellSession';
 	shellSession.aliases = [];
@@ -80222,7 +80156,7 @@ var hasRequiredVbnet;
 function requireVbnet () {
 	if (hasRequiredVbnet) return vbnet_1;
 	hasRequiredVbnet = 1;
-	var refractorBasic = requireBasic();
+	var refractorBasic = basic_1;
 	vbnet_1 = vbnet;
 	vbnet.displayName = 'vbnet';
 	vbnet.aliases = [];
@@ -82941,7 +82875,7 @@ var refractor = core;
 var refractor_1 = refractor;
 
 refractor.register(abap_1);
-refractor.register(abnf_1);
+refractor.register(requireAbnf());
 refractor.register(actionscript_1);
 refractor.register(ada_1);
 refractor.register(agda_1);
@@ -82960,25 +82894,25 @@ refractor.register(asmatmel_1);
 refractor.register(aspnet_1);
 refractor.register(autohotkey_1);
 refractor.register(autoit_1);
-refractor.register(requireAvisynth());
-refractor.register(requireAvroIdl());
-refractor.register(requireBash());
-refractor.register(requireBasic());
-refractor.register(requireBatch());
-refractor.register(requireBbcode());
-refractor.register(requireBicep());
-refractor.register(requireBirb());
-refractor.register(requireBison());
-refractor.register(requireBnf());
-refractor.register(requireBrainfuck());
-refractor.register(requireBrightscript());
-refractor.register(requireBro());
-refractor.register(requireBsl());
-refractor.register(requireC());
-refractor.register(requireCfscript());
-refractor.register(requireChaiscript());
+refractor.register(avisynth_1);
+refractor.register(avroIdl_1);
+refractor.register(bash_1);
+refractor.register(basic_1);
+refractor.register(batch_1);
+refractor.register(bbcode_1);
+refractor.register(bicep_1);
+refractor.register(birb_1);
+refractor.register(bison_1);
+refractor.register(bnf_1);
+refractor.register(brainfuck_1);
+refractor.register(brightscript_1);
+refractor.register(bro_1);
+refractor.register(bsl_1);
+refractor.register(c_1);
+refractor.register(cfscript_1);
+refractor.register(chaiscript_1);
 refractor.register(requireCil());
-refractor.register(requireClojure());
+refractor.register(clojure_1);
 refractor.register(requireCmake());
 refractor.register(requireCobol());
 refractor.register(requireCoffeescript());
@@ -87288,7 +87222,7 @@ var CodeSnippet = function CodeSnippet(_ref) {
               subject: formData.subject,
               emails: ramda.pluck("value", formData.emails),
               message: (_ref7 = (cov_uqaajbocu().b[7][0]++, (_body$ref = body.ref) === null || _body$ref === void 0 ? void 0 : _body$ref.current.innerHTML)) !== null && _ref7 !== void 0 ? _ref7 : (cov_uqaajbocu().b[7][1]++, body),
-              snippet: codeString
+              snippet: codeToDisplay
             });
           case 13:
           case "end":
@@ -90374,12 +90308,12 @@ var _1c = /*#__PURE__*/_mergeNamespaces({
   'default': _1cExports
 }, [_1cExports]);
 
-var abnfExports = requireAbnf();
+var abnfExports$1 = requireAbnf$1();
 
-var abnf = /*#__PURE__*/_mergeNamespaces({
+var abnf$1 = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': abnfExports
-}, [abnfExports]);
+  'default': abnfExports$1
+}, [abnfExports$1]);
 
 var accesslogExports = requireAccesslog();
 
@@ -90493,33 +90427,33 @@ var axapta = /*#__PURE__*/_mergeNamespaces({
   'default': axaptaExports
 }, [axaptaExports]);
 
-var bashExports$1 = requireBash$1();
+var bashExports = requireBash();
 
-var bash$1 = /*#__PURE__*/_mergeNamespaces({
+var bash = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': bashExports$1
-}, [bashExports$1]);
+  'default': bashExports
+}, [bashExports]);
 
-var basicExports$1 = requireBasic$1();
+var basicExports = requireBasic();
 
-var basic$1 = /*#__PURE__*/_mergeNamespaces({
+var basic = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': basicExports$1
-}, [basicExports$1]);
+  'default': basicExports
+}, [basicExports]);
 
-var bnfExports$1 = requireBnf$1();
+var bnfExports = requireBnf();
 
-var bnf$1 = /*#__PURE__*/_mergeNamespaces({
+var bnf = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': bnfExports$1
-}, [bnfExports$1]);
+  'default': bnfExports
+}, [bnfExports]);
 
-var brainfuckExports$1 = requireBrainfuck$1();
+var brainfuckExports = requireBrainfuck();
 
-var brainfuck$1 = /*#__PURE__*/_mergeNamespaces({
+var brainfuck = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': brainfuckExports$1
-}, [brainfuckExports$1]);
+  'default': brainfuckExports
+}, [brainfuckExports]);
 
 var cLikeExports = requireCLike();
 
@@ -90528,12 +90462,12 @@ var cLike = /*#__PURE__*/_mergeNamespaces({
   'default': cLikeExports
 }, [cLikeExports]);
 
-var cExports$1 = requireC$1();
+var cExports = requireC();
 
-var c$1 = /*#__PURE__*/_mergeNamespaces({
+var c = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': cExports$1
-}, [cExports$1]);
+  'default': cExports
+}, [cExports]);
 
 var calExports = requireCal();
 
@@ -90570,12 +90504,12 @@ var clojureRepl = /*#__PURE__*/_mergeNamespaces({
   'default': clojureReplExports
 }, [clojureReplExports]);
 
-var clojureExports$1 = requireClojure$1();
+var clojureExports = requireClojure();
 
-var clojure$1 = /*#__PURE__*/_mergeNamespaces({
+var clojure = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': clojureExports$1
-}, [clojureExports$1]);
+  'default': clojureExports
+}, [clojureExports]);
 
 var cmakeExports$1 = requireCmake$1();
 
@@ -91704,124 +91638,12 @@ var zephir = /*#__PURE__*/_mergeNamespaces({
   'default': zephirExports
 }, [zephirExports]);
 
-var avisynthExports = requireAvisynth();
-
-var avisynth = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': avisynthExports
-}, [avisynthExports]);
-
-var avroIdlExports = requireAvroIdl();
-
-var avroIdl = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': avroIdlExports
-}, [avroIdlExports]);
-
-var bashExports = requireBash();
-
-var bash = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': bashExports
-}, [bashExports]);
-
-var basicExports = requireBasic();
-
-var basic = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': basicExports
-}, [basicExports]);
-
-var batchExports = requireBatch();
-
-var batch = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': batchExports
-}, [batchExports]);
-
-var bbcodeExports = requireBbcode();
-
-var bbcode = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': bbcodeExports
-}, [bbcodeExports]);
-
-var bicepExports = requireBicep();
-
-var bicep = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': bicepExports
-}, [bicepExports]);
-
-var birbExports = requireBirb();
-
-var birb = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': birbExports
-}, [birbExports]);
-
-var bisonExports = requireBison();
-
-var bison = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': bisonExports
-}, [bisonExports]);
-
-var bnfExports = requireBnf();
-
-var bnf = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': bnfExports
-}, [bnfExports]);
-
-var brainfuckExports = requireBrainfuck();
-
-var brainfuck = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': brainfuckExports
-}, [brainfuckExports]);
-
-var brightscriptExports = requireBrightscript();
-
-var brightscript = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': brightscriptExports
-}, [brightscriptExports]);
-
-var broExports = requireBro();
-
-var bro = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': broExports
-}, [broExports]);
-
-var bslExports = requireBsl();
-
-var bsl = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': bslExports
-}, [bslExports]);
-
-var cExports = requireC();
-
-var c = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': cExports
-}, [cExports]);
-
-var cfscriptExports = requireCfscript();
-
-var cfscript = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': cfscriptExports
-}, [cfscriptExports]);
-
-var chaiscriptExports = requireChaiscript();
+var abnfExports = requireAbnf();
 
-var chaiscript = /*#__PURE__*/_mergeNamespaces({
+var abnf = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': chaiscriptExports
-}, [chaiscriptExports]);
+  'default': abnfExports
+}, [abnfExports]);
 
 var cilExports = requireCil();
 
@@ -91830,13 +91652,6 @@ var cil = /*#__PURE__*/_mergeNamespaces({
   'default': cilExports
 }, [cilExports]);
 
-var clojureExports = requireClojure();
-
-var clojure = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': clojureExports
-}, [clojureExports]);
-
 var cmakeExports = requireCmake();
 
 var cmake = /*#__PURE__*/_mergeNamespaces({