<- =>

abstract case catch
class def derives do
else enum extends extension
final finally
for forSome given if
implicit import;
infix inline lazy
match new null object
opaque open
override package private
protected return sealed
self super this throw
trait transparent try
type using val
var while with yield

----------------------------------------------------

[
	["keyword", "<-"], ["keyword", "=>"],

	["keyword", "abstract"],
	["keyword", "case"],
	["keyword", "catch"],

	["keyword", "class"],
	["keyword", "def"],
	["keyword", "derives"],
	["keyword", "do"],

	["keyword", "else"],
	["keyword", "enum"],
	["keyword", "extends"],
	["keyword", "extension"],

	["keyword", "final"],
	["keyword", "finally"],

	["keyword", "for"],
	["keyword", "forSome"],
	["keyword", "given"],
	["keyword", "if"],

	["keyword", "implicit"],
	["keyword", "import"],
	["punctuation", ";"],

	["keyword", "infix"],
	["keyword", "inline"],
	["keyword", "lazy"],

	["keyword", "match"],
	["keyword", "new"],
	["keyword", "null"],
	["keyword", "object"],

	["keyword", "opaque"],
	["keyword", "open"],

	["namespace", ["override"]],
	["keyword", "package"],
	["keyword", "private"],

	["keyword", "protected"],
	["keyword", "return"],
	["keyword", "sealed"],

	["keyword", "self"],
	["keyword", "super"],
	["keyword", "this"],
	["keyword", "throw"],

	["keyword", "trait"],
	["keyword", "transparent"],
	["keyword", "try"],

	["keyword", "type"],
	["keyword", "using"],
	["keyword", "val"],

	["keyword", "var"],
	["keyword", "while"],
	["keyword", "with"],
	["keyword", "yield"]
]

----------------------------------------------------

Checks for keywords.
