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

Navigation

CSS classes reference¶

Python (“python”, “py”, “gyp”)¶

Python profiler results (“profile”)¶

Ruby (“ruby”, “rb”, “gemspec”, “podspec”, “thor”, “irb”)¶

Haml (“haml”)¶

Perl (“perl”, “pl”)¶

PHP (“php”, “php3”, “php4”, “php5”, “php6”)¶

Scala (“scala”)¶

Groovy (“groovy)¶

Go (“go”, “golang”)¶

Gradle (“gradle”)¶

HTML, XML (“xml”, “html”, “xhtml”, “rss”, “atom”, “xsl”, “plist”)¶

Lasso (“lasso”, “ls”, “lassoscript”)¶

CSS (“css”)¶

SCSS (“scss”)¶

Markdown (“markdown”, “md”, “mkdown”, “mkd”)¶

AsciiDoc (“asciidoc”)¶

Django (“django”, “jinja”)¶

Handlebars (“handlebars”, “hbs”, “html.hbs”, “html.handlebars”)¶

Dust (“dust”, “dst”)¶

JSON (“json”)¶

Mathematica (“mathematica”, “mma”)¶

JavaScript (“javascript”, “js”)¶

TypeScript (“typescript”, “ts”)¶

CoffeeScript (“coffeescript”, “coffee”, “cson”, “iced”)¶

Dart (“dart”)¶

ActionScript (“actionscript”, “as”)¶

Haxe (“haxe”, “hx”)¶

VBScript (“vbscript”, “vbs”)¶

VB.Net (“vbnet”, “vb”)¶

Protocol Buffers (“protobuf”)¶

Cap’n Proto (“capnproto”, “capnp”)¶

Thrift (“thrift”)¶

HTTP (“http”)¶

Lua (“lua”)¶

Delphi (“delphi”)¶

Oxygene (“oxygene”)¶

Java (“java”, “jsp”)¶

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

Objective C (“objectivec”, “m”, “mm”, “objc”, “obj-c”)¶

Vala (“vala”)¶

C# (“cs”, “csharp”)¶

F# (“fsharp”, “fs”)¶

OCaml (“ocaml”, “ml”)¶

D (“d”)¶

RenderMan RSL (“rsl”)¶

RenderMan RIB (“rib”)¶

Maya Embedded Language (“mel”)¶

SQL (“sql”)¶

Smalltalk (“smalltalk”, “st”)¶

Lisp (“lisp”)¶

Clojure (“clojure”, “clj”)¶

Scheme (“scheme”)¶

Ini (“ini”)¶

Apache (“apache”, “apacheconf”)¶

Nginx (“nginx”, “nginxconf”)¶

Diff (“diff”, “patch”)¶

DOS (“dos”, “bat”, “cmd”)¶

Bash (“bash”, “sh”, “zsh”)¶

Makefile (“makefile”, “mk”, “mak”)¶

CMake (“cmake”, “cmake.in”)¶

Nix (“nix”)¶

NSIS (“nsis”)¶

Axapta (“axapta”)¶

Oracle Rules Language (“ruleslanguage”)¶

1C (“1c”)¶

x86 Assembly (“x86asm”)¶

AVR assembler (“avrasm”)¶

VHDL (“vhdl”)¶

Parser3 (“parser3”)¶

LiveCode Server (“livecodeserver”)¶

TeX (“tex”)¶

Haskell (“haskell”, “hs”)¶

Erlang (“erlang”, “erl”)¶

Elixir (“elixir”)¶

Rust (“rust”, “rs”)¶

Matlab (“matlab”)¶

Scilab (“scilab”, “sci”)¶

R (“r”)¶