react-ai-renderer 0.1.6 → 0.1.8

package/dist/index.js

@@ -5753,126 +5753,134 @@ function c(Prism) {
   delete Prism.languages.c['boolean'];
 }
 
-var refractorC$1 = c_1;
-var cpp_1 = cpp;
-cpp.displayName = 'cpp';
-cpp.aliases = [];
-function cpp(Prism) {
-  Prism.register(refractorC$1)
-  ;(function (Prism) {
-    var keyword =
-      /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/;
-    var modName = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(
-      /<keyword>/g,
-      function () {
-        return keyword.source
-      }
-    );
-    Prism.languages.cpp = Prism.languages.extend('c', {
-      'class-name': [
-        {
-          pattern: RegExp(
-            /(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(
-              /<keyword>/g,
-              function () {
-                return keyword.source
-              }
-            )
-          ),
-          lookbehind: true
-        }, // This is intended to capture the class name of method implementations like:
-        //   void foo::bar() const {}
-        // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
-        // it starts with an uppercase letter. This approximation should give decent results.
-        /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, // This will capture the class name before destructors like:
-        //   Foo::~Foo() {}
-        /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, // This also intends to capture the class name of method implementations but here the class has template
-        // parameters, so it can't be a namespace (until C++ adds generic namespaces).
-        /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
-      ],
-      keyword: keyword,
-      number: {
-        pattern:
-          /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
-        greedy: true
-      },
-      operator:
-        />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
-      boolean: /\b(?:false|true)\b/
-    });
-    Prism.languages.insertBefore('cpp', 'string', {
-      module: {
-        // https://en.cppreference.com/w/cpp/language/modules
-        pattern: RegExp(
-          /(\b(?:import|module)\s+)/.source +
-            '(?:' + // header-name
-            /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source +
-            '|' + // module name or partition or both
-            /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(
-              /<mod-name>/g,
-              function () {
-                return modName
-              }
-            ) +
-            ')'
-        ),
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          string: /^[<"][\s\S]+/,
-          operator: /:/,
-          punctuation: /\./
-        }
-      },
-      'raw-string': {
-        pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
-        alias: 'string',
-        greedy: true
-      }
-    });
-    Prism.languages.insertBefore('cpp', 'keyword', {
-      'generic-function': {
-        pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
-        inside: {
-          function: /^\w+/,
-          generic: {
-            pattern: /<[\s\S]+/,
-            alias: 'class-name',
-            inside: Prism.languages.cpp
-          }
-        }
-      }
-    });
-    Prism.languages.insertBefore('cpp', 'operator', {
-      'double-colon': {
-        pattern: /::/,
-        alias: 'punctuation'
-      }
-    });
-    Prism.languages.insertBefore('cpp', 'class-name', {
-      // the base clause is an optional list of parent classes
-      // https://en.cppreference.com/w/cpp/language/class
-      'base-clause': {
-        pattern:
-          /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
-        lookbehind: true,
-        greedy: true,
-        inside: Prism.languages.extend('cpp', {})
-      }
-    });
-    Prism.languages.insertBefore(
-      'inside',
-      'double-colon',
-      {
-        // All untokenized words that are not namespaces should be class names
-        'class-name': /\b[a-z_]\w*\b(?!\s*::)/i
-      },
-      Prism.languages.cpp['base-clause']
-    );
-  })(Prism);
+var cpp_1;
+var hasRequiredCpp;
+
+function requireCpp () {
+	if (hasRequiredCpp) return cpp_1;
+	hasRequiredCpp = 1;
+	var refractorC = c_1;
+	cpp_1 = cpp;
+	cpp.displayName = 'cpp';
+	cpp.aliases = [];
+	function cpp(Prism) {
+	  Prism.register(refractorC)
+	  ;(function (Prism) {
+	    var keyword =
+	      /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/;
+	    var modName = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(
+	      /<keyword>/g,
+	      function () {
+	        return keyword.source
+	      }
+	    );
+	    Prism.languages.cpp = Prism.languages.extend('c', {
+	      'class-name': [
+	        {
+	          pattern: RegExp(
+	            /(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(
+	              /<keyword>/g,
+	              function () {
+	                return keyword.source
+	              }
+	            )
+	          ),
+	          lookbehind: true
+	        }, // This is intended to capture the class name of method implementations like:
+	        //   void foo::bar() const {}
+	        // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
+	        // it starts with an uppercase letter. This approximation should give decent results.
+	        /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, // This will capture the class name before destructors like:
+	        //   Foo::~Foo() {}
+	        /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, // This also intends to capture the class name of method implementations but here the class has template
+	        // parameters, so it can't be a namespace (until C++ adds generic namespaces).
+	        /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
+	      ],
+	      keyword: keyword,
+	      number: {
+	        pattern:
+	          /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
+	        greedy: true
+	      },
+	      operator:
+	        />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
+	      boolean: /\b(?:false|true)\b/
+	    });
+	    Prism.languages.insertBefore('cpp', 'string', {
+	      module: {
+	        // https://en.cppreference.com/w/cpp/language/modules
+	        pattern: RegExp(
+	          /(\b(?:import|module)\s+)/.source +
+	            '(?:' + // header-name
+	            /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source +
+	            '|' + // module name or partition or both
+	            /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(
+	              /<mod-name>/g,
+	              function () {
+	                return modName
+	              }
+	            ) +
+	            ')'
+	        ),
+	        lookbehind: true,
+	        greedy: true,
+	        inside: {
+	          string: /^[<"][\s\S]+/,
+	          operator: /:/,
+	          punctuation: /\./
+	        }
+	      },
+	      'raw-string': {
+	        pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
+	        alias: 'string',
+	        greedy: true
+	      }
+	    });
+	    Prism.languages.insertBefore('cpp', 'keyword', {
+	      'generic-function': {
+	        pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
+	        inside: {
+	          function: /^\w+/,
+	          generic: {
+	            pattern: /<[\s\S]+/,
+	            alias: 'class-name',
+	            inside: Prism.languages.cpp
+	          }
+	        }
+	      }
+	    });
+	    Prism.languages.insertBefore('cpp', 'operator', {
+	      'double-colon': {
+	        pattern: /::/,
+	        alias: 'punctuation'
+	      }
+	    });
+	    Prism.languages.insertBefore('cpp', 'class-name', {
+	      // the base clause is an optional list of parent classes
+	      // https://en.cppreference.com/w/cpp/language/class
+	      'base-clause': {
+	        pattern:
+	          /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
+	        lookbehind: true,
+	        greedy: true,
+	        inside: Prism.languages.extend('cpp', {})
+	      }
+	    });
+	    Prism.languages.insertBefore(
+	      'inside',
+	      'double-colon',
+	      {
+	        // All untokenized words that are not namespaces should be class names
+	        'class-name': /\b[a-z_]\w*\b(?!\s*::)/i
+	      },
+	      Prism.languages.cpp['base-clause']
+	    );
+	  })(Prism);
+	}
+	return cpp_1;
 }
 
-var refractorCpp$1 = cpp_1;
+var refractorCpp$1 = requireCpp();
 var arduino_1 = arduino;
 arduino.displayName = 'arduino';
 arduino.aliases = ['ino'];
@@ -6216,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*@.*%>/,
@@ -6997,59 +7014,68 @@ 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;
 
-var bash_1 = bash;
+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;
 bash.displayName = 'bash';
 bash.aliases = ['shell'];
 function bash(Prism) {
@@ -7628,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;
@@ -7873,7 +7908,7 @@ function cfscript(Prism) {
   Prism.languages.cfc = Prism.languages['cfscript'];
 }
 
-var refractorCpp = cpp_1;
+var refractorCpp = requireCpp();
 var chaiscript_1 = chaiscript;
 chaiscript.displayName = 'chaiscript';
 chaiscript.aliases = [];
@@ -8195,813 +8230,883 @@ function coffeescript(Prism) {
   })(Prism);
 }
 
-var 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;
+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 = coq;
-coq.displayName = 'coq';
-coq.aliases = [];
-function coq(Prism) {
+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);
+	    // 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 = ruby;
-ruby.displayName = 'ruby';
-ruby.aliases = ['rb'];
-function ruby(Prism) {
+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);
+	    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 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
-      }
-    });
-  })(Prism);
+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 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,
-        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);
+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) {
+	    /**
+	     * @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 csp_1 = csp;
-csp.displayName = 'csp';
-csp.aliases = [];
-function csp(Prism) {
+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) {
-    /**
-     * @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 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 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);
-}
+var csv_1;
+var hasRequiredCsv;
 
-var csv_1 = csv;
-csv.displayName = 'csv';
-csv.aliases = [];
-function csv(Prism) {
-  // https://tools.ietf.org/html/rfc4180
-  Prism.languages.csv = {
-    value: /[^\r\n,"]+|"(?:[^"]|"")*"(?!")/,
-    punctuation: /,/
-  };
+function requireCsv () {
+	if (hasRequiredCsv) return csv_1;
+	hasRequiredCsv = 1;
+
+	csv_1 = csv;
+	csv.displayName = 'csv';
+	csv.aliases = [];
+	function csv(Prism) {
+	  // https://tools.ietf.org/html/rfc4180
+	  Prism.languages.csv = {
+	    value: /[^\r\n,"]+|"(?:[^"]|"")*"(?!")/,
+	    punctuation: /,/
+	  };
+	}
+	return csv_1;
 }
 
 var cypher_1;
@@ -9053,90 +9158,99 @@ function requireCypher () {
 	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;
@@ -9232,224 +9346,260 @@ function requireDart () {
 	return dart_1;
 }
 
-var dataweave_1 = dataweave;
-dataweave.displayName = 'dataweave';
-dataweave.aliases = [];
-function dataweave(Prism) {
+var dataweave_1;
+var hasRequiredDataweave;
+
+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;
+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;
+var hasRequiredDhall;
+
+function requireDhall () {
+	if (hasRequiredDhall) return dhall_1;
+	hasRequiredDhall = 1;
+
+	dhall_1 = dhall;
+	dhall.displayName = 'dhall';
+	dhall.aliases = [];
+	function dhall(Prism) {
+	  // ABNF grammar:
+	  // https://github.com/dhall-lang/dhall-lang/blob/master/standard/dhall.abnf
+	  Prism.languages.dhall = {
+	    // Multi-line comments can be nested. E.g. {- foo {- bar -} -}
+	    // The multi-line pattern is essentially this:
+	    //   \{-(?:[^-{]|-(?!\})|\{(?!-)|<SELF>)*-\}
+	    comment:
+	      /--.*|\{-(?:[^-{]|-(?!\})|\{(?!-)|\{-(?:[^-{]|-(?!\})|\{(?!-))*-\})*-\}/,
+	    string: {
+	      pattern: /"(?:[^"\\]|\\.)*"|''(?:[^']|'(?!')|'''|''\$\{)*''(?!'|\$)/,
+	      greedy: true,
+	      inside: {
+	        interpolation: {
+	          pattern: /\$\{[^{}]*\}/,
+	          inside: {
+	            expression: {
+	              pattern: /(^\$\{)[\s\S]+(?=\}$)/,
+	              lookbehind: true,
+	              alias: 'language-dhall',
+	              inside: null // see blow
+	            },
+	            punctuation: /\$\{|\}/
+	          }
+	        }
+	      }
+	    },
+	    label: {
+	      pattern: /`[^`]*`/,
+	      greedy: true
+	    },
+	    url: {
+	      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L596
+	      pattern:
+	        /\bhttps?:\/\/[\w.:%!$&'*+;=@~-]+(?:\/[\w.:%!$&'*+;=@~-]*)*(?:\?[/?\w.:%!$&'*+;=@~-]*)?/,
+	      greedy: true
+	    },
+	    env: {
+	      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L661
+	      pattern: /\benv:(?:(?!\d)\w+|"(?:[^"\\=]|\\.)*")/,
+	      greedy: true,
+	      inside: {
+	        function: /^env/,
+	        operator: /^:/,
+	        variable: /[\s\S]+/
+	      }
+	    },
+	    hash: {
+	      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L725
+	      pattern: /\bsha256:[\da-fA-F]{64}\b/,
+	      inside: {
+	        function: /sha256/,
+	        operator: /:/,
+	        number: /[\da-fA-F]{64}/
+	      }
+	    },
+	    // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L359
+	    keyword:
+	      /\b(?:as|assert|else|forall|if|in|let|merge|missing|then|toMap|using|with)\b|\u2200/,
+	    builtin: /\b(?:None|Some)\b/,
+	    boolean: /\b(?:False|True)\b/,
+	    number:
+	      /\bNaN\b|-?\bInfinity\b|[+-]?\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/,
+	    operator:
+	      /\/\\|\/\/\\\\|&&|\|\||===|[!=]=|\/\/|->|\+\+|::|[+*#@=:?<>|\\\u2227\u2a53\u2261\u2afd\u03bb\u2192]/,
+	    punctuation: /\.\.|[{}\[\](),./]/,
+	    // we'll just assume that every capital word left is a type name
+	    'class-name': /\b[A-Z]\w*\b/
+	  };
+	  Prism.languages.dhall.string.inside.interpolation.inside.expression.inside =
+	    Prism.languages.dhall;
+	}
+	return dhall_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 diff_1;
+var hasRequiredDiff;
 
-var dhall_1 = dhall;
-dhall.displayName = 'dhall';
-dhall.aliases = [];
-function dhall(Prism) {
-  // ABNF grammar:
-  // https://github.com/dhall-lang/dhall-lang/blob/master/standard/dhall.abnf
-  Prism.languages.dhall = {
-    // Multi-line comments can be nested. E.g. {- foo {- bar -} -}
-    // The multi-line pattern is essentially this:
-    //   \{-(?:[^-{]|-(?!\})|\{(?!-)|<SELF>)*-\}
-    comment:
-      /--.*|\{-(?:[^-{]|-(?!\})|\{(?!-)|\{-(?:[^-{]|-(?!\})|\{(?!-))*-\})*-\}/,
-    string: {
-      pattern: /"(?:[^"\\]|\\.)*"|''(?:[^']|'(?!')|'''|''\$\{)*''(?!'|\$)/,
-      greedy: true,
-      inside: {
-        interpolation: {
-          pattern: /\$\{[^{}]*\}/,
-          inside: {
-            expression: {
-              pattern: /(^\$\{)[\s\S]+(?=\}$)/,
-              lookbehind: true,
-              alias: 'language-dhall',
-              inside: null // see blow
-            },
-            punctuation: /\$\{|\}/
-          }
-        }
-      }
-    },
-    label: {
-      pattern: /`[^`]*`/,
-      greedy: true
-    },
-    url: {
-      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L596
-      pattern:
-        /\bhttps?:\/\/[\w.:%!$&'*+;=@~-]+(?:\/[\w.:%!$&'*+;=@~-]*)*(?:\?[/?\w.:%!$&'*+;=@~-]*)?/,
-      greedy: true
-    },
-    env: {
-      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L661
-      pattern: /\benv:(?:(?!\d)\w+|"(?:[^"\\=]|\\.)*")/,
-      greedy: true,
-      inside: {
-        function: /^env/,
-        operator: /^:/,
-        variable: /[\s\S]+/
-      }
-    },
-    hash: {
-      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L725
-      pattern: /\bsha256:[\da-fA-F]{64}\b/,
-      inside: {
-        function: /sha256/,
-        operator: /:/,
-        number: /[\da-fA-F]{64}/
-      }
-    },
-    // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L359
-    keyword:
-      /\b(?:as|assert|else|forall|if|in|let|merge|missing|then|toMap|using|with)\b|\u2200/,
-    builtin: /\b(?:None|Some)\b/,
-    boolean: /\b(?:False|True)\b/,
-    number:
-      /\bNaN\b|-?\bInfinity\b|[+-]?\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/,
-    operator:
-      /\/\\|\/\/\\\\|&&|\|\||===|[!=]=|\/\/|->|\+\+|::|[+*#@=:?<>|\\\u2227\u2a53\u2261\u2afd\u03bb\u2192]/,
-    punctuation: /\.\.|[{}\[\](),./]/,
-    // we'll just assume that every capital word left is a type name
-    'class-name': /\b[A-Z]\w*\b/
-  };
-  Prism.languages.dhall.string.inside.interpolation.inside.expression.inside =
-    Prism.languages.dhall;
-}
+function requireDiff () {
+	if (hasRequiredDiff) return diff_1;
+	hasRequiredDiff = 1;
 
-var diff_1 = diff;
-diff.displayName = 'diff';
-diff.aliases = [];
-function diff(Prism) {
+	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;
@@ -9564,335 +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;
+	return docker_1;
 }
 
-var django_1;
-var hasRequiredDjango;
+var dot_1;
+var hasRequiredDot;
 
-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+/,
+function requireDot () {
+	if (hasRequiredDot) return dot_1;
+	hasRequiredDot = 1;
+
+	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: 'keyword'
+	        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
 	      },
-	      delimiter: {
-	        pattern: /^\{[{%][+-]?|[+-]?[}%]\}$/,
-	        alias: 'punctuation'
+	      'graph-name': {
+	        pattern: withID(
+	          /(\b(?:digraph|graph|subgraph)[ \t\r\n]+)<ID>/.source,
+	          'i'
+	        ),
+	        lookbehind: true,
+	        greedy: true,
+	        alias: 'class-name',
+	        inside: IDInside
 	      },
-	      string: {
-	        pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
-	        greedy: true
+	      'attr-value': {
+	        pattern: withID(/(=[ \t\r\n]*)<ID>/.source),
+	        lookbehind: true,
+	        greedy: true,
+	        inside: IDInside
 	      },
-	      filter: {
-	        pattern: /(\|)\w+/,
+	      'attr-name': {
+	        pattern: withID(/([\[;, \t\r\n])<ID>(?=[ \t\r\n]*=)/.source),
 	        lookbehind: true,
-	        alias: 'function'
+	        greedy: true,
+	        inside: IDInside
 	      },
-	      test: {
-	        pattern: /(\bis\s+(?:not\s+)?)(?!not\b)\w+/,
+	      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: 'function'
+	        alias: 'builtin'
 	      },
-	      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: /[{}[\](),.:;]/
+	      node: {
+	        pattern: withID(/(^|[^-.\w\x80-\uFFFF\\])<ID>/.source),
+	        lookbehind: true,
+	        greedy: true,
+	        inside: IDInside
+	      },
+	      operator: /[=:]|-[->]/,
+	      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.languages.gv = Prism.languages.dot;
 	  })(Prism);
 	}
-	return django_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 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);
-}
-
-var 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);
+	return dot_1;
 }
 
 var ebnf_1;
@@ -9930,37 +10107,46 @@ function requireEbnf () {
 	return ebnf_1;
 }
 
-var editorconfig_1 = editorconfig;
-editorconfig.displayName = 'editorconfig';
-editorconfig.aliases = [];
-function editorconfig(Prism) {
-  Prism.languages.editorconfig = {
-    // https://editorconfig-specification.readthedocs.io
-    comment: /[;#].*/,
-    section: {
-      pattern: /(^[ \t]*)\[.+\]/m,
-      lookbehind: true,
-      alias: 'selector',
-      inside: {
-        regex: /\\\\[\[\]{},!?.*]/,
-        // Escape special characters with '\\'
-        operator: /[!?]|\.\.|\*{1,2}/,
-        punctuation: /[\[\]{},]/
-      }
-    },
-    key: {
-      pattern: /(^[ \t]*)[^\s=]+(?=[ \t]*=)/m,
-      lookbehind: true,
-      alias: 'attr-name'
-    },
-    value: {
-      pattern: /=.*/,
-      alias: 'attr-value',
-      inside: {
-        punctuation: /^=/
-      }
-    }
-  };
+var editorconfig_1;
+var hasRequiredEditorconfig;
+
+function requireEditorconfig () {
+	if (hasRequiredEditorconfig) return editorconfig_1;
+	hasRequiredEditorconfig = 1;
+
+	editorconfig_1 = editorconfig;
+	editorconfig.displayName = 'editorconfig';
+	editorconfig.aliases = [];
+	function editorconfig(Prism) {
+	  Prism.languages.editorconfig = {
+	    // https://editorconfig-specification.readthedocs.io
+	    comment: /[;#].*/,
+	    section: {
+	      pattern: /(^[ \t]*)\[.+\]/m,
+	      lookbehind: true,
+	      alias: 'selector',
+	      inside: {
+	        regex: /\\\\[\[\]{},!?.*]/,
+	        // Escape special characters with '\\'
+	        operator: /[!?]|\.\.|\*{1,2}/,
+	        punctuation: /[\[\]{},]/
+	      }
+	    },
+	    key: {
+	      pattern: /(^[ \t]*)[^\s=]+(?=[ \t]*=)/m,
+	      lookbehind: true,
+	      alias: 'attr-name'
+	    },
+	    value: {
+	      pattern: /=.*/,
+	      alias: 'attr-value',
+	      inside: {
+	        punctuation: /^=/
+	      }
+	    }
+	  };
+	}
+	return editorconfig_1;
 }
 
 var eiffel_1;
@@ -10237,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';
@@ -12719,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 = [];
@@ -25155,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 = [];
@@ -27913,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);
@@ -27922,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);
@@ -27934,28 +28120,28 @@ 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(cpp_1);
-refractor.register(crystal_1);
-refractor.register(csharp_1);
-refractor.register(cshtml_1);
-refractor.register(csp_1);
-refractor.register(cssExtras_1);
-refractor.register(csv_1);
+refractor.register(requireConcurnas());
+refractor.register(requireCoq());
+refractor.register(requireCpp());
+refractor.register(requireCrystal());
+refractor.register(requireCsharp());
+refractor.register(requireCshtml());
+refractor.register(requireCsp());
+refractor.register(requireCssExtras());
+refractor.register(requireCsv());
 refractor.register(requireCypher());
-refractor.register(d_1);
+refractor.register(requireD());
 refractor.register(requireDart());
-refractor.register(dataweave_1);
-refractor.register(dax_1);
-refractor.register(dhall_1);
-refractor.register(diff_1);
+refractor.register(requireDataweave());
+refractor.register(requireDax());
+refractor.register(requireDhall());
+refractor.register(requireDiff());
 refractor.register(requireDjango());
-refractor.register(dnsZoneFile_1);
-refractor.register(docker_1);
-refractor.register(dot_1);
+refractor.register(requireDnsZoneFile());
+refractor.register(requireDocker());
+refractor.register(requireDot());
 refractor.register(requireEbnf());
-refractor.register(editorconfig_1);
+refractor.register(requireEditorconfig());
 refractor.register(requireEiffel());
 refractor.register(requireEjs());
 refractor.register(requireElixir());
@@ -28103,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());
@@ -38930,10 +39116,34 @@ 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;
+/**
+ * 预处理 MDX 内容，转义可能被误认为 HTML 标签的内容
+ * @param content MDX 内容
+ * @returns 处理后的内容
+ */
+function preprocessMdxContent(content) {
+  // 匹配可能被误认为 HTML 标签的模式，如 <数字、<字母但不是真正的组件标签
+  // 真正的 React 组件标签应该以大写字母开头，如 <Component>
+  // HTML 标签以小写字母开头，如 <div>
+  // 需要排除正常的闭合标签 </Component>
+  return content.replace(/<(?!\/|[A-Z][a-zA-Z]*\b|[a-z][a-zA-Z0-9]*\b)/g, '&lt;');
+}
 // 辅助函数：格式化props
 function formatProps(props) {
   return Object.entries(props).map(function (_a) {
@@ -38953,7 +39163,7 @@ function formatProps(props) {
 }
 function renderMdx(mdxContent, scope, registeredComponents) {
   return __awaiter(this, void 0, void 0, function () {
-    var componentTagRegex, usedComponents, match, vf, XComponent;
+    var componentTagRegex, usedComponents, match, processedContent, vf, XComponent, e_1;
     return __generator(this, function (_a) {
       switch (_a.label) {
         case 0:
@@ -38965,7 +39175,8 @@ function renderMdx(mdxContent, scope, registeredComponents) {
           while ((match = componentTagRegex.exec(mdxContent)) !== null) {
             usedComponents.add(match[1]);
           }
-          return [4 /*yield*/, compile(mdxContent, {
+          processedContent = preprocessMdxContent(mdxContent);
+          return [4 /*yield*/, compile(processedContent, {
             outputFormat: "function-body",
             remarkPlugins: [[RemarkMath, {
               strict: true
@@ -38988,7 +39199,8 @@ function renderMdx(mdxContent, scope, registeredComponents) {
             scope: scope
           })];
         case 3:
-          _a.sent();
+          e_1 = _a.sent();
+          console.log(e_1, 'e');
           return [2 /*return*/, new Promise(function (resolve) {
             renderTimer = setTimeout(function () {
               resolve(/*#__PURE__*/React.createElement('div', {