@banyan_cloud/roots 1.0.95 → 1.0.96

package/dist/cjs/index.js

@@ -20527,134 +20527,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'];
@@ -20998,484 +20990,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*@.*%>/,
@@ -22664,7 +22647,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 = [];
@@ -22837,900 +22820,830 @@ 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;
-
-	coq_1 = coq;
-	coq.displayName = 'coq';
-	coq.aliases = [];
-	function coq(Prism) {
+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);
-	}
-	return coq_1;
+    // 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);
 }
 
-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) {
+var 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;
+    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 crystal_1;
-var hasRequiredCrystal;
-
-function requireCrystal () {
-	if (hasRequiredCrystal) return crystal_1;
-	hasRequiredCrystal = 1;
-	var refractorRuby = requireRuby();
-	crystal_1 = crystal;
-	crystal.displayName = 'crystal';
-	crystal.aliases = [];
-	function crystal(Prism) {
-	  Prism.register(refractorRuby)
-	  ;(function (Prism) {
-	    Prism.languages.crystal = Prism.languages.extend('ruby', {
-	      keyword: [
-	        /\b(?:__DIR__|__END_LINE__|__FILE__|__LINE__|abstract|alias|annotation|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|ifdef|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|ptr|require|rescue|return|select|self|sizeof|struct|super|then|type|typeof|undef|uninitialized|union|unless|until|when|while|with|yield)\b/,
-	        {
-	          pattern: /(\.\s*)(?:is_a|responds_to)\?/,
-	          lookbehind: true
-	        }
-	      ],
-	      number:
-	        /\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[\da-fA-F_]*[\da-fA-F]|(?:\d(?:[\d_]*\d)?)(?:\.[\d_]*\d)?(?:[eE][+-]?[\d_]*\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\b/,
-	      operator: [/->/, Prism.languages.ruby.operator],
-	      punctuation: /[(){}[\].,;\\]/
-	    });
-	    Prism.languages.insertBefore('crystal', 'string-literal', {
-	      attribute: {
-	        pattern: /@\[.*?\]/,
-	        inside: {
-	          delimiter: {
-	            pattern: /^@\[|\]$/,
-	            alias: 'punctuation'
-	          },
-	          attribute: {
-	            pattern: /^(\s*)\w+/,
-	            lookbehind: true,
-	            alias: 'class-name'
-	          },
-	          args: {
-	            pattern: /\S(?:[\s\S]*\S)?/,
-	            inside: Prism.languages.crystal
-	          }
-	        }
-	      },
-	      expansion: {
-	        pattern: /\{(?:\{.*?\}|%.*?%)\}/,
-	        inside: {
-	          content: {
-	            pattern: /^(\{.)[\s\S]+(?=.\}$)/,
-	            lookbehind: true,
-	            inside: Prism.languages.crystal
-	          },
-	          delimiter: {
-	            pattern: /^\{[\{%]|[\}%]\}$/,
-	            alias: 'operator'
-	          }
-	        }
-	      },
-	      char: {
-	        pattern:
-	          /'(?:[^\\\r\n]{1,2}|\\(?:.|u(?:[A-Fa-f0-9]{1,4}|\{[A-Fa-f0-9]{1,6}\})))'/,
-	        greedy: true
-	      }
-	    });
-	  })(Prism);
-	}
-	return crystal_1;
-}
-
-var cshtml_1;
-var hasRequiredCshtml;
-
-function requireCshtml () {
-	if (hasRequiredCshtml) return cshtml_1;
-	hasRequiredCshtml = 1;
-	var refractorCsharp = requireCsharp();
-	cshtml_1 = cshtml;
-	cshtml.displayName = 'cshtml';
-	cshtml.aliases = ['razor'];
-	function cshtml(Prism) {
-	  Prism.register(refractorCsharp)
-	  // Docs:
-	  // https://docs.microsoft.com/en-us/aspnet/core/razor-pages/?view=aspnetcore-5.0&tabs=visual-studio
-	  // https://docs.microsoft.com/en-us/aspnet/core/mvc/views/razor?view=aspnetcore-5.0
-	  ;(function (Prism) {
-	    var commentLike = /\/(?![/*])|\/\/.*[\r\n]|\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\//
-	      .source;
-	    var stringLike =
-	      /@(?!")|"(?:[^\r\n\\"]|\\.)*"|@"(?:[^\\"]|""|\\[\s\S])*"(?!")/.source +
-	      '|' +
-	      /'(?:(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'|(?=[^\\](?!')))/.source;
-	    /**
-	     * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
-	     *
-	     * @param {string} pattern
-	     * @param {number} depthLog2
-	     * @returns {string}
-	     */
-	    function nested(pattern, depthLog2) {
-	      for (var i = 0; i < depthLog2; i++) {
-	        pattern = pattern.replace(/<self>/g, function () {
-	          return '(?:' + pattern + ')'
-	        });
-	      }
-	      return pattern
-	        .replace(/<self>/g, '[^\\s\\S]')
-	        .replace(/<str>/g, '(?:' + stringLike + ')')
-	        .replace(/<comment>/g, '(?:' + commentLike + ')')
-	    }
-	    var round = nested(/\((?:[^()'"@/]|<str>|<comment>|<self>)*\)/.source, 2);
-	    var square = nested(/\[(?:[^\[\]'"@/]|<str>|<comment>|<self>)*\]/.source, 2);
-	    var curly = nested(/\{(?:[^{}'"@/]|<str>|<comment>|<self>)*\}/.source, 2);
-	    var angle = nested(/<(?:[^<>'"@/]|<str>|<comment>|<self>)*>/.source, 2); // Note about the above bracket patterns:
-	    // They all ignore HTML expressions that might be in the C# code. This is a problem because HTML (like strings and
-	    // comments) is parsed differently. This is a huge problem because HTML might contain brackets and quotes which
-	    // messes up the bracket and string counting implemented by the above patterns.
-	    //
-	    // This problem is not fixable because 1) HTML expression are highly context sensitive and very difficult to detect
-	    // and 2) they require one capturing group at every nested level. See the `tagRegion` pattern to admire the
-	    // complexity of an HTML expression.
-	    //
-	    // To somewhat alleviate the problem a bit, the patterns for characters (e.g. 'a') is very permissive, it also
-	    // allows invalid characters to support HTML expressions like this: <p>That's it!</p>.
-	    var tagAttrs =
-	      /(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?/
-	        .source;
-	    var tagContent = /(?!\d)[^\s>\/=$<%]+/.source + tagAttrs + /\s*\/?>/.source;
-	    var tagRegion =
-	      /\B@?/.source +
-	      '(?:' +
-	      /<([a-zA-Z][\w:]*)/.source +
-	      tagAttrs +
-	      /\s*>/.source +
-	      '(?:' +
-	      (/[^<]/.source +
-	        '|' + // all tags that are not the start tag
-	        // eslint-disable-next-line regexp/strict
-	        /<\/?(?!\1\b)/.source +
-	        tagContent +
-	        '|' + // nested start tag
-	        nested(
-	          // eslint-disable-next-line regexp/strict
-	          /<\1/.source +
-	            tagAttrs +
-	            /\s*>/.source +
-	            '(?:' +
-	            (/[^<]/.source +
-	              '|' + // all tags that are not the start tag
-	              // eslint-disable-next-line regexp/strict
-	              /<\/?(?!\1\b)/.source +
-	              tagContent +
-	              '|' +
-	              '<self>') +
-	            ')*' + // eslint-disable-next-line regexp/strict
-	            /<\/\1\s*>/.source,
-	          2
-	        )) +
-	      ')*' + // eslint-disable-next-line regexp/strict
-	      /<\/\1\s*>/.source +
-	      '|' +
-	      /</.source +
-	      tagContent +
-	      ')'; // Now for the actual language definition(s):
-	    //
-	    // Razor as a language has 2 parts:
-	    //  1) CSHTML: A markup-like language that has been extended with inline C# code expressions and blocks.
-	    //  2) C#+HTML: A variant of C# that can contain CSHTML tags as expressions.
-	    //
-	    // In the below code, both CSHTML and C#+HTML will be create as separate language definitions that reference each
-	    // other. However, only CSHTML will be exported via `Prism.languages`.
-	    Prism.languages.cshtml = Prism.languages.extend('markup', {});
-	    var csharpWithHtml = Prism.languages.insertBefore(
-	      'csharp',
-	      'string',
-	      {
-	        html: {
-	          pattern: RegExp(tagRegion),
-	          greedy: true,
-	          inside: Prism.languages.cshtml
-	        }
-	      },
-	      {
-	        csharp: Prism.languages.extend('csharp', {})
-	      }
-	    );
-	    var cs = {
-	      pattern: /\S[\s\S]*/,
-	      alias: 'language-csharp',
-	      inside: csharpWithHtml
-	    };
-	    Prism.languages.insertBefore('cshtml', 'prolog', {
-	      'razor-comment': {
-	        pattern: /@\*[\s\S]*?\*@/,
-	        greedy: true,
-	        alias: 'comment'
-	      },
-	      block: {
-	        pattern: RegExp(
-	          /(^|[^@])@/.source +
-	            '(?:' +
-	            [
-	              // @{ ... }
-	              curly, // @code{ ... }
-	              /(?:code|functions)\s*/.source + curly, // @for (...) { ... }
-	              /(?:for|foreach|lock|switch|using|while)\s*/.source +
-	                round +
-	                /\s*/.source +
-	                curly, // @do { ... } while (...);
-	              /do\s*/.source +
-	                curly +
-	                /\s*while\s*/.source +
-	                round +
-	                /(?:\s*;)?/.source, // @try { ... } catch (...) { ... } finally { ... }
-	              /try\s*/.source +
-	                curly +
-	                /\s*catch\s*/.source +
-	                round +
-	                /\s*/.source +
-	                curly +
-	                /\s*finally\s*/.source +
-	                curly, // @if (...) {...} else if (...) {...} else {...}
-	              /if\s*/.source +
-	                round +
-	                /\s*/.source +
-	                curly +
-	                '(?:' +
-	                /\s*else/.source +
-	                '(?:' +
-	                /\s+if\s*/.source +
-	                round +
-	                ')?' +
-	                /\s*/.source +
-	                curly +
-	                ')*'
-	            ].join('|') +
-	            ')'
-	        ),
-	        lookbehind: true,
-	        greedy: true,
-	        inside: {
-	          keyword: /^@\w*/,
-	          csharp: cs
-	        }
-	      },
-	      directive: {
-	        pattern:
-	          /^([ \t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/m,
-	        lookbehind: true,
-	        greedy: true,
-	        inside: {
-	          keyword: /^@\w+/,
-	          csharp: cs
-	        }
-	      },
-	      value: {
-	        pattern: RegExp(
-	          /(^|[^@])@/.source +
-	            /(?:await\b\s*)?/.source +
-	            '(?:' +
-	            /\w+\b/.source +
-	            '|' +
-	            round +
-	            ')' +
-	            '(?:' +
-	            /[?!]?\.\w+\b/.source +
-	            '|' +
-	            round +
-	            '|' +
-	            square +
-	            '|' +
-	            angle +
-	            round +
-	            ')*'
-	        ),
-	        lookbehind: true,
-	        greedy: true,
-	        alias: 'variable',
-	        inside: {
-	          keyword: /^@/,
-	          csharp: cs
-	        }
-	      },
-	      'delegate-operator': {
-	        pattern: /(^|[^@])@(?=<)/,
-	        lookbehind: true,
-	        alias: 'operator'
-	      }
-	    });
-	    Prism.languages.razor = Prism.languages.cshtml;
-	  })(Prism);
-	}
-	return cshtml_1;
+var 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 csp_1;
-var hasRequiredCsp;
-
-function requireCsp () {
-	if (hasRequiredCsp) return csp_1;
-	hasRequiredCsp = 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);
+}
 
-	csp_1 = csp;
-	csp.displayName = 'csp';
-	csp.aliases = [];
-	function csp(Prism) {
+var csp_1 = csp;
+csp.displayName = 'csp';
+csp.aliases = [];
+function csp(Prism) {
 (function (Prism) {
-	    /**
-	     * @param {string} source
-	     * @returns {RegExp}
-	     */
-	    function value(source) {
-	      return RegExp(
-	        /([ \t])/.source + '(?:' + source + ')' + /(?=[\s;]|$)/.source,
-	        'i'
-	      )
-	    }
-	    Prism.languages.csp = {
-	      directive: {
-	        pattern:
-	          /(^|[\s;])(?:base-uri|block-all-mixed-content|(?:child|connect|default|font|frame|img|manifest|media|object|prefetch|script|style|worker)-src|disown-opener|form-action|frame-(?:ancestors|options)|input-protection(?:-(?:clip|selectors))?|navigate-to|plugin-types|policy-uri|referrer|reflected-xss|report-(?:to|uri)|require-sri-for|sandbox|(?:script|style)-src-(?:attr|elem)|upgrade-insecure-requests)(?=[\s;]|$)/i,
-	        lookbehind: true,
-	        alias: 'property'
-	      },
-	      scheme: {
-	        pattern: value(/[a-z][a-z0-9.+-]*:/.source),
-	        lookbehind: true
-	      },
-	      none: {
-	        pattern: value(/'none'/.source),
-	        lookbehind: true,
-	        alias: 'keyword'
-	      },
-	      nonce: {
-	        pattern: value(/'nonce-[-+/\w=]+'/.source),
-	        lookbehind: true,
-	        alias: 'number'
-	      },
-	      hash: {
-	        pattern: value(/'sha(?:256|384|512)-[-+/\w=]+'/.source),
-	        lookbehind: true,
-	        alias: 'number'
-	      },
-	      host: {
-	        pattern: value(
-	          /[a-z][a-z0-9.+-]*:\/\/[^\s;,']*/.source +
-	            '|' +
-	            /\*[^\s;,']*/.source +
-	            '|' +
-	            /[a-z0-9-]+(?:\.[a-z0-9-]+)+(?::[\d*]+)?(?:\/[^\s;,']*)?/.source
-	        ),
-	        lookbehind: true,
-	        alias: 'url',
-	        inside: {
-	          important: /\*/
-	        }
-	      },
-	      keyword: [
-	        {
-	          pattern: value(/'unsafe-[a-z-]+'/.source),
-	          lookbehind: true,
-	          alias: 'unsafe'
-	        },
-	        {
-	          pattern: value(/'[a-z-]+'/.source),
-	          lookbehind: true,
-	          alias: 'safe'
-	        }
-	      ],
-	      punctuation: /;/
-	    };
-	  })(Prism);
-	}
-	return csp_1;
+    /**
+     * @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 cssExtras_1;
@@ -25197,7 +25110,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';
@@ -27679,7 +27592,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 = [];
@@ -40115,7 +40028,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 = [];
@@ -42892,15 +42805,15 @@ 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(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(requireCssExtras());
 refractor.register(requireCsv());
 refractor.register(requireCypher());
@@ -43063,7 +42976,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());
@@ -110183,8 +110096,8 @@ NestedPieChart.defaultProps = {
   theme: 'dark'
 };
 
-var css$4 = ".BaseWidget_module_root__d03f6b45 {\n  display: flex;\n  flex-direction: column;\n  justify-content: flex-start;\n  align-items: stretch;\n  height: 100%;\n  width: 100%;\n  padding: 0.25rem;\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 {\n  display: flex;\n  flex-direction: row;\n  justify-content: space-between;\n  align-items: center;\n  padding: 0.25rem;\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerTitle__d03f6b45 {\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-start;\n  align-items: center;\n  gap: 0.5rem;\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerTitle__d03f6b45 .BaseWidget_module_back__d03f6b45 {\n  height: 1.5rem;\n  width: 1.5rem;\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerTitle__d03f6b45 .BaseWidget_module_back__d03f6b45 [data-elem=component1] .BaseWidget_module_icon__d03f6b45 {\n  width: 1.5rem;\n  height: 1.5rem;\n  fill: var(--white);\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerTitle__d03f6b45.BaseWidget_module_noOptions__d03f6b45 {\n  flex: 1;\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerTitle__d03f6b45 .BaseWidget_module_title__d03f6b45 {\n  white-space: nowrap;\n  color: var(--white);\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerTitle__d03f6b45 .BaseWidget_module_value__d03f6b45 {\n  white-space: nowrap;\n  color: var(--white);\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerOptions__d03f6b45 {\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-end;\n  align-items: center;\n  gap: 0.5rem;\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerOptions__d03f6b45 .BaseWidget_module_toggleBody__d03f6b45 {\n  padding: 0.125rem 0.25rem;\n  height: 1.75rem;\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerOptions__d03f6b45 .BaseWidget_module_dropdownHeader__d03f6b45 {\n  height: 1.75rem;\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerOptions__d03f6b45 .BaseWidget_module_dropdownHeader__d03f6b45 [data-elem=select] {\n  background-color: transparent;\n  width: 100%;\n  color: var(--white);\n  border-color: var(--grey);\n  padding: 0.07rem 0.5rem;\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerOptions__d03f6b45 .BaseWidget_module_dropdownHeader__d03f6b45 [data-elem=select] [data-elem=placeholder] {\n  font-size: 0.875rem;\n  color: var(--white);\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerOptions__d03f6b45 .BaseWidget_module_dropdownHeader__d03f6b45 [data-elem=select] > svg {\n  fill: var(--white);\n  width: 0.875rem;\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerOptions__d03f6b45 .BaseWidget_module_expandButton__d03f6b45 {\n  height: 1.75rem;\n  color: var(--white);\n  border-color: var(--grey);\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_header__d03f6b45 .BaseWidget_module_headerOptions__d03f6b45 .BaseWidget_module_expandButton__d03f6b45 .BaseWidget_module_expandIcon__d03f6b45 {\n  height: 1.25rem;\n  width: 1.25rem;\n  fill: var(--white);\n}\n.BaseWidget_module_root__d03f6b45 .BaseWidget_module_children__d03f6b45 {\n  flex: 1 1;\n  position: relative;\n}\n\n.BaseWidget_module_dropdownPopper__d03f6b45 {\n  padding: 0rem;\n  background: var(--grey1);\n}\n.BaseWidget_module_dropdownPopper__d03f6b45 .BaseWidget_module_dropdownItem__d03f6b45 {\n  height: 2.25rem;\n  color: var(--white);\n  background: var(--grey);\n}\n.BaseWidget_module_dropdownPopper__d03f6b45 .BaseWidget_module_dropdownItem__d03f6b45:hover, .BaseWidget_module_dropdownPopper__d03f6b45 .BaseWidget_module_dropdownItem__d03f6b45:focus {\n  color: var(--dark-grey);\n  background: var(--grey2);\n}\n.BaseWidget_module_dropdownPopper__d03f6b45 .BaseWidget_module_dropdownItem__d03f6b45:hover label > svg, .BaseWidget_module_dropdownPopper__d03f6b45 .BaseWidget_module_dropdownItem__d03f6b45:focus label > svg {\n  border: 1px solid var(--dark-grey);\n  border-radius: 0.25rem;\n}";
-var modules_6a0e74b6 = {"root":"BaseWidget_module_root__d03f6b45","header":"BaseWidget_module_header__d03f6b45","header-title":"BaseWidget_module_headerTitle__d03f6b45","back":"BaseWidget_module_back__d03f6b45","icon":"BaseWidget_module_icon__d03f6b45","no-options":"BaseWidget_module_noOptions__d03f6b45","title":"BaseWidget_module_title__d03f6b45","value":"BaseWidget_module_value__d03f6b45","header-options":"BaseWidget_module_headerOptions__d03f6b45","toggle-body":"BaseWidget_module_toggleBody__d03f6b45","dropdown-header":"BaseWidget_module_dropdownHeader__d03f6b45","expand-button":"BaseWidget_module_expandButton__d03f6b45","expand-icon":"BaseWidget_module_expandIcon__d03f6b45","children":"BaseWidget_module_children__d03f6b45","dropdown-popper":"BaseWidget_module_dropdownPopper__d03f6b45","dropdown-item":"BaseWidget_module_dropdownItem__d03f6b45"};
+var css$4 = ".BaseWidget_module_root__aee86ec3 {\n  display: flex;\n  flex-direction: column;\n  justify-content: flex-start;\n  align-items: stretch;\n  height: 100%;\n  width: 100%;\n  padding: 0.25rem;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 {\n  display: flex;\n  flex-direction: row;\n  justify-content: space-between;\n  align-items: center;\n  padding: 0.25rem;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerTitle__aee86ec3 {\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-start;\n  align-items: center;\n  gap: 0.5rem;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerTitle__aee86ec3 .BaseWidget_module_back__aee86ec3 {\n  height: 1.5rem;\n  width: 1.5rem;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerTitle__aee86ec3 .BaseWidget_module_back__aee86ec3 [data-elem=component1] .BaseWidget_module_icon__aee86ec3 {\n  width: 1.5rem;\n  height: 1.5rem;\n  fill: var(--white);\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerTitle__aee86ec3.BaseWidget_module_noOptions__aee86ec3 {\n  flex: 1;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerTitle__aee86ec3 .BaseWidget_module_title__aee86ec3 {\n  white-space: nowrap;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerTitle__aee86ec3 .BaseWidget_module_value__aee86ec3 {\n  white-space: nowrap;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 {\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-end;\n  align-items: center;\n  gap: 0.5rem;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_toggleBody__aee86ec3 {\n  padding: 0.125rem 0.25rem;\n  height: 1.75rem;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_dropdownHeader__aee86ec3 {\n  height: 1.75rem;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_dropdownHeader__aee86ec3 [data-elem=select] {\n  background-color: transparent;\n  width: 100%;\n  padding: 0.07rem 0.5rem;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_dropdownHeader__aee86ec3 [data-elem=select] [data-elem=placeholder] {\n  font-size: 0.875rem;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_dropdownHeader__aee86ec3 [data-elem=select] > svg {\n  width: 0.875rem;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_expandButton__aee86ec3 {\n  height: 1.75rem;\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_expandButton__aee86ec3 .BaseWidget_module_expandIcon__aee86ec3 {\n  height: 1.25rem;\n  width: 1.25rem;\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_darkTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerTitle__aee86ec3 .BaseWidget_module_title__aee86ec3 {\n  color: var(--white);\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_darkTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerTitle__aee86ec3 .BaseWidget_module_value__aee86ec3 {\n  color: var(--white);\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_darkTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_dropdownHeader__aee86ec3 [data-elem=select] {\n  border-color: var(--grey);\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_darkTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_dropdownHeader__aee86ec3 [data-elem=select] [data-elem=placeholder] {\n  color: var(--white);\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_darkTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_dropdownHeader__aee86ec3 [data-elem=select] > svg {\n  fill: var(--white);\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_darkTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_expandButton__aee86ec3 {\n  color: var(--white);\n  border-color: var(--grey);\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_darkTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_expandButton__aee86ec3 .BaseWidget_module_expandIcon__aee86ec3 {\n  fill: var(--white);\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_lightTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerTitle__aee86ec3 .BaseWidget_module_title__aee86ec3 {\n  color: var(--dark-grey);\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_lightTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerTitle__aee86ec3 .BaseWidget_module_value__aee86ec3 {\n  color: var(--dark-grey);\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_lightTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_dropdownHeader__aee86ec3 [data-elem=select] {\n  border-color: var(--grey6);\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_lightTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_dropdownHeader__aee86ec3 [data-elem=select] [data-elem=placeholder] {\n  color: var(--dark-grey);\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_lightTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_dropdownHeader__aee86ec3 [data-elem=select] > svg {\n  fill: var(--dark-grey);\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_lightTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_expandButton__aee86ec3 {\n  color: var(--dark-grey);\n  border-color: var(--grey6);\n}\n.BaseWidget_module_root__aee86ec3.BaseWidget_module_lightTheme__aee86ec3 .BaseWidget_module_header__aee86ec3 .BaseWidget_module_headerOptions__aee86ec3 .BaseWidget_module_expandButton__aee86ec3 .BaseWidget_module_expandIcon__aee86ec3 {\n  fill: var(--dark-grey);\n}\n.BaseWidget_module_root__aee86ec3 .BaseWidget_module_children__aee86ec3 {\n  flex: 1 1;\n  position: relative;\n}\n\n.BaseWidget_module_dropdownPopper__aee86ec3 {\n  padding: 0rem;\n  background: var(--grey1);\n}\n.BaseWidget_module_dropdownPopper__aee86ec3 .BaseWidget_module_dropdownItem__aee86ec3 {\n  height: 2.25rem;\n  color: var(--white);\n  background: var(--grey);\n}\n.BaseWidget_module_dropdownPopper__aee86ec3 .BaseWidget_module_dropdownItem__aee86ec3:hover, .BaseWidget_module_dropdownPopper__aee86ec3 .BaseWidget_module_dropdownItem__aee86ec3:focus {\n  color: var(--dark-grey);\n  background: var(--grey2);\n}\n.BaseWidget_module_dropdownPopper__aee86ec3 .BaseWidget_module_dropdownItem__aee86ec3:hover label > svg, .BaseWidget_module_dropdownPopper__aee86ec3 .BaseWidget_module_dropdownItem__aee86ec3:focus label > svg {\n  border: 1px solid var(--dark-grey);\n  border-radius: 0.25rem;\n}";
+var modules_6a0e74b6 = {"root":"BaseWidget_module_root__aee86ec3","header":"BaseWidget_module_header__aee86ec3","header-title":"BaseWidget_module_headerTitle__aee86ec3","back":"BaseWidget_module_back__aee86ec3","icon":"BaseWidget_module_icon__aee86ec3","no-options":"BaseWidget_module_noOptions__aee86ec3","title":"BaseWidget_module_title__aee86ec3","value":"BaseWidget_module_value__aee86ec3","header-options":"BaseWidget_module_headerOptions__aee86ec3","toggle-body":"BaseWidget_module_toggleBody__aee86ec3","dropdown-header":"BaseWidget_module_dropdownHeader__aee86ec3","expand-button":"BaseWidget_module_expandButton__aee86ec3","expand-icon":"BaseWidget_module_expandIcon__aee86ec3","dark-theme":"BaseWidget_module_darkTheme__aee86ec3","light-theme":"BaseWidget_module_lightTheme__aee86ec3","children":"BaseWidget_module_children__aee86ec3","dropdown-popper":"BaseWidget_module_dropdownPopper__aee86ec3","dropdown-item":"BaseWidget_module_dropdownItem__aee86ec3"};
 n(css$4,{});
 
 var css$3 = "div.Toggle_module_root__7f4ba8d3 {\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-start;\n  align-items: center;\n  overflow: auto;\n  gap: 0.25rem;\n  padding: 0.25rem;\n  background: var(--grey8);\n  width: -webkit-fit-content;\n  width: -moz-fit-content;\n  width: fit-content;\n  border-radius: 0.4rem 0.4rem;\n  border-width: 1px;\n  border-style: solid;\n  background: transparent;\n}\ndiv.Toggle_module_root__7f4ba8d3 [data-elem=base-cell].Toggle_module_toggleButton__7f4ba8d3 {\n  background: transparent;\n}\ndiv.Toggle_module_root__7f4ba8d3.Toggle_module_themeDark__7f4ba8d3 {\n  border-color: var(--dark-grey);\n}\ndiv.Toggle_module_root__7f4ba8d3.Toggle_module_themeDark__7f4ba8d3 [data-elem=base-cell].Toggle_module_toggleButton__7f4ba8d3 {\n  color: var(--grey4);\n}\ndiv.Toggle_module_root__7f4ba8d3.Toggle_module_themeDark__7f4ba8d3 [data-elem=base-cell].Toggle_module_toggleButton__7f4ba8d3.Toggle_module_active__7f4ba8d3 {\n  background: var(--dark-grey);\n  color: var(--white);\n  border: 1px solid var(--grey);\n}\ndiv.Toggle_module_root__7f4ba8d3.Toggle_module_themeLight__7f4ba8d3 {\n  border-color: var(--grey6);\n}\ndiv.Toggle_module_root__7f4ba8d3.Toggle_module_themeLight__7f4ba8d3 [data-elem=base-cell].Toggle_module_toggleButton__7f4ba8d3 {\n  background: transparent;\n  color: var(--grey);\n}\ndiv.Toggle_module_root__7f4ba8d3.Toggle_module_themeLight__7f4ba8d3 [data-elem=base-cell].Toggle_module_toggleButton__7f4ba8d3.Toggle_module_active__7f4ba8d3 {\n  background: var(--grey6);\n  color: var(--dark-grey);\n  border: 1px solid var(--grey4);\n}\ndiv.Toggle_module_root__7f4ba8d3 [data-elem=base-cell].Toggle_module_toggleButton__7f4ba8d3 {\n  padding: 0.344rem 0.75rem;\n  height: 2rem;\n}\ndiv.Toggle_module_root__7f4ba8d3 [data-elem=base-cell].Toggle_module_toggleButton__7f4ba8d3.Toggle_module_active__7f4ba8d3 {\n  border-radius: 0.25rem;\n}\ndiv.Toggle_module_root__7f4ba8d3 .Toggle_module_input__7f4ba8d3 {\n  display: none;\n}";
@@ -110382,20 +110295,20 @@ WidgetFallback.defaultProps = {
   theme: 'dark'
 };
 
-var generateOptions = function generateOptions(optionData) {
+var generateOptions = function generateOptions(optionData, theme) {
   var _optionData$id, _optionData$placehold, _optionData$value, _optionData$onChange, _optionData$selectOpt, _optionData$title, _optionData$onClick;
   switch ((_optionData$id = optionData === null || optionData === void 0 ? void 0 : optionData.id) !== null && _optionData$id !== void 0 ? _optionData$id : '') {
     case 'toggle':
       return /*#__PURE__*/jsxRuntime.jsx(Toggle, _objectSpread2({
         className: modules_6a0e74b6['toggle-body'],
-        theme: "dark"
+        theme: theme
       }, optionData));
     case 'dropdown':
       return /*#__PURE__*/jsxRuntime.jsx(Dropdown, {
         placeholder: (_optionData$placehold = optionData === null || optionData === void 0 ? void 0 : optionData.placeholder) !== null && _optionData$placehold !== void 0 ? _optionData$placehold : '',
         value: (_optionData$value = optionData === null || optionData === void 0 ? void 0 : optionData.value) !== null && _optionData$value !== void 0 ? _optionData$value : '',
         onChange: (_optionData$onChange = optionData === null || optionData === void 0 ? void 0 : optionData.onChange) !== null && _optionData$onChange !== void 0 ? _optionData$onChange : '',
-        className: modules_6a0e74b6['dropdown-header'],
+        className: classes(modules_6a0e74b6['dropdown-header']),
         popperClassName: modules_6a0e74b6['dropdown-popper'],
         children: ((_optionData$selectOpt = optionData === null || optionData === void 0 ? void 0 : optionData.selectOption) !== null && _optionData$selectOpt !== void 0 ? _optionData$selectOpt : []).map(function (objectData) {
           var _objectData$title, _objectData$value, _objectData$value2;
@@ -110421,7 +110334,9 @@ var generateOptions = function generateOptions(optionData) {
         }
       });
     case 'custom':
-      return optionData.render();
+      return optionData.render({
+        theme: theme
+      });
     default:
       return null;
   }
@@ -110459,7 +110374,7 @@ var BaseWidget = /*#__PURE__*/React.forwardRef(function BaseWidget(props, ref) {
   }, [emptyChartData]);
   return /*#__PURE__*/jsxRuntime.jsxs("div", {
     ref: ref,
-    className: classes(modules_6a0e74b6.root, className),
+    className: classes(modules_6a0e74b6.root, className, modules_6a0e74b6["".concat(theme, "-theme")]),
     style: style,
     onMouseDown: onMouseDown,
     onMouseUp: onMouseUp,
@@ -110487,10 +110402,10 @@ var BaseWidget = /*#__PURE__*/React.forwardRef(function BaseWidget(props, ref) {
           children: title
         })]
       }), /*#__PURE__*/jsxRuntime.jsx("div", {
-        className: modules_6a0e74b6['header-options'],
+        className: classes(modules_6a0e74b6['header-options']),
         "data-elem": "header-options",
         children: ((_options$length2 = options === null || options === void 0 ? void 0 : options.length) !== null && _options$length2 !== void 0 ? _options$length2 : 0) > 0 && (options === null || options === void 0 ? void 0 : options.map(function (objectData) {
-          return generateOptions(objectData);
+          return generateOptions(objectData, theme);
         }))
       })]
     }), /*#__PURE__*/jsxRuntime.jsxs("div", {