CSS classes reference
=====================

This is a full list of available classes corresponding to languages'
syntactic structures. The parentheses after language name contain identifiers
used as class names in ``<code>`` element.


Gams ("gms", "gams")
--------------------

* ``section``:          section
* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string


Python ("python", "py", "gyp")
------------------------------

* ``keyword``:          keyword
* ``built_in``:         built-in objects (None, False, True and Ellipsis)
* ``number``:           number
* ``string``:           string (of any type)
* ``comment``:          comment
* ``decorator``:        @-decorator for functions
* ``function``:         function header "def some_name(...):"
* ``class``:            class header "class SomeName(...):"
* ``title``:            name of a function or a class inside a header
* ``params``:           everything inside parentheses in a function's or class' header

Python profiler results ("profile")
-----------------------------------

* ``number``:           number
* ``string``:           string
* ``built_in``:         built-in function entry
* ``filename``:         filename in an entry
* ``summary``:          profiling summary
* ``header``:           header of table of results
* ``keyword``:          column header
* ``function``:         function name in an entry (including parentheses)
* ``title``:            actual name of a function in an entry (excluding parentheses)
* ``prompt``:           interpreter prompt (>>> or ...)

Ruby ("ruby", "rb", "gemspec", "podspec", "thor", "irb")
--------------------------------------------------------

* ``keyword``:          keyword
* ``string``:           string
* ``subst``:            in-string substitution (#{...})
* ``comment``:          comment
* ``doctag``:           YARD doctag
* ``function``:         function header "def some_name(...):"
* ``class``:            class header "class SomeName(...):"
* ``title``:            name of a function or a class inside a header
* ``parent``:           name of a parent class
* ``symbol``:           symbol
* ``input``:            complete input line (interpreter)
* ``output``:           complete output line  (interpreter)
* ``prompt``:           interpreter prompt (>>)
* ``status``:           interpreter response (=>)

Haml ("haml")
-------------

* ``tag``:              any tag starting with "%"
* ``title``:            tag's name
* ``attribute``:        tag's attribute
* ``keyword``:          tag's attribute that is a keyword
* ``string``:           attribute's value that is a string
* ``value``:            attribute's value, shorthand id or class for tag
* ``comment``:          comment
* ``doctype``:          !!! declaration
* ``bullet``:           line defined by variable

Perl ("perl", "pl")
-------------------

* ``keyword``:          keyword
* ``comment``:          comment
* ``number``:           number
* ``string``:           string
* ``regexp``:           regular expression
* ``sub``:              subroutine header (from "sub" till "{")
* ``variable``:         variable starting with "$", "%", "@"
* ``operator``:         operator
* ``pod``:              plain old doc

PHP ("php", "php3", "php4", "php5", "php6")
-------------------------------------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string (of any type)
* ``comment``:          comment
* ``doctag``:           phpdoc params in comments
* ``variable``:         variable starting with "$"
* ``preprocessor``:     preprocessor marks: "<?php" and "?>"
* ``class``:            class header
* ``function``:         header of a function
* ``title``:            name of a function inside a header
* ``params``:           parentheses and everything inside them in a function's header

Scala ("scala")
---------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``doctag``:           @-tag in javadoc comment
* ``annotation``:       annotation
* ``class``:            class header
* ``title``:            class name inside a header
* ``params``:           everything in parentheses inside a class header
* ``inheritance``:      keywords "extends" and "with" inside class header

Groovy ("groovy")
-----------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string, map string keys and named argument labels
* ``regex``:            regular expression
* ``comment``:          comment
* ``doctag``:           @-tag in javadoc comment
* ``annotation``:       annotation
* ``class``:            class header
* ``title``:            class name inside a header
* ``label``:            label
* ``shebang``:          Groovy shell script header

Go ("go", "golang")
-------------------

* ``comment``:          comment
* ``string``:           string constant
* ``number``:           number
* ``keyword``:          language keywords
* ``constant``:         true false nil iota
* ``typename``:         built-in plain types (int, string etc.)
* ``built_in``:         built-in functions

Golo ("golo", "gololang")
-------------------

* ``keyword``:          language keywords
* ``literal``:          true false null
* ``typename``:         Golo type objects (DynamicObject, struct, ...)
* ``annotation``:       decorator

Gradle ("gradle")
-----------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string and character
* ``comment``:          comment
* ``regexp``:           regular expression


HTML, XML ("xml", "html", "xhtml", "rss", "atom", "xsl", "plist")
-----------------------------------------------------------------

* ``tag``:              any tag from "<" till ">"
* ``attribute``:        tag's attribute with or without value
* ``value``:            attribute's value
* ``comment``:          comment
* ``pi``:               processing instruction (<? ... ?>)
* ``doctype``:          <!DOCTYPE ... > declaration
* ``cdata``:            CDATA section

Lasso ("lasso", "ls", "lassoscript")
------------------------------------

* ``preprocessor``:     delimiters and interpreter flags
* ``shebang``:          Lasso 9 shell script header
* ``comment``:          single- or multi-line comment
* ``keyword``:          keyword
* ``literal``:          keyword representing a value
* ``built_in``:         built-in types and variables
* ``number``:           number
* ``string``:           string
* ``variable``:         variable reference starting with "#" or "$"
* ``tag``:              tag literal
* ``attribute``:        named or rest parameter in method signature
* ``subst``:            unary/binary/ternary operator symbols
* ``class``:            type, trait, or method header
* ``title``:            name following "define" inside a header

CSS ("css")
-----------

* ``tag``:              tag in selectors
* ``id``:               #some_name in selectors
* ``class``:            .some_name in selectors
* ``at_rule``:          @-rule till first "{" or ";"
* ``keyword``:          name of @-rule after @ sign
* ``attr_selector``:    attribute selector (square brackets in a[href^=http://])
* ``pseudo``:           pseudo classes and elements (:after, ::after etc.)
* ``comment``:          comment
* ``rules``:            everything from "{" till "}"
* ``rule``:             rule itself — everything inside "{" and "}"
* ``attribute``:        property name inside a rule
* ``value``:            property value inside a rule, from ":" till ";" or till the end of rule block
* ``number``:           number within a value
* ``string``:           string within a value
* ``hexcolor``:         hex color (#FFFFFF) within a value
* ``function``:         CSS function within a value
* ``important``:        "!important" symbol

SCSS ("scss")
-------------

* ``tag``:              tag in selectors
* ``id``:               #some_name in selectors
* ``class``:            .some_name in selectors
* ``at_rule``:          @-rule till first "{" or ";"
* ``attr_selector``:    attribute selector (square brackets in a[href^=http://])
* ``pseudo``:           pseudo classes and elements (:after, ::after etc.)
* ``comment``:          comment
* ``rules``:            everything from "{" till "}"
* ``attribute``:        property name inside a rule
* ``value``:            property value inside a rule, from ":" till ";" or till the end of rule block
* ``number``:           number within a value
* ``string``:           string within a value
* ``hexcolor``:         hex color (#FFFFFF) within a value
* ``function``:         CSS function within a value
* ``important``:        "!important" symbol
* ``variable``:         variable starting with "$"
* ``preprocessor``:     keywords after @

Less ("less")
-------------

* ``comment``:          comment
* ``number``:           number
* ``string``:           string
* ``attribute``:        property name
* ``variable``:         @var, @@var or @{var}
* ``keyword``:          Less keywords (when, extend etc.)
* ``function``:         Less and CSS functions (rgba, unit etc.)
* ``tag``:              tag
* ``id``:               #id
* ``class``:            .class
* ``at_rule``:          at-rule keyword (@media, @keyframes etc.)
* ``attr_selector``:    attribute selector (e.g. [href^=http://])
* ``pseudo``:           pseudo classes and elements (:hover, ::before etc.)
* ``hexcolor``:         hex color (#FFF)
* ``built_in``:         inline javascript (or whatever host language) string

Stylus ("stylus", "styl")
-------------------------

* ``at_rule``:          @-rule till first "{" or ";"
* ``attribute``:        property name inside a rule
* ``class``:            .some_name in selectors
* ``comment``:          comment
* ``function``:         Stylus function
* ``hexcolor``:         hex color (#FFFFFF) within a value
* ``id``:               #some_name in selectors
* ``number``:           number within a value
* ``pseudo``:           pseudo classes and elements (:after, ::after etc.)
* ``string``:           string within a value
* ``tag``:              tag in selectors
* ``variable``:         variable starting with "$"

Markdown ("markdown", "md", "mkdown", "mkd")
--------------------------------------------

* ``header``:            header
* ``bullet``:            list bullet
* ``emphasis``:          emphasis
* ``strong``:            strong emphasis
* ``blockquote``:        blockquote
* ``code``:              code
* ``horizontal_rule``:   horizontal rule
* ``link_label``:        link label
* ``link_url``:          link url
* ``link_reference``:    link reference

AsciiDoc ("asciidoc", "adoc")
-----------------------------

* ``header``:            heading
* ``bullet``:            list or labeled bullet
* ``emphasis``:          emphasis
* ``strong``:            strong emphasis
* ``blockquote``:        blockquote
* ``code``:              inline or block code
* ``horizontal_rule``:   horizontal rule
* ``link_label``:        link or image label
* ``link_url``:          link or image url
* ``comment``:           comment
* ``attribute``:         document attribute, block attributes
* ``label``:             admonition label

Django ("django", "jinja")
--------------------------

* ``keyword``:          HTML tag in HTML, default tags and default filters in templates
* ``tag``:              any tag from "<" till ">"
* ``comment``:          template comment, both {# .. #} and {% comment %}
* ``doctype``:          <!DOCTYPE ... > declaration
* ``attribute``:        tag's attribute with or without value
* ``value``:            attribute's value
* ``template_tag``:     template tag {% .. %}
* ``variable``:         template variable {{ .. }}
* ``filter``:           filter from "|" till the next filter or the end of tag
* ``argument``:         filter argument


Twig ("twig", "craftcms")
-------------------------

* ``keyword``:          HTML tag in HTML, default tags and default filters in templates
* ``tag``:              any tag from "<" till ">"
* ``comment``:          template comment {# .. #}
* ``doctype``:          <!DOCTYPE ... > declaration
* ``attribute``:        tag's attribute with or withou value
* ``value``:            attribute's value
* ``template_tag``:     template tag {% .. %}
* ``variable``:         template variable {{ .. }}
* ``filter``:           filter from "|" till the next filter or the end of tag
* ``argument``:         filter argument


Handlebars ("handlebars", "hbs", "html.hbs", "html.handlebars")
---------------------------------------------------------------

* ``expression``:       expression to be evaluated
* ``variable``:         variable
* ``begin-block``:      the beginning of a block
* ``end-block``:        the ending of a block
* ``string``:           string

Dust ("dust", "dst")
--------------------

* ``expression``:       expression to be evaluated
* ``variable``:         variable
* ``begin-block``:      the beginning of a block
* ``end-block``:        the ending of a block
* ``string``:           string

JSON ("json")
-------------

* ``number``:           number
* ``literal``:          "true", "false" and "null"
* ``string``:           string value
* ``attribute``:        name of an object property
* ``value``:            value of an object property

Mathematica ("mathematica", "mma")
----------------------------------

* ``keyword``:          keyword
* ``number``:           number
* ``comment``:          comment
* ``string``:           string
* ``list``:             a list { .. } - the basic Mma structure

JavaScript ("javascript", "js")
-------------------------------

* ``keyword``:          keyword
* ``comment``:          comment
* ``number``:           number
* ``literal``:          special literal: "true", "false" and "null"
* ``built_in``:         built-in objects and functions ("window", "console", "require", etc...)
* ``string``:           string
* ``regexp``:           regular expression
* ``function``:         header of a function
* ``title``:            name of a function inside a header
* ``params``:           parentheses and everything inside them in a function's header
* ``pi``:               'use strict' processing instruction

TypeScript ("typescript", "ts")
-------------------------------

* ``keyword``:          keyword
* ``comment``:          comment
* ``number``:           number
* ``literal``:          special literal: "true", "false" and "null"
* ``built_in``:         built-in objects and functions ("window", "console", "require", etc...)
* ``string``:           string
* ``regexp``:           regular expression
* ``function``:         header of a function
* ``title``:            name of a function inside a header
* ``params``:           parentheses and everything inside them in a function's header
* ``pi``:               'use strict' processing instruction

CoffeeScript ("coffeescript", "coffee", "cson", "iced")
-------------------------------------------------------

* ``keyword``:          keyword
* ``comment``:          comment
* ``number``:           number
* ``literal``:          special literal: "true", "false" and "null"
* ``built_in``:         built-in objects and functions ("window", "console", "require", etc...)
* ``string``:           string
* ``subst``:            #{ ... } interpolation in double-quoted strings
* ``regexp``:           regular expression
* ``function``:         header of a function
* ``class``:            header of a class
* ``title``:            name of a function variable inside a header
* ``params``:           parentheses and everything inside them in a function's header
* ``property``:         @-property within class and functions

Dart ("dart")
-------------

* ``keyword``:          keyword
* ``literal``:          keyword that can be uses as identifier but have special meaning in some cases
* ``built_in``:         some of basic built in classes and function
* ``number``:           number
* ``string``:           string
* ``subst``:            in-string substitution (${...})
* ``comment``:          commment
* ``annotation``:       annotation
* ``class``:            class header from "class" till "{"
* ``title``:            class name

LiveScript ("livescript", "ls")
-------------------------------

* ``keyword``:          keyword
* ``comment``:          comment
* ``number``:           number
* ``literal``:          special literal: "true", "false" and "null"
* ``built_in``:         built-in objects and functions ("window", "console", "require", etc...)
* ``string``:           string
* ``subst``:            #{ ... } interpolation in double-quoted strings
* ``regexp``:           regular expression
* ``function``:         header of a function
* ``class``:            header of a class
* ``title``:            name of a function variable inside a header
* ``params``:           parentheses and everything inside them in a function's header
* ``property``:         @-property within class and functions

ActionScript ("actionscript", "as")
-----------------------------------

* ``comment``:          comment
* ``string``:           string
* ``number``:           number
* ``keyword``:          keywords
* ``literal``:          literal
* ``reserved``:         reserved keyword
* ``title``:            name of declaration (package, class or function)
* ``preprocessor``:     preprocessor directive (import, include)
* ``type``:             type of returned value (for functions)
* ``package``:          package (named or not)
* ``class``:            class/interface
* ``function``:         function
* ``param``:            params of function
* ``rest_arg``:         rest argument of function

Haxe ("haxe", "hx")
-------------------

* ``comment``:          comment
* ``string``:           string
* ``number``:           number
* ``keyword``:          keywords
* ``literal``:          literal
* ``reserved``:         reserved keyword
* ``title``:            name of declaration (package, class or function)
* ``preprocessor``:     preprocessor directive (if, else, elseif, error)
* ``type``:             type of returned value (for functions)
* ``package``:          package (named or not)
* ``class``:            class/interface
* ``function``:         function
* ``param``:            params of function
* ``rest_arg``:         rest argument of function

VBScript ("vbscript", "vbs")
----------------------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``built_in``:         built-in function

VB.Net ("vbnet", "vb")
----------------------

* ``keyword``:          keyword
* ``built_in``:         built-in types
* ``literal``:          "true", "false" and "nothing"
* ``string``:           string
* ``comment``:          comment
* ``xmlDocTag``:        xmldoc tag ("'''", "<!--", "-->", "<..>")
* ``preprocessor``:     preprocessor directive

Protocol Buffers ("protobuf")
-----------------------------

* ``keyword``:          keyword
* ``built_in``:         built-in types (e.g. `int64`, `string`)
* ``string``:           string
* ``number``:           number
* ``literal``:          "true" and "false"
* ``comment``:          comment
* ``class``:            message, service or enum definition header
* ``title``:            message, service or enum identifier
* ``function``:         RPC call identifier

Cap’n Proto ("capnproto", "capnp")
----------------------------------

* ``shebang``:          message identifier
* ``keyword``:          keyword
* ``built_in``:         built-in types (e.g. `Int64`, `Text`)
* ``string``:           string
* ``number``:           number or field number (e.g. @N)
* ``literal``:          "true" and "false"
* ``comment``:          comment
* ``class``:            message, interface or enum definition header
* ``title``:            message, interface or enum identifier

Thrift ("thrift")
-----------------

* ``keyword``:          keyword
* ``built_in``:         built-in types (e.g. `byte`, `i32`)
* ``string``:           string
* ``number``:           number
* ``literal``:          "true" and "false"
* ``comment``:          comment
* ``class``:            struct, enum, service or exception definition header
* ``title``:            struct, enum, service or exception identifier

HTTP ("http", "https")
----------------------

* ``request``:          first line of a request
* ``status``:           first line of a response
* ``attribute``:        header name
* ``string``:           header value or query string in a request line
* ``number``:           status code

Lua ("lua")
-----------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``built_in``:         built-in operator
* ``function``:         header of a function
* ``title``:            name of a function inside a header
* ``params``:           everything inside parentheses in a function's header
* ``long_brackets``:    multiline string in [=[ .. ]=]

Delphi ("delphi")
-----------------

* ``keyword``:          keyword
* ``comment``:          comment (of any type)
* ``number``:           number
* ``string``:           string
* ``function``:         header of a function, procedure, constructor and destructor
* ``title``:            name of a function, procedure, constructor or destructor inside a header
* ``params``:           everything inside parentheses in a function's header
* ``class``:            class' body from "= class" till "end;"

Oxygene ("oxygene")
-------------------

* ``keyword``:          keyword
* ``comment``:          comment (of any type)
* ``string``:           string/char
* ``function``:         method, destructor, procedure or function
* ``title``:            name of a function (inside function)
* ``params``:           everything inside parentheses in a function's header
* ``number``:           number
* ``class``:            class' body from "= class" till "end;"

Java ("java", "jsp")
--------------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``annotaion``:        annotation
* ``class``:            class header from "class" till "{"
* ``function``:         method header
* ``title``:            class or method name
* ``params``:           everything in parentheses inside a class header
* ``inheritance``:      keywords "extends" and "implements" inside class header

Processing ("processing")
-------------------------

* ``constant``:         Processing constants
* ``variable``:         Processing special variables
* ``keyword``:          Variable types
* ``function``:         Processing setup and draw functions
* ``built_in``:         Processing built in functions

AspectJ ("aspectj")
-------------------

* ``comment``:          comment
* ``doctag``:           @-tag in javadoc comment
* ``string``:           string
* ``number``:           number
* ``keyword``:          keyword
* ``annotation``:       annotation
* ``function``:         method and intertype method header
* ``aspect``:           aspect header from "aspect" till "{"
* ``params``:           everything in parentheses inside an aspect header
* ``inheritance``:      keywords "extends" and "implements" inside an aspect header
* ``title``:            aspect, (intertype) method name or pointcut name inside an aspect header

Fortran ("fortran", "f90", "f95")
---------------------------------

* ``comment``:          comment
* ``function``:         name of a function or a subroutine 
* ``keyword``:          language keywords (function, if) 
* ``number``:           number
* ``string``:           string constant (single or double quote)

IRPF90 ("irpf90")
-----------------

* ``comment``:          comment
* ``function``:         name of a function or a subroutine
* ``keyword``:          language keywords (function, if) 
* ``number``:           number
* ``string``:           string constant (single or double quote)

C++ ("cpp", "c", "cc", "h", "c++", "h++", "hpp")
------------------------------------------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string and character
* ``comment``:          comment
* ``preprocessor``:     preprocessor directive

Objective C ("objectivec", "mm", "objc", "obj-c")
-------------------------------------------------

* ``keyword``:          keyword
* ``built_in``:         Cocoa/Cocoa Touch constants and classes
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``preprocessor``:     preprocessor directive
* ``class``:            interface/implementation, protocol and forward class declaration
* ``title``:            title (id) of interface, implementation, protocol, class
* ``variable``:         properties and struct accessors

Vala ("vala")
-------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``class``:            class definitions
* ``title``:            in class definition
* ``constant``:         ALL_UPPER_CASE

C# ("cs", "csharp")
-------------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``xmlDocTag``:        xmldoc tag ("///", "<!--", "-->", "<..>")
* ``class``:            class header from "class" till "{"
* ``function``:         method header
* ``title``:            title of namespace or class

F# ("fsharp", "fs")
-------------------

* ``keywords``:         keyword
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``class``:            any custom F# type
* ``title``:            the name of a custom F# type
* ``annotation``:       any attribute

OCaml ("ocaml", "ml")
---------------------

* ``keywords``:         keyword
* ``literal``:          true false etc.
* ``number``:           number
* ``string``:           string
* ``char``:             character
* ``comment``:          comment
* ``built_in``:         built-in type (int, list etc.)
* ``type``:             variant constructor, module name
* ``tag``:              polymorphic variant tag
* ``symbol``:           type variable

D ("d")
-------

* ``comment``:          comment
* ``string``:           string constant
* ``number``:           number
* ``keyword``:          language keywords (including @attributes)
* ``constant``:         true false null
* ``built_in``:         built-in plain types (int, string etc.)

RenderMan RSL ("rsl")
---------------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string (including @"..")
* ``comment``:          comment
* ``preprocessor``:     preprocessor directive
* ``shader``:           shader keywords
* ``shading``:          shading keywords
* ``built_in``:         built-in function

RenderMan RIB ("rib")
---------------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``commands``:         command

Maya Embedded Language ("mel")
------------------------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``variable``:         variable

SQL ("sql")
-----------

* ``keyword``:          keyword (mostly SQL'92, SQL'99 and T-SQL)
* ``literal``:          special literal: "true" and "false"
* ``built_in``:         built-in type name
* ``number``:           number
* ``string``:           string (of any type: "..", '..', \`..\`)
* ``comment``:          comment

Smalltalk ("smalltalk", "st")
-----------------------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``symbol``:           symbol
* ``array``:            array
* ``class``:            name of a class
* ``char``:             char
* ``localvars``:        block of local variables

Lisp ("lisp")
-------------

* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``variable``:         variable
* ``literal``:          b, t and nil
* ``list``:             non-quoted list
* ``keyword``:          first symbol in a non-quoted list
* ``body``:             remainder of the non-quoted list
* ``quoted``:           quoted list, both "(quote .. )" and "'(..)"

Clojure ("clojure", "clj")
--------------------------

* ``comment``:          comments and hints
* ``string``:           string
* ``number``:           number
* ``collection``:       collections
* ``attribute``:        :keyword
* ``list``:             non-quoted list
* ``keyword``:          first symbol in a list
* ``built_in``:         built-in function name as the first symbol in a list
* ``prompt``:           REPL prompt

Scheme ("scheme")
-----------------

* ``shebang``:          script interpreter header
* ``comment``:          comment
* ``string``:           string
* ``number``:           number
* ``regexp``:           regexp
* ``variable``:         single-quote 'identifier
* ``list``:             non-quoted list
* ``keyword``:          first symbol in a list
* ``built_in``:         built-in function name as the first symbol in a list
* ``literal``:          #t, #f, #\...\

Ini ("ini")
-----------

* ``title``:            title of a section
* ``value``:            value of a setting of any type
* ``string``:           string
* ``number``:           number
* ``keyword``:          boolean value keyword

Apache ("apache", "apacheconf")
-------------------------------

* ``keyword``:          keyword
* ``number``:           number
* ``comment``:          comment
* ``literal``:          On and Off
* ``sqbracket``:        variables in rewrites "%{..}"
* ``cbracket``:         options in rewrites "[..]"
* ``tag``:              begin and end of a configuration section

Nginx ("nginx", "nginxconf")
----------------------------

* ``title``:            directive title
* ``string``:           string
* ``number``:           number
* ``comment``:          comment
* ``built_in``:         built-in constant
* ``variable``:         $-variable
* ``regexp``:           regexp

Diff ("diff", "patch")
----------------------

* ``header``:           file header
* ``chunk``:            chunk header within a file
* ``addition``:         added lines
* ``deletion``:         deleted lines
* ``change``:           changed lines

DOS ("dos", "bat", "cmd")
-------------------------

* ``keyword``:          keyword
* ``flow``:             batch control keyword
* ``stream``:           DOS special files ("con", "prn", ...)
* ``winutils``:         some commands (see dos.js specifically)
* ``envvar``:           environment variables

PowerShell ("powershell", "ps")
-------------------------------

* ``keyword``:          keyword
* ``string``:           string
* ``number``:           number
* ``comment``:          comment
* ``literal``:          special literal: "true" and "false"
* ``variable``:         variable

Bash ("bash", "sh", "zsh")
--------------------------

* ``keyword``:          keyword
* ``string``:           string
* ``number``:           number
* ``comment``:          comment
* ``literal``:          special literal: "true" and "false"
* ``variable``:         variable
* ``shebang``:          script interpreter header

Makefile ("makefile", "mk", "mak")
----------------------------------

* ``keyword``:          keyword ".PHONY" within the phony line
* ``string``:           string
* ``comment``:          comment
* ``variable``:         $(..) variable
* ``title``:            target title
* ``constant``:         constant within the initial definition

CMake ("cmake", "cmake.in")
---------------------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``envvar``:           $-variable
* ``operator``:         operator (LESS, STREQUAL, MATCHES, etc)

Nix ("nix")
-----------

* ``keyword``:          keyword
* ``built_in``:         built-in constant
* ``number``:           number
* ``string``:           single and double quotes
* ``subst``:            antiquote ${}
* ``comment``:          comment
* ``variable``:         function parameter name

NSIS ("nsis")
-------------

* ``symbol``:           directory constants
* ``number``:           number
* ``constant``:         definitions, language-strings, compiler commands
* ``variable``:         $-variable
* ``string``:           string
* ``comment``:          comment
* ``params``:           parameters
* ``keyword``:          keywords
* ``literal``:          keyword options

Axapta ("axapta")
-----------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``class``:            class header from "class" till "{"
* ``title``:            class name inside a header
* ``params``:           everything in parentheses inside a class header
* ``preprocessor``:     preprocessor directive

Oracle Rules Language ("ruleslanguage")
---------------------------------------

* ``comment``:          comment
* ``string``:           string constant
* ``number``:           number
* ``keyword``:          language keywords
* ``built_in``:         built-in functions
* ``array``:            array stem

1C ("1c")
---------

* ``keyword``:          keyword
* ``number``:           number
* ``date``:             date
* ``string``:           string
* ``comment``:          comment
* ``function``:         header of function or procedure
* ``title``:            function name inside a header
* ``params``:           everything in parentheses inside a function header
* ``preprocessor``:     preprocessor directive

x86 Assembly ("x86asm")
-----------------------

* ``keyword``:          instruction mnemonic
* ``literal``:          register name
* ``pseudo``:           assembler's pseudo instruction
* ``preprocessor``:     macro
* ``built_in``:         assembler's keyword
* ``comment``:          comment
* ``number``:           number
* ``string``:           string
* ``label``:            jump label
* ``argument``:         macro's argument

AVR assembler ("avrasm")
------------------------

* ``keyword``:          keyword
* ``built_in``:         pre-defined register
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``label``:            label
* ``preprocessor``:     preprocessor directive
* ``localvars``:        substitution in .macro

VHDL ("vhdl")
-------------

* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``literal``:          signal logical value
* ``typename``:         typename
* ``attribute``:        signal attribute

Parser3 ("parser3")
-------------------

* ``keyword``:          keyword
* ``number``:           number
* ``comment``:          comment
* ``variable``:         variable starting with "$"
* ``preprocessor``:     preprocessor directive
* ``title``:            user-defined name starting with "@"

LiveCode Server ("livecodeserver")
----------------------------------

* ``variable``:         variable starting with "g", "t", "p", "s", "$_"
* ``string``:           string
* ``comment``:          comment
* ``number``:           number
* ``title``:            name of a command or a function
* ``keyword``:          keyword
* ``constant``:         constant
* ``operator``:         operator
* ``built_in``:         built_in functions and commands
* ``function``:         header of a function
* ``command``:          header of a command
* ``preprocessor``:     preprocessor marks: "<?", "<?rev", "<?lc", "<?livecode" and "?>"

TeX ("tex")
-----------

* ``comment``:          comment
* ``number``:           number
* ``command``:          command
* ``parameter``:        parameter
* ``formula``:          formula
* ``special``:          special symbol

Haskell ("haskell", "hs")
-------------------------

* ``comment``:          comment
* ``pragma``:           GHC pragma
* ``preprocessor``:     CPP preprocessor directive
* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``title``:            function or variable name
* ``type``:             value, type or type class constructor name (i.e. capitalized)
* ``container``:        (..., ...) or {...; ...} list in declaration or record
* ``module``:           module declaration
* ``import``:           import declaration
* ``class``:            type class or instance declaration
* ``typedef``:          type declaration (type, newtype, data)
* ``default``:          default declaration
* ``infix``:            infix declaration
* ``foreign``:          FFI declaration
* ``shebang``:          shebang line

Elm ("elm")
-------------------------

* ``comment``:          comment
* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``title``:            function or variable name
* ``type``:             value or type constructor name (i.e. capitalized)
* ``container``:        (..., ...) or {...; ...} list in declaration or record
* ``module``:           module declaration
* ``import``:           import declaration
* ``typedef``:          type declaration (type, type alias)
* ``infix``:            infix declaration
* ``foreign``:          javascript interop declaration

Erlang ("erlang", "erl")
------------------------

* ``comment``:          comment
* ``string``:           string
* ``number``:           number
* ``keyword``:          keyword
* ``record_name``:      record access (#record_name)
* ``title``:            name of declaration function
* ``variable``:         variable (starts with capital letter or with _)
* ``pp``:.keywords      module's attribute (-attribute)
* ``function_name``:    atom or atom:atom in case of function call

Elixir ("elixir")
-----------------

*  ``keyword``:         keyword
*  ``string``:          string
*  ``subst``:           in-string substitution (#{...})
*  ``comment``:         comment
*  ``function``:        function header "def some_name(...):"
*  ``class``:           defmodule and defrecord headers
*  ``title``:           name of a function or a module inside a header
*  ``symbol``:          atom
*  ``constant``:        name of a module
*  ``number``:          number
*  ``variable``:        variable
*  ``regexp``:          regexp

Rust ("rust", "rs")
-------------------

* ``comment``:          comment
* ``string``:           string
* ``number``:           number
* ``keyword``:          keyword
* ``title``:            name of declaration
* ``preprocessor``:     preprocessor directive

Matlab ("matlab")
-----------------

* ``comment``:          comment
* ``string``:           string
* ``number``:           number
* ``keyword``:          keyword
* ``title``:            function name
* ``function``:         function
* ``param``:            params of function
* ``matrix``:           matrix in [ .. ]
* ``cell``:             cell in { .. }

Scilab ("scilab", "sci")
------------------------

* ``comment``:          comment
* ``string``:           string
* ``number``:           number
* ``keyword``:          keyword
* ``title``:            function name
* ``function``:         function
* ``param``:            params of function
* ``matrix``:           matrix in [ .. ]

R ("r")
-------

* ``comment``:          comment
* ``string``:           string constant
* ``number``:           number
* ``keyword``:          language keywords (function, if) plus "structural" functions (attach, require, setClass)
* ``literal``:          special literal: TRUE, FALSE, NULL, NA, etc.

OpenGL Shading Language ("glsl")
--------------------------------

* ``comment``:          comment
* ``number``:           number
* ``preprocessor``:     preprocessor directive
* ``keyword``:          keyword
* ``built_in``:         GLSL built-in functions and variables
* ``literal``:          true false

AppleScript ("applescript", "osascript")
----------------------------------------

* ``keyword``:          keyword
* ``command``:          core AppleScript command
* ``constant``:         AppleScript built in constant
* ``type``:             AppleScript variable type (integer, etc.)
* ``property``:         Applescript built in property (length, etc.)
* ``number``:           number
* ``string``:           string
* ``comment``:          comment
* ``title``:            name of a handler

Vim Script ("vim")
------------------

* ``keyword``:          keyword
* ``built_in``:         built-in functions
* ``string``:           string, comment
* ``number``:           number
* ``function``:         function header "function Foo(...)"
* ``title``:            name of a function
* ``params``:           everything inside parentheses in a function's header
* ``variable``:         vim variables with different visibilities "g:foo, b:bar"

Brainfuck ("brainfuck", "bf")
-----------------------------

* ``title``:            Brainfuck while loop command
* ``literal``:          Brainfuck inc and dec commands
* ``comment``:          comment
* ``string``:           Brainfuck input and output commands

Mizar ("mizar")
---------------

* ``keyword``:          keyword
* ``comment``:          comment

AutoHotkey ("autohotkey")
-------------------------

* ``keyword``:          keyword
* ``literal``:          A (active window), true, false, NOT, AND, OR
* ``built_in``:         built-in variables
* ``string``:           string
* ``comment``:          comment
* ``number``:           number
* ``var_expand``:       variable expansion (enclosed in percent sign)
* ``label``:            label, hotkey label, hotstring label

Monkey ("monkey")
-----------------

* ``keyword``:          keyword
* ``built_in``:         built-in functions, variables and types of variables
* ``literal``:          True, False, Null, And, Or, Shl, Shr, Mod
* ``string``:           string
* ``comment``:          comment
* ``number``:           number
* ``function``:         header of a function, method and constructor
* ``class``:            class header
* ``title``:            name of an alias, class, interface, function or method inside a header
* ``variable``:         self and super keywords
* ``preprocessor``:     import and preprocessor
* ``pi``:               Strict directive

FIX ("fix")
-----------

* ``attribute``:        attribute name
* ``string``:           attribute value

Gherkin ("gherkin")
-------------------

* ``keyword``:          keyword
* ``number``:           number
* ``comment``:          comment
* ``string``:           string

TP ("tp")
---------

* ``keyword``:          keyword
* ``constant``:         ON, OFF, max_speed, LPOS, JPOS, ENABLE, DISABLE, START, STOP, RESET
* ``number``:           number
* ``comment``:          comment
* ``string``:           string
* ``data``:             numeric registers, positions, position registers, etc.
* ``io``:               inputs and outputs
* ``label``:            data and io labels
* ``variable``:         system variables
* ``units``:            units (e.g. mm/sec, sec, deg)

Nimrod ("nimrod", "nim")
------------------------

* ``decorator``         pragma
* ``string``            string literal
* ``type``              variable type
* ``number``            numeric literal
* ``comment``           comment

Swift ("swift")
---------------

* ``keyword``:          keyword
* ``comment``:          comment
* ``number``:           number
* ``string``:           string
* ``literal``:          special literal: "true", "false" and "nil"
* ``built_in``:         built-in Swift functions
* ``func``:             header of a function
* ``class``:            class, protocol, enum, struct, or extension declaration
* ``title``:            name of a function or class (or protocol, etc)
* ``generics``:         generic type of a function
* ``params``:           parameters of a function
* ``type``:             a type
* ``preprocessor``:     @attributes

G-Code ("gcode", "nc")
----------------------

* ``keyword``:          G words, looping constructs and conditional operators
* ``comment``:          comment
* ``number``:           number
* ``built_in``:         trigonometric and mathematical functions
* ``title``:            M words and variable registers
* ``preprocessor``:     program number and ending character
* ``label``:            block number

Q ("k", "kdb")
--------------

* ``comment``:          comment
* ``string``:           string constant
* ``number``:           number
* ``keyword``:          language keywords
* ``constant``:         0/1b
* ``typename``:         built-in plain types (int, symbol etc.)
* ``built_in``:         built-in function

Tcl ("tcl", "tk")
-----------------

* ``keyword``:          keyword
* ``comment``:          comment
* ``symbol``:           function (proc)
* ``variable``:         variable
* ``string``:           string
* ``number``:           number

Puppet ("puppet", "pp")
-----------------------

* ``comment``:          comment
* ``string``:           string
* ``number``:           number
* ``keyword``:          classes and types
* ``constant``:         dependencies

Stata ("stata")
---------------

* ``keyword``:          commands and control flow
* ``label``:            macros (locals and globals)
* ``string``:           string
* ``comment``:          comment
* ``literal``:          built-in functions

XL ("xl", "tao")
----------------

* ``keyword``:          keywords defined in the default syntax file
* ``literal``:          names entered in the compiler (true, false, nil)
* ``type``:             basic types (integer, real, text, name, etc)
* ``built_in``:         built-in functions (sin, exp, mod, etc)
* ``module``:           names of frequently used Tao modules
* ``id``:               names of frequently used Tao functions
* ``constant``:         all-uppercase names such as HELLO
* ``variable``:         Mixed-case names such as Hello (style convention)
* ``id``:               Lower-case names such as hello
* ``string``:           Text between single or double quote, long text << >>
* ``number``:           Number values
* ``function``:         Function or variable definition
* ``import``:           Import clause

Roboconf ("graph", "instances")
-------------------------------

* ``keyword``:          keyword
* ``string``:           names of imported variables
* ``comment``:          comment
* ``facet``:            a **facet** section
* ``component``:        a **component** section
* ``instance-of``:      an **instance** section

STEP Part 21 ("p21", "step", "stp")
-----------------------------------

* ``preprocessor``:     delimiters
* ``comment``:          single- or multi-line comment
* ``keyword``:          keyword
* ``number``:           number
* ``string``:           string
* ``label``:            variable reference starting with "#"

Mercury ("mercury")
-------------------

* ``keyword``:          keyword
* ``pragma``:           compiler directive
* ``preprocessor``:     foreign language interface
* ``built_in``:         control flow, logical, implication, head-body conjunction, purity
* ``number``:           number, numcode of character
* ``comment``:          comment
* ``label``:            TODO label inside comment
* ``string``:           string
* ``constant``:         string format

Smali ("smali")
---------------

* ``string``:           string
* ``comment``:          comment
* ``keyword``:          smali keywords
* ``instruction``:      instruction
* ``class``:            classtypes
* ``function``:         function (call or signature)
* ``variable``:         variable or parameter

Verilog ("verilog", "v")
------------------------

* ``keyword``:          keyword, operator
* ``comment``:          comment
* ``typename``:         types of data, register, and net
* ``number``:           number literals (including X and Z)
* ``value``:            parameters passed to instances

Dockerfile ("dockerfile", "docker")
-----------------------------------

* ``keyword``:          instruction keyword
* ``comment``:          comment
* ``number``:           number
* ``string``:           string

PF ("pf", "pf.conf")
--------------------

* ``built_in``:         top level action, e.g. block/match/pass
* ``keyword``:          some parameter/modifier to an action (in, on, nat-to, most reserved words)
* ``literal``:          words representing special values, e.g. all, egress
* ``comment``:          comment
* ``number``:           number
* ``string``:           string
* ``variable``:         used for both macros and tables

XQuery ("xpath", "xq")
----------------------

* ``keyword``:          instruction keyword
* ``literal``:          words representing special values, e.g. all, egress
* ``comment``:          comment
* ``number``:           number
* ``string``:           string
* ``variable``:         variable
* ``decorator``:        annotations
* ``function``:         function

C/AL ("cal")
------------

* ``keyword``:          keyword
* ``comment``:          comment (of any type)
* ``number``:           number
* ``string``:           string
* ``date``:             date, time, or datetime
* ``function``:         header of a procedure
* ``title``:            name of an object or procedure inside a header
* ``params``:           everything inside parentheses in a function's header
* ``class``:            objects body
* ``variable``:         reference to variables

Inform7 ("I7")
--------------

* ``string``:           string
* ``comment``:          comment
* ``title``:            a section header or table header
* ``subst``:            a substitution inside a string
* ``kind``:             a built-in kind (thing, room, person, etc), for relevance
* ``characteristic``:   a commonly-used characteristic (open, closed, scenery, etc), for relevance
* ``verb``:             a commonly-used verb (is, understand), for relevance.
* ``misc_keyword``:     a word with specific I7 meaning (kind, rule), for relevance.

Prolog ("prolog")
-----------------

* ``atom``:             non-quoted atoms and functor names
* ``string``:           quoted atoms, strings, character code list literals, character code literals
* ``number``:           numbers
* ``variable``:         variables
* ``comment``:          comments

DNS Zone file ("dns", "zone", "bind")
-------------------------------------

* ``keyword``:          DNS resource records as defined in various RFCs
* ``operator``:         operator
* ``number``:           IPv4 and IPv6 addresses
* ``comment``:          comments

Ceylon ("ceylon")
-----------------

* ``keyword``:          keyword
* ``annotation``:       language annotation or compiler annotation
* ``string``:           string literal, part of string template, character literal
* ``number``:           number
* ``comment``:          comment

OpenSCAD ("openscad", "scad")
-----------------------------

* ``built_in``:          built-in functions (cube, sphere, translate, ...)
* ``comment``:           comments
* ``function``:          function or module definition
* ``keyword``:           keywords
* ``literal``:           words representing values (e.g. false, undef, PI)
* ``number``:            numbers
* ``params``:            parameters in function or module header or call
* ``preprocessor``:      file includes (i.e. include, use)
* ``string``:            quoted strings
* ``title``:             names of function or module in a header

ARM assembler ("armasm", "arm")
-------------------------------

* ``keyword``:          keyword (instruction mnemonics)
* ``literal``:          pre-defined register
* ``number``:           number
* ``built_in``:         constants (true, false)
* ``string``:           string
* ``comment``:          comment
* ``label``:            label
* ``preprocessor``:     preprocessor directive
* ``title``:            symbol versions

AutoIt ("autoit")
-----------------

* ``keyword``:          keyword
* ``literal``:          True, False, And, Null, Not, Or
* ``built_in``:         built-in functions and UDF
* ``constant``:     	constant, macros
* ``variable``:         variables
* ``string``:           string
* ``comment``:          comment
* ``number``:           number
* ``preprocessor``:     AutoIt3Wrapper directives section

Access log ("accesslog")
------------------------

* ``keyword``:          HTTP method name
* ``string``:           date, request string, user-agent etc
* ``number``:           IP-address, numbers

Crystal ("crystal", "cr")
-------------------------

* ``keyword``:          keyword
* ``string``:           string
* ``number``:           number
* ``symbol``:           symbol
* ``regexp``:           regexp
* ``literal``:          true, false or nil
* ``constant``:         constant
* ``variable``:         global, instance, class and fresh variables
* ``subst``:            in-string substitution (#{...})
* ``expansion``:        macro expansion ({{...}}, {%...%})
* ``class``:            class, module, struct, enum, union or lib header
* ``function``:         method or function header
* ``title``:            a method name or class name
* ``parent``:           name of a parent class
