@bigbinary/neeto-molecules 1.0.17 → 1.0.18

package/dist/NeetoWidget.cjs.js

@@ -4727,11 +4727,11 @@ function require_1c () {
  * */
 
 var abnf_1$1;
-var hasRequiredAbnf$1;
+var hasRequiredAbnf;
 
-function requireAbnf$1 () {
-	if (hasRequiredAbnf$1) return abnf_1$1;
-	hasRequiredAbnf$1 = 1;
+function requireAbnf () {
+	if (hasRequiredAbnf) return abnf_1$1;
+	hasRequiredAbnf = 1;
 	/**
 	 * @param {RegExp | string } re
 	 * @returns {string}
@@ -8074,11 +8074,11 @@ function requireAxapta () {
  * */
 
 var bash_1$1;
-var hasRequiredBash;
+var hasRequiredBash$1;
 
-function requireBash () {
-	if (hasRequiredBash) return bash_1$1;
-	hasRequiredBash = 1;
+function requireBash$1 () {
+	if (hasRequiredBash$1) return bash_1$1;
+	hasRequiredBash$1 = 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;
+var hasRequiredBasic$1;
 
-function requireBasic () {
-	if (hasRequiredBasic) return basic_1$1;
-	hasRequiredBasic = 1;
+function requireBasic$1 () {
+	if (hasRequiredBasic$1) return basic_1$1;
+	hasRequiredBasic$1 = 1;
 	/** @type LanguageFn */
 	function basic(hljs) {
 	  return {
@@ -8327,11 +8327,11 @@ Author: Oleg Efimov <efimovov@gmail.com>
 */
 
 var bnf_1$1;
-var hasRequiredBnf;
+var hasRequiredBnf$1;
 
-function requireBnf () {
-	if (hasRequiredBnf) return bnf_1$1;
-	hasRequiredBnf = 1;
+function requireBnf$1 () {
+	if (hasRequiredBnf$1) return bnf_1$1;
+	hasRequiredBnf$1 = 1;
 	/** @type LanguageFn */
 	function bnf(hljs) {
 	  return {
@@ -8374,11 +8374,11 @@ Website: https://esolangs.org/wiki/Brainfuck
 */
 
 var brainfuck_1$1;
-var hasRequiredBrainfuck;
+var hasRequiredBrainfuck$1;
 
-function requireBrainfuck () {
-	if (hasRequiredBrainfuck) return brainfuck_1$1;
-	hasRequiredBrainfuck = 1;
+function requireBrainfuck$1 () {
+	if (hasRequiredBrainfuck$1) return brainfuck_1$1;
+	hasRequiredBrainfuck$1 = 1;
 	/** @type LanguageFn */
 	function brainfuck(hljs) {
 	  const LITERAL = {
@@ -8938,11 +8938,11 @@ function requireCLike () {
  * */
 
 var c_1$1;
-var hasRequiredC;
+var hasRequiredC$1;
 
-function requireC () {
-	if (hasRequiredC) return c_1$1;
-	hasRequiredC = 1;
+function requireC$1 () {
+	if (hasRequiredC$1) return c_1$1;
+	hasRequiredC$1 = 1;
 	/**
 	 * @param {RegExp | string } re
 	 * @returns {string}
@@ -9585,11 +9585,11 @@ Category: lisp
 */
 
 var clojure_1$1;
-var hasRequiredClojure;
+var hasRequiredClojure$1;
 
-function requireClojure () {
-	if (hasRequiredClojure) return clojure_1$1;
-	hasRequiredClojure = 1;
+function requireClojure$1 () {
+	if (hasRequiredClojure$1) return clojure_1$1;
+	hasRequiredClojure$1 = 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$1());
+low.registerLanguage('abnf', requireAbnf());
 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());
-low.registerLanguage('basic', requireBasic());
-low.registerLanguage('bnf', requireBnf());
+low.registerLanguage('bash', requireBash$1());
+low.registerLanguage('basic', requireBasic$1());
+low.registerLanguage('bnf', requireBnf$1());
 low.registerLanguage(
   'brainfuck',
-  requireBrainfuck()
+  requireBrainfuck$1()
 );
 low.registerLanguage('c-like', requireCLike());
-low.registerLanguage('c', requireC());
+low.registerLanguage('c', requireC$1());
 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());
+low.registerLanguage('clojure', requireClojure$1());
 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$1; });
+    return Promise.resolve().then(function () { return abnf; });
   }),
   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; });
+    return Promise.resolve().then(function () { return bash$1; });
   }),
   basic: createLanguageAsyncLoader("basic", function () {
-    return Promise.resolve().then(function () { return basic; });
+    return Promise.resolve().then(function () { return basic$1; });
   }),
   bnf: createLanguageAsyncLoader("bnf", function () {
-    return Promise.resolve().then(function () { return bnf; });
+    return Promise.resolve().then(function () { return bnf$1; });
   }),
   brainfuck: createLanguageAsyncLoader("brainfuck", function () {
-    return Promise.resolve().then(function () { return brainfuck; });
+    return Promise.resolve().then(function () { return brainfuck$1; });
   }),
   cLike: createLanguageAsyncLoader("cLike", function () {
     return Promise.resolve().then(function () { return cLike; });
   }),
   c: createLanguageAsyncLoader("c", function () {
-    return Promise.resolve().then(function () { return c; });
+    return Promise.resolve().then(function () { return c$1; });
   }),
   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; });
+    return Promise.resolve().then(function () { return clojure$1; });
   }),
   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; });
+    return Promise.resolve().then(function () { return abnf$2; });
   }),
   actionscript: createLanguageAsyncLoader("actionscript", function () {
     return Promise.resolve().then(function () { return actionscript$2; });
@@ -50346,7 +50346,7 @@ var languageLoaders = {
     return Promise.resolve().then(function () { return agda$1; });
   }),
   al: createLanguageAsyncLoader("al", function () {
-    return Promise.resolve().then(function () { return al$1; });
+    return Promise.resolve().then(function () { return al; });
   }),
   antlr4: createLanguageAsyncLoader("antlr4", function () {
     return Promise.resolve().then(function () { return antlr4$1; });
@@ -50394,52 +50394,52 @@ var languageLoaders = {
     return Promise.resolve().then(function () { return avisynth$1; });
   }),
   avroIdl: createLanguageAsyncLoader("avroIdl", function () {
-    return Promise.resolve().then(function () { return avroIdl$1; });
+    return Promise.resolve().then(function () { return avroIdl; });
   }),
   bash: createLanguageAsyncLoader("bash", function () {
-    return Promise.resolve().then(function () { return bash$2; });
+    return Promise.resolve().then(function () { return bash; });
   }),
   basic: createLanguageAsyncLoader("basic", function () {
-    return Promise.resolve().then(function () { return basic$2; });
+    return Promise.resolve().then(function () { return basic; });
   }),
   batch: createLanguageAsyncLoader("batch", function () {
-    return Promise.resolve().then(function () { return batch$1; });
+    return Promise.resolve().then(function () { return batch; });
   }),
   bbcode: createLanguageAsyncLoader("bbcode", function () {
-    return Promise.resolve().then(function () { return bbcode$1; });
+    return Promise.resolve().then(function () { return bbcode; });
   }),
   bicep: createLanguageAsyncLoader("bicep", function () {
-    return Promise.resolve().then(function () { return bicep$1; });
+    return Promise.resolve().then(function () { return bicep; });
   }),
   birb: createLanguageAsyncLoader("birb", function () {
-    return Promise.resolve().then(function () { return birb$1; });
+    return Promise.resolve().then(function () { return birb; });
   }),
   bison: createLanguageAsyncLoader("bison", function () {
-    return Promise.resolve().then(function () { return bison$1; });
+    return Promise.resolve().then(function () { return bison; });
   }),
   bnf: createLanguageAsyncLoader("bnf", function () {
-    return Promise.resolve().then(function () { return bnf$2; });
+    return Promise.resolve().then(function () { return bnf; });
   }),
   brainfuck: createLanguageAsyncLoader("brainfuck", function () {
-    return Promise.resolve().then(function () { return brainfuck$2; });
+    return Promise.resolve().then(function () { return brainfuck; });
   }),
   brightscript: createLanguageAsyncLoader("brightscript", function () {
-    return Promise.resolve().then(function () { return brightscript$1; });
+    return Promise.resolve().then(function () { return brightscript; });
   }),
   bro: createLanguageAsyncLoader("bro", function () {
-    return Promise.resolve().then(function () { return bro$1; });
+    return Promise.resolve().then(function () { return bro; });
   }),
   bsl: createLanguageAsyncLoader("bsl", function () {
-    return Promise.resolve().then(function () { return bsl$1; });
+    return Promise.resolve().then(function () { return bsl; });
   }),
   c: createLanguageAsyncLoader("c", function () {
-    return Promise.resolve().then(function () { return c$2; });
+    return Promise.resolve().then(function () { return c; });
   }),
   cfscript: createLanguageAsyncLoader("cfscript", function () {
-    return Promise.resolve().then(function () { return cfscript$1; });
+    return Promise.resolve().then(function () { return cfscript; });
   }),
   chaiscript: createLanguageAsyncLoader("chaiscript", function () {
-    return Promise.resolve().then(function () { return chaiscript$1; });
+    return Promise.resolve().then(function () { return chaiscript; });
   }),
   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$2; });
+    return Promise.resolve().then(function () { return clojure; });
   }),
   cmake: createLanguageAsyncLoader("cmake", function () {
     return Promise.resolve().then(function () { return cmake; });
@@ -59703,77 +59703,73 @@ var abap$1 = /*#__PURE__*/_mergeNamespaces({
   'default': abap_1
 }, [abap_1]);
 
-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) {
+var abnf_1 = abnf$1;
+abnf$1.displayName = 'abnf';
+abnf$1.aliases = [];
+function abnf$1(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);
-	}
-	return abnf_1;
+    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 abnf$2 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': abnf_1
+}, [abnf_1]);
+
 var actionscript_1 = actionscript$1;
 actionscript$1.displayName = 'actionscript';
 actionscript$1.aliases = [];
@@ -59870,42 +59866,46 @@ var agda$1 = /*#__PURE__*/_mergeNamespaces({
   'default': agda_1
 }, [agda_1]);
 
-var al_1 = al;
-al.displayName = 'al';
-al.aliases = [];
-function al(Prism) {
-  // based on https://github.com/microsoft/AL/blob/master/grammar/alsyntax.tmlanguage
-  Prism.languages.al = {
-    comment: /\/\/.*|\/\*[\s\S]*?\*\//,
-    string: {
-      pattern: /'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,
-      greedy: true
-    },
-    function: {
-      pattern:
-        /(\b(?:event|procedure|trigger)\s+|(?:^|[^.])\.\s*)[a-z_]\w*(?=\s*\()/i,
-      lookbehind: true
-    },
-    keyword: [
-      // keywords
-      /\b(?:array|asserterror|begin|break|case|do|downto|else|end|event|exit|for|foreach|function|if|implements|in|indataset|interface|internal|local|of|procedure|program|protected|repeat|runonclient|securityfiltering|suppressdispose|temporary|then|to|trigger|until|var|while|with|withevents)\b/i, // objects and metadata that are used like keywords
-      /\b(?:action|actions|addafter|addbefore|addfirst|addlast|area|assembly|chartpart|codeunit|column|controladdin|cuegroup|customizes|dataitem|dataset|dotnet|elements|enum|enumextension|extends|field|fieldattribute|fieldelement|fieldgroup|fieldgroups|fields|filter|fixed|grid|group|key|keys|label|labels|layout|modify|moveafter|movebefore|movefirst|movelast|page|pagecustomization|pageextension|part|profile|query|repeater|report|requestpage|schema|separator|systempart|table|tableelement|tableextension|textattribute|textelement|type|usercontrol|value|xmlport)\b/i
-    ],
-    number:
-      /\b(?:0x[\da-f]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)(?:F|LL?|U(?:LL?)?)?\b/i,
-    boolean: /\b(?:false|true)\b/i,
-    variable: /\b(?:Curr(?:FieldNo|Page|Report)|x?Rec|RequestOptionsPage)\b/,
-    'class-name':
-      /\b(?:automation|biginteger|bigtext|blob|boolean|byte|char|clienttype|code|completiontriggererrorlevel|connectiontype|database|dataclassification|datascope|date|dateformula|datetime|decimal|defaultlayout|dialog|dictionary|dotnetassembly|dotnettypedeclaration|duration|errorinfo|errortype|executioncontext|executionmode|fieldclass|fieldref|fieldtype|file|filterpagebuilder|guid|httpclient|httpcontent|httpheaders|httprequestmessage|httpresponsemessage|instream|integer|joker|jsonarray|jsonobject|jsontoken|jsonvalue|keyref|list|moduledependencyinfo|moduleinfo|none|notification|notificationscope|objecttype|option|outstream|pageresult|record|recordid|recordref|reportformat|securityfilter|sessionsettings|tableconnectiontype|tablefilter|testaction|testfield|testfilterfield|testpage|testpermissions|testrequestpage|text|textbuilder|textconst|textencoding|time|transactionmodel|transactiontype|variant|verbosity|version|view|views|webserviceactioncontext|webserviceactionresultcode|xmlattribute|xmlattributecollection|xmlcdata|xmlcomment|xmldeclaration|xmldocument|xmldocumenttype|xmlelement|xmlnamespacemanager|xmlnametable|xmlnode|xmlnodelist|xmlprocessinginstruction|xmlreadoptions|xmltext|xmlwriteoptions)\b/i,
-    operator: /\.\.|:[=:]|[-+*/]=?|<>|[<>]=?|=|\b(?:and|div|mod|not|or|xor)\b/i,
-    punctuation: /[()\[\]{}:.;,]/
-  };
-}
+var al_1;
+var hasRequiredAl;
 
-var al$1 = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': al_1
-}, [al_1]);
+function requireAl () {
+	if (hasRequiredAl) return al_1;
+	hasRequiredAl = 1;
+
+	al_1 = al;
+	al.displayName = 'al';
+	al.aliases = [];
+	function al(Prism) {
+	  // based on https://github.com/microsoft/AL/blob/master/grammar/alsyntax.tmlanguage
+	  Prism.languages.al = {
+	    comment: /\/\/.*|\/\*[\s\S]*?\*\//,
+	    string: {
+	      pattern: /'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,
+	      greedy: true
+	    },
+	    function: {
+	      pattern:
+	        /(\b(?:event|procedure|trigger)\s+|(?:^|[^.])\.\s*)[a-z_]\w*(?=\s*\()/i,
+	      lookbehind: true
+	    },
+	    keyword: [
+	      // keywords
+	      /\b(?:array|asserterror|begin|break|case|do|downto|else|end|event|exit|for|foreach|function|if|implements|in|indataset|interface|internal|local|of|procedure|program|protected|repeat|runonclient|securityfiltering|suppressdispose|temporary|then|to|trigger|until|var|while|with|withevents)\b/i, // objects and metadata that are used like keywords
+	      /\b(?:action|actions|addafter|addbefore|addfirst|addlast|area|assembly|chartpart|codeunit|column|controladdin|cuegroup|customizes|dataitem|dataset|dotnet|elements|enum|enumextension|extends|field|fieldattribute|fieldelement|fieldgroup|fieldgroups|fields|filter|fixed|grid|group|key|keys|label|labels|layout|modify|moveafter|movebefore|movefirst|movelast|page|pagecustomization|pageextension|part|profile|query|repeater|report|requestpage|schema|separator|systempart|table|tableelement|tableextension|textattribute|textelement|type|usercontrol|value|xmlport)\b/i
+	    ],
+	    number:
+	      /\b(?:0x[\da-f]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)(?:F|LL?|U(?:LL?)?)?\b/i,
+	    boolean: /\b(?:false|true)\b/i,
+	    variable: /\b(?:Curr(?:FieldNo|Page|Report)|x?Rec|RequestOptionsPage)\b/,
+	    'class-name':
+	      /\b(?:automation|biginteger|bigtext|blob|boolean|byte|char|clienttype|code|completiontriggererrorlevel|connectiontype|database|dataclassification|datascope|date|dateformula|datetime|decimal|defaultlayout|dialog|dictionary|dotnetassembly|dotnettypedeclaration|duration|errorinfo|errortype|executioncontext|executionmode|fieldclass|fieldref|fieldtype|file|filterpagebuilder|guid|httpclient|httpcontent|httpheaders|httprequestmessage|httpresponsemessage|instream|integer|joker|jsonarray|jsonobject|jsontoken|jsonvalue|keyref|list|moduledependencyinfo|moduleinfo|none|notification|notificationscope|objecttype|option|outstream|pageresult|record|recordid|recordref|reportformat|securityfilter|sessionsettings|tableconnectiontype|tablefilter|testaction|testfield|testfilterfield|testpage|testpermissions|testrequestpage|text|textbuilder|textconst|textencoding|time|transactionmodel|transactiontype|variant|verbosity|version|view|views|webserviceactioncontext|webserviceactionresultcode|xmlattribute|xmlattributecollection|xmlcdata|xmlcomment|xmldeclaration|xmldocument|xmldocumenttype|xmlelement|xmlnamespacemanager|xmlnametable|xmlnode|xmlnodelist|xmlprocessinginstruction|xmlreadoptions|xmltext|xmlwriteoptions)\b/i,
+	    operator: /\.\.|:[=:]|[-+*/]=?|<>|[<>]=?|=|\b(?:and|div|mod|not|or|xor)\b/i,
+	    punctuation: /[()\[\]{}:.;,]/
+	  };
+	}
+	return al_1;
+}
 
 var antlr4_1 = antlr4;
 antlr4.displayName = 'antlr4';
@@ -60313,98 +60313,102 @@ var aql$1 = /*#__PURE__*/_mergeNamespaces({
   'default': aql_1
 }, [aql_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_1;
+var hasRequiredC;
 
-var c$2 = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': c_1
-}, [c_1]);
+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 cpp_1;
 var hasRequiredCpp;
@@ -60412,7 +60416,7 @@ var hasRequiredCpp;
 function requireCpp () {
 	if (hasRequiredCpp) return cpp_1;
 	hasRequiredCpp = 1;
-	var refractorC = c_1;
+	var refractorC = requireC();
 	cpp_1 = cpp;
 	cpp.displayName = 'cpp';
 	cpp.aliases = [];
@@ -60533,12 +60537,12 @@ function requireCpp () {
 	return cpp_1;
 }
 
-var refractorCpp$1 = requireCpp();
+var refractorCpp = requireCpp();
 var arduino_1 = arduino$1;
 arduino$1.displayName = 'arduino';
 arduino$1.aliases = ['ino'];
 function arduino$1(Prism) {
-  Prism.register(refractorCpp$1);
+  Prism.register(refractorCpp);
   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/,
@@ -61712,1023 +61716,1081 @@ var avisynth$1 = /*#__PURE__*/_mergeNamespaces({
   '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'];
-}
+var avroIdl_1;
+var hasRequiredAvroIdl;
 
-var avroIdl$1 = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': avroIdl_1
-}, [avroIdl_1]);
+function requireAvroIdl () {
+	if (hasRequiredAvroIdl) return avroIdl_1;
+	hasRequiredAvroIdl = 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);
+	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$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: /[,;:()]/
-  };
-}
+var bash_1;
+var hasRequiredBash;
 
-var basic$2 = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': basic_1
-}, [basic_1]);
+function requireBash () {
+	if (hasRequiredBash) return bash_1;
+	hasRequiredBash = 1;
 
-var batch_1 = batch;
-batch.displayName = 'batch';
-batch.aliases = [];
-function batch(Prism) {
+	bash_1 = bash;
+	bash.displayName = 'bash';
+	bash.aliases = ['shell'];
+	function bash(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);
-}
-
-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 = /*#__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;
+	    // $ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 cfscript$1 = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': cfscript_1
-}, [cfscript_1]);
+var brightscript_1;
+var hasRequiredBrightscript;
 
-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]+/
-      }
-    }
-  });
+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 chaiscript$1 = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': chaiscript_1
-}, [chaiscript_1]);
+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 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 cfscript_1;
+var hasRequiredCfscript;
+
+function requireCfscript () {
+	if (hasRequiredCfscript) return cfscript_1;
+	hasRequiredCfscript = 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 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 cil_1;
 var hasRequiredCil;
@@ -62766,49 +62828,53 @@ function requireCil () {
 	return cil_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_1;
+var hasRequiredClojure;
 
-var clojure$2 = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': clojure_1
-}, [clojure_1]);
+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 cmake_1;
 var hasRequiredCmake;
@@ -67212,7 +67278,7 @@ var hasRequiredGlsl;
 function requireGlsl () {
 	if (hasRequiredGlsl) return glsl_1;
 	hasRequiredGlsl = 1;
-	var refractorC = c_1;
+	var refractorC = requireC();
 	glsl_1 = glsl;
 	glsl.displayName = 'glsl';
 	glsl.aliases = [];
@@ -68186,7 +68252,7 @@ var hasRequiredHlsl;
 function requireHlsl () {
 	if (hasRequiredHlsl) return hlsl_1;
 	hasRequiredHlsl = 1;
-	var refractorC = c_1;
+	var refractorC = requireC();
 	hlsl_1 = hlsl;
 	hlsl.displayName = 'hlsl';
 	hlsl.aliases = [];
@@ -74719,7 +74785,7 @@ var hasRequiredObjectivec;
 function requireObjectivec () {
 	if (hasRequiredObjectivec) return objectivec_1;
 	hasRequiredObjectivec = 1;
-	var refractorC = c_1;
+	var refractorC = requireC();
 	objectivec_1 = objectivec;
 	objectivec.displayName = 'objectivec';
 	objectivec.aliases = ['objc'];
@@ -74817,7 +74883,7 @@ var hasRequiredOpencl;
 function requireOpencl () {
 	if (hasRequiredOpencl) return opencl_1;
 	hasRequiredOpencl = 1;
-	var refractorC = c_1;
+	var refractorC = requireC();
 	opencl_1 = opencl;
 	opencl.displayName = 'opencl';
 	opencl.aliases = [];
@@ -78689,7 +78755,7 @@ var hasRequiredShellSession;
 function requireShellSession () {
 	if (hasRequiredShellSession) return shellSession_1;
 	hasRequiredShellSession = 1;
-	var refractorBash = bash_1;
+	var refractorBash = requireBash();
 	shellSession_1 = shellSession;
 	shellSession.displayName = 'shellSession';
 	shellSession.aliases = [];
@@ -80156,7 +80222,7 @@ var hasRequiredVbnet;
 function requireVbnet () {
 	if (hasRequiredVbnet) return vbnet_1;
 	hasRequiredVbnet = 1;
-	var refractorBasic = basic_1;
+	var refractorBasic = requireBasic();
 	vbnet_1 = vbnet;
 	vbnet.displayName = 'vbnet';
 	vbnet.aliases = [];
@@ -82875,11 +82941,11 @@ var refractor = core;
 var refractor_1 = refractor;
 
 refractor.register(abap_1);
-refractor.register(requireAbnf());
+refractor.register(abnf_1);
 refractor.register(actionscript_1);
 refractor.register(ada_1);
 refractor.register(agda_1);
-refractor.register(al_1);
+refractor.register(requireAl());
 refractor.register(antlr4_1);
 refractor.register(apacheconf_1);
 refractor.register(apex_1);
@@ -82895,24 +82961,24 @@ refractor.register(aspnet_1);
 refractor.register(autohotkey_1);
 refractor.register(autoit_1);
 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(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(requireCil());
-refractor.register(clojure_1);
+refractor.register(requireClojure());
 refractor.register(requireCmake());
 refractor.register(requireCobol());
 refractor.register(requireCoffeescript());
@@ -90308,12 +90374,12 @@ var _1c = /*#__PURE__*/_mergeNamespaces({
   'default': _1cExports
 }, [_1cExports]);
 
-var abnfExports$1 = requireAbnf$1();
+var abnfExports = requireAbnf();
 
-var abnf$1 = /*#__PURE__*/_mergeNamespaces({
+var abnf = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': abnfExports$1
-}, [abnfExports$1]);
+  'default': abnfExports
+}, [abnfExports]);
 
 var accesslogExports = requireAccesslog();
 
@@ -90427,33 +90493,33 @@ var axapta = /*#__PURE__*/_mergeNamespaces({
   'default': axaptaExports
 }, [axaptaExports]);
 
-var bashExports = requireBash();
+var bashExports$1 = requireBash$1();
 
-var bash = /*#__PURE__*/_mergeNamespaces({
+var bash$1 = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': bashExports
-}, [bashExports]);
+  'default': bashExports$1
+}, [bashExports$1]);
 
-var basicExports = requireBasic();
+var basicExports$1 = requireBasic$1();
 
-var basic = /*#__PURE__*/_mergeNamespaces({
+var basic$1 = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': basicExports
-}, [basicExports]);
+  'default': basicExports$1
+}, [basicExports$1]);
 
-var bnfExports = requireBnf();
+var bnfExports$1 = requireBnf$1();
 
-var bnf = /*#__PURE__*/_mergeNamespaces({
+var bnf$1 = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': bnfExports
-}, [bnfExports]);
+  'default': bnfExports$1
+}, [bnfExports$1]);
 
-var brainfuckExports = requireBrainfuck();
+var brainfuckExports$1 = requireBrainfuck$1();
 
-var brainfuck = /*#__PURE__*/_mergeNamespaces({
+var brainfuck$1 = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': brainfuckExports
-}, [brainfuckExports]);
+  'default': brainfuckExports$1
+}, [brainfuckExports$1]);
 
 var cLikeExports = requireCLike();
 
@@ -90462,12 +90528,12 @@ var cLike = /*#__PURE__*/_mergeNamespaces({
   'default': cLikeExports
 }, [cLikeExports]);
 
-var cExports = requireC();
+var cExports$1 = requireC$1();
 
-var c = /*#__PURE__*/_mergeNamespaces({
+var c$1 = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': cExports
-}, [cExports]);
+  'default': cExports$1
+}, [cExports$1]);
 
 var calExports = requireCal();
 
@@ -90504,12 +90570,12 @@ var clojureRepl = /*#__PURE__*/_mergeNamespaces({
   'default': clojureReplExports
 }, [clojureReplExports]);
 
-var clojureExports = requireClojure();
+var clojureExports$1 = requireClojure$1();
 
-var clojure = /*#__PURE__*/_mergeNamespaces({
+var clojure$1 = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': clojureExports
-}, [clojureExports]);
+  'default': clojureExports$1
+}, [clojureExports$1]);
 
 var cmakeExports$1 = requireCmake$1();
 
@@ -91638,12 +91704,124 @@ var zephir = /*#__PURE__*/_mergeNamespaces({
   'default': zephirExports
 }, [zephirExports]);
 
-var abnfExports = requireAbnf();
+var alExports = requireAl();
 
-var abnf = /*#__PURE__*/_mergeNamespaces({
+var al = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
-  'default': abnfExports
-}, [abnfExports]);
+  'default': alExports
+}, [alExports]);
+
+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 chaiscript = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': chaiscriptExports
+}, [chaiscriptExports]);
 
 var cilExports = requireCil();
 
@@ -91652,6 +91830,13 @@ 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({