broomhlda 0.1.0

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

@@ -0,0 +1,128 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Cython"
+  aliases: ["cython", "pyx"]
+  extensions: [".pyx", ".pxd", ".pxi"]
+  mimetypes: ["text/x-cython", "application/x-cython"]
+  start: .root
+  flags: 0
+
+  lex(tsqs):
+    r"'''" is(literal.string) -> pop
+    any-of(strings)
+    any-of(nl)
+
+  lex(builtins):
+    r"(?<!\.)(__import__|abs|all|any|apply|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|exit|file|filter|float|frozenset|getattr|globals|hasattr|hash|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b" is(name.builtin)
+    r"(?<!\.)(self|None|Ellipsis|NotImplemented|False|True|NULL)\b" is(name.builtin.pseudo)
+    r"(?<!\.)(ArithmeticError|AssertionError|AttributeError|BaseException|DeprecationWarning|EOFError|EnvironmentError|Exception|FloatingPointError|FutureWarning|GeneratorExit|IOError|ImportError|ImportWarning|IndentationError|IndexError|KeyError|KeyboardInterrupt|LookupError|MemoryError|NameError|NotImplemented|NotImplementedError|OSError|OverflowError|OverflowWarning|PendingDeprecationWarning|ReferenceError|RuntimeError|RuntimeWarning|StandardError|StopIteration|SyntaxError|SyntaxWarning|SystemError|SystemExit|TabError|TypeError|UnboundLocalError|UnicodeDecodeError|UnicodeEncodeError|UnicodeError|UnicodeTranslateError|UnicodeWarning|UserWarning|ValueError|Warning|ZeroDivisionError)\b" is(name.exception)
+
+  lex(name):
+    r"@[a-zA-Z0-9_]+" is(name.decorator)
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name)
+
+  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(tdqs):
+    r"\"\"\"" is(literal.string) -> pop
+    any-of(strings)
+    any-of(nl)
+
+  lex(backtick):
+    r"`.*?`" is(literal.string.backtick)
+
+  lex(funcname):
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name.function) -> pop
+
+  lex(classname):
+    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(numbers):
+    r"(\d+\.?\d*|\d*\.\d+)([eE][+-]?[0-9]+)?" is(literal.number.float)
+    r"0\d+" is(literal.number.oct)
+    r"0[xX][a-fA-F0-9]+" is(literal.number.hex)
+    r"\d+L" is(literal.number.integer.long)
+    r"\d+" is(literal.number.integer)
+
+  lex(import):
+    r"(\s+)(as)(\s+)" is(by-groups(text, keyword, text))
+    r"[a-zA-Z_][a-zA-Z0-9_.]*" is(name.namespace)
+    r"(\s*)(,)(\s*)" is(by-groups(text, operator, text))
+    r"" is(text) -> pop
+
+  lex(keywords):
+    r"(assert|break|by|continue|ctypedef|del|elif|else|except\??|exec|finally|for|gil|global|if|include|lambda|nogil|pass|print|raise|return|try|while|yield|as|with)\b" is(keyword)
+    r"(DEF|IF|ELIF|ELSE)\b" is(comment.preproc)
+
+  lex(cdef):
+    r"(public|readonly|extern|api|inline)\b" is(keyword.reserved)
+    r"(struct|enum|union|class)\b" is(keyword)
+    r"([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(?=[(:\#=]|$)" is(by-groups(name.function, text)) -> pop
+    r"([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(,)" is(by-groups(name.function, text, punctuation))
+    r"from\b" is(keyword) -> pop
+    r"as\b" is(keyword)
+    r":" is(punctuation) -> pop
+    r"(?=[\"\'])" is(text) -> pop
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(keyword.type)
+    r"." is(text)
+
+  lex(nl):
+    r"\n" is(literal.string)
+
+  lex(root):
+    r"\n" is(text)
+    r"^(\s*)(\"\"\"(?:.|\n)*?\"\"\")" is(by-groups(text, literal.string.doc))
+    r"^(\s*)('''(?:.|\n)*?''')" is(by-groups(text, literal.string.doc))
+    r"[^\S\n]+" is(text)
+    r"\#.*$" is(comment)
+    r"[\]{}:(),;\[]" is(punctuation)
+    r"\\\n" is(text)
+    r"\\" is(text)
+    r"(in|is|and|or|not)\b" is(operator.word)
+    r"(<)([a-zA-Z0-9.?]+)(>)" is(by-groups(punctuation, keyword.type, punctuation))
+    r"!=|==|<<|>>|[-\126+/*%=<>&^|.?]" is(operator)
+    r"(from)(\d+)(<=)(\s+)(<)(\d+)(:)" is(by-groups(keyword, literal.number.integer, operator, name, operator, name, punctuation))
+    any-of(keywords)
+    r"(def|property)(\s+)" is(by-groups(keyword, text)) -> go-to(funcname)
+    r"(cp?def)(\s+)" is(by-groups(keyword, text)) -> go-to(cdef)
+    r"(class|struct)(\s+)" is(by-groups(keyword, text)) -> go-to(classname)
+    r"(from)(\s+)" is(by-groups(keyword, text)) -> go-to(fromimport)
+    r"(c?import)(\s+)" is(by-groups(keyword, text)) -> go-to(import)
+    any-of(builtins)
+    any-of(backtick)
+    r"(?:[rR]|[uU][rR]|[rR][uU])\"\"\"" is(literal.string) -> go-to(tdqs)
+    r"(?:[rR]|[uU][rR]|[rR][uU])'''" is(literal.string) -> go-to(tsqs)
+    r"(?:[rR]|[uU][rR]|[rR][uU])\"" is(literal.string) -> go-to(dqs)
+    r"(?:[rR]|[uU][rR]|[rR][uU])'" is(literal.string) -> go-to(sqs)
+    r"[uU]?\"\"\"" is(literal.string) -> combined(stringescape, tdqs)
+    r"[uU]?'''" is(literal.string) -> combined(stringescape, tsqs)
+    r"[uU]?\"" is(literal.string) -> combined(stringescape, dqs)
+    r"[uU]?'" is(literal.string) -> combined(stringescape, sqs)
+    any-of(name)
+    any-of(numbers)
+
+  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(fromimport):
+    r"(\s+)(c?import)\b" is(by-groups(text, keyword)) -> pop
+    r"[a-zA-Z_.][a-zA-Z0-9_.]*" is(name.namespace)
+    r"" is(text) -> pop
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,102 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "D"
+  aliases: ["d"]
+  extensions: [".d", ".di"]
+  mimetypes: ["text/x-dsrc"]
+  start: .root
+  flags: 0
+
+  lex(delimited-parenthesis):
+    r"[^\(\)]+" is(literal.string)
+    r"\(" is(literal.string) -> go-to(delimited-inside-parenthesis)
+    r"\)\"" is(literal.string) -> pop
+
+  lex(delimited-curly):
+    r"[^{}]+" is(literal.string)
+    r"{" is(literal.string) -> go-to(delimited-inside-curly)
+    r"}\"" is(literal.string) -> pop
+
+  lex(delimited-angle):
+    r"[^<>]+" is(literal.string)
+    r"<" is(literal.string) -> go-to(delimited-inside-angle)
+    r">\"" is(literal.string) -> pop
+
+  lex(delimited-inside-parenthesis):
+    r"[^\(\)]+" is(literal.string)
+    r"\(" is(literal.string) -> push
+    r"\)" is(literal.string) -> pop
+
+  lex(delimited-inside-curly):
+    r"[^{}]+" is(literal.string)
+    r"{" is(literal.string) -> push
+    r"}" is(literal.string) -> pop
+
+  lex(delimited-inside-bracket):
+    r"[^\[\]]+" is(literal.string)
+    r"\[" is(literal.string) -> push
+    r"\]" is(literal.string) -> pop
+
+  lex(token-string-nest):
+    r"{" is(punctuation) -> push
+    r"}" is(punctuation) -> pop
+    any-of(root)
+
+  lex(delimited-bracket):
+    r"[^\[\]]+" is(literal.string)
+    r"\[" is(literal.string) -> go-to(delimited-inside-bracket)
+    r"\]\"" is(literal.string) -> pop
+
+  lex(token-string):
+    r"{" is(punctuation) -> go-to(token-string-nest)
+    r"}" is(literal.string) -> pop
+    any-of(root)
+
+  lex(delimited-inside-angle):
+    r"[^<>]+" is(literal.string)
+    r"<" is(literal.string) -> push
+    r">" is(literal.string) -> pop
+
+  lex(root):
+    r"\n" is(text)
+    r"\s+" is(text)
+    r"//(.*?)\n" is(comment.single)
+    r"/(\\\n)?[*](.|\n)*?[*](\\\n)?/" is(comment.multiline)
+    r"/\+" is(comment.multiline) -> go-to(nested-comment)
+    r"(abstract|alias|align|asm|assert|auto|body|break|case|cast|catch|class|const|continue|debug|default|delegate|delete|deprecated|do|else|enum|export|extern|finally|final|foreach_reverse|foreach|for|function|goto|if|import|inout|interface|invariant|in|is|lazy|mixin|module|new|nothrow|out|override|package|pragma|private|protected|public|pure|ref|return|scope|static|struct|super|switch|synchronized|template|this|throw|try|typedef|typeid|typeof|union|unittest|version|volatile|while|with|__traits)\b" is(keyword)
+    r"(bool|byte|cdouble|cent|cfloat|char|creal|dchar|double|float|idouble|ifloat|int|ireal|long|real|short|ubyte|ucent|uint|ulong|ushort|void|wchar)\b" is(keyword.type)
+    r"(false|true|null)\b" is(keyword.constant)
+    r"macro\b" is(keyword.reserved)
+    r"(string|wstring|dstring)\b" is(name.builtin)
+    r"0[xX]([0-9a-fA-F_]*\.[0-9a-fA-F_]+|[0-9a-fA-F_]+)[pP][+\-]?[0-9_]+[fFL]?[i]?" is(literal.number.float)
+    r"[0-9_]+(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*|[eE][+\-]?[0-9_]+)[fFL]?[i]?" is(literal.number.float)
+    r"\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[fFL]?[i]?" is(literal.number.float)
+    r"0[Bb][01_]+" is(literal.number)
+    r"0[0-7_]+" is(literal.number.oct)
+    r"0[xX][0-9a-fA-F_]+" is(literal.number.hex)
+    r"(0|[1-9][0-9_]*)([LUu]|Lu|LU|uL|UL)?" is(literal.number.integer)
+    r"'(\\['\"?\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\&\w+;|.)'" is(literal.string.char)
+    r"r\"[^\"]*\"[cwd]?" is(literal.string)
+    r"`[^`]*`[cwd]?" is(literal.string)
+    r"\"(\\\\|\\\"|[^\"])*\"[cwd]?" is(literal.string)
+    r"\\(['\\"?\\abfnrtv]|x[0-9a-fA-F]{2}|[0-7]{1,3}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|&\w+;)" is(literal.string)
+    r"x\"[0-9a-fA-F_\s]*\"[cwd]?" is(literal.string)
+    r"q\"\[" is(literal.string) -> go-to(delimited-bracket)
+    r"q\"\(" is(literal.string) -> go-to(delimited-parenthesis)
+    r"q\"<" is(literal.string) -> go-to(delimited-angle)
+    r"q\"{" is(literal.string) -> go-to(delimited-curly)
+    r"q\"([a-zA-Z_]\w*)\n.*?\n\1\"" is(literal.string)
+    r"q\"(.).*?\1\"" is(literal.string)
+    r"q{" is(literal.string) -> go-to(token-string)
+    r"(\126=|\^=|%=|\*=|==|!>=|!<=|!<>=|!<>|!<|!>|!=|>>>=|>>>|>>=|>>|>=|<>=|<>|<<=|<<|<=|\+\+|\+=|--|-=|\|\||\|=|&&|&=|\.\.\.|\.\.|/=)|[/.&|\-+<>!()\[\]{}?,;:$=*%^\126]" is(punctuation)
+    r"[a-zA-Z_]\w*" is(name)
+
+  lex(nested-comment):
+    r"[^+/]+" is(comment.multiline)
+    r"/\+" is(comment.multiline) -> push
+    r"\+/" is(comment.multiline) -> pop
+    r"[+/]" is(comment.multiline)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,45 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Darcs Patch"
+  aliases: ["dpatch"]
+  extensions: [".dpatch", ".darcspatch"]
+  mimetypes: []
+  start: .root
+  flags: 0
+
+  lex(comment):
+    r"[^\]].*\n" is(comment)
+    r"\]" is(operator) -> pop
+
+  lex(insert):
+    any-of(specialText)
+    r"\[" is(generic.inserted)
+    r"[^\n\[]+" is(generic.inserted)
+
+  lex(delete):
+    any-of(specialText)
+    r"\[" is(generic.deleted)
+    r"[^\n\[]+" is(generic.deleted)
+
+  lex(root):
+    r"<" is(operator)
+    r">" is(operator)
+    r"{" is(operator)
+    r"}" is(operator)
+    r"(\[)((?:TAG )?)(.*)(\n)(.*)(\*\*)(\d+)(\s?)(\])" is(by-groups(operator, keyword, name, text, name, operator, literal.date, text, operator))
+    r"(\[)((?:TAG )?)(.*)(\n)(.*)(\*\*)(\d+)(\s?)" is(by-groups(operator, keyword, name, text, name, operator, literal.date, text)) -> go-to(comment)
+    r"New patches:" is(generic.heading)
+    r"Context:" is(generic.heading)
+    r"Patch bundle hash:" is(generic.heading)
+    r"(\s*)(hunk|addfile|adddir|rmfile|rmdir|move|replace)(.*\n)" is(by-groups(text, keyword, text))
+    r"\+" is(generic.inserted) -> go-to(insert)
+    r"-" is(generic.deleted) -> go-to(delete)
+    r".*\n" is(text)
+
+  lex(specialText):
+    r"\n" is(text) -> pop
+    r"\[_[^_]*_]" is(operator)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,84 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Dart"
+  aliases: ["dart"]
+  extensions: [".dart"]
+  mimetypes: ["text/x-dart"]
+  start: .root
+  flags: Regexp MULTILINE
+
+  lex(string-single-multiline):
+    r"'''" is(literal.string.single) -> pop
+    r"[^\'$\\]+" is(literal.string.single)
+    any-of(string-common)
+    r"(\$|\')+" is(literal.string.single)
+
+  lex(string-single):
+    r"'" is(literal.string.single) -> pop
+    r"[^\'$\\\n]+" is(literal.string.single)
+    any-of(string-common)
+    r"\$+" is(literal.string.single)
+
+  lex(string-common):
+    r"\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\{[0-9A-Fa-f]*\}|[a-z\'\\"$\\])" is(literal.string.escape)
+    r"(\$)([a-zA-Z_][a-zA-Z0-9_]*)" is(by-groups(literal.string.interpol, name))
+    r"(\$\{)(.*?)(\})" is(by-groups(literal.string.interpol, using(self class), literal.string.interpol))
+
+  lex(string-literal):
+    r"r\"\"\"([\s|\S]*?)\"\"\"" is(literal.string.double)
+    r"r'''([\s|\S]*?)'''" is(literal.string.single)
+    r"r\"(.*?)\"" is(literal.string.double)
+    r"r'(.*?)'" is(literal.string.single)
+    r"\"\"\"" is(literal.string.double) -> go-to(string-double-multiline)
+    r"'''" is(literal.string.single) -> go-to(string-single-multiline)
+    r"\"" is(literal.string.double) -> go-to(string-double)
+    r"'" is(literal.string.single) -> go-to(string-single)
+
+  lex(string-double):
+    r"\"" is(literal.string.double) -> pop
+    r"[^\\"$\\\n]+" is(literal.string.double)
+    any-of(string-common)
+    r"\$+" is(literal.string.double)
+
+  lex(import-decl):
+    any-of(string-literal)
+    r"\s+" is(text)
+    r"\b(as|show|hide)\b" is(keyword)
+    r"[a-zA-Z_$][a-zA-Z0-9_]*" is(name)
+    r"\," is(punctuation)
+    r"\;" is(punctuation) -> pop
+
+  lex(string-double-multiline):
+    r"\"\"\"" is(literal.string.double) -> pop
+    r"[^\\"$\\]+" is(literal.string.double)
+    any-of(string-common)
+    r"(\$|\\")+" is(literal.string.double)
+
+  lex(root):
+    any-of(string-literal)
+    r"\#!(.*?)$" is(comment.preproc)
+    r"\b(import|export)\b" is(keyword) -> go-to(import-decl)
+    r"\b(library|source|part of|part)\b" is(keyword)
+    r"[^\S\n]+" is(text)
+    r"//.*?\n" is(comment.single)
+    r"/\*.*?\*/" is(comment.multiline)
+    r"\b(class)\b(\s+)" is(by-groups(keyword.declaration, text)) -> go-to(class)
+    r"\b(assert|break|case|catch|continue|default|do|else|finally|for|if|in|is|new|return|super|switch|this|throw|try|while)\b" is(keyword)
+    r"\b(abstract|const|extends|factory|final|get|implements|native|operator|set|static|typedef|var)\b" is(keyword.declaration)
+    r"\b(bool|double|Dynamic|int|num|Object|String|void)\b" is(keyword.type)
+    r"\b(false|null|true)\b" is(keyword.constant)
+    r"[\126!%^&*+=|?:<>/-]|as" is(operator)
+    r"[a-zA-Z_$][a-zA-Z0-9_]*:" is(name.label)
+    r"[a-zA-Z_$][a-zA-Z0-9_]*" is(name)
+    r"[(){}\[\],.;]" is(punctuation)
+    r"0[xX][0-9a-fA-F]+" is(literal.number.hex)
+    r"\d+(\.\d*)?([eE][+-]?\d+)?" is(literal.number)
+    r"\.\d+([eE][+-]?\d+)?" is(literal.number)
+    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/debiancontrol.ay

@@ -0,0 +1,51 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Debian Control file"
+  aliases: ["control"]
+  extensions: ["control"]
+  mimetypes: []
+  start: .root
+  flags: 0
+
+  lex(maintainer):
+    r"<[^>]+>" is(generic.strong)
+    r"<[^>]+>$" is(generic.strong) -> pop
+    r",\n?" is(text)
+    r"." is(text)
+
+  lex(depends):
+    r":\s*" is(text)
+    r"(\$)(\{)(\w+\s*:\s*\w+)" is(by-groups(operator, text, name.entity))
+    r"\(" is(text) -> go-to(depend-vers)
+    r"," is(text)
+    r"\|" is(operator)
+    r"[\s]+" is(text)
+    r"[}\)]\s*$" is(text) -> pop
+    r"}" is(text)
+    r"[^,]$" is(name.function) -> pop
+    r"([\+\.a-zA-Z0-9-])(\s*)" is(by-groups(name.function, text))
+    r"\[.*?\]" is(name.entity)
+
+  lex(root):
+    r"^(Description)" is(keyword) -> go-to(description)
+    r"^(Maintainer)(:\s*)" is(by-groups(keyword, text)) -> go-to(maintainer)
+    r"^((Build-)?Depends)" is(keyword) -> go-to(depends)
+    r"^((?:Python-)?Version)(:\s*)(\S+)$" is(by-groups(keyword, text, literal.number))
+    r"^((?:Installed-)?Size)(:\s*)(\S+)$" is(by-groups(keyword, text, literal.number))
+    r"^(MD5Sum|SHA1|SHA256)(:\s*)(\S+)$" is(by-groups(keyword, text, literal.number))
+    r"^([a-zA-Z\-0-9\.]*?)(:\s*)(.*?)$" is(by-groups(keyword, text.whitespace, literal.string))
+
+  lex(description):
+    r"(.*)(Homepage)(: )(\S+)" is(by-groups(text, literal.string, name, name.class))
+    r":.*\n" is(generic.strong)
+    r" .*\n" is(text)
+    r"" is(text) -> pop
+
+  lex(depend-vers):
+    r"\)," is(text) -> pop
+    r"\)[^,]" is(text) -> pop(2)
+    r"([><=]+)(\s*)([^\)]+)" is(by-groups(operator, text, literal.number))
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,61 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "dg"
+  aliases: ["dg"]
+  extensions: [".dg"]
+  mimetypes: ["text/x-dg"]
+  start: .root
+  flags: 0
+
+  lex(tsqs):
+    r"'''" is(literal.string) -> pop
+
+  lex(string):
+    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)
+    r"\n" is(literal.string)
+
+  lex(dqs):
+    r"\"" is(literal.string) -> pop
+
+  lex(sqs):
+    r"'" is(literal.string) -> pop
+
+  lex(root):
+    r"\s+" is(text)
+    r"\#.*?$" is(comment.single)
+    r"0[bB][01]+" is(literal.number.bin)
+    r"0[oO][0-7]+" is(literal.number.oct)
+    r"0[xX][\da-fA-F]+" is(literal.number.hex)
+    r"[+-]?\d+\.\d+([eE][+-]?\d+)?[jJ]?" is(literal.number.float)
+    r"[+-]?\d+[eE][+-]?\d+[jJ]?" is(literal.number.float)
+    r"[+-]?\d+[jJ]?" is(literal.number.integer)
+    r"[br]*'''" is(literal.string) -> combined(stringescape, tsqs, string)
+    r"[br]*\"\"\"" is(literal.string) -> combined(stringescape, tdqs, string)
+    r"[br]*'" is(literal.string) -> combined(stringescape, sqs, string)
+    r"[br]*\"" is(literal.string) -> combined(stringescape, dqs, string)
+    r"`\w+'*`" is(operator)
+    r"\b(or|and|if|else|where|is|in)\b" is(operator.word)
+    r"[!$%&*+\-./:<-@\\^|\126;,]+" is(operator)
+    r"(?<!\.)(bool|bytearray|bytes|classmethod|complex|dict'?|float|frozenset|int|list'?|memoryview|object|property|range|set'?|slice|staticmethod|str|super|tuple'?|type)(?!['\w])" is(name.builtin)
+    r"(?<!\.)(__import__|abs|all|any|bin|bind|chr|cmp|compile|complex|delattr|dir|divmod|drop|dropwhile|enumerate|eval|filter|flip|foldl1?|format|fst|getattr|globals|hasattr|hash|head|hex|id|init|input|isinstance|issubclass|iter|iterate|last|len|locals|map|max|min|next|oct|open|ord|pow|print|repr|reversed|round|setattr|scanl1?|snd|sorted|sum|tail|take|takewhile|vars|zip)(?!['\w])" is(name.builtin)
+    r"(?<!\.)(self|Ellipsis|NotImplemented|None|True|False)(?!['\w])" is(name.builtin.pseudo)
+    r"(?<!\.)[A-Z]\w*(Error|Exception|Warning)'*(?!['\w])" is(name.exception)
+    r"(?<!\.)(KeyboardInterrupt|SystemExit|StopIteration|GeneratorExit)(?!['\w])" is(name.exception)
+    r"(?<![\.\w])(import|inherit|for|while|switch|not|raise|unsafe|yield|with)(?!['\w])" is(keyword.reserved)
+    r"[A-Z_']+\b" is(name)
+    r"[A-Z][\w']*\b" is(keyword.type)
+    r"\w+'*" is(name)
+    r"[()]" is(punctuation)
+
+  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
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,22 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Diff"
+  aliases: ["diff", "udiff"]
+  extensions: [".diff", ".patch"]
+  mimetypes: ["text/x-diff", "text/x-patch"]
+  start: .root
+  flags: 0
+
+  lex(root):
+    r" .*\n" is(text)
+    r"\+.*\n" is(generic.inserted)
+    r"-.*\n" is(generic.deleted)
+    r"!.*\n" is(generic.strong)
+    r"@.*\n" is(generic.subheading)
+    r"([Ii]ndex|diff).*\n" is(generic.heading)
+    r"=.*\n" is(generic.heading)
+    r".*\n" is(text)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,46 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Django/Jinja"
+  aliases: ["django", "jinja"]
+  extensions: []
+  mimetypes: ["application/x-django-templating", "application/x-jinja"]
+  start: .root
+  flags: Regexp MULTILINE
+
+  lex(var):
+    r"\s+" is(text)
+    r"(-?)(\}\})" is(by-groups(text, comment.preproc)) -> pop
+    any-of(varnames)
+
+  lex(varnames):
+    r"(\|)(\s*)([a-zA-Z_][a-zA-Z0-9_]*)" is(by-groups(operator, text, name.function))
+    r"(is)(\s+)(not)?(\s+)?([a-zA-Z_][a-zA-Z0-9_]*)" is(by-groups(keyword, text, keyword, text, name.function))
+    r"(_|true|false|none|True|False|None)\b" is(keyword.pseudo)
+    r"(in|as|reversed|recursive|not|and|or|is|if|else|import|with(?:(?:out)?\s*context)?|scoped|ignore\s+missing)\b" is(keyword)
+    r"(loop|block|super|forloop)\b" is(name.builtin)
+    r"[a-zA-Z][a-zA-Z0-9_-]*" is(name.variable)
+    r"\.[a-zA-Z0-9_]+" is(name.variable)
+    r":?\"(\\\\|\\\"|[^\"])*\"" is(literal.string.double)
+    r":?'(\\\\|\\'|[^'])*'" is(literal.string.single)
+    r"([{}()\[\]+\-*/,:\126]|[><=]=?)" is(operator)
+    r"[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?" is(literal.number)
+
+  lex(root):
+    r"[^{]+" is(other)
+    r"\{\{" is(comment.preproc) -> go-to(var)
+    r"\{[*\#].*?[*\#]\}" is(comment)
+    r"(\{%)(-?\s*)(comment)(\s*-?)(%\})(.*?)(\{%)(-?\s*)(endcomment)(\s*-?)(%\})" is(by-groups(comment.preproc, text, keyword, text, comment.preproc, comment, comment.preproc, text, keyword, text, comment.preproc))
+    r"(\{%)(-?\s*)(raw)(\s*-?)(%\})(.*?)(\{%)(-?\s*)(endraw)(\s*-?)(%\})" is(by-groups(comment.preproc, text, keyword, text, comment.preproc, text, comment.preproc, text, keyword, text, comment.preproc))
+    r"(\{%)(-?\s*)(filter)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)" is(by-groups(comment.preproc, text, keyword, text, name.function)) -> go-to(block)
+    r"(\{%)(-?\s*)([a-zA-Z_][a-zA-Z0-9_]*)" is(by-groups(comment.preproc, text, keyword)) -> go-to(block)
+    r"\{" is(other)
+
+  lex(block):
+    r"\s+" is(text)
+    r"(-?)(%\})" is(by-groups(text, comment.preproc)) -> pop
+    any-of(varnames)
+    r"." is(punctuation)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,62 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "DTD"
+  aliases: ["dtd"]
+  extensions: [".dtd"]
+  mimetypes: ["application/xml-dtd"]
+  start: .root
+  flags: Regexp MULTILINE
+
+  lex(comment):
+    r"[^-]+" is(comment)
+    r"-->" is(comment) -> pop
+    r"-" is(comment)
+
+  lex(notation):
+    any-of(common)
+    r"SYSTEM|PUBLIC" is(keyword.constant)
+    r"[^>\s\|()?+*,]+" is(name.attribute)
+    r">" is(keyword) -> pop
+
+  lex(entity):
+    any-of(common)
+    r"SYSTEM|PUBLIC|NDATA" is(keyword.constant)
+    r"[^>\s\|()?+*,]+" is(name.entity)
+    r">" is(keyword) -> pop
+
+  lex(common):
+    r"\s+" is(text)
+    r"(%|&)[^;]*;" is(name.entity)
+    r"<!--" is(comment) -> go-to(comment)
+    r"[(|)*,?+]" is(operator)
+    r"\"[^\"]*\"" is(literal.string.double)
+    r"\'[^\']*\'" is(literal.string.single)
+
+  lex(element):
+    any-of(common)
+    r"EMPTY|ANY|\#PCDATA" is(keyword.constant)
+    r"[^>\s\|()?+*,]+" is(name.tag)
+    r">" is(keyword) -> pop
+
+  lex(root):
+    any-of(common)
+    r"(<!ELEMENT)(\s+)(\S+)" is(by-groups(keyword, text, name.tag)) -> go-to(element)
+    r"(<!ATTLIST)(\s+)(\S+)" is(by-groups(keyword, text, name.tag)) -> go-to(attlist)
+    r"(<!ENTITY)(\s+)(\S+)" is(by-groups(keyword, text, name.entity)) -> go-to(entity)
+    r"(<!NOTATION)(\s+)(\S+)" is(by-groups(keyword, text, name.tag)) -> go-to(notation)
+    r"(<!\[)([^\[\s]+)(\s*)(\[)" is(by-groups(keyword, name.entity, text, keyword))
+    r"(<!DOCTYPE)(\s+)([^>\s]+)" is(by-groups(keyword, text, name.tag))
+    r"PUBLIC|SYSTEM" is(keyword.constant)
+    r"[\[\]>]" is(keyword)
+
+  lex(attlist):
+    any-of(common)
+    r"CDATA|IDREFS|IDREF|ID|NMTOKENS|NMTOKEN|ENTITIES|ENTITY|NOTATION" is(keyword.constant)
+    r"\#REQUIRED|\#IMPLIED|\#FIXED" is(keyword.constant)
+    r"xml:space|xml:lang" is(keyword.reserved)
+    r"[^>\s\|()?+*,]+" is(name.attribute)
+    r">" is(keyword) -> pop
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,60 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Dylan"
+  aliases: ["dylan"]
+  extensions: [".dylan", ".dyl", ".intr"]
+  mimetypes: ["text/x-dylan"]
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(comment):
+    r"[^*/]" is(comment.multiline)
+    r"/\*" is(comment.multiline) -> push
+    r"\*/" is(comment.multiline) -> pop
+    r"[*/]" is(comment.multiline)
+
+  lex(code):
+    r"\s+" is(text)
+    r"//.*?\n" is(comment.single)
+    r"/\*" is(comment.multiline) -> go-to(comment)
+    r"\"" is(literal.string) -> go-to(string)
+    r"'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'" is(literal.string.char)
+    r"\#[bB][01]+" is(literal.number)
+    r"\#[oO][0-7]+" is(literal.number.oct)
+    r"[-+]?(\d*\.\d+(e[-+]?\d+)?|\d+(\.\d*)?e[-+]?\d+)" is(literal.number.float)
+    r"[-+]?\d+" is(literal.number.integer)
+    r"\#[xX][0-9a-fA-F]+" is(literal.number.hex)
+    r"(\?\\?[a-zA-Z0-9\!\&\*\<\>\|\^\$\%\@\_\-\+\\126\?\/\=]+)(:)(token|name|variable|expression|body|case-body|\*)" is(by-groups(name.tag, operator, name.builtin))
+    r"(\?)(:)(token|name|variable|expression|body|case-body|\*)" is(by-groups(name.tag, operator, name.builtin))
+    r"\?\\?[a-zA-Z0-9\!\&\*\<\>\|\^\$\%\@\_\-\+\\126\?\/\=]+" is(name.tag)
+    r"(=>|::|\#\(|\#\[|\#\#|\?|\?\?|\?=|[(){}\[\],\.;])" is(punctuation)
+    r":=" is(operator)
+    r"\#[tf]" is(literal)
+    r"\#\"" is(literal.string.symbol) -> go-to(keyword)
+    r"\#[a-zA-Z0-9-]+" is(keyword)
+    r"\\?[a-zA-Z0-9\!\&\*\<\>\|\^\$\%\@\_\-\+\\126\?\/\=]+:" is(keyword)
+    r"<\\?[a-zA-Z0-9\!\&\*\<\>\|\^\$\%\@\_\-\+\\126\?\/\=]+>" is(name.class)
+    r"\*\\?[a-zA-Z0-9\!\&\*\<\>\|\^\$\%\@\_\-\+\\126\?\/\=]+\*" is(name.variable.global)
+    r"\$\\?[a-zA-Z0-9\!\&\*\<\>\|\^\$\%\@\_\-\+\\126\?\/\=]+" is(name.constant)
+    r"\\?[a-zA-Z0-9\!\&\*\<\>\|\^\$\%\@\_\-\+\\126\?\/\=]+" is(name)
+
+  lex(root):
+    r"\s+" is(text)
+    r"//.*?\n" is(comment.single)
+    r"([A-Za-z0-9-]+)(:)([ \t]*)(.*(?:\n[ \t].+)*)" is(by-groups(name.attribute, operator, text, literal.string))
+    r"" is(text) -> go-to(code)
+
+  lex(string):
+    r"\"" is(literal.string) -> pop
+    r"\\([\\abfnrtv\"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})" is(literal.string.escape)
+    r"[^\\\"\n]+" is(literal.string)
+    r"\\\n" is(literal.string)
+    r"\\" is(literal.string)
+
+  lex(keyword):
+    r"\"" is(literal.string.symbol) -> pop
+    r"[^\\\"]+" is(literal.string.symbol)
+
+const-set(.Lexer, lexer)