broomhlda 0.1.0

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

@@ -0,0 +1,115 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "SCSS"
+  aliases: ["scss"]
+  extensions: [".scss"]
+  mimetypes: ["text/x-scss"]
+  start: .root
+  flags: Regexp IGNORECASE | Regexp MULTILINE
+
+  lex(string-url):
+    r"(\\\#|\#(?=[^\n{])|[^\n\#)])+" is(literal.string.other)
+    r"\#\{" is(literal.string.interpol) -> go-to(interpolation)
+    r"\)" is(literal.string.other) -> pop
+
+  lex(attr):
+    r"[^\s:=\"\[]+" is(name.attribute)
+    r"\#{" is(literal.string.interpol) -> go-to(interpolation)
+    r"[ \t]*:" is(operator) -> go-to(value)
+
+  lex(string-double):
+    r"(\\.|\#(?=[^\n{])|[^\n\"\#])+" is(literal.string.double)
+    r"\#\{" is(literal.string.interpol) -> go-to(interpolation)
+    r"\"" is(literal.string.double) -> pop
+
+  lex(class):
+    r"[\w-]+" is(name.class)
+    r"\#\{" is(literal.string.interpol) -> go-to(interpolation)
+    r"" is(text) -> pop
+
+  lex(pseudo-class):
+    r"[\w-]+" is(name.decorator)
+    r"\#\{" is(literal.string.interpol) -> go-to(interpolation)
+    r"" is(text) -> pop
+
+  lex(value):
+    r"[ \t]+" is(text)
+    r"[!$][\w-]+" is(name.variable)
+    r"url\(" is(literal.string.other) -> go-to(string-url)
+    r"[a-z_-][\w-]*(?=\()" is(name.function)
+    r"(azimuth|background-attachment|background-color|background-image|background-position|background-repeat|background|border-bottom-color|border-bottom-style|border-bottom-width|border-left-color|border-left-style|border-left-width|border-right|border-right-color|border-right-style|border-right-width|border-top-color|border-top-style|border-top-width|border-bottom|border-collapse|border-left|border-width|border-color|border-spacing|border-style|border-top|border|caption-side|clear|clip|color|content|counter-increment|counter-reset|cue-after|cue-before|cue|cursor|direction|display|elevation|empty-cells|float|font-family|font-size|font-size-adjust|font-stretch|font-style|font-variant|font-weight|font|height|letter-spacing|line-height|list-style-type|list-style-image|list-style-position|list-style|margin-bottom|margin-left|margin-right|margin-top|margin|marker-offset|marks|max-height|max-width|min-height|min-width|opacity|orphans|outline|outline-color|outline-style|outline-width|overflow|padding-bottom|padding-left|padding-right|padding-top|padding|page|page-break-after|page-break-before|page-break-inside|pause-after|pause-before|pause|pitch|pitch-range|play-during|position|quotes|richness|right|size|speak-header|speak-numeral|speak-punctuation|speak|speech-rate|stress|table-layout|text-align|text-decoration|text-indent|text-shadow|text-transform|top|unicode-bidi|vertical-align|visibility|voice-family|volume|white-space|widows|width|word-spacing|z-index|bottom|left|above|absolute|always|armenian|aural|auto|avoid|baseline|behind|below|bidi-override|blink|block|bold|bolder|both|capitalize|center-left|center-right|center|circle|cjk-ideographic|close-quote|collapse|condensed|continuous|crop|crosshair|cross|cursive|dashed|decimal-leading-zero|decimal|default|digits|disc|dotted|double|e-resize|embed|extra-condensed|extra-expanded|expanded|fantasy|far-left|far-right|faster|fast|fixed|georgian|groove|hebrew|help|hidden|hide|higher|high|hiragana-iroha|hiragana|icon|inherit|inline-table|inline|inset|inside|invert|italic|justify|katakana-iroha|katakana|landscape|larger|large|left-side|leftwards|level|lighter|line-through|list-item|loud|lower-alpha|lower-greek|lower-roman|lowercase|ltr|lower|low|medium|message-box|middle|mix|monospace|n-resize|narrower|ne-resize|no-close-quote|no-open-quote|no-repeat|none|normal|nowrap|nw-resize|oblique|once|open-quote|outset|outside|overline|pointer|portrait|px|relative|repeat-x|repeat-y|repeat|rgb|ridge|right-side|rightwards|s-resize|sans-serif|scroll|se-resize|semi-condensed|semi-expanded|separate|serif|show|silent|slow|slower|small-caps|small-caption|smaller|soft|solid|spell-out|square|static|status-bar|super|sw-resize|table-caption|table-cell|table-column|table-column-group|table-footer-group|table-header-group|table-row|table-row-group|text|text-bottom|text-top|thick|thin|transparent|ultra-condensed|ultra-expanded|underline|upper-alpha|upper-latin|upper-roman|uppercase|url|visible|w-resize|wait|wider|x-fast|x-high|x-large|x-loud|x-low|x-small|x-soft|xx-large|xx-small|yes)\b" is(name.constant)
+    r"(indigo|gold|firebrick|indianred|darkolivegreen|darkseagreen|mediumvioletred|mediumorchid|chartreuse|mediumslateblue|springgreen|crimson|lightsalmon|brown|turquoise|olivedrab|cyan|skyblue|darkturquoise|goldenrod|darkgreen|darkviolet|darkgray|lightpink|darkmagenta|lightgoldenrodyellow|lavender|yellowgreen|thistle|violet|orchid|ghostwhite|honeydew|cornflowerblue|darkblue|darkkhaki|mediumpurple|cornsilk|bisque|slategray|darkcyan|khaki|wheat|deepskyblue|darkred|steelblue|aliceblue|gainsboro|mediumturquoise|floralwhite|coral|lightgrey|lightcyan|darksalmon|beige|azure|lightsteelblue|oldlace|greenyellow|royalblue|lightseagreen|mistyrose|sienna|lightcoral|orangered|navajowhite|palegreen|burlywood|seashell|mediumspringgreen|papayawhip|blanchedalmond|peru|aquamarine|darkslategray|ivory|dodgerblue|lemonchiffon|chocolate|orange|forestgreen|slateblue|mintcream|antiquewhite|darkorange|cadetblue|moccasin|limegreen|saddlebrown|darkslateblue|lightskyblue|deeppink|plum|darkgoldenrod|sandybrown|magenta|tan|rosybrown|pink|lightblue|palevioletred|mediumseagreen|dimgray|powderblue|seagreen|snow|mediumblue|midnightblue|paleturquoise|palegoldenrod|whitesmoke|darkorchid|salmon|lightslategray|lawngreen|lightgreen|tomato|hotpink|lightyellow|lavenderblush|linen|mediumaquamarine|blueviolet|peachpuff)\b" is(name.entity)
+    r"(black|silver|gray|white|maroon|red|purple|fuchsia|green|lime|olive|yellow|navy|blue|teal|aqua)\b" is(name.builtin)
+    r"\!(important|default)" is(name.exception)
+    r"(true|false)" is(name.pseudo)
+    r"(and|or|not)" is(operator.word)
+    r"/\*" is(comment.multiline) -> go-to(inline-comment)
+    r"//[^\n]*" is(comment.single)
+    r"\\#[a-z0-9]{1,6}" is(literal.number.hex)
+    r"(-?\d+)(\%|[a-z]+)?" is(by-groups(literal.number.integer, keyword.type))
+    r"(-?\d*\.\d+)(\%|[a-z]+)?" is(by-groups(literal.number.float, keyword.type))
+    r"\#{" is(literal.string.interpol) -> go-to(interpolation)
+    r"[\126\^\*!&%<>\|+=@:,./?-]+" is(operator)
+    r"[\[\]()]+" is(punctuation)
+    r"\"" is(literal.string.double) -> go-to(string-double)
+    r"'" is(literal.string.single) -> go-to(string-single)
+    r"[a-z_-][\w-]*" is(name)
+    r"\n" is(text)
+    r"[;{}]" is(punctuation) -> go-to(root)
+
+  lex(for):
+    r"(from|to|through)" is(operator.word)
+    any-of(value)
+
+  lex(string-single):
+    r"(\\.|\#(?=[^\n{])|[^\n'\#])+" is(literal.string.double)
+    r"\#\{" is(literal.string.interpol) -> go-to(interpolation)
+    r"'" is(literal.string.double) -> pop
+
+  lex(inline-comment):
+    r"(\\\#|\#(?=[^{])|\*(?=[^/])|[^\#*])+" is(comment.multiline)
+    r"\#\{" is(literal.string.interpol) -> go-to(interpolation)
+    r"\*/" is(comment) -> pop
+
+  lex(selector):
+    r"[ \t]+" is(text)
+    r"\:" is(name.decorator) -> go-to(pseudo-class)
+    r"\." is(name.class) -> go-to(class)
+    r"\\#" is(name.namespace) -> go-to(id)
+    r"[a-zA-Z0-9_-]+" is(name.tag)
+    r"\#\{" is(literal.string.interpol) -> go-to(interpolation)
+    r"&" is(keyword)
+    r"[\126\^\*!&\[\]\(\)<>\|+=@:;,./?-]" is(operator)
+    r"\"" is(literal.string.double) -> go-to(string-double)
+    r"'" is(literal.string.single) -> go-to(string-single)
+    r"\n" is(text)
+    r"[;{}]" is(punctuation) -> go-to(root)
+
+  lex(root):
+    r"\s+" is(text)
+    r"//.*?\n" is(comment.single)
+    r"/\*.*?\*/" is(comment.multiline)
+    r"@import" is(keyword) -> go-to(value)
+    r"@for" is(keyword) -> go-to(for)
+    r"@(debug|warn|if|while)" is(keyword) -> go-to(value)
+    r"(@mixin)( [\w-]+)" is(by-groups(keyword, name.function)) -> go-to(value)
+    r"(@include)( [\w-]+)" is(by-groups(keyword, name.decorator)) -> go-to(value)
+    r"@extend" is(keyword) -> go-to(selector)
+    r"@[a-z0-9_-]+" is(keyword) -> go-to(selector)
+    r"(\$[\w-]*\w)([ \t]*:)" is(by-groups(name.variable, operator)) -> go-to(value)
+    r"(?=[^;{}][;}])" is(name.attribute) -> go-to(attr)
+    r"(?=[^;{}:]+:[^a-z])" is(name.attribute) -> go-to(attr)
+    r"" is(text) -> go-to(selector)
+
+  lex(id):
+    r"[\w-]+" is(name.namespace)
+    r"\#\{" is(literal.string.interpol) -> go-to(interpolation)
+    r"" is(text) -> pop
+
+  lex(interpolation):
+    r"\}" is(literal.string.interpol) -> pop
+    any-of(value)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,71 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Smali"
+  aliases: ["smali"]
+  extensions: [".smali"]
+  mimetypes: ["text/smali"]
+  start: .root
+  flags: 0
+
+  lex(comment):
+    r"\#.*?\n" is(comment)
+
+  lex(instruction):
+    r"\b[vp]\d+\b" is(name.builtin)
+    r"\b[a-z][A-Za-z0-9/-]+\s+" is(text)
+
+  lex(class):
+    r"(L)((?:[A-Za-z0-9_$]+/)*)([A-Za-z0-9_$]+)(;)" is(by-groups(keyword.type, text, name.class, text))
+
+  lex(whitespace):
+    r"\n" is(text)
+    r"\s+" is(text)
+
+  lex(directive):
+    r"^[ \t]*\.(class|super|implements|field|subannotation|annotation|enum|method|registers|locals|array-data|packed-switch|sparse-switch|catchall|catch|line|parameter|local|prologue|epilogue|source)" is(keyword)
+    r"^[ \t]*\.end (field|subannotation|annotation|method|array-data|packed-switch|sparse-switch|parameter|local)" is(keyword)
+    r"^[ \t]*\.restart local" is(keyword)
+
+  lex(type):
+    r"[ZBSCIJFDV\[]+" is(keyword.type)
+
+  lex(punctuation):
+    r"->" is(punctuation)
+    r"[{},\(\):=\.-]" is(punctuation)
+
+  lex(label):
+    r":[A-Za-z0-9_]+" is(name.label)
+
+  lex(field):
+    r"(\$?\b)([A-Za-z0-9_$]*)(:)" is(by-groups(punctuation, name.variable, punctuation))
+
+  lex(literal):
+    r"\".*\"" is(literal.string)
+    r"0x[0-9A-Fa-f]+t?" is(literal.number.hex)
+    r"[0-9]*\.[0-9]+([eE][0-9]+)?[fd]?" is(literal.number.float)
+    r"[0-9]+L?" is(literal.number.integer)
+
+  lex(access-modifier):
+    r"(public|private|protected|static|final|synchronized|bridge|varargs|native|abstract|strictfp|synthetic|constructor|declared-synchronized|interface|enum|annotation|volatile|transient)" is(keyword)
+
+  lex(root):
+    any-of(comment)
+    any-of(label)
+    any-of(field)
+    any-of(method)
+    any-of(class)
+    any-of(directive)
+    any-of(access-modifier)
+    any-of(instruction)
+    any-of(literal)
+    any-of(punctuation)
+    any-of(type)
+    any-of(whitespace)
+
+  lex(method):
+    r"<(?:cl)?init>" is(name.function)
+    r"(\$?\b)([A-Za-z0-9_$]*)(\()" is(by-groups(punctuation, name.function, punctuation))
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,93 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Smalltalk"
+  aliases: ["smalltalk", "squeak"]
+  extensions: [".st"]
+  mimetypes: ["text/x-smalltalk"]
+  start: .root
+  flags: 0
+
+  lex(objects):
+    r"\[" is(text) -> go-to(blockvariables)
+    r"\]" is(text) -> go-to(afterobject)
+    r"\b(self|super|true|false|nil|thisContext)\b" is(name.builtin.pseudo) -> go-to(afterobject)
+    r"\b[A-Z]\w*(?!:)\b" is(name.class) -> go-to(afterobject)
+    r"\b[a-z]\w*(?!:)\b" is(name.variable) -> go-to(afterobject)
+    r"\#(\"(\"\"|[^\"])*\"|[-+*/\\\126<>=|&!?,@%]+|[\w:]+)" is(literal.string.symbol) -> go-to(afterobject)
+    any-of(literals)
+
+  lex(blockvariables):
+    any-of(whitespaces)
+    r"(:)(\s*)(\w+)" is(by-groups(operator, text, name.variable))
+    r"\|" is(operator) -> pop
+    r"" is(text) -> pop
+
+  lex(_parenth-helper):
+    any-of(whitespaces)
+    r"(\d+r)?-?\d+(\.\d+)?(e-?\d+)?" is(literal.number)
+    r"[-+*/\\\126<>=|&\#!?,@%\w:]+" is(literal.string.symbol)
+    r"'(''|[^'])*'" is(literal.string)
+    r"\$." is(literal.string.char)
+    r"\#*\(" is(literal.string.symbol) -> go-to(inner-parenth)
+
+  lex(afterobject):
+    r"! !$" is(keyword) -> pop
+    any-of(whitespaces)
+    r"\b(ifTrue:|ifFalse:|whileTrue:|whileFalse:|timesRepeat:)" is(name.builtin) -> pop
+    r"\b(new\b(?!:))" is(name.builtin)
+    r"\:=|\_" is(operator) -> pop
+    r"\b[a-zA-Z]+\w*:" is(name.function) -> pop
+    r"\b[a-zA-Z]+\w*" is(name.function)
+    r"\w+:?|[-+*/\\\126<>=|&!?,@%]+" is(name.function) -> pop
+    r"\." is(punctuation) -> pop
+    r";" is(punctuation)
+    r"[\])}]" is(text)
+    r"[\[({]" is(text) -> pop
+
+  lex(literals):
+    r"'(''|[^'])*'" is(literal.string) -> go-to(afterobject)
+    r"\$." is(literal.string.char) -> go-to(afterobject)
+    r"\#\(" is(literal.string.symbol) -> go-to(parenth)
+    r"\)" is(text) -> go-to(afterobject)
+    r"(\d+r)?-?\d+(\.\d+)?(e-?\d+)?" is(literal.number) -> go-to(afterobject)
+
+  lex(method-definition):
+    r"([a-zA-Z]+\w*:)(\s*)(\w+)" is(by-groups(name.function, text, name.variable))
+    r"^(\b[a-zA-Z]+\w*\b)(\s*)$" is(by-groups(name.function, text))
+    r"^([-+*/\\\126<>=|&!?,@%]+)(\s*)(\w+)(\s*)$" is(by-groups(name.function, text, name.variable, text))
+
+  lex(parenth):
+    r"\)" is(literal.string.symbol) -> do-all(go-to(root), go-to(afterobject))
+    any-of(_parenth-helper)
+
+  lex(inner-parenth):
+    r"\)" is(literal.string.symbol) -> pop
+    any-of(_parenth-helper)
+
+  lex(whitespaces):
+    r"\s+" is(text)
+    r"\"(\"\"|[^\"])*\"" is(comment)
+
+  lex(squeak-fileout):
+    r"^\"(\"\"|[^\"])*\"!" is(keyword)
+    r"^'(''|[^'])*'!" is(keyword)
+    r"^(!)(\w+)( commentStamp: )(.*?)( prior: .*?!\n)(.*?)(!)" is(by-groups(keyword, name.class, keyword, literal.string, keyword, text, keyword))
+    r"^(!)(\w+(?: class)?)( methodsFor: )('(?:''|[^'])*')(.*?!)" is(by-groups(keyword, name.class, keyword, literal.string, keyword))
+    r"^(\w+)( subclass: )(\#\w+)(\s+instanceVariableNames: )(.*?)(\s+classVariableNames: )(.*?)(\s+poolDictionaries: )(.*?)(\s+category: )(.*?)(!)" is(by-groups(name.class, keyword, literal.string.symbol, keyword, literal.string, keyword, literal.string, keyword, literal.string, keyword, literal.string, keyword))
+    r"^(\w+(?: class)?)(\s+instanceVariableNames: )(.*?)(!)" is(by-groups(name.class, keyword, literal.string, keyword))
+    r"(!\n)(\].*)(! !)$" is(by-groups(keyword, text, keyword))
+    r"! !$" is(keyword)
+
+  lex(root):
+    r"(<)(\w+:)(.*?)(>)" is(by-groups(text, keyword, text, text))
+    any-of(squeak-fileout)
+    any-of(whitespaces)
+    any-of(method-definition)
+    r"(\|)([\w\s]*)(\|)" is(by-groups(operator, name.variable, operator))
+    any-of(objects)
+    r"\^|\:=|\_" is(operator)
+    r"[\]({}.;!]" is(text)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,42 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Snobol"
+  aliases: ["snobol"]
+  extensions: [".snobol"]
+  mimetypes: ["text/x-snobol"]
+  start: .root
+  flags: 0
+
+  lex(root):
+    r"\*.*\n" is(comment)
+    r"[\+\.] " is(punctuation) -> go-to(statement)
+    r"-.*\n" is(comment)
+    r"END\s*\n" is(name.label) -> go-to(heredoc)
+    r"[A-Za-z\$][\w$]*" is(name.label) -> go-to(statement)
+    r"\s+" is(text) -> go-to(statement)
+
+  lex(goto):
+    r"\s*\n" is(text) -> pop(2)
+    r"\s+" is(text)
+    r"F|S" is(keyword)
+    r"(\()([A-Za-z][\w.]*)(\))" is(by-groups(punctuation, name.label, punctuation))
+
+  lex(statement):
+    r"\s*\n" is(text) -> pop
+    r"\s+" is(text)
+    r"(?<=[^\w.])(LT|LE|EQ|NE|GE|GT|INTEGER|IDENT|DIFFER|LGT|SIZE|REPLACE|TRIM|DUPL|REMDR|DATE|TIME|EVAL|APPLY|OPSYN|LOAD|UNLOAD|LEN|SPAN|BREAK|ANY|NOTANY|TAB|RTAB|REM|POS|RPOS|FAIL|FENCE|ABORT|ARB|ARBNO|BAL|SUCCEED|INPUT|OUTPUT|TERMINAL)(?=[^\w.])" is(name.builtin)
+    r"[A-Za-z][\w\.]*" is(name)
+    r"\*\*|[\?\$\.!%\*/\#+\-@\|&\\=]" is(operator)
+    r"\"[^\"]*\"" is(literal.string)
+    r"'[^']*'" is(literal.string)
+    r"[0-9]+(?=[^\.EeDd])" is(literal.number.integer)
+    r"[0-9]+(\.[0-9]*)?([EDed][-+]?[0-9]+)?" is(literal.number.float)
+    r":" is(punctuation) -> go-to(goto)
+    r"[\(\)<>,;]" is(punctuation)
+
+  lex(heredoc):
+    r".*\n" is(literal.string.heredoc)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,58 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "SourcePawn"
+  aliases: ["sp"]
+  extensions: [".sp"]
+  mimetypes: ["text/x-sourcepawn"]
+  start: .root
+  flags: 0
+
+  lex(macro):
+    r"[^/\n]+" is(comment.preproc)
+    r"/\*(.|\n)*?\*/" is(comment.multiline)
+    r"//.*?\n" is(comment.single) -> pop
+    r"/" is(comment.preproc)
+    r"(?<=\\)\n" is(comment.preproc)
+    r"\n" is(comment.preproc) -> pop
+
+  lex(root):
+    r"^\#if\s+0" is(comment.preproc) -> go-to(if0)
+    r"^\#" is(comment.preproc) -> go-to(macro)
+    r"^(?:\s|//.*?\n|/\*.*?\*/)+\#if\s+0" is(comment.preproc) -> go-to(if0)
+    r"^(?:\s|//.*?\n|/\*.*?\*/)+\#" is(comment.preproc) -> go-to(macro)
+    r"\n" is(text)
+    r"\s+" is(text)
+    r"\\\n" is(text)
+    r"/(\\\n)?/(\n|(.|\n)*?[^\\]\n)" is(comment.single)
+    r"/(\\\n)?\*(.|\n)*?\*(\\\n)?/" is(comment.multiline)
+    r"[{}]" is(punctuation)
+    r"L?\"" is(literal.string) -> go-to(string)
+    r"L?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'" is(literal.string.char)
+    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"(case|const|continue|native|default|else|enum|for|if|new|operator|public|return|sizeof|static|decl|struct|switch)\b" is(keyword)
+    r"(bool|Float)\b" is(keyword.type)
+    r"(true|false)\b" is(keyword.constant)
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name)
+
+  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(if0):
+    r"^\s*\#if.*?(?<!\\)\n" is(comment.preproc) -> push
+    r"^\s*\#endif.*?(?<!\\)\n" is(comment.preproc) -> pop
+    r".*?\n" is(comment)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,37 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Debian Sourcelist"
+  aliases: ["sourceslist", "sources.list"]
+  extensions: ["sources.list"]
+  mimetypes: []
+  start: .root
+  flags: 0
+
+  lex(distribution):
+    r"\#.*?$" is(comment) -> pop
+    r"\$\(ARCH\)" is(name.variable)
+    r"[^\s$\[]+" is(literal.string)
+    r"\[" is(literal.string.other) -> go-to(escaped-distribution)
+    r"\$" is(literal.string)
+    r"\s+" is(text) -> go-to(components)
+
+  lex(root):
+    r"\s+" is(text)
+    r"\#.*?$" is(comment)
+    r"^(deb(?:-src)?)(\s+)" is(by-groups(keyword, text)) -> go-to(distribution)
+
+  lex(escaped-distribution):
+    r"\]" is(literal.string.other) -> pop
+    r"\$\(ARCH\)" is(name.variable)
+    r"[^\]$]+" is(literal.string.other)
+    r"\$" is(literal.string.other)
+
+  lex(components):
+    r"\#.*?$" is(comment) -> pop(2)
+    r"$" is(text) -> pop(2)
+    r"\s+" is(text)
+    r"\S+" is(keyword.pseudo)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,31 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "SQL"
+  aliases: ["sql"]
+  extensions: [".sql"]
+  mimetypes: ["text/x-sql"]
+  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"--.*?\n" is(comment.single)
+    r"/\*" is(comment.multiline) -> go-to(multiline-comments)
+    r"(ABORT|ABS|ABSOLUTE|ACCESS|ADA|ADD|ADMIN|AFTER|AGGREGATE|ALIAS|ALL|ALLOCATE|ALTER|ANALYSE|ANALYZE|AND|ANY|ARE|AS|ASC|ASENSITIVE|ASSERTION|ASSIGNMENT|ASYMMETRIC|AT|ATOMIC|AUTHORIZATION|AVG|BACKWARD|BEFORE|BEGIN|BETWEEN|BITVAR|BIT_LENGTH|BOTH|BREADTH|BY|C|CACHE|CALL|CALLED|CARDINALITY|CASCADE|CASCADED|CASE|CAST|CATALOG|CATALOG_NAME|CHAIN|CHARACTERISTICS|CHARACTER_LENGTH|CHARACTER_SET_CATALOG|CHARACTER_SET_NAME|CHARACTER_SET_SCHEMA|CHAR_LENGTH|CHECK|CHECKED|CHECKPOINT|CLASS|CLASS_ORIGIN|CLOB|CLOSE|CLUSTER|COALSECE|COBOL|COLLATE|COLLATION|COLLATION_CATALOG|COLLATION_NAME|COLLATION_SCHEMA|COLUMN|COLUMN_NAME|COMMAND_FUNCTION|COMMAND_FUNCTION_CODE|COMMENT|COMMIT|COMMITTED|COMPLETION|CONDITION_NUMBER|CONNECT|CONNECTION|CONNECTION_NAME|CONSTRAINT|CONSTRAINTS|CONSTRAINT_CATALOG|CONSTRAINT_NAME|CONSTRAINT_SCHEMA|CONSTRUCTOR|CONTAINS|CONTINUE|CONVERSION|CONVERT|COPY|CORRESPONTING|COUNT|CREATE|CREATEDB|CREATEUSER|CROSS|CUBE|CURRENT|CURRENT_DATE|CURRENT_PATH|CURRENT_ROLE|CURRENT_TIME|CURRENT_TIMESTAMP|CURRENT_USER|CURSOR|CURSOR_NAME|CYCLE|DATA|DATABASE|DATETIME_INTERVAL_CODE|DATETIME_INTERVAL_PRECISION|DAY|DEALLOCATE|DECLARE|DEFAULT|DEFAULTS|DEFERRABLE|DEFERRED|DEFINED|DEFINER|DELETE|DELIMITER|DELIMITERS|DEREF|DESC|DESCRIBE|DESCRIPTOR|DESTROY|DESTRUCTOR|DETERMINISTIC|DIAGNOSTICS|DICTIONARY|DISCONNECT|DISPATCH|DISTINCT|DO|DOMAIN|DROP|DYNAMIC|DYNAMIC_FUNCTION|DYNAMIC_FUNCTION_CODE|EACH|ELSE|ENCODING|ENCRYPTED|END|END-EXEC|EQUALS|ESCAPE|EVERY|EXCEPT|ESCEPTION|EXCLUDING|EXCLUSIVE|EXEC|EXECUTE|EXISTING|EXISTS|EXPLAIN|EXTERNAL|EXTRACT|FALSE|FETCH|FINAL|FIRST|FOR|FORCE|FOREIGN|FORTRAN|FORWARD|FOUND|FREE|FREEZE|FROM|FULL|FUNCTION|G|GENERAL|GENERATED|GET|GLOBAL|GO|GOTO|GRANT|GRANTED|GROUP|GROUPING|HANDLER|HAVING|HIERARCHY|HOLD|HOST|IDENTITY|IGNORE|ILIKE|IMMEDIATE|IMMUTABLE|IMPLEMENTATION|IMPLICIT|IN|INCLUDING|INCREMENT|INDEX|INDITCATOR|INFIX|INHERITS|INITIALIZE|INITIALLY|INNER|INOUT|INPUT|INSENSITIVE|INSERT|INSTANTIABLE|INSTEAD|INTERSECT|INTO|INVOKER|IS|ISNULL|ISOLATION|ITERATE|JOIN|KEY|KEY_MEMBER|KEY_TYPE|LANCOMPILER|LANGUAGE|LARGE|LAST|LATERAL|LEADING|LEFT|LENGTH|LESS|LEVEL|LIKE|LIMIT|LISTEN|LOAD|LOCAL|LOCALTIME|LOCALTIMESTAMP|LOCATION|LOCATOR|LOCK|LOWER|MAP|MATCH|MAX|MAXVALUE|MESSAGE_LENGTH|MESSAGE_OCTET_LENGTH|MESSAGE_TEXT|METHOD|MIN|MINUTE|MINVALUE|MOD|MODE|MODIFIES|MODIFY|MONTH|MORE|MOVE|MUMPS|NAMES|NATIONAL|NATURAL|NCHAR|NCLOB|NEW|NEXT|NO|NOCREATEDB|NOCREATEUSER|NONE|NOT|NOTHING|NOTIFY|NOTNULL|NULL|NULLABLE|NULLIF|OBJECT|OCTET_LENGTH|OF|OFF|OFFSET|OIDS|OLD|ON|ONLY|OPEN|OPERATION|OPERATOR|OPTION|OPTIONS|OR|ORDER|ORDINALITY|OUT|OUTER|OUTPUT|OVERLAPS|OVERLAY|OVERRIDING|OWNER|PAD|PARAMETER|PARAMETERS|PARAMETER_MODE|PARAMATER_NAME|PARAMATER_ORDINAL_POSITION|PARAMETER_SPECIFIC_CATALOG|PARAMETER_SPECIFIC_NAME|PARAMATER_SPECIFIC_SCHEMA|PARTIAL|PASCAL|PENDANT|PLACING|PLI|POSITION|POSTFIX|PRECISION|PREFIX|PREORDER|PREPARE|PRESERVE|PRIMARY|PRIOR|PRIVILEGES|PROCEDURAL|PROCEDURE|PUBLIC|READ|READS|RECHECK|RECURSIVE|REF|REFERENCES|REFERENCING|REINDEX|RELATIVE|RENAME|REPEATABLE|REPLACE|RESET|RESTART|RESTRICT|RESULT|RETURN|RETURNED_LENGTH|RETURNED_OCTET_LENGTH|RETURNED_SQLSTATE|RETURNS|REVOKE|RIGHT|ROLE|ROLLBACK|ROLLUP|ROUTINE|ROUTINE_CATALOG|ROUTINE_NAME|ROUTINE_SCHEMA|ROW|ROWS|ROW_COUNT|RULE|SAVE_POINT|SCALE|SCHEMA|SCHEMA_NAME|SCOPE|SCROLL|SEARCH|SECOND|SECURITY|SELECT|SELF|SENSITIVE|SERIALIZABLE|SERVER_NAME|SESSION|SESSION_USER|SET|SETOF|SETS|SHARE|SHOW|SIMILAR|SIMPLE|SIZE|SOME|SOURCE|SPACE|SPECIFIC|SPECIFICTYPE|SPECIFIC_NAME|SQL|SQLCODE|SQLERROR|SQLEXCEPTION|SQLSTATE|SQLWARNINIG|STABLE|START|STATE|STATEMENT|STATIC|STATISTICS|STDIN|STDOUT|STORAGE|STRICT|STRUCTURE|STYPE|SUBCLASS_ORIGIN|SUBLIST|SUBSTRING|SUM|SYMMETRIC|SYSID|SYSTEM|SYSTEM_USER|TABLE|TABLE_NAME| TEMP|TEMPLATE|TEMPORARY|TERMINATE|THAN|THEN|TIMESTAMP|TIMEZONE_HOUR|TIMEZONE_MINUTE|TO|TOAST|TRAILING|TRANSATION|TRANSACTIONS_COMMITTED|TRANSACTIONS_ROLLED_BACK|TRANSATION_ACTIVE|TRANSFORM|TRANSFORMS|TRANSLATE|TRANSLATION|TREAT|TRIGGER|TRIGGER_CATALOG|TRIGGER_NAME|TRIGGER_SCHEMA|TRIM|TRUE|TRUNCATE|TRUSTED|TYPE|UNCOMMITTED|UNDER|UNENCRYPTED|UNION|UNIQUE|UNKNOWN|UNLISTEN|UNNAMED|UNNEST|UNTIL|UPDATE|UPPER|USAGE|USER|USER_DEFINED_TYPE_CATALOG|USER_DEFINED_TYPE_NAME|USER_DEFINED_TYPE_SCHEMA|USING|VACUUM|VALID|VALIDATOR|VALUES|VARIABLE|VERBOSE|VERSION|VIEW|VOLATILE|WHEN|WHENEVER|WHERE|WITH|WITHOUT|WORK|WRITE|YEAR|ZONE)\b" is(keyword)
+    r"(ARRAY|BIGINT|BINARY|BIT|BLOB|BOOLEAN|CHAR|CHARACTER|DATE|DEC|DECIMAL|FLOAT|INT|INTEGER|INTERVAL|NUMBER|NUMERIC|REAL|SERIAL|SMALLINT|VARCHAR|VARYING|INT8|SERIAL8|TEXT)\b" is(name.builtin)
+    r"[+*/<>=\126!@\#%^&|`?-]" is(operator)
+    r"[0-9]+" is(literal.number.integer)
+    r"'(''|[^'])*'" is(literal.string.single)
+    r"\"(\"\"|[^\"])*\"" is(literal.string.symbol)
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name)
+    r"[;:()\[\],\.]" is(punctuation)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,29 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "SquidConf"
+  aliases: ["squidconf", "squid.conf", "squid"]
+  extensions: ["squid.conf"]
+  mimetypes: ["text/x-squidconf"]
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(comment):
+    r"\s*TAG:.*" is(literal.string.escape) -> pop
+    r".*" is(comment) -> pop
+
+  lex(root):
+    r"\s+" is(text.whitespace)
+    r"\#" is(comment) -> go-to(comment)
+    r"\b(?:access_log|acl|always_direct|announce_host|announce_period|announce_port|announce_to|anonymize_headers|append_domain|as_whois_server|auth_param_basic|authenticate_children|authenticate_program|authenticate_ttl|broken_posts|buffered_logs|cache_access_log|cache_announce|cache_dir|cache_dns_program|cache_effective_group|cache_effective_user|cache_host|cache_host_acl|cache_host_domain|cache_log|cache_mem|cache_mem_high|cache_mem_low|cache_mgr|cachemgr_passwd|cache_peer|cache_peer_access|cahce_replacement_policy|cache_stoplist|cache_stoplist_pattern|cache_store_log|cache_swap|cache_swap_high|cache_swap_log|cache_swap_low|client_db|client_lifetime|client_netmask|connect_timeout|coredump_dir|dead_peer_timeout|debug_options|delay_access|delay_class|delay_initial_bucket_level|delay_parameters|delay_pools|deny_info|dns_children|dns_defnames|dns_nameservers|dns_testnames|emulate_httpd_log|err_html_text|fake_user_agent|firewall_ip|forwarded_for|forward_snmpd_port|fqdncache_size|ftpget_options|ftpget_program|ftp_list_width|ftp_passive|ftp_user|half_closed_clients|header_access|header_replace|hierarchy_stoplist|high_response_time_warning|high_page_fault_warning|hosts_file|htcp_port|http_access|http_anonymizer|httpd_accel|httpd_accel_host|httpd_accel_port|httpd_accel_uses_host_header|httpd_accel_with_proxy|http_port|http_reply_access|icp_access|icp_hit_stale|icp_port|icp_query_timeout|ident_lookup|ident_lookup_access|ident_timeout|incoming_http_average|incoming_icp_average|inside_firewall|ipcache_high|ipcache_low|ipcache_size|local_domain|local_ip|logfile_rotate|log_fqdn|log_icp_queries|log_mime_hdrs|maximum_object_size|maximum_single_addr_tries|mcast_groups|mcast_icp_query_timeout|mcast_miss_addr|mcast_miss_encode_key|mcast_miss_port|memory_pools|memory_pools_limit|memory_replacement_policy|mime_table|min_http_poll_cnt|min_icp_poll_cnt|minimum_direct_hops|minimum_object_size|minimum_retry_timeout|miss_access|negative_dns_ttl|negative_ttl|neighbor_timeout|neighbor_type_domain|netdb_high|netdb_low|netdb_ping_period|netdb_ping_rate|never_direct|no_cache|passthrough_proxy|pconn_timeout|pid_filename|pinger_program|positive_dns_ttl|prefer_direct|proxy_auth|proxy_auth_realm|query_icmp|quick_abort|quick_abort|quick_abort_max|quick_abort_min|quick_abort_pct|range_offset_limit|read_timeout|redirect_children|redirect_program|redirect_rewrites_host_header|reference_age|reference_age|refresh_pattern|reload_into_ims|request_body_max_size|request_size|request_timeout|shutdown_lifetime|single_parent_bypass|siteselect_timeout|snmp_access|snmp_incoming_address|snmp_port|source_ping|ssl_proxy|store_avg_object_size|store_objects_per_bucket|strip_query_terms|swap_level1_dirs|swap_level2_dirs|tcp_incoming_address|tcp_outgoing_address|tcp_recv_bufsize|test_reachability|udp_hit_obj|udp_hit_obj_size|udp_incoming_address|udp_outgoing_address|unique_hostname|unlinkd_program|uri_whitespace|useragent_log|visible_hostname|wais_relay|wais_relay_host|wais_relay_port)\b" is(keyword)
+    r"\b(?:proxy-only|weight|ttl|no-query|default|round-robin|multicast-responder|on|off|all|deny|allow|via|parent|no-digest|heap|lru|realm|children|q1|q2|credentialsttl|none|disable|offline_toggle|diskd)\b" is(name.constant)
+    r"\b(?:shutdown|info|parameter|server_list|client_list|squid\.conf)\b" is(literal.string)
+    r"stats/\b(?:shutdown|info|parameter|server_list|client_list|squid\.conf)\b" is(literal.string)
+    r"log/\b(?:shutdown|info|parameter|server_list|client_list|squid\.conf)\b=" is(literal.string)
+    r"\b(?:url_regex|urlpath_regex|referer_regex|port|proto|req_mime_type|rep_mime_type|method|browser|user|src|dst|time|dstdomain|ident|snmp_community)\b" is(keyword)
+    r"(?:(?:(?:[3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}|0x0*[0-9a-f]{1,2}|0+[1-3]?[0-7]{0,2})(?:\.(?:[3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}|0x0*[0-9a-f]{1,2}|0+[1-3]?[0-7]{0,2})){3})|(?!.*::.*::)(?:(?!:)|:(?=:))(?:[0-9a-f]{0,4}(?:(?<=::)|(?<!::):)){6}(?:[0-9a-f]{0,4}(?:(?<=::)|(?<!::):)[0-9a-f]{0,4}(?:(?<=::)|(?<!:)|(?<=:)(?<!::):)|(?:25[0-4]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-4]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))(?:/(?:(?:(?:(?:[3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}|0x0*[0-9a-f]{1,2}|0+[1-3]?[0-7]{0,2})(?:\.(?:[3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}|0x0*[0-9a-f]{1,2}|0+[1-3]?[0-7]{0,2})){3})|(?!.*::.*::)(?:(?!:)|:(?=:))(?:[0-9a-f]{0,4}(?:(?<=::)|(?<!::):)){6}(?:[0-9a-f]{0,4}(?:(?<=::)|(?<!::):)[0-9a-f]{0,4}(?:(?<=::)|(?<!:)|(?<=:)(?<!::):)|(?:25[0-4]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-4]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|\b\d+\b))?" is(literal.number.float)
+    r"(?:\b\d+\b(?:-\b\d+|%)?)" is(literal.number)
+    r"\S+" is(text)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,38 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Stan"
+  aliases: ["stan"]
+  extensions: [".stan"]
+  mimetypes: []
+  start: .root
+  flags: 0
+
+  lex(root):
+    r"\"[^\"]*\"" is(literal.string)
+    any-of(comments)
+    any-of(whitespace)
+    r"(data|transformed\s+?data|parameters|transformed\s+parameters|model|generated\s+quantities)(\s*)({)" is(by-groups(keyword.namespace, text, punctuation))
+    r"(for|in|while|repeat|until|if|then|else|true|false|T|lower|upper|print)\b" is(keyword.reserved)
+    r"(int|real|vector|simplex|ordered|row_vector|matrix|corr_matrix|cov_matrix|positive_ordered)\b" is(keyword.type)
+    r"[;:,\[\]()<>]" is(punctuation)
+    r"(Phi|abs|acos|acosh|asin|asinh|atan|atan2|atanh|bernoulli_log|beta_binomial_log|beta_log|binary_log_loss|binomial_coefficient_log|categorical_log|cauchy_log|cbrt|ceil|chi_square_log|cholesky_decompose|col|cols|cos|cosh|determinant|diag_matrix|diagonal|dirichlet_log|dot_product|dot_self|double_exponential_log|eigenvalues|eigenvalues_sym|erf|erfc|exp|exp2|expm1|exponential_cdf|exponential_log|fabs|fdim|floor|fma|fmax|fmin|fmod|gamma_log|hypergeometric_log|hypot|if_else|int_step|inv_chi_square_log|inv_cloglog|inv_gamma_log|inv_logit|inv_wishart_log|inverse|lbeta|lgamma|lkj_corr_cholesky_log|lkj_corr_log|lkj_cov_log|lmgamma|log|log10|log1m|log1p|log1p_exp|log2|log_sum_exp|logistic_log|logit|lognormal_cdf|lognormal_log|max|mean|min|multi_normal_cholesky_log|multi_normal_log|multi_student_t_log|multinomial_log|multiply_log|multiply_lower_tri_self_transpose|neg_binomial_log|normal_cdf|normal_log|ordered_logistic_log|pareto_log|poisson_log|pow|prod|round|row|rows|scaled_inv_chi_square_log|sd|sin|singular_values|sinh|softmax|sqrt|square|step|student_t_log|sum|tan|tanh|tgamma|trace|trunc|uniform_log|variance|weibull_cdf|weibull_log|wishart_log|bernoulli|beta|beta_binomial|categorical|cauchy|chi_square|dirichlet|double_exponential|exponential|gamma|hypergeometric|inv_chi_square|inv_gamma|inv_wishart|lkj_corr|lkj_corr_cholesky|lkj_cov|logistic|lognormal|multi_normal|multi_normal_cholesky|multi_student_t|multinomial|neg_binomial|normal|ordered_logistic|pareto|poisson|scaled_inv_chi_square|student_t|uniform|weibull|wishart)(?=\s*\()" is(name.builtin)
+    r"(e|epsilon|log10|log2|negative_epsilon|negative_infinity|not_a_number|pi|positive_infinity|sqrt2)(?=\s*\()" is(keyword.constant)
+    r"[A-Za-z][A-Za-z0-9_]*__\b" is(name.builtin.pseudo)
+    r"[A-Za-z][A-Za-z0-9_]*\b" is(name)
+    r"-?[0-9]+(\.[0-9]+)?[eE]-?[0-9]+" is(literal.number.float)
+    r"-?[0-9]*\.[0-9]*" is(literal.number.float)
+    r"-?[0-9]+" is(literal.number.integer)
+    r"<-|\126" is(operator)
+    r"\+|-|\.?\*|\.?/|\\|'|=" is(operator)
+    r"[{}]" is(punctuation)
+
+  lex(whitespace):
+    r"\s+" is(text)
+
+  lex(comments):
+    r"(?m)/\*.*?\*/" is(comment.multiline)
+    r"(//|\#).*$" is(comment.single)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,65 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "systemverilog"
+  aliases: ["systemverilog", "sv"]
+  extensions: [".sv", ".svh"]
+  mimetypes: ["text/x-systemverilog"]
+  start: .root
+  flags: 0
+
+  lex(classname):
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name.class) -> pop
+
+  lex(macro):
+    r"[^/\n]+" is(comment.preproc)
+    r"/[*](.|\n)*?[*]/" is(comment.multiline)
+    r"//.*?\n" is(comment.single) -> pop
+    r"/" is(comment.preproc)
+    r"(?<=\\)\n" is(comment.preproc)
+    r"\n" is(comment.preproc) -> pop
+
+  lex(root):
+    r"^\s*`define" is(comment.preproc) -> go-to(macro)
+    r"^(\s*)(package)(\s+)" is(by-groups(text, keyword.namespace, text))
+    r"^(\s*)(import)(\s+)" is(by-groups(text, keyword.namespace, text)) -> go-to(import)
+    r"\n" is(text)
+    r"\s+" is(text)
+    r"\\\n" is(text)
+    r"/(\\\n)?/(\n|(.|\n)*?[^\\]\n)" is(comment.single)
+    r"/(\\\n)?[*](.|\n)*?[*](\\\n)?/" is(comment.multiline)
+    r"[{}\#@]" is(punctuation)
+    r"L?\"" is(literal.string) -> go-to(string)
+    r"L?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'" is(literal.string.char)
+    r"(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?" is(literal.number.float)
+    r"(\d+\.\d*|\.\d+|\d+[fF])[fF]?" is(literal.number.float)
+    r"([0-9]+)|(\'h)[0-9a-fA-F]+" is(literal.number.hex)
+    r"([0-9]+)|(\'b)[0-1]+" is(literal.number.hex)
+    r"([0-9]+)|(\'d)[0-9]+" is(literal.number.integer)
+    r"([0-9]+)|(\'o)[0-7]+" is(literal.number.oct)
+    r"\'[01xz]" is(literal.number)
+    r"\d+[Ll]?" is(literal.number.integer)
+    r"\*/" is(error)
+    r"[\126!%^&*+=|?:<>/-]" is(operator)
+    r"[()\[\],.;\']" is(punctuation)
+    r"`[a-zA-Z_][a-zA-Z0-9_]*" is(name.constant)
+    r"(accept_on|alias|always|always_comb|always_ff|always_latch|and|assert|assign|assume|automatic|before|begin|bind|bins|binsof|bit|break|buf|bufif0|bufif1|byte|case|casex|casez|cell|chandle|checker|class|clocking|cmos|config|const|constraint|context|continue|cover|covergroup|coverpoint|cross|deassign|default|defparam|design|disable|dist|do|edge|else|end|endcase|endchecker|endclass|endclocking|endconfig|endfunction|endgenerate|endgroup|endinterface|endmodule|endpackage|endprimitive|endprogram|endproperty|endsequence|endspecify|endtable|endtask|enum|event|eventually|expect|export|extends|extern|final|first_match|for|force|foreach|forever|fork|forkjoin|function|generate|genvar|global|highz0|highz1|if|iff|ifnone|ignore_bins|illegal_bins|implies|import|incdir|include|initial|inout|input|inside|instance|int|integer|interface|intersect|join|join_any|join_none|large|let|liblist|library|local|localparam|logic|longint|macromodule|matches|medium|modport|module|nand|negedge|new|nexttime|nmos|nor|noshowcancelled|not|notif0|notif1|null|or|output|package|packed|parameter|pmos|posedge|primitive|priority|program|property|protected|pull0|pull1|pulldown|pullup|pulsestyle_ondetect|pulsestyle_onevent|pure|rand|randc|randcase|randsequence|rcmos|real|realtime|ref|reg|reject_on|release|repeat|restrict|return|rnmos|rpmos|rtran|rtranif0|rtranif1|s_always|s_eventually|s_nexttime|s_until|s_until_with|scalared|sequence|shortint|shortreal|showcancelled|signed|small|solve|specify|specparam|static|string|strong|strong0|strong1|struct|super|supply0|supply1|sync_accept_on|sync_reject_on|table|tagged|task|this|throughout|time|timeprecision|timeunit|tran|tranif0|tranif1|tri|tri0|tri1|triand|trior|trireg|type|typedef|union|unique|unique0|unsigned|until|until_with|untyped|use|uwire|var|vectored|virtual|void|wait|wait_order|wand|weak|weak0|weak1|while|wildcard|wire|with|within|wor|xnor|xor)\b" is(keyword)
+    r"(`__FILE__|`__LINE__|`begin_keywords|`celldefine|`default_nettype|`define|`else|`elsif|`end_keywords|`endcelldefine|`endif|`ifdef|`ifndef|`include|`line|`nounconnected_drive|`pragma|`resetall|`timescale|`unconnected_drive|`undef|`undefineall)\b" is(comment.preproc)
+    r"(\$display|\$displayb|\$displayh|\$displayo|\$dumpall|\$dumpfile|\$dumpflush|\$dumplimit|\$dumpoff|\$dumpon|\$dumpports|\$dumpportsall|\$dumpportsflush|\$dumpportslimit|\$dumpportsoff|\$dumpportson|\$dumpvars|\$fclose|\$fdisplay|\$fdisplayb|\$fdisplayh|\$fdisplayo|\$feof|\$ferror|\$fflush|\$fgetc|\$fgets|\$fmonitor|\$fmonitorb|\$fmonitorh|\$fmonitoro|\$fopen|\$fread|\$fscanf|\$fseek|\$fstrobe|\$fstrobeb|\$fstrobeh|\$fstrobeo|\$ftell|\$fwrite|\$fwriteb|\$fwriteh|\$fwriteo|\$monitor|\$monitorb|\$monitorh|\$monitoro|\$monitoroff|\$monitoron|\$plusargs|\$readmemb|\$readmemh|\$rewind|\$sformat|\$sformatf|\$sscanf|\$strobe|\$strobeb|\$strobeh|\$strobeo|\$swrite|\$swriteb|\$swriteh|\$swriteo|\$test|\$ungetc|\$value\$plusargs|\$write|\$writeb|\$writeh|\$writememb|\$writememh|\$writeo)\b" is(name.builtin)
+    r"(class)(\s+)" is(by-groups(keyword, text)) -> go-to(classname)
+    r"(byte|shortint|int|longint|integer|time|bit|logic|reg|supply0|supply1|tri|triand|trior|tri0|tri1|trireg|uwire|wire|wand|worshortreal|real|realtime)\b" is(keyword.type)
+    r"[a-zA-Z_][a-zA-Z0-9_]*:(?!:)" is(name.label)
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name)
+
+  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(import):
+    r"[a-zA-Z0-9_:]+\*?" is(name.namespace) -> pop
+
+const-set(.Lexer, lexer)