react-ai-renderer 0.1.6 → 0.1.7

package/dist/index.js

@@ -5753,126 +5753,134 @@ function c(Prism) {
   delete Prism.languages.c['boolean'];
 }
 
-var refractorC$1 = c_1;
-var cpp_1 = cpp;
-cpp.displayName = 'cpp';
-cpp.aliases = [];
-function cpp(Prism) {
-  Prism.register(refractorC$1)
-  ;(function (Prism) {
-    var keyword =
-      /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/;
-    var modName = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(
-      /<keyword>/g,
-      function () {
-        return keyword.source
-      }
-    );
-    Prism.languages.cpp = Prism.languages.extend('c', {
-      'class-name': [
-        {
-          pattern: RegExp(
-            /(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(
-              /<keyword>/g,
-              function () {
-                return keyword.source
-              }
-            )
-          ),
-          lookbehind: true
-        }, // This is intended to capture the class name of method implementations like:
-        //   void foo::bar() const {}
-        // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
-        // it starts with an uppercase letter. This approximation should give decent results.
-        /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, // This will capture the class name before destructors like:
-        //   Foo::~Foo() {}
-        /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, // This also intends to capture the class name of method implementations but here the class has template
-        // parameters, so it can't be a namespace (until C++ adds generic namespaces).
-        /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
-      ],
-      keyword: keyword,
-      number: {
-        pattern:
-          /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
-        greedy: true
-      },
-      operator:
-        />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
-      boolean: /\b(?:false|true)\b/
-    });
-    Prism.languages.insertBefore('cpp', 'string', {
-      module: {
-        // https://en.cppreference.com/w/cpp/language/modules
-        pattern: RegExp(
-          /(\b(?:import|module)\s+)/.source +
-            '(?:' + // header-name
-            /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source +
-            '|' + // module name or partition or both
-            /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(
-              /<mod-name>/g,
-              function () {
-                return modName
-              }
-            ) +
-            ')'
-        ),
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          string: /^[<"][\s\S]+/,
-          operator: /:/,
-          punctuation: /\./
-        }
-      },
-      'raw-string': {
-        pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
-        alias: 'string',
-        greedy: true
-      }
-    });
-    Prism.languages.insertBefore('cpp', 'keyword', {
-      'generic-function': {
-        pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
-        inside: {
-          function: /^\w+/,
-          generic: {
-            pattern: /<[\s\S]+/,
-            alias: 'class-name',
-            inside: Prism.languages.cpp
-          }
-        }
-      }
-    });
-    Prism.languages.insertBefore('cpp', 'operator', {
-      'double-colon': {
-        pattern: /::/,
-        alias: 'punctuation'
-      }
-    });
-    Prism.languages.insertBefore('cpp', 'class-name', {
-      // the base clause is an optional list of parent classes
-      // https://en.cppreference.com/w/cpp/language/class
-      'base-clause': {
-        pattern:
-          /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
-        lookbehind: true,
-        greedy: true,
-        inside: Prism.languages.extend('cpp', {})
-      }
-    });
-    Prism.languages.insertBefore(
-      'inside',
-      'double-colon',
-      {
-        // All untokenized words that are not namespaces should be class names
-        'class-name': /\b[a-z_]\w*\b(?!\s*::)/i
-      },
-      Prism.languages.cpp['base-clause']
-    );
-  })(Prism);
+var cpp_1;
+var hasRequiredCpp;
+
+function requireCpp () {
+	if (hasRequiredCpp) return cpp_1;
+	hasRequiredCpp = 1;
+	var refractorC = c_1;
+	cpp_1 = cpp;
+	cpp.displayName = 'cpp';
+	cpp.aliases = [];
+	function cpp(Prism) {
+	  Prism.register(refractorC)
+	  ;(function (Prism) {
+	    var keyword =
+	      /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/;
+	    var modName = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(
+	      /<keyword>/g,
+	      function () {
+	        return keyword.source
+	      }
+	    );
+	    Prism.languages.cpp = Prism.languages.extend('c', {
+	      'class-name': [
+	        {
+	          pattern: RegExp(
+	            /(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(
+	              /<keyword>/g,
+	              function () {
+	                return keyword.source
+	              }
+	            )
+	          ),
+	          lookbehind: true
+	        }, // This is intended to capture the class name of method implementations like:
+	        //   void foo::bar() const {}
+	        // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
+	        // it starts with an uppercase letter. This approximation should give decent results.
+	        /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, // This will capture the class name before destructors like:
+	        //   Foo::~Foo() {}
+	        /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, // This also intends to capture the class name of method implementations but here the class has template
+	        // parameters, so it can't be a namespace (until C++ adds generic namespaces).
+	        /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
+	      ],
+	      keyword: keyword,
+	      number: {
+	        pattern:
+	          /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
+	        greedy: true
+	      },
+	      operator:
+	        />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
+	      boolean: /\b(?:false|true)\b/
+	    });
+	    Prism.languages.insertBefore('cpp', 'string', {
+	      module: {
+	        // https://en.cppreference.com/w/cpp/language/modules
+	        pattern: RegExp(
+	          /(\b(?:import|module)\s+)/.source +
+	            '(?:' + // header-name
+	            /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source +
+	            '|' + // module name or partition or both
+	            /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(
+	              /<mod-name>/g,
+	              function () {
+	                return modName
+	              }
+	            ) +
+	            ')'
+	        ),
+	        lookbehind: true,
+	        greedy: true,
+	        inside: {
+	          string: /^[<"][\s\S]+/,
+	          operator: /:/,
+	          punctuation: /\./
+	        }
+	      },
+	      'raw-string': {
+	        pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
+	        alias: 'string',
+	        greedy: true
+	      }
+	    });
+	    Prism.languages.insertBefore('cpp', 'keyword', {
+	      'generic-function': {
+	        pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
+	        inside: {
+	          function: /^\w+/,
+	          generic: {
+	            pattern: /<[\s\S]+/,
+	            alias: 'class-name',
+	            inside: Prism.languages.cpp
+	          }
+	        }
+	      }
+	    });
+	    Prism.languages.insertBefore('cpp', 'operator', {
+	      'double-colon': {
+	        pattern: /::/,
+	        alias: 'punctuation'
+	      }
+	    });
+	    Prism.languages.insertBefore('cpp', 'class-name', {
+	      // the base clause is an optional list of parent classes
+	      // https://en.cppreference.com/w/cpp/language/class
+	      'base-clause': {
+	        pattern:
+	          /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
+	        lookbehind: true,
+	        greedy: true,
+	        inside: Prism.languages.extend('cpp', {})
+	      }
+	    });
+	    Prism.languages.insertBefore(
+	      'inside',
+	      'double-colon',
+	      {
+	        // All untokenized words that are not namespaces should be class names
+	        'class-name': /\b[a-z_]\w*\b(?!\s*::)/i
+	      },
+	      Prism.languages.cpp['base-clause']
+	    );
+	  })(Prism);
+	}
+	return cpp_1;
 }
 
-var refractorCpp$1 = cpp_1;
+var refractorCpp$1 = requireCpp();
 var arduino_1 = arduino;
 arduino.displayName = 'arduino';
 arduino.aliases = ['ino'];
@@ -7873,7 +7881,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 = [];
@@ -8993,64 +9001,64 @@ 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;
 
-var cypher_1;
-var hasRequiredCypher;
+function requireCsv () {
+	if (hasRequiredCsv) return csv_1;
+	hasRequiredCsv = 1;
 
-function requireCypher () {
-	if (hasRequiredCypher) return cypher_1;
-	hasRequiredCypher = 1;
-
-	cypher_1 = cypher;
-	cypher.displayName = 'cypher';
-	cypher.aliases = [];
-	function cypher(Prism) {
-	  Prism.languages.cypher = {
-	    // https://neo4j.com/docs/cypher-manual/current/syntax/comments/
-	    comment: /\/\/.*/,
-	    string: {
-	      pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/,
-	      greedy: true
-	    },
-	    'class-name': {
-	      pattern: /(:\s*)(?:\w+|`(?:[^`\\\r\n])*`)(?=\s*[{):])/,
-	      lookbehind: true,
-	      greedy: true
-	    },
-	    relationship: {
-	      pattern:
-	        /(-\[\s*(?:\w+\s*|`(?:[^`\\\r\n])*`\s*)?:\s*|\|\s*:\s*)(?:\w+|`(?:[^`\\\r\n])*`)/,
-	      lookbehind: true,
-	      greedy: true,
-	      alias: 'property'
-	    },
-	    identifier: {
-	      pattern: /`(?:[^`\\\r\n])*`/,
-	      greedy: true
-	    },
-	    variable: /\$\w+/,
-	    // https://neo4j.com/docs/cypher-manual/current/syntax/reserved/
-	    keyword:
-	      /\b(?:ADD|ALL|AND|AS|ASC|ASCENDING|ASSERT|BY|CALL|CASE|COMMIT|CONSTRAINT|CONTAINS|CREATE|CSV|DELETE|DESC|DESCENDING|DETACH|DISTINCT|DO|DROP|ELSE|END|ENDS|EXISTS|FOR|FOREACH|IN|INDEX|IS|JOIN|KEY|LIMIT|LOAD|MANDATORY|MATCH|MERGE|NODE|NOT|OF|ON|OPTIONAL|OR|ORDER(?=\s+BY)|PERIODIC|REMOVE|REQUIRE|RETURN|SCALAR|SCAN|SET|SKIP|START|STARTS|THEN|UNION|UNIQUE|UNWIND|USING|WHEN|WHERE|WITH|XOR|YIELD)\b/i,
-	    function: /\b\w+\b(?=\s*\()/,
-	    boolean: /\b(?:false|null|true)\b/i,
-	    number: /\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
-	    // https://neo4j.com/docs/cypher-manual/current/syntax/operators/
-	    operator: /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/,
-	    punctuation: /[()[\]{},;.]/
+	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 cypher_1;
+	return csv_1;
+}
+
+var cypher_1 = cypher;
+cypher.displayName = 'cypher';
+cypher.aliases = [];
+function cypher(Prism) {
+  Prism.languages.cypher = {
+    // https://neo4j.com/docs/cypher-manual/current/syntax/comments/
+    comment: /\/\/.*/,
+    string: {
+      pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/,
+      greedy: true
+    },
+    'class-name': {
+      pattern: /(:\s*)(?:\w+|`(?:[^`\\\r\n])*`)(?=\s*[{):])/,
+      lookbehind: true,
+      greedy: true
+    },
+    relationship: {
+      pattern:
+        /(-\[\s*(?:\w+\s*|`(?:[^`\\\r\n])*`\s*)?:\s*|\|\s*:\s*)(?:\w+|`(?:[^`\\\r\n])*`)/,
+      lookbehind: true,
+      greedy: true,
+      alias: 'property'
+    },
+    identifier: {
+      pattern: /`(?:[^`\\\r\n])*`/,
+      greedy: true
+    },
+    variable: /\$\w+/,
+    // https://neo4j.com/docs/cypher-manual/current/syntax/reserved/
+    keyword:
+      /\b(?:ADD|ALL|AND|AS|ASC|ASCENDING|ASSERT|BY|CALL|CASE|COMMIT|CONSTRAINT|CONTAINS|CREATE|CSV|DELETE|DESC|DESCENDING|DETACH|DISTINCT|DO|DROP|ELSE|END|ENDS|EXISTS|FOR|FOREACH|IN|INDEX|IS|JOIN|KEY|LIMIT|LOAD|MANDATORY|MATCH|MERGE|NODE|NOT|OF|ON|OPTIONAL|OR|ORDER(?=\s+BY)|PERIODIC|REMOVE|REQUIRE|RETURN|SCALAR|SCAN|SET|SKIP|START|STARTS|THEN|UNION|UNIQUE|UNWIND|USING|WHEN|WHERE|WITH|XOR|YIELD)\b/i,
+    function: /\b\w+\b(?=\s*\()/,
+    boolean: /\b(?:false|null|true)\b/i,
+    number: /\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
+    // https://neo4j.com/docs/cypher-manual/current/syntax/operators/
+    operator: /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/,
+    punctuation: /[()[\]{},;.]/
+  };
 }
 
 var d_1 = d;
@@ -9139,97 +9147,88 @@ function d(Prism) {
   });
 }
 
-var dart_1;
-var hasRequiredDart;
-
-function requireDart () {
-	if (hasRequiredDart) return dart_1;
-	hasRequiredDart = 1;
-
-	dart_1 = dart;
-	dart.displayName = 'dart';
-	dart.aliases = [];
-	function dart(Prism) {
+var dart_1 = dart;
+dart.displayName = 'dart';
+dart.aliases = [];
+function dart(Prism) {
 (function (Prism) {
-	    var keywords = [
-	      /\b(?:async|sync|yield)\*/,
-	      /\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|final|finally|for|get|hide|if|implements|import|in|interface|library|mixin|new|null|on|operator|part|rethrow|return|set|show|static|super|switch|sync|this|throw|try|typedef|var|void|while|with|yield)\b/
-	    ]; // Handles named imports, such as http.Client
-	    var packagePrefix = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/
-	      .source; // based on the dart naming conventions
-	    var className = {
-	      pattern: RegExp(packagePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
-	      lookbehind: true,
-	      inside: {
-	        namespace: {
-	          pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
-	          inside: {
-	            punctuation: /\./
-	          }
-	        }
-	      }
-	    };
-	    Prism.languages.dart = Prism.languages.extend('clike', {
-	      'class-name': [
-	        className,
-	        {
-	          // variables and parameters
-	          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
-	          pattern: RegExp(
-	            packagePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source
-	          ),
-	          lookbehind: true,
-	          inside: className.inside
-	        }
-	      ],
-	      keyword: keywords,
-	      operator:
-	        /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
-	    });
-	    Prism.languages.insertBefore('dart', 'string', {
-	      'string-literal': {
-	        pattern:
-	          /r?(?:("""|''')[\s\S]*?\1|(["'])(?:\\.|(?!\2)[^\\\r\n])*\2(?!\2))/,
-	        greedy: true,
-	        inside: {
-	          interpolation: {
-	            pattern:
-	              /((?:^|[^\\])(?:\\{2})*)\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,
-	            lookbehind: true,
-	            inside: {
-	              punctuation: /^\$\{?|\}$/,
-	              expression: {
-	                pattern: /[\s\S]+/,
-	                inside: Prism.languages.dart
-	              }
-	            }
-	          },
-	          string: /[\s\S]+/
-	        }
-	      },
-	      string: undefined
-	    });
-	    Prism.languages.insertBefore('dart', 'class-name', {
-	      metadata: {
-	        pattern: /@\w+/,
-	        alias: 'function'
-	      }
-	    });
-	    Prism.languages.insertBefore('dart', 'class-name', {
-	      generics: {
-	        pattern:
-	          /<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/,
-	        inside: {
-	          'class-name': className,
-	          keyword: keywords,
-	          punctuation: /[<>(),.:]/,
-	          operator: /[?&|]/
-	        }
-	      }
-	    });
-	  })(Prism);
-	}
-	return dart_1;
+    var keywords = [
+      /\b(?:async|sync|yield)\*/,
+      /\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|final|finally|for|get|hide|if|implements|import|in|interface|library|mixin|new|null|on|operator|part|rethrow|return|set|show|static|super|switch|sync|this|throw|try|typedef|var|void|while|with|yield)\b/
+    ]; // Handles named imports, such as http.Client
+    var packagePrefix = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/
+      .source; // based on the dart naming conventions
+    var className = {
+      pattern: RegExp(packagePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
+      lookbehind: true,
+      inside: {
+        namespace: {
+          pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+          inside: {
+            punctuation: /\./
+          }
+        }
+      }
+    };
+    Prism.languages.dart = Prism.languages.extend('clike', {
+      'class-name': [
+        className,
+        {
+          // variables and parameters
+          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+          pattern: RegExp(
+            packagePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source
+          ),
+          lookbehind: true,
+          inside: className.inside
+        }
+      ],
+      keyword: keywords,
+      operator:
+        /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
+    });
+    Prism.languages.insertBefore('dart', 'string', {
+      'string-literal': {
+        pattern:
+          /r?(?:("""|''')[\s\S]*?\1|(["'])(?:\\.|(?!\2)[^\\\r\n])*\2(?!\2))/,
+        greedy: true,
+        inside: {
+          interpolation: {
+            pattern:
+              /((?:^|[^\\])(?:\\{2})*)\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,
+            lookbehind: true,
+            inside: {
+              punctuation: /^\$\{?|\}$/,
+              expression: {
+                pattern: /[\s\S]+/,
+                inside: Prism.languages.dart
+              }
+            }
+          },
+          string: /[\s\S]+/
+        }
+      },
+      string: undefined
+    });
+    Prism.languages.insertBefore('dart', 'class-name', {
+      metadata: {
+        pattern: /@\w+/,
+        alias: 'function'
+      }
+    });
+    Prism.languages.insertBefore('dart', 'class-name', {
+      generics: {
+        pattern:
+          /<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/,
+        inside: {
+          'class-name': className,
+          keyword: keywords,
+          punctuation: /[<>(),.:]/,
+          operator: /[?&|]/
+        }
+      }
+    });
+  })(Prism);
 }
 
 var dataweave_1 = dataweave;
@@ -9316,80 +9315,89 @@ function dax(Prism) {
   };
 }
 
-var dhall_1 = dhall;
-dhall.displayName = 'dhall';
-dhall.aliases = [];
-function dhall(Prism) {
-  // ABNF grammar:
-  // https://github.com/dhall-lang/dhall-lang/blob/master/standard/dhall.abnf
-  Prism.languages.dhall = {
-    // Multi-line comments can be nested. E.g. {- foo {- bar -} -}
-    // The multi-line pattern is essentially this:
-    //   \{-(?:[^-{]|-(?!\})|\{(?!-)|<SELF>)*-\}
-    comment:
-      /--.*|\{-(?:[^-{]|-(?!\})|\{(?!-)|\{-(?:[^-{]|-(?!\})|\{(?!-))*-\})*-\}/,
-    string: {
-      pattern: /"(?:[^"\\]|\\.)*"|''(?:[^']|'(?!')|'''|''\$\{)*''(?!'|\$)/,
-      greedy: true,
-      inside: {
-        interpolation: {
-          pattern: /\$\{[^{}]*\}/,
-          inside: {
-            expression: {
-              pattern: /(^\$\{)[\s\S]+(?=\}$)/,
-              lookbehind: true,
-              alias: 'language-dhall',
-              inside: null // see blow
-            },
-            punctuation: /\$\{|\}/
-          }
-        }
-      }
-    },
-    label: {
-      pattern: /`[^`]*`/,
-      greedy: true
-    },
-    url: {
-      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L596
-      pattern:
-        /\bhttps?:\/\/[\w.:%!$&'*+;=@~-]+(?:\/[\w.:%!$&'*+;=@~-]*)*(?:\?[/?\w.:%!$&'*+;=@~-]*)?/,
-      greedy: true
-    },
-    env: {
-      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L661
-      pattern: /\benv:(?:(?!\d)\w+|"(?:[^"\\=]|\\.)*")/,
-      greedy: true,
-      inside: {
-        function: /^env/,
-        operator: /^:/,
-        variable: /[\s\S]+/
-      }
-    },
-    hash: {
-      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L725
-      pattern: /\bsha256:[\da-fA-F]{64}\b/,
-      inside: {
-        function: /sha256/,
-        operator: /:/,
-        number: /[\da-fA-F]{64}/
-      }
-    },
-    // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L359
-    keyword:
-      /\b(?:as|assert|else|forall|if|in|let|merge|missing|then|toMap|using|with)\b|\u2200/,
-    builtin: /\b(?:None|Some)\b/,
-    boolean: /\b(?:False|True)\b/,
-    number:
-      /\bNaN\b|-?\bInfinity\b|[+-]?\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/,
-    operator:
-      /\/\\|\/\/\\\\|&&|\|\||===|[!=]=|\/\/|->|\+\+|::|[+*#@=:?<>|\\\u2227\u2a53\u2261\u2afd\u03bb\u2192]/,
-    punctuation: /\.\.|[{}\[\](),./]/,
-    // we'll just assume that every capital word left is a type name
-    'class-name': /\b[A-Z]\w*\b/
-  };
-  Prism.languages.dhall.string.inside.interpolation.inside.expression.inside =
-    Prism.languages.dhall;
+var dhall_1;
+var hasRequiredDhall;
+
+function requireDhall () {
+	if (hasRequiredDhall) return dhall_1;
+	hasRequiredDhall = 1;
+
+	dhall_1 = dhall;
+	dhall.displayName = 'dhall';
+	dhall.aliases = [];
+	function dhall(Prism) {
+	  // ABNF grammar:
+	  // https://github.com/dhall-lang/dhall-lang/blob/master/standard/dhall.abnf
+	  Prism.languages.dhall = {
+	    // Multi-line comments can be nested. E.g. {- foo {- bar -} -}
+	    // The multi-line pattern is essentially this:
+	    //   \{-(?:[^-{]|-(?!\})|\{(?!-)|<SELF>)*-\}
+	    comment:
+	      /--.*|\{-(?:[^-{]|-(?!\})|\{(?!-)|\{-(?:[^-{]|-(?!\})|\{(?!-))*-\})*-\}/,
+	    string: {
+	      pattern: /"(?:[^"\\]|\\.)*"|''(?:[^']|'(?!')|'''|''\$\{)*''(?!'|\$)/,
+	      greedy: true,
+	      inside: {
+	        interpolation: {
+	          pattern: /\$\{[^{}]*\}/,
+	          inside: {
+	            expression: {
+	              pattern: /(^\$\{)[\s\S]+(?=\}$)/,
+	              lookbehind: true,
+	              alias: 'language-dhall',
+	              inside: null // see blow
+	            },
+	            punctuation: /\$\{|\}/
+	          }
+	        }
+	      }
+	    },
+	    label: {
+	      pattern: /`[^`]*`/,
+	      greedy: true
+	    },
+	    url: {
+	      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L596
+	      pattern:
+	        /\bhttps?:\/\/[\w.:%!$&'*+;=@~-]+(?:\/[\w.:%!$&'*+;=@~-]*)*(?:\?[/?\w.:%!$&'*+;=@~-]*)?/,
+	      greedy: true
+	    },
+	    env: {
+	      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L661
+	      pattern: /\benv:(?:(?!\d)\w+|"(?:[^"\\=]|\\.)*")/,
+	      greedy: true,
+	      inside: {
+	        function: /^env/,
+	        operator: /^:/,
+	        variable: /[\s\S]+/
+	      }
+	    },
+	    hash: {
+	      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L725
+	      pattern: /\bsha256:[\da-fA-F]{64}\b/,
+	      inside: {
+	        function: /sha256/,
+	        operator: /:/,
+	        number: /[\da-fA-F]{64}/
+	      }
+	    },
+	    // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L359
+	    keyword:
+	      /\b(?:as|assert|else|forall|if|in|let|merge|missing|then|toMap|using|with)\b|\u2200/,
+	    builtin: /\b(?:None|Some)\b/,
+	    boolean: /\b(?:False|True)\b/,
+	    number:
+	      /\bNaN\b|-?\bInfinity\b|[+-]?\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/,
+	    operator:
+	      /\/\\|\/\/\\\\|&&|\|\||===|[!=]=|\/\/|->|\+\+|::|[+*#@=:?<>|\\\u2227\u2a53\u2261\u2afd\u03bb\u2192]/,
+	    punctuation: /\.\.|[{}\[\](),./]/,
+	    // we'll just assume that every capital word left is a type name
+	    'class-name': /\b[A-Z]\w*\b/
+	  };
+	  Prism.languages.dhall.string.inside.interpolation.inside.expression.inside =
+	    Prism.languages.dhall;
+	}
+	return dhall_1;
 }
 
 var diff_1 = diff;
@@ -9582,73 +9590,65 @@ function requireMarkupTemplating () {
 	return markupTemplating_1;
 }
 
-var django_1;
-var hasRequiredDjango;
-
-function requireDjango () {
-	if (hasRequiredDjango) return django_1;
-	hasRequiredDjango = 1;
-	var refractorMarkupTemplating = requireMarkupTemplating();
-	django_1 = django;
-	django.displayName = 'django';
-	django.aliases = ['jinja2'];
-	function django(Prism) {
-	  Prism.register(refractorMarkupTemplating)
-	  // Django/Jinja2 syntax definition for Prism.js <http://prismjs.com> syntax highlighter.
-	  // Mostly it works OK but can paint code incorrectly on complex html/template tag combinations.
-	  ;(function (Prism) {
-	    Prism.languages.django = {
-	      comment: /^\{#[\s\S]*?#\}$/,
-	      tag: {
-	        pattern: /(^\{%[+-]?\s*)\w+/,
-	        lookbehind: true,
-	        alias: 'keyword'
-	      },
-	      delimiter: {
-	        pattern: /^\{[{%][+-]?|[+-]?[}%]\}$/,
-	        alias: 'punctuation'
-	      },
-	      string: {
-	        pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
-	        greedy: true
-	      },
-	      filter: {
-	        pattern: /(\|)\w+/,
-	        lookbehind: true,
-	        alias: 'function'
-	      },
-	      test: {
-	        pattern: /(\bis\s+(?:not\s+)?)(?!not\b)\w+/,
-	        lookbehind: true,
-	        alias: 'function'
-	      },
-	      function: /\b[a-z_]\w+(?=\s*\()/i,
-	      keyword:
-	        /\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\b/,
-	      operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
-	      number: /\b\d+(?:\.\d+)?\b/,
-	      boolean: /[Ff]alse|[Nn]one|[Tt]rue/,
-	      variable: /\b\w+\b/,
-	      punctuation: /[{}[\](),.:;]/
-	    };
-	    var pattern = /\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\}|\{#[\s\S]*?#\}/g;
-	    var markupTemplating = Prism.languages['markup-templating'];
-	    Prism.hooks.add('before-tokenize', function (env) {
-	      markupTemplating.buildPlaceholders(env, 'django', pattern);
-	    });
-	    Prism.hooks.add('after-tokenize', function (env) {
-	      markupTemplating.tokenizePlaceholders(env, 'django');
-	    }); // Add an Jinja2 alias
-	    Prism.languages.jinja2 = Prism.languages.django;
-	    Prism.hooks.add('before-tokenize', function (env) {
-	      markupTemplating.buildPlaceholders(env, 'jinja2', pattern);
-	    });
-	    Prism.hooks.add('after-tokenize', function (env) {
-	      markupTemplating.tokenizePlaceholders(env, 'jinja2');
-	    });
-	  })(Prism);
-	}
-	return django_1;
+var refractorMarkupTemplating$1 = requireMarkupTemplating();
+var django_1 = django;
+django.displayName = 'django';
+django.aliases = ['jinja2'];
+function django(Prism) {
+  Prism.register(refractorMarkupTemplating$1)
+  // Django/Jinja2 syntax definition for Prism.js <http://prismjs.com> syntax highlighter.
+  // Mostly it works OK but can paint code incorrectly on complex html/template tag combinations.
+  ;(function (Prism) {
+    Prism.languages.django = {
+      comment: /^\{#[\s\S]*?#\}$/,
+      tag: {
+        pattern: /(^\{%[+-]?\s*)\w+/,
+        lookbehind: true,
+        alias: 'keyword'
+      },
+      delimiter: {
+        pattern: /^\{[{%][+-]?|[+-]?[}%]\}$/,
+        alias: 'punctuation'
+      },
+      string: {
+        pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        greedy: true
+      },
+      filter: {
+        pattern: /(\|)\w+/,
+        lookbehind: true,
+        alias: 'function'
+      },
+      test: {
+        pattern: /(\bis\s+(?:not\s+)?)(?!not\b)\w+/,
+        lookbehind: true,
+        alias: 'function'
+      },
+      function: /\b[a-z_]\w+(?=\s*\()/i,
+      keyword:
+        /\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\b/,
+      operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+      number: /\b\d+(?:\.\d+)?\b/,
+      boolean: /[Ff]alse|[Nn]one|[Tt]rue/,
+      variable: /\b\w+\b/,
+      punctuation: /[{}[\](),.:;]/
+    };
+    var pattern = /\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\}|\{#[\s\S]*?#\}/g;
+    var markupTemplating = Prism.languages['markup-templating'];
+    Prism.hooks.add('before-tokenize', function (env) {
+      markupTemplating.buildPlaceholders(env, 'django', pattern);
+    });
+    Prism.hooks.add('after-tokenize', function (env) {
+      markupTemplating.tokenizePlaceholders(env, 'django');
+    }); // Add an Jinja2 alias
+    Prism.languages.jinja2 = Prism.languages.django;
+    Prism.hooks.add('before-tokenize', function (env) {
+      markupTemplating.buildPlaceholders(env, 'jinja2', pattern);
+    });
+    Prism.hooks.add('after-tokenize', function (env) {
+      markupTemplating.tokenizePlaceholders(env, 'jinja2');
+    });
+  })(Prism);
 }
 
 var dnsZoneFile_1 = dnsZoneFile;
@@ -9930,37 +9930,46 @@ function requireEbnf () {
 	return ebnf_1;
 }
 
-var editorconfig_1 = editorconfig;
-editorconfig.displayName = 'editorconfig';
-editorconfig.aliases = [];
-function editorconfig(Prism) {
-  Prism.languages.editorconfig = {
-    // https://editorconfig-specification.readthedocs.io
-    comment: /[;#].*/,
-    section: {
-      pattern: /(^[ \t]*)\[.+\]/m,
-      lookbehind: true,
-      alias: 'selector',
-      inside: {
-        regex: /\\\\[\[\]{},!?.*]/,
-        // Escape special characters with '\\'
-        operator: /[!?]|\.\.|\*{1,2}/,
-        punctuation: /[\[\]{},]/
-      }
-    },
-    key: {
-      pattern: /(^[ \t]*)[^\s=]+(?=[ \t]*=)/m,
-      lookbehind: true,
-      alias: 'attr-name'
-    },
-    value: {
-      pattern: /=.*/,
-      alias: 'attr-value',
-      inside: {
-        punctuation: /^=/
-      }
-    }
-  };
+var editorconfig_1;
+var hasRequiredEditorconfig;
+
+function requireEditorconfig () {
+	if (hasRequiredEditorconfig) return editorconfig_1;
+	hasRequiredEditorconfig = 1;
+
+	editorconfig_1 = editorconfig;
+	editorconfig.displayName = 'editorconfig';
+	editorconfig.aliases = [];
+	function editorconfig(Prism) {
+	  Prism.languages.editorconfig = {
+	    // https://editorconfig-specification.readthedocs.io
+	    comment: /[;#].*/,
+	    section: {
+	      pattern: /(^[ \t]*)\[.+\]/m,
+	      lookbehind: true,
+	      alias: 'selector',
+	      inside: {
+	        regex: /\\\\[\[\]{},!?.*]/,
+	        // Escape special characters with '\\'
+	        operator: /[!?]|\.\.|\*{1,2}/,
+	        punctuation: /[\[\]{},]/
+	      }
+	    },
+	    key: {
+	      pattern: /(^[ \t]*)[^\s=]+(?=[ \t]*=)/m,
+	      lookbehind: true,
+	      alias: 'attr-name'
+	    },
+	    value: {
+	      pattern: /=.*/,
+	      alias: 'attr-value',
+	      inside: {
+	        punctuation: /^=/
+	      }
+	    }
+	  };
+	}
+	return editorconfig_1;
 }
 
 var eiffel_1;
@@ -10010,45 +10019,37 @@ function requireEiffel () {
 	return eiffel_1;
 }
 
-var ejs_1;
-var hasRequiredEjs;
-
-function requireEjs () {
-	if (hasRequiredEjs) return ejs_1;
-	hasRequiredEjs = 1;
-	var refractorMarkupTemplating = requireMarkupTemplating();
-	ejs_1 = ejs;
-	ejs.displayName = 'ejs';
-	ejs.aliases = ['eta'];
-	function ejs(Prism) {
-	  Prism.register(refractorMarkupTemplating)
-	  ;(function (Prism) {
-	    Prism.languages.ejs = {
-	      delimiter: {
-	        pattern: /^<%[-_=]?|[-_]?%>$/,
-	        alias: 'punctuation'
-	      },
-	      comment: /^#[\s\S]*/,
-	      'language-javascript': {
-	        pattern: /[\s\S]+/,
-	        inside: Prism.languages.javascript
-	      }
-	    };
-	    Prism.hooks.add('before-tokenize', function (env) {
-	      var ejsPattern = /<%(?!%)[\s\S]+?%>/g;
-	      Prism.languages['markup-templating'].buildPlaceholders(
-	        env,
-	        'ejs',
-	        ejsPattern
-	      );
-	    });
-	    Prism.hooks.add('after-tokenize', function (env) {
-	      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'ejs');
-	    });
-	    Prism.languages.eta = Prism.languages.ejs;
-	  })(Prism);
-	}
-	return ejs_1;
+var refractorMarkupTemplating = requireMarkupTemplating();
+var ejs_1 = ejs;
+ejs.displayName = 'ejs';
+ejs.aliases = ['eta'];
+function ejs(Prism) {
+  Prism.register(refractorMarkupTemplating)
+  ;(function (Prism) {
+    Prism.languages.ejs = {
+      delimiter: {
+        pattern: /^<%[-_=]?|[-_]?%>$/,
+        alias: 'punctuation'
+      },
+      comment: /^#[\s\S]*/,
+      'language-javascript': {
+        pattern: /[\s\S]+/,
+        inside: Prism.languages.javascript
+      }
+    };
+    Prism.hooks.add('before-tokenize', function (env) {
+      var ejsPattern = /<%(?!%)[\s\S]+?%>/g;
+      Prism.languages['markup-templating'].buildPlaceholders(
+        env,
+        'ejs',
+        ejsPattern
+      );
+    });
+    Prism.hooks.add('after-tokenize', function (env) {
+      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'ejs');
+    });
+    Prism.languages.eta = Prism.languages.ejs;
+  })(Prism);
 }
 
 var elixir_1;
@@ -27936,28 +27937,28 @@ 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(requireCypher());
+refractor.register(requireCsv());
+refractor.register(cypher_1);
 refractor.register(d_1);
-refractor.register(requireDart());
+refractor.register(dart_1);
 refractor.register(dataweave_1);
 refractor.register(dax_1);
-refractor.register(dhall_1);
+refractor.register(requireDhall());
 refractor.register(diff_1);
-refractor.register(requireDjango());
+refractor.register(django_1);
 refractor.register(dnsZoneFile_1);
 refractor.register(docker_1);
 refractor.register(dot_1);
 refractor.register(requireEbnf());
-refractor.register(editorconfig_1);
+refractor.register(requireEditorconfig());
 refractor.register(requireEiffel());
-refractor.register(requireEjs());
+refractor.register(ejs_1);
 refractor.register(requireElixir());
 refractor.register(requireElm());
 refractor.register(requireErb());
@@ -38934,6 +38935,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) {
@@ -38953,7 +38966,7 @@ function formatProps(props) {
 }
 function renderMdx(mdxContent, scope, registeredComponents) {
   return __awaiter(this, void 0, void 0, function () {
-    var componentTagRegex, usedComponents, match, vf, XComponent;
+    var componentTagRegex, usedComponents, match, processedContent, vf, XComponent, e_1;
     return __generator(this, function (_a) {
       switch (_a.label) {
         case 0:
@@ -38965,7 +38978,8 @@ function renderMdx(mdxContent, scope, registeredComponents) {
           while ((match = componentTagRegex.exec(mdxContent)) !== null) {
             usedComponents.add(match[1]);
           }
-          return [4 /*yield*/, compile(mdxContent, {
+          processedContent = preprocessMdxContent(mdxContent);
+          return [4 /*yield*/, compile(processedContent, {
             outputFormat: "function-body",
             remarkPlugins: [[RemarkMath, {
               strict: true
@@ -38988,7 +39002,8 @@ function renderMdx(mdxContent, scope, registeredComponents) {
             scope: scope
           })];
         case 3:
-          _a.sent();
+          e_1 = _a.sent();
+          console.log(e_1, 'e');
           return [2 /*return*/, new Promise(function (resolve) {
             renderTimer = setTimeout(function () {
               resolve(/*#__PURE__*/React.createElement('div', {