react-ai-renderer 0.1.5 → 0.1.7

package/dist/index.cjs

@@ -5775,126 +5775,134 @@ function c(Prism) {
   delete Prism.languages.c['boolean'];
 }
 
-var refractorC$1 = c_1;
-var cpp_1 = cpp;
-cpp.displayName = 'cpp';
-cpp.aliases = [];
-function cpp(Prism) {
-  Prism.register(refractorC$1)
-  ;(function (Prism) {
-    var keyword =
-      /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/;
-    var modName = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(
-      /<keyword>/g,
-      function () {
-        return keyword.source
-      }
-    );
-    Prism.languages.cpp = Prism.languages.extend('c', {
-      'class-name': [
-        {
-          pattern: RegExp(
-            /(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(
-              /<keyword>/g,
-              function () {
-                return keyword.source
-              }
-            )
-          ),
-          lookbehind: true
-        }, // This is intended to capture the class name of method implementations like:
-        //   void foo::bar() const {}
-        // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
-        // it starts with an uppercase letter. This approximation should give decent results.
-        /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, // This will capture the class name before destructors like:
-        //   Foo::~Foo() {}
-        /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, // This also intends to capture the class name of method implementations but here the class has template
-        // parameters, so it can't be a namespace (until C++ adds generic namespaces).
-        /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
-      ],
-      keyword: keyword,
-      number: {
-        pattern:
-          /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
-        greedy: true
-      },
-      operator:
-        />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
-      boolean: /\b(?:false|true)\b/
-    });
-    Prism.languages.insertBefore('cpp', 'string', {
-      module: {
-        // https://en.cppreference.com/w/cpp/language/modules
-        pattern: RegExp(
-          /(\b(?:import|module)\s+)/.source +
-            '(?:' + // header-name
-            /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source +
-            '|' + // module name or partition or both
-            /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(
-              /<mod-name>/g,
-              function () {
-                return modName
-              }
-            ) +
-            ')'
-        ),
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          string: /^[<"][\s\S]+/,
-          operator: /:/,
-          punctuation: /\./
-        }
-      },
-      'raw-string': {
-        pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
-        alias: 'string',
-        greedy: true
-      }
-    });
-    Prism.languages.insertBefore('cpp', 'keyword', {
-      'generic-function': {
-        pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
-        inside: {
-          function: /^\w+/,
-          generic: {
-            pattern: /<[\s\S]+/,
-            alias: 'class-name',
-            inside: Prism.languages.cpp
-          }
-        }
-      }
-    });
-    Prism.languages.insertBefore('cpp', 'operator', {
-      'double-colon': {
-        pattern: /::/,
-        alias: 'punctuation'
-      }
-    });
-    Prism.languages.insertBefore('cpp', 'class-name', {
-      // the base clause is an optional list of parent classes
-      // https://en.cppreference.com/w/cpp/language/class
-      'base-clause': {
-        pattern:
-          /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
-        lookbehind: true,
-        greedy: true,
-        inside: Prism.languages.extend('cpp', {})
-      }
-    });
-    Prism.languages.insertBefore(
-      'inside',
-      'double-colon',
-      {
-        // All untokenized words that are not namespaces should be class names
-        'class-name': /\b[a-z_]\w*\b(?!\s*::)/i
-      },
-      Prism.languages.cpp['base-clause']
-    );
-  })(Prism);
+var cpp_1;
+var hasRequiredCpp;
+
+function requireCpp () {
+	if (hasRequiredCpp) return cpp_1;
+	hasRequiredCpp = 1;
+	var refractorC = c_1;
+	cpp_1 = cpp;
+	cpp.displayName = 'cpp';
+	cpp.aliases = [];
+	function cpp(Prism) {
+	  Prism.register(refractorC)
+	  ;(function (Prism) {
+	    var keyword =
+	      /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/;
+	    var modName = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(
+	      /<keyword>/g,
+	      function () {
+	        return keyword.source
+	      }
+	    );
+	    Prism.languages.cpp = Prism.languages.extend('c', {
+	      'class-name': [
+	        {
+	          pattern: RegExp(
+	            /(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(
+	              /<keyword>/g,
+	              function () {
+	                return keyword.source
+	              }
+	            )
+	          ),
+	          lookbehind: true
+	        }, // This is intended to capture the class name of method implementations like:
+	        //   void foo::bar() const {}
+	        // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
+	        // it starts with an uppercase letter. This approximation should give decent results.
+	        /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, // This will capture the class name before destructors like:
+	        //   Foo::~Foo() {}
+	        /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, // This also intends to capture the class name of method implementations but here the class has template
+	        // parameters, so it can't be a namespace (until C++ adds generic namespaces).
+	        /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
+	      ],
+	      keyword: keyword,
+	      number: {
+	        pattern:
+	          /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
+	        greedy: true
+	      },
+	      operator:
+	        />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
+	      boolean: /\b(?:false|true)\b/
+	    });
+	    Prism.languages.insertBefore('cpp', 'string', {
+	      module: {
+	        // https://en.cppreference.com/w/cpp/language/modules
+	        pattern: RegExp(
+	          /(\b(?:import|module)\s+)/.source +
+	            '(?:' + // header-name
+	            /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source +
+	            '|' + // module name or partition or both
+	            /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(
+	              /<mod-name>/g,
+	              function () {
+	                return modName
+	              }
+	            ) +
+	            ')'
+	        ),
+	        lookbehind: true,
+	        greedy: true,
+	        inside: {
+	          string: /^[<"][\s\S]+/,
+	          operator: /:/,
+	          punctuation: /\./
+	        }
+	      },
+	      'raw-string': {
+	        pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
+	        alias: 'string',
+	        greedy: true
+	      }
+	    });
+	    Prism.languages.insertBefore('cpp', 'keyword', {
+	      'generic-function': {
+	        pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
+	        inside: {
+	          function: /^\w+/,
+	          generic: {
+	            pattern: /<[\s\S]+/,
+	            alias: 'class-name',
+	            inside: Prism.languages.cpp
+	          }
+	        }
+	      }
+	    });
+	    Prism.languages.insertBefore('cpp', 'operator', {
+	      'double-colon': {
+	        pattern: /::/,
+	        alias: 'punctuation'
+	      }
+	    });
+	    Prism.languages.insertBefore('cpp', 'class-name', {
+	      // the base clause is an optional list of parent classes
+	      // https://en.cppreference.com/w/cpp/language/class
+	      'base-clause': {
+	        pattern:
+	          /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
+	        lookbehind: true,
+	        greedy: true,
+	        inside: Prism.languages.extend('cpp', {})
+	      }
+	    });
+	    Prism.languages.insertBefore(
+	      'inside',
+	      'double-colon',
+	      {
+	        // All untokenized words that are not namespaces should be class names
+	        'class-name': /\b[a-z_]\w*\b(?!\s*::)/i
+	      },
+	      Prism.languages.cpp['base-clause']
+	    );
+	  })(Prism);
+	}
+	return cpp_1;
 }
 
-var refractorCpp$1 = cpp_1;
+var refractorCpp$1 = requireCpp();
 var arduino_1 = arduino;
 arduino.displayName = 'arduino';
 arduino.aliases = ['ino'];
@@ -7895,7 +7903,7 @@ function cfscript(Prism) {
   Prism.languages.cfc = Prism.languages['cfscript'];
 }
 
-var refractorCpp = cpp_1;
+var refractorCpp = requireCpp();
 var chaiscript_1 = chaiscript;
 chaiscript.displayName = 'chaiscript';
 chaiscript.aliases = [];
@@ -8543,12 +8551,12 @@ function ruby(Prism) {
   })(Prism);
 }
 
-var refractorRuby$1 = ruby_1;
+var refractorRuby = ruby_1;
 var crystal_1 = crystal;
 crystal.displayName = 'crystal';
 crystal.aliases = [];
 function crystal(Prism) {
-  Prism.register(refractorRuby$1)
+  Prism.register(refractorRuby)
   ;(function (Prism) {
     Prism.languages.crystal = Prism.languages.extend('ruby', {
       keyword: [
@@ -9015,15 +9023,24 @@ function cssExtras(Prism) {
   })(Prism);
 }
 
-var csv_1 = csv;
-csv.displayName = 'csv';
-csv.aliases = [];
-function csv(Prism) {
-  // https://tools.ietf.org/html/rfc4180
-  Prism.languages.csv = {
-    value: /[^\r\n,"]+|"(?:[^"]|"")*"(?!")/,
-    punctuation: /,/
-  };
+var csv_1;
+var hasRequiredCsv;
+
+function requireCsv () {
+	if (hasRequiredCsv) return csv_1;
+	hasRequiredCsv = 1;
+
+	csv_1 = csv;
+	csv.displayName = 'csv';
+	csv.aliases = [];
+	function csv(Prism) {
+	  // https://tools.ietf.org/html/rfc4180
+	  Prism.languages.csv = {
+	    value: /[^\r\n,"]+|"(?:[^"]|"")*"(?!")/,
+	    punctuation: /,/
+	  };
+	}
+	return csv_1;
 }
 
 var cypher_1 = cypher;
@@ -9595,12 +9612,12 @@ function requireMarkupTemplating () {
 	return markupTemplating_1;
 }
 
-var refractorMarkupTemplating$3 = requireMarkupTemplating();
+var refractorMarkupTemplating$1 = requireMarkupTemplating();
 var django_1 = django;
 django.displayName = 'django';
 django.aliases = ['jinja2'];
 function django(Prism) {
-  Prism.register(refractorMarkupTemplating$3)
+  Prism.register(refractorMarkupTemplating$1)
   // Django/Jinja2 syntax definition for Prism.js <http://prismjs.com> syntax highlighter.
   // Mostly it works OK but can paint code incorrectly on complex html/template tag combinations.
   ;(function (Prism) {
@@ -9817,96 +9834,87 @@ function docker(Prism) {
   })(Prism);
 }
 
-var dot_1;
-var hasRequiredDot;
-
-function requireDot () {
-	if (hasRequiredDot) return dot_1;
-	hasRequiredDot = 1;
-
-	dot_1 = dot;
-	dot.displayName = 'dot';
-	dot.aliases = ['gv'];
-	function dot(Prism) {
+var dot_1 = dot;
+dot.displayName = 'dot';
+dot.aliases = ['gv'];
+function dot(Prism) {
 (function (Prism) {
-	    var ID =
-	      '(?:' +
-	      [
-	        // an identifier
-	        /[a-zA-Z_\x80-\uFFFF][\w\x80-\uFFFF]*/.source, // a number
-	        /-?(?:\.\d+|\d+(?:\.\d*)?)/.source, // a double-quoted string
-	        /"[^"\\]*(?:\\[\s\S][^"\\]*)*"/.source, // HTML-like string
-	        /<(?:[^<>]|(?!<!--)<(?:[^<>"']|"[^"]*"|'[^']*')+>|<!--(?:[^-]|-(?!->))*-->)*>/
-	          .source
-	      ].join('|') +
-	      ')';
-	    var IDInside = {
-	      markup: {
-	        pattern: /(^<)[\s\S]+(?=>$)/,
-	        lookbehind: true,
-	        alias: ['language-markup', 'language-html', 'language-xml'],
-	        inside: Prism.languages.markup
-	      }
-	    };
-	    /**
-	     * @param {string} source
-	     * @param {string} flags
-	     * @returns {RegExp}
-	     */
-	    function withID(source, flags) {
-	      return RegExp(
-	        source.replace(/<ID>/g, function () {
-	          return ID
-	        }),
-	        flags
-	      )
-	    }
-	    Prism.languages.dot = {
-	      comment: {
-	        pattern: /\/\/.*|\/\*[\s\S]*?\*\/|^#.*/m,
-	        greedy: true
-	      },
-	      'graph-name': {
-	        pattern: withID(
-	          /(\b(?:digraph|graph|subgraph)[ \t\r\n]+)<ID>/.source,
-	          'i'
-	        ),
-	        lookbehind: true,
-	        greedy: true,
-	        alias: 'class-name',
-	        inside: IDInside
-	      },
-	      'attr-value': {
-	        pattern: withID(/(=[ \t\r\n]*)<ID>/.source),
-	        lookbehind: true,
-	        greedy: true,
-	        inside: IDInside
-	      },
-	      'attr-name': {
-	        pattern: withID(/([\[;, \t\r\n])<ID>(?=[ \t\r\n]*=)/.source),
-	        lookbehind: true,
-	        greedy: true,
-	        inside: IDInside
-	      },
-	      keyword: /\b(?:digraph|edge|graph|node|strict|subgraph)\b/i,
-	      'compass-point': {
-	        pattern: /(:[ \t\r\n]*)(?:[ewc_]|[ns][ew]?)(?![\w\x80-\uFFFF])/,
-	        lookbehind: true,
-	        alias: 'builtin'
-	      },
-	      node: {
-	        pattern: withID(/(^|[^-.\w\x80-\uFFFF\\])<ID>/.source),
-	        lookbehind: true,
-	        greedy: true,
-	        inside: IDInside
-	      },
-	      operator: /[=:]|-[->]/,
-	      punctuation: /[\[\]{};,]/
-	    };
-	    Prism.languages.gv = Prism.languages.dot;
-	  })(Prism);
-	}
-	return dot_1;
+    var ID =
+      '(?:' +
+      [
+        // an identifier
+        /[a-zA-Z_\x80-\uFFFF][\w\x80-\uFFFF]*/.source, // a number
+        /-?(?:\.\d+|\d+(?:\.\d*)?)/.source, // a double-quoted string
+        /"[^"\\]*(?:\\[\s\S][^"\\]*)*"/.source, // HTML-like string
+        /<(?:[^<>]|(?!<!--)<(?:[^<>"']|"[^"]*"|'[^']*')+>|<!--(?:[^-]|-(?!->))*-->)*>/
+          .source
+      ].join('|') +
+      ')';
+    var IDInside = {
+      markup: {
+        pattern: /(^<)[\s\S]+(?=>$)/,
+        lookbehind: true,
+        alias: ['language-markup', 'language-html', 'language-xml'],
+        inside: Prism.languages.markup
+      }
+    };
+    /**
+     * @param {string} source
+     * @param {string} flags
+     * @returns {RegExp}
+     */
+    function withID(source, flags) {
+      return RegExp(
+        source.replace(/<ID>/g, function () {
+          return ID
+        }),
+        flags
+      )
+    }
+    Prism.languages.dot = {
+      comment: {
+        pattern: /\/\/.*|\/\*[\s\S]*?\*\/|^#.*/m,
+        greedy: true
+      },
+      'graph-name': {
+        pattern: withID(
+          /(\b(?:digraph|graph|subgraph)[ \t\r\n]+)<ID>/.source,
+          'i'
+        ),
+        lookbehind: true,
+        greedy: true,
+        alias: 'class-name',
+        inside: IDInside
+      },
+      'attr-value': {
+        pattern: withID(/(=[ \t\r\n]*)<ID>/.source),
+        lookbehind: true,
+        greedy: true,
+        inside: IDInside
+      },
+      'attr-name': {
+        pattern: withID(/([\[;, \t\r\n])<ID>(?=[ \t\r\n]*=)/.source),
+        lookbehind: true,
+        greedy: true,
+        inside: IDInside
+      },
+      keyword: /\b(?:digraph|edge|graph|node|strict|subgraph)\b/i,
+      'compass-point': {
+        pattern: /(:[ \t\r\n]*)(?:[ewc_]|[ns][ew]?)(?![\w\x80-\uFFFF])/,
+        lookbehind: true,
+        alias: 'builtin'
+      },
+      node: {
+        pattern: withID(/(^|[^-.\w\x80-\uFFFF\\])<ID>/.source),
+        lookbehind: true,
+        greedy: true,
+        inside: IDInside
+      },
+      operator: /[=:]|-[->]/,
+      punctuation: /[\[\]{};,]/
+    };
+    Prism.languages.gv = Prism.languages.dot;
+  })(Prism);
 }
 
 var ebnf_1;
@@ -9944,83 +9952,101 @@ function requireEbnf () {
 	return ebnf_1;
 }
 
-var editorconfig_1 = editorconfig;
-editorconfig.displayName = 'editorconfig';
-editorconfig.aliases = [];
-function editorconfig(Prism) {
-  Prism.languages.editorconfig = {
-    // https://editorconfig-specification.readthedocs.io
-    comment: /[;#].*/,
-    section: {
-      pattern: /(^[ \t]*)\[.+\]/m,
-      lookbehind: true,
-      alias: 'selector',
-      inside: {
-        regex: /\\\\[\[\]{},!?.*]/,
-        // Escape special characters with '\\'
-        operator: /[!?]|\.\.|\*{1,2}/,
-        punctuation: /[\[\]{},]/
-      }
-    },
-    key: {
-      pattern: /(^[ \t]*)[^\s=]+(?=[ \t]*=)/m,
-      lookbehind: true,
-      alias: 'attr-name'
-    },
-    value: {
-      pattern: /=.*/,
-      alias: 'attr-value',
-      inside: {
-        punctuation: /^=/
-      }
-    }
-  };
-}
+var editorconfig_1;
+var hasRequiredEditorconfig;
 
-var eiffel_1 = eiffel;
-eiffel.displayName = 'eiffel';
-eiffel.aliases = [];
-function eiffel(Prism) {
-  Prism.languages.eiffel = {
-    comment: /--.*/,
-    string: [
-      // Aligned-verbatim-strings
-      {
-        pattern: /"([^[]*)\[[\s\S]*?\]\1"/,
-        greedy: true
-      }, // Non-aligned-verbatim-strings
-      {
-        pattern: /"([^{]*)\{[\s\S]*?\}\1"/,
-        greedy: true
-      }, // Single-line string
-      {
-        pattern: /"(?:%(?:(?!\n)\s)*\n\s*%|%\S|[^%"\r\n])*"/,
-        greedy: true
-      }
-    ],
-    // normal char | special char | char code
-    char: /'(?:%.|[^%'\r\n])+'/,
-    keyword:
-      /\b(?:across|agent|alias|all|and|as|assign|attached|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor)\b/i,
-    boolean: /\b(?:False|True)\b/i,
-    // Convention: class-names are always all upper-case characters
-    'class-name': /\b[A-Z][\dA-Z_]*\b/,
-    number: [
-      // hexa | octal | bin
-      /\b0[xcb][\da-f](?:_*[\da-f])*\b/i, // Decimal
-      /(?:\b\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?e[+-]?)?\d(?:_*\d)*\b|\b\d(?:_*\d)*\b\.?/i
-    ],
-    punctuation: /:=|<<|>>|\(\||\|\)|->|\.(?=\w)|[{}[\];(),:?]/,
-    operator: /\\\\|\|\.\.\||\.\.|\/[~\/=]?|[><]=?|[-+*^=~]/
-  };
+function requireEditorconfig () {
+	if (hasRequiredEditorconfig) return editorconfig_1;
+	hasRequiredEditorconfig = 1;
+
+	editorconfig_1 = editorconfig;
+	editorconfig.displayName = 'editorconfig';
+	editorconfig.aliases = [];
+	function editorconfig(Prism) {
+	  Prism.languages.editorconfig = {
+	    // https://editorconfig-specification.readthedocs.io
+	    comment: /[;#].*/,
+	    section: {
+	      pattern: /(^[ \t]*)\[.+\]/m,
+	      lookbehind: true,
+	      alias: 'selector',
+	      inside: {
+	        regex: /\\\\[\[\]{},!?.*]/,
+	        // Escape special characters with '\\'
+	        operator: /[!?]|\.\.|\*{1,2}/,
+	        punctuation: /[\[\]{},]/
+	      }
+	    },
+	    key: {
+	      pattern: /(^[ \t]*)[^\s=]+(?=[ \t]*=)/m,
+	      lookbehind: true,
+	      alias: 'attr-name'
+	    },
+	    value: {
+	      pattern: /=.*/,
+	      alias: 'attr-value',
+	      inside: {
+	        punctuation: /^=/
+	      }
+	    }
+	  };
+	}
+	return editorconfig_1;
 }
 
-var refractorMarkupTemplating$2 = requireMarkupTemplating();
-var ejs_1 = ejs;
-ejs.displayName = 'ejs';
+var eiffel_1;
+var hasRequiredEiffel;
+
+function requireEiffel () {
+	if (hasRequiredEiffel) return eiffel_1;
+	hasRequiredEiffel = 1;
+
+	eiffel_1 = eiffel;
+	eiffel.displayName = 'eiffel';
+	eiffel.aliases = [];
+	function eiffel(Prism) {
+	  Prism.languages.eiffel = {
+	    comment: /--.*/,
+	    string: [
+	      // Aligned-verbatim-strings
+	      {
+	        pattern: /"([^[]*)\[[\s\S]*?\]\1"/,
+	        greedy: true
+	      }, // Non-aligned-verbatim-strings
+	      {
+	        pattern: /"([^{]*)\{[\s\S]*?\}\1"/,
+	        greedy: true
+	      }, // Single-line string
+	      {
+	        pattern: /"(?:%(?:(?!\n)\s)*\n\s*%|%\S|[^%"\r\n])*"/,
+	        greedy: true
+	      }
+	    ],
+	    // normal char | special char | char code
+	    char: /'(?:%.|[^%'\r\n])+'/,
+	    keyword:
+	      /\b(?:across|agent|alias|all|and|as|assign|attached|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor)\b/i,
+	    boolean: /\b(?:False|True)\b/i,
+	    // Convention: class-names are always all upper-case characters
+	    'class-name': /\b[A-Z][\dA-Z_]*\b/,
+	    number: [
+	      // hexa | octal | bin
+	      /\b0[xcb][\da-f](?:_*[\da-f])*\b/i, // Decimal
+	      /(?:\b\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?e[+-]?)?\d(?:_*\d)*\b|\b\d(?:_*\d)*\b\.?/i
+	    ],
+	    punctuation: /:=|<<|>>|\(\||\|\)|->|\.(?=\w)|[{}[\];(),:?]/,
+	    operator: /\\\\|\|\.\.\||\.\.|\/[~\/=]?|[><]=?|[-+*^=~]/
+	  };
+	}
+	return eiffel_1;
+}
+
+var refractorMarkupTemplating = requireMarkupTemplating();
+var ejs_1 = ejs;
+ejs.displayName = 'ejs';
 ejs.aliases = ['eta'];
 function ejs(Prism) {
-  Prism.register(refractorMarkupTemplating$2)
+  Prism.register(refractorMarkupTemplating)
   ;(function (Prism) {
     Prism.languages.ejs = {
       delimiter: {
@@ -10048,1561 +10074,1676 @@ function ejs(Prism) {
   })(Prism);
 }
 
-var elixir_1 = elixir;
-elixir.displayName = 'elixir';
-elixir.aliases = [];
-function elixir(Prism) {
-  Prism.languages.elixir = {
-    doc: {
-      pattern:
-        /@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/,
-      inside: {
-        attribute: /^@\w+/,
-        string: /['"][\s\S]+/
-      }
-    },
-    comment: {
-      pattern: /#.*/,
-      greedy: true
-    },
-    // ~r"""foo""" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r"foo", ~r'foo', ~r(foo), ~r[foo], ~r{foo}, ~r<foo>
-    regex: {
-      pattern:
-        /~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/,
-      greedy: true
-    },
-    string: [
-      {
-        // ~s"""foo""" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s"foo", ~s'foo', ~s(foo), ~s[foo], ~s{foo} (with interpolation care), ~s<foo>
-        pattern:
-          /~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|#(?!\{)|[^#\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,
-        greedy: true,
-        inside: {
-          // See interpolation below
-        }
-      },
-      {
-        pattern: /("""|''')[\s\S]*?\1/,
-        greedy: true,
-        inside: {
-          // See interpolation below
-        }
-      },
-      {
-        // Multi-line strings are allowed
-        pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-        greedy: true,
-        inside: {
-          // See interpolation below
-        }
-      }
-    ],
-    atom: {
-      // Look-behind prevents bad highlighting of the :: operator
-      pattern: /(^|[^:]):\w+/,
-      lookbehind: true,
-      alias: 'symbol'
-    },
-    module: {
-      pattern: /\b[A-Z]\w*\b/,
-      alias: 'class-name'
-    },
-    // Look-ahead prevents bad highlighting of the :: operator
-    'attr-name': /\b\w+\??:(?!:)/,
-    argument: {
-      // Look-behind prevents bad highlighting of the && operator
-      pattern: /(^|[^&])&\d+/,
-      lookbehind: true,
-      alias: 'variable'
-    },
-    attribute: {
-      pattern: /@\w+/,
-      alias: 'variable'
-    },
-    function: /\b[_a-zA-Z]\w*[?!]?(?:(?=\s*(?:\.\s*)?\()|(?=\/\d))/,
-    number: /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i,
-    keyword:
-      /\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\b/,
-    boolean: /\b(?:false|nil|true)\b/,
-    operator: [
-      /\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/,
-      {
-        // We don't want to match <<
-        pattern: /([^<])<(?!<)/,
-        lookbehind: true
-      },
-      {
-        // We don't want to match >>
-        pattern: /([^>])>(?!>)/,
-        lookbehind: true
-      }
-    ],
-    punctuation: /<<|>>|[.,%\[\]{}()]/
-  };
-  Prism.languages.elixir.string.forEach(function (o) {
-    o.inside = {
-      interpolation: {
-        pattern: /#\{[^}]+\}/,
-        inside: {
-          delimiter: {
-            pattern: /^#\{|\}$/,
-            alias: 'punctuation'
-          },
-          rest: Prism.languages.elixir
-        }
-      }
-    };
-  });
-}
+var elixir_1;
+var hasRequiredElixir;
 
-var elm_1 = elm;
-elm.displayName = 'elm';
-elm.aliases = [];
-function elm(Prism) {
-  Prism.languages.elm = {
-    comment: /--.*|\{-[\s\S]*?-\}/,
-    char: {
-      pattern:
-        /'(?:[^\\'\r\n]|\\(?:[abfnrtv\\']|\d+|x[0-9a-fA-F]+|u\{[0-9a-fA-F]+\}))'/,
-      greedy: true
-    },
-    string: [
-      {
-        // Multiline strings are wrapped in triple ". Quotes may appear unescaped.
-        pattern: /"""[\s\S]*?"""/,
-        greedy: true
-      },
-      {
-        pattern: /"(?:[^\\"\r\n]|\\.)*"/,
-        greedy: true
-      }
-    ],
-    'import-statement': {
-      // The imported or hidden names are not included in this import
-      // statement. This is because we want to highlight those exactly like
-      // we do for the names in the program.
-      pattern:
-        /(^[\t ]*)import\s+[A-Z]\w*(?:\.[A-Z]\w*)*(?:\s+as\s+(?:[A-Z]\w*)(?:\.[A-Z]\w*)*)?(?:\s+exposing\s+)?/m,
-      lookbehind: true,
-      inside: {
-        keyword: /\b(?:as|exposing|import)\b/
-      }
-    },
-    keyword:
-      /\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\b/,
-    // These are builtin variables only. Constructors are highlighted later as a constant.
-    builtin:
-      /\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\b/,
-    // decimal integers and floating point numbers | hexadecimal integers
-    number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[0-9a-f]+)\b/i,
-    // Most of this is needed because of the meaning of a single '.'.
-    // If it stands alone freely, it is the function composition.
-    // It may also be a separator between a module name and an identifier => no
-    // operator. If it comes together with other special characters it is an
-    // operator too.
-    // Valid operator characters in 0.18: +-/*=.$<>:&|^?%#@~!
-    // Ref: https://groups.google.com/forum/#!msg/elm-dev/0AHSnDdkSkQ/E0SVU70JEQAJ
-    operator: /\s\.\s|[+\-/*=.$<>:&|^?%#@~!]{2,}|[+\-/*=$<>:&|^?%#@~!]/,
-    // In Elm, nearly everything is a variable, do not highlight these.
-    hvariable: /\b(?:[A-Z]\w*\.)*[a-z]\w*\b/,
-    constant: /\b(?:[A-Z]\w*\.)*[A-Z]\w*\b/,
-    punctuation: /[{}[\]|(),.:]/
-  };
-}
+function requireElixir () {
+	if (hasRequiredElixir) return elixir_1;
+	hasRequiredElixir = 1;
 
-var refractorRuby = ruby_1;
-var refractorMarkupTemplating$1 = requireMarkupTemplating();
-var erb_1 = erb;
-erb.displayName = 'erb';
-erb.aliases = [];
-function erb(Prism) {
-  Prism.register(refractorRuby);
-  Prism.register(refractorMarkupTemplating$1)
-  ;(function (Prism) {
-    Prism.languages.erb = {
-      delimiter: {
-        pattern: /^(\s*)<%=?|%>(?=\s*$)/,
-        lookbehind: true,
-        alias: 'punctuation'
-      },
-      ruby: {
-        pattern: /\s*\S[\s\S]*/,
-        alias: 'language-ruby',
-        inside: Prism.languages.ruby
-      }
-    };
-    Prism.hooks.add('before-tokenize', function (env) {
-      var erbPattern =
-        /<%=?(?:[^\r\n]|[\r\n](?!=begin)|[\r\n]=begin\s(?:[^\r\n]|[\r\n](?!=end))*[\r\n]=end)+?%>/g;
-      Prism.languages['markup-templating'].buildPlaceholders(
-        env,
-        'erb',
-        erbPattern
-      );
-    });
-    Prism.hooks.add('after-tokenize', function (env) {
-      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'erb');
-    });
-  })(Prism);
+	elixir_1 = elixir;
+	elixir.displayName = 'elixir';
+	elixir.aliases = [];
+	function elixir(Prism) {
+	  Prism.languages.elixir = {
+	    doc: {
+	      pattern:
+	        /@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/,
+	      inside: {
+	        attribute: /^@\w+/,
+	        string: /['"][\s\S]+/
+	      }
+	    },
+	    comment: {
+	      pattern: /#.*/,
+	      greedy: true
+	    },
+	    // ~r"""foo""" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r"foo", ~r'foo', ~r(foo), ~r[foo], ~r{foo}, ~r<foo>
+	    regex: {
+	      pattern:
+	        /~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/,
+	      greedy: true
+	    },
+	    string: [
+	      {
+	        // ~s"""foo""" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s"foo", ~s'foo', ~s(foo), ~s[foo], ~s{foo} (with interpolation care), ~s<foo>
+	        pattern:
+	          /~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|#(?!\{)|[^#\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,
+	        greedy: true,
+	        inside: {
+	          // See interpolation below
+	        }
+	      },
+	      {
+	        pattern: /("""|''')[\s\S]*?\1/,
+	        greedy: true,
+	        inside: {
+	          // See interpolation below
+	        }
+	      },
+	      {
+	        // Multi-line strings are allowed
+	        pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+	        greedy: true,
+	        inside: {
+	          // See interpolation below
+	        }
+	      }
+	    ],
+	    atom: {
+	      // Look-behind prevents bad highlighting of the :: operator
+	      pattern: /(^|[^:]):\w+/,
+	      lookbehind: true,
+	      alias: 'symbol'
+	    },
+	    module: {
+	      pattern: /\b[A-Z]\w*\b/,
+	      alias: 'class-name'
+	    },
+	    // Look-ahead prevents bad highlighting of the :: operator
+	    'attr-name': /\b\w+\??:(?!:)/,
+	    argument: {
+	      // Look-behind prevents bad highlighting of the && operator
+	      pattern: /(^|[^&])&\d+/,
+	      lookbehind: true,
+	      alias: 'variable'
+	    },
+	    attribute: {
+	      pattern: /@\w+/,
+	      alias: 'variable'
+	    },
+	    function: /\b[_a-zA-Z]\w*[?!]?(?:(?=\s*(?:\.\s*)?\()|(?=\/\d))/,
+	    number: /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i,
+	    keyword:
+	      /\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\b/,
+	    boolean: /\b(?:false|nil|true)\b/,
+	    operator: [
+	      /\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/,
+	      {
+	        // We don't want to match <<
+	        pattern: /([^<])<(?!<)/,
+	        lookbehind: true
+	      },
+	      {
+	        // We don't want to match >>
+	        pattern: /([^>])>(?!>)/,
+	        lookbehind: true
+	      }
+	    ],
+	    punctuation: /<<|>>|[.,%\[\]{}()]/
+	  };
+	  Prism.languages.elixir.string.forEach(function (o) {
+	    o.inside = {
+	      interpolation: {
+	        pattern: /#\{[^}]+\}/,
+	        inside: {
+	          delimiter: {
+	            pattern: /^#\{|\}$/,
+	            alias: 'punctuation'
+	          },
+	          rest: Prism.languages.elixir
+	        }
+	      }
+	    };
+	  });
+	}
+	return elixir_1;
 }
 
-var erlang_1 = erlang;
-erlang.displayName = 'erlang';
-erlang.aliases = [];
-function erlang(Prism) {
-  Prism.languages.erlang = {
-    comment: /%.+/,
-    string: {
-      pattern: /"(?:\\.|[^\\"\r\n])*"/,
-      greedy: true
-    },
-    'quoted-function': {
-      pattern: /'(?:\\.|[^\\'\r\n])+'(?=\()/,
-      alias: 'function'
-    },
-    'quoted-atom': {
-      pattern: /'(?:\\.|[^\\'\r\n])+'/,
-      alias: 'atom'
-    },
-    boolean: /\b(?:false|true)\b/,
-    keyword: /\b(?:after|case|catch|end|fun|if|of|receive|try|when)\b/,
-    number: [
-      /\$\\?./,
-      /\b\d+#[a-z0-9]+/i,
-      /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i
-    ],
-    function: /\b[a-z][\w@]*(?=\()/,
-    variable: {
-      // Look-behind is used to prevent wrong highlighting of atoms containing "@"
-      pattern: /(^|[^@])(?:\b|\?)[A-Z_][\w@]*/,
-      lookbehind: true
-    },
-    operator: [
-      /[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\b/,
-      {
-        // We don't want to match <<
-        pattern: /(^|[^<])<(?!<)/,
-        lookbehind: true
-      },
-      {
-        // We don't want to match >>
-        pattern: /(^|[^>])>(?!>)/,
-        lookbehind: true
-      }
-    ],
-    atom: /\b[a-z][\w@]*/,
-    punctuation: /[()[\]{}:;,.#|]|<<|>>/
-  };
-}
+var elm_1;
+var hasRequiredElm;
 
-var lua_1 = lua;
-lua.displayName = 'lua';
-lua.aliases = [];
-function lua(Prism) {
-  Prism.languages.lua = {
-    comment: /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m,
-    // \z may be used to skip the following space
-    string: {
-      pattern:
-        /(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[^z]))*\1|\[(=*)\[[\s\S]*?\]\2\]/,
-      greedy: true
-    },
-    number:
-      /\b0x[a-f\d]+(?:\.[a-f\d]*)?(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|(?:\.\d*)?(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i,
-    keyword:
-      /\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/,
-    function: /(?!\d)\w+(?=\s*(?:[({]))/,
-    operator: [
-      /[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/,
-      {
-        // Match ".." but don't break "..."
-        pattern: /(^|[^.])\.\.(?!\.)/,
-        lookbehind: true
-      }
-    ],
-    punctuation: /[\[\](){},;]|\.+|:+/
-  };
+function requireElm () {
+	if (hasRequiredElm) return elm_1;
+	hasRequiredElm = 1;
+
+	elm_1 = elm;
+	elm.displayName = 'elm';
+	elm.aliases = [];
+	function elm(Prism) {
+	  Prism.languages.elm = {
+	    comment: /--.*|\{-[\s\S]*?-\}/,
+	    char: {
+	      pattern:
+	        /'(?:[^\\'\r\n]|\\(?:[abfnrtv\\']|\d+|x[0-9a-fA-F]+|u\{[0-9a-fA-F]+\}))'/,
+	      greedy: true
+	    },
+	    string: [
+	      {
+	        // Multiline strings are wrapped in triple ". Quotes may appear unescaped.
+	        pattern: /"""[\s\S]*?"""/,
+	        greedy: true
+	      },
+	      {
+	        pattern: /"(?:[^\\"\r\n]|\\.)*"/,
+	        greedy: true
+	      }
+	    ],
+	    'import-statement': {
+	      // The imported or hidden names are not included in this import
+	      // statement. This is because we want to highlight those exactly like
+	      // we do for the names in the program.
+	      pattern:
+	        /(^[\t ]*)import\s+[A-Z]\w*(?:\.[A-Z]\w*)*(?:\s+as\s+(?:[A-Z]\w*)(?:\.[A-Z]\w*)*)?(?:\s+exposing\s+)?/m,
+	      lookbehind: true,
+	      inside: {
+	        keyword: /\b(?:as|exposing|import)\b/
+	      }
+	    },
+	    keyword:
+	      /\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\b/,
+	    // These are builtin variables only. Constructors are highlighted later as a constant.
+	    builtin:
+	      /\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\b/,
+	    // decimal integers and floating point numbers | hexadecimal integers
+	    number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[0-9a-f]+)\b/i,
+	    // Most of this is needed because of the meaning of a single '.'.
+	    // If it stands alone freely, it is the function composition.
+	    // It may also be a separator between a module name and an identifier => no
+	    // operator. If it comes together with other special characters it is an
+	    // operator too.
+	    // Valid operator characters in 0.18: +-/*=.$<>:&|^?%#@~!
+	    // Ref: https://groups.google.com/forum/#!msg/elm-dev/0AHSnDdkSkQ/E0SVU70JEQAJ
+	    operator: /\s\.\s|[+\-/*=.$<>:&|^?%#@~!]{2,}|[+\-/*=$<>:&|^?%#@~!]/,
+	    // In Elm, nearly everything is a variable, do not highlight these.
+	    hvariable: /\b(?:[A-Z]\w*\.)*[a-z]\w*\b/,
+	    constant: /\b(?:[A-Z]\w*\.)*[A-Z]\w*\b/,
+	    punctuation: /[{}[\]|(),.:]/
+	  };
+	}
+	return elm_1;
 }
 
-var refractorLua = lua_1;
-var refractorMarkupTemplating = requireMarkupTemplating();
-var etlua_1 = etlua;
-etlua.displayName = 'etlua';
-etlua.aliases = [];
-function etlua(Prism) {
-  Prism.register(refractorLua);
-  Prism.register(refractorMarkupTemplating)
-  ;(function (Prism) {
-    Prism.languages.etlua = {
-      delimiter: {
-        pattern: /^<%[-=]?|-?%>$/,
-        alias: 'punctuation'
-      },
-      'language-lua': {
-        pattern: /[\s\S]+/,
-        inside: Prism.languages.lua
-      }
-    };
-    Prism.hooks.add('before-tokenize', function (env) {
-      var pattern = /<%[\s\S]+?%>/g;
-      Prism.languages['markup-templating'].buildPlaceholders(
-        env,
-        'etlua',
-        pattern
-      );
-    });
-    Prism.hooks.add('after-tokenize', function (env) {
-      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'etlua');
-    });
-  })(Prism);
+var erb_1;
+var hasRequiredErb;
+
+function requireErb () {
+	if (hasRequiredErb) return erb_1;
+	hasRequiredErb = 1;
+	var refractorRuby = ruby_1;
+	var refractorMarkupTemplating = requireMarkupTemplating();
+	erb_1 = erb;
+	erb.displayName = 'erb';
+	erb.aliases = [];
+	function erb(Prism) {
+	  Prism.register(refractorRuby);
+	  Prism.register(refractorMarkupTemplating)
+	  ;(function (Prism) {
+	    Prism.languages.erb = {
+	      delimiter: {
+	        pattern: /^(\s*)<%=?|%>(?=\s*$)/,
+	        lookbehind: true,
+	        alias: 'punctuation'
+	      },
+	      ruby: {
+	        pattern: /\s*\S[\s\S]*/,
+	        alias: 'language-ruby',
+	        inside: Prism.languages.ruby
+	      }
+	    };
+	    Prism.hooks.add('before-tokenize', function (env) {
+	      var erbPattern =
+	        /<%=?(?:[^\r\n]|[\r\n](?!=begin)|[\r\n]=begin\s(?:[^\r\n]|[\r\n](?!=end))*[\r\n]=end)+?%>/g;
+	      Prism.languages['markup-templating'].buildPlaceholders(
+	        env,
+	        'erb',
+	        erbPattern
+	      );
+	    });
+	    Prism.hooks.add('after-tokenize', function (env) {
+	      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'erb');
+	    });
+	  })(Prism);
+	}
+	return erb_1;
 }
 
-var excelFormula_1 = excelFormula;
-excelFormula.displayName = 'excelFormula';
-excelFormula.aliases = [];
-function excelFormula(Prism) {
-  Prism.languages['excel-formula'] = {
-    comment: {
-      pattern: /(\bN\(\s*)"(?:[^"]|"")*"(?=\s*\))/i,
-      lookbehind: true,
-      greedy: true
-    },
-    string: {
-      pattern: /"(?:[^"]|"")*"(?!")/,
-      greedy: true
-    },
-    reference: {
-      // https://www.ablebits.com/office-addins-blog/2015/12/08/excel-reference-another-sheet-workbook/
-      // Sales!B2
-      // 'Winter sales'!B2
-      // [Sales.xlsx]Jan!B2:B5
-      // D:\Reports\[Sales.xlsx]Jan!B2:B5
-      // '[Sales.xlsx]Jan sales'!B2:B5
-      // 'D:\Reports\[Sales.xlsx]Jan sales'!B2:B5
-      pattern:
-        /(?:'[^']*'|(?:[^\s()[\]{}<>*?"';,$&]*\[[^^\s()[\]{}<>*?"']+\])?\w+)!/,
-      greedy: true,
-      alias: 'string',
-      inside: {
-        operator: /!$/,
-        punctuation: /'/,
-        sheet: {
-          pattern: /[^[\]]+$/,
-          alias: 'function'
-        },
-        file: {
-          pattern: /\[[^[\]]+\]$/,
-          inside: {
-            punctuation: /[[\]]/
-          }
-        },
-        path: /[\s\S]+/
-      }
-    },
-    'function-name': {
-      pattern: /\b[A-Z]\w*(?=\()/i,
-      alias: 'keyword'
-    },
-    range: {
-      pattern:
-        /\$?\b(?:[A-Z]+\$?\d+:\$?[A-Z]+\$?\d+|[A-Z]+:\$?[A-Z]+|\d+:\$?\d+)\b/i,
-      alias: 'property',
-      inside: {
-        operator: /:/,
-        cell: /\$?[A-Z]+\$?\d+/i,
-        column: /\$?[A-Z]+/i,
-        row: /\$?\d+/
-      }
-    },
-    cell: {
-      // Excel is case insensitive, so the string "foo1" could be either a variable or a cell.
-      // To combat this, we match cells case insensitive, if the contain at least one "$", and case sensitive otherwise.
-      pattern: /\b[A-Z]+\d+\b|\$[A-Za-z]+\$?\d+\b|\b[A-Za-z]+\$\d+\b/,
-      alias: 'property'
-    },
-    number: /(?:\b\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?\b/i,
-    boolean: /\b(?:FALSE|TRUE)\b/i,
-    operator: /[-+*/^%=&,]|<[=>]?|>=?/,
-    punctuation: /[[\]();{}|]/
-  };
-  Prism.languages['xlsx'] = Prism.languages['xls'] =
-    Prism.languages['excel-formula'];
+var erlang_1;
+var hasRequiredErlang;
+
+function requireErlang () {
+	if (hasRequiredErlang) return erlang_1;
+	hasRequiredErlang = 1;
+
+	erlang_1 = erlang;
+	erlang.displayName = 'erlang';
+	erlang.aliases = [];
+	function erlang(Prism) {
+	  Prism.languages.erlang = {
+	    comment: /%.+/,
+	    string: {
+	      pattern: /"(?:\\.|[^\\"\r\n])*"/,
+	      greedy: true
+	    },
+	    'quoted-function': {
+	      pattern: /'(?:\\.|[^\\'\r\n])+'(?=\()/,
+	      alias: 'function'
+	    },
+	    'quoted-atom': {
+	      pattern: /'(?:\\.|[^\\'\r\n])+'/,
+	      alias: 'atom'
+	    },
+	    boolean: /\b(?:false|true)\b/,
+	    keyword: /\b(?:after|case|catch|end|fun|if|of|receive|try|when)\b/,
+	    number: [
+	      /\$\\?./,
+	      /\b\d+#[a-z0-9]+/i,
+	      /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i
+	    ],
+	    function: /\b[a-z][\w@]*(?=\()/,
+	    variable: {
+	      // Look-behind is used to prevent wrong highlighting of atoms containing "@"
+	      pattern: /(^|[^@])(?:\b|\?)[A-Z_][\w@]*/,
+	      lookbehind: true
+	    },
+	    operator: [
+	      /[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\b/,
+	      {
+	        // We don't want to match <<
+	        pattern: /(^|[^<])<(?!<)/,
+	        lookbehind: true
+	      },
+	      {
+	        // We don't want to match >>
+	        pattern: /(^|[^>])>(?!>)/,
+	        lookbehind: true
+	      }
+	    ],
+	    atom: /\b[a-z][\w@]*/,
+	    punctuation: /[()[\]{}:;,.#|]|<<|>>/
+	  };
+	}
+	return erlang_1;
+}
+
+var lua_1;
+var hasRequiredLua;
+
+function requireLua () {
+	if (hasRequiredLua) return lua_1;
+	hasRequiredLua = 1;
+
+	lua_1 = lua;
+	lua.displayName = 'lua';
+	lua.aliases = [];
+	function lua(Prism) {
+	  Prism.languages.lua = {
+	    comment: /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m,
+	    // \z may be used to skip the following space
+	    string: {
+	      pattern:
+	        /(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[^z]))*\1|\[(=*)\[[\s\S]*?\]\2\]/,
+	      greedy: true
+	    },
+	    number:
+	      /\b0x[a-f\d]+(?:\.[a-f\d]*)?(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|(?:\.\d*)?(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i,
+	    keyword:
+	      /\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/,
+	    function: /(?!\d)\w+(?=\s*(?:[({]))/,
+	    operator: [
+	      /[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/,
+	      {
+	        // Match ".." but don't break "..."
+	        pattern: /(^|[^.])\.\.(?!\.)/,
+	        lookbehind: true
+	      }
+	    ],
+	    punctuation: /[\[\](){},;]|\.+|:+/
+	  };
+	}
+	return lua_1;
 }
 
-var factor_1 = factor;
-factor.displayName = 'factor';
-factor.aliases = [];
-function factor(Prism) {
+var etlua_1;
+var hasRequiredEtlua;
+
+function requireEtlua () {
+	if (hasRequiredEtlua) return etlua_1;
+	hasRequiredEtlua = 1;
+	var refractorLua = requireLua();
+	var refractorMarkupTemplating = requireMarkupTemplating();
+	etlua_1 = etlua;
+	etlua.displayName = 'etlua';
+	etlua.aliases = [];
+	function etlua(Prism) {
+	  Prism.register(refractorLua);
+	  Prism.register(refractorMarkupTemplating)
+	  ;(function (Prism) {
+	    Prism.languages.etlua = {
+	      delimiter: {
+	        pattern: /^<%[-=]?|-?%>$/,
+	        alias: 'punctuation'
+	      },
+	      'language-lua': {
+	        pattern: /[\s\S]+/,
+	        inside: Prism.languages.lua
+	      }
+	    };
+	    Prism.hooks.add('before-tokenize', function (env) {
+	      var pattern = /<%[\s\S]+?%>/g;
+	      Prism.languages['markup-templating'].buildPlaceholders(
+	        env,
+	        'etlua',
+	        pattern
+	      );
+	    });
+	    Prism.hooks.add('after-tokenize', function (env) {
+	      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'etlua');
+	    });
+	  })(Prism);
+	}
+	return etlua_1;
+}
+
+var excelFormula_1;
+var hasRequiredExcelFormula;
+
+function requireExcelFormula () {
+	if (hasRequiredExcelFormula) return excelFormula_1;
+	hasRequiredExcelFormula = 1;
+
+	excelFormula_1 = excelFormula;
+	excelFormula.displayName = 'excelFormula';
+	excelFormula.aliases = [];
+	function excelFormula(Prism) {
+	  Prism.languages['excel-formula'] = {
+	    comment: {
+	      pattern: /(\bN\(\s*)"(?:[^"]|"")*"(?=\s*\))/i,
+	      lookbehind: true,
+	      greedy: true
+	    },
+	    string: {
+	      pattern: /"(?:[^"]|"")*"(?!")/,
+	      greedy: true
+	    },
+	    reference: {
+	      // https://www.ablebits.com/office-addins-blog/2015/12/08/excel-reference-another-sheet-workbook/
+	      // Sales!B2
+	      // 'Winter sales'!B2
+	      // [Sales.xlsx]Jan!B2:B5
+	      // D:\Reports\[Sales.xlsx]Jan!B2:B5
+	      // '[Sales.xlsx]Jan sales'!B2:B5
+	      // 'D:\Reports\[Sales.xlsx]Jan sales'!B2:B5
+	      pattern:
+	        /(?:'[^']*'|(?:[^\s()[\]{}<>*?"';,$&]*\[[^^\s()[\]{}<>*?"']+\])?\w+)!/,
+	      greedy: true,
+	      alias: 'string',
+	      inside: {
+	        operator: /!$/,
+	        punctuation: /'/,
+	        sheet: {
+	          pattern: /[^[\]]+$/,
+	          alias: 'function'
+	        },
+	        file: {
+	          pattern: /\[[^[\]]+\]$/,
+	          inside: {
+	            punctuation: /[[\]]/
+	          }
+	        },
+	        path: /[\s\S]+/
+	      }
+	    },
+	    'function-name': {
+	      pattern: /\b[A-Z]\w*(?=\()/i,
+	      alias: 'keyword'
+	    },
+	    range: {
+	      pattern:
+	        /\$?\b(?:[A-Z]+\$?\d+:\$?[A-Z]+\$?\d+|[A-Z]+:\$?[A-Z]+|\d+:\$?\d+)\b/i,
+	      alias: 'property',
+	      inside: {
+	        operator: /:/,
+	        cell: /\$?[A-Z]+\$?\d+/i,
+	        column: /\$?[A-Z]+/i,
+	        row: /\$?\d+/
+	      }
+	    },
+	    cell: {
+	      // Excel is case insensitive, so the string "foo1" could be either a variable or a cell.
+	      // To combat this, we match cells case insensitive, if the contain at least one "$", and case sensitive otherwise.
+	      pattern: /\b[A-Z]+\d+\b|\$[A-Za-z]+\$?\d+\b|\b[A-Za-z]+\$\d+\b/,
+	      alias: 'property'
+	    },
+	    number: /(?:\b\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?\b/i,
+	    boolean: /\b(?:FALSE|TRUE)\b/i,
+	    operator: /[-+*/^%=&,]|<[=>]?|>=?/,
+	    punctuation: /[[\]();{}|]/
+	  };
+	  Prism.languages['xlsx'] = Prism.languages['xls'] =
+	    Prism.languages['excel-formula'];
+	}
+	return excelFormula_1;
+}
+
+var factor_1;
+var hasRequiredFactor;
+
+function requireFactor () {
+	if (hasRequiredFactor) return factor_1;
+	hasRequiredFactor = 1;
+
+	factor_1 = factor;
+	factor.displayName = 'factor';
+	factor.aliases = [];
+	function factor(Prism) {
 (function (Prism) {
-    var comment_inside = {
-      function:
-        /\b(?:BUGS?|FIX(?:MES?)?|NOTES?|TODOS?|XX+|HACKS?|WARN(?:ING)?|\?{2,}|!{2,})\b/
-    };
-    var string_inside = {
-      number: /\\[^\s']|%\w/
-    };
-    var factor = {
-      comment: [
-        {
-          // ! single-line exclamation point comments with whitespace after/around the !
-          pattern: /(^|\s)(?:! .*|!$)/,
-          lookbehind: true,
-          inside: comment_inside
-        },
-        /* from basis/multiline: */
-        {
-          // /* comment */, /* comment*/
-          pattern: /(^|\s)\/\*\s[\s\S]*?\*\/(?=\s|$)/,
-          lookbehind: true,
-          greedy: true,
-          inside: comment_inside
-        },
-        {
-          // ![[ comment ]] , ![===[ comment]===]
-          pattern: /(^|\s)!\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,
-          lookbehind: true,
-          greedy: true,
-          inside: comment_inside
-        }
-      ],
-      number: [
-        {
-          // basic base 10 integers 9, -9
-          pattern: /(^|\s)[+-]?\d+(?=\s|$)/,
-          lookbehind: true
-        },
-        {
-          // base prefix integers 0b010 0o70 0xad 0d10 0XAD -0xa9
-          pattern: /(^|\s)[+-]?0(?:b[01]+|o[0-7]+|d\d+|x[\dA-F]+)(?=\s|$)/i,
-          lookbehind: true
-        },
-        {
-          // fractional ratios 1/5 -1/5 and the literal float approximations 1/5. -1/5.
-          pattern: /(^|\s)[+-]?\d+\/\d+\.?(?=\s|$)/,
-          lookbehind: true
-        },
-        {
-          // positive mixed numbers 23+1/5 +23+1/5
-          pattern: /(^|\s)\+?\d+\+\d+\/\d+(?=\s|$)/,
-          lookbehind: true
-        },
-        {
-          // negative mixed numbers -23-1/5
-          pattern: /(^|\s)-\d+-\d+\/\d+(?=\s|$)/,
-          lookbehind: true
-        },
-        {
-          // basic decimal floats -0.01 0. .0 .1 -.1 -1. -12.13 +12.13
-          // and scientific notation with base 10 exponents 3e4 3e-4 .3e-4
-          pattern:
-            /(^|\s)[+-]?(?:\d*\.\d+|\d+\.\d*|\d+)(?:e[+-]?\d+)?(?=\s|$)/i,
-          lookbehind: true
-        },
-        {
-          // NAN literal syntax NAN: 80000deadbeef, NAN: a
-          pattern: /(^|\s)NAN:\s+[\da-fA-F]+(?=\s|$)/,
-          lookbehind: true
-        },
-        {
-          /*
-base prefix floats 0x1.0p3 (8.0) 0b1.010p2 (5.0) 0x1.p1 0b1.11111111p11111...
-"The normalized hex form ±0x1.MMMMMMMMMMMMM[pP]±EEEE allows any floating-point number to be specified precisely.
-The values of MMMMMMMMMMMMM and EEEE map directly to the mantissa and exponent fields of the binary IEEE 754 representation."
-<https://docs.factorcode.org/content/article-syntax-floats.html>
-*/
-          pattern:
-            /(^|\s)[+-]?0(?:b1\.[01]*|o1\.[0-7]*|d1\.\d*|x1\.[\dA-F]*)p\d+(?=\s|$)/i,
-          lookbehind: true
-        }
-      ],
-      // R/ regexp?\/\\/
-      regexp: {
-        pattern:
-          /(^|\s)R\/\s(?:\\\S|[^\\/])*\/(?:[idmsr]*|[idmsr]+-[idmsr]+)(?=\s|$)/,
-        lookbehind: true,
-        alias: 'number',
-        inside: {
-          variable: /\\\S/,
-          keyword: /[+?*\[\]^$(){}.|]/,
-          operator: {
-            pattern: /(\/)[idmsr]+(?:-[idmsr]+)?/,
-            lookbehind: true
-          }
-        }
-      },
-      boolean: {
-        pattern: /(^|\s)[tf](?=\s|$)/,
-        lookbehind: true
-      },
-      // SBUF" asd", URL" ://...", P" /etc/"
-      'custom-string': {
-        pattern: /(^|\s)[A-Z0-9\-]+"\s(?:\\\S|[^"\\])*"/,
-        lookbehind: true,
-        greedy: true,
-        alias: 'string',
-        inside: {
-          number: /\\\S|%\w|\//
-        }
-      },
-      'multiline-string': [
-        {
-          // STRING: name \n content \n ; -> CONSTANT: name "content" (symbol)
-          pattern: /(^|\s)STRING:\s+\S+(?:\n|\r\n).*(?:\n|\r\n)\s*;(?=\s|$)/,
-          lookbehind: true,
-          greedy: true,
-          alias: 'string',
-          inside: {
-            number: string_inside.number,
-            // trailing semicolon on its own line
-            'semicolon-or-setlocal': {
-              pattern: /([\r\n][ \t]*);(?=\s|$)/,
-              lookbehind: true,
-              alias: 'function'
-            }
-          }
-        },
-        {
-          // HEREDOC: marker \n content \n marker ; -> "content" (immediate)
-          pattern: /(^|\s)HEREDOC:\s+\S+(?:\n|\r\n).*(?:\n|\r\n)\s*\S+(?=\s|$)/,
-          lookbehind: true,
-          greedy: true,
-          alias: 'string',
-          inside: string_inside
-        },
-        {
-          // [[ string ]], [==[ string]==]
-          pattern: /(^|\s)\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,
-          lookbehind: true,
-          greedy: true,
-          alias: 'string',
-          inside: string_inside
-        }
-      ],
-      'special-using': {
-        pattern: /(^|\s)USING:(?:\s\S+)*(?=\s+;(?:\s|$))/,
-        lookbehind: true,
-        alias: 'function',
-        inside: {
-          // this is essentially a regex for vocab names, which i don't want to specify
-          // but the USING: gets picked up as a vocab name
-          string: {
-            pattern: /(\s)[^:\s]+/,
-            lookbehind: true
-          }
-        }
-      },
-      /* this description of stack effect literal syntax is not complete and not as specific as theoretically possible
-trying to do better is more work and regex-computation-time than it's worth though.
-- we'd like to have the "delimiter" parts of the stack effect [ (, --, and ) ] be a different (less-important or comment-like) colour to the stack effect contents
-- we'd like if nested stack effects were treated as such rather than just appearing flat (with `inside`)
-- we'd like if the following variable name conventions were recognised specifically:
-special row variables = ..a b..
-type and stack effect annotations end with a colon = ( quot: ( a: ( -- ) -- b ) -- x ), ( x: number -- )
-word throws unconditional error = *
-any other word-like variable name = a ? q' etc
-https://docs.factorcode.org/content/article-effects.html
-these are pretty complicated to highlight properly without a real parser, and therefore out of scope
-the old pattern, which may be later useful, was: (^|\s)(?:call|execute|eval)?\((?:\s+[^"\r\n\t ]\S*)*?\s+--(?:\s+[^"\n\t ]\S*)*?\s+\)(?=\s|$)
-*/
-      // current solution is not great
-      'stack-effect-delimiter': [
-        {
-          // opening parenthesis
-          pattern: /(^|\s)(?:call|eval|execute)?\((?=\s)/,
-          lookbehind: true,
-          alias: 'operator'
-        },
-        {
-          // middle --
-          pattern: /(\s)--(?=\s)/,
-          lookbehind: true,
-          alias: 'operator'
-        },
-        {
-          // closing parenthesis
-          pattern: /(\s)\)(?=\s|$)/,
-          lookbehind: true,
-          alias: 'operator'
-        }
-      ],
-      combinators: {
-        pattern: null,
-        lookbehind: true,
-        alias: 'keyword'
-      },
-      'kernel-builtin': {
-        pattern: null,
-        lookbehind: true,
-        alias: 'variable'
-      },
-      'sequences-builtin': {
-        pattern: null,
-        lookbehind: true,
-        alias: 'variable'
-      },
-      'math-builtin': {
-        pattern: null,
-        lookbehind: true,
-        alias: 'variable'
-      },
-      'constructor-word': {
-        // <array> but not <=>
-        pattern: /(^|\s)<(?!=+>|-+>)\S+>(?=\s|$)/,
-        lookbehind: true,
-        alias: 'keyword'
-      },
-      'other-builtin-syntax': {
-        pattern: null,
-        lookbehind: true,
-        alias: 'operator'
-      },
-      /*
-full list of supported word naming conventions: (the convention appears outside of the [brackets])
-set-[x]
-change-[x]
-with-[x]
-new-[x]
->[string]
-[base]>
-[string]>[number]
-+[symbol]+
-[boolean-word]?
-?[of]
-[slot-reader]>>
->>[slot-setter]
-[slot-writer]<<
-([implementation-detail])
-[mutater]!
-[variant]*
-[prettyprint].
-$[help-markup]
-<constructors>, SYNTAX:, etc are supported by their own patterns.
-`with` and `new` from `kernel` are their own builtins.
-see <https://docs.factorcode.org/content/article-conventions.html>
-*/
-      'conventionally-named-word': {
-        pattern:
-          /(^|\s)(?!")(?:(?:change|new|set|with)-\S+|\$\S+|>[^>\s]+|[^:>\s]+>|[^>\s]+>[^>\s]+|\+[^+\s]+\+|[^?\s]+\?|\?[^?\s]+|[^>\s]+>>|>>[^>\s]+|[^<\s]+<<|\([^()\s]+\)|[^!\s]+!|[^*\s]\S*\*|[^.\s]\S*\.)(?=\s|$)/,
-        lookbehind: true,
-        alias: 'keyword'
-      },
-      'colon-syntax': {
-        pattern: /(^|\s)(?:[A-Z0-9\-]+#?)?:{1,2}\s+(?:;\S+|(?!;)\S+)(?=\s|$)/,
-        lookbehind: true,
-        greedy: true,
-        alias: 'function'
-      },
-      'semicolon-or-setlocal': {
-        pattern: /(\s)(?:;|:>)(?=\s|$)/,
-        lookbehind: true,
-        alias: 'function'
-      },
-      // do not highlight leading } or trailing X{ at the begin/end of the file as it's invalid syntax
-      'curly-brace-literal-delimiter': [
-        {
-          // opening
-          pattern: /(^|\s)[a-z]*\{(?=\s)/i,
-          lookbehind: true,
-          alias: 'operator'
-        },
-        {
-          // closing
-          pattern: /(\s)\}(?=\s|$)/,
-          lookbehind: true,
-          alias: 'operator'
-        }
-      ],
-      // do not highlight leading ] or trailing [ at the begin/end of the file as it's invalid syntax
-      'quotation-delimiter': [
-        {
-          // opening
-          pattern: /(^|\s)\[(?=\s)/,
-          lookbehind: true,
-          alias: 'operator'
-        },
-        {
-          // closing
-          pattern: /(\s)\](?=\s|$)/,
-          lookbehind: true,
-          alias: 'operator'
-        }
-      ],
-      'normal-word': {
-        pattern: /(^|\s)[^"\s]\S*(?=\s|$)/,
-        lookbehind: true
-      },
-      /*
-basic first-class string "a"
-with escaped double-quote "a\""
-escaped backslash "\\"
-and general escapes since Factor has so many "\N"
-syntax that works in the reference implementation that isn't fully
-supported because it's an implementation detail:
-"string 1""string 2" -> 2 strings (works anyway)
-"string"5 -> string, 5
-"string"[ ] -> string, quotation
-{ "a"} -> array<string>
-the rest of those examples all properly recognise the string, but not
-the other object (number, quotation, etc)
-this is fine for a regex-only implementation.
-*/
-      string: {
-        pattern: /"(?:\\\S|[^"\\])*"/,
-        greedy: true,
-        inside: string_inside
-      }
-    };
-    var escape = function (str) {
-      return (str + '').replace(/([.?*+\^$\[\]\\(){}|\-])/g, '\\$1')
-    };
-    var arrToWordsRegExp = function (arr) {
-      return new RegExp('(^|\\s)(?:' + arr.map(escape).join('|') + ')(?=\\s|$)')
-    };
-    var builtins = {
-      'kernel-builtin': [
-        'or',
-        '2nipd',
-        '4drop',
-        'tuck',
-        'wrapper',
-        'nip',
-        'wrapper?',
-        'callstack>array',
-        'die',
-        'dupd',
-        'callstack',
-        'callstack?',
-        '3dup',
-        'hashcode',
-        'pick',
-        '4nip',
-        'build',
-        '>boolean',
-        'nipd',
-        'clone',
-        '5nip',
-        'eq?',
-        '?',
-        '=',
-        'swapd',
-        '2over',
-        'clear',
-        '2dup',
-        'get-retainstack',
-        'not',
-        'tuple?',
-        'dup',
-        '3nipd',
-        'call',
-        '-rotd',
-        'object',
-        'drop',
-        'assert=',
-        'assert?',
-        '-rot',
-        'execute',
-        'boa',
-        'get-callstack',
-        'curried?',
-        '3drop',
-        'pickd',
-        'overd',
-        'over',
-        'roll',
-        '3nip',
-        'swap',
-        'and',
-        '2nip',
-        'rotd',
-        'throw',
-        '(clone)',
-        'hashcode*',
-        'spin',
-        'reach',
-        '4dup',
-        'equal?',
-        'get-datastack',
-        'assert',
-        '2drop',
-        '<wrapper>',
-        'boolean?',
-        'identity-hashcode',
-        'identity-tuple?',
-        'null',
-        'composed?',
-        'new',
-        '5drop',
-        'rot',
-        '-roll',
-        'xor',
-        'identity-tuple',
-        'boolean'
-      ],
-      'other-builtin-syntax': [
-        // syntax
-        '=======',
-        'recursive',
-        'flushable',
-        '>>',
-        '<<<<<<',
-        'M\\',
-        'B',
-        'PRIVATE>',
-        '\\',
-        '======',
-        'final',
-        'inline',
-        'delimiter',
-        'deprecated',
-        '<PRIVATE',
-        '>>>>>>',
-        '<<<<<<<',
-        'parse-complex',
-        'malformed-complex',
-        'read-only',
-        '>>>>>>>',
-        'call-next-method',
-        '<<',
-        'foldable', // literals
-        '$',
-        '$[',
-        '${'
-      ],
-      'sequences-builtin': [
-        'member-eq?',
-        'mismatch',
-        'append',
-        'assert-sequence=',
-        'longer',
-        'repetition',
-        'clone-like',
-        '3sequence',
-        'assert-sequence?',
-        'last-index-from',
-        'reversed',
-        'index-from',
-        'cut*',
-        'pad-tail',
-        'join-as',
-        'remove-eq!',
-        'concat-as',
-        'but-last',
-        'snip',
-        'nths',
-        'nth',
-        'sequence',
-        'longest',
-        'slice?',
-        '<slice>',
-        'remove-nth',
-        'tail-slice',
-        'empty?',
-        'tail*',
-        'member?',
-        'virtual-sequence?',
-        'set-length',
-        'drop-prefix',
-        'iota',
-        'unclip',
-        'bounds-error?',
-        'unclip-last-slice',
-        'non-negative-integer-expected',
-        'non-negative-integer-expected?',
-        'midpoint@',
-        'longer?',
-        '?set-nth',
-        '?first',
-        'rest-slice',
-        'prepend-as',
-        'prepend',
-        'fourth',
-        'sift',
-        'subseq-start',
-        'new-sequence',
-        '?last',
-        'like',
-        'first4',
-        '1sequence',
-        'reverse',
-        'slice',
-        'virtual@',
-        'repetition?',
-        'set-last',
-        'index',
-        '4sequence',
-        'max-length',
-        'set-second',
-        'immutable-sequence',
-        'first2',
-        'first3',
-        'supremum',
-        'unclip-slice',
-        'suffix!',
-        'insert-nth',
-        'tail',
-        '3append',
-        'short',
-        'suffix',
-        'concat',
-        'flip',
-        'immutable?',
-        'reverse!',
-        '2sequence',
-        'sum',
-        'delete-all',
-        'indices',
-        'snip-slice',
-        '<iota>',
-        'check-slice',
-        'sequence?',
-        'head',
-        'append-as',
-        'halves',
-        'sequence=',
-        'collapse-slice',
-        '?second',
-        'slice-error?',
-        'product',
-        'bounds-check?',
-        'bounds-check',
-        'immutable',
-        'virtual-exemplar',
-        'harvest',
-        'remove',
-        'pad-head',
-        'last',
-        'set-fourth',
-        'cartesian-product',
-        'remove-eq',
-        'shorten',
-        'shorter',
-        'reversed?',
-        'shorter?',
-        'shortest',
-        'head-slice',
-        'pop*',
-        'tail-slice*',
-        'but-last-slice',
-        'iota?',
-        'append!',
-        'cut-slice',
-        'new-resizable',
-        'head-slice*',
-        'sequence-hashcode',
-        'pop',
-        'set-nth',
-        '?nth',
-        'second',
-        'join',
-        'immutable-sequence?',
-        '<reversed>',
-        '3append-as',
-        'virtual-sequence',
-        'subseq?',
-        'remove-nth!',
-        'length',
-        'last-index',
-        'lengthen',
-        'assert-sequence',
-        'copy',
-        'move',
-        'third',
-        'first',
-        'tail?',
-        'set-first',
-        'prefix',
-        'bounds-error',
-        '<repetition>',
-        'exchange',
-        'surround',
-        'cut',
-        'min-length',
-        'set-third',
-        'push-all',
-        'head?',
-        'subseq-start-from',
-        'delete-slice',
-        'rest',
-        'sum-lengths',
-        'head*',
-        'infimum',
-        'remove!',
-        'glue',
-        'slice-error',
-        'subseq',
-        'push',
-        'replace-slice',
-        'subseq-as',
-        'unclip-last'
-      ],
-      'math-builtin': [
-        'number=',
-        'next-power-of-2',
-        '?1+',
-        'fp-special?',
-        'imaginary-part',
-        'float>bits',
-        'number?',
-        'fp-infinity?',
-        'bignum?',
-        'fp-snan?',
-        'denominator',
-        'gcd',
-        '*',
-        '+',
-        'fp-bitwise=',
-        '-',
-        'u>=',
-        '/',
-        '>=',
-        'bitand',
-        'power-of-2?',
-        'log2-expects-positive',
-        'neg?',
-        '<',
-        'log2',
-        '>',
-        'integer?',
-        'number',
-        'bits>double',
-        '2/',
-        'zero?',
-        'bits>float',
-        'float?',
-        'shift',
-        'ratio?',
-        'rect>',
-        'even?',
-        'ratio',
-        'fp-sign',
-        'bitnot',
-        '>fixnum',
-        'complex?',
-        '/i',
-        'integer>fixnum',
-        '/f',
-        'sgn',
-        '>bignum',
-        'next-float',
-        'u<',
-        'u>',
-        'mod',
-        'recip',
-        'rational',
-        '>float',
-        '2^',
-        'integer',
-        'fixnum?',
-        'neg',
-        'fixnum',
-        'sq',
-        'bignum',
-        '>rect',
-        'bit?',
-        'fp-qnan?',
-        'simple-gcd',
-        'complex',
-        '<fp-nan>',
-        'real',
-        '>fraction',
-        'double>bits',
-        'bitor',
-        'rem',
-        'fp-nan-payload',
-        'real-part',
-        'log2-expects-positive?',
-        'prev-float',
-        'align',
-        'unordered?',
-        'float',
-        'fp-nan?',
-        'abs',
-        'bitxor',
-        'integer>fixnum-strict',
-        'u<=',
-        'odd?',
-        '<=',
-        '/mod',
-        '>integer',
-        'real?',
-        'rational?',
-        'numerator'
-      ] // that's all for now
-    };
-    Object.keys(builtins).forEach(function (k) {
-      factor[k].pattern = arrToWordsRegExp(builtins[k]);
-    });
-    var combinators = [
-      // kernel
-      '2bi',
-      'while',
-      '2tri',
-      'bi*',
-      '4dip',
-      'both?',
-      'same?',
-      'tri@',
-      'curry',
-      'prepose',
-      '3bi',
-      '?if',
-      'tri*',
-      '2keep',
-      '3keep',
-      'curried',
-      '2keepd',
-      'when',
-      '2bi*',
-      '2tri*',
-      '4keep',
-      'bi@',
-      'keepdd',
-      'do',
-      'unless*',
-      'tri-curry',
-      'if*',
-      'loop',
-      'bi-curry*',
-      'when*',
-      '2bi@',
-      '2tri@',
-      'with',
-      '2with',
-      'either?',
-      'bi',
-      'until',
-      '3dip',
-      '3curry',
-      'tri-curry*',
-      'tri-curry@',
-      'bi-curry',
-      'keepd',
-      'compose',
-      '2dip',
-      'if',
-      '3tri',
-      'unless',
-      'tuple',
-      'keep',
-      '2curry',
-      'tri',
-      'most',
-      'while*',
-      'dip',
-      'composed',
-      'bi-curry@', // sequences
-      'find-last-from',
-      'trim-head-slice',
-      'map-as',
-      'each-from',
-      'none?',
-      'trim-tail',
-      'partition',
-      'if-empty',
-      'accumulate*',
-      'reject!',
-      'find-from',
-      'accumulate-as',
-      'collector-for-as',
-      'reject',
-      'map',
-      'map-sum',
-      'accumulate!',
-      '2each-from',
-      'follow',
-      'supremum-by',
-      'map!',
-      'unless-empty',
-      'collector',
-      'padding',
-      'reduce-index',
-      'replicate-as',
-      'infimum-by',
-      'trim-tail-slice',
-      'count',
-      'find-index',
-      'filter',
-      'accumulate*!',
-      'reject-as',
-      'map-integers',
-      'map-find',
-      'reduce',
-      'selector',
-      'interleave',
-      '2map',
-      'filter-as',
-      'binary-reduce',
-      'map-index-as',
-      'find',
-      'produce',
-      'filter!',
-      'replicate',
-      'cartesian-map',
-      'cartesian-each',
-      'find-index-from',
-      'map-find-last',
-      '3map-as',
-      '3map',
-      'find-last',
-      'selector-as',
-      '2map-as',
-      '2map-reduce',
-      'accumulate',
-      'each',
-      'each-index',
-      'accumulate*-as',
-      'when-empty',
-      'all?',
-      'collector-as',
-      'push-either',
-      'new-like',
-      'collector-for',
-      '2selector',
-      'push-if',
-      '2all?',
-      'map-reduce',
-      '3each',
-      'any?',
-      'trim-slice',
-      '2reduce',
-      'change-nth',
-      'produce-as',
-      '2each',
-      'trim',
-      'trim-head',
-      'cartesian-find',
-      'map-index', // math
-      'if-zero',
-      'each-integer',
-      'unless-zero',
-      '(find-integer)',
-      'when-zero',
-      'find-last-integer',
-      '(all-integers?)',
-      'times',
-      '(each-integer)',
-      'find-integer',
-      'all-integers?', // math.combinators
-      'unless-negative',
-      'if-positive',
-      'when-positive',
-      'when-negative',
-      'unless-positive',
-      'if-negative', // combinators
-      'case',
-      '2cleave',
-      'cond>quot',
-      'case>quot',
-      '3cleave',
-      'wrong-values',
-      'to-fixed-point',
-      'alist>quot',
-      'cond',
-      'cleave',
-      'call-effect',
-      'recursive-hashcode',
-      'spread',
-      'deep-spread>quot', // combinators.short-circuit
-      '2||',
-      '0||',
-      'n||',
-      '0&&',
-      '2&&',
-      '3||',
-      '1||',
-      '1&&',
-      'n&&',
-      '3&&', // combinators.smart
-      'smart-unless*',
-      'keep-inputs',
-      'reduce-outputs',
-      'smart-when*',
-      'cleave>array',
-      'smart-with',
-      'smart-apply',
-      'smart-if',
-      'inputs/outputs',
-      'output>sequence-n',
-      'map-outputs',
-      'map-reduce-outputs',
-      'dropping',
-      'output>array',
-      'smart-map-reduce',
-      'smart-2map-reduce',
-      'output>array-n',
-      'nullary',
-      'input<sequence',
-      'append-outputs',
-      'drop-inputs',
-      'inputs',
-      'smart-2reduce',
-      'drop-outputs',
-      'smart-reduce',
-      'preserving',
-      'smart-when',
-      'outputs',
-      'append-outputs-as',
-      'smart-unless',
-      'smart-if*',
-      'sum-outputs',
-      'input<sequence-unsafe',
-      'output>sequence' // tafn
-    ];
-    factor.combinators.pattern = arrToWordsRegExp(combinators);
-    Prism.languages.factor = factor;
-  })(Prism);
+	    var comment_inside = {
+	      function:
+	        /\b(?:BUGS?|FIX(?:MES?)?|NOTES?|TODOS?|XX+|HACKS?|WARN(?:ING)?|\?{2,}|!{2,})\b/
+	    };
+	    var string_inside = {
+	      number: /\\[^\s']|%\w/
+	    };
+	    var factor = {
+	      comment: [
+	        {
+	          // ! single-line exclamation point comments with whitespace after/around the !
+	          pattern: /(^|\s)(?:! .*|!$)/,
+	          lookbehind: true,
+	          inside: comment_inside
+	        },
+	        /* from basis/multiline: */
+	        {
+	          // /* comment */, /* comment*/
+	          pattern: /(^|\s)\/\*\s[\s\S]*?\*\/(?=\s|$)/,
+	          lookbehind: true,
+	          greedy: true,
+	          inside: comment_inside
+	        },
+	        {
+	          // ![[ comment ]] , ![===[ comment]===]
+	          pattern: /(^|\s)!\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,
+	          lookbehind: true,
+	          greedy: true,
+	          inside: comment_inside
+	        }
+	      ],
+	      number: [
+	        {
+	          // basic base 10 integers 9, -9
+	          pattern: /(^|\s)[+-]?\d+(?=\s|$)/,
+	          lookbehind: true
+	        },
+	        {
+	          // base prefix integers 0b010 0o70 0xad 0d10 0XAD -0xa9
+	          pattern: /(^|\s)[+-]?0(?:b[01]+|o[0-7]+|d\d+|x[\dA-F]+)(?=\s|$)/i,
+	          lookbehind: true
+	        },
+	        {
+	          // fractional ratios 1/5 -1/5 and the literal float approximations 1/5. -1/5.
+	          pattern: /(^|\s)[+-]?\d+\/\d+\.?(?=\s|$)/,
+	          lookbehind: true
+	        },
+	        {
+	          // positive mixed numbers 23+1/5 +23+1/5
+	          pattern: /(^|\s)\+?\d+\+\d+\/\d+(?=\s|$)/,
+	          lookbehind: true
+	        },
+	        {
+	          // negative mixed numbers -23-1/5
+	          pattern: /(^|\s)-\d+-\d+\/\d+(?=\s|$)/,
+	          lookbehind: true
+	        },
+	        {
+	          // basic decimal floats -0.01 0. .0 .1 -.1 -1. -12.13 +12.13
+	          // and scientific notation with base 10 exponents 3e4 3e-4 .3e-4
+	          pattern:
+	            /(^|\s)[+-]?(?:\d*\.\d+|\d+\.\d*|\d+)(?:e[+-]?\d+)?(?=\s|$)/i,
+	          lookbehind: true
+	        },
+	        {
+	          // NAN literal syntax NAN: 80000deadbeef, NAN: a
+	          pattern: /(^|\s)NAN:\s+[\da-fA-F]+(?=\s|$)/,
+	          lookbehind: true
+	        },
+	        {
+	          /*
+	base prefix floats 0x1.0p3 (8.0) 0b1.010p2 (5.0) 0x1.p1 0b1.11111111p11111...
+	"The normalized hex form ±0x1.MMMMMMMMMMMMM[pP]±EEEE allows any floating-point number to be specified precisely.
+	The values of MMMMMMMMMMMMM and EEEE map directly to the mantissa and exponent fields of the binary IEEE 754 representation."
+	<https://docs.factorcode.org/content/article-syntax-floats.html>
+	*/
+	          pattern:
+	            /(^|\s)[+-]?0(?:b1\.[01]*|o1\.[0-7]*|d1\.\d*|x1\.[\dA-F]*)p\d+(?=\s|$)/i,
+	          lookbehind: true
+	        }
+	      ],
+	      // R/ regexp?\/\\/
+	      regexp: {
+	        pattern:
+	          /(^|\s)R\/\s(?:\\\S|[^\\/])*\/(?:[idmsr]*|[idmsr]+-[idmsr]+)(?=\s|$)/,
+	        lookbehind: true,
+	        alias: 'number',
+	        inside: {
+	          variable: /\\\S/,
+	          keyword: /[+?*\[\]^$(){}.|]/,
+	          operator: {
+	            pattern: /(\/)[idmsr]+(?:-[idmsr]+)?/,
+	            lookbehind: true
+	          }
+	        }
+	      },
+	      boolean: {
+	        pattern: /(^|\s)[tf](?=\s|$)/,
+	        lookbehind: true
+	      },
+	      // SBUF" asd", URL" ://...", P" /etc/"
+	      'custom-string': {
+	        pattern: /(^|\s)[A-Z0-9\-]+"\s(?:\\\S|[^"\\])*"/,
+	        lookbehind: true,
+	        greedy: true,
+	        alias: 'string',
+	        inside: {
+	          number: /\\\S|%\w|\//
+	        }
+	      },
+	      'multiline-string': [
+	        {
+	          // STRING: name \n content \n ; -> CONSTANT: name "content" (symbol)
+	          pattern: /(^|\s)STRING:\s+\S+(?:\n|\r\n).*(?:\n|\r\n)\s*;(?=\s|$)/,
+	          lookbehind: true,
+	          greedy: true,
+	          alias: 'string',
+	          inside: {
+	            number: string_inside.number,
+	            // trailing semicolon on its own line
+	            'semicolon-or-setlocal': {
+	              pattern: /([\r\n][ \t]*);(?=\s|$)/,
+	              lookbehind: true,
+	              alias: 'function'
+	            }
+	          }
+	        },
+	        {
+	          // HEREDOC: marker \n content \n marker ; -> "content" (immediate)
+	          pattern: /(^|\s)HEREDOC:\s+\S+(?:\n|\r\n).*(?:\n|\r\n)\s*\S+(?=\s|$)/,
+	          lookbehind: true,
+	          greedy: true,
+	          alias: 'string',
+	          inside: string_inside
+	        },
+	        {
+	          // [[ string ]], [==[ string]==]
+	          pattern: /(^|\s)\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,
+	          lookbehind: true,
+	          greedy: true,
+	          alias: 'string',
+	          inside: string_inside
+	        }
+	      ],
+	      'special-using': {
+	        pattern: /(^|\s)USING:(?:\s\S+)*(?=\s+;(?:\s|$))/,
+	        lookbehind: true,
+	        alias: 'function',
+	        inside: {
+	          // this is essentially a regex for vocab names, which i don't want to specify
+	          // but the USING: gets picked up as a vocab name
+	          string: {
+	            pattern: /(\s)[^:\s]+/,
+	            lookbehind: true
+	          }
+	        }
+	      },
+	      /* this description of stack effect literal syntax is not complete and not as specific as theoretically possible
+	trying to do better is more work and regex-computation-time than it's worth though.
+	- we'd like to have the "delimiter" parts of the stack effect [ (, --, and ) ] be a different (less-important or comment-like) colour to the stack effect contents
+	- we'd like if nested stack effects were treated as such rather than just appearing flat (with `inside`)
+	- we'd like if the following variable name conventions were recognised specifically:
+	special row variables = ..a b..
+	type and stack effect annotations end with a colon = ( quot: ( a: ( -- ) -- b ) -- x ), ( x: number -- )
+	word throws unconditional error = *
+	any other word-like variable name = a ? q' etc
+	https://docs.factorcode.org/content/article-effects.html
+	these are pretty complicated to highlight properly without a real parser, and therefore out of scope
+	the old pattern, which may be later useful, was: (^|\s)(?:call|execute|eval)?\((?:\s+[^"\r\n\t ]\S*)*?\s+--(?:\s+[^"\n\t ]\S*)*?\s+\)(?=\s|$)
+	*/
+	      // current solution is not great
+	      'stack-effect-delimiter': [
+	        {
+	          // opening parenthesis
+	          pattern: /(^|\s)(?:call|eval|execute)?\((?=\s)/,
+	          lookbehind: true,
+	          alias: 'operator'
+	        },
+	        {
+	          // middle --
+	          pattern: /(\s)--(?=\s)/,
+	          lookbehind: true,
+	          alias: 'operator'
+	        },
+	        {
+	          // closing parenthesis
+	          pattern: /(\s)\)(?=\s|$)/,
+	          lookbehind: true,
+	          alias: 'operator'
+	        }
+	      ],
+	      combinators: {
+	        pattern: null,
+	        lookbehind: true,
+	        alias: 'keyword'
+	      },
+	      'kernel-builtin': {
+	        pattern: null,
+	        lookbehind: true,
+	        alias: 'variable'
+	      },
+	      'sequences-builtin': {
+	        pattern: null,
+	        lookbehind: true,
+	        alias: 'variable'
+	      },
+	      'math-builtin': {
+	        pattern: null,
+	        lookbehind: true,
+	        alias: 'variable'
+	      },
+	      'constructor-word': {
+	        // <array> but not <=>
+	        pattern: /(^|\s)<(?!=+>|-+>)\S+>(?=\s|$)/,
+	        lookbehind: true,
+	        alias: 'keyword'
+	      },
+	      'other-builtin-syntax': {
+	        pattern: null,
+	        lookbehind: true,
+	        alias: 'operator'
+	      },
+	      /*
+	full list of supported word naming conventions: (the convention appears outside of the [brackets])
+	set-[x]
+	change-[x]
+	with-[x]
+	new-[x]
+	>[string]
+	[base]>
+	[string]>[number]
+	+[symbol]+
+	[boolean-word]?
+	?[of]
+	[slot-reader]>>
+	>>[slot-setter]
+	[slot-writer]<<
+	([implementation-detail])
+	[mutater]!
+	[variant]*
+	[prettyprint].
+	$[help-markup]
+	<constructors>, SYNTAX:, etc are supported by their own patterns.
+	`with` and `new` from `kernel` are their own builtins.
+	see <https://docs.factorcode.org/content/article-conventions.html>
+	*/
+	      'conventionally-named-word': {
+	        pattern:
+	          /(^|\s)(?!")(?:(?:change|new|set|with)-\S+|\$\S+|>[^>\s]+|[^:>\s]+>|[^>\s]+>[^>\s]+|\+[^+\s]+\+|[^?\s]+\?|\?[^?\s]+|[^>\s]+>>|>>[^>\s]+|[^<\s]+<<|\([^()\s]+\)|[^!\s]+!|[^*\s]\S*\*|[^.\s]\S*\.)(?=\s|$)/,
+	        lookbehind: true,
+	        alias: 'keyword'
+	      },
+	      'colon-syntax': {
+	        pattern: /(^|\s)(?:[A-Z0-9\-]+#?)?:{1,2}\s+(?:;\S+|(?!;)\S+)(?=\s|$)/,
+	        lookbehind: true,
+	        greedy: true,
+	        alias: 'function'
+	      },
+	      'semicolon-or-setlocal': {
+	        pattern: /(\s)(?:;|:>)(?=\s|$)/,
+	        lookbehind: true,
+	        alias: 'function'
+	      },
+	      // do not highlight leading } or trailing X{ at the begin/end of the file as it's invalid syntax
+	      'curly-brace-literal-delimiter': [
+	        {
+	          // opening
+	          pattern: /(^|\s)[a-z]*\{(?=\s)/i,
+	          lookbehind: true,
+	          alias: 'operator'
+	        },
+	        {
+	          // closing
+	          pattern: /(\s)\}(?=\s|$)/,
+	          lookbehind: true,
+	          alias: 'operator'
+	        }
+	      ],
+	      // do not highlight leading ] or trailing [ at the begin/end of the file as it's invalid syntax
+	      'quotation-delimiter': [
+	        {
+	          // opening
+	          pattern: /(^|\s)\[(?=\s)/,
+	          lookbehind: true,
+	          alias: 'operator'
+	        },
+	        {
+	          // closing
+	          pattern: /(\s)\](?=\s|$)/,
+	          lookbehind: true,
+	          alias: 'operator'
+	        }
+	      ],
+	      'normal-word': {
+	        pattern: /(^|\s)[^"\s]\S*(?=\s|$)/,
+	        lookbehind: true
+	      },
+	      /*
+	basic first-class string "a"
+	with escaped double-quote "a\""
+	escaped backslash "\\"
+	and general escapes since Factor has so many "\N"
+	syntax that works in the reference implementation that isn't fully
+	supported because it's an implementation detail:
+	"string 1""string 2" -> 2 strings (works anyway)
+	"string"5 -> string, 5
+	"string"[ ] -> string, quotation
+	{ "a"} -> array<string>
+	the rest of those examples all properly recognise the string, but not
+	the other object (number, quotation, etc)
+	this is fine for a regex-only implementation.
+	*/
+	      string: {
+	        pattern: /"(?:\\\S|[^"\\])*"/,
+	        greedy: true,
+	        inside: string_inside
+	      }
+	    };
+	    var escape = function (str) {
+	      return (str + '').replace(/([.?*+\^$\[\]\\(){}|\-])/g, '\\$1')
+	    };
+	    var arrToWordsRegExp = function (arr) {
+	      return new RegExp('(^|\\s)(?:' + arr.map(escape).join('|') + ')(?=\\s|$)')
+	    };
+	    var builtins = {
+	      'kernel-builtin': [
+	        'or',
+	        '2nipd',
+	        '4drop',
+	        'tuck',
+	        'wrapper',
+	        'nip',
+	        'wrapper?',
+	        'callstack>array',
+	        'die',
+	        'dupd',
+	        'callstack',
+	        'callstack?',
+	        '3dup',
+	        'hashcode',
+	        'pick',
+	        '4nip',
+	        'build',
+	        '>boolean',
+	        'nipd',
+	        'clone',
+	        '5nip',
+	        'eq?',
+	        '?',
+	        '=',
+	        'swapd',
+	        '2over',
+	        'clear',
+	        '2dup',
+	        'get-retainstack',
+	        'not',
+	        'tuple?',
+	        'dup',
+	        '3nipd',
+	        'call',
+	        '-rotd',
+	        'object',
+	        'drop',
+	        'assert=',
+	        'assert?',
+	        '-rot',
+	        'execute',
+	        'boa',
+	        'get-callstack',
+	        'curried?',
+	        '3drop',
+	        'pickd',
+	        'overd',
+	        'over',
+	        'roll',
+	        '3nip',
+	        'swap',
+	        'and',
+	        '2nip',
+	        'rotd',
+	        'throw',
+	        '(clone)',
+	        'hashcode*',
+	        'spin',
+	        'reach',
+	        '4dup',
+	        'equal?',
+	        'get-datastack',
+	        'assert',
+	        '2drop',
+	        '<wrapper>',
+	        'boolean?',
+	        'identity-hashcode',
+	        'identity-tuple?',
+	        'null',
+	        'composed?',
+	        'new',
+	        '5drop',
+	        'rot',
+	        '-roll',
+	        'xor',
+	        'identity-tuple',
+	        'boolean'
+	      ],
+	      'other-builtin-syntax': [
+	        // syntax
+	        '=======',
+	        'recursive',
+	        'flushable',
+	        '>>',
+	        '<<<<<<',
+	        'M\\',
+	        'B',
+	        'PRIVATE>',
+	        '\\',
+	        '======',
+	        'final',
+	        'inline',
+	        'delimiter',
+	        'deprecated',
+	        '<PRIVATE',
+	        '>>>>>>',
+	        '<<<<<<<',
+	        'parse-complex',
+	        'malformed-complex',
+	        'read-only',
+	        '>>>>>>>',
+	        'call-next-method',
+	        '<<',
+	        'foldable', // literals
+	        '$',
+	        '$[',
+	        '${'
+	      ],
+	      'sequences-builtin': [
+	        'member-eq?',
+	        'mismatch',
+	        'append',
+	        'assert-sequence=',
+	        'longer',
+	        'repetition',
+	        'clone-like',
+	        '3sequence',
+	        'assert-sequence?',
+	        'last-index-from',
+	        'reversed',
+	        'index-from',
+	        'cut*',
+	        'pad-tail',
+	        'join-as',
+	        'remove-eq!',
+	        'concat-as',
+	        'but-last',
+	        'snip',
+	        'nths',
+	        'nth',
+	        'sequence',
+	        'longest',
+	        'slice?',
+	        '<slice>',
+	        'remove-nth',
+	        'tail-slice',
+	        'empty?',
+	        'tail*',
+	        'member?',
+	        'virtual-sequence?',
+	        'set-length',
+	        'drop-prefix',
+	        'iota',
+	        'unclip',
+	        'bounds-error?',
+	        'unclip-last-slice',
+	        'non-negative-integer-expected',
+	        'non-negative-integer-expected?',
+	        'midpoint@',
+	        'longer?',
+	        '?set-nth',
+	        '?first',
+	        'rest-slice',
+	        'prepend-as',
+	        'prepend',
+	        'fourth',
+	        'sift',
+	        'subseq-start',
+	        'new-sequence',
+	        '?last',
+	        'like',
+	        'first4',
+	        '1sequence',
+	        'reverse',
+	        'slice',
+	        'virtual@',
+	        'repetition?',
+	        'set-last',
+	        'index',
+	        '4sequence',
+	        'max-length',
+	        'set-second',
+	        'immutable-sequence',
+	        'first2',
+	        'first3',
+	        'supremum',
+	        'unclip-slice',
+	        'suffix!',
+	        'insert-nth',
+	        'tail',
+	        '3append',
+	        'short',
+	        'suffix',
+	        'concat',
+	        'flip',
+	        'immutable?',
+	        'reverse!',
+	        '2sequence',
+	        'sum',
+	        'delete-all',
+	        'indices',
+	        'snip-slice',
+	        '<iota>',
+	        'check-slice',
+	        'sequence?',
+	        'head',
+	        'append-as',
+	        'halves',
+	        'sequence=',
+	        'collapse-slice',
+	        '?second',
+	        'slice-error?',
+	        'product',
+	        'bounds-check?',
+	        'bounds-check',
+	        'immutable',
+	        'virtual-exemplar',
+	        'harvest',
+	        'remove',
+	        'pad-head',
+	        'last',
+	        'set-fourth',
+	        'cartesian-product',
+	        'remove-eq',
+	        'shorten',
+	        'shorter',
+	        'reversed?',
+	        'shorter?',
+	        'shortest',
+	        'head-slice',
+	        'pop*',
+	        'tail-slice*',
+	        'but-last-slice',
+	        'iota?',
+	        'append!',
+	        'cut-slice',
+	        'new-resizable',
+	        'head-slice*',
+	        'sequence-hashcode',
+	        'pop',
+	        'set-nth',
+	        '?nth',
+	        'second',
+	        'join',
+	        'immutable-sequence?',
+	        '<reversed>',
+	        '3append-as',
+	        'virtual-sequence',
+	        'subseq?',
+	        'remove-nth!',
+	        'length',
+	        'last-index',
+	        'lengthen',
+	        'assert-sequence',
+	        'copy',
+	        'move',
+	        'third',
+	        'first',
+	        'tail?',
+	        'set-first',
+	        'prefix',
+	        'bounds-error',
+	        '<repetition>',
+	        'exchange',
+	        'surround',
+	        'cut',
+	        'min-length',
+	        'set-third',
+	        'push-all',
+	        'head?',
+	        'subseq-start-from',
+	        'delete-slice',
+	        'rest',
+	        'sum-lengths',
+	        'head*',
+	        'infimum',
+	        'remove!',
+	        'glue',
+	        'slice-error',
+	        'subseq',
+	        'push',
+	        'replace-slice',
+	        'subseq-as',
+	        'unclip-last'
+	      ],
+	      'math-builtin': [
+	        'number=',
+	        'next-power-of-2',
+	        '?1+',
+	        'fp-special?',
+	        'imaginary-part',
+	        'float>bits',
+	        'number?',
+	        'fp-infinity?',
+	        'bignum?',
+	        'fp-snan?',
+	        'denominator',
+	        'gcd',
+	        '*',
+	        '+',
+	        'fp-bitwise=',
+	        '-',
+	        'u>=',
+	        '/',
+	        '>=',
+	        'bitand',
+	        'power-of-2?',
+	        'log2-expects-positive',
+	        'neg?',
+	        '<',
+	        'log2',
+	        '>',
+	        'integer?',
+	        'number',
+	        'bits>double',
+	        '2/',
+	        'zero?',
+	        'bits>float',
+	        'float?',
+	        'shift',
+	        'ratio?',
+	        'rect>',
+	        'even?',
+	        'ratio',
+	        'fp-sign',
+	        'bitnot',
+	        '>fixnum',
+	        'complex?',
+	        '/i',
+	        'integer>fixnum',
+	        '/f',
+	        'sgn',
+	        '>bignum',
+	        'next-float',
+	        'u<',
+	        'u>',
+	        'mod',
+	        'recip',
+	        'rational',
+	        '>float',
+	        '2^',
+	        'integer',
+	        'fixnum?',
+	        'neg',
+	        'fixnum',
+	        'sq',
+	        'bignum',
+	        '>rect',
+	        'bit?',
+	        'fp-qnan?',
+	        'simple-gcd',
+	        'complex',
+	        '<fp-nan>',
+	        'real',
+	        '>fraction',
+	        'double>bits',
+	        'bitor',
+	        'rem',
+	        'fp-nan-payload',
+	        'real-part',
+	        'log2-expects-positive?',
+	        'prev-float',
+	        'align',
+	        'unordered?',
+	        'float',
+	        'fp-nan?',
+	        'abs',
+	        'bitxor',
+	        'integer>fixnum-strict',
+	        'u<=',
+	        'odd?',
+	        '<=',
+	        '/mod',
+	        '>integer',
+	        'real?',
+	        'rational?',
+	        'numerator'
+	      ] // that's all for now
+	    };
+	    Object.keys(builtins).forEach(function (k) {
+	      factor[k].pattern = arrToWordsRegExp(builtins[k]);
+	    });
+	    var combinators = [
+	      // kernel
+	      '2bi',
+	      'while',
+	      '2tri',
+	      'bi*',
+	      '4dip',
+	      'both?',
+	      'same?',
+	      'tri@',
+	      'curry',
+	      'prepose',
+	      '3bi',
+	      '?if',
+	      'tri*',
+	      '2keep',
+	      '3keep',
+	      'curried',
+	      '2keepd',
+	      'when',
+	      '2bi*',
+	      '2tri*',
+	      '4keep',
+	      'bi@',
+	      'keepdd',
+	      'do',
+	      'unless*',
+	      'tri-curry',
+	      'if*',
+	      'loop',
+	      'bi-curry*',
+	      'when*',
+	      '2bi@',
+	      '2tri@',
+	      'with',
+	      '2with',
+	      'either?',
+	      'bi',
+	      'until',
+	      '3dip',
+	      '3curry',
+	      'tri-curry*',
+	      'tri-curry@',
+	      'bi-curry',
+	      'keepd',
+	      'compose',
+	      '2dip',
+	      'if',
+	      '3tri',
+	      'unless',
+	      'tuple',
+	      'keep',
+	      '2curry',
+	      'tri',
+	      'most',
+	      'while*',
+	      'dip',
+	      'composed',
+	      'bi-curry@', // sequences
+	      'find-last-from',
+	      'trim-head-slice',
+	      'map-as',
+	      'each-from',
+	      'none?',
+	      'trim-tail',
+	      'partition',
+	      'if-empty',
+	      'accumulate*',
+	      'reject!',
+	      'find-from',
+	      'accumulate-as',
+	      'collector-for-as',
+	      'reject',
+	      'map',
+	      'map-sum',
+	      'accumulate!',
+	      '2each-from',
+	      'follow',
+	      'supremum-by',
+	      'map!',
+	      'unless-empty',
+	      'collector',
+	      'padding',
+	      'reduce-index',
+	      'replicate-as',
+	      'infimum-by',
+	      'trim-tail-slice',
+	      'count',
+	      'find-index',
+	      'filter',
+	      'accumulate*!',
+	      'reject-as',
+	      'map-integers',
+	      'map-find',
+	      'reduce',
+	      'selector',
+	      'interleave',
+	      '2map',
+	      'filter-as',
+	      'binary-reduce',
+	      'map-index-as',
+	      'find',
+	      'produce',
+	      'filter!',
+	      'replicate',
+	      'cartesian-map',
+	      'cartesian-each',
+	      'find-index-from',
+	      'map-find-last',
+	      '3map-as',
+	      '3map',
+	      'find-last',
+	      'selector-as',
+	      '2map-as',
+	      '2map-reduce',
+	      'accumulate',
+	      'each',
+	      'each-index',
+	      'accumulate*-as',
+	      'when-empty',
+	      'all?',
+	      'collector-as',
+	      'push-either',
+	      'new-like',
+	      'collector-for',
+	      '2selector',
+	      'push-if',
+	      '2all?',
+	      'map-reduce',
+	      '3each',
+	      'any?',
+	      'trim-slice',
+	      '2reduce',
+	      'change-nth',
+	      'produce-as',
+	      '2each',
+	      'trim',
+	      'trim-head',
+	      'cartesian-find',
+	      'map-index', // math
+	      'if-zero',
+	      'each-integer',
+	      'unless-zero',
+	      '(find-integer)',
+	      'when-zero',
+	      'find-last-integer',
+	      '(all-integers?)',
+	      'times',
+	      '(each-integer)',
+	      'find-integer',
+	      'all-integers?', // math.combinators
+	      'unless-negative',
+	      'if-positive',
+	      'when-positive',
+	      'when-negative',
+	      'unless-positive',
+	      'if-negative', // combinators
+	      'case',
+	      '2cleave',
+	      'cond>quot',
+	      'case>quot',
+	      '3cleave',
+	      'wrong-values',
+	      'to-fixed-point',
+	      'alist>quot',
+	      'cond',
+	      'cleave',
+	      'call-effect',
+	      'recursive-hashcode',
+	      'spread',
+	      'deep-spread>quot', // combinators.short-circuit
+	      '2||',
+	      '0||',
+	      'n||',
+	      '0&&',
+	      '2&&',
+	      '3||',
+	      '1||',
+	      '1&&',
+	      'n&&',
+	      '3&&', // combinators.smart
+	      'smart-unless*',
+	      'keep-inputs',
+	      'reduce-outputs',
+	      'smart-when*',
+	      'cleave>array',
+	      'smart-with',
+	      'smart-apply',
+	      'smart-if',
+	      'inputs/outputs',
+	      'output>sequence-n',
+	      'map-outputs',
+	      'map-reduce-outputs',
+	      'dropping',
+	      'output>array',
+	      'smart-map-reduce',
+	      'smart-2map-reduce',
+	      'output>array-n',
+	      'nullary',
+	      'input<sequence',
+	      'append-outputs',
+	      'drop-inputs',
+	      'inputs',
+	      'smart-2reduce',
+	      'drop-outputs',
+	      'smart-reduce',
+	      'preserving',
+	      'smart-when',
+	      'outputs',
+	      'append-outputs-as',
+	      'smart-unless',
+	      'smart-if*',
+	      'sum-outputs',
+	      'input<sequence-unsafe',
+	      'output>sequence' // tafn
+	    ];
+	    factor.combinators.pattern = arrToWordsRegExp(combinators);
+	    Prism.languages.factor = factor;
+	  })(Prism);
+	}
+	return factor_1;
 }
 
-var _false = $false;
-$false.displayName = '$false';
-$false.aliases = [];
-function $false(Prism) {
+var _false;
+var hasRequired_false;
+
+function require_false () {
+	if (hasRequired_false) return _false;
+	hasRequired_false = 1;
+
+	_false = $false;
+	$false.displayName = '$false';
+	$false.aliases = [];
+	function $false(Prism) {
 (function (Prism) {
-    /**
-     * Based on the manual by Wouter van Oortmerssen.
-     *
-     * @see {@link https://github.com/PrismJS/prism/issues/2801#issue-829717504}
-     */
-    Prism.languages['false'] = {
-      comment: {
-        pattern: /\{[^}]*\}/
-      },
-      string: {
-        pattern: /"[^"]*"/,
-        greedy: true
-      },
-      'character-code': {
-        pattern: /'(?:[^\r]|\r\n?)/,
-        alias: 'number'
-      },
-      'assembler-code': {
-        pattern: /\d+`/,
-        alias: 'important'
-      },
-      number: /\d+/,
-      operator: /[-!#$%&'*+,./:;=>?@\\^_`|~ßø]/,
-      punctuation: /\[|\]/,
-      variable: /[a-z]/,
-      'non-standard': {
-        pattern: /[()<BDO®]/,
-        alias: 'bold'
-      }
-    };
-  })(Prism);
+	    /**
+	     * Based on the manual by Wouter van Oortmerssen.
+	     *
+	     * @see {@link https://github.com/PrismJS/prism/issues/2801#issue-829717504}
+	     */
+	    Prism.languages['false'] = {
+	      comment: {
+	        pattern: /\{[^}]*\}/
+	      },
+	      string: {
+	        pattern: /"[^"]*"/,
+	        greedy: true
+	      },
+	      'character-code': {
+	        pattern: /'(?:[^\r]|\r\n?)/,
+	        alias: 'number'
+	      },
+	      'assembler-code': {
+	        pattern: /\d+`/,
+	        alias: 'important'
+	      },
+	      number: /\d+/,
+	      operator: /[-!#$%&'*+,./:;=>?@\\^_`|~ßø]/,
+	      punctuation: /\[|\]/,
+	      variable: /[a-z]/,
+	      'non-standard': {
+	        pattern: /[()<BDO®]/,
+	        alias: 'bold'
+	      }
+	    };
+	  })(Prism);
+	}
+	return _false;
 }
 
-var firestoreSecurityRules_1 = firestoreSecurityRules;
-firestoreSecurityRules.displayName = 'firestoreSecurityRules';
-firestoreSecurityRules.aliases = [];
-function firestoreSecurityRules(Prism) {
-  Prism.languages['firestore-security-rules'] = Prism.languages.extend(
-    'clike',
-    {
-      comment: /\/\/.*/,
-      keyword:
-        /\b(?:allow|function|if|match|null|return|rules_version|service)\b/,
-      operator: /&&|\|\||[<>!=]=?|[-+*/%]|\b(?:in|is)\b/
-    }
-  );
-  delete Prism.languages['firestore-security-rules']['class-name'];
-  Prism.languages.insertBefore('firestore-security-rules', 'keyword', {
-    path: {
-      pattern:
-        /(^|[\s(),])(?:\/(?:[\w\xA0-\uFFFF]+|\{[\w\xA0-\uFFFF]+(?:=\*\*)?\}|\$\([\w\xA0-\uFFFF.]+\)))+/,
-      lookbehind: true,
-      greedy: true,
-      inside: {
-        variable: {
-          pattern: /\{[\w\xA0-\uFFFF]+(?:=\*\*)?\}|\$\([\w\xA0-\uFFFF.]+\)/,
-          inside: {
-            operator: /=/,
-            keyword: /\*\*/,
-            punctuation: /[.$(){}]/
-          }
-        },
-        punctuation: /\//
-      }
-    },
-    method: {
-      // to make the pattern shorter, the actual method names are omitted
-      pattern: /(\ballow\s+)[a-z]+(?:\s*,\s*[a-z]+)*(?=\s*[:;])/,
-      lookbehind: true,
-      alias: 'builtin',
-      inside: {
-        punctuation: /,/
-      }
-    }
-  });
+var firestoreSecurityRules_1;
+var hasRequiredFirestoreSecurityRules;
+
+function requireFirestoreSecurityRules () {
+	if (hasRequiredFirestoreSecurityRules) return firestoreSecurityRules_1;
+	hasRequiredFirestoreSecurityRules = 1;
+
+	firestoreSecurityRules_1 = firestoreSecurityRules;
+	firestoreSecurityRules.displayName = 'firestoreSecurityRules';
+	firestoreSecurityRules.aliases = [];
+	function firestoreSecurityRules(Prism) {
+	  Prism.languages['firestore-security-rules'] = Prism.languages.extend(
+	    'clike',
+	    {
+	      comment: /\/\/.*/,
+	      keyword:
+	        /\b(?:allow|function|if|match|null|return|rules_version|service)\b/,
+	      operator: /&&|\|\||[<>!=]=?|[-+*/%]|\b(?:in|is)\b/
+	    }
+	  );
+	  delete Prism.languages['firestore-security-rules']['class-name'];
+	  Prism.languages.insertBefore('firestore-security-rules', 'keyword', {
+	    path: {
+	      pattern:
+	        /(^|[\s(),])(?:\/(?:[\w\xA0-\uFFFF]+|\{[\w\xA0-\uFFFF]+(?:=\*\*)?\}|\$\([\w\xA0-\uFFFF.]+\)))+/,
+	      lookbehind: true,
+	      greedy: true,
+	      inside: {
+	        variable: {
+	          pattern: /\{[\w\xA0-\uFFFF]+(?:=\*\*)?\}|\$\([\w\xA0-\uFFFF.]+\)/,
+	          inside: {
+	            operator: /=/,
+	            keyword: /\*\*/,
+	            punctuation: /[.$(){}]/
+	          }
+	        },
+	        punctuation: /\//
+	      }
+	    },
+	    method: {
+	      // to make the pattern shorter, the actual method names are omitted
+	      pattern: /(\ballow\s+)[a-z]+(?:\s*,\s*[a-z]+)*(?=\s*[:;])/,
+	      lookbehind: true,
+	      alias: 'builtin',
+	      inside: {
+	        punctuation: /,/
+	      }
+	    }
+	  });
+	}
+	return firestoreSecurityRules_1;
 }
 
-var flow_1 = flow;
-flow.displayName = 'flow';
-flow.aliases = [];
-function flow(Prism) {
+var flow_1;
+var hasRequiredFlow;
+
+function requireFlow () {
+	if (hasRequiredFlow) return flow_1;
+	hasRequiredFlow = 1;
+
+	flow_1 = flow;
+	flow.displayName = 'flow';
+	flow.aliases = [];
+	function flow(Prism) {
 (function (Prism) {
-    Prism.languages.flow = Prism.languages.extend('javascript', {});
-    Prism.languages.insertBefore('flow', 'keyword', {
-      type: [
-        {
-          pattern:
-            /\b(?:[Bb]oolean|Function|[Nn]umber|[Ss]tring|any|mixed|null|void)\b/,
-          alias: 'tag'
-        }
-      ]
-    });
-    Prism.languages.flow['function-variable'].pattern =
-      /(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=\s*(?:function\b|(?:\([^()]*\)(?:\s*:\s*\w+)?|(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/i;
-    delete Prism.languages.flow['parameter'];
-    Prism.languages.insertBefore('flow', 'operator', {
-      'flow-punctuation': {
-        pattern: /\{\||\|\}/,
-        alias: 'punctuation'
-      }
-    });
-    if (!Array.isArray(Prism.languages.flow.keyword)) {
-      Prism.languages.flow.keyword = [Prism.languages.flow.keyword];
-    }
-    Prism.languages.flow.keyword.unshift(
-      {
-        pattern: /(^|[^$]\b)(?:Class|declare|opaque|type)\b(?!\$)/,
-        lookbehind: true
-      },
-      {
-        pattern:
-          /(^|[^$]\B)\$(?:Diff|Enum|Exact|Keys|ObjMap|PropertyType|Record|Shape|Subtype|Supertype|await)\b(?!\$)/,
-        lookbehind: true
-      }
-    );
-  })(Prism);
+	    Prism.languages.flow = Prism.languages.extend('javascript', {});
+	    Prism.languages.insertBefore('flow', 'keyword', {
+	      type: [
+	        {
+	          pattern:
+	            /\b(?:[Bb]oolean|Function|[Nn]umber|[Ss]tring|any|mixed|null|void)\b/,
+	          alias: 'tag'
+	        }
+	      ]
+	    });
+	    Prism.languages.flow['function-variable'].pattern =
+	      /(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=\s*(?:function\b|(?:\([^()]*\)(?:\s*:\s*\w+)?|(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/i;
+	    delete Prism.languages.flow['parameter'];
+	    Prism.languages.insertBefore('flow', 'operator', {
+	      'flow-punctuation': {
+	        pattern: /\{\||\|\}/,
+	        alias: 'punctuation'
+	      }
+	    });
+	    if (!Array.isArray(Prism.languages.flow.keyword)) {
+	      Prism.languages.flow.keyword = [Prism.languages.flow.keyword];
+	    }
+	    Prism.languages.flow.keyword.unshift(
+	      {
+	        pattern: /(^|[^$]\b)(?:Class|declare|opaque|type)\b(?!\$)/,
+	        lookbehind: true
+	      },
+	      {
+	        pattern:
+	          /(^|[^$]\B)\$(?:Diff|Enum|Exact|Keys|ObjMap|PropertyType|Record|Shape|Subtype|Supertype|await)\b(?!\$)/,
+	        lookbehind: true
+	      }
+	    );
+	  })(Prism);
+	}
+	return flow_1;
 }
 
-var fortran_1 = fortran;
-fortran.displayName = 'fortran';
-fortran.aliases = [];
-function fortran(Prism) {
-  Prism.languages.fortran = {
-    'quoted-number': {
-      pattern: /[BOZ](['"])[A-F0-9]+\1/i,
-      alias: 'number'
-    },
-    string: {
-      pattern:
-        /(?:\b\w+_)?(['"])(?:\1\1|&(?:\r\n?|\n)(?:[ \t]*!.*(?:\r\n?|\n)|(?![ \t]*!))|(?!\1).)*(?:\1|&)/,
-      inside: {
-        comment: {
-          pattern: /(&(?:\r\n?|\n)\s*)!.*/,
-          lookbehind: true
-        }
-      }
-    },
-    comment: {
-      pattern: /!.*/,
-      greedy: true
-    },
-    boolean: /\.(?:FALSE|TRUE)\.(?:_\w+)?/i,
-    number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[ED][+-]?\d+)?(?:_\w+)?/i,
-    keyword: [
-      // Types
-      /\b(?:CHARACTER|COMPLEX|DOUBLE ?PRECISION|INTEGER|LOGICAL|REAL)\b/i, // END statements
-      /\b(?:END ?)?(?:BLOCK ?DATA|DO|FILE|FORALL|FUNCTION|IF|INTERFACE|MODULE(?! PROCEDURE)|PROGRAM|SELECT|SUBROUTINE|TYPE|WHERE)\b/i, // Statements
-      /\b(?:ALLOCATABLE|ALLOCATE|BACKSPACE|CALL|CASE|CLOSE|COMMON|CONTAINS|CONTINUE|CYCLE|DATA|DEALLOCATE|DIMENSION|DO|END|EQUIVALENCE|EXIT|EXTERNAL|FORMAT|GO ?TO|IMPLICIT(?: NONE)?|INQUIRE|INTENT|INTRINSIC|MODULE PROCEDURE|NAMELIST|NULLIFY|OPEN|OPTIONAL|PARAMETER|POINTER|PRINT|PRIVATE|PUBLIC|READ|RETURN|REWIND|SAVE|SELECT|STOP|TARGET|WHILE|WRITE)\b/i, // Others
-      /\b(?:ASSIGNMENT|DEFAULT|ELEMENTAL|ELSE|ELSEIF|ELSEWHERE|ENTRY|IN|INCLUDE|INOUT|KIND|NULL|ONLY|OPERATOR|OUT|PURE|RECURSIVE|RESULT|SEQUENCE|STAT|THEN|USE)\b/i
-    ],
-    operator: [
-      /\*\*|\/\/|=>|[=\/]=|[<>]=?|::|[+\-*=%]|\.[A-Z]+\./i,
-      {
-        // Use lookbehind to prevent confusion with (/ /)
-        pattern: /(^|(?!\().)\/(?!\))/,
-        lookbehind: true
-      }
-    ],
-    punctuation: /\(\/|\/\)|[(),;:&]/
-  };
-}
+var fortran_1;
+var hasRequiredFortran;
 
-var fsharp_1 = fsharp;
-fsharp.displayName = 'fsharp';
-fsharp.aliases = [];
-function fsharp(Prism) {
-  Prism.languages.fsharp = Prism.languages.extend('clike', {
-    comment: [
-      {
-        pattern: /(^|[^\\])\(\*(?!\))[\s\S]*?\*\)/,
-        lookbehind: true,
-        greedy: true
-      },
-      {
-        pattern: /(^|[^\\:])\/\/.*/,
-        lookbehind: true,
-        greedy: true
-      }
-    ],
-    string: {
-      pattern: /(?:"""[\s\S]*?"""|@"(?:""|[^"])*"|"(?:\\[\s\S]|[^\\"])*")B?/,
-      greedy: true
-    },
-    'class-name': {
-      pattern:
-        /(\b(?:exception|inherit|interface|new|of|type)\s+|\w\s*:\s*|\s:\??>\s*)[.\w]+\b(?:\s*(?:->|\*)\s*[.\w]+\b)*(?!\s*[:.])/,
-      lookbehind: true,
-      inside: {
-        operator: /->|\*/,
-        punctuation: /\./
-      }
-    },
-    keyword:
-      /\b(?:let|return|use|yield)(?:!\B|\b)|\b(?:abstract|and|as|asr|assert|atomic|base|begin|break|checked|class|component|const|constraint|constructor|continue|default|delegate|do|done|downcast|downto|eager|elif|else|end|event|exception|extern|external|false|finally|fixed|for|fun|function|functor|global|if|in|include|inherit|inline|interface|internal|land|lazy|lor|lsl|lsr|lxor|match|member|method|mixin|mod|module|mutable|namespace|new|not|null|object|of|open|or|override|parallel|private|process|protected|public|pure|rec|sealed|select|sig|static|struct|tailcall|then|to|trait|true|try|type|upcast|val|virtual|void|volatile|when|while|with)\b/,
-    number: [
-      /\b0x[\da-fA-F]+(?:LF|lf|un)?\b/,
-      /\b0b[01]+(?:uy|y)?\b/,
-      /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[fm]|e[+-]?\d+)?\b/i,
-      /\b\d+(?:[IlLsy]|UL|u[lsy]?)?\b/
-    ],
-    operator:
-      /([<>~&^])\1\1|([*.:<>&])\2|<-|->|[!=:]=|<?\|{1,3}>?|\??(?:<=|>=|<>|[-+*/%=<>])\??|[!?^&]|~[+~-]|:>|:\?>?/
-  });
-  Prism.languages.insertBefore('fsharp', 'keyword', {
-    preprocessor: {
-      pattern: /(^[\t ]*)#.*/m,
-      lookbehind: true,
-      alias: 'property',
-      inside: {
-        directive: {
-          pattern: /(^#)\b(?:else|endif|if|light|line|nowarn)\b/,
-          lookbehind: true,
-          alias: 'keyword'
-        }
-      }
-    }
-  });
-  Prism.languages.insertBefore('fsharp', 'punctuation', {
-    'computation-expression': {
-      pattern: /\b[_a-z]\w*(?=\s*\{)/i,
-      alias: 'keyword'
-    }
-  });
-  Prism.languages.insertBefore('fsharp', 'string', {
-    annotation: {
-      pattern: /\[<.+?>\]/,
-      greedy: true,
-      inside: {
-        punctuation: /^\[<|>\]$/,
-        'class-name': {
-          pattern: /^\w+$|(^|;\s*)[A-Z]\w*(?=\()/,
-          lookbehind: true
-        },
-        'annotation-content': {
-          pattern: /[\s\S]+/,
-          inside: Prism.languages.fsharp
-        }
-      }
-    },
-    char: {
-      pattern:
-        /'(?:[^\\']|\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8}))'B?/,
-      greedy: true
-    }
-  });
+function requireFortran () {
+	if (hasRequiredFortran) return fortran_1;
+	hasRequiredFortran = 1;
+
+	fortran_1 = fortran;
+	fortran.displayName = 'fortran';
+	fortran.aliases = [];
+	function fortran(Prism) {
+	  Prism.languages.fortran = {
+	    'quoted-number': {
+	      pattern: /[BOZ](['"])[A-F0-9]+\1/i,
+	      alias: 'number'
+	    },
+	    string: {
+	      pattern:
+	        /(?:\b\w+_)?(['"])(?:\1\1|&(?:\r\n?|\n)(?:[ \t]*!.*(?:\r\n?|\n)|(?![ \t]*!))|(?!\1).)*(?:\1|&)/,
+	      inside: {
+	        comment: {
+	          pattern: /(&(?:\r\n?|\n)\s*)!.*/,
+	          lookbehind: true
+	        }
+	      }
+	    },
+	    comment: {
+	      pattern: /!.*/,
+	      greedy: true
+	    },
+	    boolean: /\.(?:FALSE|TRUE)\.(?:_\w+)?/i,
+	    number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[ED][+-]?\d+)?(?:_\w+)?/i,
+	    keyword: [
+	      // Types
+	      /\b(?:CHARACTER|COMPLEX|DOUBLE ?PRECISION|INTEGER|LOGICAL|REAL)\b/i, // END statements
+	      /\b(?:END ?)?(?:BLOCK ?DATA|DO|FILE|FORALL|FUNCTION|IF|INTERFACE|MODULE(?! PROCEDURE)|PROGRAM|SELECT|SUBROUTINE|TYPE|WHERE)\b/i, // Statements
+	      /\b(?:ALLOCATABLE|ALLOCATE|BACKSPACE|CALL|CASE|CLOSE|COMMON|CONTAINS|CONTINUE|CYCLE|DATA|DEALLOCATE|DIMENSION|DO|END|EQUIVALENCE|EXIT|EXTERNAL|FORMAT|GO ?TO|IMPLICIT(?: NONE)?|INQUIRE|INTENT|INTRINSIC|MODULE PROCEDURE|NAMELIST|NULLIFY|OPEN|OPTIONAL|PARAMETER|POINTER|PRINT|PRIVATE|PUBLIC|READ|RETURN|REWIND|SAVE|SELECT|STOP|TARGET|WHILE|WRITE)\b/i, // Others
+	      /\b(?:ASSIGNMENT|DEFAULT|ELEMENTAL|ELSE|ELSEIF|ELSEWHERE|ENTRY|IN|INCLUDE|INOUT|KIND|NULL|ONLY|OPERATOR|OUT|PURE|RECURSIVE|RESULT|SEQUENCE|STAT|THEN|USE)\b/i
+	    ],
+	    operator: [
+	      /\*\*|\/\/|=>|[=\/]=|[<>]=?|::|[+\-*=%]|\.[A-Z]+\./i,
+	      {
+	        // Use lookbehind to prevent confusion with (/ /)
+	        pattern: /(^|(?!\().)\/(?!\))/,
+	        lookbehind: true
+	      }
+	    ],
+	    punctuation: /\(\/|\/\)|[(),;:&]/
+	  };
+	}
+	return fortran_1;
+}
+
+var fsharp_1;
+var hasRequiredFsharp;
+
+function requireFsharp () {
+	if (hasRequiredFsharp) return fsharp_1;
+	hasRequiredFsharp = 1;
+
+	fsharp_1 = fsharp;
+	fsharp.displayName = 'fsharp';
+	fsharp.aliases = [];
+	function fsharp(Prism) {
+	  Prism.languages.fsharp = Prism.languages.extend('clike', {
+	    comment: [
+	      {
+	        pattern: /(^|[^\\])\(\*(?!\))[\s\S]*?\*\)/,
+	        lookbehind: true,
+	        greedy: true
+	      },
+	      {
+	        pattern: /(^|[^\\:])\/\/.*/,
+	        lookbehind: true,
+	        greedy: true
+	      }
+	    ],
+	    string: {
+	      pattern: /(?:"""[\s\S]*?"""|@"(?:""|[^"])*"|"(?:\\[\s\S]|[^\\"])*")B?/,
+	      greedy: true
+	    },
+	    'class-name': {
+	      pattern:
+	        /(\b(?:exception|inherit|interface|new|of|type)\s+|\w\s*:\s*|\s:\??>\s*)[.\w]+\b(?:\s*(?:->|\*)\s*[.\w]+\b)*(?!\s*[:.])/,
+	      lookbehind: true,
+	      inside: {
+	        operator: /->|\*/,
+	        punctuation: /\./
+	      }
+	    },
+	    keyword:
+	      /\b(?:let|return|use|yield)(?:!\B|\b)|\b(?:abstract|and|as|asr|assert|atomic|base|begin|break|checked|class|component|const|constraint|constructor|continue|default|delegate|do|done|downcast|downto|eager|elif|else|end|event|exception|extern|external|false|finally|fixed|for|fun|function|functor|global|if|in|include|inherit|inline|interface|internal|land|lazy|lor|lsl|lsr|lxor|match|member|method|mixin|mod|module|mutable|namespace|new|not|null|object|of|open|or|override|parallel|private|process|protected|public|pure|rec|sealed|select|sig|static|struct|tailcall|then|to|trait|true|try|type|upcast|val|virtual|void|volatile|when|while|with)\b/,
+	    number: [
+	      /\b0x[\da-fA-F]+(?:LF|lf|un)?\b/,
+	      /\b0b[01]+(?:uy|y)?\b/,
+	      /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[fm]|e[+-]?\d+)?\b/i,
+	      /\b\d+(?:[IlLsy]|UL|u[lsy]?)?\b/
+	    ],
+	    operator:
+	      /([<>~&^])\1\1|([*.:<>&])\2|<-|->|[!=:]=|<?\|{1,3}>?|\??(?:<=|>=|<>|[-+*/%=<>])\??|[!?^&]|~[+~-]|:>|:\?>?/
+	  });
+	  Prism.languages.insertBefore('fsharp', 'keyword', {
+	    preprocessor: {
+	      pattern: /(^[\t ]*)#.*/m,
+	      lookbehind: true,
+	      alias: 'property',
+	      inside: {
+	        directive: {
+	          pattern: /(^#)\b(?:else|endif|if|light|line|nowarn)\b/,
+	          lookbehind: true,
+	          alias: 'keyword'
+	        }
+	      }
+	    }
+	  });
+	  Prism.languages.insertBefore('fsharp', 'punctuation', {
+	    'computation-expression': {
+	      pattern: /\b[_a-z]\w*(?=\s*\{)/i,
+	      alias: 'keyword'
+	    }
+	  });
+	  Prism.languages.insertBefore('fsharp', 'string', {
+	    annotation: {
+	      pattern: /\[<.+?>\]/,
+	      greedy: true,
+	      inside: {
+	        punctuation: /^\[<|>\]$/,
+	        'class-name': {
+	          pattern: /^\w+$|(^|;\s*)[A-Z]\w*(?=\()/,
+	          lookbehind: true
+	        },
+	        'annotation-content': {
+	          pattern: /[\s\S]+/,
+	          inside: Prism.languages.fsharp
+	        }
+	      }
+	    },
+	    char: {
+	      pattern:
+	        /'(?:[^\\']|\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8}))'B?/,
+	      greedy: true
+	    }
+	  });
+	}
+	return fsharp_1;
 }
 
 var ftl_1;
@@ -11807,98 +11948,125 @@ function requireGap () {
 	return gap_1;
 }
 
-var gcode_1 = gcode;
-gcode.displayName = 'gcode';
-gcode.aliases = [];
-function gcode(Prism) {
-  Prism.languages.gcode = {
-    comment: /;.*|\B\(.*?\)\B/,
-    string: {
-      pattern: /"(?:""|[^"])*"/,
-      greedy: true
-    },
-    keyword: /\b[GM]\d+(?:\.\d+)?\b/,
-    property: /\b[A-Z]/,
-    checksum: {
-      pattern: /(\*)\d+/,
-      lookbehind: true,
-      alias: 'number'
-    },
-    // T0:0:0
-    punctuation: /[:*]/
-  };
+var gcode_1;
+var hasRequiredGcode;
+
+function requireGcode () {
+	if (hasRequiredGcode) return gcode_1;
+	hasRequiredGcode = 1;
+
+	gcode_1 = gcode;
+	gcode.displayName = 'gcode';
+	gcode.aliases = [];
+	function gcode(Prism) {
+	  Prism.languages.gcode = {
+	    comment: /;.*|\B\(.*?\)\B/,
+	    string: {
+	      pattern: /"(?:""|[^"])*"/,
+	      greedy: true
+	    },
+	    keyword: /\b[GM]\d+(?:\.\d+)?\b/,
+	    property: /\b[A-Z]/,
+	    checksum: {
+	      pattern: /(\*)\d+/,
+	      lookbehind: true,
+	      alias: 'number'
+	    },
+	    // T0:0:0
+	    punctuation: /[:*]/
+	  };
+	}
+	return gcode_1;
 }
 
-var gdscript_1 = gdscript;
-gdscript.displayName = 'gdscript';
-gdscript.aliases = [];
-function gdscript(Prism) {
-  Prism.languages.gdscript = {
-    comment: /#.*/,
-    string: {
-      pattern:
-        /@?(?:("|')(?:(?!\1)[^\n\\]|\\[\s\S])*\1(?!"|')|"""(?:[^\\]|\\[\s\S])*?""")/,
-      greedy: true
-    },
-    'class-name': {
-      // class_name Foo, extends Bar, class InnerClass
-      // export(int) var baz, export(int, 0) var i
-      // as Node
-      // const FOO: int = 9, var bar: bool = true
-      // func add(reference: Item, amount: int) -> Item:
-      pattern:
-        /(^(?:class|class_name|extends)[ \t]+|^export\([ \t]*|\bas[ \t]+|(?:\b(?:const|var)[ \t]|[,(])[ \t]*\w+[ \t]*:[ \t]*|->[ \t]*)[a-zA-Z_]\w*/m,
-      lookbehind: true
-    },
-    keyword:
-      /\b(?:and|as|assert|break|breakpoint|class|class_name|const|continue|elif|else|enum|export|extends|for|func|if|in|is|master|mastersync|match|not|null|onready|or|pass|preload|puppet|puppetsync|remote|remotesync|return|self|setget|signal|static|tool|var|while|yield)\b/,
-    function: /\b[a-z_]\w*(?=[ \t]*\()/i,
-    variable: /\$\w+/,
-    number: [
-      /\b0b[01_]+\b|\b0x[\da-fA-F_]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.[\d_]+)(?:e[+-]?[\d_]+)?\b/,
-      /\b(?:INF|NAN|PI|TAU)\b/
-    ],
-    constant: /\b[A-Z][A-Z_\d]*\b/,
-    boolean: /\b(?:false|true)\b/,
-    operator: /->|:=|&&|\|\||<<|>>|[-+*/%&|!<>=]=?|[~^]/,
-    punctuation: /[.:,;()[\]{}]/
-  };
+var gdscript_1;
+var hasRequiredGdscript;
+
+function requireGdscript () {
+	if (hasRequiredGdscript) return gdscript_1;
+	hasRequiredGdscript = 1;
+
+	gdscript_1 = gdscript;
+	gdscript.displayName = 'gdscript';
+	gdscript.aliases = [];
+	function gdscript(Prism) {
+	  Prism.languages.gdscript = {
+	    comment: /#.*/,
+	    string: {
+	      pattern:
+	        /@?(?:("|')(?:(?!\1)[^\n\\]|\\[\s\S])*\1(?!"|')|"""(?:[^\\]|\\[\s\S])*?""")/,
+	      greedy: true
+	    },
+	    'class-name': {
+	      // class_name Foo, extends Bar, class InnerClass
+	      // export(int) var baz, export(int, 0) var i
+	      // as Node
+	      // const FOO: int = 9, var bar: bool = true
+	      // func add(reference: Item, amount: int) -> Item:
+	      pattern:
+	        /(^(?:class|class_name|extends)[ \t]+|^export\([ \t]*|\bas[ \t]+|(?:\b(?:const|var)[ \t]|[,(])[ \t]*\w+[ \t]*:[ \t]*|->[ \t]*)[a-zA-Z_]\w*/m,
+	      lookbehind: true
+	    },
+	    keyword:
+	      /\b(?:and|as|assert|break|breakpoint|class|class_name|const|continue|elif|else|enum|export|extends|for|func|if|in|is|master|mastersync|match|not|null|onready|or|pass|preload|puppet|puppetsync|remote|remotesync|return|self|setget|signal|static|tool|var|while|yield)\b/,
+	    function: /\b[a-z_]\w*(?=[ \t]*\()/i,
+	    variable: /\$\w+/,
+	    number: [
+	      /\b0b[01_]+\b|\b0x[\da-fA-F_]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.[\d_]+)(?:e[+-]?[\d_]+)?\b/,
+	      /\b(?:INF|NAN|PI|TAU)\b/
+	    ],
+	    constant: /\b[A-Z][A-Z_\d]*\b/,
+	    boolean: /\b(?:false|true)\b/,
+	    operator: /->|:=|&&|\|\||<<|>>|[-+*/%&|!<>=]=?|[~^]/,
+	    punctuation: /[.:,;()[\]{}]/
+	  };
+	}
+	return gdscript_1;
 }
 
-var gedcom_1 = gedcom;
-gedcom.displayName = 'gedcom';
-gedcom.aliases = [];
-function gedcom(Prism) {
-  Prism.languages.gedcom = {
-    'line-value': {
-      // Preceded by level, optional pointer, and tag
-      pattern:
-        /(^[\t ]*\d+ +(?:@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@ +)?\w+ ).+/m,
-      lookbehind: true,
-      inside: {
-        pointer: {
-          pattern: /^@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@$/,
-          alias: 'variable'
-        }
-      }
-    },
-    tag: {
-      // Preceded by level and optional pointer
-      pattern:
-        /(^[\t ]*\d+ +(?:@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@ +)?)\w+/m,
-      lookbehind: true,
-      alias: 'string'
-    },
-    level: {
-      pattern: /(^[\t ]*)\d+/m,
-      lookbehind: true,
-      alias: 'number'
-    },
-    pointer: {
-      pattern: /@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@/,
-      alias: 'variable'
-    }
-  };
+var gedcom_1;
+var hasRequiredGedcom;
+
+function requireGedcom () {
+	if (hasRequiredGedcom) return gedcom_1;
+	hasRequiredGedcom = 1;
+
+	gedcom_1 = gedcom;
+	gedcom.displayName = 'gedcom';
+	gedcom.aliases = [];
+	function gedcom(Prism) {
+	  Prism.languages.gedcom = {
+	    'line-value': {
+	      // Preceded by level, optional pointer, and tag
+	      pattern:
+	        /(^[\t ]*\d+ +(?:@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@ +)?\w+ ).+/m,
+	      lookbehind: true,
+	      inside: {
+	        pointer: {
+	          pattern: /^@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@$/,
+	          alias: 'variable'
+	        }
+	      }
+	    },
+	    tag: {
+	      // Preceded by level and optional pointer
+	      pattern:
+	        /(^[\t ]*\d+ +(?:@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@ +)?)\w+/m,
+	      lookbehind: true,
+	      alias: 'string'
+	    },
+	    level: {
+	      pattern: /(^[\t ]*)\d+/m,
+	      lookbehind: true,
+	      alias: 'number'
+	    },
+	    pointer: {
+	      pattern: /@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@/,
+	      alias: 'variable'
+	    }
+	  };
+	}
+	return gedcom_1;
 }
 
 var gherkin_1;
@@ -12127,89 +12295,107 @@ function requireGml () {
 	return gml_1;
 }
 
-var gn_1 = gn;
-gn.displayName = 'gn';
-gn.aliases = ['gni'];
-function gn(Prism) {
-  // https://gn.googlesource.com/gn/+/refs/heads/main/docs/reference.md#grammar
-  Prism.languages.gn = {
-    comment: {
-      pattern: /#.*/,
-      greedy: true
-    },
-    'string-literal': {
-      pattern: /(^|[^\\"])"(?:[^\r\n"\\]|\\.)*"/,
-      lookbehind: true,
-      greedy: true,
-      inside: {
-        interpolation: {
-          pattern:
-            /((?:^|[^\\])(?:\\{2})*)\$(?:\{[\s\S]*?\}|[a-zA-Z_]\w*|0x[a-fA-F0-9]{2})/,
-          lookbehind: true,
-          inside: {
-            number: /^\$0x[\s\S]{2}$/,
-            variable: /^\$\w+$/,
-            'interpolation-punctuation': {
-              pattern: /^\$\{|\}$/,
-              alias: 'punctuation'
-            },
-            expression: {
-              pattern: /[\s\S]+/,
-              inside: null // see below
-            }
-          }
-        },
-        string: /[\s\S]+/
-      }
-    },
-    keyword: /\b(?:else|if)\b/,
-    boolean: /\b(?:false|true)\b/,
-    'builtin-function': {
-      // a few functions get special highlighting to improve readability
-      pattern:
-        /\b(?:assert|defined|foreach|import|pool|print|template|tool|toolchain)(?=\s*\()/i,
-      alias: 'keyword'
-    },
-    function: /\b[a-z_]\w*(?=\s*\()/i,
-    constant:
-      /\b(?:current_cpu|current_os|current_toolchain|default_toolchain|host_cpu|host_os|root_build_dir|root_gen_dir|root_out_dir|target_cpu|target_gen_dir|target_os|target_out_dir)\b/,
-    number: /-?\b\d+\b/,
-    operator: /[-+!=<>]=?|&&|\|\|/,
-    punctuation: /[(){}[\],.]/
-  };
-  Prism.languages.gn['string-literal'].inside['interpolation'].inside[
-    'expression'
-  ].inside = Prism.languages.gn;
-  Prism.languages.gni = Prism.languages.gn;
+var gn_1;
+var hasRequiredGn;
+
+function requireGn () {
+	if (hasRequiredGn) return gn_1;
+	hasRequiredGn = 1;
+
+	gn_1 = gn;
+	gn.displayName = 'gn';
+	gn.aliases = ['gni'];
+	function gn(Prism) {
+	  // https://gn.googlesource.com/gn/+/refs/heads/main/docs/reference.md#grammar
+	  Prism.languages.gn = {
+	    comment: {
+	      pattern: /#.*/,
+	      greedy: true
+	    },
+	    'string-literal': {
+	      pattern: /(^|[^\\"])"(?:[^\r\n"\\]|\\.)*"/,
+	      lookbehind: true,
+	      greedy: true,
+	      inside: {
+	        interpolation: {
+	          pattern:
+	            /((?:^|[^\\])(?:\\{2})*)\$(?:\{[\s\S]*?\}|[a-zA-Z_]\w*|0x[a-fA-F0-9]{2})/,
+	          lookbehind: true,
+	          inside: {
+	            number: /^\$0x[\s\S]{2}$/,
+	            variable: /^\$\w+$/,
+	            'interpolation-punctuation': {
+	              pattern: /^\$\{|\}$/,
+	              alias: 'punctuation'
+	            },
+	            expression: {
+	              pattern: /[\s\S]+/,
+	              inside: null // see below
+	            }
+	          }
+	        },
+	        string: /[\s\S]+/
+	      }
+	    },
+	    keyword: /\b(?:else|if)\b/,
+	    boolean: /\b(?:false|true)\b/,
+	    'builtin-function': {
+	      // a few functions get special highlighting to improve readability
+	      pattern:
+	        /\b(?:assert|defined|foreach|import|pool|print|template|tool|toolchain)(?=\s*\()/i,
+	      alias: 'keyword'
+	    },
+	    function: /\b[a-z_]\w*(?=\s*\()/i,
+	    constant:
+	      /\b(?:current_cpu|current_os|current_toolchain|default_toolchain|host_cpu|host_os|root_build_dir|root_gen_dir|root_out_dir|target_cpu|target_gen_dir|target_os|target_out_dir)\b/,
+	    number: /-?\b\d+\b/,
+	    operator: /[-+!=<>]=?|&&|\|\|/,
+	    punctuation: /[(){}[\],.]/
+	  };
+	  Prism.languages.gn['string-literal'].inside['interpolation'].inside[
+	    'expression'
+	  ].inside = Prism.languages.gn;
+	  Prism.languages.gni = Prism.languages.gn;
+	}
+	return gn_1;
 }
 
-var goModule_1 = goModule;
-goModule.displayName = 'goModule';
-goModule.aliases = [];
-function goModule(Prism) {
-  // https://go.dev/ref/mod#go-mod-file-module
-  Prism.languages['go-mod'] = Prism.languages['go-module'] = {
-    comment: {
-      pattern: /\/\/.*/,
-      greedy: true
-    },
-    version: {
-      pattern: /(^|[\s()[\],])v\d+\.\d+\.\d+(?:[+-][-+.\w]*)?(?![^\s()[\],])/,
-      lookbehind: true,
-      alias: 'number'
-    },
-    'go-version': {
-      pattern: /((?:^|\s)go\s+)\d+(?:\.\d+){1,2}/,
-      lookbehind: true,
-      alias: 'number'
-    },
-    keyword: {
-      pattern: /^([ \t]*)(?:exclude|go|module|replace|require|retract)\b/m,
-      lookbehind: true
-    },
-    operator: /=>/,
-    punctuation: /[()[\],]/
-  };
+var goModule_1;
+var hasRequiredGoModule;
+
+function requireGoModule () {
+	if (hasRequiredGoModule) return goModule_1;
+	hasRequiredGoModule = 1;
+
+	goModule_1 = goModule;
+	goModule.displayName = 'goModule';
+	goModule.aliases = [];
+	function goModule(Prism) {
+	  // https://go.dev/ref/mod#go-mod-file-module
+	  Prism.languages['go-mod'] = Prism.languages['go-module'] = {
+	    comment: {
+	      pattern: /\/\/.*/,
+	      greedy: true
+	    },
+	    version: {
+	      pattern: /(^|[\s()[\],])v\d+\.\d+\.\d+(?:[+-][-+.\w]*)?(?![^\s()[\],])/,
+	      lookbehind: true,
+	      alias: 'number'
+	    },
+	    'go-version': {
+	      pattern: /((?:^|\s)go\s+)\d+(?:\.\d+){1,2}/,
+	      lookbehind: true,
+	      alias: 'number'
+	    },
+	    keyword: {
+	      pattern: /^([ \t]*)(?:exclude|go|module|replace|require|retract)\b/m,
+	      lookbehind: true
+	    },
+	    operator: /=>/,
+	    punctuation: /[()[\],]/
+	  };
+	}
+	return goModule_1;
 }
 
 var go_1;
@@ -27773,13 +27959,13 @@ refractor.register(cobol_1);
 refractor.register(coffeescript_1);
 refractor.register(concurnas_1);
 refractor.register(coq_1);
-refractor.register(cpp_1);
+refractor.register(requireCpp());
 refractor.register(crystal_1);
 refractor.register(csharp_1);
 refractor.register(cshtml_1);
 refractor.register(csp_1);
 refractor.register(cssExtras_1);
-refractor.register(csv_1);
+refractor.register(requireCsv());
 refractor.register(cypher_1);
 refractor.register(d_1);
 refractor.register(dart_1);
@@ -27790,34 +27976,34 @@ refractor.register(diff_1);
 refractor.register(django_1);
 refractor.register(dnsZoneFile_1);
 refractor.register(docker_1);
-refractor.register(requireDot());
+refractor.register(dot_1);
 refractor.register(requireEbnf());
-refractor.register(editorconfig_1);
-refractor.register(eiffel_1);
+refractor.register(requireEditorconfig());
+refractor.register(requireEiffel());
 refractor.register(ejs_1);
-refractor.register(elixir_1);
-refractor.register(elm_1);
-refractor.register(erb_1);
-refractor.register(erlang_1);
-refractor.register(etlua_1);
-refractor.register(excelFormula_1);
-refractor.register(factor_1);
-refractor.register(_false);
-refractor.register(firestoreSecurityRules_1);
-refractor.register(flow_1);
-refractor.register(fortran_1);
-refractor.register(fsharp_1);
+refractor.register(requireElixir());
+refractor.register(requireElm());
+refractor.register(requireErb());
+refractor.register(requireErlang());
+refractor.register(requireEtlua());
+refractor.register(requireExcelFormula());
+refractor.register(requireFactor());
+refractor.register(require_false());
+refractor.register(requireFirestoreSecurityRules());
+refractor.register(requireFlow());
+refractor.register(requireFortran());
+refractor.register(requireFsharp());
 refractor.register(requireFtl());
 refractor.register(requireGap());
-refractor.register(gcode_1);
-refractor.register(gdscript_1);
-refractor.register(gedcom_1);
+refractor.register(requireGcode());
+refractor.register(requireGdscript());
+refractor.register(requireGedcom());
 refractor.register(requireGherkin());
 refractor.register(requireGit());
 refractor.register(requireGlsl());
 refractor.register(requireGml());
-refractor.register(gn_1);
-refractor.register(goModule_1);
+refractor.register(requireGn());
+refractor.register(requireGoModule());
 refractor.register(requireGo());
 refractor.register(requireGraphql());
 refractor.register(requireGroovy());
@@ -27872,7 +28058,7 @@ refractor.register(requireLivescript());
 refractor.register(requireLlvm());
 refractor.register(requireLog());
 refractor.register(requireLolcode());
-refractor.register(lua_1);
+refractor.register(requireLua());
 refractor.register(requireMagma());
 refractor.register(requireMakefile());
 refractor.register(requireMarkdown());
@@ -38771,6 +38957,18 @@ function escapeContentForStream(content) {
 }
 
 var renderTimer = null;
+/**
+ * 预处理 MDX 内容，转义可能被误认为 HTML 标签的内容
+ * @param content MDX 内容
+ * @returns 处理后的内容
+ */
+function preprocessMdxContent(content) {
+  // 匹配可能被误认为 HTML 标签的模式，如 <数字、<字母但不是真正的组件标签
+  // 真正的 React 组件标签应该以大写字母开头，如 <Component>
+  // HTML 标签以小写字母开头，如 <div>
+  // 需要排除正常的闭合标签 </Component>
+  return content.replace(/<(?!\/|[A-Z][a-zA-Z]*\b|[a-z][a-zA-Z0-9]*\b)/g, '&lt;');
+}
 // 辅助函数：格式化props
 function formatProps(props) {
   return Object.entries(props).map(function (_a) {
@@ -38790,7 +38988,7 @@ function formatProps(props) {
 }
 function renderMdx(mdxContent, scope, registeredComponents) {
   return __awaiter(this, void 0, void 0, function () {
-    var componentTagRegex, usedComponents, match, vf, XComponent;
+    var componentTagRegex, usedComponents, match, processedContent, vf, XComponent, e_1;
     return __generator(this, function (_a) {
       switch (_a.label) {
         case 0:
@@ -38802,7 +39000,8 @@ function renderMdx(mdxContent, scope, registeredComponents) {
           while ((match = componentTagRegex.exec(mdxContent)) !== null) {
             usedComponents.add(match[1]);
           }
-          return [4 /*yield*/, mdx.compile(mdxContent, {
+          processedContent = preprocessMdxContent(mdxContent);
+          return [4 /*yield*/, mdx.compile(processedContent, {
             outputFormat: "function-body",
             remarkPlugins: [[RemarkMath, {
               strict: true
@@ -38825,7 +39024,8 @@ function renderMdx(mdxContent, scope, registeredComponents) {
             scope: scope
           })];
         case 3:
-          _a.sent();
+          e_1 = _a.sent();
+          console.log(e_1, 'e');
           return [2 /*return*/, new Promise(function (resolve) {
             renderTimer = setTimeout(function () {
               resolve(/*#__PURE__*/React__namespace.createElement('div', {