broomhlda 0.1.0

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

@@ -0,0 +1,33 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "MoinMoin/Trac Wiki markup"
+  aliases: ["trac-wiki", "moin"]
+  extensions: []
+  mimetypes: ["text/x-trac-wiki"]
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(root):
+    r"^\#.*$" is(comment)
+    r"(!)(\S+)" is(by-groups(keyword, text))
+    r"^(=+)([^=]+)(=+)(\s*\#.+)?$" is(by-groups(generic.heading, using(self class), generic.heading, literal.string))
+    r"({{{)(\n\#!.+)?" is(by-groups(name.builtin, name.namespace)) -> go-to(codeblock)
+    r"(\'\'\'?|\|\||`|__|\126\126|\^|,,|::)" is(comment)
+    r"^( +)([.*-])( )" is(by-groups(text, name.builtin, text))
+    r"^( +)([a-z]{1,5}\.)( )" is(by-groups(text, name.builtin, text))
+    r"\[\[\w+.*?\]\]" is(keyword)
+    r"(\[[^\s\]]+)(\s+[^\]]+?)?(\])" is(by-groups(keyword, literal.string, keyword))
+    r"^----+$" is(keyword)
+    r"[^\n\'\[{!_\126^,|]+" is(text)
+    r"\n" is(text)
+    r"." is(text)
+
+  lex(codeblock):
+    r"}}}" is(name.builtin) -> pop
+    r"{{{" is(text) -> push
+    r"[^{}]+" is(comment.preproc)
+    r"." is(comment.preproc)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,84 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Monkey"
+  aliases: ["monkey"]
+  extensions: [".monkey"]
+  mimetypes: ["text/x-monkey"]
+  start: .root
+  flags: 0
+
+  lex(comment):
+    r"(?i)^\#rem.*?" is(comment.multiline) -> push
+    r"(?i)^\#end.*?" is(comment.multiline) -> pop
+    r"\n" is(comment.multiline)
+    r".+" is(comment.multiline)
+
+  lex(string):
+    r"[^\"\126]+" is(literal.string.double)
+    r"\126q|\126n|\126r|\126t|\126z|\126\126" is(literal.string.escape)
+    r"\"" is(literal.string.double) -> pop
+
+  lex(variables):
+    r"[A-Z_][A-Z0-9_]*\b" is(name.constant)
+    r"[a-z_][a-zA-Z0-9_]*\b" is(name.variable)
+    r"[?%\#$]" is(keyword.type)
+    r"\s+" is(text)
+    r":" is(punctuation) -> go-to(classname)
+    r"," is(punctuation) -> push
+    r"" is(text) -> pop
+
+  lex(funcname):
+    r"(?i)[A-Z][a-zA-Z0-9_]*\b" is(name.function)
+    r":" is(punctuation) -> go-to(classname)
+    r"\s+" is(text)
+    r"\(" is(punctuation) -> go-to(variables)
+    r"\)" is(punctuation) -> pop
+
+  lex(classname):
+    r"[a-z0-9_]*\." is(name.namespace)
+    r"(?:Int|Float|String|Bool|Object|Array|Void)\b" is(keyword.type)
+    r"[A-Z][a-zA-Z0-9_]*\b" is(name.class)
+    r"(\[)(\s*)(\d*)(\s*)(\])" is(by-groups(punctuation, text, literal.number.integer, text, punctuation))
+    r"\s+(?!<)" is(text) -> pop
+    r"<" is(punctuation) -> push
+    r">" is(punctuation) -> pop
+    r"\n" is(text) -> pop
+    r"" is(text) -> pop
+
+  lex(root):
+    r"\s+" is(text)
+    r"'.*" is(comment)
+    r"(?i)^\#rem\b" is(comment.multiline) -> go-to(comment)
+    r"(?i)^(?:\#If|\#ElseIf|\#Else|\#EndIf|\#End|\#Print|\#Error)\b" is(comment.preproc)
+    r"^\#" is(comment.preproc) -> go-to(variables)
+    r"\"" is(literal.string.double) -> go-to(string)
+    r"[0-9]+\.[0-9]*(?!\.)" is(literal.number.float)
+    r"\.[0-9]+(?!\.)" is(literal.number.float)
+    r"[0-9]+" is(literal.number.integer)
+    r"\$[0-9a-fA-Z]+" is(literal.number.hex)
+    r"\%[10]+" is(literal.number)
+    r"\b(?:Int|Float|String|Bool|Object|Array|Void)\b" is(keyword.type)
+    r"(?i)\b(?:Try|Catch|Throw)\b" is(keyword.reserved)
+    r"Throwable" is(name.exception)
+    r"(?i)\b(?:Null|True|False)\b" is(name.builtin)
+    r"(?i)\b(?:Self|Super)\b" is(name.builtin.pseudo)
+    r"\b(?:HOST|LANG|TARGET|CONFIG)\b" is(name.constant)
+    r"(?i)^(Import)(\s+)(.*)(\n)" is(by-groups(keyword.namespace, text, name.namespace, text))
+    r"(?i)^Strict\b.*\n" is(keyword.reserved)
+    r"(?i)(Const|Local|Global|Field)(\s+)" is(by-groups(keyword.declaration, text)) -> go-to(variables)
+    r"(?i)(New|Class|Interface|Extends|Implements)(\s+)" is(by-groups(keyword.reserved, text)) -> go-to(classname)
+    r"(?i)(Function|Method)(\s+)" is(by-groups(keyword.reserved, text)) -> go-to(funcname)
+    r"(?i)(?:End|Return|Public|Private|Extern|Property|Final|Abstract)\b" is(keyword.reserved)
+    r"(?i)(?:If|Then|Else|ElseIf|EndIf|Select|Case|Default|While|Wend|Repeat|Until|Forever|For|To|Until|Step|EachIn|Next|Exit|Continue)\s+" is(keyword.reserved)
+    r"(?i)\b(?:Module|Inline)\b" is(keyword.reserved)
+    r"[\[\]]" is(punctuation)
+    r"<=|>=|<>|\*=|/=|\+=|-=|&=|\126=|\|=|[-&*/^+=<>|\126]" is(operator)
+    r"(?i)(?:Not|Mod|Shl|Shr|And|Or)" is(operator.word)
+    r"[\(\){}!\#,.:]" is(punctuation)
+    r"[A-Z_][A-Z0-9_]*\b" is(name.constant)
+    r"[A-Z][a-zA-Z0-9_]*\b" is(name.function)
+    r"[a-z_][a-zA-Z0-9_]*\b" is(name.variable)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,26 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "MOOCode"
+  aliases: ["moocode"]
+  extensions: [".moo"]
+  mimetypes: ["text/x-moocode"]
+  start: .root
+  flags: 0
+
+  lex(root):
+    r"(0|[1-9][0-9_]*)" is(literal.number.integer)
+    r"\"(\\\\|\\\"|[^\"])*\"" is(literal.string)
+    r"(E_PERM|E_DIV)" is(name.exception)
+    r"((\#[-0-9]+)|(\$[a-z_A-Z0-9]+))" is(name.entity)
+    r"\b(if|else|elseif|endif|for|endfor|fork|endfork|while|endwhile|break|continue|return|try|except|endtry|finally|in)\b" is(keyword)
+    r"(random|length)" is(name.builtin)
+    r"(player|caller|this|args)" is(name.variable.instance)
+    r"\s+" is(text)
+    r"\n" is(text)
+    r"([!;=,{}&\|:\.\[\]@\(\)\<\>\?]+)" is(operator)
+    r"([a-z_A-Z0-9]+)(\()" is(by-groups(name.function, operator))
+    r"([a-zA-Z_0-9]+)" is(text)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,52 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "MoonScript"
+  aliases: ["moon", "moonscript"]
+  extensions: [".moon"]
+  mimetypes: ["text/x-moonscript", "application/x-moonscript"]
+  start: .root
+  flags: 0
+
+  lex(sqs):
+    r"'" is(literal.string.single) -> pop
+    r"." is(literal.string)
+
+  lex(stringescape):
+    r"\\([abfnrtv\\\"']|\d{1,3})" is(literal.string.escape)
+
+  lex(base):
+    r"--.*$" is(comment.single)
+    r"(?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?" is(literal.number.float)
+    r"(?i)\d+e[+-]?\d+" is(literal.number.float)
+    r"(?i)0x[0-9a-f]*" is(literal.number.hex)
+    r"\d+" is(literal.number.integer)
+    r"\n" is(text)
+    r"[^\S\n]+" is(text)
+    r"(?m)\[(=*)\[.*?\]\1\]" is(literal.string)
+    r"(->|=>)" is(name.function)
+    r":[a-zA-Z_][a-zA-Z0-9_]*" is(name.variable)
+    r"(==|!=|\126=|<=|>=|\.\.\.|\.\.|[=+\-*/%^<>\#!.\\:])" is(operator)
+    r"[;,]" is(punctuation)
+    r"[\[\]\{\}\(\)]" is(keyword.type)
+    r"[a-zA-Z_][a-zA-Z0-9_]*:" is(name.variable)
+    r"(class|extends|if|then|super|do|with|import|export|while|elseif|return|for|in|from|when|using|else|and|or|not|switch|break)\b" is(keyword)
+    r"(true|false|nil)\b" is(keyword.constant)
+    r"(and|or|not)\b" is(operator.word)
+    r"(self)\b" is(name.builtin.pseudo)
+    r"@@?([a-zA-Z_][a-zA-Z0-9_]*)?" is(name.variable.class)
+    r"[A-Z]\w*" is(name.class)
+    r"[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?" is(name)
+    r"'" is(literal.string.single) -> combined(stringescape, sqs)
+    r"\"" is(literal.string.double) -> combined(stringescape, dqs)
+
+  lex(root):
+    r"\#!(.*?)$" is(comment.preproc)
+    r"" is(text) -> go-to(base)
+
+  lex(dqs):
+    r"\"" is(literal.string.double) -> pop
+    r"." is(literal.string)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,35 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Mscgen"
+  aliases: ["mscgen", "msc"]
+  extensions: [".msc"]
+  mimetypes: []
+  start: .root
+  flags: 0
+
+  lex(root):
+    r"msc\b" is(keyword.type)
+    r"(hscale|HSCALE|width|WIDTH|wordwraparcs|WORDWRAPARCS|arcgradient|ARCGRADIENT)\b" is(name.property)
+    r"(abox|ABOX|rbox|RBOX|box|BOX|note|NOTE)\b" is(operator.word)
+    r"(\.|-|\|){3}" is(keyword)
+    r"(?:-|=|\.|:){2}|<<=>>|<->|<=>|<<>>|<:>|->|=>>|>>|=>|:>|-x|-X|<-|<<=|<<|<=|<:|x-|X-|=" is(operator)
+    r"\*" is(name.builtin)
+    r"([a-zA-Z0-9_]+|\"(?:\\\"|[^\"])*\")" is(name.variable)
+    r"\[" is(punctuation) -> go-to(attrs)
+    r"\{|\}|,|;" is(punctuation)
+    any-of(comments)
+
+  lex(attrs):
+    r"\]" is(punctuation) -> pop
+    r"([a-zA-Z0-9_]+|\"(?:\\\"|[^\"])*\")(\s*)(=)(\s*)([a-zA-Z0-9_]+|\"(?:\\\"|[^\"])*\")" is(by-groups(name.attribute, text.whitespace, operator, text.whitespace, literal.string))
+    r"," is(punctuation)
+    any-of(comments)
+
+  lex(comments):
+    r"(?://|\#).*?\n" is(comment.single)
+    r"/\*(?:.|\n)*?\*/" is(comment.multiline)
+    r"[ \t\r\n]+" is(text.whitespace)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,36 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "MuPAD"
+  aliases: ["mupad"]
+  extensions: [".mu"]
+  mimetypes: []
+  start: .root
+  flags: 0
+
+  lex(comment):
+    r"[^*/]" is(comment.multiline)
+    r"/\*" is(comment.multiline) -> push
+    r"\*/" is(comment.multiline) -> pop
+    r"[*/]" is(comment.multiline)
+
+  lex(root):
+    r"//.*?$" is(comment.single)
+    r"/\*" is(comment.multiline) -> go-to(comment)
+    r"\"(?:[^\"\\]|\\.)*\"" is(literal.string)
+    r"\(|\)|\[|\]|\{|\}" is(punctuation)
+    r"(?x)\b(?:\10            next|break|end|\10            axiom|end_axiom|category|end_category|domain|end_domain|inherits|\10            if|%if|then|elif|else|end_if|\10            case|of|do|otherwise|end_case|\10            while|end_while|\10            repeat|until|end_repeat|\10            for|from|to|downto|step|end_for|\10            proc|local|option|save|begin|end_proc|\10            delete|frame\10          )\b" is(keyword)
+    r"(?x)\b(?:\10            DOM_ARRAY|DOM_BOOL|DOM_COMPLEX|DOM_DOMAIN|DOM_EXEC|DOM_EXPR|\10            DOM_FAIL|DOM_FLOAT|DOM_FRAME|DOM_FUNC_ENV|DOM_HFARRAY|DOM_IDENT|\10            DOM_INT|DOM_INTERVAL|DOM_LIST|DOM_NIL|DOM_NULL|DOM_POLY|DOM_PROC|\10            DOM_PROC_ENV|DOM_RAT|DOM_SET|DOM_STRING|DOM_TABLE|DOM_VAR\10          )\b" is(name.class)
+    r"(?x)\b(?:\10            PI|EULER|E|CATALAN|\10            NIL|FAIL|undefined|infinity|\10            TRUE|FALSE|UNKNOWN\10          )\b" is(name.constant)
+    r"\b(?:dom|procname)\b" is(name.builtin.pseudo)
+    r"\.|,|:|;|=|\+|-|\*|/|\^|@|>|<|\$|\||!|\'|%|\126=" is(operator)
+    r"(?x)\b(?:\10            and|or|not|xor|\10            assuming|\10            div|mod|\10            union|minus|intersect|in|subset\10          )\b" is(operator.word)
+    r"\b(?:I|RDN_INF|RD_NINF|RD_NAN)\b" is(literal.number)
+    r"(?x)\10          ((?:[a-zA-Z_\#][a-zA-Z_\#0-9]*|`[^`]*`)\10          (?:::[a-zA-Z_\#][a-zA-Z_\#0-9]*|`[^`]*`)*)(\s*)([(])" is(by-groups(name.function, text, punctuation))
+    r"(?x)\10          (?:[a-zA-Z_\#][a-zA-Z_\#0-9]*|`[^`]*`)\10          (?:::[a-zA-Z_\#][a-zA-Z_\#0-9]*|`[^`]*`)*" is(name.variable)
+    r"[0-9]+(?:\.[0-9]*)?(?:e[0-9]+)?" is(literal.number)
+    r"\.[0-9]+(?:e[0-9]+)?" is(literal.number)
+    r"." is(text)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,37 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "MySQL"
+  aliases: ["mysql"]
+  extensions: []
+  mimetypes: ["text/x-mysql"]
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(multiline-comments):
+    r"/\*" is(comment.multiline) -> go-to(multiline-comments)
+    r"\*/" is(comment.multiline) -> pop
+    r"[^/\*]+" is(comment.multiline)
+    r"[/*]" is(comment.multiline)
+
+  lex(root):
+    r"\s+" is(text)
+    r"(\#|--\s+).*?\n" is(comment.single)
+    r"/\*" is(comment.multiline) -> go-to(multiline-comments)
+    r"[0-9]+" is(literal.number.integer)
+    r"[0-9]*\.[0-9]+(e[+-][0-9]+)" is(literal.number.float)
+    r"'(''|[^'])*'" is(literal.string.single)
+    r"\"(\"\"|[^\"])*\"" is(literal.string.double)
+    r"`(``|[^`])*`" is(literal.string.symbol)
+    r"[+*/<>=\126!@\#%^&|`?-]" is(operator)
+    r"\b(tinyint|smallint|mediumint|int|integer|bigint|date|datetime|time|bit|bool|tinytext|mediumtext|longtext|text|tinyblob|mediumblob|longblob|blob|float|double|double\s+precision|real|numeric|dec|decimal|timestamp|year|char|varchar|varbinary|varcharacter|enum|set)(\b\s*)(\()?" is(by-groups(keyword.type, text, punctuation))
+    r"\b(add|all|alter|analyze|and|as|asc|asensitive|before|between|bigint|binary|blob|both|by|call|cascade|case|change|char|character|check|collate|column|condition|constraint|continue|convert|create|cross|current_date|current_time|current_timestamp|current_user|cursor|database|databases|day_hour|day_microsecond|day_minute|day_second|dec|decimal|declare|default|delayed|delete|desc|describe|deterministic|distinct|distinctrow|div|double|drop|dual|each|else|elseif|enclosed|escaped|exists|exit|explain|fetch|float|float4|float8|for|force|foreign|from|fulltext|grant|group|having|high_priority|hour_microsecond|hour_minute|hour_second|if|ignore|in|index|infile|inner|inout|insensitive|insert|int|int1|int2|int3|int4|int8|integer|interval|into|is|iterate|join|key|keys|kill|leading|leave|left|like|limit|lines|load|localtime|localtimestamp|lock|long|loop|low_priority|match|minute_microsecond|minute_second|mod|modifies|natural|no_write_to_binlog|not|numeric|on|optimize|option|optionally|or|order|out|outer|outfile|precision|primary|procedure|purge|raid0|read|reads|real|references|regexp|release|rename|repeat|replace|require|restrict|return|revoke|right|rlike|schema|schemas|second_microsecond|select|sensitive|separator|set|show|smallint|soname|spatial|specific|sql|sql_big_result|sql_calc_found_rows|sql_small_result|sqlexception|sqlstate|sqlwarning|ssl|starting|straight_join|table|terminated|then|to|trailing|trigger|undo|union|unique|unlock|unsigned|update|usage|use|using|utc_date|utc_time|utc_timestamp|values|varying|when|where|while|with|write|x509|xor|year_month|zerofill)\b" is(keyword)
+    r"\b(auto_increment|engine|charset|tables)\b" is(keyword.pseudo)
+    r"(true|false|null)" is(name.constant)
+    r"([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\()" is(by-groups(name.function, text, punctuation))
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name)
+    r"@[A-Za-z0-9]*[._]*[A-Za-z0-9]*" is(name.variable)
+    r"[;:()\[\],\.]" is(punctuation)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,52 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "NASM"
+  aliases: ["nasm"]
+  extensions: [".asm", ".ASM"]
+  mimetypes: ["text/x-nasm"]
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(preproc):
+    r"[^;\n]+" is(comment.preproc)
+    r";.*?\n" is(comment.single) -> pop
+    r"\n" is(comment.preproc) -> pop
+
+  lex(punctuation):
+    r"[,():\[\]]+" is(punctuation)
+    r"[&|^<>+*/%\126-]+" is(operator)
+    r"[$]+" is(keyword.constant)
+    r"seg|wrt|strict" is(operator.word)
+    r"byte|[dq]?word" is(keyword.type)
+
+  lex(root):
+    any-of(whitespace)
+    r"^\s*%" is(comment.preproc) -> go-to(preproc)
+    r"[a-zA-Z$._?][a-zA-Z0-9$._?\#@\126]*:" is(name.label)
+    r"([a-zA-Z$._?][a-zA-Z0-9$._?\#@\126]*)(\s+)(equ)" is(by-groups(name.constant, keyword.declaration, keyword.declaration)) -> go-to(instruction-args)
+    r"BITS|USE16|USE32|SECTION|SEGMENT|ABSOLUTE|EXTERN|GLOBAL|ORG|ALIGN|STRUC|ENDSTRUC|COMMON|CPU|GROUP|UPPERCASE|IMPORT|EXPORT|LIBRARY|MODULE" is(keyword) -> go-to(instruction-args)
+    r"(?:res|d)[bwdqt]|times" is(keyword.declaration) -> go-to(instruction-args)
+    r"[a-zA-Z$._?][a-zA-Z0-9$._?\#@\126]*" is(name.function) -> go-to(instruction-args)
+    r"[\r\n]+" is(text)
+
+  lex(whitespace):
+    r"\n" is(text)
+    r"[ \t]+" is(text)
+    r";.*" is(comment.single)
+
+  lex(instruction-args):
+    r"\"(\\\"|[^\"\n])*\"|'(\\'|[^'\n])*'|`(\\`|[^`\n])*`" is(literal.string)
+    r"(?:0[xX][0-9a-fA-F]+|$0[0-9a-fA-F]*|[0-9]+[0-9a-fA-F]*h)" is(literal.number.hex)
+    r"[0-7]+q" is(literal.number.oct)
+    r"[01]+b" is(literal.number)
+    r"[0-9]+\.e?[0-9]+" is(literal.number.float)
+    r"[0-9]+" is(literal.number.integer)
+    any-of(punctuation)
+    r"r[0-9][0-5]?[bwd]|[a-d][lh]|[er]?[a-d]x|[er]?[sb]p|[er]?[sd]i|[c-gs]s|st[0-7]|mm[0-7]|cr[0-4]|dr[0-367]|tr[3-7]" is(name.builtin)
+    r"[a-zA-Z$._?][a-zA-Z0-9$._?\#@\126]*" is(name.variable)
+    r"[\r\n]+" is(text) -> pop
+    any-of(whitespace)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,34 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "NewLisp"
+  aliases: ["newlisp"]
+  extensions: [".lsp", ".nl"]
+  mimetypes: ["text/x-newlisp", "application/x-newlisp"]
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(bracestring):
+    r"{" is(literal.string) -> push
+    r"}" is(literal.string) -> pop
+    r"[^{}]+" is(literal.string)
+
+  lex(tagstring):
+    r"(?m)(.*?)(\[/text\])" is(literal.string) -> pop
+
+  lex(root):
+    r"\#!(.*?)$" is(comment.preproc)
+    r";.*$" is(comment.single)
+    r"\#.*$" is(comment.single)
+    r"\s+" is(text)
+    r"\"(\\\\|\\\"|[^\"])*\"" is(literal.string)
+    r"{" is(literal.string) -> go-to(bracestring)
+    r"\[text\]*" is(literal.string) -> go-to(tagstring)
+    r"('|:)" is(operator)
+    r"(\^\b|\-\-\b|\-\b|\:\b|\!\b|\!\=\b|\?\b|\@\b|\*\b|\/\b|\&\b|\%\b|\+\b|\+\+\b|\<\b|\<\<\b|\<\=\b|\=\b|\>\b|\>\=\b|\>\>\b|\|\b|\\126\b|\$\b|\$0\b|\$1\b|\$10\b|\$11\b|\$12\b|\$13\b|\$14\b|\$15\b|\$2\b|\$3\b|\$4\b|\$5\b|\$6\b|\$7\b|\$8\b|\$9\b|\$args\b|\$idx\b|\$it\b|\$main\-args\b|abort\b|abs\b|acos\b|acosh\b|add\b|address\b|amb\b|and\b|and\b|append\-file\b|append\b|apply\b|args\b|array\-list\b|array\?\b|array\b|asin\b|asinh\b|assoc\b|atan\b|atan2\b|atanh\b|atom\?\b|base64\-dec\b|base64\-enc\b|bayes\-query\b|bayes\-train\b|begin\b|begin\b|begin\b|beta\b|betai\b|bind\b|binomial\b|bits\b|callback\b|case\b|case\b|case\b|catch\b|ceil\b|change\-dir\b|char\b|chop\b|Class\b|clean\b|close\b|command\-event\b|cond\b|cond\b|cond\b|cons\b|constant\b|context\?\b|context\b|copy\-file\b|copy\b|cos\b|cosh\b|count\b|cpymem\b|crc32\b|crit\-chi2\b|crit\-z\b|current\-line\b|curry\b|date\-list\b|date\-parse\b|date\-value\b|date\b|debug\b|dec\b|def\-new\b|default\b|define\-macro\b|define\-macro\b|define\b|delete\-file\b|delete\-url\b|delete\b|destroy\b|det\b|device\b|difference\b|directory\?\b|directory\b|div\b|do\-until\b|do\-while\b|doargs\b|dolist\b|dostring\b|dotimes\b|dotree\b|dump\b|dup\b|empty\?\b|encrypt\b|ends\-with\b|env\b|erf\b|error\-event\b|eval\-string\b|eval\b|exec\b|exists\b|exit\b|exp\b|expand\b|explode\b|extend\b|factor\b|fft\b|file\-info\b|file\?\b|filter\b|find\-all\b|find\b|first\b|flat\b|float\?\b|float\b|floor\b|flt\b|fn\b|for\-all\b|for\b|fork\b|format\b|fv\b|gammai\b|gammaln\b|gcd\b|get\-char\b|get\-float\b|get\-int\b|get\-long\b|get\-string\b|get\-url\b|global\?\b|global\b|if\-not\b|if\b|ifft\b|import\b|inc\b|index\b|inf\?\b|int\b|integer\?\b|integer\b|intersect\b|invert\b|irr\b|join\b|lambda\-macro\b|lambda\?\b|lambda\b|last\-error\b|last\b|legal\?\b|length\b|let\b|let\b|let\b|letex\b|letn\b|letn\b|letn\b|list\?\b|list\b|load\b|local\b|log\b|lookup\b|lower\-case\b|macro\?\b|main\-args\b|MAIN\b|make\-dir\b|map\b|mat\b|match\b|max\b|member\b|min\b|mod\b|module\b|mul\b|multiply\b|NaN\?\b|net\-accept\b|net\-close\b|net\-connect\b|net\-error\b|net\-eval\b|net\-interface\b|net\-ipv\b|net\-listen\b|net\-local\b|net\-lookup\b|net\-packet\b|net\-peek\b|net\-peer\b|net\-ping\b|net\-receive\-from\b|net\-receive\-udp\b|net\-receive\b|net\-select\b|net\-send\-to\b|net\-send\-udp\b|net\-send\b|net\-service\b|net\-sessions\b|new\b|nil\?\b|nil\b|normal\b|not\b|now\b|nper\b|npv\b|nth\b|null\?\b|number\?\b|open\b|or\b|ostype\b|pack\b|parse\-date\b|parse\b|peek\b|pipe\b|pmt\b|pop\-assoc\b|pop\b|post\-url\b|pow\b|prefix\b|pretty\-print\b|primitive\?\b|print\b|println\b|prob\-chi2\b|prob\-z\b|process\b|prompt\-event\b|protected\?\b|push\b|put\-url\b|pv\b|quote\?\b|quote\b|rand\b|random\b|randomize\b|read\b|read\-char\b|read\-expr\b|read\-file\b|read\-key\b|read\-line\b|read\-utf8\b|read\b|reader\-event\b|real\-path\b|receive\b|ref\-all\b|ref\b|regex\-comp\b|regex\b|remove\-dir\b|rename\-file\b|replace\b|reset\b|rest\b|reverse\b|rotate\b|round\b|save\b|search\b|seed\b|seek\b|select\b|self\b|semaphore\b|send\b|sequence\b|series\b|set\-locale\b|set\-ref\-all\b|set\-ref\b|set\b|setf\b|setq\b|sgn\b|share\b|signal\b|silent\b|sin\b|sinh\b|sleep\b|slice\b|sort\b|source\b|spawn\b|sqrt\b|starts\-with\b|string\?\b|string\b|sub\b|swap\b|sym\b|symbol\?\b|symbols\b|sync\b|sys\-error\b|sys\-info\b|tan\b|tanh\b|term\b|throw\-error\b|throw\b|time\-of\-day\b|time\b|timer\b|title\-case\b|trace\-highlight\b|trace\b|transpose\b|Tree\b|trim\b|true\?\b|true\b|unicode\b|unify\b|unique\b|unless\b|unpack\b|until\b|upper\-case\b|utf8\b|utf8len\b|uuid\b|wait\-pid\b|when\b|while\b|write\b|write\-char\b|write\-file\b|write\-line\b|write\b|xfer\-event\b|xml\-error\b|xml\-parse\b|xml\-type\-tags\b|zero\?\b)" is(keyword)
+    r"(?<=\()([a-zA-Z0-9!$%&*+.,/<=>?@^_\126|-])+|(\[.*?\])+" is(name.variable)
+    r"([a-zA-Z0-9!$%&*+.,/<=>?@^_\126|-])+|(\[.*?\])+" is(literal.string.symbol)
+    r"(\(|\))" is(punctuation)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,49 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Newspeak"
+  aliases: ["newspeak"]
+  extensions: [".ns2"]
+  mimetypes: ["text/x-newspeak"]
+  start: .root
+  flags: 0
+
+  lex(literals):
+    r"\$." is(literal.string)
+    r"'[^']*'" is(literal.string)
+    r"\#'[^']*'" is(literal.string.symbol)
+    r"\#\w+:?" is(literal.string.symbol)
+    r"\#(\+|\/|\126|\*|<|>|=|@|%|\||&|\?|!|,|-)+" is(literal.string.symbol)
+
+  lex(root):
+    r"\b(Newsqueak2)\b" is(keyword.declaration)
+    r"'[^']*'" is(literal.string)
+    r"\b(class)(\s+)([a-zA-Z0-9_]+)(\s*)" is(by-groups(keyword.declaration, text, name.class, text))
+    r"\b(mixin|self|super|private|public|protected|nil|true|false)\b" is(keyword)
+    r"([a-zA-Z0-9_]+\:)(\s*)([a-zA-Z_]\w+)" is(by-groups(name.function, text, name.variable))
+    r"([a-zA-Z0-9_]+)(\s*)(=)" is(by-groups(name.attribute, text, operator))
+    r"<[a-zA-Z0-9_]+>" is(comment.special)
+    any-of(expressionstat)
+    any-of(whitespace)
+
+  lex(whitespace):
+    r"\s+" is(text)
+    r"\"[^\"]*\"" is(comment)
+
+  lex(expressionstat):
+    r"(\d+\.\d*|\.\d+|\d+[fF])[fF]?" is(literal.number.float)
+    r"\d+" is(literal.number.integer)
+    r":\w+" is(name.variable)
+    r"(\w+)(::)" is(by-groups(name.variable, operator))
+    r"\w+:" is(name.function)
+    r"\w+" is(name.variable)
+    r"\(|\)" is(punctuation)
+    r"\[|\]" is(punctuation)
+    r"\{|\}" is(punctuation)
+    r"(\^|\+|\/|\126|\*|<|>|=|@|%|\||&|\?|!|,|-|:)" is(operator)
+    r"\.|;" is(punctuation)
+    any-of(whitespace)
+    any-of(literals)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,41 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Nginx configuration file"
+  aliases: ["nginx"]
+  extensions: []
+  mimetypes: ["text/x-nginx-conf"]
+  start: .root
+  flags: 0
+
+  lex(base):
+    r"\#.*\n" is(comment.single)
+    r"on|off" is(name.constant)
+    r"\$[^\s;\#()]+" is(name.variable)
+    r"([a-z0-9.-]+)(:)([0-9]+)" is(by-groups(name, punctuation, literal.number.integer))
+    r"[a-z-]+/[a-z-+]+" is(literal.string)
+    r"[0-9]+[km]?\b" is(literal.number.integer)
+    r"(\126)(\s*)([^\s{]+)" is(by-groups(punctuation, text, literal.string.regex))
+    r"[:=\126]" is(punctuation)
+    r"[^\s;\#{}$]+" is(literal.string)
+    r"/[^\s;\#]*" is(name)
+    r"\s+" is(text)
+    r"[$;]" is(text)
+
+  lex(root):
+    r"(include)(\s+)([^\s;]+)" is(by-groups(keyword, text, name))
+    r"[^\s;\#]+" is(keyword) -> go-to(stmt)
+    any-of(base)
+
+  lex(stmt):
+    r"{" is(punctuation) -> go-to(block)
+    r";" is(punctuation) -> pop
+    any-of(base)
+
+  lex(block):
+    r"}" is(punctuation) -> pop(2)
+    r"[^\s;\#]+" is(keyword.namespace) -> go-to(stmt)
+    any-of(base)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,84 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Nimrod"
+  aliases: ["nimrod", "nim"]
+  extensions: [".nim", ".nimrod"]
+  mimetypes: ["text/x-nimrod"]
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(rdqs):
+    r"\"(?!\")" is(literal.string) -> pop
+    r"\"\"" is(literal.string.escape)
+    any-of(strings)
+
+  lex(float-suffix):
+    r"\'[fF](32|64)" is(literal.number.float)
+    r"" is(text) -> pop
+
+  lex(chars):
+    r"\\([\\abcefnrtvl\"\']|x[a-fA-F0-9]{2}|[0-9]{1,3})" is(literal.string.escape)
+    r"'" is(literal.string.char) -> pop
+    r"." is(literal.string.char)
+
+  lex(float-number):
+    r"\.(?!\.)[0-9_]*" is(literal.number.float)
+    r"[eE][+-]?[0-9][0-9_]*" is(literal.number.float)
+    r"" is(text) -> pop
+
+  lex(int-suffix):
+    r"\'[iI](32|64)" is(literal.number.integer.long)
+    r"\'[iI](8|16)" is(literal.number.integer)
+    r"" is(text) -> pop
+
+  lex(nl):
+    r"\n" is(literal.string)
+
+  lex(dqs):
+    r"\\([\\abcefnrtvl\"\']|\n|x[a-fA-F0-9]{2}|[0-9]{1,3})" is(literal.string.escape)
+    r"\"" is(literal.string) -> pop
+    any-of(strings)
+
+  lex(root):
+    r"\#\#.*$" is(literal.string.doc)
+    r"\#.*$" is(comment)
+    r"\*|=|>|<|\+|-|/|@|\$|\126|&|%|\!|\?|\||\\|\[|\]" is(operator)
+    r"\.\.|\.|,|\[\.|\.\]|{\.|\.}|\(\.|\.\)|{|}|\(|\)|:|\^|`|;" is(punctuation)
+    r"(?:[\w]+)\"" is(literal.string) -> go-to(rdqs)
+    r"\"\"\"" is(literal.string) -> go-to(tdqs)
+    r"\"" is(literal.string) -> go-to(dqs)
+    r"'" is(literal.string.char) -> go-to(chars)
+    r"(a_?n_?d_?|o_?r_?|n_?o_?t_?|x_?o_?r_?|s_?h_?l_?|s_?h_?r_?|d_?i_?v_?|m_?o_?d_?|i_?n_?|n_?o_?t_?i_?n_?|i_?s_?|i_?s_?n_?o_?t_?)\b" is(operator.word)
+    r"(p_?r_?o_?c_?\s)(?![\(\[\]])" is(keyword) -> go-to(funcname)
+    r"(a_?d_?d_?r_?|a_?n_?d_?|a_?s_?|a_?s_?m_?|a_?t_?o_?m_?i_?c_?|b_?i_?n_?d_?|b_?l_?o_?c_?k_?|b_?r_?e_?a_?k_?|c_?a_?s_?e_?|c_?a_?s_?t_?|c_?o_?n_?s_?t_?|c_?o_?n_?t_?i_?n_?u_?e_?|c_?o_?n_?v_?e_?r_?t_?e_?r_?|d_?i_?s_?c_?a_?r_?d_?|d_?i_?s_?t_?i_?n_?c_?t_?|d_?i_?v_?|e_?l_?i_?f_?|e_?l_?s_?e_?|e_?n_?d_?|e_?n_?u_?m_?|e_?x_?c_?e_?p_?t_?|f_?i_?n_?a_?l_?l_?y_?|f_?o_?r_?|g_?e_?n_?e_?r_?i_?c_?|i_?f_?|i_?m_?p_?l_?i_?e_?s_?|i_?n_?|y_?i_?e_?l_?d_?|i_?s_?|i_?s_?n_?o_?t_?|i_?t_?e_?r_?a_?t_?o_?r_?|l_?a_?m_?b_?d_?a_?|l_?e_?t_?|m_?a_?c_?r_?o_?|m_?e_?t_?h_?o_?d_?|m_?o_?d_?|n_?o_?t_?|n_?o_?t_?i_?n_?|o_?b_?j_?e_?c_?t_?|o_?f_?|o_?r_?|o_?u_?t_?|p_?r_?o_?c_?|p_?t_?r_?|r_?a_?i_?s_?e_?|r_?e_?f_?|r_?e_?t_?u_?r_?n_?|s_?h_?l_?|s_?h_?r_?|t_?e_?m_?p_?l_?a_?t_?e_?|t_?r_?y_?|t_?u_?p_?l_?e_?|t_?y_?p_?e_?|w_?h_?e_?n_?|w_?h_?i_?l_?e_?|w_?i_?t_?h_?|w_?i_?t_?h_?o_?u_?t_?|x_?o_?r_?)\b" is(keyword)
+    r"(f_?r_?o_?m_?|i_?m_?p_?o_?r_?t_?|i_?n_?c_?l_?u_?d_?e_?)\b" is(keyword.namespace)
+    r"(v_?a_?r)\b" is(keyword.declaration)
+    r"(i_?n_?t_?|i_?n_?t_?8_?|i_?n_?t_?1_?6_?|i_?n_?t_?3_?2_?|i_?n_?t_?6_?4_?|f_?l_?o_?a_?t_?|f_?l_?o_?a_?t_?3_?2_?|f_?l_?o_?a_?t_?6_?4_?|b_?o_?o_?l_?|c_?h_?a_?r_?|r_?a_?n_?g_?e_?|a_?r_?r_?a_?y_?|s_?e_?q_?|s_?e_?t_?|s_?t_?r_?i_?n_?g_?)\b" is(keyword.type)
+    r"(n_?i_?l_?|t_?r_?u_?e_?|f_?a_?l_?s_?e_?)\b" is(keyword.pseudo)
+    r"\b((?![_\d])\w)(((?!_)\w)|(_(?!_)\w))*" is(name)
+    r"[0-9][0-9_]*(?=([eE.]|\'[fF](32|64)))" is(literal.number.float) -> do-all(go-to(float-suffix), go-to(float-number))
+    r"0[xX][a-fA-F0-9][a-fA-F0-9_]*" is(literal.number.hex) -> go-to(int-suffix)
+    r"0[bB][01][01_]*" is(literal.number) -> go-to(int-suffix)
+    r"0o[0-7][0-7_]*" is(literal.number.oct) -> go-to(int-suffix)
+    r"[0-9][0-9_]*" is(literal.number.integer) -> go-to(int-suffix)
+    r"\s+" is(text)
+    r".+$" is(error)
+
+  lex(funcname):
+    r"((?![\d_])\w)(((?!_)\w)|(_(?!_)\w))*" is(name.function) -> pop
+    r"`.+`" is(name.function) -> pop
+
+  lex(tdqs):
+    r"\"\"\"(?!\")" is(literal.string) -> pop
+    any-of(strings)
+    any-of(nl)
+
+  lex(strings):
+    r"(?<!\$)\$(\d+|\#|\w+)+" is(literal.string.interpol)
+    r"[^\\\'\"\$\n]+" is(literal.string)
+    r"[\'\"\\]" is(literal.string)
+    r"\$" is(literal.string)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,55 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "NSIS"
+  aliases: ["nsis", "nsi", "nsh"]
+  extensions: [".nsi", ".nsh"]
+  mimetypes: ["text/x-nsis"]
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(str-double):
+    r"\"" is(literal.string) -> pop
+    r"\$(\\[nrt\"]|\$)" is(literal.string.escape)
+    any-of(interpol)
+    r"." is(literal.string.double)
+
+  lex(macro):
+    r"\!(addincludedir(?:dir)?|addplugindir|appendfile|cd|define|delfilefile|echo(?:message)?|else|endif|error|execute|if(?:macro)?n?(?:def)?|include|insertmacro|macro(?:end)?|packhdr|search(?:parse|replace)|system|tempfilesymbol|undef|verbose|warning)\b" is(comment.preproc)
+
+  lex(str-backtick):
+    r"`" is(literal.string) -> pop
+    r"\$(\\[nrt\"]|\$)" is(literal.string.escape)
+    any-of(interpol)
+    r"." is(literal.string.double)
+
+  lex(basic):
+    r"(\n)(Function)(\s+)([._a-z][.\w]*)\b" is(by-groups(text, keyword, text, name.function))
+    r"\b([_a-z]\w*)(::)([a-z][a-z0-9]*)\b" is(by-groups(keyword.namespace, punctuation, name.function))
+    r"\b([_a-z]\w*)(:)" is(by-groups(name.label, punctuation))
+    r"(\b[ULS]|\B)([\!\<\>=]?=|\<\>?|\>)\B" is(operator)
+    r"[|+-]" is(operator)
+    r"\\" is(punctuation)
+    r"\b(Abort|Add(?:BrandingImage|Size)|Allow(?:RootDirInstall|SkipFiles)|AutoCloseWindow|BG(?:Font|Gradient)|BrandingText|BringToFront|Call(?:InstDLL)?|(?:Sub)?Caption|ChangeUI|CheckBitmap|ClearErrors|CompletedText|ComponentText|CopyFiles|CRCCheck|Create(?:Directory|Font|Shortcut)|Delete(?:INI(?:Sec|Str)|Reg(?:Key|Value))?|DetailPrint|DetailsButtonText|Dir(?:Show|Text|Var|Verify)|(?:Disabled|Enabled)Bitmap|EnableWindow|EnumReg(?:Key|Value)|Exch|Exec(?:Shell|Wait)?|ExpandEnvStrings|File(?:BufSize|Close|ErrorText|Open|Read(?:Byte)?|Seek|Write(?:Byte)?)?|Find(?:Close|First|Next|Window)|FlushINI|Function(?:End)?|Get(?:CurInstType|CurrentAddress|DlgItem|DLLVersion(?:Local)?|ErrorLevel|FileTime(?:Local)?|FullPathName|FunctionAddress|InstDirError|LabelAddress|TempFileName)|Goto|HideWindow|Icon|If(?:Abort|Errors|FileExists|RebootFlag|Silent)|InitPluginsDir|Install(?:ButtonText|Colors|Dir(?:RegKey)?)|Inst(?:ProgressFlags|Type(?:[GS]etText)?)|Int(?:CmpU?|Fmt|Op)|IsWindow|LangString(?:UP)?|License(?:BkColor|Data|ForceSelection|LangString|Text)|LoadLanguageFile|LockWindow|Log(?:Set|Text)|MessageBox|MiscButtonText|Name|Nop|OutFile|(?:Uninst)?Page(?:Ex(?:End)?)?|PluginDir|Pop|Push|Quit|Read(?:(?:Env|INI|Reg)Str|RegDWORD)|Reboot|(?:Un)?RegDLL|Rename|RequestExecutionLevel|ReserveFile|Return|RMDir|SearchPath|Section(?:Divider|End|(?:(?:Get|Set)(?:Flags|InstTypes|Size|Text))|Group(?:End)?|In)?|SendMessage|Set(?:AutoClose|BrandingImage|Compress(?:ionLevel|or(?:DictSize)?)?|CtlColors|CurInstType|DatablockOptimize|DateSave|Details(?:Print|View)|Error(?:s|Level)|FileAttributes|Font|OutPath|Overwrite|PluginUnload|RebootFlag|ShellVarContext|Silent|StaticBkColor)|Show(?:(?:I|Uni)nstDetails|Window)|Silent(?:Un)?Install|Sleep|SpaceTexts|Str(?:CmpS?|Cpy|Len)|SubSection(?:End)?|Uninstall(?:ButtonText|(?:Sub)?Caption|EXEName|Icon|Text)|UninstPage|Var|VI(?:AddVersionKey|ProductVersion)|WindowIcon|Write(?:INIStr|Reg(:?Bin|DWORD|(?:Expand)?Str)|Uninstaller)|XPStyle)\b" is(keyword)
+    r"\b(CUR|END|(?:FILE_ATTRIBUTE_)?(?:ARCHIVE|HIDDEN|NORMAL|OFFLINE|READONLY|SYSTEM|TEMPORARY)|HK(CC|CR|CU|DD|LM|PD|U)|HKEY_(?:CLASSES_ROOT|CURRENT_(?:CONFIG|USER)|DYN_DATA|LOCAL_MACHINE|PERFORMANCE_DATA|USERS)|ID(?:ABORT|CANCEL|IGNORE|NO|OK|RETRY|YES)|MB_(?:ABORTRETRYIGNORE|DEFBUTTON[1-4]|ICON(?:EXCLAMATION|INFORMATION|QUESTION|STOP)|OK(?:CANCEL)?|RETRYCANCEL|RIGHT|SETFOREGROUND|TOPMOST|USERICON|YESNO(?:CANCEL)?)|SET|SHCTX|SW_(?:HIDE|SHOW(?:MAXIMIZED|MINIMIZED|NORMAL))|admin|all|auto|both|bottom|bzip2|checkbox|colored|current|false|force|hide|highest|if(?:diff|newer)|lastused|leave|left|listonly|lzma|nevershow|none|normal|off|on|pop|push|radiobuttons|right|show|silent|silentlog|smooth|textonly|top|true|try|user|zlib)\b" is(name.constant)
+
+  lex(interpol):
+    r"\$(R?[0-9])" is(name.builtin.pseudo)
+    r"\$(ADMINTOOLS|APPDATA|CDBURN_AREA|COOKIES|COMMONFILES(?:32|64)|DESKTOP|DOCUMENTS|EXE(?:DIR|FILE|PATH)|FAVORITES|FONTS|HISTORY|HWNDPARENT|INTERNET_CACHE|LOCALAPPDATA|MUSIC|NETHOOD|PICTURES|PLUGINSDIR|PRINTHOOD|PROFILE|PROGRAMFILES(?:32|64)|QUICKLAUNCH|RECENT|RESOURCES(?:_LOCALIZED)?|SENDTO|SM(?:PROGRAMS|STARTUP)|STARTMENU|SYSDIR|TEMP(?:LATES)?|VIDEOS|WINDIR|\{NSISDIR\})" is(name.builtin)
+    r"\$(CMDLINE|INSTDIR|OUTDIR|LANGUAGE)" is(name.variable.global)
+    r"\$[a-z_]\w*" is(name.variable)
+
+  lex(root):
+    r"[;\\#].*\n" is(comment)
+    r"'.*'" is(literal.string.single)
+    r"\"" is(literal.string.double) -> go-to(str-double)
+    r"`" is(literal.string.backtick) -> go-to(str-backtick)
+    any-of(macro)
+    any-of(interpol)
+    any-of(basic)
+    r"\$\{[a-z_|][\w|]*\}" is(keyword.pseudo)
+    r"/[a-z_]\w*" is(name.attribute)
+    r"." is(text)
+
+const-set(.Lexer, lexer)