bunmicro 0.8.0

package/runtime/syntax/gleam.yaml

@@ -0,0 +1,69 @@
+filetype: gleam
+
+detect:
+    filename: "\\.gleam$"
+
+rules:
+    - identifier: "\\b[a-z][a-z0-9_]*\\b"
+
+    - statement: "\\b(as|assert|auto|case|const|delegate|derive|echo|else|fn|if|implement|import|let|macro|opaque|panic|pub|test|todo|type|use)\\b"
+
+    - type: "\\b[A-Z][a-zA-Z0-9_]*\\b"
+
+    - type: "\\b(Int|Float|String|Bool|List|Option|Result|BitArray)\\b"
+
+    - constant: "\\b(True|False|Nil)\\b"
+
+    - preproc: "@[a-z][a-z_]*"
+
+    - statement: "(\\|>|->|<-)"
+    - statement: "(\\.\\.|<>)"
+    - statement: "(==|!=|<=\\.|>=\\.|<\\.|>\\.|<=|>=)"
+    - statement: "(&&|\\|\\|)"
+    - statement: "(\\+\\.|-\\.|\\*\\.|/\\.|\\+|-|\\*|/|%)"
+    - statement: "(=|<|>|!|<<|>>)"
+
+    - constant.number: "\\b0b[01](_?[01])*\\b"
+    - constant.number: "\\b0o[0-7](_?[0-7])*\\b"
+    - constant.number: "\\b0x[0-9a-fA-F](_?[0-9a-fA-F])*\\b"
+    - constant.number: "\\b[0-9](_?[0-9])*(\\.[0-9](_?[0-9])*)?([eE][+-]?[0-9](_?[0-9])*)?\\b"
+
+    - default:
+        start: "#\\("
+        end: "\\)"
+        limit-group: special
+        rules:
+            - identifier: "\\b[a-z][a-z0-9_]*\\b"
+            - statement: "\\b(as|assert|auto|case|const|delegate|derive|echo|else|fn|if|implement|import|let|macro|opaque|panic|pub|test|todo|type|use)\\b"
+            - type: "\\b[A-Z][a-zA-Z0-9_]*\\b"
+            - type: "\\b(Int|Float|String|Bool|List|Option|Result|BitArray)\\b"
+            - constant: "\\b(True|False|Nil)\\b"
+            - statement: "(\\|>|->|<-)"
+            - statement: "(\\.\\.|<>)"
+            - statement: "(==|!=|<=\\.|>=\\.|<\\.|>\\.|<=|>=)"
+            - statement: "(&&|\\|\\|)"
+            - statement: "(\\+\\.|-\\.|\\*\\.|/\\.|\\+|-|\\*|/|%)"
+            - statement: "(=|<|>|!|<<|>>)"
+            - constant.number: "\\b0b[01](_?[01])*\\b"
+            - constant.number: "\\b0o[0-7](_?[0-7])*\\b"
+            - constant.number: "\\b0x[0-9a-fA-F](_?[0-9a-fA-F])*\\b"
+            - constant.number: "\\b[0-9](_?[0-9])*(\\.[0-9](_?[0-9])*)?([eE][+-]?[0-9](_?[0-9])*)?\\b"
+            - constant.string:
+                start: '"'
+                end: '"'
+                skip: "\\\\."
+                rules:
+                    - constant.specialChar: "\\\\."
+
+    - constant.string:
+        start: '"'
+        end: '"'
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - comment:
+        start: "//"
+        end: "$"
+        rules:
+            - todo: "(TODO|FIXME|XXX):?"

package/runtime/syntax/glsl.yaml

@@ -0,0 +1,26 @@
+filetype: glsl
+
+detect:
+    filename: "\\.(frag|vert|fp|vp|glsl)$"
+
+rules:
+    - identifier: "[A-Za-z_][A-Za-z0-9_]*[[:space:]]*[()]"
+    - type: "\\b(void|bool|bvec2|bvec3|bvec4|int|ivec2|ivec3|ivec4|float|vec2|vec3|vec4|mat2|mat3|mat4|struct|sampler1D|sampler2D|sampler3D|samplerCUBE|sampler1DShadow|sampler2DShadow)\\b"
+    - identifier: "\\bgl_(DepthRangeParameters|PointParameters|MaterialParameters|LightSourceParameters|LightModelParameters|LightModelProducts|LightProducts|FogParameters)\\b"
+    - statement: "\\b(const|attribute|varying|uniform|in|out|inout|if|else|return|discard|while|for|do)\\b"
+    - statement: "\\b(break|continue)\\b"
+    - constant.bool: "\\b(true|false)\\b"
+    - symbol.operator: "[-+/*=<>?:!~%&|^]"
+    - constant.number: "\\b([0-9]+|0x[0-9a-fA-F]*)\\b"
+
+    - comment:
+        start: "//"
+        end: "$"
+        rules:
+            - todo: "TODO:?"
+
+    - comment:
+        start: "/\\*"
+        end: "\\*/"
+        rules:
+            - todo: "TODO:?"

package/runtime/syntax/gnuplot.yaml

@@ -0,0 +1,15 @@
+filetype: gnuplot
+
+detect:
+    filename: "\\.(gnu|gpi|plt|gp)$"
+
+rules:
+    - statement: "\\b(set|unset|plot|splot|replot|if|else|do|for|while|fit)\\b"
+    - symbol.operator: "[-+/*=<>?:!~%&|^$]"
+    - constant.number: "\\b([0-9]+|0x[0-9a-fA-F]*)\\b"
+
+    - comment:
+        start: "#"
+        end: "$"
+        rules:
+            - todo: "TODO:?"

package/runtime/syntax/go.yaml

@@ -0,0 +1,62 @@
+filetype: go
+
+detect:
+    filename: "\\.go$"
+
+rules:
+    # Conditionals and control flow
+    - special: "\\b(break|case|continue|default|go|goto|range|return|println|fallthrough)\\b"
+    - statement: "\\b(else|for|if|switch|select)\\b"
+    - preproc: "\\b(package|import|const|var|type|struct|func|defer|iota|make|new|copy|len|cap|panic|append|close|delete|print|recover)\\b"
+    - symbol.operator: "[-+/*=<>!~%&|^]|:="
+
+      # Types
+    - symbol: "(,|\\.)"
+    - type: "\\b(u?int(8|16|32|64)?|float(32|64)|complex(64|128))\\b"
+    - type: "\\b(uintptr|byte|rune|string|interface|bool|map|chan|error)\\b"
+    - type.keyword: "\\b(struct)\\b"
+    - constant.bool: "\\b(true|false|nil)\\b"
+
+      # Brackets
+    - symbol.brackets: "(\\{|\\})"
+    - symbol.brackets: "(\\(|\\))"
+    - symbol.brackets: "(\\[|\\])"
+
+      # Numbers and strings
+    - constant.number: "\\b([0-9]+|0x[0-9a-fA-F]*)\\b|'.'"
+
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "%."
+            - constant.specialChar: "\\\\[abfnrtv'\\\"\\\\]"
+            - constant.specialChar: "\\\\([0-7]{3}|x[A-Fa-f0-9]{2}|u[A-Fa-f0-9]{4}|U[A-Fa-f0-9]{8})"
+
+    - constant.string:
+        start: "'"
+        end: "'"
+        skip: "\\\\."
+        rules:
+            - error: "..+"
+            - constant.specialChar: "%."
+            - constant.specialChar: "\\\\[abfnrtv'\\\"\\\\]"
+            - constant.specialChar: "\\\\([0-7]{3}|x[A-Fa-f0-9]{2}|u[A-Fa-f0-9]{4}|U[A-Fa-f0-9]{8})"
+
+    - constant.string:
+        start: "`"
+        end: "`"
+        rules: []
+
+    - comment:
+        start: "//"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"
+
+    - comment:
+        start: "/\\*"
+        end: "\\*/"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"

package/runtime/syntax/godoc.yaml

@@ -0,0 +1,17 @@
+# godoc
+# example: go doc -all | micro
+
+filetype: godoc
+
+detect:
+    filename: "\\.godoc$"
+    header: package.*import
+
+rules:
+    - preproc: "^[^ ].*"
+
+    - comment:
+        start: "//"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"

package/runtime/syntax/golo.yaml

@@ -0,0 +1,73 @@
+filetype: golo
+
+detect:
+    filename: "\\.golo$"
+
+rules:
+    - type: "\\b(function|fun|)\\b"
+    - type: "\\b(struct|DynamicObject|union|AdapterFabric|Adapter|DynamicVariable|Observable)\\b"
+    - type: "\\b(list|set|array|vector|tuple|map)\\b"
+    - type: "\\b(Ok|Error|Empty|None|Some|Option|Result|Result.ok|Result.fail|Result.error|Result.empty|Optional.empty|Optional.of)\\b"
+
+    - identifier.class: "\\b(augment|pimp)\\b"
+    - identifier.class: "\\b(interfaces|implements|extends|overrides|maker|newInstance)\\b"
+    - identifier.class: "\\b(isEmpty|isNone|isPresent|isSome|iterator|flattened|toList|flatMap|`and|orElseGet|`or|toResult|apply|either)\\b"
+    - identifier.class: "\\b(result|option|trying|raising|nullify|catching)\\b"
+    - identifier.class: "\\b(promise|setFuture|failedFuture|all|any)\\b"
+    - identifier.class: "\\b(initialize|initializeWithinThread|start|future|fallbackTo|onSet|onFail|cancel|enqueue)\\b"
+    - identifier.class: "\\b(println|print|raise|readln|readPassword|secureReadPassword|requireNotNull|require|newTypedArray|range|reversedRange|mapEntry|asInterfaceInstance|asFunctionalInterface|isClosure|fileToText|textToFile|fileExists|currentDir|sleep|uuid|isArray|arrayTypeOf|charValue|intValue|longValue|doubleValue|floatValue|removeByIndex|box)\\b"
+    - identifier.class: "\\b(likelySupported|reset|bold|underscore|blink|reverse_video|concealed|fg_black|fg_red|fg_green|fg_yellow|fg_blue|fg_magenta|fg_cyan|fg_white|bg_black|bg_red|bg_green|bg_yellow|bg_blue|bg_magenta|bg_cyan|bg_white|cursor_position|cursor_save_position|cursor_restore_position|cursor_up|cursor_down|cursor_forward|cursor_backward|erase_display|erase_line)\\b"
+    - identifier.class: "\\b(emptyList|cons|lazyList|fromIter|generator|repeat|iterate)\\b"
+    - identifier.class: "\\b(asLazyList|foldl|foldr|take|takeWhile|drop|dropWhile|subList)\\b"
+    - identifier.class: "\\b(import)\\b"
+    - identifier.class: "\\b(module)\\b"
+    - identifier.class: "\\b(JSON)\\b"
+    - identifier.class: "\\b(stringify|parse|toJSON|toDynamicObject|updateFromJSON)\\b"
+    - identifier.class: "\\b(newInstance|define|getKey|getValue|properties|fallback)\\b"
+    - identifier.class: "\\b(times|upTo|downTo)\\b"
+    - identifier.class: "\\b(format|toInt|toInteger|toDouble|toFloat|toLong)\\b"
+    - identifier.class: "\\b(head|tail|isEmpty|reduce|each|count|exists)\\b"
+    - identifier.class: "\\b(newWithSameType|destruct|append|add|addIfAbsent|prepend|insert|last|unmodifiableView|find|filter|map|join|reverse|reversed|order|ordered|removeAt|include|exclude|remove|delete|has|contains|getOrElse|toArray)\\b"
+    - identifier.class: "\\b(add|addTo|succ|pred|mul|neg|sub|rsub|div|rdiv|mod|rmod|pow|rpow|str|lt|gt|eq|ne|ge|le|`and|`or|`not|xor|even|odd|contains|isEmpty|`is|`isnt|`oftype|`orIfNull|fst|snd|getitem|setitem|getter|id|const|False|True|Null|curry|uncurry|unary|spreader|varargs|swapArgs|swapCurry|swapCouple|swap|invokeWith|pipe|compose|io|andThen|until|recur|cond)\\b"
+    - identifier.class: "\\b(toUpperCase|equals|startsWith)\\b"
+
+    - statement: "\\b(if|else|then|when|case|match|otherwise)\\b"
+    - special: "\\b(with|break|continue|return)\\b"
+    - error: "\\b(try|catch|finally|throw)\\b"
+    - identifier: "\\b(super|this|let|var|local)\\b"
+    - symbol.brackets: "[(){}]|\\[|\\]"
+    - statement: "\\b(for|while|foreach|in)\\b"
+    - constant: "\\b(and|in|is|not|or|isnt|orIfNull)\\b"
+
+    - constant.bool: "\\b(true|false)\\b"
+    - constant:  "\\b(null|undefined)\\b"
+
+    - symbol.operator: "[\\-+/*=<>!~%&|^]|:="
+    - constant.number:   "\\b([0-9]+|0x[0-9a-fA-F]*)\\b|'.'"
+
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - constant.string:
+        start: "'"
+        end: "'"
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - comment:
+        start: "#"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"
+
+    - comment:
+        start: "----"
+        end: "----"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"
+

package/runtime/syntax/gomod.yaml

@@ -0,0 +1,31 @@
+filetype: gomod
+
+detect:
+    filename: "go.mod"
+
+rules:
+    # URL
+    - type: "(^|[ \\t])+\\b([a-zA-Z0-9-]+\\.?)+(/[a-zA-Z0-9-_\\.]+)*\\b"
+
+    # Keywords
+    - special: "(^|[ \\t])+\\b(module|go)\\b"
+    - preproc: "(^|[ \\t])+\\b(toolchain|require|exclude|replace|retract)\\b"
+    - symbol.operator: "=>"
+
+    # Brackets
+    - type: "(\\(|\\))"
+
+    # Go version
+    - type: "(^|[ \\t])+([0-9]+\\.?)+"
+
+    # Version
+    - constant.string: "(^|[ \\t])+v([0-9]+\\.?){3}.*"
+    - constant.number: "(^|[ \\t])+v([0-9]+\\.?){3}"
+
+    - comment:
+        start: "//"
+        end: "$"
+        rules:
+            - todo: "(indirect):?"
+
+# (^|[ \\t])+ means after start of string or space or tab character

package/runtime/syntax/graphql.yaml

@@ -0,0 +1,47 @@
+filetype: graphql
+
+detect:
+    filename: "\\.(gql|graphql)$"
+
+rules:
+    - type: "\\b(?:(query|mutation|subscription|type|input|scalar|fragment|schema|union|on|extends?))\\b"
+
+    # scalar types
+    - statement: "\\b(ID|Int|Float|Boolean|String|Datetime|Null)\\b"
+
+    # introspection types
+    - statement: "(__\\w+)"
+
+    # parameters
+    - statement: "((\\w+)(?:\\:([\\s]*)?)(?:\\$))"
+
+    # directive locations
+    - statement: "\\b(QUERY|MUTATION|SUBSCRIPTION|FIELD|FRAGMENT_DEFINITION|FRAGMENT_SPREAD|INLINE_FRAGMENT|SCHEMA|SCALAR|OBJECT|FIELD_DEFINITION|ARGUMENT_DEFINITION|INTERFACE|UNION|ENUM|ENUM_VALUE|INPUT_OBJECT|INPUT_FIELD_DEFINITION)\\b"
+
+    # directives
+    - constant: "(@\\w+)"
+
+    # root types
+    - constant: "\\b(Query|Mutation|Subscription|Schema|Root)\\b"
+
+    # variables
+    - special: "(\\$\\w+)"
+
+    # required symbol
+    - special: "(!)"
+
+    - symbol: "(:|=|\\||\\(|\\)|\\{|\\}|\\[|\\])"
+
+    - constant.bool: "\\b(true|false)\\b"
+
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - comment:
+        start: "#"
+        end: "$"
+        rules: []

package/runtime/syntax/groff.yaml

@@ -0,0 +1,30 @@
+filetype: groff
+
+detect:
+    filename: "\\.m[ems]$|\\.rof|\\.tmac$|^tmac."
+
+rules:
+    - statement: "^\\.(ds|nr) [^[[:space:]]]*"
+    - constant.specialChar: "\\\\."
+    - constant.specialChar: "\\\\f.|\\\\f\\(..|\\\\s(\\+|\\-)?[0-9]"
+    - constant: "(\\\\|\\\\\\\\)n(.|\\(..)"
+    - constant:
+        start: "(\\\\|\\\\\\\\)n\\["
+        end: "]"
+        rules: []
+
+    - type: "^\\.[[:space:]]*[^[[:space:]]]*"
+    - comment: "^\\.\\\\\".*$"
+    - constant.string: "(\\\\|\\\\\\\\)\\*(.|\\(..)"
+    - constant.string:
+        start: "(\\\\|\\\\\\\\)\\*\\["
+        end: "]"
+        rules: []
+
+    - constant.specialChar: "\\\\\\(.."
+    - constant.specialChar:
+        start: "\\\\\\["
+        end: "]"
+        rules: []
+
+    - identifier.macro: "\\\\\\\\\\$[1-9]"

package/runtime/syntax/groovy.yaml

@@ -0,0 +1,111 @@
+filetype: groovy
+
+detect:
+    filename: "(\\.(groovy|gy|gvy|gsh|gradle)$|^[Jj]enkinsfile$)"
+    header: "^#!.*/(env +)?groovy *$"
+
+rules:
+    # And the style guide for constants is CONSTANT_CASE
+    - identifier: "\\b[A-Z_$]+\\b"
+    # The style guide for JVM languages is PascalCase for classes and interfaces
+    - identifier.class: "\\b[A-Z][a-zA-Z0-9$]+\\b"
+
+    # Primitive types
+    - type: "\\b(byte|short|int|long|float|double|char|boolean|void)\\b"
+
+    # Type-related keywords
+    - type.keyword: "\\b(private|public|protected|static|final|var|def)\\b"
+
+    # Keywords
+    - statement: "\\b(for|while|do|if|else|switch|case|default|try|catch|finally)\\b"
+    - statement: "\\b(break|continue|return|throw|assert)\\b"
+    - statement: "\\b(package|import|class|interface|trait|enum|extends|implements|throws)\\b"
+    - statement: "\\b(this|super)\\b"
+    # Unsused, but reserved keywords
+    - statement: "\\b(goto|const)\\b"
+
+    # Operators and punctuation
+    - symbol.operator: "[-+*/%=<>^~&|!?:;,.@]|\\b(in|is|as|instanceof|new)\\b"
+    - symbol.brackets: "[(){}]|\\[|\\]"
+
+    # Decimal integer literal
+    - constant.number: "(?i)\\b[1-9]([_0-9]*[0-9])?[GLIDF]?\\b"
+    # Binary integer literal
+    - constant.number: "(?i)\\b0b[01]([01_]*[01])?[GLIDF]?\\b"
+    # Octal integer literal
+    - constant.number: "(?i)\\b0[0-7]([0-7_]*[0-7])?[GLIDF]?\\b"
+    # Hexadecimal integer literal
+    - constant.number: "(?i)\\b0x[0-9a-fA-F]([0-9a-f_]*[0-9a-fA-F])?[GLIDF]?\\b"
+    # Floating-point literal
+    - constant.number: "(?i)\\b[0-9]([0-9_]*[0-9])?([.][0-9]([0-9_]*[0-9])?)?(e[+-]?[0-9]([0-9_]*[0-9])?)?[DF]?\\b"
+    - constant.bool: "\\b(true|false|null)\\b"
+
+    # Annotations
+    - identifier: "@[A-Za-z_$][A-Za-z0-9_$]*\\b"
+
+    # Triple-double-quoted strings
+    - constant.string:
+        start: "\"\"\""
+        end: "\"\"\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([\"'bfnrst\\x24\\\\]|u[a-fA-F0-9]{4})"
+            - identifier.var: "\\x24[\\w\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF\u0100-\uFFFE]+([.][a-zA-Z0-9_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF\u0100-\uFFFE]+)*"
+            - identifier:
+                start: "[$][{]"
+                end: "[}]"
+                rules: []
+
+    # Triple-single-quoted strings
+    - constant.string:
+        start: "'''"
+        end: "'''"
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([\"'bfnrst\\x24\\\\]|u[a-fA-F0-9]{4})"
+
+    # Nesting ${} are never going to be matched correctly with just regex either, so highlighting will break if one is to nest interpolation
+    # Double-quoted strings
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([\"'bfnrst\\x24\\\\]|u[a-fA-F0-9]{4})"
+            - identifier.var: "\\x24[\\w\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF\u0100-\uFFFE]+([.][a-zA-Z0-9_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF\u0100-\uFFFE]+)*"
+            - identifier: "\\x24[{].*[}]"
+
+    # Single-quoted strings
+    - constant.string:
+        start: "'"
+        end: "'"
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([\"'bfnrst\\x24\\\\]|u[a-fA-F0-9]{4})"
+
+    # Slashy strings are left out, because they match in unwanted places pretty much all the time
+    # Dollar-slashy strings
+    - constant.string:
+        start: "[$]/"
+        end: "/[$]"
+        rules: []
+
+    # Single-line comments
+    - comment:
+        start: "//"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"
+
+    # Multiline comments
+    - comment:
+        start: "/[*]"
+        end: "[*]/"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"
+
+    # Groovydoc comments
+    - comment:
+        start: "/[*][*]@?"
+        end: "[*]/"
+        rules: []

package/runtime/syntax/haml.yaml

@@ -0,0 +1,16 @@
+filetype: haml
+
+detect:
+    filename: "\\.haml$"
+
+rules:
+    - symbol: "-|="
+    - default: "->|=>"
+    - constant: "([  ]|^)%[0-9A-Za-z_]+>"
+    - special: ":[0-9A-Za-z_]+>"
+    - type: "\\.[A-Za-z_]+>"
+    - constant.string: "\"([^\"]|(\\\\\"))*\"|%[QW]?\\{[^}]*\\}|%[QW]?\\([^)]*\\)|%[QW]?<[^>]*>|%[QW]?\\$[^$]*\\$|%[QW]?\\^[^^]*\\^|%[QW]?![^!]*!"
+    - constant.string: "'([^']|(\\\\'))*'|%[qw]\\{[^}]*\\}|%[qw]\\([^)]*\\)|%[qw]<[^>]*>|%[qw]\\[[^]]*\\]|%[qw]\\$[^$]*\\$|%[qw]\\^[^^]*\\^|%[qw]![^!]*!"
+    - identifier: "#\\{[^}]*\\}"
+    - identifier.var: "(@|@@)[0-9A-Z_a-z]+"
+    - comment: "#[^{].*$|#$"

package/runtime/syntax/hare.yaml

@@ -0,0 +1,52 @@
+filetype: hare
+
+detect:
+    filename: "\\.ha$"
+
+rules:
+    - identifier: "\\b[A-Z_][0-9A-Z_]+\\b"
+
+    - type: "\\b(bool|char|str|rune|void)\\b"
+    - type: "\\b(f32|f64|uint|int|u8|u16|u32|u64|i8|i16|i32|i64|uintptr)\\b"
+
+    - statement: "\\b(case|else|for|if|switch)\\b"
+    - statement: "\\b(continue|break|return)\\b"
+
+    - special: "\\b(as|const|def|defer|enum|export|fn|is|let|match|static|struct|type|union|yield|_)\\b"
+    - preproc: "\\b(abort|alloc|append|assert|delete|free|insert|len|nullable|offset|size)\\b"
+    - preproc: "^use .+;"
+    - preproc: "\\@([a-zA-Z_][0-9a-zA-Z_]+)\\b"
+
+    - constant: "\\b(false|null|true)\\b"
+    - constant.number: "\\b(0x[0-9A-Fa-f]+(i(8|16|32|64)?|u(8|16|32|64)?|z)?)\\b"
+    - constant.number: "\\b(0o[0-7]+(i(8|16|32|64)?|u(8|16|32|64)?|z)?)\\b"
+    - constant.number: "\\b(0b[01]+(i(8|16|32|64)?|u(8|16|32|64)?|z)?)\\b"
+
+    - constant.specialChar: "\\\".*\\\""
+    - constant.specialChar: "`.*`"
+    - constant.specialChar: "'([^'\\\\]|\\\\(0|a|b|f|n|r|t|v|\\\\|'|\\\"|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8}))'"
+
+    - symbol.operator: "([.:;,+*|=!\\%]|<|>|/|-|&)"
+    - symbol.brackets: "[(){}]|\\[|\\]"
+
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([\"'abfnrtv\\\\]|[0-3]?[0-7]{1,2}|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})"
+
+    - constant.string:
+        start: "'"
+        end: "'"
+        skip: "\\\\."
+        rules:
+            - error: "..+"
+            - constant.specialChar: "\\\\([\"'abfnrtv\\\\]|[0-3]?[0-7]{1,2}|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})"
+
+    - comment:
+        start: "//"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"
+

package/runtime/syntax/haskell.yaml

@@ -0,0 +1,52 @@
+filetype: haskell
+
+detect:
+    filename: "\\.hs$"
+
+rules:
+    - symbol.operator: "[!#$%&:*+/<=>?@.\\\\^\\|~\\p{Sm}\\-]+"
+
+    # Identifiers (with or without a module name)
+    - type: "\\b([A-Z][A-Za-z0-9_]*\\.)*[A-Z]+[A-Za-z0-9_']*\\b"
+    - default: "\\b([A-Z][A-Za-z0-9_]*\\.)*[a-z][A-Za-z0-9_']*\\b"
+
+    - statement: ";"
+    - symbol.bracket: "[\\(\\)\\[\\]\\{\\}]"
+    - special: "`[A-Za-z0-9']+`"
+
+    # Keywords
+    - statement: "\\b(case|of|class|data|default|deriving|do|forall|foreign|hiding|if|then|else|import|infix|infixl|infixr|instance|let|in|mdo|module|newtype|qualified|type|where)\\b"
+
+    # Data constructors
+    - constant.bool: "\\b(True|False)\\b"
+    - constant: "\\b(Nothing|Just|Left|Right|LT|EQ|GT)\\b"
+
+    - constant: "\\(\\)"  # Unit
+    - constant.number: "\\b(0[xX][0-9A-Fa-f]+|0[oO][0-7]+|0[bB][01]+|[-]?[0-9]+([.][0-9]+)?([eE][+-]?[0-9]+)?)\\b"
+
+    # Data classes
+    - identifier.class: "\\b(Additive|Applicative|Bounded|Data|Enum|Eq|Floating|Foldable|Fractional|Functor|Integral|Monad|MonadPlus|Monoid|Num|Ord|Read|Real|RealFloat|RealFrac|Semigroup|Show|Traversable|Typeable|Zip)[ ]"
+
+    # Strings
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - special: "\\\\&"
+            - constant.specialChar: "\\\\([abfnrtv\"'\\\\]|[0-9]+|x[0-9a-fA-F]+|o[0-7]+|NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC[1-4]|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL)"
+
+    # Comments
+    - comment:
+        start: "--"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"
+
+    - comment:
+        start: "\\{-"
+        end: "-\\}"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"
+
+    - identifier.macro: "undefined"

package/runtime/syntax/hc.yaml

@@ -0,0 +1,52 @@
+filetype: hc
+
+detect:
+    filename: "(\\.(hc|HC)$|\\.(hh|HH)$|\\.ii?$|\\.(def)$)"
+
+rules:
+    - identifier: "\\b[A-Z_][0-9A-Z_]+\\b"
+    - type: "\\b(F64|I8|U8|I16|U16|I32|U32|I64|U64|sizeof|enum|U0|static|extern|struct|union|class|intern|public|argc|argv|asm)\\b"
+
+    - statement: "\\b(for|if|while|do|else|case|default|switch)\\b"
+    - statement: "\\b(try|catch|throw|goto|continue|break|return)\\b"
+    - preproc: "^[[:space:]]*#[[:space:]]*(define|pragma|include|(un|ifn?)def|endif|el(if|se)|if|help_index|ifjit|ifaot|exe)"
+
+      # Operator Color
+    - symbol.operator: "([.:;,+*|=!\\%]|<|>|/|-|&)"
+    - symbol.brackets: "[(){}]|\\[|\\]"
+      # Integer Constants
+    - constant.number: "(\\b([1-9][0-9]*|0[0-7]*|0[Xx][0-9A-Fa-f]+|0[Bb][01]+)([Uu]?[Ll][Ll]?|[Ll][Ll]?[Uu]?)?\\b)"
+      # Decimal Floating Constants
+    - constant.number: "(\\b(([0-9]*[.][0-9]+|[0-9]+[.][0-9]*)([Ee][+-]?[0-9]+)?|[0-9]+[Ee][+-]?[0-9]+)[FfLl]?\\b)"
+      # Hexadecimal Floating Constants
+    - constant.number: "(\\b0[Xx]([0-9A-Za-z]*[.][0-9A-Za-z]+|[0-9A-Za-z]+[.][0-9A-Za-z]*)[Pp][+-]?[0-9]+[FfLl]?\\b)"
+    - constant.number: "NULL"
+    - constant.number: "TRUE"
+    - constant.number: "FALSE"
+
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([\"'abfnrtv\\\\]|[0-3]?[0-7]{1,2}|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})"
+
+    - constant.string:
+        start: "'"
+        end: "'"
+        skip: "\\\\."
+        rules:
+            - error: "..+"
+            - constant.specialChar: "\\\\([\"'abfnrtv\\\\]|[0-3]?[0-7]{1,2}|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})"
+
+    - comment:
+        start: "//"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"
+
+    - comment:
+        start: "/\\*"
+        end: "\\*/"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"