broomhlda 0.1.0

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

@@ -0,0 +1,88 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Ioke"
+  aliases: ["ioke", "ik"]
+  extensions: [".ik"]
+  mimetypes: ["text/x-iokesrc"]
+  start: .root
+  flags: 0
+
+  lex(squareRegexp):
+    r"(?<!\\)][oxpniums]*" is(literal.string.regex) -> pop
+    any-of(interpolatableText)
+    r"\\]" is(literal.string.regex)
+    r"[^\]]" is(literal.string.regex)
+
+  lex(textInterpolationRoot):
+    r"}" is(punctuation) -> pop
+    any-of(root)
+
+  lex(interpolatableText):
+    r"(\\b|\\e|\\t|\\n|\\f|\\r|\\\"|\\\\|\\\#|\\\Z|\\u[0-9a-fA-F]{1,4}|\\[0-3]?[0-7]?[0-7])" is(literal.string.escape)
+    r"\#{" is(punctuation) -> go-to(textInterpolationRoot)
+
+  lex(text):
+    r"(?<!\\)\"" is(literal.string) -> pop
+    any-of(interpolatableText)
+    r"[^\"]" is(literal.string)
+
+  lex(documentation):
+    r"(?<!\\)\"" is(literal.string.doc) -> pop
+    any-of(interpolatableText)
+    r"[^\"]" is(literal.string.doc)
+
+  lex(slashRegexp):
+    r"(?<!\\)/[oxpniums]*" is(literal.string.regex) -> pop
+    any-of(interpolatableText)
+    r"\\/" is(literal.string.regex)
+    r"[^/]" is(literal.string.regex)
+
+  lex(squareText):
+    r"(?<!\\)]" is(literal.string) -> pop
+    any-of(interpolatableText)
+    r"[^\]]" is(literal.string)
+
+  lex(root):
+    r"\n" is(text)
+    r"\s+" is(text)
+    r";(.*?)\n" is(comment)
+    r"\A\#!(.*?)\n" is(comment)
+    r"\#/" is(literal.string.regex) -> go-to(slashRegexp)
+    r"\#r\[" is(literal.string.regex) -> go-to(squareRegexp)
+    r":[a-zA-Z0-9_!:?]+" is(literal.string.symbol)
+    r"[a-zA-Z0-9_!:?]+:(?![a-zA-Z0-9_!?])" is(literal.string.other)
+    r":\"(\\\\|\\\"|[^\"])*\"" is(literal.string.symbol)
+    r"((?<=fn\()|(?<=fnx\()|(?<=method\()|(?<=macro\()|(?<=lecro\()|(?<=syntax\()|(?<=dmacro\()|(?<=dlecro\()|(?<=dlecrox\()|(?<=dsyntax\())\s*\"" is(literal.string.doc) -> go-to(documentation)
+    r"\"" is(literal.string) -> go-to(text)
+    r"\#\[" is(literal.string) -> go-to(squareText)
+    r"[a-zA-Z0-9_][a-zA-Z0-9!?_:]+(?=\s*=.*mimic\s)" is(name.entity)
+    r"[a-zA-Z_][a-zA-Z0-9_!:?]*(?=[\s]*[+*/-]?=[^=].*($|\.))" is(name.variable)
+    r"(break|cond|continue|do|ensure|for|for:dict|for:set|if|let|loop|p:for|p:for:dict|p:for:set|return|unless|until|while|with)(?![a-zA-Z0-9!:_?])" is(keyword.reserved)
+    r"(eval|mimic|print|println)(?![a-zA-Z0-9!:_?])" is(keyword)
+    r"(cell\?|cellNames|cellOwner\?|cellOwner|cells|cell|documentation|hash|identity|mimic|removeCell\!|undefineCell\!)(?![a-zA-Z0-9!:_?])" is(keyword)
+    r"(stackTraceAsText)(?![a-zA-Z0-9!:_?])" is(keyword)
+    r"(dict|list|message|set)(?![a-zA-Z0-9!:_?])" is(keyword.reserved)
+    r"(case|case:and|case:else|case:nand|case:nor|case:not|case:or|case:otherwise|case:xor)(?![a-zA-Z0-9!:_?])" is(keyword.reserved)
+    r"(asText|become\!|derive|freeze\!|frozen\?|in\?|is\?|kind\?|mimic\!|mimics|mimics\?|prependMimic\!|removeAllMimics\!|removeMimic\!|same\?|send|thaw\!|uniqueHexId)(?![a-zA-Z0-9!:_?])" is(keyword)
+    r"(after|around|before)(?![a-zA-Z0-9!:_?])" is(keyword.reserved)
+    r"(kind|cellDescriptionDict|cellSummary|genSym|inspect|notice)(?![a-zA-Z0-9!:_?])" is(keyword)
+    r"(use|destructuring)" is(keyword.reserved)
+    r"(cell\?|cellOwner\?|cellOwner|cellNames|cells|cell|documentation|identity|removeCell!|undefineCell)(?![a-zA-Z0-9!:_?])" is(keyword)
+    r"(internal:compositeRegexp|internal:concatenateText|internal:createDecimal|internal:createNumber|internal:createRegexp|internal:createText)(?![a-zA-Z0-9!:_?])" is(keyword.reserved)
+    r"(availableRestarts|bind|error\!|findRestart|handle|invokeRestart|rescue|restart|signal\!|warn\!)(?![a-zA-Z0-9!:_?])" is(keyword.reserved)
+    r"(nil|false|true)(?![a-zA-Z0-9!:_?])" is(name.constant)
+    r"(Arity|Base|Call|Condition|DateTime|Aspects|Pointcut|Assignment|BaseBehavior|Boolean|Case|AndCombiner|Else|NAndCombiner|NOrCombiner|NotCombiner|OrCombiner|XOrCombiner|Conditions|Definitions|FlowControl|Internal|Literals|Reflection|DefaultMacro|DefaultMethod|DefaultSyntax|Dict|FileSystem|Ground|Handler|Hook|IO|IokeGround|Struct|LexicalBlock|LexicalMacro|List|Message|Method|Mixins|NativeMethod|Number|Origin|Pair|Range|Reflector|Regexp Match|Regexp|Rescue|Restart|Runtime|Sequence|Set|Symbol|System|Text|Tuple)(?![a-zA-Z0-9!:_?])" is(name.builtin)
+    r"(generateMatchMethod|aliasMethod|\955|\654|fnx|fn|method|dmacro|dlecro|syntax|macro|dlecrox|lecrox|lecro|syntax)(?![a-zA-Z0-9!:_?])" is(name.function)
+    r"-?0[xX][0-9a-fA-F]+" is(literal.number.hex)
+    r"-?(\d+\.?\d*|\d*\.\d+)([eE][+-]?[0-9]+)?" is(literal.number.float)
+    r"-?\d+" is(literal.number.integer)
+    r"\#\(" is(punctuation)
+    r"(&&>>|\|\|>>|\*\*>>|:::|::|\.\.\.|===|\*\*>|\*\*=|&&>|&&=|\|\|>|\|\|=|\->>|\+>>|!>>|<>>>|<>>|&>>|%>>|\#>>|@>>|/>>|\*>>|\?>>|\|>>|\^>>|\126>>|\$>>|=>>|<<=|>>=|<=>|<\->|=\126|!\126|=>|\+\+|\-\-|<=|>=|==|!=|&&|\.\.|\+=|\-=|\*=|\/=|%=|&=|\^=|\|=|<\-|\+>|!>|<>|&>|%>|\#>|\@>|\/>|\*>|\?>|\|>|\^>|\126>|\$>|<\->|\->|<<|>>|\*\*|\?\||\?&|\|\||>|<|\*|\/|%|\+|\-|&|\^|\||=|\$|!|\126|\?|\#|\8800|\8728|\8712|\8713)" is(operator)
+    r"(and|nand|or|xor|nor|return|import)(?![a-zA-Z0-9_!?])" is(operator)
+    r"(\`\`|\`|\'\'|\'|\.|\,|@@|@|\[|\]|\(|\)|{|})" is(punctuation)
+    r"[A-Z][a-zA-Z0-9_!:?]*" is(name.class)
+    r"[a-z_][a-zA-Z0-9_!:?]*" is(name)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,24 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "IRC logs"
+  aliases: ["irc"]
+  extensions: [".weechatlog"]
+  mimetypes: ["text/x-irclog"]
+  start: .root
+  flags: 0
+
+  lex(msg):
+    r"\S+:(?!//)" is(name.attribute)
+    r".*\n" is(text) -> pop
+
+  lex(root):
+    r"^\*\*\*\*(.*)\*\*\*\*$" is(comment)
+    r"^\10        (\10          \# irssi / xchat and others\10          (?: \[|\()?                  \# Opening bracket or paren for the timestamp\10            (?:                        \# Timestamp\10                (?: (?:\d{1,4} [-/]?)+ \# Date as - or /-separated groups of digits\10                 [T ])?                \# Date/time separator: T or space\10                (?: \d?\d [:.]?)+      \# Time as :/.-separated groups of 1 or 2 digits\10            )\10          (?: \]|\))?\s+               \# Closing bracket or paren for the timestamp\10        |\10          \# weechat\10          \d{4}\s\w{3}\s\d{2}\s        \# Date\10          \d{2}:\d{2}:\d{2}\s+         \# Time + Whitespace\10        |\10          \# xchat\10          \w{3}\s\d{2}\s               \# Date\10          \d{2}:\d{2}:\d{2}\s+         \# Time + Whitespace\10        )?\10    (\s*<[^>]*>\s*)$" is(by-groups(comment.preproc, name.tag))
+    r"^\10        (\10          \# irssi / xchat and others\10          (?: \[|\()?                  \# Opening bracket or paren for the timestamp\10            (?:                        \# Timestamp\10                (?: (?:\d{1,4} [-/]?)+ \# Date as - or /-separated groups of digits\10                 [T ])?                \# Date/time separator: T or space\10                (?: \d?\d [:.]?)+      \# Time as :/.-separated groups of 1 or 2 digits\10            )\10          (?: \]|\))?\s+               \# Closing bracket or paren for the timestamp\10        |\10          \# weechat\10          \d{4}\s\w{3}\s\d{2}\s        \# Date\10          \d{2}:\d{2}:\d{2}\s+         \# Time + Whitespace\10        |\10          \# xchat\10          \w{3}\s\d{2}\s               \# Date\10          \d{2}:\d{2}:\d{2}\s+         \# Time + Whitespace\10        )?\10    \10                (\s*<.*?>\s*)          \# Nick " is(by-groups(comment.preproc, name.tag)) -> go-to(msg)
+    r"^\10        (\10          \# irssi / xchat and others\10          (?: \[|\()?                  \# Opening bracket or paren for the timestamp\10            (?:                        \# Timestamp\10                (?: (?:\d{1,4} [-/]?)+ \# Date as - or /-separated groups of digits\10                 [T ])?                \# Date/time separator: T or space\10                (?: \d?\d [:.]?)+      \# Time as :/.-separated groups of 1 or 2 digits\10            )\10          (?: \]|\))?\s+               \# Closing bracket or paren for the timestamp\10        |\10          \# weechat\10          \d{4}\s\w{3}\s\d{2}\s        \# Date\10          \d{2}:\d{2}:\d{2}\s+         \# Time + Whitespace\10        |\10          \# xchat\10          \w{3}\s\d{2}\s               \# Date\10          \d{2}:\d{2}:\d{2}\s+         \# Time + Whitespace\10        )?\10    \10                (\s*[*]\s+)            \# Star\10                (\S+\s+.*?\n)          \# Nick + rest of message " is(by-groups(comment.preproc, keyword, generic.inserted))
+    r"^\10        (\10          \# irssi / xchat and others\10          (?: \[|\()?                  \# Opening bracket or paren for the timestamp\10            (?:                        \# Timestamp\10                (?: (?:\d{1,4} [-/]?)+ \# Date as - or /-separated groups of digits\10                 [T ])?                \# Date/time separator: T or space\10                (?: \d?\d [:.]?)+      \# Time as :/.-separated groups of 1 or 2 digits\10            )\10          (?: \]|\))?\s+               \# Closing bracket or paren for the timestamp\10        |\10          \# weechat\10          \d{4}\s\w{3}\s\d{2}\s        \# Date\10          \d{2}:\d{2}:\d{2}\s+         \# Time + Whitespace\10        |\10          \# xchat\10          \w{3}\s\d{2}\s               \# Date\10          \d{2}:\d{2}:\d{2}\s+         \# Time + Whitespace\10        )?\10    \10                (\s*(?:\*{3}|<?-[!@=P]?->?)\s*)  \# Star(s) or symbols\10                (\S+\s+)                     \# Nick + Space\10                (.*?\n)                         \# Rest of message " is(by-groups(comment.preproc, keyword, literal.string, comment))
+    r"^.*?\n" is(text)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,36 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "JAGS"
+  aliases: ["jags"]
+  extensions: [".jag", ".bug"]
+  mimetypes: []
+  start: .root
+  flags: 0
+
+  lex(root):
+    any-of(comments)
+    any-of(whitespace)
+    r"(model|data)(\s+)({)" is(by-groups(keyword.namespace, text, punctuation))
+    r"var(?![0-9a-zA-Z\._])" is(keyword.declaration)
+    r"(for|in)(?![0-9a-zA-Z\._])" is(keyword.reserved)
+    r"(abs|arccos|arccosh|arcsin|arcsinh|arctan|arctanh|cos|cosh|cloglog|equals|exp|icloglog|ifelse|ilogit|log|logfact|loggam|logit|phi|pow|probit|round|sin|sinh|sqrt|step|tan|tanh|trunc|inprod|interp.lin|logdet|max|mean|min|prod|sum|sd|inverse|rank|sort|t|acos|acosh|asin|asinh|atan|T|I|[dpq]bern|[dpq]beta|[dpq]dchiqsqr|[dpq]ddexp|[dpq]dexp|[dpq]df|[dpq]gamma|[dpq]gen.gamma|[dpq]logis|[dpq]lnorm|[dpq]negbin|[dpq]nchisqr|[dpq]norm|[dpq]par|[dpq]pois|[dpq]weib|dt|dunif|dbetabin|dbern|dbin|dcat|dhyper|ddirch|dmnorm|dwish|dmt|dmulti|dbinom|dchisq|dnbinom|dweibull|ddirich)(?=\s*\()" is(name.builtin)
+    any-of(names)
+    r"[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?" is(literal.number)
+    r"\[|\]|\(|\)|:|,|;" is(punctuation)
+    r"<-|\126" is(operator)
+    r"\+|-|\*|\/|\|\|[&]{2}|[<>=]=?|\^|%.*?%" is(operator)
+    r"[{}]" is(punctuation)
+
+  lex(whitespace):
+    r"\s+" is(text)
+
+  lex(comments):
+    r"(?m)/\*.*?\*/" is(comment.multiline)
+    r"\#.*$" is(comment.single)
+
+  lex(names):
+    r"[a-zA-Z][a-zA-Z0-9_.]*\b" is(name)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,42 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Java"
+  aliases: ["java"]
+  extensions: [".java"]
+  mimetypes: ["text/x-java"]
+  start: .root
+  flags: Regexp MULTILINE
+
+  lex(import):
+    r"[a-zA-Z0-9_.]+\*?" is(name.namespace) -> pop
+
+  lex(root):
+    r"^(\s*(?:[a-zA-Z_][a-zA-Z0-9_\.\[\]<>]*\s+)+?)([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\()" is(by-groups(using(self class), name.function, text, operator))
+    r"[^\S\n]+" is(text)
+    r"//.*?\n" is(comment.single)
+    r"/\*.*?\*/" is(comment.multiline)
+    r"@[a-zA-Z_][a-zA-Z0-9_\.]*" is(name.decorator)
+    r"(assert|break|case|catch|continue|default|do|else|finally|for|if|goto|instanceof|new|return|switch|this|throw|try|while)\b" is(keyword)
+    r"(abstract|const|enum|extends|final|implements|native|private|protected|public|static|strictfp|super|synchronized|throws|transient|volatile)\b" is(keyword.declaration)
+    r"(boolean|byte|char|double|float|int|long|short|void)\b" is(keyword.type)
+    r"(package)(\s+)" is(by-groups(keyword.namespace, text))
+    r"(true|false|null)\b" is(keyword.constant)
+    r"(class|interface)(\s+)" is(by-groups(keyword.declaration, text)) -> go-to(class)
+    r"(import)(\s+)" is(by-groups(keyword.namespace, text)) -> go-to(import)
+    r"\"(\\\\|\\\"|[^\"])*\"" is(literal.string)
+    r"'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'" is(literal.string.char)
+    r"(\.)([a-zA-Z_][a-zA-Z0-9_]*)" is(by-groups(operator, name.attribute))
+    r"[a-zA-Z_][a-zA-Z0-9_]*:" is(name.label)
+    r"[a-zA-Z_\$][a-zA-Z0-9_]*" is(name)
+    r"[\126\^\*!%&\[\]\(\)\{\}<>\|+=:;,./?-]" is(operator)
+    r"[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?" is(literal.number.float)
+    r"0x[0-9a-fA-F]+" is(literal.number.hex)
+    r"[0-9]+L?" is(literal.number.integer)
+    r"\n" is(text)
+
+  lex(class):
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name.class) -> pop
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,45 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "JavaScript"
+  aliases: ["js", "javascript"]
+  extensions: [".js"]
+  mimetypes: ["application/javascript", "application/x-javascript", "text/x-javascript", "text/javascript"]
+  start: .root
+  flags: Regexp MULTILINE
+
+  lex(commentsandwhitespace):
+    r"\s+" is(text)
+    r"<!--" is(comment)
+    r"//.*?\n" is(comment.single)
+    r"/\*.*?\*/" is(comment.multiline)
+
+  lex(root):
+    r"^(?=\s|/|<!--)" is(text) -> go-to(slashstartsregex)
+    any-of(commentsandwhitespace)
+    r"\+\+|--|\126|&&|\?|:|\|\||\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*%&\|\^/])=?" is(operator) -> go-to(slashstartsregex)
+    r"[{(\[;,]" is(punctuation) -> go-to(slashstartsregex)
+    r"[})\].]" is(punctuation)
+    r"(for|in|while|do|break|return|continue|switch|case|default|if|else|throw|try|catch|finally|new|delete|typeof|instanceof|void|this)\b" is(keyword) -> go-to(slashstartsregex)
+    r"(var|let|with|function)\b" is(keyword.declaration) -> go-to(slashstartsregex)
+    r"(abstract|boolean|byte|char|class|const|debugger|double|enum|export|extends|final|float|goto|implements|import|int|interface|long|native|package|private|protected|public|short|static|super|synchronized|throws|transient|volatile)\b" is(keyword.reserved)
+    r"(true|false|null|NaN|Infinity|undefined)\b" is(keyword.constant)
+    r"(Array|Boolean|Date|Error|Function|Math|netscape|Number|Object|Packages|RegExp|String|sun|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|window)\b" is(name.builtin)
+    r"[$a-zA-Z_][a-zA-Z0-9_]*" is(name.other)
+    r"[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?" is(literal.number.float)
+    r"0x[0-9a-fA-F]+" is(literal.number.hex)
+    r"[0-9]+" is(literal.number.integer)
+    r"\"(\\\\|\\\"|[^\"])*\"" is(literal.string.double)
+    r"'(\\\\|\\'|[^'])*'" is(literal.string.single)
+
+  lex(slashstartsregex):
+    any-of(commentsandwhitespace)
+    r"/(\\.|[^\[/\\\n]|\[(\\.|[^\]\\\n])*])+/([gim]+\b|\B)" is(literal.string.regex) -> pop
+    r"(?=/)" is(text) -> do-all(pop, go-to(badregex))
+    r"" is(text) -> pop
+
+  lex(badregex):
+    r"\n" is(text) -> pop
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,47 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "JSON"
+  aliases: ["json"]
+  extensions: [".json"]
+  mimetypes: ["application/json"]
+  start: .root
+  flags: Regexp MULTILINE
+
+  lex(objectattribute):
+    any-of(value)
+    r":" is(punctuation)
+    r"," is(punctuation) -> pop
+    r"}" is(punctuation) -> do-all(pop, pop)
+
+  lex(whitespace):
+    r"\s+" is(text)
+
+  lex(root):
+    any-of(value)
+
+  lex(simplevalue):
+    r"(true|false|null)\b" is(keyword.constant)
+    r"-?(0|[1-9]\d*)(\.\d+[eE](\+|-)?\d+|[eE](\+|-)?\d+|\.\d+)" is(literal.number.float)
+    r"-?(0|[1-9]\d*)" is(literal.number.integer)
+    r"\"(\\\\|\\\"|[^\"])*\"" is(literal.string.double)
+
+  lex(value):
+    any-of(whitespace)
+    any-of(simplevalue)
+    r"{" is(punctuation) -> go-to(objectvalue)
+    r"\[" is(punctuation) -> go-to(arrayvalue)
+
+  lex(arrayvalue):
+    any-of(whitespace)
+    any-of(value)
+    r"," is(punctuation)
+    r"]" is(punctuation) -> pop
+
+  lex(objectvalue):
+    any-of(whitespace)
+    r"\"(\\\\|\\\"|[^\"])*\"" is(name.tag) -> go-to(objectattribute)
+    r"}" is(punctuation) -> pop
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,60 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Julia"
+  aliases: ["julia", "jl"]
+  extensions: [".jl"]
+  mimetypes: ["text/x-julia", "application/x-julia"]
+  start: .root
+  flags: 0
+
+  lex(typename):
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name.class) -> 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(root):
+    r"\n" is(text)
+    r"[^\S\n]+" is(text)
+    r"\#.*$" is(comment)
+    r"[\]{}:(),;\[@]" is(punctuation)
+    r"\\\n" is(text)
+    r"\\" is(text)
+    r"(begin|while|for|in|return|break|continue|macro|quote|let|if|elseif|else|try|catch|end|bitstype|ccall|do|using|module|import|export|importall|baremodule)\b" is(keyword)
+    r"(local|global|const)\b" is(keyword.declaration)
+    r"(Bool|Int|Int8|Int16|Int32|Int64|Uint|Uint8|Uint16|Uint32|Uint64|Float32|Float64|Complex64|Complex128|Any|Nothing|None)\b" is(keyword.type)
+    r"(function)((?:\s|\\\s)+)" is(by-groups(keyword, name.function)) -> go-to(funcname)
+    r"(type|typealias|abstract)((?:\s|\\\s)+)" is(by-groups(keyword, name.class)) -> go-to(typename)
+    r"==|!=|<=|>=|->|&&|\|\||::|<:|[-\126+/*%=<>&^|.?!$]" is(operator)
+    r"\.\*|\.\^|\.\\|\.\/|\\" is(operator)
+    r"(exit|whos|edit|load|is|isa|isequal|typeof|tuple|ntuple|uid|hash|finalizer|convert|promote|subtype|typemin|typemax|realmin|realmax|sizeof|eps|promote_type|method_exists|applicable|invoke|dlopen|dlsym|system|error|throw|assert|new|Inf|Nan|pi|im)\b" is(name.builtin)
+    r"`(?m).*?`" is(literal.string.backtick)
+    r"'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,3}|\\u[a-fA-F0-9]{1,4}|\\U[a-fA-F0-9]{1,6}|[^\\\'\n])'" is(literal.string.char)
+    r"(?<=[.\w\)\]])\'+" is(operator)
+    r"(?:[IL])\"" is(literal.string) -> go-to(string)
+    r"[E]?\"" is(literal.string) -> combined(stringescape, string)
+    r"@[a-zA-Z0-9_.]+" is(name.decorator)
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name)
+    r"(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?" is(literal.number.float)
+    r"\d+[eEf][+-]?[0-9]+" is(literal.number.float)
+    r"0b[01]+" is(literal.number.binary)
+    r"0o[0-7]+" is(literal.number.oct)
+    r"0x[a-fA-F0-9]+" is(literal.number.hex)
+    r"\d+" is(literal.number.integer)
+
+  lex(string):
+    r"\"" is(literal.string) -> pop
+    r"\\\\|\\\"|\\\n" is(literal.string.escape)
+    r"\$(\([a-zA-Z0-9_]+\))?[-\#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?" is(literal.string.interpol)
+    r"[^\\\"$]+" is(literal.string)
+    r"[\"\\]" is(literal.string)
+    r"\$" is(literal.string)
+
+  lex(funcname):
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name.function) -> pop
+    r"\([^\s\w{]{1,2}\)" is(operator) -> pop
+    r"[^\s\w{]{1,2}" is(operator) -> pop
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,71 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Kconfig"
+  aliases: ["kconfig", "menuconfig", "linux-config", "kernel-config"]
+  extensions: ["Kconfig", "Config.in", "external.in", "standard-modules.in"]
+  mimetypes: ["text/x-kconfig"]
+  start: .root
+  flags: 0
+
+  lex(indent1):
+    r"(?:\t| {1,7}\t| {8}){1}.*\n" is(literal.string.doc)
+    r"\s*\n" is(text)
+    r"" is(generic) -> pop(2)
+
+  lex(indent3):
+    r"(?:\t| {1,7}\t| {8}){3}.*\n" is(literal.string.doc)
+    r"\s*\n" is(text)
+    r"" is(generic) -> pop(2)
+
+  lex(indent2):
+    r"(?:\t| {1,7}\t| {8}){2}.*\n" is(literal.string.doc)
+    r"\s*\n" is(text)
+    r"" is(generic) -> pop(2)
+
+  lex(indent5):
+    r"(?:\t| {1,7}\t| {8}){5}.*\n" is(literal.string.doc)
+    r"\s*\n" is(text)
+    r"" is(generic) -> pop(2)
+
+  lex(help):
+    r"\s*\n" is(text)
+    r"(?:\t| {1,7}\t| {8}){7}.*\n" is(literal.string.doc) -> go-to(indent7)
+    r"(?:\t| {1,7}\t| {8}){6}.*\n" is(literal.string.doc) -> go-to(indent6)
+    r"(?:\t| {1,7}\t| {8}){5}.*\n" is(literal.string.doc) -> go-to(indent5)
+    r"(?:\t| {1,7}\t| {8}){4}.*\n" is(literal.string.doc) -> go-to(indent4)
+    r"(?:\t| {1,7}\t| {8}){3}.*\n" is(literal.string.doc) -> go-to(indent3)
+    r"(?:\t| {1,7}\t| {8}){2}.*\n" is(literal.string.doc) -> go-to(indent2)
+    r"(?:\t| {1,7}\t| {8}){1}.*\n" is(literal.string.doc) -> go-to(indent1)
+    r"" is(text) -> pop
+
+  lex(indent7):
+    r"(?:\t| {1,7}\t| {8}){7}.*\n" is(literal.string.doc)
+    r"\s*\n" is(text)
+    r"" is(generic) -> pop(2)
+
+  lex(indent6):
+    r"(?:\t| {1,7}\t| {8}){6}.*\n" is(literal.string.doc)
+    r"\s*\n" is(text)
+    r"" is(generic) -> pop(2)
+
+  lex(root):
+    r"\s+" is(text)
+    r"\#.*?\n" is(comment.single)
+    r"(mainmenu|config|menuconfig|choice|endchoice|comment|menu|endmenu|visible if|if|endif|source|prompt|select|depends on|default|range|option)\b" is(keyword)
+    r"(---help---|help)[\t ]*\n" is(keyword) -> go-to(help)
+    r"(bool|tristate|string|hex|int|defconfig_list|modules|env)\b" is(name.builtin)
+    r"[!=&|]" is(operator)
+    r"[()]" is(punctuation)
+    r"[0-9]+" is(literal.number.integer)
+    r"'(''|[^'])*'" is(literal.string.single)
+    r"\"(\"\"|[^\"])*\"" is(literal.string.double)
+    r"\S+" is(text)
+
+  lex(indent4):
+    r"(?:\t| {1,7}\t| {8}){4}.*\n" is(literal.string.doc)
+    r"\s*\n" is(text)
+    r"" is(generic) -> pop(2)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,104 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Koka"
+  aliases: ["koka"]
+  extensions: [".kk", ".kki"]
+  mimetypes: ["text/x-koka"]
+  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(string):
+    r"[^\\\"\n]+" is(literal.string.double)
+    any-of(escape-sequence)
+    r"[\"\n]" is(literal.string.double) -> pop
+
+  lex(type-nested):
+    r"[\)\]>]" is(keyword.type) -> pop
+    r"[\(\[<]" is(keyword.type) -> go-to(type-nested)
+    r"," is(keyword.type)
+    r"([a-z](?:[a-zA-Z0-9_]|\-[a-zA-Z])*)(\s*)(:)(?!:)" is(by-groups(name.variable, text, keyword.type))
+    any-of(type-content)
+
+  lex(char):
+    r"[^\\\'\n]+" is(literal.string.char)
+    any-of(escape-sequence)
+    r"[\'\n]" is(literal.string.char) -> pop
+
+  lex(alias-type):
+    r"=" is(keyword)
+    any-of(type)
+
+  lex(litstring):
+    r"[^\"]+" is(literal.string.double)
+    r"\"\"" is(literal.string.escape)
+    r"\"" is(literal.string.double) -> pop
+
+  lex(whitespace):
+    r"\s+" is(text)
+    r"/\*" is(comment.multiline) -> go-to(comment)
+    r"//.*$" is(comment.single)
+
+  lex(struct-type):
+    r"(?=\((?!,*\)))" is(punctuation) -> pop
+    any-of(type)
+
+  lex(root):
+    any-of(whitespace)
+    r"::?(?![\$%&\*\+@!/\\^\126=\.:\-\?\|<>]+)" is(keyword.type) -> go-to(type)
+    r"alias(?![a-zA-Z0-9_\-])" is(keyword) -> go-to(alias-type)
+    r"struct(?![a-zA-Z0-9_\-])" is(keyword) -> go-to(struct-type)
+    r"(type|cotype|rectype|alias|struct|enum)(?![a-zA-Z0-9_\-])" is(keyword) -> go-to(type)
+    r"(module)(\s*)((?:interface)?)(\s*)((?:[a-z](?:[a-zA-Z0-9_]|\-[a-zA-Z])*\.)*[a-z](?:[a-zA-Z0-9_]|\-[a-zA-Z])*)" is(by-groups(keyword, text, keyword, text, name.namespace))
+    r"(import)(\s+)((?:[a-z](?:[a-zA-Z0-9_]|\-[a-zA-Z])*\.)*[a-z](?:[a-zA-Z0-9_]|\-[a-zA-Z])*)(\s*)((?:as)?)((?:[A-Z](?:[a-zA-Z0-9_]|\-[a-zA-Z])*)?)" is(by-groups(keyword, text, name.namespace, text, keyword, name.namespace))
+    r"(forall|exists|some|with)(?![a-zA-Z0-9_\-])" is(keyword.type)
+    r"(infix|infixr|infixl|prefix|postfix|type|cotype|rectype|alias|struct|con|fun|function|val|var|external|if|then|else|elif|return|match|private|public|private|module|import|as|include|inline|rec|try|yield|enum|interface|instance)(?![a-zA-Z0-9_\-])" is(keyword)
+    r"(for|while|repeat|foreach|foreach-indexed|error|catch|finally|cs|js|file|ref|assigned)(?![a-zA-Z0-9_\-])" is(keyword.pseudo)
+    r"::|:=|\->|[=\.:](?![\$%&\*\+@!/\\^\126=\.:\-\?\|<>]+)" is(keyword)
+    r"\-(?![\$%&\*\+@!/\\^\126=\.:\-\?\|<>]+)" is(generic.strong)
+    r"[A-Z]([a-zA-Z0-9_]|\-[a-zA-Z])*(?=\.)" is(name.namespace)
+    r"[A-Z]([a-zA-Z0-9_]|\-[a-zA-Z])*(?!\.)" is(name.class)
+    r"[a-z]([a-zA-Z0-9_]|\-[a-zA-Z])*" is(name)
+    r"_([a-zA-Z0-9_]|\-[a-zA-Z])*" is(name.variable)
+    r"@\"" is(literal.string.double) -> go-to(litstring)
+    r"[\$%&\*\+@!/\\^\126=\.:\-\?\|<>]+" is(operator)
+    r"`" is(operator)
+    r"[\{\}\(\)\[\];,]" is(punctuation)
+    r"[0-9]+\.[0-9]+([eE][\-\+]?[0-9]+)?" is(literal.number.float)
+    r"0[xX][0-9a-fA-F]+" is(literal.number.hex)
+    r"[0-9]+" is(literal.number.integer)
+    r"'" is(literal.string.char) -> go-to(char)
+    r"\"" is(literal.string.double) -> go-to(string)
+
+  lex(escape-sequence):
+    r"\\[abfnrtv0\\\\"\'\?]" is(literal.string.escape)
+    r"\\x[0-9a-fA-F]{2}" is(literal.string.escape)
+    r"\\u[0-9a-fA-F]{4}" is(literal.string.escape)
+    r"\\U[0-9a-fA-F]{6}" is(literal.string.escape)
+
+  lex(type-content):
+    any-of(whitespace)
+    r"(forall|exists|some|with)(?![a-zA-Z0-9_\-])" is(keyword.type)
+    r"(?=((infix|infixr|infixl|prefix|postfix|type|cotype|rectype|alias|struct|con|fun|function|val|var|external|if|then|else|elif|return|match|private|public|private|module|import|as|include|inline|rec|try|yield|enum|interface|instance)(?![a-zA-Z0-9_\-])))" is(keyword) -> pop
+    r"[EPH](?![a-zA-Z0-9_\-])" is(keyword.type)
+    r"[*!]" is(keyword.type)
+    r"[A-Z]([a-zA-Z0-9_]|\-[a-zA-Z])*(?=\.)" is(name.namespace)
+    r"[A-Z]([a-zA-Z0-9_]|\-[a-zA-Z])*(?!\.)" is(name.class)
+    r"[a-z][0-9]*(?![a-zA-Z_\-])" is(keyword.type)
+    r"_([a-zA-Z0-9_]|\-[a-zA-Z])*" is(keyword.type)
+    r"[a-z]([a-zA-Z0-9_]|\-[a-zA-Z])*" is(keyword.type)
+    r"::|\->|[\.:|]" is(keyword.type)
+    r"" is(text) -> pop
+
+  lex(type):
+    r"[\(\[<]" is(keyword.type) -> go-to(type-nested)
+    any-of(type-content)
+
+const-set(.Lexer, lexer)