@aithe/aithe-ui 26.2.3 → 26.3.2

package/dist/core/highlight/lang-cmake.js

@@ -0,0 +1,27 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(#.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(add_compile_definitions|add_compile_options|add_custom_command|add_custom_target|add_definitions|add_dependencies|add_executable|add_library|add_subdirectory|add_test|aux_source_directory|break|build_command|cmake_minimum_required|cmake_policy|configure_file|continue|create_test_sourcelist|define_property|else|elseif|enable_language|enable_testing|endforeach|endfunction|endif|endmacro|endwhile|execute_process|export|file|find_file|find_library|find_package|find_path|find_program|fltk_wrap_ui|foreach|function|get_cmake_property|get_directory_property|get_filename_component|get_property|get_source_file_property|get_target_property|get_test_property|if|include|include_directories|include_external_msproject|include_regular_expression|install|link_directories|list|load_cache|load_command|macro|mark_as_advanced|math|message|option|output_required_files|project|qt_wrap_cpp|qt_wrap_ui|remove_definitions|return|separate_arguments|set|set_directory_properties|set_property|set_source_files_properties|set_target_properties|set_tests_properties|site_name|source_group|string|target_compile_definitions|target_compile_features|target_compile_options|target_include_directories|target_link_directories|target_link_libraries|target_link_options|target_precompile_headers|target_sources|try_compile|try_run|unset|variable_watch|while)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    {
+        pattern: /\b(ON|OFF|YES|NO|TRUE|FALSE|BOOL|INTERFACE|PUBLIC|PRIVATE)\b/g,
+        className: 'hl-boolean',
+        order: 3,
+    },
+    {
+        pattern: /\b(WIN32|UNIX|APPLE|MINGW|MSVC|CYGWIN|BORLAND|WATCOM|MSYS|CMAKE_SOURCE_DIR|CMAKE_BINARY_DIR|CMAKE_CURRENT_SOURCE_DIR|CMAKE_CURRENT_BINARY_DIR|CMAKE_CURRENT_LIST_DIR|CMAKE_CURRENT_LIST_FILE|CMAKE_MODULE_PATH|CMAKE_PREFIX_PATH|CMAKE_INSTALL_PREFIX|PROJECT_SOURCE_DIR|PROJECT_BINARY_DIR|PROJECT_NAME|PROJECT_VERSION|PROJECT_VERSION_MAJOR|PROJECT_VERSION_MINOR|PROJECT_VERSION_PATCH|PROJECT_VERSION_TWEAK)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 6 },
+    { pattern: /(\$\{[^}]+\\})/g, className: 'hl-keyword', order: 7 },
+    { pattern: /([{}[\](),])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'cmake', name: 'CMake', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-cpp.js

@@ -0,0 +1,27 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(alignas|alignof|and|and_eq|asm|auto|bitand|bitor|bool|break|case|catch|char|class|compl|const|constexpr|const_cast|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|false|float|for|friend|goto|if|inline|int|long|mutable|namespace|new|noexcept|not|not_eq|nullptr|operator|or|or_eq|private|protected|public|register|reinterpret_cast|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|true|try|typedef|typeid|typename|union|unsigned|using|virtual|void|volatile|wchar_t|while|xor|xor_eq)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|NULL|nullptr)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(cin|cout|cerr|clog|endl|string|vector|map|set|list|deque|array|shared_ptr|unique_ptr|weak_ptr|make_shared|make_unique)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*[fFlL]?)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 6 },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    {
+        pattern: /#\s*(include|define|ifdef|ifndef|endif|if|else|elif|pragma|undef|error|warning)\b.*/g,
+        className: 'hl-preprocessor',
+        order: 8,
+    },
+    { pattern: /([{}[\](),;])/g, className: 'hl-punctuation', order: 9 },
+];
+const definition = { langId: 'cpp', name: 'C++', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-css.js

@@ -0,0 +1,24 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(@import|@media|@keyframes|@font-face|@supports|@page|@namespace|@charset|@layer|@container|@scope|@starting-style|@property|@counter-style|important|and|or|not|only)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(inherit|initial|unset|revert|none)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(px|em|rem|vh|vw|vmin|vmax|%|pt|pc|cm|mm|in|ch|ex|lh|rlh|svw|svh|lvw|lvh|dvw|dvh|fr|deg|rad|grad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 6 },
+    { pattern: /([.#][\w-]+)/g, className: 'hl-tag', order: 7 },
+    { pattern: /([\w-]+)(?=\s*:)/g, className: 'hl-attr', order: 8 },
+    { pattern: /(url\([^)]+\))/g, className: 'hl-function', order: 9 },
+    { pattern: /([{}[\](),;])/g, className: 'hl-punctuation', order: 10 },
+];
+const definition = { langId: 'css', name: 'CSS', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-dart.js

@@ -0,0 +1,27 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(abstract|as|assert|base|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|false|final|finally|for|function|get|hide|if|implements|import|in|interface|is|late|library|mixin|new|null|on|operator|out|override|package|part|required|rethrow|return|sealed|set|show|static|super|switch|sync|this|throw|true|try|typedef|var|void|while|with|yield)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|null)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(print|println|readLine|printError|write|writeln|stdout|stderr|stdin|Object|bool|int|double|num|String|List|Set|Map|MapEntry|Runes|Symbol|dynamic|Never|Null|void|Future|Stream|StreamController|StreamSubscription|Timer|Duration|DateTime|Stopwatch|RegExp|Uri|UriData|StringBuffer|StringSink|StringBuilder|Comparable|Pattern|Iterable|Iterator|Collection|Queue|LinkedList|HashMap|HashSet|LinkedHashMap|LinkedHashSet|SplayTreeMap|SplayTreeSet|MapView|UnmodifiableListView|Error|Exception|FormatException|IntegerDivisionByZeroException|IOException|ArgumentError|RangeError|IndexError|NoSuchMethodError|UnsupportedError|StateError|ConcurrentModificationError|OutOfMemoryError|StackOverflowError|TypeError)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*[fF]?)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|r"[^"]*"|r'[^']*')/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /(\$\{[\w.]+\\})/g, className: 'hl-keyword', order: 8 },
+    { pattern: /([{}[\](),;:.])/g, className: 'hl-punctuation', order: 9 },
+];
+const definition = { langId: 'dart', name: 'Dart', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-dockerfile.js

@@ -0,0 +1,16 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(#.*$)/gm, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(FROM|MAINTAINER|RUN|CMD|LABEL|EXPOSE|ENV|ADD|COPY|ENTRYPOINT|VOLUME|USER|WORKDIR|ARG|ONBUILD|STOPSIGNAL|HEALTHCHECK|SHELL|AS)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false)\b/g, className: 'hl-boolean', order: 3 },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 6 },
+    { pattern: /(\$\{?[\\w]+\\}?)/g, className: 'hl-keyword', order: 7 },
+    { pattern: /([{}[\](),;|&])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'dockerfile', name: 'Dockerfile', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-fsharp.js

@@ -0,0 +1,23 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    { pattern: /(\(\*[\s\S]*?\*\))/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(abstract|and|as|assert|base|begin|class|default|delegate|do|done|downcast|downto|elif|else|end|exception|extern|false|finally|fixed|for|fun|function|global|if|in|inherit|inline|interface|internal|land|lazy|let|lor|lsl|lsr|lxor|match|member|mod|module|mutable|namespace|new|not|null|object|of|open|or|override|private|public|rec|return|select|sig|static|struct|then|to|true|try|type|upcast|use|val|void|when|while|with|yield)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|null)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(printf|sprintf|fprintf|scanf|sscanf|fscanf|open|close|read|write|input|output|printfn|sprintfn|failwith|failwithf|raise|reraise|invalidArg|invalidOp|nullArg|ignore|fst|snd|id|not|ref|dispose|compare|hash|sizeof|typeof|typedef|nameof|unbox|box|string|int|float|bool|char|byte|decimal|unit|option|list|array|seq|map|set|async|task|choice|result|bigint|nativeint|unativeint|exn|obj|enum|struct|record|discriminated|union|tuple)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*[fFLl]?)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 6 },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /([{}[\](),;|])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'fsharp', name: 'F#', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-go.js

@@ -0,0 +1,22 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go|goto|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|nil|iota)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(append|cap|close|complex|copy|delete|imag|len|make|new|panic|print|println|real|recover|string|int|int8|int16|int32|int64|uint|uint8|uint16|uint32|uint64|float32|float64|complex64|complex128|byte|rune|bool|error|any|comparable)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*`)/g, className: 'hl-string', order: 6 },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /([{}[\](),;:.])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'go', name: 'Go', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-html.js

@@ -0,0 +1,12 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(<\/?)([\w:-]+)/g, className: 'hl-tag', order: 1 },
+    { pattern: /([\w:-]+)(=)/g, className: 'hl-attr', order: 2 },
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 3 },
+    { pattern: /(<!--[\s\S]*?-->)/g, className: 'hl-comment', order: 4 },
+    { pattern: /(<!DOCTYPE[\s\S]*?>)/gi, className: 'hl-doctype', order: 5 },
+    { pattern: /(&\w+;)/g, className: 'hl-entity', order: 6 },
+    { pattern: /(<|\/?>)/g, className: 'hl-tag', order: 7 },
+];
+const definition = { langId: 'html', name: 'HTML', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-java.js

@@ -0,0 +1,22 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|transient|try|void|volatile|while|var|yield|record|sealed|permits|non-sealed)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|null)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(System|out|err|in|print|println|printf|String|Integer|Long|Short|Byte|Character|Double|Float|Boolean|Number|Object|Class|Thread|Array|List|Map|Set|Collection|Arrays|Collections|HashMap|HashSet|ArrayList|LinkedList)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*[dDlLfF]?)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 6 },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /([{}[\](),;<>])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'java', name: 'Java', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-javascript.js

@@ -0,0 +1,26 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(const|let|var|function|return|if|else|for|while|do|switch|case|break|continue|new|typeof|instanceof|in|of|class|extends|import|export|from|default|as|async|await|try|catch|finally|throw|void|yield|static|get|set|public|private|protected|readonly|abstract|enum|implements|interface|package|super|this)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|null|undefined|NaN|Infinity)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(document|window|console|Array|Object|String|Number|Boolean|Function|Symbol|Map|Set|WeakMap|WeakSet|Promise|Date|JSON|Math|RegExp|Error|TypeError|SyntaxError)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /([{}[\](),;])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'javascript', name: 'JavaScript', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-json.js

@@ -0,0 +1,13 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /("(?:[^"\\]|\\.)*")\s*:/g, className: 'hl-key', order: 1 },
+    { pattern: /:\s*("(?:[^"\\]|\\.)*")/g, className: 'hl-string', order: 2 },
+    { pattern: /:\s*(\d+\.?\d*)/g, className: 'hl-number', order: 3 },
+    { pattern: /:\s*(true|false|null)/g, className: 'hl-boolean', order: 4 },
+    { pattern: /("[^"]*")/g, className: 'hl-string', order: 5 },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 6 },
+    { pattern: /\b(true|false|null)\b/g, className: 'hl-boolean', order: 7 },
+    { pattern: /([[\]{}:,])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'json', name: 'JSON', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-jsonline.js

@@ -0,0 +1,13 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /("(?:[^"\\]|\\.)*")\s*:/gm, className: 'hl-key', order: 1 },
+    { pattern: /:\s*("(?:[^"\\]|\\.)*")/g, className: 'hl-string', order: 2 },
+    { pattern: /:\s*(\d+\.?\d*)/g, className: 'hl-number', order: 3 },
+    { pattern: /:\s*(true|false|null)/g, className: 'hl-boolean', order: 4 },
+    { pattern: /("[^"]*")/g, className: 'hl-string', order: 5 },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 6 },
+    { pattern: /\b(true|false|null)\b/g, className: 'hl-boolean', order: 7 },
+    { pattern: /([[]{}:,])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'jsonline', name: 'JSON (Line)', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-jsx.js

@@ -0,0 +1,30 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(const|let|var|function|return|if|else|for|while|do|switch|case|break|continue|new|typeof|instanceof|in|of|class|extends|import|export|from|default|as|async|await|try|catch|finally|throw|void|yield|static|get|set|public|private|protected|readonly|abstract|enum|implements|interface|package|super|this|type|namespace|declare)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|null|undefined|NaN|Infinity)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(React|Component|useState|useEffect|useContext|useReducer|useCallback|useMemo|useRef|useImperativeHandle|useLayoutEffect|useDebugValue|Fragment|createElement|cloneElement|createRef|forwardRef|memo|lazy|Suspense|StrictMode|createContext|useTransition|useDeferredValue|useId|useSyncExternalStore|useInsertionEffect)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /(<\/?)([\w:-]+)/g, className: 'hl-tag', order: 8 },
+    { pattern: /([\w:-]+)(=)/g, className: 'hl-attr', order: 9 },
+    { pattern: /(<\w+)/g, className: 'hl-tag', order: 10 },
+    { pattern: /(\/>|<\/\w+>)/g, className: 'hl-tag', order: 11 },
+    { pattern: /([{}[\](),;])/g, className: 'hl-punctuation', order: 12 },
+];
+const definition = { langId: 'jsx', name: 'JSX', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-kotlin.js

@@ -0,0 +1,27 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|delegate|do|dynamic|else|enum|expect|external|false|field|file|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|it|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|true|try|typealias|typeof|val|var|vararg|when|where|while)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|null)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(Array|Boolean|Byte|Char|Double|Float|Int|IntArray|Long|Short|String|StringBuilder|List|MutableList|ArrayList|Set|MutableSet|HashSet|Map|MutableMap|HashMap|Pair|Triple|Unit|Nothing|Any|Nothing|Throwable|Exception|Error|Runnable|Comparable|Iterable|Sequence|Collection|MutableCollection|Iterable|Iterator)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*[fFL]?)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|"""[\s\S]*?""")/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /(\$[\w{}]+)/g, className: 'hl-keyword', order: 8 },
+    { pattern: /([{}[\](),;:.?])/g, className: 'hl-punctuation', order: 9 },
+];
+const definition = { langId: 'kotlin', name: 'Kotlin', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-latex.js

@@ -0,0 +1,22 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(%.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(\\documentclass|\\usepackage|\\begin|\\end|\\section|\\subsection|\\subsubsection|\\paragraph|\\subparagraph|\\chapter|\\part|\\label|\\ref|\\pageref|\\cite|\\bibitem|\\bibliography|\\bibliographystyle|\\include|\\input|\\includegraphics|\\textwidth|\\textheight|\\linewidth|\\columnwidth|\\textfloatsep|\\floatsep|\\intextsep|\\abovecaptionskip|\\belowcaptionskip|\\parindent|\\parskip|\\baselineskip|\\textwidth|\\textheight|\\newpage|\\clearpage|\\cleardoublepage|\\tableofcontents|\\listoffigures|\\listoftables|\\footnote|\\marginpar|\\emph|\\textbf|\\textit|\\underline|\\texttt|\\textsc|\\textsf|\\textrm|\\textsl|\\textnormal|\\mbox|\\makebox|\\framebox|\\parbox|\\minipage|\\raisebox|\\rule|\\line|\\hfill|\\vfill|\\hspace|\\vspace|\\smallskip|\\medskip|\\bigskip|\\centering|\\raggedright|\\raggedleft|\\setlength|\\addtolength|\\newlength|\\settowidth|\\settoheight|\\settodepth|\\newcommand|\\renewcommand|\\newenvironment|\\renewenvironment|\\newtheorem|\\newfont|\\newcounter|\\setcounter|\\addtocounter|\\value|\\arabic|\\roman|\\Roman|\\alph|\\Alph|\\fnsymbol|\\the|\\today|\\author|\\title|\\date|\\maketitle|\\abstract|\\appendix|\\thanks|\\keywords)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Phi|Psi|Omega|infty|partial|nabla|sum|prod|int|iint|iiint|oint|sqrt|frac|binom|left|right|big|Big|bigg|Bigg|rightarrow|leftarrow|Rightarrow|Leftarrow|Leftrightarrow|leftrightarrow|mapsto|longrightarrow|longleftarrow|Longrightarrow|Longleftarrow|Longleftrightarrow|longleftrightarrow|implies|iff|cdot|cdots|vdots|ddots|ldots|forall|exists|neg|wedge|vee|otimes|oplus|otimes|oplus|subset|supset|subseteq|supseteq|cup|cap|setminus|emptyset|varnothing|in|notin|ni|subset|supset|subseteq|supseteq|cup|cap|setminus|emptyset|varnothing|in|notin|ni|to|gets|mapsto|circ|bullet|star|diamond|triangle|angle|perp|top|bot|propto|sim|simeq|cong|approx|equiv|doteq|prop|models|bowtie|Join|ltimes|rtimes|wr|div|odot|ominus|oslash|amalg|sqcup|sqcap|sqsubset|sqsupset|sqsubseteq|sqsupseteq|smile|frown|vdash|dashv|mid|parallel|backslash|therefore|because)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*")/g, className: 'hl-string', order: 6 },
+    { pattern: /(\$[^$]*\$|\\\[[\s\S]*?\\])/g, className: 'hl-string', order: 7 },
+    { pattern: /([{}[\](),;])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'latex', name: 'LaTeX', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-lua.js

@@ -0,0 +1,26 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(--\[\[[\s\S]*?\]\])/g, className: 'hl-comment', order: 1 },
+    { pattern: /(--.*$)/gm, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|nil)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(print|require|dofile|loadfile|load|pcall|xpcall|error|assert|type|select|pairs|ipairs|next|rawget|rawset|rawequal|rawlen|setmetatable|getmetatable|tostring|tonumber|unpack|string|table|math|io|os|coroutine|debug|utf8|collectgarbage|newproxy|setfenv|getfenv|loadstring|module|package)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\[\[[\s\S]*?]])/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /([{}[\](),;.])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'lua', name: 'Lua', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-makefile.js

@@ -0,0 +1,22 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(#.*$)/gm, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(define|else|endef|endif|export|ifdef|ifndef|ifeq|ifneq|include|override|private|unexport|undefine|vpath|MAKEFLAGS|VPATH|SHELL|MAKE|MAKECMDGOALS|CURDIR|SUFFIXES|.DEFAULT|.PHONY|.PRECIOUS|.SILENT|.IGNORE|.EXPORT_ALL_VARIABLES|.NOTPARALLEL|.ONESHELL|.DELETE_ON_ERROR|.INTERMEDIATE|.SECONDARY|.SECONDEXPANSION|.LOW_RESOLUTION_TIME|.ORDER_ONLY)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(CC|CXX|CFLAGS|CXXFLAGS|LDFLAGS|LDLIBS|AR|ARFLAGS|RM|MAKE|MAKEFLAGS|PREFIX|DESTDIR|INSTALL|INSTALL_PROGRAM|INSTALL_DATA|INSTALL_DIR)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 6 },
+    { pattern: /\$[{(][^})]+[})]/g, className: 'hl-keyword', order: 7 },
+    { pattern: /(\$[@%<?^+*])/g, className: 'hl-keyword', order: 8 },
+    { pattern: /([{}[\](),;:])/g, className: 'hl-punctuation', order: 9 },
+];
+const definition = { langId: 'makefile', name: 'Makefile', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-markdown.js

@@ -0,0 +1,18 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(<!--[\s\S]*?-->)/g, className: 'hl-comment', order: 1 },
+    { pattern: /(^#{1,6}\s.*$)/gm, className: 'hl-keyword', order: 2 },
+    { pattern: /(`{3,}[\s\S]*?`{3,})/g, className: 'hl-string', order: 3 },
+    { pattern: /(`[^`]+`)/g, className: 'hl-string', order: 4 },
+    { pattern: /(\*\*[^*]+\*\*|__[^_]+__)/g, className: 'hl-boolean', order: 5 },
+    { pattern: /(\*[^*]+\*|_[^_]+_)/g, className: 'hl-builtin', order: 6 },
+    { pattern: /(\[([^\]]+)]\(([^)]+)\))/g, className: 'hl-function', order: 7 },
+    { pattern: /(!\[([^\]]*)]\(([^)]+)\))/g, className: 'hl-tag', order: 8 },
+    { pattern: /(^[-*+]\s)/gm, className: 'hl-punctuation', order: 9 },
+    { pattern: /(^\d+\.\s)/gm, className: 'hl-number', order: 10 },
+    { pattern: /(^>\s.*$)/gm, className: 'hl-comment', order: 11 },
+    { pattern: /(---|\*\*\*|___)/g, className: 'hl-punctuation', order: 12 },
+    { pattern: /(\|)/g, className: 'hl-punctuation', order: 13 },
+];
+const definition = { langId: 'markdown', name: 'Markdown', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-objectivec.js

@@ -0,0 +1,24 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(\/\/.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(\/\*[\s\S]*?\*\/)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(at|atomic|auto|bycopy|byref|BOOL|break|case|char|Class|const|continue|default|do|double|else|enum|extern|false|float|for|goto|if|IMP|in|inline|instancetype|int|interface|long|nil|NO|nonatomic|nullable|null_unspecified|null_resettable|oneway|out|private|property|protected|protocol|public|readonly|readwrite|register|return|short|signed|sizeof|static|struct|super|switch|synthesize|true|typedef|unichar|union|unsigned|void|volatile|while|YES|_Bool|_Complex|_Imaginary)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(YES|NO|nil|Nil|NULL|true|false)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(NSObject|NSString|NSSet|NSNumber|NSData|NSDate|NSURL|NSError|NSException|NSValue|NSIndexPath|NSIndexSet|NSNotification|NSTimer|NSThread|NSBundle|NSFileManager|NSUserDefaults|NSCharacterSet|NSLocale|NSCalendar|NSTimeZone|NSDateFormatter|NSNumberFormatter|NSRegularExpression|NSPredicate|NSMutableArray|NSMutableDictionary|NSMutableSet|NSMutableString|NSMutableData|NSEnumerator|NSFastEnumeration|NSCopying|NSCoding|NSSecureCoding|UITableView|UICollectionView|UIView|UIViewController|UILabel|UIButton|UITextField|UITextView|UIImageView|UIImage|UIColor|UIFont|UIScreen|UIWindow|UIApplication|UINavigationController|UITabBarController|UIScrollView|UITableViewCell|UICollectionViewCell|UIStackView|NSLayoutConstraint|NSNotificationCenter|NSRunLoop|NSProcessInfo|NSDictionary|NSArray)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*[fFlL]?)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 6 },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /(@[\\w]+)/g, className: 'hl-keyword', order: 8 },
+    { pattern: /(\[\s*\w+\s+\w+)/g, className: 'hl-tag', order: 9 },
+    { pattern: /([{}[\](),;:.^~])/g, className: 'hl-punctuation', order: 10 },
+];
+const definition = { langId: 'objectivec', name: 'Objective-C', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-perl.js

@@ -0,0 +1,30 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(#.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(=cut[\s\S]*?=cut)/g, className: 'hl-comment', order: 1 },
+    { pattern: /(^=\w+[\s\S]*?=cut)/gm, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(if|unless|else|elsif|given|when|default|for|foreach|while|until|do|continue|last|next|redo|goto|return|my|local|state|sub|package|module|use|require|no|import|export|our|BEGIN|CHECK|INIT|END|UNITCHECK|DESTROY|AUTOLOAD|format|tie|untie|tied|ref|bless|sort|map|grep|defined|undef|delete|exists|not|and|or|xor)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(undef|1|0)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(print|printf|sprintf|say|warn|die|exit|open|close|read|write|sysopen|sysread|syswrite|seek|tell|chdir|mkdir|rmdir|opendir|closedir|readdir|glob|link|unlink|symlink|rename|chmod|chown|stat|utime|length|substr|index|rindex|join|split|reverse|chomp|chop|lc|uc|lcfirst|ucfirst|splice|push|pop|shift|unshift|keys|values|each|map|grep|sort|pack|unpack|vec|defined|undef|delete|exists|ref|bless|tie|untie|tied|wantarray|scalar|prototype|caller|local|time|localtime|gmtime|rand|srand)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`|q[qwxr]?[^a-zA-Z0-9\s])/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /(\$[\w:']+)/g, className: 'hl-keyword', order: 8 },
+    { pattern: /(@[\w:']+)/g, className: 'hl-keyword', order: 9 },
+    { pattern: /(%[\w:']+)/g, className: 'hl-builtin', order: 10 },
+    { pattern: /([{}[\](),;=>])/g, className: 'hl-punctuation', order: 11 },
+];
+const definition = { langId: 'perl', name: 'Perl', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-powershell.js

@@ -0,0 +1,23 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(#.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(<#[\s\S]*?#>)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(Begin|Break|Catch|Class|Continue|Data|Define|Do|DynamicParam|Else|Elseif|End|Exit|Filter|Finally|For|ForEach|From|Function|Get|Global|If|In|InlineScript|Local|Module|New|Not|Parallel|Param|Process|Return|Sequence|Set|Static|Switch|Throw|Trap|Try|Until|Using|Var|While|Workflow)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(\$true|\$false|\$null)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(Write-Host|Write-Output|Write-Error|Write-Warning|Write-Verbose|Write-Debug|Read-Host|Get-ChildItem|Get-Item|Get-Content|Set-Content|Add-Content|Get-Command|Get-Member|Get-Help|Get-Process|Get-Service|Get-Date|Get-Location|Set-Location|Invoke-Command|Invoke-Expression|Invoke-Item|Select-Object|Where-Object|ForEach-Object|Sort-Object|Group-Object|Measure-Object|New-Object|New-Item|Remove-Item|Remove-ItemProperty|Copy-Item|Move-Item|Rename-Item|Test-Path|Join-Path|Split-Path|ConvertTo-Json|ConvertFrom-Json|Export-Csv|Import-Csv|Format-Table|Format-List|Format-Wide|Out-File|Out-Null)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 6 },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /(\$[\w{}]+)/g, className: 'hl-keyword', order: 8 },
+    { pattern: /([{}[\](),;|&])/g, className: 'hl-punctuation', order: 9 },
+];
+const definition = { langId: 'powershell', name: 'PowerShell', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-python.js

@@ -0,0 +1,27 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(#.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /('''[\s\S]*?'''|"""[\s\S]*?""")/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(False|None|True|and|as|assert|async|await|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|import|in|is|lambda|nonlocal|not|or|pass|raise|return|try|while|with|yield)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(True|False|None)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(print|len|range|type|int|str|float|list|dict|set|tuple|bool|super|self|cls|open|input|isinstance|enumerate|zip|map|filter|sorted|reversed|abs|min|max|sum|any|all|hasattr|getattr|setattr|delattr|__init__|__str__|__repr__|__call__)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*[jJlL]?)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|f"(?:[^"\\]|\\.)*"|f'(?:[^'\\]|\\.)*')/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /(@[\w.]+)/g, className: 'hl-keyword', order: 8 },
+    { pattern: /([{}[\](),:])/g, className: 'hl-punctuation', order: 9 },
+];
+const definition = { langId: 'python', name: 'Python', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-r.js

@@ -0,0 +1,21 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(#.*$)/gm, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(if|else|in|case|stop|ifelse|elseif|for|while|repeat|switch|function|return|next|break|TRUE|FALSE|NULL|Inf|NaN|NA|NA_integer_|NA_real_|NA_complex_|NA_character_)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(TRUE|FALSE|NULL|NA|NaN|Inf)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(print|cat|sprintf|paste|paste0|format|sink|readline|readLines|writeLines|scan|read.csv|read.table|write.csv|write.table|save|load|library|require|install.packages|source|setwd|getwd|list.files|dir|file.exists|file.create|file.remove|file.rename|file.copy|file.append|file.info|file.path|dir.create|unlink|system|options|getOption|set.seed|sample|seq|rep|length|nrow|ncol|dim|names|rownames|colnames|class|typeof|mode|str|summary|head|tail|unique|duplicated|table|aggregate|apply|lapply|sapply|vapply|tapply|mapply|by|merge|cbind|rbind|split|subset|order|sort|rank|scale|center|scale|log|exp|sqrt|abs|round|ceiling|floor|trunc|signif|sin|cos|tan|asin|acos|atan|atan2|min|max|which|which.min|which.max|mean|median|sd|var|cor|cov|quantile|IQR|fivenum|range|diff|sum|prod|cumsum|cumprod|cummin|cummax|pmax|pmin|colSums|rowSums|colMeans|rowMeans|is.na|is.null|is.nan|is.finite|is.infinite|is.array|is.character|is.complex|is.double|is.element|is.environment|is.factor|is.function|is.integer|is.language|is.list|is.logical|is.matrix|is.na|is.name|is.nan|is.null|is.numeric|is.object|is.ordered|is.package_version|is.pairlist|is.primitive|is.qr|is.R|is.raw|is.recursive|is.single|is.symbol|is.table|is.unsorted|is.vector|as.array|as.character|as.complex|as.double|as.expression|as.factor|as.integer|as.list|as.logical|as.matrix|as.name|as.null|as.numeric|as.ordered|as.raw|as.table)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, className: 'hl-string', order: 6 },
+    { pattern: /\b([a-zA-Z_.][a-zA-Z0-9_.]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /([{}[\](),;])/g, className: 'hl-punctuation', order: 8 },
+];
+const definition = { langId: 'r', name: 'R', rules };
+SyntaxRegistry.register(definition);

package/dist/core/highlight/lang-ruby.js

@@ -0,0 +1,29 @@
+import { SyntaxRegistry } from './registry';
+const rules = [
+    { pattern: /(#.*$)/gm, className: 'hl-comment', order: 1 },
+    { pattern: /(=begin[\s\S]*?=end)/g, className: 'hl-comment', order: 1 },
+    {
+        pattern: /\b(BEGIN|END|alias|and|begin|break|case|class|def|defined|do|else|elsif|end|ensure|for|if|in|module|next|nil|not|or|redo|rescue|retry|return|self|super|then|undef|unless|until|when|while|yield)\b/g,
+        className: 'hl-keyword',
+        order: 2,
+    },
+    { pattern: /\b(true|false|nil)\b/g, className: 'hl-boolean', order: 3 },
+    {
+        pattern: /\b(puts|print|p|require|include|extend|attr_accessor|attr_reader|attr_writer|raise|throw|catch|fail|lambda|proc|new|send|respond_to|method_missing|block_given|each|map|select|reject|reduce|inject)\b/g,
+        className: 'hl-builtin',
+        order: 4,
+    },
+    { pattern: /\b(\d+\.?\d*)\b/g, className: 'hl-number', order: 5 },
+    {
+        pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g,
+        className: 'hl-string',
+        order: 6,
+    },
+    { pattern: /\b([a-zA-Z_][\\w]*)\s*(?=\()/g, className: 'hl-function', order: 7 },
+    { pattern: /(@@?[\\w]+)/g, className: 'hl-keyword', order: 8 },
+    { pattern: /(\$[\\w]+)/g, className: 'hl-builtin', order: 9 },
+    { pattern: /(:\w+)/g, className: 'hl-key', order: 10 },
+    { pattern: /([{}[\](),;])/g, className: 'hl-punctuation', order: 11 },
+];
+const definition = { langId: 'ruby', name: 'Ruby', rules };
+SyntaxRegistry.register(definition);