broomhlda 0.1.0

data/lib/hl/lexers/imported/dylanlid.ay

@@ -0,0 +1,17 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "DylanLID"
+  aliases: ["dylan-lid", "lid"]
+  extensions: [".lid", ".hdp"]
+  mimetypes: ["text/x-dylan-lid"]
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(root):
+    r"\s+" is(text)
+    r"//.*?\n" is(comment.single)
+    r"(.*?)(:)([ \t]*)(.*(?:\n[ \t].+)*)" is(by-groups(name.attribute, operator, text, literal.string))
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/ecl.ay

@@ -0,0 +1,57 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "ECL"
+  aliases: ["ecl"]
+  extensions: [".ecl"]
+  mimetypes: ["application/x-ecl"]
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(functions):
+    r"(ABS|ACOS|ALLNODES|ASCII|ASIN|ASSTRING|ATAN|ATAN2|AVE|CASE|CHOOSE|CHOOSEN|CHOOSESETS|CLUSTERSIZE|COMBINE|CORRELATION|COS|COSH|COUNT|COVARIANCE|CRON|DATASET|DEDUP|DEFINE|DENORMALIZE|DISTRIBUTE|DISTRIBUTED|DISTRIBUTION|EBCDIC|ENTH|ERROR|EVALUATE|EVENT|EVENTEXTRA|EVENTNAME|EXISTS|EXP|FAILCODE|FAILMESSAGE|FETCH|FROMUNICODE|GETISVALID|GLOBAL|GRAPH|GROUP|HASH|HASH32|HASH64|HASHCRC|HASHMD5|HAVING|IF|INDEX|INTFORMAT|ISVALID|ITERATE|JOIN|KEYUNICODE|LENGTH|LIBRARY|LIMIT|LN|LOCAL|LOG|LOOP|MAP|MATCHED|MATCHLENGTH|MATCHPOSITION|MATCHTEXT|MATCHUNICODE|MAX|MERGE|MERGEJOIN|MIN|NOLOCAL|NONEMPTY|NORMALIZE|PARSE|PIPE|POWER|PRELOAD|PROCESS|PROJECT|PULL|RANDOM|RANGE|RANK|RANKED|REALFORMAT|RECORDOF|REGEXFIND|REGEXREPLACE|REGROUP|REJECTED|ROLLUP|ROUND|ROUNDUP|ROW|ROWDIFF|SAMPLE|SET|SIN|SINH|SIZEOF|SOAPCALL|SORT|SORTED|SQRT|STEPPED|STORED|SUM|TABLE|TAN|TANH|THISNODE|TOPN|TOUNICODE|TRANSFER|TRIM|TRUNCATE|TYPEOF|UNGROUP|UNICODEORDER|VARIANCE|WHICH|WORKUNIT|XMLDECODE|XMLENCODE|XMLTEXT|XMLUNICODE)\b" is(name.function)
+
+  lex(statements):
+    any-of(types)
+    any-of(keywords)
+    any-of(functions)
+    any-of(hash)
+    r"\"" is(literal.string) -> go-to(string)
+    r"\'" is(literal.string) -> go-to(string)
+    r"(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*" is(literal.number.float)
+    r"(\d+\.\d*|\.\d+|\d+[fF])[fF]?" is(literal.number.float)
+    r"0x[0-9a-fA-F]+[LlUu]*" is(literal.number.hex)
+    r"0[0-7]+[LlUu]*" is(literal.number.oct)
+    r"\d+[LlUu]*" is(literal.number.integer)
+    r"\*/" is(error)
+    r"[\126!%^&*+=|?:<>/-]+" is(operator)
+    r"[{}()\[\],.;]" is(punctuation)
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name)
+
+  lex(whitespace):
+    r"\s+" is(text)
+    r"\/\/.*" is(comment.single)
+    r"/(\\\n)?\*(.|\n)*?\*(\\\n)?/" is(comment.multiline)
+
+  lex(keywords):
+    r"(APPLY|ASSERT|BUILD|BUILDINDEX|EVALUATE|FAIL|KEYDIFF|KEYPATCH|LOADXML|NOTHOR|NOTIFY|OUTPUT|PARALLEL|SEQUENTIAL|SOAPCALL|WAITCHECKPOINT|DEPRECATED|FAILCODE|FAILMESSAGE|FAILURE|GLOBAL|INDEPENDENT|ONWARNING|PERSIST|PRIORITY|RECOVERY|STORED|SUCCESS|WAIT|WHEN)\b" is(keyword.reserved)
+    r"(ALL|AND|ANY|AS|ATMOST|BEFORE|BEGINC\+\+|BEST|BETWEEN|CASE|CONST|COUNTER|CSV|DESCEND|ENCRYPT|ENDC\+\+|ENDMACRO|EXCEPT|EXCLUSIVE|EXPIRE|EXPORT|EXTEND|FALSE|FEW|FIRST|FLAT|FULL|FUNCTION|GROUP|HEADER|HEADING|HOLE|IFBLOCK|IMPORT|IN|JOINED|KEEP|KEYED|LAST|LEFT|LIMIT|LOAD|LOCAL|LOCALE|LOOKUP|MACRO|MANY|MAXCOUNT|MAXLENGTH|MIN SKEW|MODULE|INTERFACE|NAMED|NOCASE|NOROOT|NOSCAN|NOSORT|NOT|OF|ONLY|OPT|OR|OUTER|OVERWRITE|PACKED|PARTITION|PENALTY|PHYSICALLENGTH|PIPE|QUOTE|RELATIONSHIP|REPEAT|RETURN|RIGHT|SCAN|SELF|SEPARATOR|SERVICE|SHARED|SKEW|SKIP|SQL|STORE|TERMINATOR|THOR|THRESHOLD|TOKEN|TRANSFORM|TRIM|TRUE|TYPE|UNICODEORDER|UNSORTED|VALIDATE|VIRTUAL|WHOLE|WILD|WITHIN|XML|XPATH|__COMPRESSED__)\b" is(keyword.reserved)
+
+  lex(hash):
+    r"^\#.*$" is(comment.preproc)
+
+  lex(root):
+    any-of(whitespace)
+    any-of(statements)
+
+  lex(types):
+    r"(RECORD|END)\D" is(keyword.declaration)
+    r"((?:ASCII|BIG_ENDIAN|BOOLEAN|DATA|DECIMAL|EBCDIC|INTEGER|PATTERN|QSTRING|REAL|RECORD|RULE|SET OF|STRING|TOKEN|UDECIMAL|UNICODE|UNSIGNED|VARSTRING|VARUNICODE)\d*)(\s+)" is(by-groups(keyword.type, text))
+
+  lex(string):
+    r"\"" is(literal.string) -> pop
+    r"\'" is(literal.string) -> pop
+    r"[^\"\']+" is(literal.string)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/elixir.ay

@@ -0,0 +1,93 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Elixir"
+  aliases: ["elixir", "ex", "exs"]
+  extensions: [".ex", ".exs"]
+  mimetypes: ["text/x-elixir"]
+  start: .root
+  flags: 0
+
+  lex(enddoublestr):
+    any-of(interpoling)
+    r"[^\#\"]+" is(literal.string.double)
+
+  lex(interpoling-symbol):
+    r"\"" is(literal.string.symbol) -> pop
+    any-of(interpoling)
+    r"[^\#\"]+" is(literal.string.symbol)
+
+  lex(sbno-intp):
+    r".*\][a-z]*" is(literal.string.double) -> pop
+
+  lex(sbintp):
+    r"\][a-z]*" is(literal.string.double) -> pop
+    any-of(enddoublestr)
+
+  lex(interpoling-string):
+    r"}" is(literal.string.interpol) -> pop
+    any-of(root)
+
+  lex(dqs):
+    r"\"" is(literal.string.double) -> pop
+    any-of(enddoublestr)
+
+  lex(paintp):
+    r"\)[a-z]*" is(literal.string.double) -> pop
+    any-of(enddoublestr)
+
+  lex(ltintp):
+    r"\>[a-z]*" is(literal.string.double) -> pop
+    any-of(enddoublestr)
+
+  lex(cbintp):
+    r"\}[a-z]*" is(literal.string.double) -> pop
+    any-of(enddoublestr)
+
+  lex(pano-intp):
+    r".*\)[a-z]*" is(literal.string.double) -> pop
+
+  lex(interpoling):
+    r"\#{" is(literal.string.interpol) -> go-to(interpoling-string)
+
+  lex(cbno-intp):
+    r".*\}[a-z]*" is(literal.string.double) -> pop
+
+  lex(root):
+    r"\s+" is(text)
+    r"\#.*$" is(comment.single)
+    r"\b(case|cond|end|bc|lc|if|unless|try|loop|receive|fn|defmodule|defp?|defprotocol|defimpl|defrecord|defmacrop?|defdelegate|defexception|exit|raise|throw|unless|after|rescue|catch|else)\b(?![?!])|(?<!\.)\b(do|\-\>)\b\s*" is(keyword)
+    r"\b(import|require|use|recur|quote|unquote|super|refer)\b(?![?!])" is(keyword.namespace)
+    r"(?<!\.)\b(and|not|or|when|xor|in)\b" is(operator.word)
+    r"%=|\*=|\*\*=|\+=|\-=|\^=|\|\|=|<=>|<(?!<|=)|>(?!<|=|>)|<=|>=|===|==|=\126|!=|!\126|(?=[ \t])\?|(?<=[ \t])!+|&&|\|\||\^|\*|\+|\-|/|\||\+\+|\-\-|\*\*|\/\/|\<\-|\<\>|<<|>>|=|\." is(operator)
+    r"(?<!:)(:)([a-zA-Z_]\w*([?!]|=(?![>=]))?|\<\>|===?|>=?|<=?|<=>|&&?|%\(\)|%\[\]|%\{\}|\+\+?|\-\-?|\|\|?|\!|//|[%&`/\|]|\*\*?|=?\126|<\-)|([a-zA-Z_]\w*([?!])?)(:)(?!:)" is(literal.string.symbol)
+    r":\"" is(literal.string.symbol) -> go-to(interpoling-symbol)
+    r"\b(nil|true|false)\b(?![?!])|\b[A-Z]\w*\b" is(name.constant)
+    r"\b(__(FILE|LINE|MODULE|MAIN|FUNCTION)__)\b(?![?!])" is(name.builtin.pseudo)
+    r"[a-zA-Z_!][\w_]*[!\?]?" is(name)
+    r"[(){};,/\|:\\\[\]]" is(punctuation)
+    r"@[a-zA-Z_]\w*|&\d" is(name.variable)
+    r"\b(0[xX][0-9A-Fa-f]+|\d(_?\d)*(\.(?![^\d\s])(_?\d)*)?([eE][-+]?\d(_?\d)*)?|0[bB][01]+)\b" is(literal.number)
+    r"%r\/.*\/" is(literal.string.regex)
+    any-of(strings)
+
+  lex(strings):
+    r"(%[A-Ba-z])?\"\"\"(?:.|\n)*?\"\"\"" is(literal.string.doc)
+    r"'''(?:.|\n)*?'''" is(literal.string.doc)
+    r"\"" is(literal.string.double) -> go-to(dqs)
+    r"'.*'" is(literal.string.single)
+    r"(?<!\w)\?(\\(x\d{1,2}|\h{1,2}(?!\h)\b|0[0-7]{0,2}(?![0-7])\b|[^x0MC])|(\\[MC]-)+\w|[^\s\\])" is(literal.string.other)
+    r"%[a-z]\{" is(literal.string.double) -> go-to(cbintp)
+    r"%[A-Z]\{" is(literal.string.double) -> go-to(cbno-intp)
+    r"%[a-z]\[" is(literal.string.double) -> go-to(sbintp)
+    r"%[A-Z]\[" is(literal.string.double) -> go-to(sbno-intp)
+    r"%[a-z]\(" is(literal.string.double) -> go-to(paintp)
+    r"%[A-Z]\(" is(literal.string.double) -> go-to(pano-intp)
+    r"%[a-z]\<" is(literal.string.double) -> go-to(ltintp)
+    r"%[A-Z]\<" is(literal.string.double) -> go-to(ltno-intp)
+
+  lex(ltno-intp):
+    r".*\>[a-z]*" is(literal.string.double) -> pop
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/erlang.ay

@@ -0,0 +1,47 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Erlang"
+  aliases: ["erlang"]
+  extensions: [".erl", ".hrl", ".es", ".escript"]
+  mimetypes: ["text/x-erlang"]
+  start: .root
+  flags: 0
+
+  lex(root):
+    r"\s+" is(text)
+    r"%.*\n" is(comment)
+    r"(after|begin|case|catch|cond|end|fun|if|let|of|query|receive|try|when)\b" is(keyword)
+    r"(abs|append_element|apply|atom_to_list|binary_to_list|bitstring_to_list|binary_to_term|bit_size|bump_reductions|byte_size|cancel_timer|check_process_code|delete_module|demonitor|disconnect_node|display|element|erase|exit|float|float_to_list|fun_info|fun_to_list|function_exported|garbage_collect|get|get_keys|group_leader|hash|hd|integer_to_list|iolist_to_binary|iolist_size|is_atom|is_binary|is_bitstring|is_boolean|is_builtin|is_float|is_function|is_integer|is_list|is_number|is_pid|is_port|is_process_alive|is_record|is_reference|is_tuple|length|link|list_to_atom|list_to_binary|list_to_bitstring|list_to_existing_atom|list_to_float|list_to_integer|list_to_pid|list_to_tuple|load_module|localtime_to_universaltime|make_tuple|md5|md5_final|md5_update|memory|module_loaded|monitor|monitor_node|node|nodes|open_port|phash|phash2|pid_to_list|port_close|port_command|port_connect|port_control|port_call|port_info|port_to_list|process_display|process_flag|process_info|purge_module|put|read_timer|ref_to_list|register|resume_process|round|send|send_after|send_nosuspend|set_cookie|setelement|size|spawn|spawn_link|spawn_monitor|spawn_opt|split_binary|start_timer|statistics|suspend_process|system_flag|system_info|system_monitor|system_profile|term_to_binary|tl|trace|trace_delivered|trace_info|trace_pattern|trunc|tuple_size|tuple_to_list|universaltime_to_localtime|unlink|unregister|whereis)\b" is(name.builtin)
+    r"(and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\b" is(operator.word)
+    r"^-" is(punctuation) -> go-to(directive)
+    r"(\+\+?|--?|\*|/|<|>|/=|=:=|=/=|=<|>=|==?|<-|!|\?)" is(operator)
+    r"\"" is(literal.string) -> go-to(string)
+    r"<<" is(name.label)
+    r">>" is(name.label)
+    r"((?:[a-z][a-zA-Z0-9_]*|'[^\n']*[^\\]'))(:)" is(by-groups(name.namespace, punctuation))
+    r"(?:^|(?<=:))((?:[a-z][a-zA-Z0-9_]*|'[^\n']*[^\\]'))(\s*)(\()" is(by-groups(name.function, text, punctuation))
+    r"[+-]?(?:[2-9]|[12][0-9]|3[0-6])\#[0-9a-zA-Z]+" is(literal.number.integer)
+    r"[+-]?\d+" is(literal.number.integer)
+    r"[+-]?\d+.\d+" is(literal.number.float)
+    r"[\]\[:_@\\".{}()|;,]" is(punctuation)
+    r"(?:[A-Z_][a-zA-Z0-9_]*)" is(name.variable)
+    r"(?:[a-z][a-zA-Z0-9_]*|'[^\n']*[^\\]')" is(name)
+    r"\?(?:(?:[A-Z_][a-zA-Z0-9_]*)|(?:[a-z][a-zA-Z0-9_]*|'[^\n']*[^\\]'))" is(name.constant)
+    r"\$(?:(?:\\(?:[bdefnrstv\'\"\\/]|[0-7][0-7]?[0-7]?|\^[a-zA-Z]))|\\[ %]|[^\\])" is(literal.string.char)
+    r"\#(?:[a-z][a-zA-Z0-9_]*|'[^\n']*[^\\]')(:?\.(?:[a-z][a-zA-Z0-9_]*|'[^\n']*[^\\]'))?" is(name.label)
+
+  lex(string):
+    r"(?:\\(?:[bdefnrstv\'\"\\/]|[0-7][0-7]?[0-7]?|\^[a-zA-Z]))" is(literal.string.escape)
+    r"\"" is(literal.string) -> pop
+    r"\126[0-9.*]*[\126\#+bBcdefginpPswWxX]" is(literal.string.interpol)
+    r"[^\"\\\126]+" is(literal.string)
+    r"\126" is(literal.string)
+
+  lex(directive):
+    r"(define)(\s*)(\()((?:(?:[A-Z_][a-zA-Z0-9_]*)|(?:[a-z][a-zA-Z0-9_]*|'[^\n']*[^\\]')))" is(by-groups(name.entity, text, punctuation, name.constant)) -> pop
+    r"(record)(\s*)(\()((?:(?:[A-Z_][a-zA-Z0-9_]*)|(?:[a-z][a-zA-Z0-9_]*|'[^\n']*[^\\]')))" is(by-groups(name.entity, text, punctuation, name.label)) -> pop
+    r"(?:[a-z][a-zA-Z0-9_]*|'[^\n']*[^\\]')" is(name.entity) -> pop
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/factor.ay

@@ -0,0 +1,89 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Factor"
+  aliases: ["factor"]
+  extensions: [".factor"]
+  mimetypes: ["text/x-factor"]
+  start: .root
+  flags: 0
+
+  lex(stackeffect):
+    r"\s*\(" is(name.function) -> go-to(stackeffect)
+    r"\)" is(name.function) -> pop
+    r"\-\-" is(name.function)
+    r"\s+" is(text)
+    r"\S+" is(name.variable)
+
+  lex(import):
+    r";" is(keyword) -> pop
+    r"\S+" is(name.namespace)
+    r"\s+" is(text)
+
+  lex(slots):
+    r"\s+" is(text)
+    r";\s" is(keyword) -> pop
+    r"\S+" is(name.variable)
+
+  lex(root):
+    r"(\s*)(:|::|MACRO:|MEMO:)(\s+)(\S+)" is(by-groups(text, keyword, text, name.function))
+    r"(\s*)(M:)(\s+)(\S+)(\s+)(\S+)" is(by-groups(text, keyword, text, name.class, text, name.function))
+    r"(\s*)(GENERIC:)(\s+)(\S+)" is(by-groups(text, keyword, text, name.function))
+    r"(\s*)(HOOK:|GENERIC\#)(\s+)(\S+)(\s+)(\S+)" is(by-groups(text, keyword, text, name.function, text, name.function))
+    r"(\()(\s+)" is(by-groups(name.function, text)) -> go-to(stackeffect)
+    r"\;\s" is(keyword)
+    r"(USING:)((?:\s|\\\s)+)" is(by-groups(keyword.namespace, text)) -> go-to(import)
+    r"(USE:)(\s+)(\S+)" is(by-groups(keyword.namespace, text, name.namespace))
+    r"(UNUSE:)(\s+)(\S+)" is(by-groups(keyword.namespace, text, name.namespace))
+    r"(QUALIFIED:)(\s+)(\S+)" is(by-groups(keyword.namespace, text, name.namespace))
+    r"(QUALIFIED-WITH:)(\s+)(\S+)" is(by-groups(keyword.namespace, text, name.namespace))
+    r"(FROM:|EXCLUDE:)(\s+)(\S+)(\s+)(=>)" is(by-groups(keyword.namespace, text, name.namespace, text, text))
+    r"(IN:)(\s+)(\S+)" is(by-groups(keyword.namespace, text, name.namespace))
+    r"(?:ALIAS|DEFER|FORGET|POSTPONE):" is(keyword.namespace)
+    r"(TUPLE:)(\s+)(\S+)(\s+<\s+)(\S+)" is(by-groups(keyword, text, name.class, text, name.class)) -> go-to(slots)
+    r"(TUPLE:)(\s+)(\S+)" is(by-groups(keyword, text, name.class)) -> go-to(slots)
+    r"(UNION:)(\s+)(\S+)" is(by-groups(keyword, text, name.class))
+    r"(INTERSECTION:)(\s+)(\S+)" is(by-groups(keyword, text, name.class))
+    r"(PREDICATE:)(\s+)(\S+)(\s+<\s+)(\S+)" is(by-groups(keyword, text, name.class, text, name.class))
+    r"(C:)(\s+)(\S+)(\s+)(\S+)" is(by-groups(keyword, text, name.function, text, name.class))
+    r"INSTANCE:" is(keyword)
+    r"SLOT:" is(keyword)
+    r"MIXIN:" is(keyword)
+    r"(?:SINGLETON|SINGLETONS):" is(keyword)
+    r"CONSTANT:" is(keyword)
+    r"(?:SYMBOL|SYMBOLS):" is(keyword)
+    r"ERROR:" is(keyword)
+    r"SYNTAX:" is(keyword)
+    r"(HELP:)(\s+)(\S+)" is(by-groups(keyword, text, name.function))
+    r"(MAIN:)(\s+)(\S+)" is(by-groups(keyword.namespace, text, name.function))
+    r"(?:ALIEN|TYPEDEF|FUNCTION|STRUCT):" is(keyword)
+    r"(?:<PRIVATE|PRIVATE>)" is(keyword.namespace)
+    r"\"\"\"\s+(?:.|\n)*?\s+\"\"\"" is(literal.string)
+    r"\"(?:\\\\|\\\"|[^\"])*\"" is(literal.string)
+    r"CHAR:\s+(\\[\\abfnrstv]*|\S)\s" is(literal.string.char)
+    r"\!\s+.*$" is(comment)
+    r"\#\!\s+.*$" is(comment)
+    r"(t|f)\s" is(name.constant)
+    r"-?\d+\.\d+\s" is(literal.number.float)
+    r"-?\d+\s" is(literal.number.integer)
+    r"HEX:\s+[a-fA-F\d]+\s" is(literal.number.hex)
+    r"BIN:\s+[01]+\s" is(literal.number.integer)
+    r"OCT:\s+[0-7]+\s" is(literal.number.oct)
+    r"[-+/*=<>^]\s" is(operator)
+    r"(?:deprecated|final|foldable|flushable|inline|recursive)\s" is(keyword)
+    r"(?:or|2bi|2tri|while|wrapper|nip|4dip|wrapper\\?|bi\\*|callstack>array|both\\?|hashcode|die|dupd|callstack|callstack\\?|3dup|tri@|pick|curry|build|\\?execute|3bi|prepose|>boolean|\\?if|clone|eq\\?|tri\\*|\\?|=|swapd|2over|2keep|3keep|clear|2dup|when|not|tuple\\?|dup|2bi\\*|2tri\\*|call|tri-curry|object|bi@|do|unless\\*|if\\*|loop|bi-curry\\*|drop|when\\*|assert=|retainstack|assert\\?|-rot|execute|2bi@|2tri@|boa|with|either\\?|3drop|bi|curry\\?|datastack|until|3dip|over|3curry|tri-curry\\*|tri-curry@|swap|and|2nip|throw|bi-curry|\\(clone\\)|hashcode\\*|compose|2dip|if|3tri|unless|compose\\?|tuple|keep|2curry|equal\\?|assert|tri|2drop|most|<wrapper>|boolean\\?|identity-hashcode|identity-tuple\\?|null|new|dip|bi-curry@|rot|xor|identity-tuple|boolean)\s" is(name.builtin)
+    r"(?:\\?at|assoc\\?|assoc-clone-like|assoc=|delete-at\\*|assoc-partition|extract-keys|new-assoc|value\\?|assoc-size|map>assoc|push-at|assoc-like|key\\?|assoc-intersect|assoc-refine|update|assoc-union|assoc-combine|at\\*|assoc-empty\\?|at\\+|set-at|assoc-all\\?|assoc-subset\\?|assoc-hashcode|change-at|assoc-each|assoc-diff|zip|values|value-at|rename-at|inc-at|enum\\?|at|cache|assoc>map|<enum>|assoc|assoc-map|enum|value-at\\*|assoc-map-as|>alist|assoc-filter-as|clear-assoc|assoc-stack|maybe-set-at|substitute|assoc-filter|2cache|delete-at|assoc-find|keys|assoc-any\\?|unzip)\s" is(name.builtin)
+    r"(?:case|execute-effect|no-cond|no-case\\?|3cleave>quot|2cleave|cond>quot|wrong-values\\?|no-cond\\?|cleave>quot|no-case|case>quot|3cleave|wrong-values|to-fixed-point|alist>quot|case-find|cond|cleave|call-effect|2cleave>quot|recursive-hashcode|linear-case-quot|spread|spread>quot)\s" is(name.builtin)
+    r"(?:number=|if-zero|next-power-of-2|each-integer|\\?1\\+|fp-special\\?|imaginary-part|unless-zero|float>bits|number\\?|fp-infinity\\?|bignum\\?|fp-snan\\?|denominator|fp-bitwise=|\\*|\\+|power-of-2\\?|-|u>=|/|>=|bitand|log2-expects-positive|<|log2|>|integer\\?|number|bits>double|2/|zero\\?|(find-integer)|bits>float|float\\?|shift|ratio\\?|even\\?|ratio|fp-sign|bitnot|>fixnum|complex\\?|/i|/f|byte-array>bignum|when-zero|sgn|>bignum|next-float|u<|u>|mod|recip|rational|find-last-integer|>float|(all-integers\\?)|2^|times|integer|fixnum\\?|neg|fixnum|sq|bignum|(each-integer)|bit\\?|fp-qnan\\?|find-integer|complex|<fp-nan>|real|double>bits|bitor|rem|fp-nan-payload|all-integers\\?|real-part|log2-expects-positive\\?|prev-float|align|unordered\\?|float|fp-nan\\?|abs|bitxor|u<=|odd\\?|<=|/mod|rational\\?|>integer|real\\?|numerator)\s" is(name.builtin)
+    r"(?:member-eq\\?|append|assert-sequence=|find-last-from|trim-head-slice|clone-like|3sequence|assert-sequence\\?|map-as|last-index-from|reversed|index-from|cut\\*|pad-tail|remove-eq!|concat-as|but-last|snip|trim-tail|nths|nth|2selector|sequence|slice\\?|<slice>|partition|remove-nth|tail-slice|empty\\?|tail\\*|if-empty|find-from|virtual-sequence\\?|member\\?|set-length|drop-prefix|unclip|unclip-last-slice|iota|map-sum|bounds-error\\?|sequence-hashcode-step|selector-for|accumulate-as|map|start|midpoint@|\\(accumulate\\)|rest-slice|prepend|fourth|sift|accumulate!|new-sequence|follow|map!|like|first4|1sequence|reverse|slice|unless-empty|padding|virtual@|repetition\\?|set-last|index|4sequence|max-length|set-second|immutable-sequence|first2|first3|replicate-as|reduce-index|unclip-slice|supremum|suffix!|insert-nth|trim-tail-slice|tail|3append|short|count|suffix|concat|flip|filter|sum|immutable\\?|reverse!|2sequence|map-integers|delete-all|start\\*|indices|snip-slice|check-slice|sequence\\?|head|map-find|filter!|append-as|reduce|sequence=|halves|collapse-slice|interleave|2map|filter-as|binary-reduce|slice-error\\?|product|bounds-check\\?|bounds-check|harvest|immutable|virtual-exemplar|find|produce|remove|pad-head|last|replicate|set-fourth|remove-eq|shorten|reversed\\?|map-find-last|3map-as|2unclip-slice|shorter\\?|3map|find-last|head-slice|pop\\*|2map-as|tail-slice\\*|but-last-slice|2map-reduce|iota\\?|collector-for|accumulate|each|selector|append!|new-resizable|cut-slice|each-index|head-slice\\*|2reverse-each|sequence-hashcode|pop|set-nth|\\?nth|<flat-slice>|second|join|when-empty|collector|immutable-sequence\\?|<reversed>|all\\?|3append-as|virtual-sequence|subseq\\?|remove-nth!|push-either|new-like|length|last-index|push-if|2all\\?|lengthen|assert-sequence|copy|map-reduce|move|third|first|3each|tail\\?|set-first|prefix|bounds-error|any\\?|<repetition>|trim-slice|exchange|surround|2reduce|cut|change-nth|min-length|set-third|produce-as|push-all|head\\?|delete-slice|rest|sum-lengths|2each|head\\*|infimum|remove!|glue|slice-error|subseq|trim|replace-slice|push|repetition|map-index|trim-head|unclip-last|mismatch)\s" is(name.builtin)
+    r"(?:global|\\+@|change|set-namestack|change-global|init-namespaces|on|off|set-global|namespace|set|with-scope|bind|with-variable|inc|dec|counter|initialize|namestack|get|get-global|make-assoc)\s" is(name.builtin)
+    r"(?:<array>|2array|3array|pair|>array|1array|4array|pair\\?|array|resize-array|array\\?)\s" is(name.builtin)
+    r"(?:\\+character\\+|bad-seek-type\\?|readln|each-morsel|stream-seek|read|print|with-output-stream|contents|write1|stream-write1|stream-copy|stream-element-type|with-input-stream|stream-print|stream-read|stream-contents|stream-tell|tell-output|bl|seek-output|bad-seek-type|nl|stream-nl|write|flush|stream-lines|\\+byte\\+|stream-flush|read1|seek-absolute\\?|stream-read1|lines|stream-readln|stream-read-until|each-line|seek-end|with-output-stream\\*|seek-absolute|with-streams|seek-input|seek-relative\\?|input-stream|stream-write|read-partial|seek-end\\?|seek-relative|error-stream|read-until|with-input-stream\\*|with-streams\\*|tell-input|each-block|output-stream|stream-read-partial|each-stream-block|each-stream-line)\s" is(name.builtin)
+    r"(?:resize-string|>string|<string>|1string|string|string\\?)\s" is(name.builtin)
+    r"(?:vector\\?|<vector>|\\?push|vector|>vector|1vector)\s" is(name.builtin)
+    r"(?:with-return|restarts|return-continuation|with-datastack|recover|rethrow-restarts|<restart>|ifcc|set-catchstack|>continuation<|cleanup|ignore-errors|restart\\?|compute-restarts|attempt-all-error|error-thread|continue|<continuation>|attempt-all-error\\?|condition\\?|<condition>|throw-restarts|error|catchstack|continue-with|thread-error-hook|continuation|rethrow|callcc1|error-continuation|callcc0|attempt-all|condition|continuation\\?|restart|return)\s" is(name.builtin)
+    r"\s+" is(text)
+    r"\S+" is(text)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/fancy.ay

@@ -0,0 +1,54 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Fancy"
+  aliases: ["fancy", "fy"]
+  extensions: [".fy", ".fancypack"]
+  mimetypes: ["text/x-fancysrc"]
+  start: .root
+  flags: 0
+
+  lex(root):
+    r"\s+" is(text)
+    r"s{(\\\\|\\}|[^}])*}\s*" is(literal.string.regex) -> go-to(balanced-regex)
+    r"s<(\\\\|\\>|[^>])*>\s*" is(literal.string.regex) -> go-to(balanced-regex)
+    r"s\[(\\\\|\\\]|[^\]])*\]\s*" is(literal.string.regex) -> go-to(balanced-regex)
+    r"s\((\\\\|\\\)|[^\)])*\)\s*" is(literal.string.regex) -> go-to(balanced-regex)
+    r"m?/(\\\\|\\/|[^/\n])*/[gcimosx]*" is(literal.string.regex)
+    r"m(?=[/!\\{<\[\(@%\$])" is(literal.string.regex) -> go-to(balanced-regex)
+    r"\#(.*?)\n" is(comment.single)
+    r"\'([^\'\s\[\]\(\)\{\}]+|\[\])" is(literal.string.symbol)
+    r"\"\"\"(\\\\|\\\"|[^\"])*\"\"\"" is(literal.string)
+    r"\"(\\\\|\\\"|[^\"])*\"" is(literal.string)
+    r"(def|class|try|catch|finally|retry|return|return_local|match|case|->|=>)\b" is(keyword)
+    r"(self|super|nil|false|true)\b" is(name.constant)
+    r"[(){};,/?\|:\\]" is(punctuation)
+    r"(Object|Array|Hash|Directory|File|Class|String|Number|Enumerable|FancyEnumerable|Block|TrueClass|NilClass|FalseClass|Tuple|Symbol|Stack|Set|FancySpec|Method|Package|Range)\b" is(name.builtin)
+    r"[a-zA-Z]([a-zA-Z0-9_]|[-+?!=*/^><%])*:" is(name.function)
+    r"[-+*/\126,<>=&!?%^\[\]\.$]+" is(operator)
+    r"[A-Z][a-zA-Z0-9_]*" is(name.constant)
+    r"@[a-zA-Z_][a-zA-Z0-9_]*" is(name.variable.instance)
+    r"@@[a-zA-Z_][a-zA-Z0-9_]*" is(name.variable.class)
+    r"@@?" is(operator)
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name)
+    r"(0[oO]?[0-7]+(?:_[0-7]+)*)(\s*)([/?])?" is(by-groups(literal.number.oct, text, operator))
+    r"(0[xX][0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*)(\s*)([/?])?" is(by-groups(literal.number.hex, text, operator))
+    r"(0[bB][01]+(?:_[01]+)*)(\s*)([/?])?" is(by-groups(literal.number.bin, text, operator))
+    r"([\d]+(?:_\d+)*)(\s*)([/?])?" is(by-groups(literal.number.integer, text, operator))
+    r"\d+([eE][+-]?[0-9]+)|\d+\.\d+([eE][+-]?[0-9]+)?" is(literal.number.float)
+    r"\d+" is(literal.number.integer)
+
+  lex(balanced-regex):
+    r"/(\\\\|\\/|[^/])*/[egimosx]*" is(literal.string.regex) -> pop
+    r"!(\\\\|\\!|[^!])*![egimosx]*" is(literal.string.regex) -> pop
+    r"\\(\\\\|[^\\])*\\[egimosx]*" is(literal.string.regex) -> pop
+    r"{(\\\\|\\}|[^}])*}[egimosx]*" is(literal.string.regex) -> pop
+    r"<(\\\\|\\>|[^>])*>[egimosx]*" is(literal.string.regex) -> pop
+    r"\[(\\\\|\\\]|[^\]])*\][egimosx]*" is(literal.string.regex) -> pop
+    r"\((\\\\|\\\)|[^\)])*\)[egimosx]*" is(literal.string.regex) -> pop
+    r"@(\\\\|\\\@|[^\@])*@[egimosx]*" is(literal.string.regex) -> pop
+    r"%(\\\\|\\\%|[^\%])*%[egimosx]*" is(literal.string.regex) -> pop
+    r"\$(\\\\|\\\$|[^\$])*\$[egimosx]*" is(literal.string.regex) -> pop
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/fantom.ay

@@ -0,0 +1,149 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Fantom"
+  aliases: ["fan"]
+  extensions: [".fan"]
+  mimetypes: ["application/x-fantom"]
+  start: .root
+  flags: 0
+
+  lex(inheritance):
+    r"\s+" is(text)
+    r":|," is(punctuation)
+    r"(?:(\w+)(::))?(\w+)" is(by-groups(name.namespace, punctuation, name.class))
+    r"{" is(punctuation) -> pop
+
+  lex(facet):
+    r"\s+" is(text)
+    r"{" is(punctuation) -> go-to(facetFields)
+    r"" is(text) -> pop
+
+  lex(insideUri):
+    r"\\\\" is(literal.string.escape)
+    r"\\\"" is(literal.string.escape)
+    r"\\`" is(literal.string.escape)
+    r"\$\w+" is(literal.string.interpol)
+    r"\${.*?}" is(literal.string.interpol)
+    r"`" is(punctuation) -> pop
+    r"." is(literal.string.backtick)
+
+  lex(literals):
+    r"\b-?[\d_]+(ns|ms|sec|min|hr|day)" is(literal.number)
+    r"\b-?[\d_]*\.[\d_]+(ns|ms|sec|min|hr|day)" is(literal.number)
+    r"\b-?(\d+)?\.\d+(f|F|d|D)?" is(literal.number.float)
+    r"\b-?0x[0-9a-fA-F_]+" is(literal.number.hex)
+    r"\b-?[\d_]+" is(literal.number.integer)
+    r"'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'" is(literal.string.char)
+    r"\"" is(punctuation) -> go-to(insideStr)
+    r"`" is(punctuation) -> go-to(insideUri)
+    r"\b(true|false|null)\b" is(keyword.constant)
+    r"(?:(\w+)(::))?(\w+)(<\|)(.*?)(\|>)" is(by-groups(name.namespace, punctuation, name.class, punctuation, literal.string, punctuation))
+    r"(?:(\w+)(::))?(\w+)?(\#)(\w+)?" is(by-groups(name.namespace, punctuation, name.class, punctuation, name.function))
+    r"\[,\]" is(literal)
+    r"((?:\[|[a-zA-Z_]|\|)[:\w\[\]\|\->\?]*?)(\[,\])" is(by-groups(using(self class), literal))
+    r"\[:\]" is(literal)
+    r"((?:\[|[a-zA-Z_]|\|)[:\w\[\]\|\->\?]*?)(\[:\])" is(by-groups(using(self class), literal))
+
+  lex(methodKeywords):
+    r"\b(abstract|native|once|override|static|virtual|final)\b" is(keyword)
+
+  lex(using):
+    r"[ \t]+" is(text)
+    r"(\[)(\w+)(\])" is(by-groups(punctuation, comment.special, punctuation))
+    r"(\\")?([\w\.]+)(\\")?" is(by-groups(punctuation, name.namespace, punctuation))
+    r"::" is(punctuation) -> go-to(usingClass)
+    r"" is(text) -> pop
+
+  lex(protectionKeywords):
+    r"\b(public|protected|private|internal)\b" is(keyword)
+
+  lex(insideStr):
+    r"\\\\" is(literal.string.escape)
+    r"\\\"" is(literal.string.escape)
+    r"\\`" is(literal.string.escape)
+    r"\$\w+" is(literal.string.interpol)
+    r"\${.*?}" is(literal.string.interpol)
+    r"\"" is(punctuation) -> pop
+    r"." is(literal.string)
+
+  lex(operators):
+    r"\+\+|\-\-|\+|\-|\*|/|\|\||&&|<=>|<=|<|>=|>|=|!|\[|\]" is(operator)
+
+  lex(inType):
+    r"[\[\]\|\->:\?]" is(punctuation)
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name.class)
+    r"" is(text) -> pop
+
+  lex(facetFields):
+    any-of(comments)
+    any-of(literals)
+    any-of(operators)
+    r"\s+" is(text)
+    r"(\s*)(\w+)(\s*)(=)" is(by-groups(text, name, text, operator))
+    r"}" is(punctuation) -> pop
+    r"." is(text)
+
+  lex(comments):
+    r"(?m)/\*.*?\*/" is(comment.multiline)
+    r"//.*?\n" is(comment.single)
+    r"\*\*.*?\n" is(comment.special)
+    r"\#.*\n" is(comment.single)
+
+  lex(insideMethodDeclArgs):
+    r"\)" is(punctuation) -> pop
+    r"((?:\[|[a-zA-Z_]|\|)[:\w\[\]\|\->\?]*?)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\))" is(by-groups(using(self class), text, name.variable, text, punctuation)) -> pop
+    any-of(root)
+
+  lex(usingClass):
+    r"[ \t]+" is(text)
+    r"(as)(\s+)(\w+)" is(by-groups(keyword.declaration, text, name.class)) -> pop(2)
+    r"[\w\$]+" is(name.class)
+    r"" is(text) -> pop(2)
+
+  lex(typeKeywords):
+    r"\b(abstract|final|const|native|facet|enum)\b" is(keyword)
+
+  lex(insideBrace):
+    r"\}" is(punctuation) -> pop
+    any-of(root)
+
+  lex(otherKeywords):
+    r"\b(try|catch|throw|finally|for|if|else|while|as|is|isnot|switch|case|default|continue|break|do|return|get|set)\b" is(keyword)
+    r"\b(it|this|super)\b" is(name.builtin.pseudo)
+
+  lex(fieldKeywords):
+    r"\b(abstract|const|final|native|override|static|virtual|readonly)\b" is(keyword)
+
+  lex(insideParen):
+    r"\)" is(punctuation) -> pop
+    any-of(root)
+
+  lex(root):
+    any-of(comments)
+    any-of(protectionKeywords)
+    any-of(typeKeywords)
+    any-of(methodKeywords)
+    any-of(fieldKeywords)
+    any-of(literals)
+    any-of(otherKeywords)
+    any-of(operators)
+    r"using\b" is(keyword.namespace) -> go-to(using)
+    r"@\w+" is(name.decorator) -> go-to(facet)
+    r"(class|mixin)(\s+)(\w+)" is(by-groups(keyword, text, name.class)) -> go-to(inheritance)
+    r"((?:\[|[a-zA-Z_]|\|)[:\w\[\]\|\->\?]*?)([ \t]+)([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(:=)" is(by-groups(using(self class), text, name.variable, text, operator))
+    r"([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(:=)" is(by-groups(name.variable, text, operator))
+    r"(\.|(?:\->))([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\()" is(by-groups(operator, name.function, text, punctuation)) -> go-to(insideParen)
+    r"(\.|(?:\->))([a-zA-Z_][a-zA-Z0-9_]*)" is(by-groups(operator, name.function))
+    r"(new)(\s+)(make\w*)(\s*)(\()" is(by-groups(keyword, text, name.function, text, punctuation)) -> go-to(insideMethodDeclArgs)
+    r"((?:\[|[a-zA-Z_]|\|)[:\w\[\]\|\->\?]*?)([ \t]+)([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\()" is(by-groups(using(self class), text, name.function, text, punctuation)) -> go-to(insideMethodDeclArgs)
+    r"((?:\[|[a-zA-Z_]|\|)[:\w\[\]\|\->\?]*?)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(,)" is(by-groups(using(self class), text, name.variable, text, punctuation))
+    r"((?:\[|[a-zA-Z_]|\|)[:\w\[\]\|\->\?]*?)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\->)(\s*)((?:\[|[a-zA-Z_]|\|)[:\w\[\]\|\->\?]*?)(\|)" is(by-groups(using(self class), text, name.variable, text, punctuation, text, using(self class), punctuation))
+    r"((?:\[|[a-zA-Z_]|\|)[:\w\[\]\|\->\?]*?)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\|)" is(by-groups(using(self class), text, name.variable, text, punctuation))
+    r"((?:\[|[a-zA-Z_]|\|)[:\w\[\]\|\->\?]*?)([ \t]+)([a-zA-Z_][a-zA-Z0-9_]*)" is(by-groups(using(self class), text, name.variable))
+    r"\(" is(punctuation) -> go-to(insideParen)
+    r"\{" is(punctuation) -> go-to(insideBrace)
+    r"." is(text)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/felix.ay

@@ -0,0 +1,140 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Felix"
+  aliases: ["felix", "flx"]
+  extensions: [".flx", ".flxh"]
+  mimetypes: ["text/x-felix"]
+  start: .root
+  flags: 0
+
+  lex(comment):
+    r"//(.*?)\n" is(comment.single)
+    r"/[*]" is(comment.multiline) -> go-to(comment2)
+
+  lex(modulename2):
+    any-of(whitespace)
+    r"([a-zA-Z_]\w*)" is(name.namespace) -> pop(2)
+
+  lex(modulename):
+    any-of(whitespace)
+    r"\[" is(punctuation) -> do-all(go-to(modulename2), go-to(tvarlist))
+    r"" is(error) -> go-to(modulename2)
+
+  lex(if0):
+    r"^\s*\#if.*?(?<!\\)\n" is(comment) -> push
+    r"^\s*\#endif.*?(?<!\\)\n" is(comment) -> pop
+    r".*?\n" is(comment)
+
+  lex(whitespace):
+    r"\n" is(text)
+    r"\s+" is(text)
+    any-of(comment)
+    r"\#\s*if\s+0" is(comment.preproc) -> go-to(if0)
+    r"\#" is(comment.preproc) -> go-to(macro)
+
+  lex(dqs):
+    r"\"" is(literal.string) -> pop
+    r"\\\\|\\\"|\\\n" is(literal.string.escape)
+    any-of(strings)
+
+  lex(sqs):
+    r"'" is(literal.string) -> pop
+    r"\\\\|\\'|\\\n" is(literal.string.escape)
+    any-of(strings)
+
+  lex(macro):
+    any-of(comment)
+    r"(import|include)(\s+)(<[^>]*?>)" is(by-groups(comment.preproc, text, literal.string)) -> pop
+    r"(import|include)(\s+)(\"[^\"]*?\")" is(by-groups(comment.preproc, text, literal.string)) -> pop
+    r"(import|include)(\s+)('[^']*?')" is(by-groups(comment.preproc, text, literal.string)) -> pop
+    r"[^/\n]+" is(comment.preproc)
+    r"/" is(comment.preproc)
+    r"(?<=\\)\n" is(comment.preproc)
+    r"\n" is(comment.preproc) -> pop
+
+  lex(operators):
+    r"(and|not|in|is|isin|or|xor)\b" is(operator.word)
+    r"!=|==|<<|>>|\|\||&&|[-\126+/*%=<>&^|.$]" is(operator)
+
+  lex(tsqs):
+    r"'''" is(literal.string) -> pop
+    any-of(strings)
+    any-of(nl)
+
+  lex(comment2):
+    r"[^\/*]" is(comment.multiline)
+    r"/[*]" is(comment.multiline) -> push
+    r"[*]/" is(comment.multiline) -> pop
+    r"[\/*]" is(comment.multiline)
+
+  lex(classname):
+    any-of(whitespace)
+    r"[a-zA-Z_]\w*" is(name.class) -> pop
+    r"(?=\{)" is(text) -> pop
+
+  lex(stringescape):
+    r"\\([\\abfnrtv\"\']|\n|N{.*?}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})" is(literal.string.escape)
+
+  lex(tdqs):
+    r"\"\"\"" is(literal.string) -> pop
+    any-of(strings)
+    any-of(nl)
+
+  lex(nl):
+    r"\n" is(literal.string)
+
+  lex(funcname):
+    any-of(whitespace)
+    r"[a-zA-Z_]\w*" is(name.function) -> pop
+    r"(?=\()" is(text) -> pop
+
+  lex(root):
+    any-of(whitespace)
+    r"(axiom|ctor|fun|gen|proc|reduce|union)\b" is(keyword) -> go-to(funcname)
+    r"(class|cclass|cstruct|obj|struct)\b" is(keyword) -> go-to(classname)
+    r"(instance|module|typeclass)\b" is(keyword) -> go-to(modulename)
+    r"(_|_deref|all|as|assert|attempt|call|callback|case|caseno|cclass|code|compound|ctypes|do|done|downto|elif|else|endattempt|endcase|endif|endmatch|enum|except|exceptions|expect|finally|for|forall|forget|fork|functor|goto|ident|if|incomplete|inherit|instance|interface|jump|lambda|loop|match|module|namespace|new|noexpand|nonterm|obj|of|open|parse|raise|regexp|reglex|regmatch|rename|return|the|then|to|type|typecase|typedef|typematch|typeof|upto|when|whilst|with|yield)\b" is(keyword)
+    r"(_gc_pointer|_gc_type|body|comment|const|export|header|inline|lval|macro|noinline|noreturn|package|private|pod|property|public|publish|requires|todo|virtual|use)\b" is(name.decorator)
+    r"(def|let|ref|val|var)\b" is(keyword.declaration)
+    r"(unit|void|any|bool|byte|offset|address|caddress|cvaddress|vaddress|tiny|short|int|long|vlong|utiny|ushort|vshort|uint|ulong|uvlong|int8|int16|int32|int64|uint8|uint16|uint32|uint64|float|double|ldouble|complex|dcomplex|lcomplex|imaginary|dimaginary|limaginary|char|wchar|uchar|charp|charcp|ucharp|ucharcp|string|wstring|ustring|cont|array|varray|list|lvalue|opt|slice)\b" is(keyword.type)
+    r"(false|true)\b" is(keyword.constant)
+    any-of(operators)
+    r"0[xX]([0-9a-fA-F_]*\.[0-9a-fA-F_]+|[0-9a-fA-F_]+)[pP][+\-]?[0-9_]+[lLfFdD]?" is(literal.number.float)
+    r"[0-9_]+(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*|[eE][+\-]?[0-9_]+)[lLfFdD]?" is(literal.number.float)
+    r"\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[lLfFdD]?" is(literal.number.float)
+    r"0[Bb][01_]+([tTsSiIlLvV]|ll|LL|([iIuU])(8|16|32|64))?" is(literal.number)
+    r"0[0-7_]+([tTsSiIlLvV]|ll|LL|([iIuU])(8|16|32|64))?" is(literal.number.oct)
+    r"0[xX][0-9a-fA-F_]+([tTsSiIlLvV]|ll|LL|([iIuU])(8|16|32|64))?" is(literal.number.hex)
+    r"(0|[1-9][0-9_]*)([tTsSiIlLvV]|ll|LL|([iIuU])(8|16|32|64))?" is(literal.number.integer)
+    r"([rR][cC]?|[cC][rR])\"\"\"" is(literal.string) -> go-to(tdqs)
+    r"([rR][cC]?|[cC][rR])'''" is(literal.string) -> go-to(tsqs)
+    r"([rR][cC]?|[cC][rR])\"" is(literal.string) -> go-to(dqs)
+    r"([rR][cC]?|[cC][rR])'" is(literal.string) -> go-to(sqs)
+    r"[cCfFqQwWuU]?\"\"\"" is(literal.string) -> combined(stringescape, tdqs)
+    r"[cCfFqQwWuU]?'''" is(literal.string) -> combined(stringescape, tsqs)
+    r"[cCfFqQwWuU]?\"" is(literal.string) -> combined(stringescape, dqs)
+    r"[cCfFqQwWuU]?'" is(literal.string) -> combined(stringescape, sqs)
+    r"[\[\]{}:(),;?]" is(punctuation)
+    r"[a-zA-Z_]\w*:>" is(name.label)
+    r"(_svc|while)\b" is(name.builtin)
+    r"(root|self|this)\b" is(name.builtin.pseudo)
+    r"[a-zA-Z_]\w*" is(name)
+
+  lex(strings):
+    r"%(\([a-zA-Z0-9]+\))?[-\#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[diouxXeEfFgGcrs%]" is(literal.string.interpol)
+    r"[^\\\'\"%\n]+" is(literal.string)
+    r"[\'\"\\]" is(literal.string)
+    r"%" is(literal.string)
+
+  lex(tvarlist):
+    any-of(whitespace)
+    any-of(operators)
+    r"\[" is(punctuation) -> push
+    r"\]" is(punctuation) -> pop
+    r"," is(punctuation)
+    r"(with|where)\b" is(keyword)
+    r"[a-zA-Z_]\w*" is(name)
+
+const-set(.Lexer, lexer)