@banyan_cloud/roots 1.0.110 → 1.0.111

package/dist/cjs/index.js

@@ -20694,134 +20694,126 @@ function c(Prism) {
   delete Prism.languages.c['boolean'];
 }
 
-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 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 refractorCpp$1 = requireCpp();
+var refractorCpp$1 = cpp_1;
 var arduino_1 = arduino;
 arduino.displayName = 'arduino';
 arduino.aliases = ['ino'];
@@ -21165,484 +21157,475 @@ function asmatmel(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) {
+var 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);
-	}
-	return csharp_1;
+    /**
+     * 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);
 }
 
-var refractorCsharp = requireCsharp();
+var refractorCsharp$1 = csharp_1;
 var aspnet_1 = aspnet;
 aspnet.displayName = 'aspnet';
 aspnet.aliases = [];
 function aspnet(Prism) {
-  Prism.register(refractorCsharp);
+  Prism.register(refractorCsharp$1);
   Prism.languages.aspnet = Prism.languages.extend('markup', {
     'page-directive': {
       pattern: /<%\s*@.*%>/,
@@ -22831,7 +22814,7 @@ function cfscript(Prism) {
   Prism.languages.cfc = Prism.languages['cfscript'];
 }
 
-var refractorCpp = requireCpp();
+var refractorCpp = cpp_1;
 var chaiscript_1 = chaiscript;
 chaiscript.displayName = 'chaiscript';
 chaiscript.aliases = [];
@@ -23004,1194 +22987,1088 @@ function cmake(Prism) {
   };
 }
 
-var cobol_1;
-var hasRequiredCobol;
-
-function requireCobol () {
-	if (hasRequiredCobol) return cobol_1;
-	hasRequiredCobol = 1;
-
-	cobol_1 = cobol;
-	cobol.displayName = 'cobol';
-	cobol.aliases = [];
-	function cobol(Prism) {
-	  Prism.languages.cobol = {
-	    comment: {
-	      pattern: /\*>.*|(^[ \t]*)\*.*/m,
-	      lookbehind: true,
-	      greedy: true
-	    },
-	    string: {
-	      pattern: /[xzgn]?(?:"(?:[^\r\n"]|"")*"(?!")|'(?:[^\r\n']|'')*'(?!'))/i,
-	      greedy: true
-	    },
-	    level: {
-	      pattern: /(^[ \t]*)\d+\b/m,
-	      lookbehind: true,
-	      greedy: true,
-	      alias: 'number'
-	    },
-	    'class-name': {
-	      // https://github.com/antlr/grammars-v4/blob/42edd5b687d183b5fa679e858a82297bd27141e7/cobol85/Cobol85.g4#L1015
-	      pattern:
-	        /(\bpic(?:ture)?\s+)(?:(?:[-\w$/,:*+<>]|\.(?!\s|$))(?:\(\d+\))?)+/i,
-	      lookbehind: true,
-	      inside: {
-	        number: {
-	          pattern: /(\()\d+/,
-	          lookbehind: true
-	        },
-	        punctuation: /[()]/
-	      }
-	    },
-	    keyword: {
-	      pattern:
-	        /(^|[^\w-])(?:ABORT|ACCEPT|ACCESS|ADD|ADDRESS|ADVANCING|AFTER|ALIGNED|ALL|ALPHABET|ALPHABETIC|ALPHABETIC-LOWER|ALPHABETIC-UPPER|ALPHANUMERIC|ALPHANUMERIC-EDITED|ALSO|ALTER|ALTERNATE|ANY|ARE|AREA|AREAS|AS|ASCENDING|ASCII|ASSIGN|ASSOCIATED-DATA|ASSOCIATED-DATA-LENGTH|AT|ATTRIBUTE|AUTHOR|AUTO|AUTO-SKIP|BACKGROUND-COLOR|BACKGROUND-COLOUR|BASIS|BEEP|BEFORE|BEGINNING|BELL|BINARY|BIT|BLANK|BLINK|BLOCK|BOTTOM|BOUNDS|BY|BYFUNCTION|BYTITLE|CALL|CANCEL|CAPABLE|CCSVERSION|CD|CF|CH|CHAINING|CHANGED|CHANNEL|CHARACTER|CHARACTERS|CLASS|CLASS-ID|CLOCK-UNITS|CLOSE|CLOSE-DISPOSITION|COBOL|CODE|CODE-SET|COL|COLLATING|COLUMN|COM-REG|COMMA|COMMITMENT|COMMON|COMMUNICATION|COMP|COMP-1|COMP-2|COMP-3|COMP-4|COMP-5|COMPUTATIONAL|COMPUTATIONAL-1|COMPUTATIONAL-2|COMPUTATIONAL-3|COMPUTATIONAL-4|COMPUTATIONAL-5|COMPUTE|CONFIGURATION|CONTAINS|CONTENT|CONTINUE|CONTROL|CONTROL-POINT|CONTROLS|CONVENTION|CONVERTING|COPY|CORR|CORRESPONDING|COUNT|CRUNCH|CURRENCY|CURSOR|DATA|DATA-BASE|DATE|DATE-COMPILED|DATE-WRITTEN|DAY|DAY-OF-WEEK|DBCS|DE|DEBUG-CONTENTS|DEBUG-ITEM|DEBUG-LINE|DEBUG-NAME|DEBUG-SUB-1|DEBUG-SUB-2|DEBUG-SUB-3|DEBUGGING|DECIMAL-POINT|DECLARATIVES|DEFAULT|DEFAULT-DISPLAY|DEFINITION|DELETE|DELIMITED|DELIMITER|DEPENDING|DESCENDING|DESTINATION|DETAIL|DFHRESP|DFHVALUE|DISABLE|DISK|DISPLAY|DISPLAY-1|DIVIDE|DIVISION|DONTCARE|DOUBLE|DOWN|DUPLICATES|DYNAMIC|EBCDIC|EGCS|EGI|ELSE|EMI|EMPTY-CHECK|ENABLE|END|END-ACCEPT|END-ADD|END-CALL|END-COMPUTE|END-DELETE|END-DIVIDE|END-EVALUATE|END-IF|END-MULTIPLY|END-OF-PAGE|END-PERFORM|END-READ|END-RECEIVE|END-RETURN|END-REWRITE|END-SEARCH|END-START|END-STRING|END-SUBTRACT|END-UNSTRING|END-WRITE|ENDING|ENTER|ENTRY|ENTRY-PROCEDURE|ENVIRONMENT|EOL|EOP|EOS|ERASE|ERROR|ESCAPE|ESI|EVALUATE|EVENT|EVERY|EXCEPTION|EXCLUSIVE|EXHIBIT|EXIT|EXPORT|EXTEND|EXTENDED|EXTERNAL|FD|FILE|FILE-CONTROL|FILLER|FINAL|FIRST|FOOTING|FOR|FOREGROUND-COLOR|FOREGROUND-COLOUR|FROM|FULL|FUNCTION|FUNCTION-POINTER|FUNCTIONNAME|GENERATE|GIVING|GLOBAL|GO|GOBACK|GRID|GROUP|HEADING|HIGH-VALUE|HIGH-VALUES|HIGHLIGHT|I-O|I-O-CONTROL|ID|IDENTIFICATION|IF|IMPLICIT|IMPORT|IN|INDEX|INDEXED|INDICATE|INITIAL|INITIALIZE|INITIATE|INPUT|INPUT-OUTPUT|INSPECT|INSTALLATION|INTEGER|INTO|INVALID|INVOKE|IS|JUST|JUSTIFIED|KANJI|KEPT|KEY|KEYBOARD|LABEL|LANGUAGE|LAST|LB|LD|LEADING|LEFT|LEFTLINE|LENGTH|LENGTH-CHECK|LIBACCESS|LIBPARAMETER|LIBRARY|LIMIT|LIMITS|LINAGE|LINAGE-COUNTER|LINE|LINE-COUNTER|LINES|LINKAGE|LIST|LOCAL|LOCAL-STORAGE|LOCK|LONG-DATE|LONG-TIME|LOW-VALUE|LOW-VALUES|LOWER|LOWLIGHT|MEMORY|MERGE|MESSAGE|MMDDYYYY|MODE|MODULES|MORE-LABELS|MOVE|MULTIPLE|MULTIPLY|NAMED|NATIONAL|NATIONAL-EDITED|NATIVE|NEGATIVE|NETWORK|NEXT|NO|NO-ECHO|NULL|NULLS|NUMBER|NUMERIC|NUMERIC-DATE|NUMERIC-EDITED|NUMERIC-TIME|OBJECT-COMPUTER|OCCURS|ODT|OF|OFF|OMITTED|ON|OPEN|OPTIONAL|ORDER|ORDERLY|ORGANIZATION|OTHER|OUTPUT|OVERFLOW|OVERLINE|OWN|PACKED-DECIMAL|PADDING|PAGE|PAGE-COUNTER|PASSWORD|PERFORM|PF|PH|PIC|PICTURE|PLUS|POINTER|PORT|POSITION|POSITIVE|PRINTER|PRINTING|PRIVATE|PROCEDURE|PROCEDURE-POINTER|PROCEDURES|PROCEED|PROCESS|PROGRAM|PROGRAM-ID|PROGRAM-LIBRARY|PROMPT|PURGE|QUEUE|QUOTE|QUOTES|RANDOM|RD|READ|READER|REAL|RECEIVE|RECEIVED|RECORD|RECORDING|RECORDS|RECURSIVE|REDEFINES|REEL|REF|REFERENCE|REFERENCES|RELATIVE|RELEASE|REMAINDER|REMARKS|REMOTE|REMOVAL|REMOVE|RENAMES|REPLACE|REPLACING|REPORT|REPORTING|REPORTS|REQUIRED|RERUN|RESERVE|RESET|RETURN|RETURN-CODE|RETURNING|REVERSE-VIDEO|REVERSED|REWIND|REWRITE|RF|RH|RIGHT|ROUNDED|RUN|SAME|SAVE|SCREEN|SD|SEARCH|SECTION|SECURE|SECURITY|SEGMENT|SEGMENT-LIMIT|SELECT|SEND|SENTENCE|SEPARATE|SEQUENCE|SEQUENTIAL|SET|SHARED|SHAREDBYALL|SHAREDBYRUNUNIT|SHARING|SHIFT-IN|SHIFT-OUT|SHORT-DATE|SIGN|SIZE|SORT|SORT-CONTROL|SORT-CORE-SIZE|SORT-FILE-SIZE|SORT-MERGE|SORT-MESSAGE|SORT-MODE-SIZE|SORT-RETURN|SOURCE|SOURCE-COMPUTER|SPACE|SPACES|SPECIAL-NAMES|STANDARD|STANDARD-1|STANDARD-2|START|STATUS|STOP|STRING|SUB-QUEUE-1|SUB-QUEUE-2|SUB-QUEUE-3|SUBTRACT|SUM|SUPPRESS|SYMBOL|SYMBOLIC|SYNC|SYNCHRONIZED|TABLE|TALLY|TALLYING|TAPE|TASK|TERMINAL|TERMINATE|TEST|TEXT|THEN|THREAD|THREAD-LOCAL|THROUGH|THRU|TIME|TIMER|TIMES|TITLE|TO|TODAYS-DATE|TODAYS-NAME|TOP|TRAILING|TRUNCATED|TYPE|TYPEDEF|UNDERLINE|UNIT|UNSTRING|UNTIL|UP|UPON|USAGE|USE|USING|VALUE|VALUES|VARYING|VIRTUAL|WAIT|WHEN|WHEN-COMPILED|WITH|WORDS|WORKING-STORAGE|WRITE|YEAR|YYYYDDD|YYYYMMDD|ZERO-FILL|ZEROES|ZEROS)(?![\w-])/i,
-	      lookbehind: true
-	    },
-	    boolean: {
-	      pattern: /(^|[^\w-])(?:false|true)(?![\w-])/i,
-	      lookbehind: true
-	    },
-	    number: {
-	      pattern:
-	        /(^|[^\w-])(?:[+-]?(?:(?:\d+(?:[.,]\d+)?|[.,]\d+)(?:e[+-]?\d+)?|zero))(?![\w-])/i,
-	      lookbehind: true
-	    },
-	    operator: [
-	      /<>|[<>]=?|[=+*/&]/,
-	      {
-	        pattern: /(^|[^\w-])(?:-|and|equal|greater|less|not|or|than)(?![\w-])/i,
-	        lookbehind: true
-	      }
-	    ],
-	    punctuation: /[.:,()]/
-	  };
-	}
-	return cobol_1;
+var cobol_1 = cobol;
+cobol.displayName = 'cobol';
+cobol.aliases = [];
+function cobol(Prism) {
+  Prism.languages.cobol = {
+    comment: {
+      pattern: /\*>.*|(^[ \t]*)\*.*/m,
+      lookbehind: true,
+      greedy: true
+    },
+    string: {
+      pattern: /[xzgn]?(?:"(?:[^\r\n"]|"")*"(?!")|'(?:[^\r\n']|'')*'(?!'))/i,
+      greedy: true
+    },
+    level: {
+      pattern: /(^[ \t]*)\d+\b/m,
+      lookbehind: true,
+      greedy: true,
+      alias: 'number'
+    },
+    'class-name': {
+      // https://github.com/antlr/grammars-v4/blob/42edd5b687d183b5fa679e858a82297bd27141e7/cobol85/Cobol85.g4#L1015
+      pattern:
+        /(\bpic(?:ture)?\s+)(?:(?:[-\w$/,:*+<>]|\.(?!\s|$))(?:\(\d+\))?)+/i,
+      lookbehind: true,
+      inside: {
+        number: {
+          pattern: /(\()\d+/,
+          lookbehind: true
+        },
+        punctuation: /[()]/
+      }
+    },
+    keyword: {
+      pattern:
+        /(^|[^\w-])(?:ABORT|ACCEPT|ACCESS|ADD|ADDRESS|ADVANCING|AFTER|ALIGNED|ALL|ALPHABET|ALPHABETIC|ALPHABETIC-LOWER|ALPHABETIC-UPPER|ALPHANUMERIC|ALPHANUMERIC-EDITED|ALSO|ALTER|ALTERNATE|ANY|ARE|AREA|AREAS|AS|ASCENDING|ASCII|ASSIGN|ASSOCIATED-DATA|ASSOCIATED-DATA-LENGTH|AT|ATTRIBUTE|AUTHOR|AUTO|AUTO-SKIP|BACKGROUND-COLOR|BACKGROUND-COLOUR|BASIS|BEEP|BEFORE|BEGINNING|BELL|BINARY|BIT|BLANK|BLINK|BLOCK|BOTTOM|BOUNDS|BY|BYFUNCTION|BYTITLE|CALL|CANCEL|CAPABLE|CCSVERSION|CD|CF|CH|CHAINING|CHANGED|CHANNEL|CHARACTER|CHARACTERS|CLASS|CLASS-ID|CLOCK-UNITS|CLOSE|CLOSE-DISPOSITION|COBOL|CODE|CODE-SET|COL|COLLATING|COLUMN|COM-REG|COMMA|COMMITMENT|COMMON|COMMUNICATION|COMP|COMP-1|COMP-2|COMP-3|COMP-4|COMP-5|COMPUTATIONAL|COMPUTATIONAL-1|COMPUTATIONAL-2|COMPUTATIONAL-3|COMPUTATIONAL-4|COMPUTATIONAL-5|COMPUTE|CONFIGURATION|CONTAINS|CONTENT|CONTINUE|CONTROL|CONTROL-POINT|CONTROLS|CONVENTION|CONVERTING|COPY|CORR|CORRESPONDING|COUNT|CRUNCH|CURRENCY|CURSOR|DATA|DATA-BASE|DATE|DATE-COMPILED|DATE-WRITTEN|DAY|DAY-OF-WEEK|DBCS|DE|DEBUG-CONTENTS|DEBUG-ITEM|DEBUG-LINE|DEBUG-NAME|DEBUG-SUB-1|DEBUG-SUB-2|DEBUG-SUB-3|DEBUGGING|DECIMAL-POINT|DECLARATIVES|DEFAULT|DEFAULT-DISPLAY|DEFINITION|DELETE|DELIMITED|DELIMITER|DEPENDING|DESCENDING|DESTINATION|DETAIL|DFHRESP|DFHVALUE|DISABLE|DISK|DISPLAY|DISPLAY-1|DIVIDE|DIVISION|DONTCARE|DOUBLE|DOWN|DUPLICATES|DYNAMIC|EBCDIC|EGCS|EGI|ELSE|EMI|EMPTY-CHECK|ENABLE|END|END-ACCEPT|END-ADD|END-CALL|END-COMPUTE|END-DELETE|END-DIVIDE|END-EVALUATE|END-IF|END-MULTIPLY|END-OF-PAGE|END-PERFORM|END-READ|END-RECEIVE|END-RETURN|END-REWRITE|END-SEARCH|END-START|END-STRING|END-SUBTRACT|END-UNSTRING|END-WRITE|ENDING|ENTER|ENTRY|ENTRY-PROCEDURE|ENVIRONMENT|EOL|EOP|EOS|ERASE|ERROR|ESCAPE|ESI|EVALUATE|EVENT|EVERY|EXCEPTION|EXCLUSIVE|EXHIBIT|EXIT|EXPORT|EXTEND|EXTENDED|EXTERNAL|FD|FILE|FILE-CONTROL|FILLER|FINAL|FIRST|FOOTING|FOR|FOREGROUND-COLOR|FOREGROUND-COLOUR|FROM|FULL|FUNCTION|FUNCTION-POINTER|FUNCTIONNAME|GENERATE|GIVING|GLOBAL|GO|GOBACK|GRID|GROUP|HEADING|HIGH-VALUE|HIGH-VALUES|HIGHLIGHT|I-O|I-O-CONTROL|ID|IDENTIFICATION|IF|IMPLICIT|IMPORT|IN|INDEX|INDEXED|INDICATE|INITIAL|INITIALIZE|INITIATE|INPUT|INPUT-OUTPUT|INSPECT|INSTALLATION|INTEGER|INTO|INVALID|INVOKE|IS|JUST|JUSTIFIED|KANJI|KEPT|KEY|KEYBOARD|LABEL|LANGUAGE|LAST|LB|LD|LEADING|LEFT|LEFTLINE|LENGTH|LENGTH-CHECK|LIBACCESS|LIBPARAMETER|LIBRARY|LIMIT|LIMITS|LINAGE|LINAGE-COUNTER|LINE|LINE-COUNTER|LINES|LINKAGE|LIST|LOCAL|LOCAL-STORAGE|LOCK|LONG-DATE|LONG-TIME|LOW-VALUE|LOW-VALUES|LOWER|LOWLIGHT|MEMORY|MERGE|MESSAGE|MMDDYYYY|MODE|MODULES|MORE-LABELS|MOVE|MULTIPLE|MULTIPLY|NAMED|NATIONAL|NATIONAL-EDITED|NATIVE|NEGATIVE|NETWORK|NEXT|NO|NO-ECHO|NULL|NULLS|NUMBER|NUMERIC|NUMERIC-DATE|NUMERIC-EDITED|NUMERIC-TIME|OBJECT-COMPUTER|OCCURS|ODT|OF|OFF|OMITTED|ON|OPEN|OPTIONAL|ORDER|ORDERLY|ORGANIZATION|OTHER|OUTPUT|OVERFLOW|OVERLINE|OWN|PACKED-DECIMAL|PADDING|PAGE|PAGE-COUNTER|PASSWORD|PERFORM|PF|PH|PIC|PICTURE|PLUS|POINTER|PORT|POSITION|POSITIVE|PRINTER|PRINTING|PRIVATE|PROCEDURE|PROCEDURE-POINTER|PROCEDURES|PROCEED|PROCESS|PROGRAM|PROGRAM-ID|PROGRAM-LIBRARY|PROMPT|PURGE|QUEUE|QUOTE|QUOTES|RANDOM|RD|READ|READER|REAL|RECEIVE|RECEIVED|RECORD|RECORDING|RECORDS|RECURSIVE|REDEFINES|REEL|REF|REFERENCE|REFERENCES|RELATIVE|RELEASE|REMAINDER|REMARKS|REMOTE|REMOVAL|REMOVE|RENAMES|REPLACE|REPLACING|REPORT|REPORTING|REPORTS|REQUIRED|RERUN|RESERVE|RESET|RETURN|RETURN-CODE|RETURNING|REVERSE-VIDEO|REVERSED|REWIND|REWRITE|RF|RH|RIGHT|ROUNDED|RUN|SAME|SAVE|SCREEN|SD|SEARCH|SECTION|SECURE|SECURITY|SEGMENT|SEGMENT-LIMIT|SELECT|SEND|SENTENCE|SEPARATE|SEQUENCE|SEQUENTIAL|SET|SHARED|SHAREDBYALL|SHAREDBYRUNUNIT|SHARING|SHIFT-IN|SHIFT-OUT|SHORT-DATE|SIGN|SIZE|SORT|SORT-CONTROL|SORT-CORE-SIZE|SORT-FILE-SIZE|SORT-MERGE|SORT-MESSAGE|SORT-MODE-SIZE|SORT-RETURN|SOURCE|SOURCE-COMPUTER|SPACE|SPACES|SPECIAL-NAMES|STANDARD|STANDARD-1|STANDARD-2|START|STATUS|STOP|STRING|SUB-QUEUE-1|SUB-QUEUE-2|SUB-QUEUE-3|SUBTRACT|SUM|SUPPRESS|SYMBOL|SYMBOLIC|SYNC|SYNCHRONIZED|TABLE|TALLY|TALLYING|TAPE|TASK|TERMINAL|TERMINATE|TEST|TEXT|THEN|THREAD|THREAD-LOCAL|THROUGH|THRU|TIME|TIMER|TIMES|TITLE|TO|TODAYS-DATE|TODAYS-NAME|TOP|TRAILING|TRUNCATED|TYPE|TYPEDEF|UNDERLINE|UNIT|UNSTRING|UNTIL|UP|UPON|USAGE|USE|USING|VALUE|VALUES|VARYING|VIRTUAL|WAIT|WHEN|WHEN-COMPILED|WITH|WORDS|WORKING-STORAGE|WRITE|YEAR|YYYYDDD|YYYYMMDD|ZERO-FILL|ZEROES|ZEROS)(?![\w-])/i,
+      lookbehind: true
+    },
+    boolean: {
+      pattern: /(^|[^\w-])(?:false|true)(?![\w-])/i,
+      lookbehind: true
+    },
+    number: {
+      pattern:
+        /(^|[^\w-])(?:[+-]?(?:(?:\d+(?:[.,]\d+)?|[.,]\d+)(?:e[+-]?\d+)?|zero))(?![\w-])/i,
+      lookbehind: true
+    },
+    operator: [
+      /<>|[<>]=?|[=+*/&]/,
+      {
+        pattern: /(^|[^\w-])(?:-|and|equal|greater|less|not|or|than)(?![\w-])/i,
+        lookbehind: true
+      }
+    ],
+    punctuation: /[.:,()]/
+  };
 }
 
-var coffeescript_1;
-var hasRequiredCoffeescript;
-
-function requireCoffeescript () {
-	if (hasRequiredCoffeescript) return coffeescript_1;
-	hasRequiredCoffeescript = 1;
-
-	coffeescript_1 = coffeescript;
-	coffeescript.displayName = 'coffeescript';
-	coffeescript.aliases = ['coffee'];
-	function coffeescript(Prism) {
+var coffeescript_1 = coffeescript;
+coffeescript.displayName = 'coffeescript';
+coffeescript.aliases = ['coffee'];
+function coffeescript(Prism) {
 (function (Prism) {
-	    // Ignore comments starting with { to privilege string interpolation highlighting
-	    var comment = /#(?!\{).+/;
-	    var interpolation = {
-	      pattern: /#\{[^}]+\}/,
-	      alias: 'variable'
-	    };
-	    Prism.languages.coffeescript = Prism.languages.extend('javascript', {
-	      comment: comment,
-	      string: [
-	        // Strings are multiline
-	        {
-	          pattern: /'(?:\\[\s\S]|[^\\'])*'/,
-	          greedy: true
-	        },
-	        {
-	          // Strings are multiline
-	          pattern: /"(?:\\[\s\S]|[^\\"])*"/,
-	          greedy: true,
-	          inside: {
-	            interpolation: interpolation
-	          }
-	        }
-	      ],
-	      keyword:
-	        /\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/,
-	      'class-member': {
-	        pattern: /@(?!\d)\w+/,
-	        alias: 'variable'
-	      }
-	    });
-	    Prism.languages.insertBefore('coffeescript', 'comment', {
-	      'multiline-comment': {
-	        pattern: /###[\s\S]+?###/,
-	        alias: 'comment'
-	      },
-	      // Block regexp can contain comments and interpolation
-	      'block-regex': {
-	        pattern: /\/{3}[\s\S]*?\/{3}/,
-	        alias: 'regex',
-	        inside: {
-	          comment: comment,
-	          interpolation: interpolation
-	        }
-	      }
-	    });
-	    Prism.languages.insertBefore('coffeescript', 'string', {
-	      'inline-javascript': {
-	        pattern: /`(?:\\[\s\S]|[^\\`])*`/,
-	        inside: {
-	          delimiter: {
-	            pattern: /^`|`$/,
-	            alias: 'punctuation'
-	          },
-	          script: {
-	            pattern: /[\s\S]+/,
-	            alias: 'language-javascript',
-	            inside: Prism.languages.javascript
-	          }
-	        }
-	      },
-	      // Block strings
-	      'multiline-string': [
-	        {
-	          pattern: /'''[\s\S]*?'''/,
-	          greedy: true,
-	          alias: 'string'
-	        },
-	        {
-	          pattern: /"""[\s\S]*?"""/,
-	          greedy: true,
-	          alias: 'string',
-	          inside: {
-	            interpolation: interpolation
-	          }
-	        }
-	      ]
-	    });
-	    Prism.languages.insertBefore('coffeescript', 'keyword', {
-	      // Object property
-	      property: /(?!\d)\w+(?=\s*:(?!:))/
-	    });
-	    delete Prism.languages.coffeescript['template-string'];
-	    Prism.languages.coffee = Prism.languages.coffeescript;
-	  })(Prism);
-	}
-	return coffeescript_1;
+    // Ignore comments starting with { to privilege string interpolation highlighting
+    var comment = /#(?!\{).+/;
+    var interpolation = {
+      pattern: /#\{[^}]+\}/,
+      alias: 'variable'
+    };
+    Prism.languages.coffeescript = Prism.languages.extend('javascript', {
+      comment: comment,
+      string: [
+        // Strings are multiline
+        {
+          pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+          greedy: true
+        },
+        {
+          // Strings are multiline
+          pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+          greedy: true,
+          inside: {
+            interpolation: interpolation
+          }
+        }
+      ],
+      keyword:
+        /\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/,
+      'class-member': {
+        pattern: /@(?!\d)\w+/,
+        alias: 'variable'
+      }
+    });
+    Prism.languages.insertBefore('coffeescript', 'comment', {
+      'multiline-comment': {
+        pattern: /###[\s\S]+?###/,
+        alias: 'comment'
+      },
+      // Block regexp can contain comments and interpolation
+      'block-regex': {
+        pattern: /\/{3}[\s\S]*?\/{3}/,
+        alias: 'regex',
+        inside: {
+          comment: comment,
+          interpolation: interpolation
+        }
+      }
+    });
+    Prism.languages.insertBefore('coffeescript', 'string', {
+      'inline-javascript': {
+        pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+        inside: {
+          delimiter: {
+            pattern: /^`|`$/,
+            alias: 'punctuation'
+          },
+          script: {
+            pattern: /[\s\S]+/,
+            alias: 'language-javascript',
+            inside: Prism.languages.javascript
+          }
+        }
+      },
+      // Block strings
+      'multiline-string': [
+        {
+          pattern: /'''[\s\S]*?'''/,
+          greedy: true,
+          alias: 'string'
+        },
+        {
+          pattern: /"""[\s\S]*?"""/,
+          greedy: true,
+          alias: 'string',
+          inside: {
+            interpolation: interpolation
+          }
+        }
+      ]
+    });
+    Prism.languages.insertBefore('coffeescript', 'keyword', {
+      // Object property
+      property: /(?!\d)\w+(?=\s*:(?!:))/
+    });
+    delete Prism.languages.coffeescript['template-string'];
+    Prism.languages.coffee = Prism.languages.coffeescript;
+  })(Prism);
 }
 
-var concurnas_1;
-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 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 coq_1;
-var hasRequiredCoq;
-
-function requireCoq () {
-	if (hasRequiredCoq) return coq_1;
-	hasRequiredCoq = 1;
+var coq_1 = coq;
+coq.displayName = 'coq';
+coq.aliases = [];
+function coq(Prism) {
+(function (Prism) {
+    // https://github.com/coq/coq
+    var commentSource = /\(\*(?:[^(*]|\((?!\*)|\*(?!\))|<self>)*\*\)/.source;
+    for (var i = 0; i < 2; i++) {
+      commentSource = commentSource.replace(/<self>/g, function () {
+        return commentSource
+      });
+    }
+    commentSource = commentSource.replace(/<self>/g, '[]');
+    Prism.languages.coq = {
+      comment: RegExp(commentSource),
+      string: {
+        pattern: /"(?:[^"]|"")*"(?!")/,
+        greedy: true
+      },
+      attribute: [
+        {
+          pattern: RegExp(
+            /#\[(?:[^\[\]("]|"(?:[^"]|"")*"(?!")|\((?!\*)|<comment>)*\]/.source.replace(
+              /<comment>/g,
+              function () {
+                return commentSource
+              }
+            )
+          ),
+          greedy: true,
+          alias: 'attr-name',
+          inside: {
+            comment: RegExp(commentSource),
+            string: {
+              pattern: /"(?:[^"]|"")*"(?!")/,
+              greedy: true
+            },
+            operator: /=/,
+            punctuation: /^#\[|\]$|[,()]/
+          }
+        },
+        {
+          pattern:
+            /\b(?:Cumulative|Global|Local|Monomorphic|NonCumulative|Polymorphic|Private|Program)\b/,
+          alias: 'attr-name'
+        }
+      ],
+      keyword:
+        /\b(?:Abort|About|Add|Admit|Admitted|All|Arguments|As|Assumptions|Axiom|Axioms|Back|BackTo|Backtrace|BinOp|BinOpSpec|BinRel|Bind|Blacklist|Canonical|Case|Cd|Check|Class|Classes|Close|CoFixpoint|CoInductive|Coercion|Coercions|Collection|Combined|Compute|Conjecture|Conjectures|Constant|Constants|Constraint|Constructors|Context|Corollary|Create|CstOp|Custom|Cut|Debug|Declare|Defined|Definition|Delimit|Dependencies|Dependent|Derive|Diffs|Drop|Elimination|End|Entry|Equality|Eval|Example|Existential|Existentials|Existing|Export|Extern|Extraction|Fact|Fail|Field|File|Firstorder|Fixpoint|Flags|Focus|From|Funclass|Function|Functional|GC|Generalizable|Goal|Grab|Grammar|Graph|Guarded|Haskell|Heap|Hide|Hint|HintDb|Hints|Hypotheses|Hypothesis|IF|Identity|Immediate|Implicit|Implicits|Import|Include|Induction|Inductive|Infix|Info|Initial|InjTyp|Inline|Inspect|Instance|Instances|Intro|Intros|Inversion|Inversion_clear|JSON|Language|Left|Lemma|Let|Lia|Libraries|Library|Load|LoadPath|Locate|Ltac|Ltac2|ML|Match|Method|Minimality|Module|Modules|Morphism|Next|NoInline|Notation|Number|OCaml|Obligation|Obligations|Opaque|Open|Optimize|Parameter|Parameters|Parametric|Path|Paths|Prenex|Preterm|Primitive|Print|Profile|Projections|Proof|Prop|PropBinOp|PropOp|PropUOp|Property|Proposition|Pwd|Qed|Quit|Rec|Record|Recursive|Redirect|Reduction|Register|Relation|Remark|Remove|Require|Reserved|Reset|Resolve|Restart|Rewrite|Right|Ring|Rings|SProp|Saturate|Save|Scheme|Scope|Scopes|Search|SearchHead|SearchPattern|SearchRewrite|Section|Separate|Set|Setoid|Show|Signatures|Solve|Solver|Sort|Sortclass|Sorted|Spec|Step|Strategies|Strategy|String|Structure|SubClass|Subgraph|SuchThat|Tactic|Term|TestCompile|Theorem|Time|Timeout|To|Transparent|Type|Typeclasses|Types|Typing|UnOp|UnOpSpec|Undelimit|Undo|Unfocus|Unfocused|Unfold|Universe|Universes|Unshelve|Variable|Variables|Variant|Verbose|View|Visibility|Zify|_|apply|as|at|by|cofix|else|end|exists|exists2|fix|for|forall|fun|if|in|let|match|measure|move|removed|return|struct|then|using|wf|where|with)\b/,
+      number:
+        /\b(?:0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]+)?(?:p[+-]?\d[\d_]*)?|\d[\d_]*(?:\.[\d_]+)?(?:e[+-]?\d[\d_]*)?)\b/i,
+      punct: {
+        pattern: /@\{|\{\||\[=|:>/,
+        alias: 'punctuation'
+      },
+      operator:
+        /\/\\|\\\/|\.{2,3}|:{1,2}=|\*\*|[-=]>|<(?:->?|[+:=>]|<:)|>(?:=|->)|\|[-|]?|[-!%&*+/<=>?@^~']/,
+      punctuation: /\.\(|`\(|@\{|`\{|\{\||\[=|:>|[:.,;(){}\[\]]/
+    };
+  })(Prism);
+}
 
-	coq_1 = coq;
-	coq.displayName = 'coq';
-	coq.aliases = [];
-	function coq(Prism) {
+var ruby_1 = ruby;
+ruby.displayName = 'ruby';
+ruby.aliases = ['rb'];
+function ruby(Prism) {
 (function (Prism) {
-	    // https://github.com/coq/coq
-	    var commentSource = /\(\*(?:[^(*]|\((?!\*)|\*(?!\))|<self>)*\*\)/.source;
-	    for (var i = 0; i < 2; i++) {
-	      commentSource = commentSource.replace(/<self>/g, function () {
-	        return commentSource
-	      });
-	    }
-	    commentSource = commentSource.replace(/<self>/g, '[]');
-	    Prism.languages.coq = {
-	      comment: RegExp(commentSource),
-	      string: {
-	        pattern: /"(?:[^"]|"")*"(?!")/,
-	        greedy: true
-	      },
-	      attribute: [
-	        {
-	          pattern: RegExp(
-	            /#\[(?:[^\[\]("]|"(?:[^"]|"")*"(?!")|\((?!\*)|<comment>)*\]/.source.replace(
-	              /<comment>/g,
-	              function () {
-	                return commentSource
-	              }
-	            )
-	          ),
-	          greedy: true,
-	          alias: 'attr-name',
-	          inside: {
-	            comment: RegExp(commentSource),
-	            string: {
-	              pattern: /"(?:[^"]|"")*"(?!")/,
-	              greedy: true
-	            },
-	            operator: /=/,
-	            punctuation: /^#\[|\]$|[,()]/
-	          }
-	        },
-	        {
-	          pattern:
-	            /\b(?:Cumulative|Global|Local|Monomorphic|NonCumulative|Polymorphic|Private|Program)\b/,
-	          alias: 'attr-name'
-	        }
-	      ],
-	      keyword:
-	        /\b(?:Abort|About|Add|Admit|Admitted|All|Arguments|As|Assumptions|Axiom|Axioms|Back|BackTo|Backtrace|BinOp|BinOpSpec|BinRel|Bind|Blacklist|Canonical|Case|Cd|Check|Class|Classes|Close|CoFixpoint|CoInductive|Coercion|Coercions|Collection|Combined|Compute|Conjecture|Conjectures|Constant|Constants|Constraint|Constructors|Context|Corollary|Create|CstOp|Custom|Cut|Debug|Declare|Defined|Definition|Delimit|Dependencies|Dependent|Derive|Diffs|Drop|Elimination|End|Entry|Equality|Eval|Example|Existential|Existentials|Existing|Export|Extern|Extraction|Fact|Fail|Field|File|Firstorder|Fixpoint|Flags|Focus|From|Funclass|Function|Functional|GC|Generalizable|Goal|Grab|Grammar|Graph|Guarded|Haskell|Heap|Hide|Hint|HintDb|Hints|Hypotheses|Hypothesis|IF|Identity|Immediate|Implicit|Implicits|Import|Include|Induction|Inductive|Infix|Info|Initial|InjTyp|Inline|Inspect|Instance|Instances|Intro|Intros|Inversion|Inversion_clear|JSON|Language|Left|Lemma|Let|Lia|Libraries|Library|Load|LoadPath|Locate|Ltac|Ltac2|ML|Match|Method|Minimality|Module|Modules|Morphism|Next|NoInline|Notation|Number|OCaml|Obligation|Obligations|Opaque|Open|Optimize|Parameter|Parameters|Parametric|Path|Paths|Prenex|Preterm|Primitive|Print|Profile|Projections|Proof|Prop|PropBinOp|PropOp|PropUOp|Property|Proposition|Pwd|Qed|Quit|Rec|Record|Recursive|Redirect|Reduction|Register|Relation|Remark|Remove|Require|Reserved|Reset|Resolve|Restart|Rewrite|Right|Ring|Rings|SProp|Saturate|Save|Scheme|Scope|Scopes|Search|SearchHead|SearchPattern|SearchRewrite|Section|Separate|Set|Setoid|Show|Signatures|Solve|Solver|Sort|Sortclass|Sorted|Spec|Step|Strategies|Strategy|String|Structure|SubClass|Subgraph|SuchThat|Tactic|Term|TestCompile|Theorem|Time|Timeout|To|Transparent|Type|Typeclasses|Types|Typing|UnOp|UnOpSpec|Undelimit|Undo|Unfocus|Unfocused|Unfold|Universe|Universes|Unshelve|Variable|Variables|Variant|Verbose|View|Visibility|Zify|_|apply|as|at|by|cofix|else|end|exists|exists2|fix|for|forall|fun|if|in|let|match|measure|move|removed|return|struct|then|using|wf|where|with)\b/,
-	      number:
-	        /\b(?:0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]+)?(?:p[+-]?\d[\d_]*)?|\d[\d_]*(?:\.[\d_]+)?(?:e[+-]?\d[\d_]*)?)\b/i,
-	      punct: {
-	        pattern: /@\{|\{\||\[=|:>/,
-	        alias: 'punctuation'
-	      },
-	      operator:
-	        /\/\\|\\\/|\.{2,3}|:{1,2}=|\*\*|[-=]>|<(?:->?|[+:=>]|<:)|>(?:=|->)|\|[-|]?|[-!%&*+/<=>?@^~']/,
-	      punctuation: /\.\(|`\(|@\{|`\{|\{\||\[=|:>|[:.,;(){}\[\]]/
-	    };
-	  })(Prism);
-	}
-	return coq_1;
-}
-
-var ruby_1;
-var hasRequiredRuby;
-
-function requireRuby () {
-	if (hasRequiredRuby) return ruby_1;
-	hasRequiredRuby = 1;
-
-	ruby_1 = ruby;
-	ruby.displayName = 'ruby';
-	ruby.aliases = ['rb'];
-	function ruby(Prism) {
-(function (Prism) {
-	    Prism.languages.ruby = Prism.languages.extend('clike', {
-	      comment: {
-	        pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
-	        greedy: true
-	      },
-	      'class-name': {
-	        pattern:
-	          /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
-	        lookbehind: true,
-	        inside: {
-	          punctuation: /[.\\]/
-	        }
-	      },
-	      keyword:
-	        /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
-	      operator:
-	        /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
-	      punctuation: /[(){}[\].,;]/
-	    });
-	    Prism.languages.insertBefore('ruby', 'operator', {
-	      'double-colon': {
-	        pattern: /::/,
-	        alias: 'punctuation'
-	      }
-	    });
-	    var interpolation = {
-	      pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
-	      lookbehind: true,
-	      inside: {
-	        content: {
-	          pattern: /^(#\{)[\s\S]+(?=\}$)/,
-	          lookbehind: true,
-	          inside: Prism.languages.ruby
-	        },
-	        delimiter: {
-	          pattern: /^#\{|\}$/,
-	          alias: 'punctuation'
-	        }
-	      }
-	    };
-	    delete Prism.languages.ruby.function;
-	    var percentExpression =
-	      '(?:' +
-	      [
-	        /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
-	        /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
-	        /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
-	        /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
-	        /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
-	      ].join('|') +
-	      ')';
-	    var symbolName =
-	      /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/
-	        .source;
-	    Prism.languages.insertBefore('ruby', 'keyword', {
-	      'regex-literal': [
-	        {
-	          pattern: RegExp(
-	            /%r/.source + percentExpression + /[egimnosux]{0,6}/.source
-	          ),
-	          greedy: true,
-	          inside: {
-	            interpolation: interpolation,
-	            regex: /[\s\S]+/
-	          }
-	        },
-	        {
-	          pattern:
-	            /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
-	          lookbehind: true,
-	          greedy: true,
-	          inside: {
-	            interpolation: interpolation,
-	            regex: /[\s\S]+/
-	          }
-	        }
-	      ],
-	      variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
-	      symbol: [
-	        {
-	          pattern: RegExp(/(^|[^:]):/.source + symbolName),
-	          lookbehind: true,
-	          greedy: true
-	        },
-	        {
-	          pattern: RegExp(
-	            /([\r\n{(,][ \t]*)/.source + symbolName + /(?=:(?!:))/.source
-	          ),
-	          lookbehind: true,
-	          greedy: true
-	        }
-	      ],
-	      'method-definition': {
-	        pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
-	        lookbehind: true,
-	        inside: {
-	          function: /\b\w+$/,
-	          keyword: /^self\b/,
-	          'class-name': /^\w+/,
-	          punctuation: /\./
-	        }
-	      }
-	    });
-	    Prism.languages.insertBefore('ruby', 'string', {
-	      'string-literal': [
-	        {
-	          pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression),
-	          greedy: true,
-	          inside: {
-	            interpolation: interpolation,
-	            string: /[\s\S]+/
-	          }
-	        },
-	        {
-	          pattern:
-	            /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
-	          greedy: true,
-	          inside: {
-	            interpolation: interpolation,
-	            string: /[\s\S]+/
-	          }
-	        },
-	        {
-	          pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
-	          alias: 'heredoc-string',
-	          greedy: true,
-	          inside: {
-	            delimiter: {
-	              pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
-	              inside: {
-	                symbol: /\b\w+/,
-	                punctuation: /^<<[-~]?/
-	              }
-	            },
-	            interpolation: interpolation,
-	            string: /[\s\S]+/
-	          }
-	        },
-	        {
-	          pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
-	          alias: 'heredoc-string',
-	          greedy: true,
-	          inside: {
-	            delimiter: {
-	              pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
-	              inside: {
-	                symbol: /\b\w+/,
-	                punctuation: /^<<[-~]?'|'$/
-	              }
-	            },
-	            string: /[\s\S]+/
-	          }
-	        }
-	      ],
-	      'command-literal': [
-	        {
-	          pattern: RegExp(/%x/.source + percentExpression),
-	          greedy: true,
-	          inside: {
-	            interpolation: interpolation,
-	            command: {
-	              pattern: /[\s\S]+/,
-	              alias: 'string'
-	            }
-	          }
-	        },
-	        {
-	          pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
-	          greedy: true,
-	          inside: {
-	            interpolation: interpolation,
-	            command: {
-	              pattern: /[\s\S]+/,
-	              alias: 'string'
-	            }
-	          }
-	        }
-	      ]
-	    });
-	    delete Prism.languages.ruby.string;
-	    Prism.languages.insertBefore('ruby', 'number', {
-	      builtin:
-	        /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
-	      constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
-	    });
-	    Prism.languages.rb = Prism.languages.ruby;
-	  })(Prism);
-	}
-	return ruby_1;
-}
-
-var crystal_1;
-var hasRequiredCrystal;
-
-function requireCrystal () {
-	if (hasRequiredCrystal) return crystal_1;
-	hasRequiredCrystal = 1;
-	var refractorRuby = requireRuby();
-	crystal_1 = crystal;
-	crystal.displayName = 'crystal';
-	crystal.aliases = [];
-	function crystal(Prism) {
-	  Prism.register(refractorRuby)
-	  ;(function (Prism) {
-	    Prism.languages.crystal = Prism.languages.extend('ruby', {
-	      keyword: [
-	        /\b(?:__DIR__|__END_LINE__|__FILE__|__LINE__|abstract|alias|annotation|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|ifdef|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|ptr|require|rescue|return|select|self|sizeof|struct|super|then|type|typeof|undef|uninitialized|union|unless|until|when|while|with|yield)\b/,
-	        {
-	          pattern: /(\.\s*)(?:is_a|responds_to)\?/,
-	          lookbehind: true
-	        }
-	      ],
-	      number:
-	        /\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[\da-fA-F_]*[\da-fA-F]|(?:\d(?:[\d_]*\d)?)(?:\.[\d_]*\d)?(?:[eE][+-]?[\d_]*\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\b/,
-	      operator: [/->/, Prism.languages.ruby.operator],
-	      punctuation: /[(){}[\].,;\\]/
-	    });
-	    Prism.languages.insertBefore('crystal', 'string-literal', {
-	      attribute: {
-	        pattern: /@\[.*?\]/,
-	        inside: {
-	          delimiter: {
-	            pattern: /^@\[|\]$/,
-	            alias: 'punctuation'
-	          },
-	          attribute: {
-	            pattern: /^(\s*)\w+/,
-	            lookbehind: true,
-	            alias: 'class-name'
-	          },
-	          args: {
-	            pattern: /\S(?:[\s\S]*\S)?/,
-	            inside: Prism.languages.crystal
-	          }
-	        }
-	      },
-	      expansion: {
-	        pattern: /\{(?:\{.*?\}|%.*?%)\}/,
-	        inside: {
-	          content: {
-	            pattern: /^(\{.)[\s\S]+(?=.\}$)/,
-	            lookbehind: true,
-	            inside: Prism.languages.crystal
-	          },
-	          delimiter: {
-	            pattern: /^\{[\{%]|[\}%]\}$/,
-	            alias: 'operator'
-	          }
-	        }
-	      },
-	      char: {
-	        pattern:
-	          /'(?:[^\\\r\n]{1,2}|\\(?:.|u(?:[A-Fa-f0-9]{1,4}|\{[A-Fa-f0-9]{1,6}\})))'/,
-	        greedy: true
-	      }
-	    });
-	  })(Prism);
-	}
-	return crystal_1;
-}
-
-var cshtml_1;
-var hasRequiredCshtml;
-
-function requireCshtml () {
-	if (hasRequiredCshtml) return cshtml_1;
-	hasRequiredCshtml = 1;
-	var refractorCsharp = requireCsharp();
-	cshtml_1 = cshtml;
-	cshtml.displayName = 'cshtml';
-	cshtml.aliases = ['razor'];
-	function cshtml(Prism) {
-	  Prism.register(refractorCsharp)
-	  // Docs:
-	  // https://docs.microsoft.com/en-us/aspnet/core/razor-pages/?view=aspnetcore-5.0&tabs=visual-studio
-	  // https://docs.microsoft.com/en-us/aspnet/core/mvc/views/razor?view=aspnetcore-5.0
-	  ;(function (Prism) {
-	    var commentLike = /\/(?![/*])|\/\/.*[\r\n]|\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\//
-	      .source;
-	    var stringLike =
-	      /@(?!")|"(?:[^\r\n\\"]|\\.)*"|@"(?:[^\\"]|""|\\[\s\S])*"(?!")/.source +
-	      '|' +
-	      /'(?:(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'|(?=[^\\](?!')))/.source;
-	    /**
-	     * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
-	     *
-	     * @param {string} pattern
-	     * @param {number} depthLog2
-	     * @returns {string}
-	     */
-	    function nested(pattern, depthLog2) {
-	      for (var i = 0; i < depthLog2; i++) {
-	        pattern = pattern.replace(/<self>/g, function () {
-	          return '(?:' + pattern + ')'
-	        });
-	      }
-	      return pattern
-	        .replace(/<self>/g, '[^\\s\\S]')
-	        .replace(/<str>/g, '(?:' + stringLike + ')')
-	        .replace(/<comment>/g, '(?:' + commentLike + ')')
-	    }
-	    var round = nested(/\((?:[^()'"@/]|<str>|<comment>|<self>)*\)/.source, 2);
-	    var square = nested(/\[(?:[^\[\]'"@/]|<str>|<comment>|<self>)*\]/.source, 2);
-	    var curly = nested(/\{(?:[^{}'"@/]|<str>|<comment>|<self>)*\}/.source, 2);
-	    var angle = nested(/<(?:[^<>'"@/]|<str>|<comment>|<self>)*>/.source, 2); // Note about the above bracket patterns:
-	    // They all ignore HTML expressions that might be in the C# code. This is a problem because HTML (like strings and
-	    // comments) is parsed differently. This is a huge problem because HTML might contain brackets and quotes which
-	    // messes up the bracket and string counting implemented by the above patterns.
-	    //
-	    // This problem is not fixable because 1) HTML expression are highly context sensitive and very difficult to detect
-	    // and 2) they require one capturing group at every nested level. See the `tagRegion` pattern to admire the
-	    // complexity of an HTML expression.
-	    //
-	    // To somewhat alleviate the problem a bit, the patterns for characters (e.g. 'a') is very permissive, it also
-	    // allows invalid characters to support HTML expressions like this: <p>That's it!</p>.
-	    var tagAttrs =
-	      /(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?/
-	        .source;
-	    var tagContent = /(?!\d)[^\s>\/=$<%]+/.source + tagAttrs + /\s*\/?>/.source;
-	    var tagRegion =
-	      /\B@?/.source +
-	      '(?:' +
-	      /<([a-zA-Z][\w:]*)/.source +
-	      tagAttrs +
-	      /\s*>/.source +
-	      '(?:' +
-	      (/[^<]/.source +
-	        '|' + // all tags that are not the start tag
-	        // eslint-disable-next-line regexp/strict
-	        /<\/?(?!\1\b)/.source +
-	        tagContent +
-	        '|' + // nested start tag
-	        nested(
-	          // eslint-disable-next-line regexp/strict
-	          /<\1/.source +
-	            tagAttrs +
-	            /\s*>/.source +
-	            '(?:' +
-	            (/[^<]/.source +
-	              '|' + // all tags that are not the start tag
-	              // eslint-disable-next-line regexp/strict
-	              /<\/?(?!\1\b)/.source +
-	              tagContent +
-	              '|' +
-	              '<self>') +
-	            ')*' + // eslint-disable-next-line regexp/strict
-	            /<\/\1\s*>/.source,
-	          2
-	        )) +
-	      ')*' + // eslint-disable-next-line regexp/strict
-	      /<\/\1\s*>/.source +
-	      '|' +
-	      /</.source +
-	      tagContent +
-	      ')'; // Now for the actual language definition(s):
-	    //
-	    // Razor as a language has 2 parts:
-	    //  1) CSHTML: A markup-like language that has been extended with inline C# code expressions and blocks.
-	    //  2) C#+HTML: A variant of C# that can contain CSHTML tags as expressions.
-	    //
-	    // In the below code, both CSHTML and C#+HTML will be create as separate language definitions that reference each
-	    // other. However, only CSHTML will be exported via `Prism.languages`.
-	    Prism.languages.cshtml = Prism.languages.extend('markup', {});
-	    var csharpWithHtml = Prism.languages.insertBefore(
-	      'csharp',
-	      'string',
-	      {
-	        html: {
-	          pattern: RegExp(tagRegion),
-	          greedy: true,
-	          inside: Prism.languages.cshtml
-	        }
-	      },
-	      {
-	        csharp: Prism.languages.extend('csharp', {})
-	      }
-	    );
-	    var cs = {
-	      pattern: /\S[\s\S]*/,
-	      alias: 'language-csharp',
-	      inside: csharpWithHtml
-	    };
-	    Prism.languages.insertBefore('cshtml', 'prolog', {
-	      'razor-comment': {
-	        pattern: /@\*[\s\S]*?\*@/,
-	        greedy: true,
-	        alias: 'comment'
-	      },
-	      block: {
-	        pattern: RegExp(
-	          /(^|[^@])@/.source +
-	            '(?:' +
-	            [
-	              // @{ ... }
-	              curly, // @code{ ... }
-	              /(?:code|functions)\s*/.source + curly, // @for (...) { ... }
-	              /(?:for|foreach|lock|switch|using|while)\s*/.source +
-	                round +
-	                /\s*/.source +
-	                curly, // @do { ... } while (...);
-	              /do\s*/.source +
-	                curly +
-	                /\s*while\s*/.source +
-	                round +
-	                /(?:\s*;)?/.source, // @try { ... } catch (...) { ... } finally { ... }
-	              /try\s*/.source +
-	                curly +
-	                /\s*catch\s*/.source +
-	                round +
-	                /\s*/.source +
-	                curly +
-	                /\s*finally\s*/.source +
-	                curly, // @if (...) {...} else if (...) {...} else {...}
-	              /if\s*/.source +
-	                round +
-	                /\s*/.source +
-	                curly +
-	                '(?:' +
-	                /\s*else/.source +
-	                '(?:' +
-	                /\s+if\s*/.source +
-	                round +
-	                ')?' +
-	                /\s*/.source +
-	                curly +
-	                ')*'
-	            ].join('|') +
-	            ')'
-	        ),
-	        lookbehind: true,
-	        greedy: true,
-	        inside: {
-	          keyword: /^@\w*/,
-	          csharp: cs
-	        }
-	      },
-	      directive: {
-	        pattern:
-	          /^([ \t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/m,
-	        lookbehind: true,
-	        greedy: true,
-	        inside: {
-	          keyword: /^@\w+/,
-	          csharp: cs
-	        }
-	      },
-	      value: {
-	        pattern: RegExp(
-	          /(^|[^@])@/.source +
-	            /(?:await\b\s*)?/.source +
-	            '(?:' +
-	            /\w+\b/.source +
-	            '|' +
-	            round +
-	            ')' +
-	            '(?:' +
-	            /[?!]?\.\w+\b/.source +
-	            '|' +
-	            round +
-	            '|' +
-	            square +
-	            '|' +
-	            angle +
-	            round +
-	            ')*'
-	        ),
-	        lookbehind: true,
-	        greedy: true,
-	        alias: 'variable',
-	        inside: {
-	          keyword: /^@/,
-	          csharp: cs
-	        }
-	      },
-	      'delegate-operator': {
-	        pattern: /(^|[^@])@(?=<)/,
-	        lookbehind: true,
-	        alias: 'operator'
-	      }
-	    });
-	    Prism.languages.razor = Prism.languages.cshtml;
-	  })(Prism);
-	}
-	return cshtml_1;
+    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);
 }
 
-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 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 cssExtras_1;
-var hasRequiredCssExtras;
-
-function requireCssExtras () {
-	if (hasRequiredCssExtras) return cssExtras_1;
-	hasRequiredCssExtras = 1;
-
-	cssExtras_1 = cssExtras;
-	cssExtras.displayName = 'cssExtras';
-	cssExtras.aliases = [];
-	function cssExtras(Prism) {
-(function (Prism) {
-	    var string = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
-	    var selectorInside;
-	    Prism.languages.css.selector = {
-	      pattern: Prism.languages.css.selector.pattern,
-	      lookbehind: true,
-	      inside: (selectorInside = {
-	        'pseudo-element':
-	          /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
-	        'pseudo-class': /:[-\w]+/,
-	        class: /\.[-\w]+/,
-	        id: /#[-\w]+/,
-	        attribute: {
-	          pattern: RegExp('\\[(?:[^[\\]"\']|' + string.source + ')*\\]'),
-	          greedy: true,
-	          inside: {
-	            punctuation: /^\[|\]$/,
-	            'case-sensitivity': {
-	              pattern: /(\s)[si]$/i,
-	              lookbehind: true,
-	              alias: 'keyword'
-	            },
-	            namespace: {
-	              pattern: /^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/,
-	              lookbehind: true,
-	              inside: {
-	                punctuation: /\|$/
-	              }
-	            },
-	            'attr-name': {
-	              pattern: /^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/,
-	              lookbehind: true
-	            },
-	            'attr-value': [
-	              string,
-	              {
-	                pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/,
-	                lookbehind: true
-	              }
-	            ],
-	            operator: /[|~*^$]?=/
-	          }
-	        },
-	        'n-th': [
-	          {
-	            pattern: /(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/,
-	            lookbehind: true,
-	            inside: {
-	              number: /[\dn]+/,
-	              operator: /[+-]/
-	            }
-	          },
-	          {
-	            pattern: /(\(\s*)(?:even|odd)(?=\s*\))/i,
-	            lookbehind: true
-	          }
-	        ],
-	        combinator: />|\+|~|\|\|/,
-	        // the `tag` token has been existed and removed.
-	        // because we can't find a perfect tokenize to match it.
-	        // if you want to add it, please read https://github.com/PrismJS/prism/pull/2373 first.
-	        punctuation: /[(),]/
-	      })
-	    };
-	    Prism.languages.css['atrule'].inside['selector-function-argument'].inside =
-	      selectorInside;
-	    Prism.languages.insertBefore('css', 'property', {
-	      variable: {
-	        pattern:
-	          /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i,
-	        lookbehind: true
-	      }
-	    });
-	    var unit = {
-	      pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/,
-	      lookbehind: true
-	    }; // 123 -123 .123 -.123 12.3 -12.3
-	    var number = {
-	      pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
-	      lookbehind: true
-	    };
-	    Prism.languages.insertBefore('css', 'function', {
-	      operator: {
-	        pattern: /(\s)[+\-*\/](?=\s)/,
-	        lookbehind: true
-	      },
-	      // CAREFUL!
-	      // Previewers and Inline color use hexcode and color.
-	      hexcode: {
-	        pattern: /\B#[\da-f]{3,8}\b/i,
-	        alias: 'color'
-	      },
-	      color: [
-	        {
-	          pattern:
-	            /(^|[^\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)(?![\w-])/i,
-	          lookbehind: true
-	        },
-	        {
-	          pattern:
-	            /\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,
-	          inside: {
-	            unit: unit,
-	            number: number,
-	            function: /[\w-]+(?=\()/,
-	            punctuation: /[(),]/
-	          }
-	        }
-	      ],
-	      // it's important that there is no boundary assertion after the hex digits
-	      entity: /\\[\da-f]{1,8}/i,
-	      unit: unit,
-	      number: number
-	    });
-	  })(Prism);
-	}
-	return cssExtras_1;
+var 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 csv_1;
-var hasRequiredCsv;
-
-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 csp_1 = csp;
+csp.displayName = 'csp';
+csp.aliases = [];
+function csp(Prism) {
+(function (Prism) {
+    /**
+     * @param {string} source
+     * @returns {RegExp}
+     */
+    function value(source) {
+      return RegExp(
+        /([ \t])/.source + '(?:' + source + ')' + /(?=[\s;]|$)/.source,
+        'i'
+      )
+    }
+    Prism.languages.csp = {
+      directive: {
+        pattern:
+          /(^|[\s;])(?:base-uri|block-all-mixed-content|(?:child|connect|default|font|frame|img|manifest|media|object|prefetch|script|style|worker)-src|disown-opener|form-action|frame-(?:ancestors|options)|input-protection(?:-(?:clip|selectors))?|navigate-to|plugin-types|policy-uri|referrer|reflected-xss|report-(?:to|uri)|require-sri-for|sandbox|(?:script|style)-src-(?:attr|elem)|upgrade-insecure-requests)(?=[\s;]|$)/i,
+        lookbehind: true,
+        alias: 'property'
+      },
+      scheme: {
+        pattern: value(/[a-z][a-z0-9.+-]*:/.source),
+        lookbehind: true
+      },
+      none: {
+        pattern: value(/'none'/.source),
+        lookbehind: true,
+        alias: 'keyword'
+      },
+      nonce: {
+        pattern: value(/'nonce-[-+/\w=]+'/.source),
+        lookbehind: true,
+        alias: 'number'
+      },
+      hash: {
+        pattern: value(/'sha(?:256|384|512)-[-+/\w=]+'/.source),
+        lookbehind: true,
+        alias: 'number'
+      },
+      host: {
+        pattern: value(
+          /[a-z][a-z0-9.+-]*:\/\/[^\s;,']*/.source +
+            '|' +
+            /\*[^\s;,']*/.source +
+            '|' +
+            /[a-z0-9-]+(?:\.[a-z0-9-]+)+(?::[\d*]+)?(?:\/[^\s;,']*)?/.source
+        ),
+        lookbehind: true,
+        alias: 'url',
+        inside: {
+          important: /\*/
+        }
+      },
+      keyword: [
+        {
+          pattern: value(/'unsafe-[a-z-]+'/.source),
+          lookbehind: true,
+          alias: 'unsafe'
+        },
+        {
+          pattern: value(/'[a-z-]+'/.source),
+          lookbehind: true,
+          alias: 'safe'
+        }
+      ],
+      punctuation: /;/
+    };
+  })(Prism);
 }
 
-var cypher_1;
-var hasRequiredCypher;
-
-function requireCypher () {
-	if (hasRequiredCypher) return cypher_1;
-	hasRequiredCypher = 1;
-
-	cypher_1 = cypher;
-	cypher.displayName = 'cypher';
-	cypher.aliases = [];
-	function cypher(Prism) {
-	  Prism.languages.cypher = {
-	    // https://neo4j.com/docs/cypher-manual/current/syntax/comments/
-	    comment: /\/\/.*/,
-	    string: {
-	      pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/,
-	      greedy: true
-	    },
-	    'class-name': {
-	      pattern: /(:\s*)(?:\w+|`(?:[^`\\\r\n])*`)(?=\s*[{):])/,
-	      lookbehind: true,
-	      greedy: true
-	    },
-	    relationship: {
-	      pattern:
-	        /(-\[\s*(?:\w+\s*|`(?:[^`\\\r\n])*`\s*)?:\s*|\|\s*:\s*)(?:\w+|`(?:[^`\\\r\n])*`)/,
-	      lookbehind: true,
-	      greedy: true,
-	      alias: 'property'
-	    },
-	    identifier: {
-	      pattern: /`(?:[^`\\\r\n])*`/,
-	      greedy: true
-	    },
-	    variable: /\$\w+/,
-	    // https://neo4j.com/docs/cypher-manual/current/syntax/reserved/
-	    keyword:
-	      /\b(?:ADD|ALL|AND|AS|ASC|ASCENDING|ASSERT|BY|CALL|CASE|COMMIT|CONSTRAINT|CONTAINS|CREATE|CSV|DELETE|DESC|DESCENDING|DETACH|DISTINCT|DO|DROP|ELSE|END|ENDS|EXISTS|FOR|FOREACH|IN|INDEX|IS|JOIN|KEY|LIMIT|LOAD|MANDATORY|MATCH|MERGE|NODE|NOT|OF|ON|OPTIONAL|OR|ORDER(?=\s+BY)|PERIODIC|REMOVE|REQUIRE|RETURN|SCALAR|SCAN|SET|SKIP|START|STARTS|THEN|UNION|UNIQUE|UNWIND|USING|WHEN|WHERE|WITH|XOR|YIELD)\b/i,
-	    function: /\b\w+\b(?=\s*\()/,
-	    boolean: /\b(?:false|null|true)\b/i,
-	    number: /\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
-	    // https://neo4j.com/docs/cypher-manual/current/syntax/operators/
-	    operator: /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/,
-	    punctuation: /[()[\]{},;.]/
-	  };
-	}
-	return cypher_1;
+var 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 d_1;
-var hasRequiredD;
+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 requireD () {
-	if (hasRequiredD) return d_1;
-	hasRequiredD = 1;
+var cypher_1 = cypher;
+cypher.displayName = 'cypher';
+cypher.aliases = [];
+function cypher(Prism) {
+  Prism.languages.cypher = {
+    // https://neo4j.com/docs/cypher-manual/current/syntax/comments/
+    comment: /\/\/.*/,
+    string: {
+      pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/,
+      greedy: true
+    },
+    'class-name': {
+      pattern: /(:\s*)(?:\w+|`(?:[^`\\\r\n])*`)(?=\s*[{):])/,
+      lookbehind: true,
+      greedy: true
+    },
+    relationship: {
+      pattern:
+        /(-\[\s*(?:\w+\s*|`(?:[^`\\\r\n])*`\s*)?:\s*|\|\s*:\s*)(?:\w+|`(?:[^`\\\r\n])*`)/,
+      lookbehind: true,
+      greedy: true,
+      alias: 'property'
+    },
+    identifier: {
+      pattern: /`(?:[^`\\\r\n])*`/,
+      greedy: true
+    },
+    variable: /\$\w+/,
+    // https://neo4j.com/docs/cypher-manual/current/syntax/reserved/
+    keyword:
+      /\b(?:ADD|ALL|AND|AS|ASC|ASCENDING|ASSERT|BY|CALL|CASE|COMMIT|CONSTRAINT|CONTAINS|CREATE|CSV|DELETE|DESC|DESCENDING|DETACH|DISTINCT|DO|DROP|ELSE|END|ENDS|EXISTS|FOR|FOREACH|IN|INDEX|IS|JOIN|KEY|LIMIT|LOAD|MANDATORY|MATCH|MERGE|NODE|NOT|OF|ON|OPTIONAL|OR|ORDER(?=\s+BY)|PERIODIC|REMOVE|REQUIRE|RETURN|SCALAR|SCAN|SET|SKIP|START|STARTS|THEN|UNION|UNIQUE|UNWIND|USING|WHEN|WHERE|WITH|XOR|YIELD)\b/i,
+    function: /\b\w+\b(?=\s*\()/,
+    boolean: /\b(?:false|null|true)\b/i,
+    number: /\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
+    // https://neo4j.com/docs/cypher-manual/current/syntax/operators/
+    operator: /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/,
+    punctuation: /[()[\]{},;.]/
+  };
+}
 
-	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 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 dart_1;
@@ -25364,7 +25241,7 @@ var hasRequiredErb;
 function requireErb () {
 	if (hasRequiredErb) return erb_1;
 	hasRequiredErb = 1;
-	var refractorRuby = requireRuby();
+	var refractorRuby = ruby_1;
 	var refractorMarkupTemplating = requireMarkupTemplating();
 	erb_1 = erb;
 	erb.displayName = 'erb';
@@ -27846,7 +27723,7 @@ var hasRequiredHaml;
 function requireHaml () {
 	if (hasRequiredHaml) return haml_1;
 	hasRequiredHaml = 1;
-	var refractorRuby = requireRuby();
+	var refractorRuby = ruby_1;
 	haml_1 = haml;
 	haml.displayName = 'haml';
 	haml.aliases = [];
@@ -40282,7 +40159,7 @@ function requireT4Cs () {
 	if (hasRequiredT4Cs) return t4Cs_1;
 	hasRequiredT4Cs = 1;
 	var refractorT4Templating = requireT4Templating();
-	var refractorCsharp = requireCsharp();
+	var refractorCsharp = csharp_1;
 	t4Cs_1 = t4Cs;
 	t4Cs.displayName = 't4Cs';
 	t4Cs.aliases = [];
@@ -43059,19 +42936,19 @@ refractor.register(chaiscript_1);
 refractor.register(cil_1);
 refractor.register(clojure_1);
 refractor.register(cmake_1);
-refractor.register(requireCobol());
-refractor.register(requireCoffeescript());
-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(requireD());
+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(cypher_1);
+refractor.register(d_1);
 refractor.register(requireDart());
 refractor.register(requireDataweave());
 refractor.register(requireDax());
@@ -43230,7 +43107,7 @@ refractor.register(requireRest());
 refractor.register(requireRip());
 refractor.register(requireRoboconf());
 refractor.register(requireRobotframework());
-refractor.register(requireRuby());
+refractor.register(ruby_1);
 refractor.register(requireRust());
 refractor.register(requireSas());
 refractor.register(requireSass());
@@ -47632,8 +47509,8 @@ TableCell.defaultProps = _objectSpread2(_objectSpread2({}, BaseCell.defaultProps
   onSort: function onSort() {}
 });
 
-var css$x = ".TableRow_module_root__f4710f2d {\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-start;\n  align-items: center;\n}\n.TableRow_module_root__f4710f2d.TableRow_module_headerRow__f4710f2d {\n  background: var(--grey6);\n}\n.TableRow_module_root__f4710f2d.TableRow_module_headerRow__f4710f2d > [data-elem=base-cell].TableRow_module_expandableCell__f4710f2d {\n  background: transparent;\n}\n.TableRow_module_root__f4710f2d.TableRow_module_headerRow__f4710f2d > [data-elem=base-cell].TableRow_module_expandableCell__f4710f2d > [data-elem=component2] {\n  width: 3rem;\n  visibility: hidden;\n}\n.TableRow_module_root__f4710f2d.TableRow_module_bodyRow__f4710f2d {\n  background: var(--white);\n}\n.TableRow_module_root__f4710f2d.TableRow_module_bodyRow__f4710f2d:hover > [data-elem=base-cell] {\n  background: var(--info-bg);\n}\n.TableRow_module_root__f4710f2d.TableRow_module_bodyRow__f4710f2d[data-active=true] > [data-elem=base-cell] {\n  background: var(--background);\n}\n.TableRow_module_root__f4710f2d > [data-elem=base-cell]:first-child {\n  padding-left: 1rem;\n}\n.TableRow_module_root__f4710f2d > [data-elem=base-cell]:last-child {\n  padding-right: 1rem;\n}\n.TableRow_module_root__f4710f2d.TableRow_module_rowHeightMd__f4710f2d > td[data-elem=base-cell] {\n  height: 3rem;\n}\n.TableRow_module_root__f4710f2d.TableRow_module_rowHeightLg__f4710f2d > td[data-elem=base-cell] {\n  height: 4rem;\n}\n.TableRow_module_root__f4710f2d > [data-elem=base-cell].TableRow_module_expandableCell__f4710f2d {\n  padding-left: 0.9rem;\n  padding-right: 0.1rem;\n  overflow: visible;\n}\n.TableRow_module_root__f4710f2d > [data-elem=base-cell].TableRow_module_expandableCell__f4710f2d > [data-elem=component2] {\n  overflow: visible;\n}\n.TableRow_module_root__f4710f2d > [data-elem=base-cell].TableRow_module_expandableCell__f4710f2d > [data-elem=component2] > [data-elem=text] {\n  overflow: visible;\n}\n.TableRow_module_root__f4710f2d button.TableRow_module_button__f4710f2d[data-elem=base-cell] .TableRow_module_icon__f4710f2d {\n  width: 1.5rem;\n  height: 1.5rem;\n}\n.TableRow_module_root__f4710f2d button.TableRow_module_button__f4710f2d[data-elem=base-cell]:disabled {\n  cursor: default;\n}\n.TableRow_module_root__f4710f2d button.TableRow_module_button__f4710f2d[data-elem=base-cell]:disabled .TableRow_module_icon__f4710f2d {\n  visibility: hidden;\n}\n.TableRow_module_root__f4710f2d .TableRow_module_expanded__f4710f2d .TableRow_module_button__f4710f2d .TableRow_module_icon__f4710f2d {\n  transform: rotate(180deg);\n}";
-var modules_f6618a87 = {"root":"TableRow_module_root__f4710f2d","header-row":"TableRow_module_headerRow__f4710f2d","expandable-cell":"TableRow_module_expandableCell__f4710f2d","body-row":"TableRow_module_bodyRow__f4710f2d","row-height-md":"TableRow_module_rowHeightMd__f4710f2d","row-height-lg":"TableRow_module_rowHeightLg__f4710f2d","button":"TableRow_module_button__f4710f2d","icon":"TableRow_module_icon__f4710f2d","expanded":"TableRow_module_expanded__f4710f2d"};
+var css$x = ".TableRow_module_root__56f50f2c {\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-start;\n  align-items: center;\n}\n.TableRow_module_root__56f50f2c.TableRow_module_headerRow__56f50f2c {\n  background: var(--grey6);\n}\n.TableRow_module_root__56f50f2c.TableRow_module_headerRow__56f50f2c > [data-elem=base-cell].TableRow_module_expandableCell__56f50f2c {\n  background: transparent;\n}\n.TableRow_module_root__56f50f2c.TableRow_module_headerRow__56f50f2c > [data-elem=base-cell].TableRow_module_expandableCell__56f50f2c > [data-elem=component2] {\n  width: 3rem;\n  visibility: hidden;\n}\n.TableRow_module_root__56f50f2c.TableRow_module_bodyRow__56f50f2c {\n  background: var(--white);\n}\n.TableRow_module_root__56f50f2c.TableRow_module_bodyRow__56f50f2c > [data-elem=base-cell] {\n  background: var(--white);\n}\n.TableRow_module_root__56f50f2c.TableRow_module_bodyRow__56f50f2c:hover > [data-elem=base-cell] {\n  background: var(--info-bg);\n}\n.TableRow_module_root__56f50f2c.TableRow_module_bodyRow__56f50f2c[data-active=true] > [data-elem=base-cell] {\n  background: var(--background);\n}\n.TableRow_module_root__56f50f2c > [data-elem=base-cell]:first-child {\n  padding-left: 1rem;\n}\n.TableRow_module_root__56f50f2c > [data-elem=base-cell]:last-child {\n  padding-right: 1rem;\n}\n.TableRow_module_root__56f50f2c.TableRow_module_rowHeightMd__56f50f2c > td[data-elem=base-cell] {\n  height: 3rem;\n}\n.TableRow_module_root__56f50f2c.TableRow_module_rowHeightLg__56f50f2c > td[data-elem=base-cell] {\n  height: 4rem;\n}\n.TableRow_module_root__56f50f2c > [data-elem=base-cell].TableRow_module_expandableCell__56f50f2c {\n  padding-left: 0.9rem;\n  padding-right: 0.1rem;\n  overflow: visible;\n}\n.TableRow_module_root__56f50f2c > [data-elem=base-cell].TableRow_module_expandableCell__56f50f2c > [data-elem=component2] {\n  overflow: visible;\n}\n.TableRow_module_root__56f50f2c > [data-elem=base-cell].TableRow_module_expandableCell__56f50f2c > [data-elem=component2] > [data-elem=text] {\n  overflow: visible;\n}\n.TableRow_module_root__56f50f2c button.TableRow_module_button__56f50f2c[data-elem=base-cell] .TableRow_module_icon__56f50f2c {\n  width: 1.5rem;\n  height: 1.5rem;\n}\n.TableRow_module_root__56f50f2c button.TableRow_module_button__56f50f2c[data-elem=base-cell]:disabled {\n  cursor: default;\n}\n.TableRow_module_root__56f50f2c button.TableRow_module_button__56f50f2c[data-elem=base-cell]:disabled .TableRow_module_icon__56f50f2c {\n  visibility: hidden;\n}\n.TableRow_module_root__56f50f2c .TableRow_module_expanded__56f50f2c .TableRow_module_button__56f50f2c .TableRow_module_icon__56f50f2c {\n  transform: rotate(180deg);\n}";
+var modules_f6618a87 = {"root":"TableRow_module_root__56f50f2c","header-row":"TableRow_module_headerRow__56f50f2c","expandable-cell":"TableRow_module_expandableCell__56f50f2c","body-row":"TableRow_module_bodyRow__56f50f2c","row-height-md":"TableRow_module_rowHeightMd__56f50f2c","row-height-lg":"TableRow_module_rowHeightLg__56f50f2c","button":"TableRow_module_button__56f50f2c","icon":"TableRow_module_icon__56f50f2c","expanded":"TableRow_module_expanded__56f50f2c"};
 n(css$x,{});
 
 var TableRow = /*#__PURE__*/React.forwardRef(function BaseTable(props, ref) {
@@ -47652,6 +47529,19 @@ var TableRow = /*#__PURE__*/React.forwardRef(function BaseTable(props, ref) {
     _useState2 = _slicedToArray(_useState, 2),
     expanded = _useState2[0],
     setExpanded = _useState2[1];
+  var expandableProps = Expandable ? {
+    _expanded: expanded,
+    _setExpanded: setExpanded,
+    disabled: !Expandable({
+      datum: datum,
+      index: _index
+    }),
+    onClick: function onClick() {
+      setExpanded(function (prev) {
+        return !prev;
+      });
+    }
+  } : {};
   var tableCells = headerData === null || headerData === void 0 ? void 0 : (_headerData$map = headerData.map) === null || _headerData$map === void 0 ? void 0 : _headerData$map.call(headerData, function (item) {
     var _getCustomCell;
     var cellContent = null;
@@ -47662,6 +47552,7 @@ var TableRow = /*#__PURE__*/React.forwardRef(function BaseTable(props, ref) {
     }
     var cellProps = _objectSpread2(_objectSpread2(_objectSpread2({}, props), item), {}, {
       _index: _index,
+      expandableProps: expandableProps,
       setActiveId: setActiveId,
       key: item.id,
       datum: datum,
@@ -47684,38 +47575,12 @@ var TableRow = /*#__PURE__*/React.forwardRef(function BaseTable(props, ref) {
     );
   });
   return /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
-    children: [/*#__PURE__*/jsxRuntime.jsxs("tr", {
+    children: [/*#__PURE__*/jsxRuntime.jsx("tr", {
       ref: ref,
       tabIndex: -1,
       "data-elem": "table-row",
-      className: classes(className, modules_f6618a87.root, modules_f6618a87["".concat(type, "-row")], modules_f6618a87["row-height-".concat(rowHeight)], Expandable ? modules_f6618a87.expandable : ''),
-      children: [Expandable && type === 'header' && /*#__PURE__*/jsxRuntime.jsx(TableCell, {
-        className: classes(modules_f6618a87['expandable-cell'], expanded ? modules_f6618a87.expanded : ''),
-        size: "auto",
-        cellContent: null
-      }), Expandable && type === 'body' && /*#__PURE__*/jsxRuntime.jsx(TableCell, {
-        className: classes(modules_f6618a87['expandable-cell'], expanded ? modules_f6618a87.expanded : ''),
-        size: "auto",
-        cellContent: /*#__PURE__*/jsxRuntime.jsx(Button, {
-          className: modules_f6618a87.button,
-          size: "auto",
-          variant: "text",
-          disabled: !Expandable({
-            datum: datum,
-            index: _index
-          }),
-          onClick: function onClick() {
-            setExpanded(function (prev) {
-              return !prev;
-            });
-          },
-          leftComponent: function leftComponent() {
-            return /*#__PURE__*/jsxRuntime.jsx(Caret, {
-              className: modules_f6618a87.icon
-            });
-          }
-        })
-      }), tableCells]
+      className: classes(className, modules_f6618a87.root, modules_f6618a87["".concat(type, "-row")], modules_f6618a87["row-height-".concat(rowHeight)]),
+      children: tableCells
     }), Expandable && expanded && /*#__PURE__*/jsxRuntime.jsx("tr", {
       children: /*#__PURE__*/jsxRuntime.jsx(Expandable, {
         datum: datum,