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.

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
• yardoctag: YARD tag
• 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
• phpdoc: phpdoc params in comments
• variable: variable starting with “$”
• preprocessor: preprocessor marks: “<?php” and ”?>”

Scala (“scala”)

• keyword: keyword
• number: number
• string: string
• comment: comment
• annotation: annotation
• javadoc: javadoc comment
• javadoctag: @-tag in javadoc
• 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
• annotation: annotation
• javadoc: javadoc comment
• javadoctag: @-tag in javadoc
• 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

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
• javadoc: doc 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 ”;”
• 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

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 @

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”)

• 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: comment
• doctype: <!DOCTYPE ... > declaration
• attribute: tag’s attribute with or without value
• value: attribute’s value
• template_tag: template tag {% .. %}
• variable: template variable {{ .. }}
• template_comment: template comment, both {# .. #} and {% comment %}
• 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”
• 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”
• 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
• annotaion: annotation
• dartdoc: dartdoc comment
• class: class header from “class” till “{“
• title: class name

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
• stl_container: instantiation of STL-like containers (“list<...>”)

HTTP (“http”)

• 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
• javadoc: javadoc comment
• 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

C++ (“cpp”, “c”, “h”, “c++”, “h++”)

• keyword: keyword
• number: number
• string: string and character
• comment: comment
• preprocessor: preprocessor directive
• stl_container: instantiation of STL containers (“vector<...>”)

Objective C (“objectivec”, “m”, “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
• number: number
• string: string
• comment: comment
• class: any custom OCaml type
• title: the name of a custom OCaml type
• annotation: any attribute

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

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

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

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

Nimrod (“nimrod”)

• 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