react-ai-renderer 0.1.7 → 0.1.8

package/dist/index.js

@@ -6224,475 +6224,484 @@ function asmatmel(Prism) {
   };
 }
 
-var csharp_1 = csharp;
-csharp.displayName = 'csharp';
-csharp.aliases = ['dotnet', 'cs'];
-function csharp(Prism) {
+var csharp_1;
+var hasRequiredCsharp;
+
+function requireCsharp () {
+	if (hasRequiredCsharp) return csharp_1;
+	hasRequiredCsharp = 1;
+
+	csharp_1 = csharp;
+	csharp.displayName = 'csharp';
+	csharp.aliases = ['dotnet', 'cs'];
+	function csharp(Prism) {
 (function (Prism) {
-    /**
-     * Replaces all placeholders "<<n>>" of given pattern with the n-th replacement (zero based).
-     *
-     * Note: This is a simple text based replacement. Be careful when using backreferences!
-     *
-     * @param {string} pattern the given pattern.
-     * @param {string[]} replacements a list of replacement which can be inserted into the given pattern.
-     * @returns {string} the pattern with all placeholders replaced with their corresponding replacements.
-     * @example replace(/a<<0>>a/.source, [/b+/.source]) === /a(?:b+)a/.source
-     */
-    function replace(pattern, replacements) {
-      return pattern.replace(/<<(\d+)>>/g, function (m, index) {
-        return '(?:' + replacements[+index] + ')'
-      })
-    }
-    /**
-     * @param {string} pattern
-     * @param {string[]} replacements
-     * @param {string} [flags]
-     * @returns {RegExp}
-     */
-    function re(pattern, replacements, flags) {
-      return RegExp(replace(pattern, replacements), flags || '')
-    }
-    /**
-     * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
-     *
-     * @param {string} pattern
-     * @param {number} depthLog2
-     * @returns {string}
-     */
-    function nested(pattern, depthLog2) {
-      for (var i = 0; i < depthLog2; i++) {
-        pattern = pattern.replace(/<<self>>/g, function () {
-          return '(?:' + pattern + ')'
-        });
-      }
-      return pattern.replace(/<<self>>/g, '[^\\s\\S]')
-    } // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/
-    var keywordKinds = {
-      // keywords which represent a return or variable type
-      type: 'bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void',
-      // keywords which are used to declare a type
-      typeDeclaration: 'class enum interface record struct',
-      // contextual keywords
-      // ("var" and "dynamic" are missing because they are used like types)
-      contextual:
-        'add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)',
-      // all other keywords
-      other:
-        'abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield'
-    }; // keywords
-    function keywordsToPattern(words) {
-      return '\\b(?:' + words.trim().replace(/ /g, '|') + ')\\b'
-    }
-    var typeDeclarationKeywords = keywordsToPattern(
-      keywordKinds.typeDeclaration
-    );
-    var keywords = RegExp(
-      keywordsToPattern(
-        keywordKinds.type +
-          ' ' +
-          keywordKinds.typeDeclaration +
-          ' ' +
-          keywordKinds.contextual +
-          ' ' +
-          keywordKinds.other
-      )
-    );
-    var nonTypeKeywords = keywordsToPattern(
-      keywordKinds.typeDeclaration +
-        ' ' +
-        keywordKinds.contextual +
-        ' ' +
-        keywordKinds.other
-    );
-    var nonContextualKeywords = keywordsToPattern(
-      keywordKinds.type +
-        ' ' +
-        keywordKinds.typeDeclaration +
-        ' ' +
-        keywordKinds.other
-    ); // types
-    var generic = nested(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2); // the idea behind the other forbidden characters is to prevent false positives. Same for tupleElement.
-    var nestedRound = nested(/\((?:[^()]|<<self>>)*\)/.source, 2);
-    var name = /@?\b[A-Za-z_]\w*\b/.source;
-    var genericName = replace(/<<0>>(?:\s*<<1>>)?/.source, [name, generic]);
-    var identifier = replace(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source, [
-      nonTypeKeywords,
-      genericName
-    ]);
-    var array = /\[\s*(?:,\s*)*\]/.source;
-    var typeExpressionWithoutTuple = replace(
-      /<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source,
-      [identifier, array]
-    );
-    var tupleElement = replace(
-      /[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source,
-      [generic, nestedRound, array]
-    );
-    var tuple = replace(/\(<<0>>+(?:,<<0>>+)+\)/.source, [tupleElement]);
-    var typeExpression = replace(
-      /(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source,
-      [tuple, identifier, array]
-    );
-    var typeInside = {
-      keyword: keywords,
-      punctuation: /[<>()?,.:[\]]/
-    }; // strings & characters
-    // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#character-literals
-    // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#string-literals
-    var character = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source; // simplified pattern
-    var regularString = /"(?:\\.|[^\\"\r\n])*"/.source;
-    var verbatimString = /@"(?:""|\\[\s\S]|[^\\"])*"(?!")/.source;
-    Prism.languages.csharp = Prism.languages.extend('clike', {
-      string: [
-        {
-          pattern: re(/(^|[^$\\])<<0>>/.source, [verbatimString]),
-          lookbehind: true,
-          greedy: true
-        },
-        {
-          pattern: re(/(^|[^@$\\])<<0>>/.source, [regularString]),
-          lookbehind: true,
-          greedy: true
-        }
-      ],
-      'class-name': [
-        {
-          // Using static
-          // using static System.Math;
-          pattern: re(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source, [
-            identifier
-          ]),
-          lookbehind: true,
-          inside: typeInside
-        },
-        {
-          // Using alias (type)
-          // using Project = PC.MyCompany.Project;
-          pattern: re(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source, [
-            name,
-            typeExpression
-          ]),
-          lookbehind: true,
-          inside: typeInside
-        },
-        {
-          // Using alias (alias)
-          // using Project = PC.MyCompany.Project;
-          pattern: re(/(\busing\s+)<<0>>(?=\s*=)/.source, [name]),
-          lookbehind: true
-        },
-        {
-          // Type declarations
-          // class Foo<A, B>
-          // interface Foo<out A, B>
-          pattern: re(/(\b<<0>>\s+)<<1>>/.source, [
-            typeDeclarationKeywords,
-            genericName
-          ]),
-          lookbehind: true,
-          inside: typeInside
-        },
-        {
-          // Single catch exception declaration
-          // catch(Foo)
-          // (things like catch(Foo e) is covered by variable declaration)
-          pattern: re(/(\bcatch\s*\(\s*)<<0>>/.source, [identifier]),
-          lookbehind: true,
-          inside: typeInside
-        },
-        {
-          // Name of the type parameter of generic constraints
-          // where Foo : class
-          pattern: re(/(\bwhere\s+)<<0>>/.source, [name]),
-          lookbehind: true
-        },
-        {
-          // Casts and checks via as and is.
-          // as Foo<A>, is Bar<B>
-          // (things like if(a is Foo b) is covered by variable declaration)
-          pattern: re(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source, [
-            typeExpressionWithoutTuple
-          ]),
-          lookbehind: true,
-          inside: typeInside
-        },
-        {
-          // Variable, field and parameter declaration
-          // (Foo bar, Bar baz, Foo[,,] bay, Foo<Bar, FooBar<Bar>> bax)
-          pattern: re(
-            /\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/
-              .source,
-            [typeExpression, nonContextualKeywords, name]
-          ),
-          inside: typeInside
-        }
-      ],
-      keyword: keywords,
-      // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#literals
-      number:
-        /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
-      operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
-      punctuation: /\?\.?|::|[{}[\];(),.:]/
-    });
-    Prism.languages.insertBefore('csharp', 'number', {
-      range: {
-        pattern: /\.\./,
-        alias: 'operator'
-      }
-    });
-    Prism.languages.insertBefore('csharp', 'punctuation', {
-      'named-parameter': {
-        pattern: re(/([(,]\s*)<<0>>(?=\s*:)/.source, [name]),
-        lookbehind: true,
-        alias: 'punctuation'
-      }
-    });
-    Prism.languages.insertBefore('csharp', 'class-name', {
-      namespace: {
-        // namespace Foo.Bar {}
-        // using Foo.Bar;
-        pattern: re(
-          /(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source,
-          [name]
-        ),
-        lookbehind: true,
-        inside: {
-          punctuation: /\./
-        }
-      },
-      'type-expression': {
-        // default(Foo), typeof(Foo<Bar>), sizeof(int)
-        pattern: re(
-          /(\b(?:default|sizeof|typeof)\s*\(\s*(?!\s))(?:[^()\s]|\s(?!\s)|<<0>>)*(?=\s*\))/
-            .source,
-          [nestedRound]
-        ),
-        lookbehind: true,
-        alias: 'class-name',
-        inside: typeInside
-      },
-      'return-type': {
-        // Foo<Bar> ForBar(); Foo IFoo.Bar() => 0
-        // int this[int index] => 0; T IReadOnlyList<T>.this[int index] => this[index];
-        // int Foo => 0; int Foo { get; set } = 0;
-        pattern: re(
-          /<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source,
-          [typeExpression, identifier]
-        ),
-        inside: typeInside,
-        alias: 'class-name'
-      },
-      'constructor-invocation': {
-        // new List<Foo<Bar[]>> { }
-        pattern: re(/(\bnew\s+)<<0>>(?=\s*[[({])/.source, [typeExpression]),
-        lookbehind: true,
-        inside: typeInside,
-        alias: 'class-name'
-      },
-      /*'explicit-implementation': {
-// int IFoo<Foo>.Bar => 0; void IFoo<Foo<Foo>>.Foo<T>();
-pattern: replace(/\b<<0>>(?=\.<<1>>)/, className, methodOrPropertyDeclaration),
-inside: classNameInside,
-alias: 'class-name'
-},*/
-      'generic-method': {
-        // foo<Bar>()
-        pattern: re(/<<0>>\s*<<1>>(?=\s*\()/.source, [name, generic]),
-        inside: {
-          function: re(/^<<0>>/.source, [name]),
-          generic: {
-            pattern: RegExp(generic),
-            alias: 'class-name',
-            inside: typeInside
-          }
-        }
-      },
-      'type-list': {
-        // The list of types inherited or of generic constraints
-        // class Foo<F> : Bar, IList<FooBar>
-        // where F : Bar, IList<int>
-        pattern: re(
-          /\b((?:<<0>>\s+<<1>>|record\s+<<1>>\s*<<5>>|where\s+<<2>>)\s*:\s*)(?:<<3>>|<<4>>|<<1>>\s*<<5>>|<<6>>)(?:\s*,\s*(?:<<3>>|<<4>>|<<6>>))*(?=\s*(?:where|[{;]|=>|$))/
-            .source,
-          [
-            typeDeclarationKeywords,
-            genericName,
-            name,
-            typeExpression,
-            keywords.source,
-            nestedRound,
-            /\bnew\s*\(\s*\)/.source
-          ]
-        ),
-        lookbehind: true,
-        inside: {
-          'record-arguments': {
-            pattern: re(/(^(?!new\s*\()<<0>>\s*)<<1>>/.source, [
-              genericName,
-              nestedRound
-            ]),
-            lookbehind: true,
-            greedy: true,
-            inside: Prism.languages.csharp
-          },
-          keyword: keywords,
-          'class-name': {
-            pattern: RegExp(typeExpression),
-            greedy: true,
-            inside: typeInside
-          },
-          punctuation: /[,()]/
-        }
-      },
-      preprocessor: {
-        pattern: /(^[\t ]*)#.*/m,
-        lookbehind: true,
-        alias: 'property',
-        inside: {
-          // highlight preprocessor directives as keywords
-          directive: {
-            pattern:
-              /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
-            lookbehind: true,
-            alias: 'keyword'
-          }
-        }
-      }
-    }); // attributes
-    var regularStringOrCharacter = regularString + '|' + character;
-    var regularStringCharacterOrComment = replace(
-      /\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source,
-      [regularStringOrCharacter]
-    );
-    var roundExpression = nested(
-      replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
-        regularStringCharacterOrComment
-      ]),
-      2
-    ); // https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/attributes/#attribute-targets
-    var attrTarget =
-      /\b(?:assembly|event|field|method|module|param|property|return|type)\b/
-        .source;
-    var attr = replace(/<<0>>(?:\s*\(<<1>>*\))?/.source, [
-      identifier,
-      roundExpression
-    ]);
-    Prism.languages.insertBefore('csharp', 'class-name', {
-      attribute: {
-        // Attributes
-        // [Foo], [Foo(1), Bar(2, Prop = "foo")], [return: Foo(1), Bar(2)], [assembly: Foo(Bar)]
-        pattern: re(
-          /((?:^|[^\s\w>)?])\s*\[\s*)(?:<<0>>\s*:\s*)?<<1>>(?:\s*,\s*<<1>>)*(?=\s*\])/
-            .source,
-          [attrTarget, attr]
-        ),
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          target: {
-            pattern: re(/^<<0>>(?=\s*:)/.source, [attrTarget]),
-            alias: 'keyword'
-          },
-          'attribute-arguments': {
-            pattern: re(/\(<<0>>*\)/.source, [roundExpression]),
-            inside: Prism.languages.csharp
-          },
-          'class-name': {
-            pattern: RegExp(identifier),
-            inside: {
-              punctuation: /\./
-            }
-          },
-          punctuation: /[:,]/
-        }
-      }
-    }); // string interpolation
-    var formatString = /:[^}\r\n]+/.source; // multi line
-    var mInterpolationRound = nested(
-      replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
-        regularStringCharacterOrComment
-      ]),
-      2
-    );
-    var mInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
-      mInterpolationRound,
-      formatString
-    ]); // single line
-    var sInterpolationRound = nested(
-      replace(
-        /[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/
-          .source,
-        [regularStringOrCharacter]
-      ),
-      2
-    );
-    var sInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
-      sInterpolationRound,
-      formatString
-    ]);
-    function createInterpolationInside(interpolation, interpolationRound) {
-      return {
-        interpolation: {
-          pattern: re(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [interpolation]),
-          lookbehind: true,
-          inside: {
-            'format-string': {
-              pattern: re(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source, [
-                interpolationRound,
-                formatString
-              ]),
-              lookbehind: true,
-              inside: {
-                punctuation: /^:/
-              }
-            },
-            punctuation: /^\{|\}$/,
-            expression: {
-              pattern: /[\s\S]+/,
-              alias: 'language-csharp',
-              inside: Prism.languages.csharp
-            }
-          }
-        },
-        string: /[\s\S]+/
-      }
-    }
-    Prism.languages.insertBefore('csharp', 'string', {
-      'interpolation-string': [
-        {
-          pattern: re(
-            /(^|[^\\])(?:\$@|@\$)"(?:""|\\[\s\S]|\{\{|<<0>>|[^\\{"])*"/.source,
-            [mInterpolation]
-          ),
-          lookbehind: true,
-          greedy: true,
-          inside: createInterpolationInside(mInterpolation, mInterpolationRound)
-        },
-        {
-          pattern: re(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source, [
-            sInterpolation
-          ]),
-          lookbehind: true,
-          greedy: true,
-          inside: createInterpolationInside(sInterpolation, sInterpolationRound)
-        }
-      ],
-      char: {
-        pattern: RegExp(character),
-        greedy: true
-      }
-    });
-    Prism.languages.dotnet = Prism.languages.cs = Prism.languages.csharp;
-  })(Prism);
+	    /**
+	     * Replaces all placeholders "<<n>>" of given pattern with the n-th replacement (zero based).
+	     *
+	     * Note: This is a simple text based replacement. Be careful when using backreferences!
+	     *
+	     * @param {string} pattern the given pattern.
+	     * @param {string[]} replacements a list of replacement which can be inserted into the given pattern.
+	     * @returns {string} the pattern with all placeholders replaced with their corresponding replacements.
+	     * @example replace(/a<<0>>a/.source, [/b+/.source]) === /a(?:b+)a/.source
+	     */
+	    function replace(pattern, replacements) {
+	      return pattern.replace(/<<(\d+)>>/g, function (m, index) {
+	        return '(?:' + replacements[+index] + ')'
+	      })
+	    }
+	    /**
+	     * @param {string} pattern
+	     * @param {string[]} replacements
+	     * @param {string} [flags]
+	     * @returns {RegExp}
+	     */
+	    function re(pattern, replacements, flags) {
+	      return RegExp(replace(pattern, replacements), flags || '')
+	    }
+	    /**
+	     * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
+	     *
+	     * @param {string} pattern
+	     * @param {number} depthLog2
+	     * @returns {string}
+	     */
+	    function nested(pattern, depthLog2) {
+	      for (var i = 0; i < depthLog2; i++) {
+	        pattern = pattern.replace(/<<self>>/g, function () {
+	          return '(?:' + pattern + ')'
+	        });
+	      }
+	      return pattern.replace(/<<self>>/g, '[^\\s\\S]')
+	    } // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/
+	    var keywordKinds = {
+	      // keywords which represent a return or variable type
+	      type: 'bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void',
+	      // keywords which are used to declare a type
+	      typeDeclaration: 'class enum interface record struct',
+	      // contextual keywords
+	      // ("var" and "dynamic" are missing because they are used like types)
+	      contextual:
+	        'add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)',
+	      // all other keywords
+	      other:
+	        'abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield'
+	    }; // keywords
+	    function keywordsToPattern(words) {
+	      return '\\b(?:' + words.trim().replace(/ /g, '|') + ')\\b'
+	    }
+	    var typeDeclarationKeywords = keywordsToPattern(
+	      keywordKinds.typeDeclaration
+	    );
+	    var keywords = RegExp(
+	      keywordsToPattern(
+	        keywordKinds.type +
+	          ' ' +
+	          keywordKinds.typeDeclaration +
+	          ' ' +
+	          keywordKinds.contextual +
+	          ' ' +
+	          keywordKinds.other
+	      )
+	    );
+	    var nonTypeKeywords = keywordsToPattern(
+	      keywordKinds.typeDeclaration +
+	        ' ' +
+	        keywordKinds.contextual +
+	        ' ' +
+	        keywordKinds.other
+	    );
+	    var nonContextualKeywords = keywordsToPattern(
+	      keywordKinds.type +
+	        ' ' +
+	        keywordKinds.typeDeclaration +
+	        ' ' +
+	        keywordKinds.other
+	    ); // types
+	    var generic = nested(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2); // the idea behind the other forbidden characters is to prevent false positives. Same for tupleElement.
+	    var nestedRound = nested(/\((?:[^()]|<<self>>)*\)/.source, 2);
+	    var name = /@?\b[A-Za-z_]\w*\b/.source;
+	    var genericName = replace(/<<0>>(?:\s*<<1>>)?/.source, [name, generic]);
+	    var identifier = replace(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source, [
+	      nonTypeKeywords,
+	      genericName
+	    ]);
+	    var array = /\[\s*(?:,\s*)*\]/.source;
+	    var typeExpressionWithoutTuple = replace(
+	      /<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source,
+	      [identifier, array]
+	    );
+	    var tupleElement = replace(
+	      /[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source,
+	      [generic, nestedRound, array]
+	    );
+	    var tuple = replace(/\(<<0>>+(?:,<<0>>+)+\)/.source, [tupleElement]);
+	    var typeExpression = replace(
+	      /(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source,
+	      [tuple, identifier, array]
+	    );
+	    var typeInside = {
+	      keyword: keywords,
+	      punctuation: /[<>()?,.:[\]]/
+	    }; // strings & characters
+	    // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#character-literals
+	    // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#string-literals
+	    var character = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source; // simplified pattern
+	    var regularString = /"(?:\\.|[^\\"\r\n])*"/.source;
+	    var verbatimString = /@"(?:""|\\[\s\S]|[^\\"])*"(?!")/.source;
+	    Prism.languages.csharp = Prism.languages.extend('clike', {
+	      string: [
+	        {
+	          pattern: re(/(^|[^$\\])<<0>>/.source, [verbatimString]),
+	          lookbehind: true,
+	          greedy: true
+	        },
+	        {
+	          pattern: re(/(^|[^@$\\])<<0>>/.source, [regularString]),
+	          lookbehind: true,
+	          greedy: true
+	        }
+	      ],
+	      'class-name': [
+	        {
+	          // Using static
+	          // using static System.Math;
+	          pattern: re(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source, [
+	            identifier
+	          ]),
+	          lookbehind: true,
+	          inside: typeInside
+	        },
+	        {
+	          // Using alias (type)
+	          // using Project = PC.MyCompany.Project;
+	          pattern: re(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source, [
+	            name,
+	            typeExpression
+	          ]),
+	          lookbehind: true,
+	          inside: typeInside
+	        },
+	        {
+	          // Using alias (alias)
+	          // using Project = PC.MyCompany.Project;
+	          pattern: re(/(\busing\s+)<<0>>(?=\s*=)/.source, [name]),
+	          lookbehind: true
+	        },
+	        {
+	          // Type declarations
+	          // class Foo<A, B>
+	          // interface Foo<out A, B>
+	          pattern: re(/(\b<<0>>\s+)<<1>>/.source, [
+	            typeDeclarationKeywords,
+	            genericName
+	          ]),
+	          lookbehind: true,
+	          inside: typeInside
+	        },
+	        {
+	          // Single catch exception declaration
+	          // catch(Foo)
+	          // (things like catch(Foo e) is covered by variable declaration)
+	          pattern: re(/(\bcatch\s*\(\s*)<<0>>/.source, [identifier]),
+	          lookbehind: true,
+	          inside: typeInside
+	        },
+	        {
+	          // Name of the type parameter of generic constraints
+	          // where Foo : class
+	          pattern: re(/(\bwhere\s+)<<0>>/.source, [name]),
+	          lookbehind: true
+	        },
+	        {
+	          // Casts and checks via as and is.
+	          // as Foo<A>, is Bar<B>
+	          // (things like if(a is Foo b) is covered by variable declaration)
+	          pattern: re(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source, [
+	            typeExpressionWithoutTuple
+	          ]),
+	          lookbehind: true,
+	          inside: typeInside
+	        },
+	        {
+	          // Variable, field and parameter declaration
+	          // (Foo bar, Bar baz, Foo[,,] bay, Foo<Bar, FooBar<Bar>> bax)
+	          pattern: re(
+	            /\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/
+	              .source,
+	            [typeExpression, nonContextualKeywords, name]
+	          ),
+	          inside: typeInside
+	        }
+	      ],
+	      keyword: keywords,
+	      // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#literals
+	      number:
+	        /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
+	      operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
+	      punctuation: /\?\.?|::|[{}[\];(),.:]/
+	    });
+	    Prism.languages.insertBefore('csharp', 'number', {
+	      range: {
+	        pattern: /\.\./,
+	        alias: 'operator'
+	      }
+	    });
+	    Prism.languages.insertBefore('csharp', 'punctuation', {
+	      'named-parameter': {
+	        pattern: re(/([(,]\s*)<<0>>(?=\s*:)/.source, [name]),
+	        lookbehind: true,
+	        alias: 'punctuation'
+	      }
+	    });
+	    Prism.languages.insertBefore('csharp', 'class-name', {
+	      namespace: {
+	        // namespace Foo.Bar {}
+	        // using Foo.Bar;
+	        pattern: re(
+	          /(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source,
+	          [name]
+	        ),
+	        lookbehind: true,
+	        inside: {
+	          punctuation: /\./
+	        }
+	      },
+	      'type-expression': {
+	        // default(Foo), typeof(Foo<Bar>), sizeof(int)
+	        pattern: re(
+	          /(\b(?:default|sizeof|typeof)\s*\(\s*(?!\s))(?:[^()\s]|\s(?!\s)|<<0>>)*(?=\s*\))/
+	            .source,
+	          [nestedRound]
+	        ),
+	        lookbehind: true,
+	        alias: 'class-name',
+	        inside: typeInside
+	      },
+	      'return-type': {
+	        // Foo<Bar> ForBar(); Foo IFoo.Bar() => 0
+	        // int this[int index] => 0; T IReadOnlyList<T>.this[int index] => this[index];
+	        // int Foo => 0; int Foo { get; set } = 0;
+	        pattern: re(
+	          /<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source,
+	          [typeExpression, identifier]
+	        ),
+	        inside: typeInside,
+	        alias: 'class-name'
+	      },
+	      'constructor-invocation': {
+	        // new List<Foo<Bar[]>> { }
+	        pattern: re(/(\bnew\s+)<<0>>(?=\s*[[({])/.source, [typeExpression]),
+	        lookbehind: true,
+	        inside: typeInside,
+	        alias: 'class-name'
+	      },
+	      /*'explicit-implementation': {
+	// int IFoo<Foo>.Bar => 0; void IFoo<Foo<Foo>>.Foo<T>();
+	pattern: replace(/\b<<0>>(?=\.<<1>>)/, className, methodOrPropertyDeclaration),
+	inside: classNameInside,
+	alias: 'class-name'
+	},*/
+	      'generic-method': {
+	        // foo<Bar>()
+	        pattern: re(/<<0>>\s*<<1>>(?=\s*\()/.source, [name, generic]),
+	        inside: {
+	          function: re(/^<<0>>/.source, [name]),
+	          generic: {
+	            pattern: RegExp(generic),
+	            alias: 'class-name',
+	            inside: typeInside
+	          }
+	        }
+	      },
+	      'type-list': {
+	        // The list of types inherited or of generic constraints
+	        // class Foo<F> : Bar, IList<FooBar>
+	        // where F : Bar, IList<int>
+	        pattern: re(
+	          /\b((?:<<0>>\s+<<1>>|record\s+<<1>>\s*<<5>>|where\s+<<2>>)\s*:\s*)(?:<<3>>|<<4>>|<<1>>\s*<<5>>|<<6>>)(?:\s*,\s*(?:<<3>>|<<4>>|<<6>>))*(?=\s*(?:where|[{;]|=>|$))/
+	            .source,
+	          [
+	            typeDeclarationKeywords,
+	            genericName,
+	            name,
+	            typeExpression,
+	            keywords.source,
+	            nestedRound,
+	            /\bnew\s*\(\s*\)/.source
+	          ]
+	        ),
+	        lookbehind: true,
+	        inside: {
+	          'record-arguments': {
+	            pattern: re(/(^(?!new\s*\()<<0>>\s*)<<1>>/.source, [
+	              genericName,
+	              nestedRound
+	            ]),
+	            lookbehind: true,
+	            greedy: true,
+	            inside: Prism.languages.csharp
+	          },
+	          keyword: keywords,
+	          'class-name': {
+	            pattern: RegExp(typeExpression),
+	            greedy: true,
+	            inside: typeInside
+	          },
+	          punctuation: /[,()]/
+	        }
+	      },
+	      preprocessor: {
+	        pattern: /(^[\t ]*)#.*/m,
+	        lookbehind: true,
+	        alias: 'property',
+	        inside: {
+	          // highlight preprocessor directives as keywords
+	          directive: {
+	            pattern:
+	              /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
+	            lookbehind: true,
+	            alias: 'keyword'
+	          }
+	        }
+	      }
+	    }); // attributes
+	    var regularStringOrCharacter = regularString + '|' + character;
+	    var regularStringCharacterOrComment = replace(
+	      /\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source,
+	      [regularStringOrCharacter]
+	    );
+	    var roundExpression = nested(
+	      replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
+	        regularStringCharacterOrComment
+	      ]),
+	      2
+	    ); // https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/attributes/#attribute-targets
+	    var attrTarget =
+	      /\b(?:assembly|event|field|method|module|param|property|return|type)\b/
+	        .source;
+	    var attr = replace(/<<0>>(?:\s*\(<<1>>*\))?/.source, [
+	      identifier,
+	      roundExpression
+	    ]);
+	    Prism.languages.insertBefore('csharp', 'class-name', {
+	      attribute: {
+	        // Attributes
+	        // [Foo], [Foo(1), Bar(2, Prop = "foo")], [return: Foo(1), Bar(2)], [assembly: Foo(Bar)]
+	        pattern: re(
+	          /((?:^|[^\s\w>)?])\s*\[\s*)(?:<<0>>\s*:\s*)?<<1>>(?:\s*,\s*<<1>>)*(?=\s*\])/
+	            .source,
+	          [attrTarget, attr]
+	        ),
+	        lookbehind: true,
+	        greedy: true,
+	        inside: {
+	          target: {
+	            pattern: re(/^<<0>>(?=\s*:)/.source, [attrTarget]),
+	            alias: 'keyword'
+	          },
+	          'attribute-arguments': {
+	            pattern: re(/\(<<0>>*\)/.source, [roundExpression]),
+	            inside: Prism.languages.csharp
+	          },
+	          'class-name': {
+	            pattern: RegExp(identifier),
+	            inside: {
+	              punctuation: /\./
+	            }
+	          },
+	          punctuation: /[:,]/
+	        }
+	      }
+	    }); // string interpolation
+	    var formatString = /:[^}\r\n]+/.source; // multi line
+	    var mInterpolationRound = nested(
+	      replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
+	        regularStringCharacterOrComment
+	      ]),
+	      2
+	    );
+	    var mInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
+	      mInterpolationRound,
+	      formatString
+	    ]); // single line
+	    var sInterpolationRound = nested(
+	      replace(
+	        /[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/
+	          .source,
+	        [regularStringOrCharacter]
+	      ),
+	      2
+	    );
+	    var sInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
+	      sInterpolationRound,
+	      formatString
+	    ]);
+	    function createInterpolationInside(interpolation, interpolationRound) {
+	      return {
+	        interpolation: {
+	          pattern: re(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [interpolation]),
+	          lookbehind: true,
+	          inside: {
+	            'format-string': {
+	              pattern: re(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source, [
+	                interpolationRound,
+	                formatString
+	              ]),
+	              lookbehind: true,
+	              inside: {
+	                punctuation: /^:/
+	              }
+	            },
+	            punctuation: /^\{|\}$/,
+	            expression: {
+	              pattern: /[\s\S]+/,
+	              alias: 'language-csharp',
+	              inside: Prism.languages.csharp
+	            }
+	          }
+	        },
+	        string: /[\s\S]+/
+	      }
+	    }
+	    Prism.languages.insertBefore('csharp', 'string', {
+	      'interpolation-string': [
+	        {
+	          pattern: re(
+	            /(^|[^\\])(?:\$@|@\$)"(?:""|\\[\s\S]|\{\{|<<0>>|[^\\{"])*"/.source,
+	            [mInterpolation]
+	          ),
+	          lookbehind: true,
+	          greedy: true,
+	          inside: createInterpolationInside(mInterpolation, mInterpolationRound)
+	        },
+	        {
+	          pattern: re(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source, [
+	            sInterpolation
+	          ]),
+	          lookbehind: true,
+	          greedy: true,
+	          inside: createInterpolationInside(sInterpolation, sInterpolationRound)
+	        }
+	      ],
+	      char: {
+	        pattern: RegExp(character),
+	        greedy: true
+	      }
+	    });
+	    Prism.languages.dotnet = Prism.languages.cs = Prism.languages.csharp;
+	  })(Prism);
+	}
+	return csharp_1;
 }
 
-var refractorCsharp$1 = csharp_1;
+var refractorCsharp = requireCsharp();
 var aspnet_1 = aspnet;
 aspnet.displayName = 'aspnet';
 aspnet.aliases = [];
 function aspnet(Prism) {
-  Prism.register(refractorCsharp$1);
+  Prism.register(refractorCsharp);
   Prism.languages.aspnet = Prism.languages.extend('markup', {
     'page-directive': {
       pattern: /<%\s*@.*%>/,
@@ -7005,56 +7014,65 @@ function avisynth(Prism) {
   })(Prism);
 }
 
-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;
+
+function requireAvroIdl () {
+	if (hasRequiredAvroIdl) return avroIdl_1;
+	hasRequiredAvroIdl = 1;
+
+	avroIdl_1 = avroIdl;
+	avroIdl.displayName = 'avroIdl';
+	avroIdl.aliases = [];
+	function avroIdl(Prism) {
+	  // GitHub: https://github.com/apache/avro
+	  // Docs: https://avro.apache.org/docs/current/idl.html
+	  Prism.languages['avro-idl'] = {
+	    comment: {
+	      pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+	      greedy: true
+	    },
+	    string: {
+	      pattern: /(^|[^\\])"(?:[^\r\n"\\]|\\.)*"/,
+	      lookbehind: true,
+	      greedy: true
+	    },
+	    annotation: {
+	      pattern: /@(?:[$\w.-]|`[^\r\n`]+`)+/,
+	      greedy: true,
+	      alias: 'function'
+	    },
+	    'function-identifier': {
+	      pattern: /`[^\r\n`]+`(?=\s*\()/,
+	      greedy: true,
+	      alias: 'function'
+	    },
+	    identifier: {
+	      pattern: /`[^\r\n`]+`/,
+	      greedy: true
+	    },
+	    'class-name': {
+	      pattern: /(\b(?:enum|error|protocol|record|throws)\b\s+)[$\w]+/,
+	      lookbehind: true,
+	      greedy: true
+	    },
+	    keyword:
+	      /\b(?:array|boolean|bytes|date|decimal|double|enum|error|false|fixed|float|idl|import|int|local_timestamp_ms|long|map|null|oneway|protocol|record|schema|string|throws|time_ms|timestamp_ms|true|union|uuid|void)\b/,
+	    function: /\b[a-z_]\w*(?=\s*\()/i,
+	    number: [
+	      {
+	        pattern:
+	          /(^|[^\w.])-?(?:(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|0x(?:[a-f0-9]+(?:\.[a-f0-9]*)?|\.[a-f0-9]+)(?:p[+-]?\d+)?)[dfl]?(?![\w.])/i,
+	        lookbehind: true
+	      },
+	      /-?\b(?:Infinity|NaN)\b/
+	    ],
+	    operator: /=/,
+	    punctuation: /[()\[\]{}<>.:,;-]/
+	  };
+	  Prism.languages.avdl = Prism.languages['avro-idl'];
+	}
+	return avroIdl_1;
 }
 
 var bash_1 = bash;
@@ -7636,30 +7654,39 @@ function bnf(Prism) {
   Prism.languages.rbnf = Prism.languages.bnf;
 }
 
-var 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+/
-  };
+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 brightscript_1 = brightscript;
@@ -8054,951 +8081,1012 @@ function cmake(Prism) {
   };
 }
 
-var cobol_1 = cobol;
-cobol.displayName = 'cobol';
-cobol.aliases = [];
-function cobol(Prism) {
-  Prism.languages.cobol = {
-    comment: {
-      pattern: /\*>.*|(^[ \t]*)\*.*/m,
-      lookbehind: true,
-      greedy: true
-    },
-    string: {
-      pattern: /[xzgn]?(?:"(?:[^\r\n"]|"")*"(?!")|'(?:[^\r\n']|'')*'(?!'))/i,
-      greedy: true
-    },
-    level: {
-      pattern: /(^[ \t]*)\d+\b/m,
-      lookbehind: true,
-      greedy: true,
-      alias: 'number'
-    },
-    'class-name': {
-      // https://github.com/antlr/grammars-v4/blob/42edd5b687d183b5fa679e858a82297bd27141e7/cobol85/Cobol85.g4#L1015
-      pattern:
-        /(\bpic(?:ture)?\s+)(?:(?:[-\w$/,:*+<>]|\.(?!\s|$))(?:\(\d+\))?)+/i,
-      lookbehind: true,
-      inside: {
-        number: {
-          pattern: /(\()\d+/,
-          lookbehind: true
-        },
-        punctuation: /[()]/
-      }
-    },
-    keyword: {
-      pattern:
-        /(^|[^\w-])(?:ABORT|ACCEPT|ACCESS|ADD|ADDRESS|ADVANCING|AFTER|ALIGNED|ALL|ALPHABET|ALPHABETIC|ALPHABETIC-LOWER|ALPHABETIC-UPPER|ALPHANUMERIC|ALPHANUMERIC-EDITED|ALSO|ALTER|ALTERNATE|ANY|ARE|AREA|AREAS|AS|ASCENDING|ASCII|ASSIGN|ASSOCIATED-DATA|ASSOCIATED-DATA-LENGTH|AT|ATTRIBUTE|AUTHOR|AUTO|AUTO-SKIP|BACKGROUND-COLOR|BACKGROUND-COLOUR|BASIS|BEEP|BEFORE|BEGINNING|BELL|BINARY|BIT|BLANK|BLINK|BLOCK|BOTTOM|BOUNDS|BY|BYFUNCTION|BYTITLE|CALL|CANCEL|CAPABLE|CCSVERSION|CD|CF|CH|CHAINING|CHANGED|CHANNEL|CHARACTER|CHARACTERS|CLASS|CLASS-ID|CLOCK-UNITS|CLOSE|CLOSE-DISPOSITION|COBOL|CODE|CODE-SET|COL|COLLATING|COLUMN|COM-REG|COMMA|COMMITMENT|COMMON|COMMUNICATION|COMP|COMP-1|COMP-2|COMP-3|COMP-4|COMP-5|COMPUTATIONAL|COMPUTATIONAL-1|COMPUTATIONAL-2|COMPUTATIONAL-3|COMPUTATIONAL-4|COMPUTATIONAL-5|COMPUTE|CONFIGURATION|CONTAINS|CONTENT|CONTINUE|CONTROL|CONTROL-POINT|CONTROLS|CONVENTION|CONVERTING|COPY|CORR|CORRESPONDING|COUNT|CRUNCH|CURRENCY|CURSOR|DATA|DATA-BASE|DATE|DATE-COMPILED|DATE-WRITTEN|DAY|DAY-OF-WEEK|DBCS|DE|DEBUG-CONTENTS|DEBUG-ITEM|DEBUG-LINE|DEBUG-NAME|DEBUG-SUB-1|DEBUG-SUB-2|DEBUG-SUB-3|DEBUGGING|DECIMAL-POINT|DECLARATIVES|DEFAULT|DEFAULT-DISPLAY|DEFINITION|DELETE|DELIMITED|DELIMITER|DEPENDING|DESCENDING|DESTINATION|DETAIL|DFHRESP|DFHVALUE|DISABLE|DISK|DISPLAY|DISPLAY-1|DIVIDE|DIVISION|DONTCARE|DOUBLE|DOWN|DUPLICATES|DYNAMIC|EBCDIC|EGCS|EGI|ELSE|EMI|EMPTY-CHECK|ENABLE|END|END-ACCEPT|END-ADD|END-CALL|END-COMPUTE|END-DELETE|END-DIVIDE|END-EVALUATE|END-IF|END-MULTIPLY|END-OF-PAGE|END-PERFORM|END-READ|END-RECEIVE|END-RETURN|END-REWRITE|END-SEARCH|END-START|END-STRING|END-SUBTRACT|END-UNSTRING|END-WRITE|ENDING|ENTER|ENTRY|ENTRY-PROCEDURE|ENVIRONMENT|EOL|EOP|EOS|ERASE|ERROR|ESCAPE|ESI|EVALUATE|EVENT|EVERY|EXCEPTION|EXCLUSIVE|EXHIBIT|EXIT|EXPORT|EXTEND|EXTENDED|EXTERNAL|FD|FILE|FILE-CONTROL|FILLER|FINAL|FIRST|FOOTING|FOR|FOREGROUND-COLOR|FOREGROUND-COLOUR|FROM|FULL|FUNCTION|FUNCTION-POINTER|FUNCTIONNAME|GENERATE|GIVING|GLOBAL|GO|GOBACK|GRID|GROUP|HEADING|HIGH-VALUE|HIGH-VALUES|HIGHLIGHT|I-O|I-O-CONTROL|ID|IDENTIFICATION|IF|IMPLICIT|IMPORT|IN|INDEX|INDEXED|INDICATE|INITIAL|INITIALIZE|INITIATE|INPUT|INPUT-OUTPUT|INSPECT|INSTALLATION|INTEGER|INTO|INVALID|INVOKE|IS|JUST|JUSTIFIED|KANJI|KEPT|KEY|KEYBOARD|LABEL|LANGUAGE|LAST|LB|LD|LEADING|LEFT|LEFTLINE|LENGTH|LENGTH-CHECK|LIBACCESS|LIBPARAMETER|LIBRARY|LIMIT|LIMITS|LINAGE|LINAGE-COUNTER|LINE|LINE-COUNTER|LINES|LINKAGE|LIST|LOCAL|LOCAL-STORAGE|LOCK|LONG-DATE|LONG-TIME|LOW-VALUE|LOW-VALUES|LOWER|LOWLIGHT|MEMORY|MERGE|MESSAGE|MMDDYYYY|MODE|MODULES|MORE-LABELS|MOVE|MULTIPLE|MULTIPLY|NAMED|NATIONAL|NATIONAL-EDITED|NATIVE|NEGATIVE|NETWORK|NEXT|NO|NO-ECHO|NULL|NULLS|NUMBER|NUMERIC|NUMERIC-DATE|NUMERIC-EDITED|NUMERIC-TIME|OBJECT-COMPUTER|OCCURS|ODT|OF|OFF|OMITTED|ON|OPEN|OPTIONAL|ORDER|ORDERLY|ORGANIZATION|OTHER|OUTPUT|OVERFLOW|OVERLINE|OWN|PACKED-DECIMAL|PADDING|PAGE|PAGE-COUNTER|PASSWORD|PERFORM|PF|PH|PIC|PICTURE|PLUS|POINTER|PORT|POSITION|POSITIVE|PRINTER|PRINTING|PRIVATE|PROCEDURE|PROCEDURE-POINTER|PROCEDURES|PROCEED|PROCESS|PROGRAM|PROGRAM-ID|PROGRAM-LIBRARY|PROMPT|PURGE|QUEUE|QUOTE|QUOTES|RANDOM|RD|READ|READER|REAL|RECEIVE|RECEIVED|RECORD|RECORDING|RECORDS|RECURSIVE|REDEFINES|REEL|REF|REFERENCE|REFERENCES|RELATIVE|RELEASE|REMAINDER|REMARKS|REMOTE|REMOVAL|REMOVE|RENAMES|REPLACE|REPLACING|REPORT|REPORTING|REPORTS|REQUIRED|RERUN|RESERVE|RESET|RETURN|RETURN-CODE|RETURNING|REVERSE-VIDEO|REVERSED|REWIND|REWRITE|RF|RH|RIGHT|ROUNDED|RUN|SAME|SAVE|SCREEN|SD|SEARCH|SECTION|SECURE|SECURITY|SEGMENT|SEGMENT-LIMIT|SELECT|SEND|SENTENCE|SEPARATE|SEQUENCE|SEQUENTIAL|SET|SHARED|SHAREDBYALL|SHAREDBYRUNUNIT|SHARING|SHIFT-IN|SHIFT-OUT|SHORT-DATE|SIGN|SIZE|SORT|SORT-CONTROL|SORT-CORE-SIZE|SORT-FILE-SIZE|SORT-MERGE|SORT-MESSAGE|SORT-MODE-SIZE|SORT-RETURN|SOURCE|SOURCE-COMPUTER|SPACE|SPACES|SPECIAL-NAMES|STANDARD|STANDARD-1|STANDARD-2|START|STATUS|STOP|STRING|SUB-QUEUE-1|SUB-QUEUE-2|SUB-QUEUE-3|SUBTRACT|SUM|SUPPRESS|SYMBOL|SYMBOLIC|SYNC|SYNCHRONIZED|TABLE|TALLY|TALLYING|TAPE|TASK|TERMINAL|TERMINATE|TEST|TEXT|THEN|THREAD|THREAD-LOCAL|THROUGH|THRU|TIME|TIMER|TIMES|TITLE|TO|TODAYS-DATE|TODAYS-NAME|TOP|TRAILING|TRUNCATED|TYPE|TYPEDEF|UNDERLINE|UNIT|UNSTRING|UNTIL|UP|UPON|USAGE|USE|USING|VALUE|VALUES|VARYING|VIRTUAL|WAIT|WHEN|WHEN-COMPILED|WITH|WORDS|WORKING-STORAGE|WRITE|YEAR|YYYYDDD|YYYYMMDD|ZERO-FILL|ZEROES|ZEROS)(?![\w-])/i,
-      lookbehind: true
-    },
-    boolean: {
-      pattern: /(^|[^\w-])(?:false|true)(?![\w-])/i,
-      lookbehind: true
-    },
-    number: {
-      pattern:
-        /(^|[^\w-])(?:[+-]?(?:(?:\d+(?:[.,]\d+)?|[.,]\d+)(?:e[+-]?\d+)?|zero))(?![\w-])/i,
-      lookbehind: true
-    },
-    operator: [
-      /<>|[<>]=?|[=+*/&]/,
-      {
-        pattern: /(^|[^\w-])(?:-|and|equal|greater|less|not|or|than)(?![\w-])/i,
-        lookbehind: true
-      }
-    ],
-    punctuation: /[.:,()]/
-  };
-}
-
-var coffeescript_1 = coffeescript;
-coffeescript.displayName = 'coffeescript';
-coffeescript.aliases = ['coffee'];
-function coffeescript(Prism) {
-(function (Prism) {
-    // Ignore comments starting with { to privilege string interpolation highlighting
-    var comment = /#(?!\{).+/;
-    var interpolation = {
-      pattern: /#\{[^}]+\}/,
-      alias: 'variable'
-    };
-    Prism.languages.coffeescript = Prism.languages.extend('javascript', {
-      comment: comment,
-      string: [
-        // Strings are multiline
-        {
-          pattern: /'(?:\\[\s\S]|[^\\'])*'/,
-          greedy: true
-        },
-        {
-          // Strings are multiline
-          pattern: /"(?:\\[\s\S]|[^\\"])*"/,
-          greedy: true,
-          inside: {
-            interpolation: interpolation
-          }
-        }
-      ],
-      keyword:
-        /\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/,
-      'class-member': {
-        pattern: /@(?!\d)\w+/,
-        alias: 'variable'
-      }
-    });
-    Prism.languages.insertBefore('coffeescript', 'comment', {
-      'multiline-comment': {
-        pattern: /###[\s\S]+?###/,
-        alias: 'comment'
-      },
-      // Block regexp can contain comments and interpolation
-      'block-regex': {
-        pattern: /\/{3}[\s\S]*?\/{3}/,
-        alias: 'regex',
-        inside: {
-          comment: comment,
-          interpolation: interpolation
-        }
-      }
-    });
-    Prism.languages.insertBefore('coffeescript', 'string', {
-      'inline-javascript': {
-        pattern: /`(?:\\[\s\S]|[^\\`])*`/,
-        inside: {
-          delimiter: {
-            pattern: /^`|`$/,
-            alias: 'punctuation'
-          },
-          script: {
-            pattern: /[\s\S]+/,
-            alias: 'language-javascript',
-            inside: Prism.languages.javascript
-          }
-        }
-      },
-      // Block strings
-      'multiline-string': [
-        {
-          pattern: /'''[\s\S]*?'''/,
-          greedy: true,
-          alias: 'string'
-        },
-        {
-          pattern: /"""[\s\S]*?"""/,
-          greedy: true,
-          alias: 'string',
-          inside: {
-            interpolation: interpolation
-          }
-        }
-      ]
-    });
-    Prism.languages.insertBefore('coffeescript', 'keyword', {
-      // Object property
-      property: /(?!\d)\w+(?=\s*:(?!:))/
-    });
-    delete Prism.languages.coffeescript['template-string'];
-    Prism.languages.coffee = Prism.languages.coffeescript;
-  })(Prism);
-}
-
-var concurnas_1 = concurnas;
-concurnas.displayName = 'concurnas';
-concurnas.aliases = ['conc'];
-function concurnas(Prism) {
-  Prism.languages.concurnas = {
+var cobol_1 = cobol;
+cobol.displayName = 'cobol';
+cobol.aliases = [];
+function cobol(Prism) {
+  Prism.languages.cobol = {
     comment: {
-      pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*)/,
+      pattern: /\*>.*|(^[ \t]*)\*.*/m,
       lookbehind: true,
       greedy: true
     },
-    langext: {
-      pattern: /\b\w+\s*\|\|[\s\S]+?\|\|/,
+    string: {
+      pattern: /[xzgn]?(?:"(?:[^\r\n"]|"")*"(?!")|'(?:[^\r\n']|'')*'(?!'))/i,
+      greedy: true
+    },
+    level: {
+      pattern: /(^[ \t]*)\d+\b/m,
+      lookbehind: true,
       greedy: true,
+      alias: 'number'
+    },
+    'class-name': {
+      // https://github.com/antlr/grammars-v4/blob/42edd5b687d183b5fa679e858a82297bd27141e7/cobol85/Cobol85.g4#L1015
+      pattern:
+        /(\bpic(?:ture)?\s+)(?:(?:[-\w$/,:*+<>]|\.(?!\s|$))(?:\(\d+\))?)+/i,
+      lookbehind: true,
       inside: {
-        'class-name': /^\w+/,
-        string: {
-          pattern: /(^\s*\|\|)[\s\S]+(?=\|\|$)/,
+        number: {
+          pattern: /(\()\d+/,
           lookbehind: true
         },
-        punctuation: /\|\|/
+        punctuation: /[()]/
       }
     },
-    function: {
-      pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/,
+    keyword: {
+      pattern:
+        /(^|[^\w-])(?:ABORT|ACCEPT|ACCESS|ADD|ADDRESS|ADVANCING|AFTER|ALIGNED|ALL|ALPHABET|ALPHABETIC|ALPHABETIC-LOWER|ALPHABETIC-UPPER|ALPHANUMERIC|ALPHANUMERIC-EDITED|ALSO|ALTER|ALTERNATE|ANY|ARE|AREA|AREAS|AS|ASCENDING|ASCII|ASSIGN|ASSOCIATED-DATA|ASSOCIATED-DATA-LENGTH|AT|ATTRIBUTE|AUTHOR|AUTO|AUTO-SKIP|BACKGROUND-COLOR|BACKGROUND-COLOUR|BASIS|BEEP|BEFORE|BEGINNING|BELL|BINARY|BIT|BLANK|BLINK|BLOCK|BOTTOM|BOUNDS|BY|BYFUNCTION|BYTITLE|CALL|CANCEL|CAPABLE|CCSVERSION|CD|CF|CH|CHAINING|CHANGED|CHANNEL|CHARACTER|CHARACTERS|CLASS|CLASS-ID|CLOCK-UNITS|CLOSE|CLOSE-DISPOSITION|COBOL|CODE|CODE-SET|COL|COLLATING|COLUMN|COM-REG|COMMA|COMMITMENT|COMMON|COMMUNICATION|COMP|COMP-1|COMP-2|COMP-3|COMP-4|COMP-5|COMPUTATIONAL|COMPUTATIONAL-1|COMPUTATIONAL-2|COMPUTATIONAL-3|COMPUTATIONAL-4|COMPUTATIONAL-5|COMPUTE|CONFIGURATION|CONTAINS|CONTENT|CONTINUE|CONTROL|CONTROL-POINT|CONTROLS|CONVENTION|CONVERTING|COPY|CORR|CORRESPONDING|COUNT|CRUNCH|CURRENCY|CURSOR|DATA|DATA-BASE|DATE|DATE-COMPILED|DATE-WRITTEN|DAY|DAY-OF-WEEK|DBCS|DE|DEBUG-CONTENTS|DEBUG-ITEM|DEBUG-LINE|DEBUG-NAME|DEBUG-SUB-1|DEBUG-SUB-2|DEBUG-SUB-3|DEBUGGING|DECIMAL-POINT|DECLARATIVES|DEFAULT|DEFAULT-DISPLAY|DEFINITION|DELETE|DELIMITED|DELIMITER|DEPENDING|DESCENDING|DESTINATION|DETAIL|DFHRESP|DFHVALUE|DISABLE|DISK|DISPLAY|DISPLAY-1|DIVIDE|DIVISION|DONTCARE|DOUBLE|DOWN|DUPLICATES|DYNAMIC|EBCDIC|EGCS|EGI|ELSE|EMI|EMPTY-CHECK|ENABLE|END|END-ACCEPT|END-ADD|END-CALL|END-COMPUTE|END-DELETE|END-DIVIDE|END-EVALUATE|END-IF|END-MULTIPLY|END-OF-PAGE|END-PERFORM|END-READ|END-RECEIVE|END-RETURN|END-REWRITE|END-SEARCH|END-START|END-STRING|END-SUBTRACT|END-UNSTRING|END-WRITE|ENDING|ENTER|ENTRY|ENTRY-PROCEDURE|ENVIRONMENT|EOL|EOP|EOS|ERASE|ERROR|ESCAPE|ESI|EVALUATE|EVENT|EVERY|EXCEPTION|EXCLUSIVE|EXHIBIT|EXIT|EXPORT|EXTEND|EXTENDED|EXTERNAL|FD|FILE|FILE-CONTROL|FILLER|FINAL|FIRST|FOOTING|FOR|FOREGROUND-COLOR|FOREGROUND-COLOUR|FROM|FULL|FUNCTION|FUNCTION-POINTER|FUNCTIONNAME|GENERATE|GIVING|GLOBAL|GO|GOBACK|GRID|GROUP|HEADING|HIGH-VALUE|HIGH-VALUES|HIGHLIGHT|I-O|I-O-CONTROL|ID|IDENTIFICATION|IF|IMPLICIT|IMPORT|IN|INDEX|INDEXED|INDICATE|INITIAL|INITIALIZE|INITIATE|INPUT|INPUT-OUTPUT|INSPECT|INSTALLATION|INTEGER|INTO|INVALID|INVOKE|IS|JUST|JUSTIFIED|KANJI|KEPT|KEY|KEYBOARD|LABEL|LANGUAGE|LAST|LB|LD|LEADING|LEFT|LEFTLINE|LENGTH|LENGTH-CHECK|LIBACCESS|LIBPARAMETER|LIBRARY|LIMIT|LIMITS|LINAGE|LINAGE-COUNTER|LINE|LINE-COUNTER|LINES|LINKAGE|LIST|LOCAL|LOCAL-STORAGE|LOCK|LONG-DATE|LONG-TIME|LOW-VALUE|LOW-VALUES|LOWER|LOWLIGHT|MEMORY|MERGE|MESSAGE|MMDDYYYY|MODE|MODULES|MORE-LABELS|MOVE|MULTIPLE|MULTIPLY|NAMED|NATIONAL|NATIONAL-EDITED|NATIVE|NEGATIVE|NETWORK|NEXT|NO|NO-ECHO|NULL|NULLS|NUMBER|NUMERIC|NUMERIC-DATE|NUMERIC-EDITED|NUMERIC-TIME|OBJECT-COMPUTER|OCCURS|ODT|OF|OFF|OMITTED|ON|OPEN|OPTIONAL|ORDER|ORDERLY|ORGANIZATION|OTHER|OUTPUT|OVERFLOW|OVERLINE|OWN|PACKED-DECIMAL|PADDING|PAGE|PAGE-COUNTER|PASSWORD|PERFORM|PF|PH|PIC|PICTURE|PLUS|POINTER|PORT|POSITION|POSITIVE|PRINTER|PRINTING|PRIVATE|PROCEDURE|PROCEDURE-POINTER|PROCEDURES|PROCEED|PROCESS|PROGRAM|PROGRAM-ID|PROGRAM-LIBRARY|PROMPT|PURGE|QUEUE|QUOTE|QUOTES|RANDOM|RD|READ|READER|REAL|RECEIVE|RECEIVED|RECORD|RECORDING|RECORDS|RECURSIVE|REDEFINES|REEL|REF|REFERENCE|REFERENCES|RELATIVE|RELEASE|REMAINDER|REMARKS|REMOTE|REMOVAL|REMOVE|RENAMES|REPLACE|REPLACING|REPORT|REPORTING|REPORTS|REQUIRED|RERUN|RESERVE|RESET|RETURN|RETURN-CODE|RETURNING|REVERSE-VIDEO|REVERSED|REWIND|REWRITE|RF|RH|RIGHT|ROUNDED|RUN|SAME|SAVE|SCREEN|SD|SEARCH|SECTION|SECURE|SECURITY|SEGMENT|SEGMENT-LIMIT|SELECT|SEND|SENTENCE|SEPARATE|SEQUENCE|SEQUENTIAL|SET|SHARED|SHAREDBYALL|SHAREDBYRUNUNIT|SHARING|SHIFT-IN|SHIFT-OUT|SHORT-DATE|SIGN|SIZE|SORT|SORT-CONTROL|SORT-CORE-SIZE|SORT-FILE-SIZE|SORT-MERGE|SORT-MESSAGE|SORT-MODE-SIZE|SORT-RETURN|SOURCE|SOURCE-COMPUTER|SPACE|SPACES|SPECIAL-NAMES|STANDARD|STANDARD-1|STANDARD-2|START|STATUS|STOP|STRING|SUB-QUEUE-1|SUB-QUEUE-2|SUB-QUEUE-3|SUBTRACT|SUM|SUPPRESS|SYMBOL|SYMBOLIC|SYNC|SYNCHRONIZED|TABLE|TALLY|TALLYING|TAPE|TASK|TERMINAL|TERMINATE|TEST|TEXT|THEN|THREAD|THREAD-LOCAL|THROUGH|THRU|TIME|TIMER|TIMES|TITLE|TO|TODAYS-DATE|TODAYS-NAME|TOP|TRAILING|TRUNCATED|TYPE|TYPEDEF|UNDERLINE|UNIT|UNSTRING|UNTIL|UP|UPON|USAGE|USE|USING|VALUE|VALUES|VARYING|VIRTUAL|WAIT|WHEN|WHEN-COMPILED|WITH|WORDS|WORKING-STORAGE|WRITE|YEAR|YYYYDDD|YYYYMMDD|ZERO-FILL|ZEROES|ZEROS)(?![\w-])/i,
       lookbehind: true
     },
-    keyword:
-      /\b(?:abstract|actor|also|annotation|assert|async|await|bool|boolean|break|byte|case|catch|changed|char|class|closed|constant|continue|def|default|del|double|elif|else|enum|every|extends|false|finally|float|for|from|global|gpudef|gpukernel|if|import|in|init|inject|int|lambda|local|long|loop|match|new|nodefault|null|of|onchange|open|out|override|package|parfor|parforsync|post|pre|private|protected|provide|provider|public|return|shared|short|single|size_t|sizeof|super|sync|this|throw|trait|trans|transient|true|try|typedef|unchecked|using|val|var|void|while|with)\b/,
-    boolean: /\b(?:false|true)\b/,
-    number:
-      /\b0b[01][01_]*L?\b|\b0x(?:[\da-f_]*\.)?[\da-f_p+-]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfls]?/i,
-    punctuation: /[{}[\];(),.:]/,
-    operator:
-      /<==|>==|=>|->|<-|<>|&==|&<>|\?:?|\.\?|\+\+|--|[-+*/=<>]=?|[!^~]|\b(?:and|as|band|bor|bxor|comp|is|isnot|mod|or)\b=?/,
-    annotation: {
-      pattern: /@(?:\w+:)?(?:\w+|\[[^\]]+\])?/,
-      alias: 'builtin'
-    }
-  };
-  Prism.languages.insertBefore('concurnas', 'langext', {
-    'regex-literal': {
-      pattern: /\br("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
-      greedy: true,
-      inside: {
-        interpolation: {
-          pattern:
-            /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
-          lookbehind: true,
-          inside: Prism.languages.concurnas
-        },
-        regex: /[\s\S]+/
-      }
+    boolean: {
+      pattern: /(^|[^\w-])(?:false|true)(?![\w-])/i,
+      lookbehind: true
     },
-    'string-literal': {
-      pattern: /(?:\B|\bs)("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
-      greedy: true,
-      inside: {
-        interpolation: {
-          pattern:
-            /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
-          lookbehind: true,
-          inside: Prism.languages.concurnas
-        },
-        string: /[\s\S]+/
+    number: {
+      pattern:
+        /(^|[^\w-])(?:[+-]?(?:(?:\d+(?:[.,]\d+)?|[.,]\d+)(?:e[+-]?\d+)?|zero))(?![\w-])/i,
+      lookbehind: true
+    },
+    operator: [
+      /<>|[<>]=?|[=+*/&]/,
+      {
+        pattern: /(^|[^\w-])(?:-|and|equal|greater|less|not|or|than)(?![\w-])/i,
+        lookbehind: true
       }
-    }
-  });
-  Prism.languages.conc = Prism.languages.concurnas;
-}
-
-var coq_1 = coq;
-coq.displayName = 'coq';
-coq.aliases = [];
-function coq(Prism) {
-(function (Prism) {
-    // https://github.com/coq/coq
-    var commentSource = /\(\*(?:[^(*]|\((?!\*)|\*(?!\))|<self>)*\*\)/.source;
-    for (var i = 0; i < 2; i++) {
-      commentSource = commentSource.replace(/<self>/g, function () {
-        return commentSource
-      });
-    }
-    commentSource = commentSource.replace(/<self>/g, '[]');
-    Prism.languages.coq = {
-      comment: RegExp(commentSource),
-      string: {
-        pattern: /"(?:[^"]|"")*"(?!")/,
-        greedy: true
-      },
-      attribute: [
-        {
-          pattern: RegExp(
-            /#\[(?:[^\[\]("]|"(?:[^"]|"")*"(?!")|\((?!\*)|<comment>)*\]/.source.replace(
-              /<comment>/g,
-              function () {
-                return commentSource
-              }
-            )
-          ),
-          greedy: true,
-          alias: 'attr-name',
-          inside: {
-            comment: RegExp(commentSource),
-            string: {
-              pattern: /"(?:[^"]|"")*"(?!")/,
-              greedy: true
-            },
-            operator: /=/,
-            punctuation: /^#\[|\]$|[,()]/
-          }
-        },
-        {
-          pattern:
-            /\b(?:Cumulative|Global|Local|Monomorphic|NonCumulative|Polymorphic|Private|Program)\b/,
-          alias: 'attr-name'
-        }
-      ],
-      keyword:
-        /\b(?:Abort|About|Add|Admit|Admitted|All|Arguments|As|Assumptions|Axiom|Axioms|Back|BackTo|Backtrace|BinOp|BinOpSpec|BinRel|Bind|Blacklist|Canonical|Case|Cd|Check|Class|Classes|Close|CoFixpoint|CoInductive|Coercion|Coercions|Collection|Combined|Compute|Conjecture|Conjectures|Constant|Constants|Constraint|Constructors|Context|Corollary|Create|CstOp|Custom|Cut|Debug|Declare|Defined|Definition|Delimit|Dependencies|Dependent|Derive|Diffs|Drop|Elimination|End|Entry|Equality|Eval|Example|Existential|Existentials|Existing|Export|Extern|Extraction|Fact|Fail|Field|File|Firstorder|Fixpoint|Flags|Focus|From|Funclass|Function|Functional|GC|Generalizable|Goal|Grab|Grammar|Graph|Guarded|Haskell|Heap|Hide|Hint|HintDb|Hints|Hypotheses|Hypothesis|IF|Identity|Immediate|Implicit|Implicits|Import|Include|Induction|Inductive|Infix|Info|Initial|InjTyp|Inline|Inspect|Instance|Instances|Intro|Intros|Inversion|Inversion_clear|JSON|Language|Left|Lemma|Let|Lia|Libraries|Library|Load|LoadPath|Locate|Ltac|Ltac2|ML|Match|Method|Minimality|Module|Modules|Morphism|Next|NoInline|Notation|Number|OCaml|Obligation|Obligations|Opaque|Open|Optimize|Parameter|Parameters|Parametric|Path|Paths|Prenex|Preterm|Primitive|Print|Profile|Projections|Proof|Prop|PropBinOp|PropOp|PropUOp|Property|Proposition|Pwd|Qed|Quit|Rec|Record|Recursive|Redirect|Reduction|Register|Relation|Remark|Remove|Require|Reserved|Reset|Resolve|Restart|Rewrite|Right|Ring|Rings|SProp|Saturate|Save|Scheme|Scope|Scopes|Search|SearchHead|SearchPattern|SearchRewrite|Section|Separate|Set|Setoid|Show|Signatures|Solve|Solver|Sort|Sortclass|Sorted|Spec|Step|Strategies|Strategy|String|Structure|SubClass|Subgraph|SuchThat|Tactic|Term|TestCompile|Theorem|Time|Timeout|To|Transparent|Type|Typeclasses|Types|Typing|UnOp|UnOpSpec|Undelimit|Undo|Unfocus|Unfocused|Unfold|Universe|Universes|Unshelve|Variable|Variables|Variant|Verbose|View|Visibility|Zify|_|apply|as|at|by|cofix|else|end|exists|exists2|fix|for|forall|fun|if|in|let|match|measure|move|removed|return|struct|then|using|wf|where|with)\b/,
-      number:
-        /\b(?:0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]+)?(?:p[+-]?\d[\d_]*)?|\d[\d_]*(?:\.[\d_]+)?(?:e[+-]?\d[\d_]*)?)\b/i,
-      punct: {
-        pattern: /@\{|\{\||\[=|:>/,
-        alias: 'punctuation'
-      },
-      operator:
-        /\/\\|\\\/|\.{2,3}|:{1,2}=|\*\*|[-=]>|<(?:->?|[+:=>]|<:)|>(?:=|->)|\|[-|]?|[-!%&*+/<=>?@^~']/,
-      punctuation: /\.\(|`\(|@\{|`\{|\{\||\[=|:>|[:.,;(){}\[\]]/
-    };
-  })(Prism);
+    ],
+    punctuation: /[.:,()]/
+  };
 }
 
-var ruby_1 = ruby;
-ruby.displayName = 'ruby';
-ruby.aliases = ['rb'];
-function ruby(Prism) {
+var coffeescript_1 = coffeescript;
+coffeescript.displayName = 'coffeescript';
+coffeescript.aliases = ['coffee'];
+function coffeescript(Prism) {
 (function (Prism) {
-    Prism.languages.ruby = Prism.languages.extend('clike', {
-      comment: {
-        pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
-        greedy: true
-      },
-      'class-name': {
-        pattern:
-          /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
-        lookbehind: true,
-        inside: {
-          punctuation: /[.\\]/
-        }
-      },
-      keyword:
-        /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
-      operator:
-        /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
-      punctuation: /[(){}[\].,;]/
-    });
-    Prism.languages.insertBefore('ruby', 'operator', {
-      'double-colon': {
-        pattern: /::/,
-        alias: 'punctuation'
-      }
-    });
+    // Ignore comments starting with { to privilege string interpolation highlighting
+    var comment = /#(?!\{).+/;
     var interpolation = {
-      pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
-      lookbehind: true,
-      inside: {
-        content: {
-          pattern: /^(#\{)[\s\S]+(?=\}$)/,
-          lookbehind: true,
-          inside: Prism.languages.ruby
-        },
-        delimiter: {
-          pattern: /^#\{|\}$/,
-          alias: 'punctuation'
-        }
-      }
+      pattern: /#\{[^}]+\}/,
+      alias: 'variable'
     };
-    delete Prism.languages.ruby.function;
-    var percentExpression =
-      '(?:' +
-      [
-        /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
-        /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
-        /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
-        /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
-        /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
-      ].join('|') +
-      ')';
-    var symbolName =
-      /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/
-        .source;
-    Prism.languages.insertBefore('ruby', 'keyword', {
-      'regex-literal': [
-        {
-          pattern: RegExp(
-            /%r/.source + percentExpression + /[egimnosux]{0,6}/.source
-          ),
-          greedy: true,
-          inside: {
-            interpolation: interpolation,
-            regex: /[\s\S]+/
-          }
-        },
-        {
-          pattern:
-            /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
-          lookbehind: true,
-          greedy: true,
-          inside: {
-            interpolation: interpolation,
-            regex: /[\s\S]+/
-          }
-        }
-      ],
-      variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
-      symbol: [
-        {
-          pattern: RegExp(/(^|[^:]):/.source + symbolName),
-          lookbehind: true,
-          greedy: true
-        },
+    Prism.languages.coffeescript = Prism.languages.extend('javascript', {
+      comment: comment,
+      string: [
+        // Strings are multiline
         {
-          pattern: RegExp(
-            /([\r\n{(,][ \t]*)/.source + symbolName + /(?=:(?!:))/.source
-          ),
-          lookbehind: true,
+          pattern: /'(?:\\[\s\S]|[^\\'])*'/,
           greedy: true
-        }
-      ],
-      'method-definition': {
-        pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
-        lookbehind: true,
-        inside: {
-          function: /\b\w+$/,
-          keyword: /^self\b/,
-          'class-name': /^\w+/,
-          punctuation: /\./
-        }
-      }
-    });
-    Prism.languages.insertBefore('ruby', 'string', {
-      'string-literal': [
-        {
-          pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression),
-          greedy: true,
-          inside: {
-            interpolation: interpolation,
-            string: /[\s\S]+/
-          }
-        },
-        {
-          pattern:
-            /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
-          greedy: true,
-          inside: {
-            interpolation: interpolation,
-            string: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
-          alias: 'heredoc-string',
-          greedy: true,
-          inside: {
-            delimiter: {
-              pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
-              inside: {
-                symbol: /\b\w+/,
-                punctuation: /^<<[-~]?/
-              }
-            },
-            interpolation: interpolation,
-            string: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
-          alias: 'heredoc-string',
-          greedy: true,
-          inside: {
-            delimiter: {
-              pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
-              inside: {
-                symbol: /\b\w+/,
-                punctuation: /^<<[-~]?'|'$/
-              }
-            },
-            string: /[\s\S]+/
-          }
-        }
-      ],
-      'command-literal': [
-        {
-          pattern: RegExp(/%x/.source + percentExpression),
-          greedy: true,
-          inside: {
-            interpolation: interpolation,
-            command: {
-              pattern: /[\s\S]+/,
-              alias: 'string'
-            }
-          }
         },
         {
-          pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
+          // Strings are multiline
+          pattern: /"(?:\\[\s\S]|[^\\"])*"/,
           greedy: true,
           inside: {
-            interpolation: interpolation,
-            command: {
-              pattern: /[\s\S]+/,
-              alias: 'string'
-            }
+            interpolation: interpolation
           }
         }
-      ]
-    });
-    delete Prism.languages.ruby.string;
-    Prism.languages.insertBefore('ruby', 'number', {
-      builtin:
-        /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
-      constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
-    });
-    Prism.languages.rb = Prism.languages.ruby;
-  })(Prism);
-}
-
-var refractorRuby = ruby_1;
-var crystal_1 = crystal;
-crystal.displayName = 'crystal';
-crystal.aliases = [];
-function crystal(Prism) {
-  Prism.register(refractorRuby)
-  ;(function (Prism) {
-    Prism.languages.crystal = Prism.languages.extend('ruby', {
-      keyword: [
-        /\b(?:__DIR__|__END_LINE__|__FILE__|__LINE__|abstract|alias|annotation|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|ifdef|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|ptr|require|rescue|return|select|self|sizeof|struct|super|then|type|typeof|undef|uninitialized|union|unless|until|when|while|with|yield)\b/,
-        {
-          pattern: /(\.\s*)(?:is_a|responds_to)\?/,
-          lookbehind: true
-        }
       ],
-      number:
-        /\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[\da-fA-F_]*[\da-fA-F]|(?:\d(?:[\d_]*\d)?)(?:\.[\d_]*\d)?(?:[eE][+-]?[\d_]*\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\b/,
-      operator: [/->/, Prism.languages.ruby.operator],
-      punctuation: /[(){}[\].,;\\]/
-    });
-    Prism.languages.insertBefore('crystal', 'string-literal', {
-      attribute: {
-        pattern: /@\[.*?\]/,
-        inside: {
-          delimiter: {
-            pattern: /^@\[|\]$/,
-            alias: 'punctuation'
-          },
-          attribute: {
-            pattern: /^(\s*)\w+/,
-            lookbehind: true,
-            alias: 'class-name'
-          },
-          args: {
-            pattern: /\S(?:[\s\S]*\S)?/,
-            inside: Prism.languages.crystal
-          }
-        }
-      },
-      expansion: {
-        pattern: /\{(?:\{.*?\}|%.*?%)\}/,
-        inside: {
-          content: {
-            pattern: /^(\{.)[\s\S]+(?=.\}$)/,
-            lookbehind: true,
-            inside: Prism.languages.crystal
-          },
-          delimiter: {
-            pattern: /^\{[\{%]|[\}%]\}$/,
-            alias: 'operator'
-          }
-        }
-      },
-      char: {
-        pattern:
-          /'(?:[^\\\r\n]{1,2}|\\(?:.|u(?:[A-Fa-f0-9]{1,4}|\{[A-Fa-f0-9]{1,6}\})))'/,
-        greedy: true
+      keyword:
+        /\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/,
+      'class-member': {
+        pattern: /@(?!\d)\w+/,
+        alias: 'variable'
       }
     });
-  })(Prism);
-}
-
-var refractorCsharp = csharp_1;
-var cshtml_1 = cshtml;
-cshtml.displayName = 'cshtml';
-cshtml.aliases = ['razor'];
-function cshtml(Prism) {
-  Prism.register(refractorCsharp)
-  // Docs:
-  // https://docs.microsoft.com/en-us/aspnet/core/razor-pages/?view=aspnetcore-5.0&tabs=visual-studio
-  // https://docs.microsoft.com/en-us/aspnet/core/mvc/views/razor?view=aspnetcore-5.0
-  ;(function (Prism) {
-    var commentLike = /\/(?![/*])|\/\/.*[\r\n]|\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\//
-      .source;
-    var stringLike =
-      /@(?!")|"(?:[^\r\n\\"]|\\.)*"|@"(?:[^\\"]|""|\\[\s\S])*"(?!")/.source +
-      '|' +
-      /'(?:(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'|(?=[^\\](?!')))/.source;
-    /**
-     * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
-     *
-     * @param {string} pattern
-     * @param {number} depthLog2
-     * @returns {string}
-     */
-    function nested(pattern, depthLog2) {
-      for (var i = 0; i < depthLog2; i++) {
-        pattern = pattern.replace(/<self>/g, function () {
-          return '(?:' + pattern + ')'
-        });
-      }
-      return pattern
-        .replace(/<self>/g, '[^\\s\\S]')
-        .replace(/<str>/g, '(?:' + stringLike + ')')
-        .replace(/<comment>/g, '(?:' + commentLike + ')')
-    }
-    var round = nested(/\((?:[^()'"@/]|<str>|<comment>|<self>)*\)/.source, 2);
-    var square = nested(/\[(?:[^\[\]'"@/]|<str>|<comment>|<self>)*\]/.source, 2);
-    var curly = nested(/\{(?:[^{}'"@/]|<str>|<comment>|<self>)*\}/.source, 2);
-    var angle = nested(/<(?:[^<>'"@/]|<str>|<comment>|<self>)*>/.source, 2); // Note about the above bracket patterns:
-    // They all ignore HTML expressions that might be in the C# code. This is a problem because HTML (like strings and
-    // comments) is parsed differently. This is a huge problem because HTML might contain brackets and quotes which
-    // messes up the bracket and string counting implemented by the above patterns.
-    //
-    // This problem is not fixable because 1) HTML expression are highly context sensitive and very difficult to detect
-    // and 2) they require one capturing group at every nested level. See the `tagRegion` pattern to admire the
-    // complexity of an HTML expression.
-    //
-    // To somewhat alleviate the problem a bit, the patterns for characters (e.g. 'a') is very permissive, it also
-    // allows invalid characters to support HTML expressions like this: <p>That's it!</p>.
-    var tagAttrs =
-      /(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?/
-        .source;
-    var tagContent = /(?!\d)[^\s>\/=$<%]+/.source + tagAttrs + /\s*\/?>/.source;
-    var tagRegion =
-      /\B@?/.source +
-      '(?:' +
-      /<([a-zA-Z][\w:]*)/.source +
-      tagAttrs +
-      /\s*>/.source +
-      '(?:' +
-      (/[^<]/.source +
-        '|' + // all tags that are not the start tag
-        // eslint-disable-next-line regexp/strict
-        /<\/?(?!\1\b)/.source +
-        tagContent +
-        '|' + // nested start tag
-        nested(
-          // eslint-disable-next-line regexp/strict
-          /<\1/.source +
-            tagAttrs +
-            /\s*>/.source +
-            '(?:' +
-            (/[^<]/.source +
-              '|' + // all tags that are not the start tag
-              // eslint-disable-next-line regexp/strict
-              /<\/?(?!\1\b)/.source +
-              tagContent +
-              '|' +
-              '<self>') +
-            ')*' + // eslint-disable-next-line regexp/strict
-            /<\/\1\s*>/.source,
-          2
-        )) +
-      ')*' + // eslint-disable-next-line regexp/strict
-      /<\/\1\s*>/.source +
-      '|' +
-      /</.source +
-      tagContent +
-      ')'; // Now for the actual language definition(s):
-    //
-    // Razor as a language has 2 parts:
-    //  1) CSHTML: A markup-like language that has been extended with inline C# code expressions and blocks.
-    //  2) C#+HTML: A variant of C# that can contain CSHTML tags as expressions.
-    //
-    // In the below code, both CSHTML and C#+HTML will be create as separate language definitions that reference each
-    // other. However, only CSHTML will be exported via `Prism.languages`.
-    Prism.languages.cshtml = Prism.languages.extend('markup', {});
-    var csharpWithHtml = Prism.languages.insertBefore(
-      'csharp',
-      'string',
-      {
-        html: {
-          pattern: RegExp(tagRegion),
-          greedy: true,
-          inside: Prism.languages.cshtml
-        }
-      },
-      {
-        csharp: Prism.languages.extend('csharp', {})
-      }
-    );
-    var cs = {
-      pattern: /\S[\s\S]*/,
-      alias: 'language-csharp',
-      inside: csharpWithHtml
-    };
-    Prism.languages.insertBefore('cshtml', 'prolog', {
-      'razor-comment': {
-        pattern: /@\*[\s\S]*?\*@/,
-        greedy: true,
+    Prism.languages.insertBefore('coffeescript', 'comment', {
+      'multiline-comment': {
+        pattern: /###[\s\S]+?###/,
         alias: 'comment'
       },
-      block: {
-        pattern: RegExp(
-          /(^|[^@])@/.source +
-            '(?:' +
-            [
-              // @{ ... }
-              curly, // @code{ ... }
-              /(?:code|functions)\s*/.source + curly, // @for (...) { ... }
-              /(?:for|foreach|lock|switch|using|while)\s*/.source +
-                round +
-                /\s*/.source +
-                curly, // @do { ... } while (...);
-              /do\s*/.source +
-                curly +
-                /\s*while\s*/.source +
-                round +
-                /(?:\s*;)?/.source, // @try { ... } catch (...) { ... } finally { ... }
-              /try\s*/.source +
-                curly +
-                /\s*catch\s*/.source +
-                round +
-                /\s*/.source +
-                curly +
-                /\s*finally\s*/.source +
-                curly, // @if (...) {...} else if (...) {...} else {...}
-              /if\s*/.source +
-                round +
-                /\s*/.source +
-                curly +
-                '(?:' +
-                /\s*else/.source +
-                '(?:' +
-                /\s+if\s*/.source +
-                round +
-                ')?' +
-                /\s*/.source +
-                curly +
-                ')*'
-            ].join('|') +
-            ')'
-        ),
-        lookbehind: true,
-        greedy: true,
+      // Block regexp can contain comments and interpolation
+      'block-regex': {
+        pattern: /\/{3}[\s\S]*?\/{3}/,
+        alias: 'regex',
         inside: {
-          keyword: /^@\w*/,
-          csharp: cs
+          comment: comment,
+          interpolation: interpolation
         }
-      },
-      directive: {
-        pattern:
-          /^([ \t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/m,
-        lookbehind: true,
-        greedy: true,
+      }
+    });
+    Prism.languages.insertBefore('coffeescript', 'string', {
+      'inline-javascript': {
+        pattern: /`(?:\\[\s\S]|[^\\`])*`/,
         inside: {
-          keyword: /^@\w+/,
-          csharp: cs
+          delimiter: {
+            pattern: /^`|`$/,
+            alias: 'punctuation'
+          },
+          script: {
+            pattern: /[\s\S]+/,
+            alias: 'language-javascript',
+            inside: Prism.languages.javascript
+          }
         }
       },
-      value: {
-        pattern: RegExp(
-          /(^|[^@])@/.source +
-            /(?:await\b\s*)?/.source +
-            '(?:' +
-            /\w+\b/.source +
-            '|' +
-            round +
-            ')' +
-            '(?:' +
-            /[?!]?\.\w+\b/.source +
-            '|' +
-            round +
-            '|' +
-            square +
-            '|' +
-            angle +
-            round +
-            ')*'
-        ),
-        lookbehind: true,
-        greedy: true,
-        alias: 'variable',
-        inside: {
-          keyword: /^@/,
-          csharp: cs
+      // Block strings
+      'multiline-string': [
+        {
+          pattern: /'''[\s\S]*?'''/,
+          greedy: true,
+          alias: 'string'
+        },
+        {
+          pattern: /"""[\s\S]*?"""/,
+          greedy: true,
+          alias: 'string',
+          inside: {
+            interpolation: interpolation
+          }
         }
-      },
-      'delegate-operator': {
-        pattern: /(^|[^@])@(?=<)/,
-        lookbehind: true,
-        alias: 'operator'
-      }
+      ]
+    });
+    Prism.languages.insertBefore('coffeescript', 'keyword', {
+      // Object property
+      property: /(?!\d)\w+(?=\s*:(?!:))/
     });
-    Prism.languages.razor = Prism.languages.cshtml;
+    delete Prism.languages.coffeescript['template-string'];
+    Prism.languages.coffee = Prism.languages.coffeescript;
   })(Prism);
 }
 
-var csp_1 = csp;
-csp.displayName = 'csp';
-csp.aliases = [];
-function csp(Prism) {
-(function (Prism) {
-    /**
-     * @param {string} source
-     * @returns {RegExp}
-     */
-    function value(source) {
-      return RegExp(
-        /([ \t])/.source + '(?:' + source + ')' + /(?=[\s;]|$)/.source,
-        'i'
-      )
-    }
-    Prism.languages.csp = {
-      directive: {
-        pattern:
-          /(^|[\s;])(?:base-uri|block-all-mixed-content|(?:child|connect|default|font|frame|img|manifest|media|object|prefetch|script|style|worker)-src|disown-opener|form-action|frame-(?:ancestors|options)|input-protection(?:-(?:clip|selectors))?|navigate-to|plugin-types|policy-uri|referrer|reflected-xss|report-(?:to|uri)|require-sri-for|sandbox|(?:script|style)-src-(?:attr|elem)|upgrade-insecure-requests)(?=[\s;]|$)/i,
-        lookbehind: true,
-        alias: 'property'
-      },
-      scheme: {
-        pattern: value(/[a-z][a-z0-9.+-]*:/.source),
-        lookbehind: true
-      },
-      none: {
-        pattern: value(/'none'/.source),
-        lookbehind: true,
-        alias: 'keyword'
-      },
-      nonce: {
-        pattern: value(/'nonce-[-+/\w=]+'/.source),
-        lookbehind: true,
-        alias: 'number'
-      },
-      hash: {
-        pattern: value(/'sha(?:256|384|512)-[-+/\w=]+'/.source),
-        lookbehind: true,
-        alias: 'number'
-      },
-      host: {
-        pattern: value(
-          /[a-z][a-z0-9.+-]*:\/\/[^\s;,']*/.source +
-            '|' +
-            /\*[^\s;,']*/.source +
-            '|' +
-            /[a-z0-9-]+(?:\.[a-z0-9-]+)+(?::[\d*]+)?(?:\/[^\s;,']*)?/.source
-        ),
-        lookbehind: true,
-        alias: 'url',
-        inside: {
-          important: /\*/
-        }
-      },
-      keyword: [
-        {
-          pattern: value(/'unsafe-[a-z-]+'/.source),
-          lookbehind: true,
-          alias: 'unsafe'
-        },
-        {
-          pattern: value(/'[a-z-]+'/.source),
-          lookbehind: true,
-          alias: 'safe'
-        }
-      ],
-      punctuation: /;/
-    };
-  })(Prism);
+var concurnas_1;
+var hasRequiredConcurnas;
+
+function requireConcurnas () {
+	if (hasRequiredConcurnas) return concurnas_1;
+	hasRequiredConcurnas = 1;
+
+	concurnas_1 = concurnas;
+	concurnas.displayName = 'concurnas';
+	concurnas.aliases = ['conc'];
+	function concurnas(Prism) {
+	  Prism.languages.concurnas = {
+	    comment: {
+	      pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*)/,
+	      lookbehind: true,
+	      greedy: true
+	    },
+	    langext: {
+	      pattern: /\b\w+\s*\|\|[\s\S]+?\|\|/,
+	      greedy: true,
+	      inside: {
+	        'class-name': /^\w+/,
+	        string: {
+	          pattern: /(^\s*\|\|)[\s\S]+(?=\|\|$)/,
+	          lookbehind: true
+	        },
+	        punctuation: /\|\|/
+	      }
+	    },
+	    function: {
+	      pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/,
+	      lookbehind: true
+	    },
+	    keyword:
+	      /\b(?:abstract|actor|also|annotation|assert|async|await|bool|boolean|break|byte|case|catch|changed|char|class|closed|constant|continue|def|default|del|double|elif|else|enum|every|extends|false|finally|float|for|from|global|gpudef|gpukernel|if|import|in|init|inject|int|lambda|local|long|loop|match|new|nodefault|null|of|onchange|open|out|override|package|parfor|parforsync|post|pre|private|protected|provide|provider|public|return|shared|short|single|size_t|sizeof|super|sync|this|throw|trait|trans|transient|true|try|typedef|unchecked|using|val|var|void|while|with)\b/,
+	    boolean: /\b(?:false|true)\b/,
+	    number:
+	      /\b0b[01][01_]*L?\b|\b0x(?:[\da-f_]*\.)?[\da-f_p+-]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfls]?/i,
+	    punctuation: /[{}[\];(),.:]/,
+	    operator:
+	      /<==|>==|=>|->|<-|<>|&==|&<>|\?:?|\.\?|\+\+|--|[-+*/=<>]=?|[!^~]|\b(?:and|as|band|bor|bxor|comp|is|isnot|mod|or)\b=?/,
+	    annotation: {
+	      pattern: /@(?:\w+:)?(?:\w+|\[[^\]]+\])?/,
+	      alias: 'builtin'
+	    }
+	  };
+	  Prism.languages.insertBefore('concurnas', 'langext', {
+	    'regex-literal': {
+	      pattern: /\br("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+	      greedy: true,
+	      inside: {
+	        interpolation: {
+	          pattern:
+	            /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+	          lookbehind: true,
+	          inside: Prism.languages.concurnas
+	        },
+	        regex: /[\s\S]+/
+	      }
+	    },
+	    'string-literal': {
+	      pattern: /(?:\B|\bs)("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+	      greedy: true,
+	      inside: {
+	        interpolation: {
+	          pattern:
+	            /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+	          lookbehind: true,
+	          inside: Prism.languages.concurnas
+	        },
+	        string: /[\s\S]+/
+	      }
+	    }
+	  });
+	  Prism.languages.conc = Prism.languages.concurnas;
+	}
+	return concurnas_1;
+}
+
+var coq_1;
+var hasRequiredCoq;
+
+function requireCoq () {
+	if (hasRequiredCoq) return coq_1;
+	hasRequiredCoq = 1;
+
+	coq_1 = coq;
+	coq.displayName = 'coq';
+	coq.aliases = [];
+	function coq(Prism) {
+(function (Prism) {
+	    // https://github.com/coq/coq
+	    var commentSource = /\(\*(?:[^(*]|\((?!\*)|\*(?!\))|<self>)*\*\)/.source;
+	    for (var i = 0; i < 2; i++) {
+	      commentSource = commentSource.replace(/<self>/g, function () {
+	        return commentSource
+	      });
+	    }
+	    commentSource = commentSource.replace(/<self>/g, '[]');
+	    Prism.languages.coq = {
+	      comment: RegExp(commentSource),
+	      string: {
+	        pattern: /"(?:[^"]|"")*"(?!")/,
+	        greedy: true
+	      },
+	      attribute: [
+	        {
+	          pattern: RegExp(
+	            /#\[(?:[^\[\]("]|"(?:[^"]|"")*"(?!")|\((?!\*)|<comment>)*\]/.source.replace(
+	              /<comment>/g,
+	              function () {
+	                return commentSource
+	              }
+	            )
+	          ),
+	          greedy: true,
+	          alias: 'attr-name',
+	          inside: {
+	            comment: RegExp(commentSource),
+	            string: {
+	              pattern: /"(?:[^"]|"")*"(?!")/,
+	              greedy: true
+	            },
+	            operator: /=/,
+	            punctuation: /^#\[|\]$|[,()]/
+	          }
+	        },
+	        {
+	          pattern:
+	            /\b(?:Cumulative|Global|Local|Monomorphic|NonCumulative|Polymorphic|Private|Program)\b/,
+	          alias: 'attr-name'
+	        }
+	      ],
+	      keyword:
+	        /\b(?:Abort|About|Add|Admit|Admitted|All|Arguments|As|Assumptions|Axiom|Axioms|Back|BackTo|Backtrace|BinOp|BinOpSpec|BinRel|Bind|Blacklist|Canonical|Case|Cd|Check|Class|Classes|Close|CoFixpoint|CoInductive|Coercion|Coercions|Collection|Combined|Compute|Conjecture|Conjectures|Constant|Constants|Constraint|Constructors|Context|Corollary|Create|CstOp|Custom|Cut|Debug|Declare|Defined|Definition|Delimit|Dependencies|Dependent|Derive|Diffs|Drop|Elimination|End|Entry|Equality|Eval|Example|Existential|Existentials|Existing|Export|Extern|Extraction|Fact|Fail|Field|File|Firstorder|Fixpoint|Flags|Focus|From|Funclass|Function|Functional|GC|Generalizable|Goal|Grab|Grammar|Graph|Guarded|Haskell|Heap|Hide|Hint|HintDb|Hints|Hypotheses|Hypothesis|IF|Identity|Immediate|Implicit|Implicits|Import|Include|Induction|Inductive|Infix|Info|Initial|InjTyp|Inline|Inspect|Instance|Instances|Intro|Intros|Inversion|Inversion_clear|JSON|Language|Left|Lemma|Let|Lia|Libraries|Library|Load|LoadPath|Locate|Ltac|Ltac2|ML|Match|Method|Minimality|Module|Modules|Morphism|Next|NoInline|Notation|Number|OCaml|Obligation|Obligations|Opaque|Open|Optimize|Parameter|Parameters|Parametric|Path|Paths|Prenex|Preterm|Primitive|Print|Profile|Projections|Proof|Prop|PropBinOp|PropOp|PropUOp|Property|Proposition|Pwd|Qed|Quit|Rec|Record|Recursive|Redirect|Reduction|Register|Relation|Remark|Remove|Require|Reserved|Reset|Resolve|Restart|Rewrite|Right|Ring|Rings|SProp|Saturate|Save|Scheme|Scope|Scopes|Search|SearchHead|SearchPattern|SearchRewrite|Section|Separate|Set|Setoid|Show|Signatures|Solve|Solver|Sort|Sortclass|Sorted|Spec|Step|Strategies|Strategy|String|Structure|SubClass|Subgraph|SuchThat|Tactic|Term|TestCompile|Theorem|Time|Timeout|To|Transparent|Type|Typeclasses|Types|Typing|UnOp|UnOpSpec|Undelimit|Undo|Unfocus|Unfocused|Unfold|Universe|Universes|Unshelve|Variable|Variables|Variant|Verbose|View|Visibility|Zify|_|apply|as|at|by|cofix|else|end|exists|exists2|fix|for|forall|fun|if|in|let|match|measure|move|removed|return|struct|then|using|wf|where|with)\b/,
+	      number:
+	        /\b(?:0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]+)?(?:p[+-]?\d[\d_]*)?|\d[\d_]*(?:\.[\d_]+)?(?:e[+-]?\d[\d_]*)?)\b/i,
+	      punct: {
+	        pattern: /@\{|\{\||\[=|:>/,
+	        alias: 'punctuation'
+	      },
+	      operator:
+	        /\/\\|\\\/|\.{2,3}|:{1,2}=|\*\*|[-=]>|<(?:->?|[+:=>]|<:)|>(?:=|->)|\|[-|]?|[-!%&*+/<=>?@^~']/,
+	      punctuation: /\.\(|`\(|@\{|`\{|\{\||\[=|:>|[:.,;(){}\[\]]/
+	    };
+	  })(Prism);
+	}
+	return coq_1;
+}
+
+var ruby_1;
+var hasRequiredRuby;
+
+function requireRuby () {
+	if (hasRequiredRuby) return ruby_1;
+	hasRequiredRuby = 1;
+
+	ruby_1 = ruby;
+	ruby.displayName = 'ruby';
+	ruby.aliases = ['rb'];
+	function ruby(Prism) {
+(function (Prism) {
+	    Prism.languages.ruby = Prism.languages.extend('clike', {
+	      comment: {
+	        pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
+	        greedy: true
+	      },
+	      'class-name': {
+	        pattern:
+	          /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
+	        lookbehind: true,
+	        inside: {
+	          punctuation: /[.\\]/
+	        }
+	      },
+	      keyword:
+	        /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
+	      operator:
+	        /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
+	      punctuation: /[(){}[\].,;]/
+	    });
+	    Prism.languages.insertBefore('ruby', 'operator', {
+	      'double-colon': {
+	        pattern: /::/,
+	        alias: 'punctuation'
+	      }
+	    });
+	    var interpolation = {
+	      pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
+	      lookbehind: true,
+	      inside: {
+	        content: {
+	          pattern: /^(#\{)[\s\S]+(?=\}$)/,
+	          lookbehind: true,
+	          inside: Prism.languages.ruby
+	        },
+	        delimiter: {
+	          pattern: /^#\{|\}$/,
+	          alias: 'punctuation'
+	        }
+	      }
+	    };
+	    delete Prism.languages.ruby.function;
+	    var percentExpression =
+	      '(?:' +
+	      [
+	        /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+	        /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
+	        /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
+	        /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
+	        /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
+	      ].join('|') +
+	      ')';
+	    var symbolName =
+	      /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/
+	        .source;
+	    Prism.languages.insertBefore('ruby', 'keyword', {
+	      'regex-literal': [
+	        {
+	          pattern: RegExp(
+	            /%r/.source + percentExpression + /[egimnosux]{0,6}/.source
+	          ),
+	          greedy: true,
+	          inside: {
+	            interpolation: interpolation,
+	            regex: /[\s\S]+/
+	          }
+	        },
+	        {
+	          pattern:
+	            /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
+	          lookbehind: true,
+	          greedy: true,
+	          inside: {
+	            interpolation: interpolation,
+	            regex: /[\s\S]+/
+	          }
+	        }
+	      ],
+	      variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
+	      symbol: [
+	        {
+	          pattern: RegExp(/(^|[^:]):/.source + symbolName),
+	          lookbehind: true,
+	          greedy: true
+	        },
+	        {
+	          pattern: RegExp(
+	            /([\r\n{(,][ \t]*)/.source + symbolName + /(?=:(?!:))/.source
+	          ),
+	          lookbehind: true,
+	          greedy: true
+	        }
+	      ],
+	      'method-definition': {
+	        pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
+	        lookbehind: true,
+	        inside: {
+	          function: /\b\w+$/,
+	          keyword: /^self\b/,
+	          'class-name': /^\w+/,
+	          punctuation: /\./
+	        }
+	      }
+	    });
+	    Prism.languages.insertBefore('ruby', 'string', {
+	      'string-literal': [
+	        {
+	          pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression),
+	          greedy: true,
+	          inside: {
+	            interpolation: interpolation,
+	            string: /[\s\S]+/
+	          }
+	        },
+	        {
+	          pattern:
+	            /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
+	          greedy: true,
+	          inside: {
+	            interpolation: interpolation,
+	            string: /[\s\S]+/
+	          }
+	        },
+	        {
+	          pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+	          alias: 'heredoc-string',
+	          greedy: true,
+	          inside: {
+	            delimiter: {
+	              pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
+	              inside: {
+	                symbol: /\b\w+/,
+	                punctuation: /^<<[-~]?/
+	              }
+	            },
+	            interpolation: interpolation,
+	            string: /[\s\S]+/
+	          }
+	        },
+	        {
+	          pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+	          alias: 'heredoc-string',
+	          greedy: true,
+	          inside: {
+	            delimiter: {
+	              pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
+	              inside: {
+	                symbol: /\b\w+/,
+	                punctuation: /^<<[-~]?'|'$/
+	              }
+	            },
+	            string: /[\s\S]+/
+	          }
+	        }
+	      ],
+	      'command-literal': [
+	        {
+	          pattern: RegExp(/%x/.source + percentExpression),
+	          greedy: true,
+	          inside: {
+	            interpolation: interpolation,
+	            command: {
+	              pattern: /[\s\S]+/,
+	              alias: 'string'
+	            }
+	          }
+	        },
+	        {
+	          pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
+	          greedy: true,
+	          inside: {
+	            interpolation: interpolation,
+	            command: {
+	              pattern: /[\s\S]+/,
+	              alias: 'string'
+	            }
+	          }
+	        }
+	      ]
+	    });
+	    delete Prism.languages.ruby.string;
+	    Prism.languages.insertBefore('ruby', 'number', {
+	      builtin:
+	        /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
+	      constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
+	    });
+	    Prism.languages.rb = Prism.languages.ruby;
+	  })(Prism);
+	}
+	return ruby_1;
+}
+
+var crystal_1;
+var hasRequiredCrystal;
+
+function requireCrystal () {
+	if (hasRequiredCrystal) return crystal_1;
+	hasRequiredCrystal = 1;
+	var refractorRuby = requireRuby();
+	crystal_1 = crystal;
+	crystal.displayName = 'crystal';
+	crystal.aliases = [];
+	function crystal(Prism) {
+	  Prism.register(refractorRuby)
+	  ;(function (Prism) {
+	    Prism.languages.crystal = Prism.languages.extend('ruby', {
+	      keyword: [
+	        /\b(?:__DIR__|__END_LINE__|__FILE__|__LINE__|abstract|alias|annotation|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|ifdef|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|ptr|require|rescue|return|select|self|sizeof|struct|super|then|type|typeof|undef|uninitialized|union|unless|until|when|while|with|yield)\b/,
+	        {
+	          pattern: /(\.\s*)(?:is_a|responds_to)\?/,
+	          lookbehind: true
+	        }
+	      ],
+	      number:
+	        /\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[\da-fA-F_]*[\da-fA-F]|(?:\d(?:[\d_]*\d)?)(?:\.[\d_]*\d)?(?:[eE][+-]?[\d_]*\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\b/,
+	      operator: [/->/, Prism.languages.ruby.operator],
+	      punctuation: /[(){}[\].,;\\]/
+	    });
+	    Prism.languages.insertBefore('crystal', 'string-literal', {
+	      attribute: {
+	        pattern: /@\[.*?\]/,
+	        inside: {
+	          delimiter: {
+	            pattern: /^@\[|\]$/,
+	            alias: 'punctuation'
+	          },
+	          attribute: {
+	            pattern: /^(\s*)\w+/,
+	            lookbehind: true,
+	            alias: 'class-name'
+	          },
+	          args: {
+	            pattern: /\S(?:[\s\S]*\S)?/,
+	            inside: Prism.languages.crystal
+	          }
+	        }
+	      },
+	      expansion: {
+	        pattern: /\{(?:\{.*?\}|%.*?%)\}/,
+	        inside: {
+	          content: {
+	            pattern: /^(\{.)[\s\S]+(?=.\}$)/,
+	            lookbehind: true,
+	            inside: Prism.languages.crystal
+	          },
+	          delimiter: {
+	            pattern: /^\{[\{%]|[\}%]\}$/,
+	            alias: 'operator'
+	          }
+	        }
+	      },
+	      char: {
+	        pattern:
+	          /'(?:[^\\\r\n]{1,2}|\\(?:.|u(?:[A-Fa-f0-9]{1,4}|\{[A-Fa-f0-9]{1,6}\})))'/,
+	        greedy: true
+	      }
+	    });
+	  })(Prism);
+	}
+	return crystal_1;
+}
+
+var cshtml_1;
+var hasRequiredCshtml;
+
+function requireCshtml () {
+	if (hasRequiredCshtml) return cshtml_1;
+	hasRequiredCshtml = 1;
+	var refractorCsharp = requireCsharp();
+	cshtml_1 = cshtml;
+	cshtml.displayName = 'cshtml';
+	cshtml.aliases = ['razor'];
+	function cshtml(Prism) {
+	  Prism.register(refractorCsharp)
+	  // Docs:
+	  // https://docs.microsoft.com/en-us/aspnet/core/razor-pages/?view=aspnetcore-5.0&tabs=visual-studio
+	  // https://docs.microsoft.com/en-us/aspnet/core/mvc/views/razor?view=aspnetcore-5.0
+	  ;(function (Prism) {
+	    var commentLike = /\/(?![/*])|\/\/.*[\r\n]|\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\//
+	      .source;
+	    var stringLike =
+	      /@(?!")|"(?:[^\r\n\\"]|\\.)*"|@"(?:[^\\"]|""|\\[\s\S])*"(?!")/.source +
+	      '|' +
+	      /'(?:(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'|(?=[^\\](?!')))/.source;
+	    /**
+	     * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
+	     *
+	     * @param {string} pattern
+	     * @param {number} depthLog2
+	     * @returns {string}
+	     */
+	    function nested(pattern, depthLog2) {
+	      for (var i = 0; i < depthLog2; i++) {
+	        pattern = pattern.replace(/<self>/g, function () {
+	          return '(?:' + pattern + ')'
+	        });
+	      }
+	      return pattern
+	        .replace(/<self>/g, '[^\\s\\S]')
+	        .replace(/<str>/g, '(?:' + stringLike + ')')
+	        .replace(/<comment>/g, '(?:' + commentLike + ')')
+	    }
+	    var round = nested(/\((?:[^()'"@/]|<str>|<comment>|<self>)*\)/.source, 2);
+	    var square = nested(/\[(?:[^\[\]'"@/]|<str>|<comment>|<self>)*\]/.source, 2);
+	    var curly = nested(/\{(?:[^{}'"@/]|<str>|<comment>|<self>)*\}/.source, 2);
+	    var angle = nested(/<(?:[^<>'"@/]|<str>|<comment>|<self>)*>/.source, 2); // Note about the above bracket patterns:
+	    // They all ignore HTML expressions that might be in the C# code. This is a problem because HTML (like strings and
+	    // comments) is parsed differently. This is a huge problem because HTML might contain brackets and quotes which
+	    // messes up the bracket and string counting implemented by the above patterns.
+	    //
+	    // This problem is not fixable because 1) HTML expression are highly context sensitive and very difficult to detect
+	    // and 2) they require one capturing group at every nested level. See the `tagRegion` pattern to admire the
+	    // complexity of an HTML expression.
+	    //
+	    // To somewhat alleviate the problem a bit, the patterns for characters (e.g. 'a') is very permissive, it also
+	    // allows invalid characters to support HTML expressions like this: <p>That's it!</p>.
+	    var tagAttrs =
+	      /(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?/
+	        .source;
+	    var tagContent = /(?!\d)[^\s>\/=$<%]+/.source + tagAttrs + /\s*\/?>/.source;
+	    var tagRegion =
+	      /\B@?/.source +
+	      '(?:' +
+	      /<([a-zA-Z][\w:]*)/.source +
+	      tagAttrs +
+	      /\s*>/.source +
+	      '(?:' +
+	      (/[^<]/.source +
+	        '|' + // all tags that are not the start tag
+	        // eslint-disable-next-line regexp/strict
+	        /<\/?(?!\1\b)/.source +
+	        tagContent +
+	        '|' + // nested start tag
+	        nested(
+	          // eslint-disable-next-line regexp/strict
+	          /<\1/.source +
+	            tagAttrs +
+	            /\s*>/.source +
+	            '(?:' +
+	            (/[^<]/.source +
+	              '|' + // all tags that are not the start tag
+	              // eslint-disable-next-line regexp/strict
+	              /<\/?(?!\1\b)/.source +
+	              tagContent +
+	              '|' +
+	              '<self>') +
+	            ')*' + // eslint-disable-next-line regexp/strict
+	            /<\/\1\s*>/.source,
+	          2
+	        )) +
+	      ')*' + // eslint-disable-next-line regexp/strict
+	      /<\/\1\s*>/.source +
+	      '|' +
+	      /</.source +
+	      tagContent +
+	      ')'; // Now for the actual language definition(s):
+	    //
+	    // Razor as a language has 2 parts:
+	    //  1) CSHTML: A markup-like language that has been extended with inline C# code expressions and blocks.
+	    //  2) C#+HTML: A variant of C# that can contain CSHTML tags as expressions.
+	    //
+	    // In the below code, both CSHTML and C#+HTML will be create as separate language definitions that reference each
+	    // other. However, only CSHTML will be exported via `Prism.languages`.
+	    Prism.languages.cshtml = Prism.languages.extend('markup', {});
+	    var csharpWithHtml = Prism.languages.insertBefore(
+	      'csharp',
+	      'string',
+	      {
+	        html: {
+	          pattern: RegExp(tagRegion),
+	          greedy: true,
+	          inside: Prism.languages.cshtml
+	        }
+	      },
+	      {
+	        csharp: Prism.languages.extend('csharp', {})
+	      }
+	    );
+	    var cs = {
+	      pattern: /\S[\s\S]*/,
+	      alias: 'language-csharp',
+	      inside: csharpWithHtml
+	    };
+	    Prism.languages.insertBefore('cshtml', 'prolog', {
+	      'razor-comment': {
+	        pattern: /@\*[\s\S]*?\*@/,
+	        greedy: true,
+	        alias: 'comment'
+	      },
+	      block: {
+	        pattern: RegExp(
+	          /(^|[^@])@/.source +
+	            '(?:' +
+	            [
+	              // @{ ... }
+	              curly, // @code{ ... }
+	              /(?:code|functions)\s*/.source + curly, // @for (...) { ... }
+	              /(?:for|foreach|lock|switch|using|while)\s*/.source +
+	                round +
+	                /\s*/.source +
+	                curly, // @do { ... } while (...);
+	              /do\s*/.source +
+	                curly +
+	                /\s*while\s*/.source +
+	                round +
+	                /(?:\s*;)?/.source, // @try { ... } catch (...) { ... } finally { ... }
+	              /try\s*/.source +
+	                curly +
+	                /\s*catch\s*/.source +
+	                round +
+	                /\s*/.source +
+	                curly +
+	                /\s*finally\s*/.source +
+	                curly, // @if (...) {...} else if (...) {...} else {...}
+	              /if\s*/.source +
+	                round +
+	                /\s*/.source +
+	                curly +
+	                '(?:' +
+	                /\s*else/.source +
+	                '(?:' +
+	                /\s+if\s*/.source +
+	                round +
+	                ')?' +
+	                /\s*/.source +
+	                curly +
+	                ')*'
+	            ].join('|') +
+	            ')'
+	        ),
+	        lookbehind: true,
+	        greedy: true,
+	        inside: {
+	          keyword: /^@\w*/,
+	          csharp: cs
+	        }
+	      },
+	      directive: {
+	        pattern:
+	          /^([ \t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/m,
+	        lookbehind: true,
+	        greedy: true,
+	        inside: {
+	          keyword: /^@\w+/,
+	          csharp: cs
+	        }
+	      },
+	      value: {
+	        pattern: RegExp(
+	          /(^|[^@])@/.source +
+	            /(?:await\b\s*)?/.source +
+	            '(?:' +
+	            /\w+\b/.source +
+	            '|' +
+	            round +
+	            ')' +
+	            '(?:' +
+	            /[?!]?\.\w+\b/.source +
+	            '|' +
+	            round +
+	            '|' +
+	            square +
+	            '|' +
+	            angle +
+	            round +
+	            ')*'
+	        ),
+	        lookbehind: true,
+	        greedy: true,
+	        alias: 'variable',
+	        inside: {
+	          keyword: /^@/,
+	          csharp: cs
+	        }
+	      },
+	      'delegate-operator': {
+	        pattern: /(^|[^@])@(?=<)/,
+	        lookbehind: true,
+	        alias: 'operator'
+	      }
+	    });
+	    Prism.languages.razor = Prism.languages.cshtml;
+	  })(Prism);
+	}
+	return cshtml_1;
 }
 
-var cssExtras_1 = cssExtras;
-cssExtras.displayName = 'cssExtras';
-cssExtras.aliases = [];
-function cssExtras(Prism) {
+var csp_1;
+var hasRequiredCsp;
+
+function requireCsp () {
+	if (hasRequiredCsp) return csp_1;
+	hasRequiredCsp = 1;
+
+	csp_1 = csp;
+	csp.displayName = 'csp';
+	csp.aliases = [];
+	function csp(Prism) {
 (function (Prism) {
-    var string = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
-    var selectorInside;
-    Prism.languages.css.selector = {
-      pattern: Prism.languages.css.selector.pattern,
-      lookbehind: true,
-      inside: (selectorInside = {
-        'pseudo-element':
-          /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
-        'pseudo-class': /:[-\w]+/,
-        class: /\.[-\w]+/,
-        id: /#[-\w]+/,
-        attribute: {
-          pattern: RegExp('\\[(?:[^[\\]"\']|' + string.source + ')*\\]'),
-          greedy: true,
-          inside: {
-            punctuation: /^\[|\]$/,
-            'case-sensitivity': {
-              pattern: /(\s)[si]$/i,
-              lookbehind: true,
-              alias: 'keyword'
-            },
-            namespace: {
-              pattern: /^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/,
-              lookbehind: true,
-              inside: {
-                punctuation: /\|$/
-              }
-            },
-            'attr-name': {
-              pattern: /^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/,
-              lookbehind: true
-            },
-            'attr-value': [
-              string,
-              {
-                pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/,
-                lookbehind: true
-              }
-            ],
-            operator: /[|~*^$]?=/
-          }
-        },
-        'n-th': [
-          {
-            pattern: /(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/,
-            lookbehind: true,
-            inside: {
-              number: /[\dn]+/,
-              operator: /[+-]/
-            }
-          },
-          {
-            pattern: /(\(\s*)(?:even|odd)(?=\s*\))/i,
-            lookbehind: true
-          }
-        ],
-        combinator: />|\+|~|\|\|/,
-        // the `tag` token has been existed and removed.
-        // because we can't find a perfect tokenize to match it.
-        // if you want to add it, please read https://github.com/PrismJS/prism/pull/2373 first.
-        punctuation: /[(),]/
-      })
-    };
-    Prism.languages.css['atrule'].inside['selector-function-argument'].inside =
-      selectorInside;
-    Prism.languages.insertBefore('css', 'property', {
-      variable: {
-        pattern:
-          /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i,
-        lookbehind: true
-      }
-    });
-    var unit = {
-      pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/,
-      lookbehind: true
-    }; // 123 -123 .123 -.123 12.3 -12.3
-    var number = {
-      pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
-      lookbehind: true
-    };
-    Prism.languages.insertBefore('css', 'function', {
-      operator: {
-        pattern: /(\s)[+\-*\/](?=\s)/,
-        lookbehind: true
-      },
-      // CAREFUL!
-      // Previewers and Inline color use hexcode and color.
-      hexcode: {
-        pattern: /\B#[\da-f]{3,8}\b/i,
-        alias: 'color'
-      },
-      color: [
-        {
-          pattern:
-            /(^|[^\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)(?![\w-])/i,
-          lookbehind: true
-        },
-        {
-          pattern:
-            /\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,
-          inside: {
-            unit: unit,
-            number: number,
-            function: /[\w-]+(?=\()/,
-            punctuation: /[(),]/
-          }
-        }
-      ],
-      // it's important that there is no boundary assertion after the hex digits
-      entity: /\\[\da-f]{1,8}/i,
-      unit: unit,
-      number: number
-    });
-  })(Prism);
+	    /**
+	     * @param {string} source
+	     * @returns {RegExp}
+	     */
+	    function value(source) {
+	      return RegExp(
+	        /([ \t])/.source + '(?:' + source + ')' + /(?=[\s;]|$)/.source,
+	        'i'
+	      )
+	    }
+	    Prism.languages.csp = {
+	      directive: {
+	        pattern:
+	          /(^|[\s;])(?:base-uri|block-all-mixed-content|(?:child|connect|default|font|frame|img|manifest|media|object|prefetch|script|style|worker)-src|disown-opener|form-action|frame-(?:ancestors|options)|input-protection(?:-(?:clip|selectors))?|navigate-to|plugin-types|policy-uri|referrer|reflected-xss|report-(?:to|uri)|require-sri-for|sandbox|(?:script|style)-src-(?:attr|elem)|upgrade-insecure-requests)(?=[\s;]|$)/i,
+	        lookbehind: true,
+	        alias: 'property'
+	      },
+	      scheme: {
+	        pattern: value(/[a-z][a-z0-9.+-]*:/.source),
+	        lookbehind: true
+	      },
+	      none: {
+	        pattern: value(/'none'/.source),
+	        lookbehind: true,
+	        alias: 'keyword'
+	      },
+	      nonce: {
+	        pattern: value(/'nonce-[-+/\w=]+'/.source),
+	        lookbehind: true,
+	        alias: 'number'
+	      },
+	      hash: {
+	        pattern: value(/'sha(?:256|384|512)-[-+/\w=]+'/.source),
+	        lookbehind: true,
+	        alias: 'number'
+	      },
+	      host: {
+	        pattern: value(
+	          /[a-z][a-z0-9.+-]*:\/\/[^\s;,']*/.source +
+	            '|' +
+	            /\*[^\s;,']*/.source +
+	            '|' +
+	            /[a-z0-9-]+(?:\.[a-z0-9-]+)+(?::[\d*]+)?(?:\/[^\s;,']*)?/.source
+	        ),
+	        lookbehind: true,
+	        alias: 'url',
+	        inside: {
+	          important: /\*/
+	        }
+	      },
+	      keyword: [
+	        {
+	          pattern: value(/'unsafe-[a-z-]+'/.source),
+	          lookbehind: true,
+	          alias: 'unsafe'
+	        },
+	        {
+	          pattern: value(/'[a-z-]+'/.source),
+	          lookbehind: true,
+	          alias: 'safe'
+	        }
+	      ],
+	      punctuation: /;/
+	    };
+	  })(Prism);
+	}
+	return csp_1;
+}
+
+var cssExtras_1;
+var hasRequiredCssExtras;
+
+function requireCssExtras () {
+	if (hasRequiredCssExtras) return cssExtras_1;
+	hasRequiredCssExtras = 1;
+
+	cssExtras_1 = cssExtras;
+	cssExtras.displayName = 'cssExtras';
+	cssExtras.aliases = [];
+	function cssExtras(Prism) {
+(function (Prism) {
+	    var string = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
+	    var selectorInside;
+	    Prism.languages.css.selector = {
+	      pattern: Prism.languages.css.selector.pattern,
+	      lookbehind: true,
+	      inside: (selectorInside = {
+	        'pseudo-element':
+	          /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
+	        'pseudo-class': /:[-\w]+/,
+	        class: /\.[-\w]+/,
+	        id: /#[-\w]+/,
+	        attribute: {
+	          pattern: RegExp('\\[(?:[^[\\]"\']|' + string.source + ')*\\]'),
+	          greedy: true,
+	          inside: {
+	            punctuation: /^\[|\]$/,
+	            'case-sensitivity': {
+	              pattern: /(\s)[si]$/i,
+	              lookbehind: true,
+	              alias: 'keyword'
+	            },
+	            namespace: {
+	              pattern: /^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/,
+	              lookbehind: true,
+	              inside: {
+	                punctuation: /\|$/
+	              }
+	            },
+	            'attr-name': {
+	              pattern: /^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/,
+	              lookbehind: true
+	            },
+	            'attr-value': [
+	              string,
+	              {
+	                pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/,
+	                lookbehind: true
+	              }
+	            ],
+	            operator: /[|~*^$]?=/
+	          }
+	        },
+	        'n-th': [
+	          {
+	            pattern: /(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/,
+	            lookbehind: true,
+	            inside: {
+	              number: /[\dn]+/,
+	              operator: /[+-]/
+	            }
+	          },
+	          {
+	            pattern: /(\(\s*)(?:even|odd)(?=\s*\))/i,
+	            lookbehind: true
+	          }
+	        ],
+	        combinator: />|\+|~|\|\|/,
+	        // the `tag` token has been existed and removed.
+	        // because we can't find a perfect tokenize to match it.
+	        // if you want to add it, please read https://github.com/PrismJS/prism/pull/2373 first.
+	        punctuation: /[(),]/
+	      })
+	    };
+	    Prism.languages.css['atrule'].inside['selector-function-argument'].inside =
+	      selectorInside;
+	    Prism.languages.insertBefore('css', 'property', {
+	      variable: {
+	        pattern:
+	          /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i,
+	        lookbehind: true
+	      }
+	    });
+	    var unit = {
+	      pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/,
+	      lookbehind: true
+	    }; // 123 -123 .123 -.123 12.3 -12.3
+	    var number = {
+	      pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
+	      lookbehind: true
+	    };
+	    Prism.languages.insertBefore('css', 'function', {
+	      operator: {
+	        pattern: /(\s)[+\-*\/](?=\s)/,
+	        lookbehind: true
+	      },
+	      // CAREFUL!
+	      // Previewers and Inline color use hexcode and color.
+	      hexcode: {
+	        pattern: /\B#[\da-f]{3,8}\b/i,
+	        alias: 'color'
+	      },
+	      color: [
+	        {
+	          pattern:
+	            /(^|[^\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)(?![\w-])/i,
+	          lookbehind: true
+	        },
+	        {
+	          pattern:
+	            /\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,
+	          inside: {
+	            unit: unit,
+	            number: number,
+	            function: /[\w-]+(?=\()/,
+	            punctuation: /[(),]/
+	          }
+	        }
+	      ],
+	      // it's important that there is no boundary assertion after the hex digits
+	      entity: /\\[\da-f]{1,8}/i,
+	      unit: unit,
+	      number: number
+	    });
+	  })(Prism);
+	}
+	return cssExtras_1;
 }
 
 var csv_1;
@@ -9021,298 +9109,343 @@ function requireCsv () {
 	return csv_1;
 }
 
-var cypher_1 = cypher;
-cypher.displayName = 'cypher';
-cypher.aliases = [];
-function cypher(Prism) {
-  Prism.languages.cypher = {
-    // https://neo4j.com/docs/cypher-manual/current/syntax/comments/
-    comment: /\/\/.*/,
-    string: {
-      pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/,
-      greedy: true
-    },
-    'class-name': {
-      pattern: /(:\s*)(?:\w+|`(?:[^`\\\r\n])*`)(?=\s*[{):])/,
-      lookbehind: true,
-      greedy: true
-    },
-    relationship: {
-      pattern:
-        /(-\[\s*(?:\w+\s*|`(?:[^`\\\r\n])*`\s*)?:\s*|\|\s*:\s*)(?:\w+|`(?:[^`\\\r\n])*`)/,
-      lookbehind: true,
-      greedy: true,
-      alias: 'property'
-    },
-    identifier: {
-      pattern: /`(?:[^`\\\r\n])*`/,
-      greedy: true
-    },
-    variable: /\$\w+/,
-    // https://neo4j.com/docs/cypher-manual/current/syntax/reserved/
-    keyword:
-      /\b(?:ADD|ALL|AND|AS|ASC|ASCENDING|ASSERT|BY|CALL|CASE|COMMIT|CONSTRAINT|CONTAINS|CREATE|CSV|DELETE|DESC|DESCENDING|DETACH|DISTINCT|DO|DROP|ELSE|END|ENDS|EXISTS|FOR|FOREACH|IN|INDEX|IS|JOIN|KEY|LIMIT|LOAD|MANDATORY|MATCH|MERGE|NODE|NOT|OF|ON|OPTIONAL|OR|ORDER(?=\s+BY)|PERIODIC|REMOVE|REQUIRE|RETURN|SCALAR|SCAN|SET|SKIP|START|STARTS|THEN|UNION|UNIQUE|UNWIND|USING|WHEN|WHERE|WITH|XOR|YIELD)\b/i,
-    function: /\b\w+\b(?=\s*\()/,
-    boolean: /\b(?:false|null|true)\b/i,
-    number: /\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
-    // https://neo4j.com/docs/cypher-manual/current/syntax/operators/
-    operator: /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/,
-    punctuation: /[()[\]{},;.]/
-  };
+var cypher_1;
+var hasRequiredCypher;
+
+function requireCypher () {
+	if (hasRequiredCypher) return cypher_1;
+	hasRequiredCypher = 1;
+
+	cypher_1 = cypher;
+	cypher.displayName = 'cypher';
+	cypher.aliases = [];
+	function cypher(Prism) {
+	  Prism.languages.cypher = {
+	    // https://neo4j.com/docs/cypher-manual/current/syntax/comments/
+	    comment: /\/\/.*/,
+	    string: {
+	      pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/,
+	      greedy: true
+	    },
+	    'class-name': {
+	      pattern: /(:\s*)(?:\w+|`(?:[^`\\\r\n])*`)(?=\s*[{):])/,
+	      lookbehind: true,
+	      greedy: true
+	    },
+	    relationship: {
+	      pattern:
+	        /(-\[\s*(?:\w+\s*|`(?:[^`\\\r\n])*`\s*)?:\s*|\|\s*:\s*)(?:\w+|`(?:[^`\\\r\n])*`)/,
+	      lookbehind: true,
+	      greedy: true,
+	      alias: 'property'
+	    },
+	    identifier: {
+	      pattern: /`(?:[^`\\\r\n])*`/,
+	      greedy: true
+	    },
+	    variable: /\$\w+/,
+	    // https://neo4j.com/docs/cypher-manual/current/syntax/reserved/
+	    keyword:
+	      /\b(?:ADD|ALL|AND|AS|ASC|ASCENDING|ASSERT|BY|CALL|CASE|COMMIT|CONSTRAINT|CONTAINS|CREATE|CSV|DELETE|DESC|DESCENDING|DETACH|DISTINCT|DO|DROP|ELSE|END|ENDS|EXISTS|FOR|FOREACH|IN|INDEX|IS|JOIN|KEY|LIMIT|LOAD|MANDATORY|MATCH|MERGE|NODE|NOT|OF|ON|OPTIONAL|OR|ORDER(?=\s+BY)|PERIODIC|REMOVE|REQUIRE|RETURN|SCALAR|SCAN|SET|SKIP|START|STARTS|THEN|UNION|UNIQUE|UNWIND|USING|WHEN|WHERE|WITH|XOR|YIELD)\b/i,
+	    function: /\b\w+\b(?=\s*\()/,
+	    boolean: /\b(?:false|null|true)\b/i,
+	    number: /\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
+	    // https://neo4j.com/docs/cypher-manual/current/syntax/operators/
+	    operator: /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/,
+	    punctuation: /[()[\]{},;.]/
+	  };
+	}
+	return cypher_1;
 }
 
-var d_1 = d;
-d.displayName = 'd';
-d.aliases = [];
-function d(Prism) {
-  Prism.languages.d = Prism.languages.extend('clike', {
-    comment: [
-      {
-        // Shebang
-        pattern: /^\s*#!.+/,
-        greedy: true
-      },
-      {
-        pattern: RegExp(
-          /(^|[^\\])/.source +
-            '(?:' +
-            [
-              // /+ comment +/
-              // Allow one level of nesting
-              /\/\+(?:\/\+(?:[^+]|\+(?!\/))*\+\/|(?!\/\+)[\s\S])*?\+\//.source, // // comment
-              /\/\/.*/.source, // /* comment */
-              /\/\*[\s\S]*?\*\//.source
-            ].join('|') +
-            ')'
-        ),
-        lookbehind: true,
-        greedy: true
-      }
-    ],
-    string: [
-      {
-        pattern: RegExp(
-          [
-            // r"", x""
-            /\b[rx]"(?:\\[\s\S]|[^\\"])*"[cwd]?/.source, // q"[]", q"()", q"<>", q"{}"
-            /\bq"(?:\[[\s\S]*?\]|\([\s\S]*?\)|<[\s\S]*?>|\{[\s\S]*?\})"/.source, // q"IDENT
-            // ...
-            // IDENT"
-            /\bq"((?!\d)\w+)$[\s\S]*?^\1"/.source, // q"//", q"||", etc.
-            // eslint-disable-next-line regexp/strict
-            /\bq"(.)[\s\S]*?\2"/.source, // eslint-disable-next-line regexp/strict
-            /(["`])(?:\\[\s\S]|(?!\3)[^\\])*\3[cwd]?/.source
-          ].join('|'),
-          'm'
-        ),
-        greedy: true
-      },
-      {
-        pattern: /\bq\{(?:\{[^{}]*\}|[^{}])*\}/,
-        greedy: true,
-        alias: 'token-string'
-      }
-    ],
-    // In order: $, keywords and special tokens, globally defined symbols
-    keyword:
-      /\$|\b(?:__(?:(?:DATE|EOF|FILE|FUNCTION|LINE|MODULE|PRETTY_FUNCTION|TIMESTAMP|TIME|VENDOR|VERSION)__|gshared|parameters|traits|vector)|abstract|alias|align|asm|assert|auto|body|bool|break|byte|case|cast|catch|cdouble|cent|cfloat|char|class|const|continue|creal|dchar|debug|default|delegate|delete|deprecated|do|double|dstring|else|enum|export|extern|false|final|finally|float|for|foreach|foreach_reverse|function|goto|idouble|if|ifloat|immutable|import|inout|int|interface|invariant|ireal|lazy|long|macro|mixin|module|new|nothrow|null|out|override|package|pragma|private|protected|ptrdiff_t|public|pure|real|ref|return|scope|shared|short|size_t|static|string|struct|super|switch|synchronized|template|this|throw|true|try|typedef|typeid|typeof|ubyte|ucent|uint|ulong|union|unittest|ushort|version|void|volatile|wchar|while|with|wstring)\b/,
-    number: [
-      // The lookbehind and the negative look-ahead try to prevent bad highlighting of the .. operator
-      // Hexadecimal numbers must be handled separately to avoid problems with exponent "e"
-      /\b0x\.?[a-f\d_]+(?:(?!\.\.)\.[a-f\d_]*)?(?:p[+-]?[a-f\d_]+)?[ulfi]{0,4}/i,
-      {
-        pattern:
-          /((?:\.\.)?)(?:\b0b\.?|\b|\.)\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:e[+-]?\d[\d_]*)?[ulfi]{0,4}/i,
-        lookbehind: true
-      }
-    ],
-    operator:
-      /\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/
-  });
-  Prism.languages.insertBefore('d', 'string', {
-    // Characters
-    // 'a', '\\', '\n', '\xFF', '\377', '\uFFFF', '\U0010FFFF', '\quot'
-    char: /'(?:\\(?:\W|\w+)|[^\\])'/
-  });
-  Prism.languages.insertBefore('d', 'keyword', {
-    property: /\B@\w*/
-  });
-  Prism.languages.insertBefore('d', 'function', {
-    register: {
-      // Iasm registers
-      pattern:
-        /\b(?:[ABCD][LHX]|E?(?:BP|DI|SI|SP)|[BS]PL|[ECSDGF]S|CR[0234]|[DS]IL|DR[012367]|E[ABCD]X|X?MM[0-7]|R(?:1[0-5]|[89])[BWD]?|R[ABCD]X|R[BS]P|R[DS]I|TR[3-7]|XMM(?:1[0-5]|[89])|YMM(?:1[0-5]|\d))\b|\bST(?:\([0-7]\)|\b)/,
-      alias: 'variable'
-    }
-  });
+var d_1;
+var hasRequiredD;
+
+function requireD () {
+	if (hasRequiredD) return d_1;
+	hasRequiredD = 1;
+
+	d_1 = d;
+	d.displayName = 'd';
+	d.aliases = [];
+	function d(Prism) {
+	  Prism.languages.d = Prism.languages.extend('clike', {
+	    comment: [
+	      {
+	        // Shebang
+	        pattern: /^\s*#!.+/,
+	        greedy: true
+	      },
+	      {
+	        pattern: RegExp(
+	          /(^|[^\\])/.source +
+	            '(?:' +
+	            [
+	              // /+ comment +/
+	              // Allow one level of nesting
+	              /\/\+(?:\/\+(?:[^+]|\+(?!\/))*\+\/|(?!\/\+)[\s\S])*?\+\//.source, // // comment
+	              /\/\/.*/.source, // /* comment */
+	              /\/\*[\s\S]*?\*\//.source
+	            ].join('|') +
+	            ')'
+	        ),
+	        lookbehind: true,
+	        greedy: true
+	      }
+	    ],
+	    string: [
+	      {
+	        pattern: RegExp(
+	          [
+	            // r"", x""
+	            /\b[rx]"(?:\\[\s\S]|[^\\"])*"[cwd]?/.source, // q"[]", q"()", q"<>", q"{}"
+	            /\bq"(?:\[[\s\S]*?\]|\([\s\S]*?\)|<[\s\S]*?>|\{[\s\S]*?\})"/.source, // q"IDENT
+	            // ...
+	            // IDENT"
+	            /\bq"((?!\d)\w+)$[\s\S]*?^\1"/.source, // q"//", q"||", etc.
+	            // eslint-disable-next-line regexp/strict
+	            /\bq"(.)[\s\S]*?\2"/.source, // eslint-disable-next-line regexp/strict
+	            /(["`])(?:\\[\s\S]|(?!\3)[^\\])*\3[cwd]?/.source
+	          ].join('|'),
+	          'm'
+	        ),
+	        greedy: true
+	      },
+	      {
+	        pattern: /\bq\{(?:\{[^{}]*\}|[^{}])*\}/,
+	        greedy: true,
+	        alias: 'token-string'
+	      }
+	    ],
+	    // In order: $, keywords and special tokens, globally defined symbols
+	    keyword:
+	      /\$|\b(?:__(?:(?:DATE|EOF|FILE|FUNCTION|LINE|MODULE|PRETTY_FUNCTION|TIMESTAMP|TIME|VENDOR|VERSION)__|gshared|parameters|traits|vector)|abstract|alias|align|asm|assert|auto|body|bool|break|byte|case|cast|catch|cdouble|cent|cfloat|char|class|const|continue|creal|dchar|debug|default|delegate|delete|deprecated|do|double|dstring|else|enum|export|extern|false|final|finally|float|for|foreach|foreach_reverse|function|goto|idouble|if|ifloat|immutable|import|inout|int|interface|invariant|ireal|lazy|long|macro|mixin|module|new|nothrow|null|out|override|package|pragma|private|protected|ptrdiff_t|public|pure|real|ref|return|scope|shared|short|size_t|static|string|struct|super|switch|synchronized|template|this|throw|true|try|typedef|typeid|typeof|ubyte|ucent|uint|ulong|union|unittest|ushort|version|void|volatile|wchar|while|with|wstring)\b/,
+	    number: [
+	      // The lookbehind and the negative look-ahead try to prevent bad highlighting of the .. operator
+	      // Hexadecimal numbers must be handled separately to avoid problems with exponent "e"
+	      /\b0x\.?[a-f\d_]+(?:(?!\.\.)\.[a-f\d_]*)?(?:p[+-]?[a-f\d_]+)?[ulfi]{0,4}/i,
+	      {
+	        pattern:
+	          /((?:\.\.)?)(?:\b0b\.?|\b|\.)\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:e[+-]?\d[\d_]*)?[ulfi]{0,4}/i,
+	        lookbehind: true
+	      }
+	    ],
+	    operator:
+	      /\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/
+	  });
+	  Prism.languages.insertBefore('d', 'string', {
+	    // Characters
+	    // 'a', '\\', '\n', '\xFF', '\377', '\uFFFF', '\U0010FFFF', '\quot'
+	    char: /'(?:\\(?:\W|\w+)|[^\\])'/
+	  });
+	  Prism.languages.insertBefore('d', 'keyword', {
+	    property: /\B@\w*/
+	  });
+	  Prism.languages.insertBefore('d', 'function', {
+	    register: {
+	      // Iasm registers
+	      pattern:
+	        /\b(?:[ABCD][LHX]|E?(?:BP|DI|SI|SP)|[BS]PL|[ECSDGF]S|CR[0234]|[DS]IL|DR[012367]|E[ABCD]X|X?MM[0-7]|R(?:1[0-5]|[89])[BWD]?|R[ABCD]X|R[BS]P|R[DS]I|TR[3-7]|XMM(?:1[0-5]|[89])|YMM(?:1[0-5]|\d))\b|\bST(?:\([0-7]\)|\b)/,
+	      alias: 'variable'
+	    }
+	  });
+	}
+	return d_1;
+}
+
+var dart_1;
+var hasRequiredDart;
+
+function requireDart () {
+	if (hasRequiredDart) return dart_1;
+	hasRequiredDart = 1;
+
+	dart_1 = dart;
+	dart.displayName = 'dart';
+	dart.aliases = [];
+	function dart(Prism) {
+(function (Prism) {
+	    var keywords = [
+	      /\b(?:async|sync|yield)\*/,
+	      /\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|final|finally|for|get|hide|if|implements|import|in|interface|library|mixin|new|null|on|operator|part|rethrow|return|set|show|static|super|switch|sync|this|throw|try|typedef|var|void|while|with|yield)\b/
+	    ]; // Handles named imports, such as http.Client
+	    var packagePrefix = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/
+	      .source; // based on the dart naming conventions
+	    var className = {
+	      pattern: RegExp(packagePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
+	      lookbehind: true,
+	      inside: {
+	        namespace: {
+	          pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+	          inside: {
+	            punctuation: /\./
+	          }
+	        }
+	      }
+	    };
+	    Prism.languages.dart = Prism.languages.extend('clike', {
+	      'class-name': [
+	        className,
+	        {
+	          // variables and parameters
+	          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+	          pattern: RegExp(
+	            packagePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source
+	          ),
+	          lookbehind: true,
+	          inside: className.inside
+	        }
+	      ],
+	      keyword: keywords,
+	      operator:
+	        /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
+	    });
+	    Prism.languages.insertBefore('dart', 'string', {
+	      'string-literal': {
+	        pattern:
+	          /r?(?:("""|''')[\s\S]*?\1|(["'])(?:\\.|(?!\2)[^\\\r\n])*\2(?!\2))/,
+	        greedy: true,
+	        inside: {
+	          interpolation: {
+	            pattern:
+	              /((?:^|[^\\])(?:\\{2})*)\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,
+	            lookbehind: true,
+	            inside: {
+	              punctuation: /^\$\{?|\}$/,
+	              expression: {
+	                pattern: /[\s\S]+/,
+	                inside: Prism.languages.dart
+	              }
+	            }
+	          },
+	          string: /[\s\S]+/
+	        }
+	      },
+	      string: undefined
+	    });
+	    Prism.languages.insertBefore('dart', 'class-name', {
+	      metadata: {
+	        pattern: /@\w+/,
+	        alias: 'function'
+	      }
+	    });
+	    Prism.languages.insertBefore('dart', 'class-name', {
+	      generics: {
+	        pattern:
+	          /<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/,
+	        inside: {
+	          'class-name': className,
+	          keyword: keywords,
+	          punctuation: /[<>(),.:]/,
+	          operator: /[?&|]/
+	        }
+	      }
+	    });
+	  })(Prism);
+	}
+	return dart_1;
 }
 
-var dart_1 = dart;
-dart.displayName = 'dart';
-dart.aliases = [];
-function dart(Prism) {
-(function (Prism) {
-    var keywords = [
-      /\b(?:async|sync|yield)\*/,
-      /\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|final|finally|for|get|hide|if|implements|import|in|interface|library|mixin|new|null|on|operator|part|rethrow|return|set|show|static|super|switch|sync|this|throw|try|typedef|var|void|while|with|yield)\b/
-    ]; // Handles named imports, such as http.Client
-    var packagePrefix = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/
-      .source; // based on the dart naming conventions
-    var className = {
-      pattern: RegExp(packagePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
-      lookbehind: true,
-      inside: {
-        namespace: {
-          pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
-          inside: {
-            punctuation: /\./
-          }
-        }
-      }
-    };
-    Prism.languages.dart = Prism.languages.extend('clike', {
-      'class-name': [
-        className,
-        {
-          // variables and parameters
-          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
-          pattern: RegExp(
-            packagePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source
-          ),
-          lookbehind: true,
-          inside: className.inside
-        }
-      ],
-      keyword: keywords,
-      operator:
-        /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
-    });
-    Prism.languages.insertBefore('dart', 'string', {
-      'string-literal': {
-        pattern:
-          /r?(?:("""|''')[\s\S]*?\1|(["'])(?:\\.|(?!\2)[^\\\r\n])*\2(?!\2))/,
-        greedy: true,
-        inside: {
-          interpolation: {
-            pattern:
-              /((?:^|[^\\])(?:\\{2})*)\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,
-            lookbehind: true,
-            inside: {
-              punctuation: /^\$\{?|\}$/,
-              expression: {
-                pattern: /[\s\S]+/,
-                inside: Prism.languages.dart
-              }
-            }
-          },
-          string: /[\s\S]+/
-        }
-      },
-      string: undefined
-    });
-    Prism.languages.insertBefore('dart', 'class-name', {
-      metadata: {
-        pattern: /@\w+/,
-        alias: 'function'
-      }
-    });
-    Prism.languages.insertBefore('dart', 'class-name', {
-      generics: {
-        pattern:
-          /<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/,
-        inside: {
-          'class-name': className,
-          keyword: keywords,
-          punctuation: /[<>(),.:]/,
-          operator: /[?&|]/
-        }
-      }
-    });
-  })(Prism);
-}
+var dataweave_1;
+var hasRequiredDataweave;
 
-var dataweave_1 = dataweave;
-dataweave.displayName = 'dataweave';
-dataweave.aliases = [];
-function dataweave(Prism) {
+function requireDataweave () {
+	if (hasRequiredDataweave) return dataweave_1;
+	hasRequiredDataweave = 1;
+
+	dataweave_1 = dataweave;
+	dataweave.displayName = 'dataweave';
+	dataweave.aliases = [];
+	function dataweave(Prism) {
 (function (Prism) {
-    Prism.languages.dataweave = {
-      url: /\b[A-Za-z]+:\/\/[\w/:.?=&-]+|\burn:[\w:.?=&-]+/,
-      property: {
-        pattern: /(?:\b\w+#)?(?:"(?:\\.|[^\\"\r\n])*"|\b\w+)(?=\s*[:@])/,
-        greedy: true
-      },
-      string: {
-        pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
-        greedy: true
-      },
-      'mime-type':
-        /\b(?:application|audio|image|multipart|text|video)\/[\w+-]+/,
-      date: {
-        pattern: /\|[\w:+-]+\|/,
-        greedy: true
-      },
-      comment: [
-        {
-          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
-          lookbehind: true,
-          greedy: true
-        },
-        {
-          pattern: /(^|[^\\:])\/\/.*/,
-          lookbehind: true,
-          greedy: true
-        }
-      ],
-      regex: {
-        pattern: /\/(?:[^\\\/\r\n]|\\[^\r\n])+\//,
-        greedy: true
-      },
-      keyword:
-        /\b(?:and|as|at|case|do|else|fun|if|input|is|match|not|ns|null|or|output|type|unless|update|using|var)\b/,
-      function: /\b[A-Z_]\w*(?=\s*\()/i,
-      number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
-      punctuation: /[{}[\];(),.:@]/,
-      operator: /<<|>>|->|[<>~=]=?|!=|--?-?|\+\+?|!|\?/,
-      boolean: /\b(?:false|true)\b/
-    };
-  })(Prism);
+	    Prism.languages.dataweave = {
+	      url: /\b[A-Za-z]+:\/\/[\w/:.?=&-]+|\burn:[\w:.?=&-]+/,
+	      property: {
+	        pattern: /(?:\b\w+#)?(?:"(?:\\.|[^\\"\r\n])*"|\b\w+)(?=\s*[:@])/,
+	        greedy: true
+	      },
+	      string: {
+	        pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+	        greedy: true
+	      },
+	      'mime-type':
+	        /\b(?:application|audio|image|multipart|text|video)\/[\w+-]+/,
+	      date: {
+	        pattern: /\|[\w:+-]+\|/,
+	        greedy: true
+	      },
+	      comment: [
+	        {
+	          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+	          lookbehind: true,
+	          greedy: true
+	        },
+	        {
+	          pattern: /(^|[^\\:])\/\/.*/,
+	          lookbehind: true,
+	          greedy: true
+	        }
+	      ],
+	      regex: {
+	        pattern: /\/(?:[^\\\/\r\n]|\\[^\r\n])+\//,
+	        greedy: true
+	      },
+	      keyword:
+	        /\b(?:and|as|at|case|do|else|fun|if|input|is|match|not|ns|null|or|output|type|unless|update|using|var)\b/,
+	      function: /\b[A-Z_]\w*(?=\s*\()/i,
+	      number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+	      punctuation: /[{}[\];(),.:@]/,
+	      operator: /<<|>>|->|[<>~=]=?|!=|--?-?|\+\+?|!|\?/,
+	      boolean: /\b(?:false|true)\b/
+	    };
+	  })(Prism);
+	}
+	return dataweave_1;
 }
 
-var dax_1 = dax;
-dax.displayName = 'dax';
-dax.aliases = [];
-function dax(Prism) {
-  Prism.languages.dax = {
-    comment: {
-      pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/).*)/,
-      lookbehind: true
-    },
-    'data-field': {
-      pattern:
-        /'(?:[^']|'')*'(?!')(?:\[[ \w\xA0-\uFFFF]+\])?|\w+\[[ \w\xA0-\uFFFF]+\]/,
-      alias: 'symbol'
-    },
-    measure: {
-      pattern: /\[[ \w\xA0-\uFFFF]+\]/,
-      alias: 'constant'
-    },
-    string: {
-      pattern: /"(?:[^"]|"")*"(?!")/,
-      greedy: true
-    },
-    function:
-      /\b(?:ABS|ACOS|ACOSH|ACOT|ACOTH|ADDCOLUMNS|ADDMISSINGITEMS|ALL|ALLCROSSFILTERED|ALLEXCEPT|ALLNOBLANKROW|ALLSELECTED|AND|APPROXIMATEDISTINCTCOUNT|ASIN|ASINH|ATAN|ATANH|AVERAGE|AVERAGEA|AVERAGEX|BETA\.DIST|BETA\.INV|BLANK|CALCULATE|CALCULATETABLE|CALENDAR|CALENDARAUTO|CEILING|CHISQ\.DIST|CHISQ\.DIST\.RT|CHISQ\.INV|CHISQ\.INV\.RT|CLOSINGBALANCEMONTH|CLOSINGBALANCEQUARTER|CLOSINGBALANCEYEAR|COALESCE|COMBIN|COMBINA|COMBINEVALUES|CONCATENATE|CONCATENATEX|CONFIDENCE\.NORM|CONFIDENCE\.T|CONTAINS|CONTAINSROW|CONTAINSSTRING|CONTAINSSTRINGEXACT|CONVERT|COS|COSH|COT|COTH|COUNT|COUNTA|COUNTAX|COUNTBLANK|COUNTROWS|COUNTX|CROSSFILTER|CROSSJOIN|CURRENCY|CURRENTGROUP|CUSTOMDATA|DATATABLE|DATE|DATEADD|DATEDIFF|DATESBETWEEN|DATESINPERIOD|DATESMTD|DATESQTD|DATESYTD|DATEVALUE|DAY|DEGREES|DETAILROWS|DISTINCT|DISTINCTCOUNT|DISTINCTCOUNTNOBLANK|DIVIDE|EARLIER|EARLIEST|EDATE|ENDOFMONTH|ENDOFQUARTER|ENDOFYEAR|EOMONTH|ERROR|EVEN|EXACT|EXCEPT|EXP|EXPON\.DIST|FACT|FALSE|FILTER|FILTERS|FIND|FIRSTDATE|FIRSTNONBLANK|FIRSTNONBLANKVALUE|FIXED|FLOOR|FORMAT|GCD|GENERATE|GENERATEALL|GENERATESERIES|GEOMEAN|GEOMEANX|GROUPBY|HASONEFILTER|HASONEVALUE|HOUR|IF|IF\.EAGER|IFERROR|IGNORE|INT|INTERSECT|ISBLANK|ISCROSSFILTERED|ISEMPTY|ISERROR|ISEVEN|ISFILTERED|ISINSCOPE|ISLOGICAL|ISNONTEXT|ISNUMBER|ISO\.CEILING|ISODD|ISONORAFTER|ISSELECTEDMEASURE|ISSUBTOTAL|ISTEXT|KEEPFILTERS|KEYWORDMATCH|LASTDATE|LASTNONBLANK|LASTNONBLANKVALUE|LCM|LEFT|LEN|LN|LOG|LOG10|LOOKUPVALUE|LOWER|MAX|MAXA|MAXX|MEDIAN|MEDIANX|MID|MIN|MINA|MINUTE|MINX|MOD|MONTH|MROUND|NATURALINNERJOIN|NATURALLEFTOUTERJOIN|NEXTDAY|NEXTMONTH|NEXTQUARTER|NEXTYEAR|NONVISUAL|NORM\.DIST|NORM\.INV|NORM\.S\.DIST|NORM\.S\.INV|NOT|NOW|ODD|OPENINGBALANCEMONTH|OPENINGBALANCEQUARTER|OPENINGBALANCEYEAR|OR|PARALLELPERIOD|PATH|PATHCONTAINS|PATHITEM|PATHITEMREVERSE|PATHLENGTH|PERCENTILE\.EXC|PERCENTILE\.INC|PERCENTILEX\.EXC|PERCENTILEX\.INC|PERMUT|PI|POISSON\.DIST|POWER|PREVIOUSDAY|PREVIOUSMONTH|PREVIOUSQUARTER|PREVIOUSYEAR|PRODUCT|PRODUCTX|QUARTER|QUOTIENT|RADIANS|RAND|RANDBETWEEN|RANK\.EQ|RANKX|RELATED|RELATEDTABLE|REMOVEFILTERS|REPLACE|REPT|RIGHT|ROLLUP|ROLLUPADDISSUBTOTAL|ROLLUPGROUP|ROLLUPISSUBTOTAL|ROUND|ROUNDDOWN|ROUNDUP|ROW|SAMEPERIODLASTYEAR|SAMPLE|SEARCH|SECOND|SELECTCOLUMNS|SELECTEDMEASURE|SELECTEDMEASUREFORMATSTRING|SELECTEDMEASURENAME|SELECTEDVALUE|SIGN|SIN|SINH|SQRT|SQRTPI|STARTOFMONTH|STARTOFQUARTER|STARTOFYEAR|STDEV\.P|STDEV\.S|STDEVX\.P|STDEVX\.S|SUBSTITUTE|SUBSTITUTEWITHINDEX|SUM|SUMMARIZE|SUMMARIZECOLUMNS|SUMX|SWITCH|T\.DIST|T\.DIST\.2T|T\.DIST\.RT|T\.INV|T\.INV\.2T|TAN|TANH|TIME|TIMEVALUE|TODAY|TOPN|TOPNPERLEVEL|TOPNSKIP|TOTALMTD|TOTALQTD|TOTALYTD|TREATAS|TRIM|TRUE|TRUNC|UNICHAR|UNICODE|UNION|UPPER|USERELATIONSHIP|USERNAME|USEROBJECTID|USERPRINCIPALNAME|UTCNOW|UTCTODAY|VALUE|VALUES|VAR\.P|VAR\.S|VARX\.P|VARX\.S|WEEKDAY|WEEKNUM|XIRR|XNPV|YEAR|YEARFRAC)(?=\s*\()/i,
-    keyword:
-      /\b(?:DEFINE|EVALUATE|MEASURE|ORDER\s+BY|RETURN|VAR|START\s+AT|ASC|DESC)\b/i,
-    boolean: {
-      pattern: /\b(?:FALSE|NULL|TRUE)\b/i,
-      alias: 'constant'
-    },
-    number: /\b\d+(?:\.\d*)?|\B\.\d+\b/,
-    operator: /:=|[-+*\/=^]|&&?|\|\||<(?:=>?|<|>)?|>[>=]?|\b(?:IN|NOT)\b/i,
-    punctuation: /[;\[\](){}`,.]/
-  };
+var dax_1;
+var hasRequiredDax;
+
+function requireDax () {
+	if (hasRequiredDax) return dax_1;
+	hasRequiredDax = 1;
+
+	dax_1 = dax;
+	dax.displayName = 'dax';
+	dax.aliases = [];
+	function dax(Prism) {
+	  Prism.languages.dax = {
+	    comment: {
+	      pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/).*)/,
+	      lookbehind: true
+	    },
+	    'data-field': {
+	      pattern:
+	        /'(?:[^']|'')*'(?!')(?:\[[ \w\xA0-\uFFFF]+\])?|\w+\[[ \w\xA0-\uFFFF]+\]/,
+	      alias: 'symbol'
+	    },
+	    measure: {
+	      pattern: /\[[ \w\xA0-\uFFFF]+\]/,
+	      alias: 'constant'
+	    },
+	    string: {
+	      pattern: /"(?:[^"]|"")*"(?!")/,
+	      greedy: true
+	    },
+	    function:
+	      /\b(?:ABS|ACOS|ACOSH|ACOT|ACOTH|ADDCOLUMNS|ADDMISSINGITEMS|ALL|ALLCROSSFILTERED|ALLEXCEPT|ALLNOBLANKROW|ALLSELECTED|AND|APPROXIMATEDISTINCTCOUNT|ASIN|ASINH|ATAN|ATANH|AVERAGE|AVERAGEA|AVERAGEX|BETA\.DIST|BETA\.INV|BLANK|CALCULATE|CALCULATETABLE|CALENDAR|CALENDARAUTO|CEILING|CHISQ\.DIST|CHISQ\.DIST\.RT|CHISQ\.INV|CHISQ\.INV\.RT|CLOSINGBALANCEMONTH|CLOSINGBALANCEQUARTER|CLOSINGBALANCEYEAR|COALESCE|COMBIN|COMBINA|COMBINEVALUES|CONCATENATE|CONCATENATEX|CONFIDENCE\.NORM|CONFIDENCE\.T|CONTAINS|CONTAINSROW|CONTAINSSTRING|CONTAINSSTRINGEXACT|CONVERT|COS|COSH|COT|COTH|COUNT|COUNTA|COUNTAX|COUNTBLANK|COUNTROWS|COUNTX|CROSSFILTER|CROSSJOIN|CURRENCY|CURRENTGROUP|CUSTOMDATA|DATATABLE|DATE|DATEADD|DATEDIFF|DATESBETWEEN|DATESINPERIOD|DATESMTD|DATESQTD|DATESYTD|DATEVALUE|DAY|DEGREES|DETAILROWS|DISTINCT|DISTINCTCOUNT|DISTINCTCOUNTNOBLANK|DIVIDE|EARLIER|EARLIEST|EDATE|ENDOFMONTH|ENDOFQUARTER|ENDOFYEAR|EOMONTH|ERROR|EVEN|EXACT|EXCEPT|EXP|EXPON\.DIST|FACT|FALSE|FILTER|FILTERS|FIND|FIRSTDATE|FIRSTNONBLANK|FIRSTNONBLANKVALUE|FIXED|FLOOR|FORMAT|GCD|GENERATE|GENERATEALL|GENERATESERIES|GEOMEAN|GEOMEANX|GROUPBY|HASONEFILTER|HASONEVALUE|HOUR|IF|IF\.EAGER|IFERROR|IGNORE|INT|INTERSECT|ISBLANK|ISCROSSFILTERED|ISEMPTY|ISERROR|ISEVEN|ISFILTERED|ISINSCOPE|ISLOGICAL|ISNONTEXT|ISNUMBER|ISO\.CEILING|ISODD|ISONORAFTER|ISSELECTEDMEASURE|ISSUBTOTAL|ISTEXT|KEEPFILTERS|KEYWORDMATCH|LASTDATE|LASTNONBLANK|LASTNONBLANKVALUE|LCM|LEFT|LEN|LN|LOG|LOG10|LOOKUPVALUE|LOWER|MAX|MAXA|MAXX|MEDIAN|MEDIANX|MID|MIN|MINA|MINUTE|MINX|MOD|MONTH|MROUND|NATURALINNERJOIN|NATURALLEFTOUTERJOIN|NEXTDAY|NEXTMONTH|NEXTQUARTER|NEXTYEAR|NONVISUAL|NORM\.DIST|NORM\.INV|NORM\.S\.DIST|NORM\.S\.INV|NOT|NOW|ODD|OPENINGBALANCEMONTH|OPENINGBALANCEQUARTER|OPENINGBALANCEYEAR|OR|PARALLELPERIOD|PATH|PATHCONTAINS|PATHITEM|PATHITEMREVERSE|PATHLENGTH|PERCENTILE\.EXC|PERCENTILE\.INC|PERCENTILEX\.EXC|PERCENTILEX\.INC|PERMUT|PI|POISSON\.DIST|POWER|PREVIOUSDAY|PREVIOUSMONTH|PREVIOUSQUARTER|PREVIOUSYEAR|PRODUCT|PRODUCTX|QUARTER|QUOTIENT|RADIANS|RAND|RANDBETWEEN|RANK\.EQ|RANKX|RELATED|RELATEDTABLE|REMOVEFILTERS|REPLACE|REPT|RIGHT|ROLLUP|ROLLUPADDISSUBTOTAL|ROLLUPGROUP|ROLLUPISSUBTOTAL|ROUND|ROUNDDOWN|ROUNDUP|ROW|SAMEPERIODLASTYEAR|SAMPLE|SEARCH|SECOND|SELECTCOLUMNS|SELECTEDMEASURE|SELECTEDMEASUREFORMATSTRING|SELECTEDMEASURENAME|SELECTEDVALUE|SIGN|SIN|SINH|SQRT|SQRTPI|STARTOFMONTH|STARTOFQUARTER|STARTOFYEAR|STDEV\.P|STDEV\.S|STDEVX\.P|STDEVX\.S|SUBSTITUTE|SUBSTITUTEWITHINDEX|SUM|SUMMARIZE|SUMMARIZECOLUMNS|SUMX|SWITCH|T\.DIST|T\.DIST\.2T|T\.DIST\.RT|T\.INV|T\.INV\.2T|TAN|TANH|TIME|TIMEVALUE|TODAY|TOPN|TOPNPERLEVEL|TOPNSKIP|TOTALMTD|TOTALQTD|TOTALYTD|TREATAS|TRIM|TRUE|TRUNC|UNICHAR|UNICODE|UNION|UPPER|USERELATIONSHIP|USERNAME|USEROBJECTID|USERPRINCIPALNAME|UTCNOW|UTCTODAY|VALUE|VALUES|VAR\.P|VAR\.S|VARX\.P|VARX\.S|WEEKDAY|WEEKNUM|XIRR|XNPV|YEAR|YEARFRAC)(?=\s*\()/i,
+	    keyword:
+	      /\b(?:DEFINE|EVALUATE|MEASURE|ORDER\s+BY|RETURN|VAR|START\s+AT|ASC|DESC)\b/i,
+	    boolean: {
+	      pattern: /\b(?:FALSE|NULL|TRUE)\b/i,
+	      alias: 'constant'
+	    },
+	    number: /\b\d+(?:\.\d*)?|\B\.\d+\b/,
+	    operator: /:=|[-+*\/=^]|&&?|\|\||<(?:=>?|<|>)?|>[>=]?|\b(?:IN|NOT)\b/i,
+	    punctuation: /[;\[\](){}`,.]/
+	  };
+	}
+	return dax_1;
 }
 
 var dhall_1;
@@ -9400,64 +9533,73 @@ function requireDhall () {
 	return dhall_1;
 }
 
-var diff_1 = diff;
-diff.displayName = 'diff';
-diff.aliases = [];
-function diff(Prism) {
+var diff_1;
+var hasRequiredDiff;
+
+function requireDiff () {
+	if (hasRequiredDiff) return diff_1;
+	hasRequiredDiff = 1;
+
+	diff_1 = diff;
+	diff.displayName = 'diff';
+	diff.aliases = [];
+	function diff(Prism) {
 (function (Prism) {
-    Prism.languages.diff = {
-      coord: [
-        // Match all kinds of coord lines (prefixed by "+++", "---" or "***").
-        /^(?:\*{3}|-{3}|\+{3}).*$/m, // Match "@@ ... @@" coord lines in unified diff.
-        /^@@.*@@$/m, // Match coord lines in normal diff (starts with a number).
-        /^\d.*$/m
-      ] // deleted, inserted, unchanged, diff
-    };
-    /**
-     * A map from the name of a block to its line prefix.
-     *
-     * @type {Object<string, string>}
-     */
-    var PREFIXES = {
-      'deleted-sign': '-',
-      'deleted-arrow': '<',
-      'inserted-sign': '+',
-      'inserted-arrow': '>',
-      unchanged: ' ',
-      diff: '!'
-    }; // add a token for each prefix
-    Object.keys(PREFIXES).forEach(function (name) {
-      var prefix = PREFIXES[name];
-      var alias = [];
-      if (!/^\w+$/.test(name)) {
-        // "deleted-sign" -> "deleted"
-        alias.push(/\w+/.exec(name)[0]);
-      }
-      if (name === 'diff') {
-        alias.push('bold');
-      }
-      Prism.languages.diff[name] = {
-        pattern: RegExp(
-          '^(?:[' + prefix + '].*(?:\r\n?|\n|(?![\\s\\S])))+',
-          'm'
-        ),
-        alias: alias,
-        inside: {
-          line: {
-            pattern: /(.)(?=[\s\S]).*(?:\r\n?|\n)?/,
-            lookbehind: true
-          },
-          prefix: {
-            pattern: /[\s\S]/,
-            alias: /\w+/.exec(name)[0]
-          }
-        }
-      };
-    }); // make prefixes available to Diff plugin
-    Object.defineProperty(Prism.languages.diff, 'PREFIXES', {
-      value: PREFIXES
-    });
-  })(Prism);
+	    Prism.languages.diff = {
+	      coord: [
+	        // Match all kinds of coord lines (prefixed by "+++", "---" or "***").
+	        /^(?:\*{3}|-{3}|\+{3}).*$/m, // Match "@@ ... @@" coord lines in unified diff.
+	        /^@@.*@@$/m, // Match coord lines in normal diff (starts with a number).
+	        /^\d.*$/m
+	      ] // deleted, inserted, unchanged, diff
+	    };
+	    /**
+	     * A map from the name of a block to its line prefix.
+	     *
+	     * @type {Object<string, string>}
+	     */
+	    var PREFIXES = {
+	      'deleted-sign': '-',
+	      'deleted-arrow': '<',
+	      'inserted-sign': '+',
+	      'inserted-arrow': '>',
+	      unchanged: ' ',
+	      diff: '!'
+	    }; // add a token for each prefix
+	    Object.keys(PREFIXES).forEach(function (name) {
+	      var prefix = PREFIXES[name];
+	      var alias = [];
+	      if (!/^\w+$/.test(name)) {
+	        // "deleted-sign" -> "deleted"
+	        alias.push(/\w+/.exec(name)[0]);
+	      }
+	      if (name === 'diff') {
+	        alias.push('bold');
+	      }
+	      Prism.languages.diff[name] = {
+	        pattern: RegExp(
+	          '^(?:[' + prefix + '].*(?:\r\n?|\n|(?![\\s\\S])))+',
+	          'm'
+	        ),
+	        alias: alias,
+	        inside: {
+	          line: {
+	            pattern: /(.)(?=[\s\S]).*(?:\r\n?|\n)?/,
+	            lookbehind: true
+	          },
+	          prefix: {
+	            pattern: /[\s\S]/,
+	            alias: /\w+/.exec(name)[0]
+	          }
+	        }
+	      };
+	    }); // make prefixes available to Diff plugin
+	    Object.defineProperty(Prism.languages.diff, 'PREFIXES', {
+	      value: PREFIXES
+	    });
+	  })(Prism);
+	}
+	return diff_1;
 }
 
 var markupTemplating_1;
@@ -9572,327 +9714,362 @@ function requireMarkupTemplating () {
 	                    token.content = replacement;
 	                  }
 	                }
-	              } else if (
-	                token.content
-	                /* && typeof token.content !== 'string' */
-	              ) {
-	                walkTokens(token.content);
-	              }
+	              } else if (
+	                token.content
+	                /* && typeof token.content !== 'string' */
+	              ) {
+	                walkTokens(token.content);
+	              }
+	            }
+	            return tokens
+	          }
+	          walkTokens(env.tokens);
+	        }
+	      }
+	    });
+	  })(Prism);
+	}
+	return markupTemplating_1;
+}
+
+var django_1;
+var hasRequiredDjango;
+
+function requireDjango () {
+	if (hasRequiredDjango) return django_1;
+	hasRequiredDjango = 1;
+	var refractorMarkupTemplating = requireMarkupTemplating();
+	django_1 = django;
+	django.displayName = 'django';
+	django.aliases = ['jinja2'];
+	function django(Prism) {
+	  Prism.register(refractorMarkupTemplating)
+	  // Django/Jinja2 syntax definition for Prism.js <http://prismjs.com> syntax highlighter.
+	  // Mostly it works OK but can paint code incorrectly on complex html/template tag combinations.
+	  ;(function (Prism) {
+	    Prism.languages.django = {
+	      comment: /^\{#[\s\S]*?#\}$/,
+	      tag: {
+	        pattern: /(^\{%[+-]?\s*)\w+/,
+	        lookbehind: true,
+	        alias: 'keyword'
+	      },
+	      delimiter: {
+	        pattern: /^\{[{%][+-]?|[+-]?[}%]\}$/,
+	        alias: 'punctuation'
+	      },
+	      string: {
+	        pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+	        greedy: true
+	      },
+	      filter: {
+	        pattern: /(\|)\w+/,
+	        lookbehind: true,
+	        alias: 'function'
+	      },
+	      test: {
+	        pattern: /(\bis\s+(?:not\s+)?)(?!not\b)\w+/,
+	        lookbehind: true,
+	        alias: 'function'
+	      },
+	      function: /\b[a-z_]\w+(?=\s*\()/i,
+	      keyword:
+	        /\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\b/,
+	      operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+	      number: /\b\d+(?:\.\d+)?\b/,
+	      boolean: /[Ff]alse|[Nn]one|[Tt]rue/,
+	      variable: /\b\w+\b/,
+	      punctuation: /[{}[\](),.:;]/
+	    };
+	    var pattern = /\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\}|\{#[\s\S]*?#\}/g;
+	    var markupTemplating = Prism.languages['markup-templating'];
+	    Prism.hooks.add('before-tokenize', function (env) {
+	      markupTemplating.buildPlaceholders(env, 'django', pattern);
+	    });
+	    Prism.hooks.add('after-tokenize', function (env) {
+	      markupTemplating.tokenizePlaceholders(env, 'django');
+	    }); // Add an Jinja2 alias
+	    Prism.languages.jinja2 = Prism.languages.django;
+	    Prism.hooks.add('before-tokenize', function (env) {
+	      markupTemplating.buildPlaceholders(env, 'jinja2', pattern);
+	    });
+	    Prism.hooks.add('after-tokenize', function (env) {
+	      markupTemplating.tokenizePlaceholders(env, 'jinja2');
+	    });
+	  })(Prism);
+	}
+	return django_1;
+}
+
+var dnsZoneFile_1;
+var hasRequiredDnsZoneFile;
+
+function requireDnsZoneFile () {
+	if (hasRequiredDnsZoneFile) return dnsZoneFile_1;
+	hasRequiredDnsZoneFile = 1;
+
+	dnsZoneFile_1 = dnsZoneFile;
+	dnsZoneFile.displayName = 'dnsZoneFile';
+	dnsZoneFile.aliases = [];
+	function dnsZoneFile(Prism) {
+	  Prism.languages['dns-zone-file'] = {
+	    comment: /;.*/,
+	    string: {
+	      pattern: /"(?:\\.|[^"\\\r\n])*"/,
+	      greedy: true
+	    },
+	    variable: [
+	      {
+	        pattern: /(^\$ORIGIN[ \t]+)\S+/m,
+	        lookbehind: true
+	      },
+	      {
+	        pattern: /(^|\s)@(?=\s|$)/,
+	        lookbehind: true
+	      }
+	    ],
+	    keyword: /^\$(?:INCLUDE|ORIGIN|TTL)(?=\s|$)/m,
+	    class: {
+	      // https://tools.ietf.org/html/rfc1035#page-13
+	      pattern: /(^|\s)(?:CH|CS|HS|IN)(?=\s|$)/,
+	      lookbehind: true,
+	      alias: 'keyword'
+	    },
+	    type: {
+	      // https://en.wikipedia.org/wiki/List_of_DNS_record_types
+	      pattern:
+	        /(^|\s)(?:A|A6|AAAA|AFSDB|APL|ATMA|CAA|CDNSKEY|CDS|CERT|CNAME|DHCID|DLV|DNAME|DNSKEY|DS|EID|GID|GPOS|HINFO|HIP|IPSECKEY|ISDN|KEY|KX|LOC|MAILA|MAILB|MB|MD|MF|MG|MINFO|MR|MX|NAPTR|NB|NBSTAT|NIMLOC|NINFO|NS|NSAP|NSAP-PTR|NSEC|NSEC3|NSEC3PARAM|NULL|NXT|OPENPGPKEY|PTR|PX|RKEY|RP|RRSIG|RT|SIG|SINK|SMIMEA|SOA|SPF|SRV|SSHFP|TA|TKEY|TLSA|TSIG|TXT|UID|UINFO|UNSPEC|URI|WKS|X25)(?=\s|$)/,
+	      lookbehind: true,
+	      alias: 'keyword'
+	    },
+	    punctuation: /[()]/
+	  };
+	  Prism.languages['dns-zone'] = Prism.languages['dns-zone-file'];
+	}
+	return dnsZoneFile_1;
+}
+
+var docker_1;
+var hasRequiredDocker;
+
+function requireDocker () {
+	if (hasRequiredDocker) return docker_1;
+	hasRequiredDocker = 1;
+
+	docker_1 = docker;
+	docker.displayName = 'docker';
+	docker.aliases = ['dockerfile'];
+	function docker(Prism) {
+(function (Prism) {
+	    // Many of the following regexes will contain negated lookaheads like `[ \t]+(?![ \t])`. This is a trick to ensure
+	    // that quantifiers behave *atomically*. Atomic quantifiers are necessary to prevent exponential backtracking.
+	    var spaceAfterBackSlash =
+	      /\\[\r\n](?:\s|\\[\r\n]|#.*(?!.))*(?![\s#]|\\[\r\n])/.source; // At least one space, comment, or line break
+	    var space = /(?:[ \t]+(?![ \t])(?:<SP_BS>)?|<SP_BS>)/.source.replace(
+	      /<SP_BS>/g,
+	      function () {
+	        return spaceAfterBackSlash
+	      }
+	    );
+	    var string =
+	      /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"|'(?:[^'\\\r\n]|\\(?:\r\n|[\s\S]))*'/
+	        .source;
+	    var option = /--[\w-]+=(?:<STR>|(?!["'])(?:[^\s\\]|\\.)+)/.source.replace(
+	      /<STR>/g,
+	      function () {
+	        return string
+	      }
+	    );
+	    var stringRule = {
+	      pattern: RegExp(string),
+	      greedy: true
+	    };
+	    var commentRule = {
+	      pattern: /(^[ \t]*)#.*/m,
+	      lookbehind: true,
+	      greedy: true
+	    };
+	    /**
+	     * @param {string} source
+	     * @param {string} flags
+	     * @returns {RegExp}
+	     */
+	    function re(source, flags) {
+	      source = source
+	        .replace(/<OPT>/g, function () {
+	          return option
+	        })
+	        .replace(/<SP>/g, function () {
+	          return space
+	        });
+	      return RegExp(source, flags)
+	    }
+	    Prism.languages.docker = {
+	      instruction: {
+	        pattern:
+	          /(^[ \t]*)(?:ADD|ARG|CMD|COPY|ENTRYPOINT|ENV|EXPOSE|FROM|HEALTHCHECK|LABEL|MAINTAINER|ONBUILD|RUN|SHELL|STOPSIGNAL|USER|VOLUME|WORKDIR)(?=\s)(?:\\.|[^\r\n\\])*(?:\\$(?:\s|#.*$)*(?![\s#])(?:\\.|[^\r\n\\])*)*/im,
+	        lookbehind: true,
+	        greedy: true,
+	        inside: {
+	          options: {
+	            pattern: re(
+	              /(^(?:ONBUILD<SP>)?\w+<SP>)<OPT>(?:<SP><OPT>)*/.source,
+	              'i'
+	            ),
+	            lookbehind: true,
+	            greedy: true,
+	            inside: {
+	              property: {
+	                pattern: /(^|\s)--[\w-]+/,
+	                lookbehind: true
+	              },
+	              string: [
+	                stringRule,
+	                {
+	                  pattern: /(=)(?!["'])(?:[^\s\\]|\\.)+/,
+	                  lookbehind: true
+	                }
+	              ],
+	              operator: /\\$/m,
+	              punctuation: /=/
 	            }
-	            return tokens
-	          }
-	          walkTokens(env.tokens);
+	          },
+	          keyword: [
+	            {
+	              // https://docs.docker.com/engine/reference/builder/#healthcheck
+	              pattern: re(
+	                /(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\b/
+	                  .source,
+	                'i'
+	              ),
+	              lookbehind: true,
+	              greedy: true
+	            },
+	            {
+	              // https://docs.docker.com/engine/reference/builder/#from
+	              pattern: re(
+	                /(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ \t\\]+<SP>)AS/
+	                  .source,
+	                'i'
+	              ),
+	              lookbehind: true,
+	              greedy: true
+	            },
+	            {
+	              // https://docs.docker.com/engine/reference/builder/#onbuild
+	              pattern: re(/(^ONBUILD<SP>)\w+/.source, 'i'),
+	              lookbehind: true,
+	              greedy: true
+	            },
+	            {
+	              pattern: /^\w+/,
+	              greedy: true
+	            }
+	          ],
+	          comment: commentRule,
+	          string: stringRule,
+	          variable: /\$(?:\w+|\{[^{}"'\\]*\})/,
+	          operator: /\\$/m
 	        }
-	      }
-	    });
+	      },
+	      comment: commentRule
+	    };
+	    Prism.languages.dockerfile = Prism.languages.docker;
 	  })(Prism);
 	}
-	return markupTemplating_1;
-}
-
-var refractorMarkupTemplating$1 = requireMarkupTemplating();
-var django_1 = django;
-django.displayName = 'django';
-django.aliases = ['jinja2'];
-function django(Prism) {
-  Prism.register(refractorMarkupTemplating$1)
-  // Django/Jinja2 syntax definition for Prism.js <http://prismjs.com> syntax highlighter.
-  // Mostly it works OK but can paint code incorrectly on complex html/template tag combinations.
-  ;(function (Prism) {
-    Prism.languages.django = {
-      comment: /^\{#[\s\S]*?#\}$/,
-      tag: {
-        pattern: /(^\{%[+-]?\s*)\w+/,
-        lookbehind: true,
-        alias: 'keyword'
-      },
-      delimiter: {
-        pattern: /^\{[{%][+-]?|[+-]?[}%]\}$/,
-        alias: 'punctuation'
-      },
-      string: {
-        pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
-        greedy: true
-      },
-      filter: {
-        pattern: /(\|)\w+/,
-        lookbehind: true,
-        alias: 'function'
-      },
-      test: {
-        pattern: /(\bis\s+(?:not\s+)?)(?!not\b)\w+/,
-        lookbehind: true,
-        alias: 'function'
-      },
-      function: /\b[a-z_]\w+(?=\s*\()/i,
-      keyword:
-        /\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\b/,
-      operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
-      number: /\b\d+(?:\.\d+)?\b/,
-      boolean: /[Ff]alse|[Nn]one|[Tt]rue/,
-      variable: /\b\w+\b/,
-      punctuation: /[{}[\](),.:;]/
-    };
-    var pattern = /\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\}|\{#[\s\S]*?#\}/g;
-    var markupTemplating = Prism.languages['markup-templating'];
-    Prism.hooks.add('before-tokenize', function (env) {
-      markupTemplating.buildPlaceholders(env, 'django', pattern);
-    });
-    Prism.hooks.add('after-tokenize', function (env) {
-      markupTemplating.tokenizePlaceholders(env, 'django');
-    }); // Add an Jinja2 alias
-    Prism.languages.jinja2 = Prism.languages.django;
-    Prism.hooks.add('before-tokenize', function (env) {
-      markupTemplating.buildPlaceholders(env, 'jinja2', pattern);
-    });
-    Prism.hooks.add('after-tokenize', function (env) {
-      markupTemplating.tokenizePlaceholders(env, 'jinja2');
-    });
-  })(Prism);
+	return docker_1;
 }
 
-var dnsZoneFile_1 = dnsZoneFile;
-dnsZoneFile.displayName = 'dnsZoneFile';
-dnsZoneFile.aliases = [];
-function dnsZoneFile(Prism) {
-  Prism.languages['dns-zone-file'] = {
-    comment: /;.*/,
-    string: {
-      pattern: /"(?:\\.|[^"\\\r\n])*"/,
-      greedy: true
-    },
-    variable: [
-      {
-        pattern: /(^\$ORIGIN[ \t]+)\S+/m,
-        lookbehind: true
-      },
-      {
-        pattern: /(^|\s)@(?=\s|$)/,
-        lookbehind: true
-      }
-    ],
-    keyword: /^\$(?:INCLUDE|ORIGIN|TTL)(?=\s|$)/m,
-    class: {
-      // https://tools.ietf.org/html/rfc1035#page-13
-      pattern: /(^|\s)(?:CH|CS|HS|IN)(?=\s|$)/,
-      lookbehind: true,
-      alias: 'keyword'
-    },
-    type: {
-      // https://en.wikipedia.org/wiki/List_of_DNS_record_types
-      pattern:
-        /(^|\s)(?:A|A6|AAAA|AFSDB|APL|ATMA|CAA|CDNSKEY|CDS|CERT|CNAME|DHCID|DLV|DNAME|DNSKEY|DS|EID|GID|GPOS|HINFO|HIP|IPSECKEY|ISDN|KEY|KX|LOC|MAILA|MAILB|MB|MD|MF|MG|MINFO|MR|MX|NAPTR|NB|NBSTAT|NIMLOC|NINFO|NS|NSAP|NSAP-PTR|NSEC|NSEC3|NSEC3PARAM|NULL|NXT|OPENPGPKEY|PTR|PX|RKEY|RP|RRSIG|RT|SIG|SINK|SMIMEA|SOA|SPF|SRV|SSHFP|TA|TKEY|TLSA|TSIG|TXT|UID|UINFO|UNSPEC|URI|WKS|X25)(?=\s|$)/,
-      lookbehind: true,
-      alias: 'keyword'
-    },
-    punctuation: /[()]/
-  };
-  Prism.languages['dns-zone'] = Prism.languages['dns-zone-file'];
-}
+var dot_1;
+var hasRequiredDot;
 
-var docker_1 = docker;
-docker.displayName = 'docker';
-docker.aliases = ['dockerfile'];
-function docker(Prism) {
-(function (Prism) {
-    // Many of the following regexes will contain negated lookaheads like `[ \t]+(?![ \t])`. This is a trick to ensure
-    // that quantifiers behave *atomically*. Atomic quantifiers are necessary to prevent exponential backtracking.
-    var spaceAfterBackSlash =
-      /\\[\r\n](?:\s|\\[\r\n]|#.*(?!.))*(?![\s#]|\\[\r\n])/.source; // At least one space, comment, or line break
-    var space = /(?:[ \t]+(?![ \t])(?:<SP_BS>)?|<SP_BS>)/.source.replace(
-      /<SP_BS>/g,
-      function () {
-        return spaceAfterBackSlash
-      }
-    );
-    var string =
-      /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"|'(?:[^'\\\r\n]|\\(?:\r\n|[\s\S]))*'/
-        .source;
-    var option = /--[\w-]+=(?:<STR>|(?!["'])(?:[^\s\\]|\\.)+)/.source.replace(
-      /<STR>/g,
-      function () {
-        return string
-      }
-    );
-    var stringRule = {
-      pattern: RegExp(string),
-      greedy: true
-    };
-    var commentRule = {
-      pattern: /(^[ \t]*)#.*/m,
-      lookbehind: true,
-      greedy: true
-    };
-    /**
-     * @param {string} source
-     * @param {string} flags
-     * @returns {RegExp}
-     */
-    function re(source, flags) {
-      source = source
-        .replace(/<OPT>/g, function () {
-          return option
-        })
-        .replace(/<SP>/g, function () {
-          return space
-        });
-      return RegExp(source, flags)
-    }
-    Prism.languages.docker = {
-      instruction: {
-        pattern:
-          /(^[ \t]*)(?:ADD|ARG|CMD|COPY|ENTRYPOINT|ENV|EXPOSE|FROM|HEALTHCHECK|LABEL|MAINTAINER|ONBUILD|RUN|SHELL|STOPSIGNAL|USER|VOLUME|WORKDIR)(?=\s)(?:\\.|[^\r\n\\])*(?:\\$(?:\s|#.*$)*(?![\s#])(?:\\.|[^\r\n\\])*)*/im,
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          options: {
-            pattern: re(
-              /(^(?:ONBUILD<SP>)?\w+<SP>)<OPT>(?:<SP><OPT>)*/.source,
-              'i'
-            ),
-            lookbehind: true,
-            greedy: true,
-            inside: {
-              property: {
-                pattern: /(^|\s)--[\w-]+/,
-                lookbehind: true
-              },
-              string: [
-                stringRule,
-                {
-                  pattern: /(=)(?!["'])(?:[^\s\\]|\\.)+/,
-                  lookbehind: true
-                }
-              ],
-              operator: /\\$/m,
-              punctuation: /=/
-            }
-          },
-          keyword: [
-            {
-              // https://docs.docker.com/engine/reference/builder/#healthcheck
-              pattern: re(
-                /(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\b/
-                  .source,
-                'i'
-              ),
-              lookbehind: true,
-              greedy: true
-            },
-            {
-              // https://docs.docker.com/engine/reference/builder/#from
-              pattern: re(
-                /(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ \t\\]+<SP>)AS/
-                  .source,
-                'i'
-              ),
-              lookbehind: true,
-              greedy: true
-            },
-            {
-              // https://docs.docker.com/engine/reference/builder/#onbuild
-              pattern: re(/(^ONBUILD<SP>)\w+/.source, 'i'),
-              lookbehind: true,
-              greedy: true
-            },
-            {
-              pattern: /^\w+/,
-              greedy: true
-            }
-          ],
-          comment: commentRule,
-          string: stringRule,
-          variable: /\$(?:\w+|\{[^{}"'\\]*\})/,
-          operator: /\\$/m
-        }
-      },
-      comment: commentRule
-    };
-    Prism.languages.dockerfile = Prism.languages.docker;
-  })(Prism);
-}
+function requireDot () {
+	if (hasRequiredDot) return dot_1;
+	hasRequiredDot = 1;
 
-var dot_1 = dot;
-dot.displayName = 'dot';
-dot.aliases = ['gv'];
-function dot(Prism) {
+	dot_1 = dot;
+	dot.displayName = 'dot';
+	dot.aliases = ['gv'];
+	function dot(Prism) {
 (function (Prism) {
-    var ID =
-      '(?:' +
-      [
-        // an identifier
-        /[a-zA-Z_\x80-\uFFFF][\w\x80-\uFFFF]*/.source, // a number
-        /-?(?:\.\d+|\d+(?:\.\d*)?)/.source, // a double-quoted string
-        /"[^"\\]*(?:\\[\s\S][^"\\]*)*"/.source, // HTML-like string
-        /<(?:[^<>]|(?!<!--)<(?:[^<>"']|"[^"]*"|'[^']*')+>|<!--(?:[^-]|-(?!->))*-->)*>/
-          .source
-      ].join('|') +
-      ')';
-    var IDInside = {
-      markup: {
-        pattern: /(^<)[\s\S]+(?=>$)/,
-        lookbehind: true,
-        alias: ['language-markup', 'language-html', 'language-xml'],
-        inside: Prism.languages.markup
-      }
-    };
-    /**
-     * @param {string} source
-     * @param {string} flags
-     * @returns {RegExp}
-     */
-    function withID(source, flags) {
-      return RegExp(
-        source.replace(/<ID>/g, function () {
-          return ID
-        }),
-        flags
-      )
-    }
-    Prism.languages.dot = {
-      comment: {
-        pattern: /\/\/.*|\/\*[\s\S]*?\*\/|^#.*/m,
-        greedy: true
-      },
-      'graph-name': {
-        pattern: withID(
-          /(\b(?:digraph|graph|subgraph)[ \t\r\n]+)<ID>/.source,
-          'i'
-        ),
-        lookbehind: true,
-        greedy: true,
-        alias: 'class-name',
-        inside: IDInside
-      },
-      'attr-value': {
-        pattern: withID(/(=[ \t\r\n]*)<ID>/.source),
-        lookbehind: true,
-        greedy: true,
-        inside: IDInside
-      },
-      'attr-name': {
-        pattern: withID(/([\[;, \t\r\n])<ID>(?=[ \t\r\n]*=)/.source),
-        lookbehind: true,
-        greedy: true,
-        inside: IDInside
-      },
-      keyword: /\b(?:digraph|edge|graph|node|strict|subgraph)\b/i,
-      'compass-point': {
-        pattern: /(:[ \t\r\n]*)(?:[ewc_]|[ns][ew]?)(?![\w\x80-\uFFFF])/,
-        lookbehind: true,
-        alias: 'builtin'
-      },
-      node: {
-        pattern: withID(/(^|[^-.\w\x80-\uFFFF\\])<ID>/.source),
-        lookbehind: true,
-        greedy: true,
-        inside: IDInside
-      },
-      operator: /[=:]|-[->]/,
-      punctuation: /[\[\]{};,]/
-    };
-    Prism.languages.gv = Prism.languages.dot;
-  })(Prism);
+	    var ID =
+	      '(?:' +
+	      [
+	        // an identifier
+	        /[a-zA-Z_\x80-\uFFFF][\w\x80-\uFFFF]*/.source, // a number
+	        /-?(?:\.\d+|\d+(?:\.\d*)?)/.source, // a double-quoted string
+	        /"[^"\\]*(?:\\[\s\S][^"\\]*)*"/.source, // HTML-like string
+	        /<(?:[^<>]|(?!<!--)<(?:[^<>"']|"[^"]*"|'[^']*')+>|<!--(?:[^-]|-(?!->))*-->)*>/
+	          .source
+	      ].join('|') +
+	      ')';
+	    var IDInside = {
+	      markup: {
+	        pattern: /(^<)[\s\S]+(?=>$)/,
+	        lookbehind: true,
+	        alias: ['language-markup', 'language-html', 'language-xml'],
+	        inside: Prism.languages.markup
+	      }
+	    };
+	    /**
+	     * @param {string} source
+	     * @param {string} flags
+	     * @returns {RegExp}
+	     */
+	    function withID(source, flags) {
+	      return RegExp(
+	        source.replace(/<ID>/g, function () {
+	          return ID
+	        }),
+	        flags
+	      )
+	    }
+	    Prism.languages.dot = {
+	      comment: {
+	        pattern: /\/\/.*|\/\*[\s\S]*?\*\/|^#.*/m,
+	        greedy: true
+	      },
+	      'graph-name': {
+	        pattern: withID(
+	          /(\b(?:digraph|graph|subgraph)[ \t\r\n]+)<ID>/.source,
+	          'i'
+	        ),
+	        lookbehind: true,
+	        greedy: true,
+	        alias: 'class-name',
+	        inside: IDInside
+	      },
+	      'attr-value': {
+	        pattern: withID(/(=[ \t\r\n]*)<ID>/.source),
+	        lookbehind: true,
+	        greedy: true,
+	        inside: IDInside
+	      },
+	      'attr-name': {
+	        pattern: withID(/([\[;, \t\r\n])<ID>(?=[ \t\r\n]*=)/.source),
+	        lookbehind: true,
+	        greedy: true,
+	        inside: IDInside
+	      },
+	      keyword: /\b(?:digraph|edge|graph|node|strict|subgraph)\b/i,
+	      'compass-point': {
+	        pattern: /(:[ \t\r\n]*)(?:[ewc_]|[ns][ew]?)(?![\w\x80-\uFFFF])/,
+	        lookbehind: true,
+	        alias: 'builtin'
+	      },
+	      node: {
+	        pattern: withID(/(^|[^-.\w\x80-\uFFFF\\])<ID>/.source),
+	        lookbehind: true,
+	        greedy: true,
+	        inside: IDInside
+	      },
+	      operator: /[=:]|-[->]/,
+	      punctuation: /[\[\]{};,]/
+	    };
+	    Prism.languages.gv = Prism.languages.dot;
+	  })(Prism);
+	}
+	return dot_1;
 }
 
 var ebnf_1;
@@ -10019,37 +10196,45 @@ function requireEiffel () {
 	return eiffel_1;
 }
 
-var refractorMarkupTemplating = requireMarkupTemplating();
-var ejs_1 = ejs;
-ejs.displayName = 'ejs';
-ejs.aliases = ['eta'];
-function ejs(Prism) {
-  Prism.register(refractorMarkupTemplating)
-  ;(function (Prism) {
-    Prism.languages.ejs = {
-      delimiter: {
-        pattern: /^<%[-_=]?|[-_]?%>$/,
-        alias: 'punctuation'
-      },
-      comment: /^#[\s\S]*/,
-      'language-javascript': {
-        pattern: /[\s\S]+/,
-        inside: Prism.languages.javascript
-      }
-    };
-    Prism.hooks.add('before-tokenize', function (env) {
-      var ejsPattern = /<%(?!%)[\s\S]+?%>/g;
-      Prism.languages['markup-templating'].buildPlaceholders(
-        env,
-        'ejs',
-        ejsPattern
-      );
-    });
-    Prism.hooks.add('after-tokenize', function (env) {
-      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'ejs');
-    });
-    Prism.languages.eta = Prism.languages.ejs;
-  })(Prism);
+var ejs_1;
+var hasRequiredEjs;
+
+function requireEjs () {
+	if (hasRequiredEjs) return ejs_1;
+	hasRequiredEjs = 1;
+	var refractorMarkupTemplating = requireMarkupTemplating();
+	ejs_1 = ejs;
+	ejs.displayName = 'ejs';
+	ejs.aliases = ['eta'];
+	function ejs(Prism) {
+	  Prism.register(refractorMarkupTemplating)
+	  ;(function (Prism) {
+	    Prism.languages.ejs = {
+	      delimiter: {
+	        pattern: /^<%[-_=]?|[-_]?%>$/,
+	        alias: 'punctuation'
+	      },
+	      comment: /^#[\s\S]*/,
+	      'language-javascript': {
+	        pattern: /[\s\S]+/,
+	        inside: Prism.languages.javascript
+	      }
+	    };
+	    Prism.hooks.add('before-tokenize', function (env) {
+	      var ejsPattern = /<%(?!%)[\s\S]+?%>/g;
+	      Prism.languages['markup-templating'].buildPlaceholders(
+	        env,
+	        'ejs',
+	        ejsPattern
+	      );
+	    });
+	    Prism.hooks.add('after-tokenize', function (env) {
+	      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'ejs');
+	    });
+	    Prism.languages.eta = Prism.languages.ejs;
+	  })(Prism);
+	}
+	return ejs_1;
 }
 
 var elixir_1;
@@ -10238,7 +10423,7 @@ var hasRequiredErb;
 function requireErb () {
 	if (hasRequiredErb) return erb_1;
 	hasRequiredErb = 1;
-	var refractorRuby = ruby_1;
+	var refractorRuby = requireRuby();
 	var refractorMarkupTemplating = requireMarkupTemplating();
 	erb_1 = erb;
 	erb.displayName = 'erb';
@@ -12720,7 +12905,7 @@ var hasRequiredHaml;
 function requireHaml () {
 	if (hasRequiredHaml) return haml_1;
 	hasRequiredHaml = 1;
-	var refractorRuby = ruby_1;
+	var refractorRuby = requireRuby();
 	haml_1 = haml;
 	haml.displayName = 'haml';
 	haml.aliases = [];
@@ -25156,7 +25341,7 @@ function requireT4Cs () {
 	if (hasRequiredT4Cs) return t4Cs_1;
 	hasRequiredT4Cs = 1;
 	var refractorT4Templating = requireT4Templating();
-	var refractorCsharp = csharp_1;
+	var refractorCsharp = requireCsharp();
 	t4Cs_1 = t4Cs;
 	t4Cs.displayName = 't4Cs';
 	t4Cs.aliases = [];
@@ -27914,7 +28099,7 @@ refractor.register(aspnet_1);
 refractor.register(autohotkey_1);
 refractor.register(autoit_1);
 refractor.register(avisynth_1);
-refractor.register(avroIdl_1);
+refractor.register(requireAvroIdl());
 refractor.register(bash_1);
 refractor.register(basic_1);
 refractor.register(batch_1);
@@ -27923,7 +28108,7 @@ refractor.register(bicep_1);
 refractor.register(birb_1);
 refractor.register(bison_1);
 refractor.register(bnf_1);
-refractor.register(brainfuck_1);
+refractor.register(requireBrainfuck());
 refractor.register(brightscript_1);
 refractor.register(bro_1);
 refractor.register(bsl_1);
@@ -27935,30 +28120,30 @@ refractor.register(clojure_1);
 refractor.register(cmake_1);
 refractor.register(cobol_1);
 refractor.register(coffeescript_1);
-refractor.register(concurnas_1);
-refractor.register(coq_1);
+refractor.register(requireConcurnas());
+refractor.register(requireCoq());
 refractor.register(requireCpp());
-refractor.register(crystal_1);
-refractor.register(csharp_1);
-refractor.register(cshtml_1);
-refractor.register(csp_1);
-refractor.register(cssExtras_1);
+refractor.register(requireCrystal());
+refractor.register(requireCsharp());
+refractor.register(requireCshtml());
+refractor.register(requireCsp());
+refractor.register(requireCssExtras());
 refractor.register(requireCsv());
-refractor.register(cypher_1);
-refractor.register(d_1);
-refractor.register(dart_1);
-refractor.register(dataweave_1);
-refractor.register(dax_1);
+refractor.register(requireCypher());
+refractor.register(requireD());
+refractor.register(requireDart());
+refractor.register(requireDataweave());
+refractor.register(requireDax());
 refractor.register(requireDhall());
-refractor.register(diff_1);
-refractor.register(django_1);
-refractor.register(dnsZoneFile_1);
-refractor.register(docker_1);
-refractor.register(dot_1);
+refractor.register(requireDiff());
+refractor.register(requireDjango());
+refractor.register(requireDnsZoneFile());
+refractor.register(requireDocker());
+refractor.register(requireDot());
 refractor.register(requireEbnf());
 refractor.register(requireEditorconfig());
 refractor.register(requireEiffel());
-refractor.register(ejs_1);
+refractor.register(requireEjs());
 refractor.register(requireElixir());
 refractor.register(requireElm());
 refractor.register(requireErb());
@@ -28104,7 +28289,7 @@ refractor.register(requireRest());
 refractor.register(requireRip());
 refractor.register(requireRoboconf());
 refractor.register(requireRobotframework());
-refractor.register(ruby_1);
+refractor.register(requireRuby());
 refractor.register(requireRust());
 refractor.register(requireSas());
 refractor.register(requireSass());
@@ -38931,7 +39116,19 @@ function remarkThinkUpdate(content) {
  */
 function escapeContentForStream(content) {
   if (typeof content !== 'string') return content;
-  return content.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#x27;').replace(/{/g, '&#123;').replace(/}/g, '&#125;');
+  // 匹配代码块的正则表达式
+  var codeBlockRegex = /(```[\s\S]*?```|`[^`]*`)/g;
+  // 分割内容为代码块和非代码块部分
+  var parts = content.split(codeBlockRegex);
+  // 对非代码块部分进行转义，保留代码块部分不变
+  return parts.map(function (part, index) {
+    // 奇数索引为代码块部分（根据split的特性）
+    if (index % 2 === 1) {
+      return part; // 代码块部分不转义
+    }
+    // 偶数索引为非代码块部分，进行转义
+    return part.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#x27;').replace(/{/g, '&#123;').replace(/}/g, '&#125;');
+  }).join('');
 }
 
 var renderTimer = null;