/*
Core highlighting function. Accepts a string with the code to highlight and
optionaly a language name. Returns an object with the following properties:
- language (detected language)
- relevance (int)
- keyword_count (int)
- value (an HTML string with highlighting markup)
- second (object with the same structure for second-best heuristically
detected language, may be absent)
*/
var hljs = function(value, language_name) {
if(!language_name){
var result = {
keyword_count: 0,
relevance: 0,
value: hljs.escape(value)
};
var second = result;
for (var key in hljs.LANGUAGES) {
if (!hljs.LANGUAGES.hasOwnProperty(key))
continue;
var current = hljs(value, key);
current.language = key;
if (current.keyword_count + current.relevance > second.keyword_count + second.relevance) {
second = current;
}
if (current.keyword_count + current.relevance > result.keyword_count + result.relevance) {
second = result;
result = current;
}
}
if (second.language) {
result.second = second;
}
return result;
}
function subMode(lexem, mode) {
for (var i = 0; i < mode.contains.length; i++) {
var match = mode.contains[i].beginRe.exec(lexem);
if (match && match.index == 0) {
return mode.contains[i];
}
}
}
function endOfMode(mode_index, lexem) {
if (modes[mode_index].end && modes[mode_index].endRe.test(lexem))
return 1;
if (modes[mode_index].endsWithParent) {
var level = endOfMode(mode_index - 1, lexem);
return level ? level + 1 : 0;
}
return 0;
}
function isIllegal(lexem, mode) {
return mode.illegal && mode.illegalRe.test(lexem);
}
function compileTerminators(mode, language) {
var terminators = [];
for (var i = 0; i < mode.contains.length; i++) {
terminators.push(mode.contains[i].begin);
}
var index = modes.length - 1;
do {
if (modes[index].end) {
terminators.push(modes[index].end);
}
index--;
} while (modes[index + 1].endsWithParent);
if (mode.illegal) {
terminators.push(mode.illegal);
}
return terminators.length ? langRe(language, terminators.join('|'), true) : null;
}
function eatModeChunk(value, index) {
var mode = modes[modes.length - 1];
if (mode.terminators === undefined) {
mode.terminators = compileTerminators(mode, language);
}
var match;
if (mode.terminators) {
mode.terminators.lastIndex = index;
match = mode.terminators.exec(value);
}
return match ? [value.substr(index, match.index - index), match[0], false] : [value.substr(index), '', true];
}
function keywordMatch(mode, match) {
var match_str = language.case_insensitive ? match[0].toLowerCase() : match[0];
var value = mode.keywords[match_str];
if (value && value instanceof Array)
return value;
return false;
}
function processKeywords(buffer, mode) {
buffer = hljs.escape(buffer);
if (!mode.keywords)
return buffer;
var result = '';
var last_index = 0;
mode.lexemsRe.lastIndex = 0;
var match = mode.lexemsRe.exec(buffer);
while (match) {
result += buffer.substr(last_index, match.index - last_index);
var keyword_match = keywordMatch(mode, match);
if (keyword_match) {
keyword_count += keyword_match[1];
result += '' + match[0] + '';
} else {
result += match[0];
}
last_index = mode.lexemsRe.lastIndex;
match = mode.lexemsRe.exec(buffer);
}
return result + buffer.substr(last_index, buffer.length - last_index);
}
function processSubLanguage(buffer, mode) {
var result;
if (mode.subLanguage == '') {
result = hljs(buffer);
} else {
result = hljs(buffer, mode.subLanguage);
}
// Counting embedded language score towards the host language may be disabled
// with zeroing the containing mode relevance. Usecase in point is Markdown that
// allows XML everywhere and makes every XML snippet to have a much larger Markdown
// score.
if (mode.relevance > 0) {
keyword_count += result.keyword_count;
relevance += result.relevance;
}
return '' + result.value + '';
}
function processBuffer(buffer, mode) {
if (mode.subLanguage && hljs.LANGUAGES[mode.subLanguage] || mode.subLanguage == '') {
return processSubLanguage(buffer, mode);
} else {
return processKeywords(buffer, mode);
}
}
function startNewMode(mode, lexem) {
var markup = mode.className?'':'';
if (mode.returnBegin) {
result += markup;
mode.buffer = '';
} else if (mode.excludeBegin) {
result += hljs.escape(lexem) + markup;
mode.buffer = '';
} else {
result += markup;
mode.buffer = lexem;
}
modes.push(mode);
relevance += mode.relevance;
}
function processModeInfo(buffer, lexem, end) {
var current_mode = modes[modes.length - 1];
if (end) {
result += processBuffer(current_mode.buffer + buffer, current_mode);
return false;
}
var new_mode = subMode(lexem, current_mode);
if (new_mode) {
result += processBuffer(current_mode.buffer + buffer, current_mode);
startNewMode(new_mode, lexem);
return new_mode.returnBegin;
}
var end_level = endOfMode(modes.length - 1, lexem);
if (end_level) {
var markup = current_mode.className?'':'';
if (current_mode.returnEnd) {
result += processBuffer(current_mode.buffer + buffer, current_mode) + markup;
} else if (current_mode.excludeEnd) {
result += processBuffer(current_mode.buffer + buffer, current_mode) + markup + hljs.escape(lexem);
} else {
result += processBuffer(current_mode.buffer + buffer + lexem, current_mode) + markup;
}
while (end_level > 1) {
markup = modes[modes.length - 2].className?'':'';
result += markup;
end_level--;
modes.length--;
}
var last_ended_mode = modes[modes.length - 1];
modes.length--;
modes[modes.length - 1].buffer = '';
if (last_ended_mode.starts) {
startNewMode(last_ended_mode.starts, '');
}
return current_mode.returnEnd;
}
if (isIllegal(lexem, current_mode))
throw 'Illegal';
}
function langRe(language, value, global) {
return RegExp(
value,
'm' + (language.case_insensitive ? 'i' : '') + (global ? 'g' : '')
);
}
function compileMode(mode, language, is_default) {
if (mode.compiled)
return;
var keywords = []; // used later with beginWithKeyword but filled as a side-effect of keywords compilation
if (mode.keywords) {
var compiled_keywords = {};
function flatten(className, str) {
var group = str.split(' ');
for (var i = 0; i < group.length; i++) {
var pair = group[i].split('|');
compiled_keywords[pair[0]] = [className, pair[1] ? Number(pair[1]) : 1];
keywords.push(pair[0]);
}
}
mode.lexemsRe = langRe(language, mode.lexems || hljs.IDENT_RE, true);
if (typeof mode.keywords == 'string') { // string
flatten('keyword', mode.keywords)
} else {
for (var className in mode.keywords) {
if (!mode.keywords.hasOwnProperty(className))
continue;
flatten(className, mode.keywords[className]);
}
}
mode.keywords = compiled_keywords;
}
if (!is_default) {
if (mode.beginWithKeyword) {
mode.begin = '\\b(' + keywords.join('|') + ')\\s';
}
mode.beginRe = langRe(language, mode.begin ? mode.begin : '\\B|\\b');
if (!mode.end && !mode.endsWithParent)
mode.end = '\\B|\\b';
if (mode.end)
mode.endRe = langRe(language, mode.end);
}
if (mode.illegal)
mode.illegalRe = langRe(language, mode.illegal);
if (mode.relevance === undefined)
mode.relevance = 1;
if (!mode.contains) {
mode.contains = [];
}
// compiled flag is set before compiling submodes to avoid self-recursion
// (see lisp where quoted_list contains quoted_list)
mode.compiled = true;
for (var i = 0; i < mode.contains.length; i++) {
if (mode.contains[i] == 'self') {
mode.contains[i] = mode;
}
compileMode(mode.contains[i], language, false);
}
if (mode.starts) {
compileMode(mode.starts, language, false);
}
}
var language = hljs.LANGUAGES[language_name];
var modes = [language.defaultMode];
var relevance = 0;
var keyword_count = 0;
var result = '';
compileMode(language.defaultMode, language, true);
try {
var mode_info, index = 0;
language.defaultMode.buffer = '';
do {
mode_info = eatModeChunk(value, index);
var return_lexem = processModeInfo(mode_info[0], mode_info[1], mode_info[2]);
index += mode_info[0].length;
if (!return_lexem) {
index += mode_info[1].length;
}
} while (!mode_info[2]);
if(modes.length > 2 || (modes.length == 2 && !modes[1].endsWithParent))
throw 'Illegal';
return {
language: language_name,
relevance: relevance,
keyword_count: keyword_count,
value: result
};
} catch (e) {
if (e == 'Illegal') {
return {
language: language_name,
relevance: 0,
keyword_count: 0,
value: hljs.escape(value)
};
} else {
throw e;
}
}
}
hljs.LANGUAGES = {};
// Common regexps
hljs.IDENT_RE = '[a-zA-Z][a-zA-Z0-9_]*';
hljs.UNDERSCORE_IDENT_RE = '[a-zA-Z_][a-zA-Z0-9_]*';
hljs.NUMBER_RE = '\\b\\d+(\\.\\d+)?';
hljs.C_NUMBER_RE = '\\b(0[xX][a-fA-F0-9]+|(\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)'; // 0x..., 0..., decimal, float
hljs.BINARY_NUMBER_RE = '\\b(0b[01]+)'; // 0b...
hljs.RE_STARTERS_RE = '!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|\\.|-|-=|/|/=|:|;|<|<<|<<=|<=|=|==|===|>|>=|>>|>>=|>>>|>>>=|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~';
hljs.EOF_RE = '(?![\\s\\S])';
// Common modes
hljs.BACKSLASH_ESCAPE = {
begin: '\\\\.', relevance: 0
};
hljs.APOS_STRING_MODE = {
className: 'string',
begin: '\'', end: '\'',
illegal: '\\n',
contains: [hljs.BACKSLASH_ESCAPE],
relevance: 0
};
hljs.QUOTE_STRING_MODE = {
className: 'string',
begin: '"', end: '"',
illegal: '\\n',
contains: [hljs.BACKSLASH_ESCAPE],
relevance: 0
};
hljs.C_LINE_COMMENT_MODE = {
className: 'comment',
begin: '//', end: '$'
};
hljs.C_BLOCK_COMMENT_MODE = {
className: 'comment',
begin: '/\\*', end: '\\*/'
};
hljs.HASH_COMMENT_MODE = {
className: 'comment',
begin: '#', end: '$'
};
hljs.NUMBER_MODE = {
className: 'number',
begin: hljs.NUMBER_RE,
relevance: 0
};
hljs.C_NUMBER_MODE = {
className: 'number',
begin: hljs.C_NUMBER_RE,
relevance: 0
};
hljs.BINARY_NUMBER_MODE = {
className: 'number',
begin: hljs.BINARY_NUMBER_RE,
relevance: 0
};
// Utility functions
hljs.escape = function(value) {
return value.replace(/&/gm, '&').replace(/|\\?)',
contains: STRINGS.concat([
hljs.HASH_COMMENT_MODE,
hljs.inherit(FUNC_CLASS_PROTO, {className: 'function', keywords: 'def'}),
hljs.inherit(FUNC_CLASS_PROTO, {className: 'class', keywords: 'class'}),
hljs.C_NUMBER_MODE,
{
className: 'decorator',
begin: '@', end: '$'
}
])
}
};
}();
/*
Language: Python profile
Description: Python profiler results
Author: Brian Beck
*/
hljs.LANGUAGES.profile = {
defaultMode: {
contains: [
hljs.C_NUMBER_MODE,
{
className: 'builtin',
begin: '{', end: '}$',
excludeBegin: true, excludeEnd: true,
contains: [hljs.APOS_STRING_MODE, hljs.QUOTE_STRING_MODE],
relevance: 0
},
{
className: 'filename',
begin: '[a-zA-Z_][\\da-zA-Z_]+\\.[\\da-zA-Z_]{1,3}', end: ':',
excludeEnd: true
},
{
className: 'header',
begin: '(ncalls|tottime|cumtime)', end: '$',
keywords: 'ncalls tottime|10 cumtime|10 filename',
relevance: 10
},
{
className: 'summary',
begin: 'function calls', end: '$',
contains: [hljs.C_NUMBER_MODE],
relevance: 10
},
hljs.APOS_STRING_MODE,
hljs.QUOTE_STRING_MODE,
{
className: 'function',
begin: '\\(', end: '\\)$',
contains: [{
className: 'title',
begin: hljs.UNDERSCORE_IDENT_RE,
relevance: 0
}],
relevance: 0
}
]
}
};
/*
Language: Ruby
Author: Anton Kovalyov
Contributors: Peter Leonov , Vasily Polovnyov , Loren Segal
*/
hljs.LANGUAGES.ruby = function(){
var RUBY_IDENT_RE = '[a-zA-Z_][a-zA-Z0-9_]*(\\!|\\?)?';
var RUBY_METHOD_RE = '[a-zA-Z_]\\w*[!?=]?|[-+~]\\@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?';
var RUBY_KEYWORDS =
'and false then defined module in return redo if BEGIN retry end for true self when ' +
'next until do begin unless END rescue nil else break undef not super class case ' +
'require yield alias while ensure elsif or def';
var YARDOCTAG = {
className: 'yardoctag',
begin: '@[A-Za-z]+'
};
var COMMENTS = [
{
className: 'comment',
begin: '#', end: '$',
contains: [YARDOCTAG]
},
{
className: 'comment',
begin: '^\\=begin', end: '^\\=end',
contains: [YARDOCTAG],
relevance: 10
},
{
className: 'comment',
begin: '^__END__', end: '\\n$'
}
];
var SUBST = {
className: 'subst',
begin: '#\\{', end: '}',
lexems: RUBY_IDENT_RE,
keywords: RUBY_KEYWORDS
};
var STR_CONTAINS = [hljs.BACKSLASH_ESCAPE, SUBST];
var STRINGS = [
{
className: 'string',
begin: '\'', end: '\'',
contains: STR_CONTAINS,
relevance: 0
},
{
className: 'string',
begin: '"', end: '"',
contains: STR_CONTAINS,
relevance: 0
},
{
className: 'string',
begin: '%[qw]?\\(', end: '\\)',
contains: STR_CONTAINS,
relevance: 10
},
{
className: 'string',
begin: '%[qw]?\\[', end: '\\]',
contains: STR_CONTAINS,
relevance: 10
},
{
className: 'string',
begin: '%[qw]?{', end: '}',
contains: STR_CONTAINS,
relevance: 10
},
{
className: 'string',
begin: '%[qw]?<', end: '>',
contains: STR_CONTAINS,
relevance: 10
},
{
className: 'string',
begin: '%[qw]?/', end: '/',
contains: STR_CONTAINS,
relevance: 10
},
{
className: 'string',
begin: '%[qw]?%', end: '%',
contains: STR_CONTAINS,
relevance: 10
},
{
className: 'string',
begin: '%[qw]?-', end: '-',
contains: STR_CONTAINS,
relevance: 10
},
{
className: 'string',
begin: '%[qw]?\\|', end: '\\|',
contains: STR_CONTAINS,
relevance: 10
}
];
var FUNCTION = {
className: 'function',
begin: '\\bdef\\s+', end: ' |$|;',
lexems: RUBY_IDENT_RE,
keywords: RUBY_KEYWORDS,
contains: [
{
className: 'title',
begin: RUBY_METHOD_RE,
lexems: RUBY_IDENT_RE,
keywords: RUBY_KEYWORDS
},
{
className: 'params',
begin: '\\(', end: '\\)',
lexems: RUBY_IDENT_RE,
keywords: RUBY_KEYWORDS
}
].concat(COMMENTS)
};
var IDENTIFIER = {
className: 'identifier',
begin: RUBY_IDENT_RE,
lexems: RUBY_IDENT_RE,
keywords: RUBY_KEYWORDS,
relevance: 0
};
var RUBY_DEFAULT_CONTAINS = COMMENTS.concat(STRINGS.concat([
{
className: 'class',
beginWithKeyword: true, end: '$|;',
keywords: 'class module',
contains: [
{
className: 'title',
begin: '[A-Za-z_]\\w*(::\\w+)*(\\?|\\!)?',
relevance: 0
},
{
className: 'inheritance',
begin: '<\\s*',
contains: [{
className: 'parent',
begin: '(' + hljs.IDENT_RE + '::)?' + hljs.IDENT_RE
}]
}
].concat(COMMENTS)
},
FUNCTION,
{
className: 'constant',
begin: '(::)?([A-Z]\\w*(::)?)+',
relevance: 0
},
{
className: 'symbol',
begin: ':',
contains: STRINGS.concat([IDENTIFIER]),
relevance: 0
},
{
className: 'number',
begin: '(\\b0[0-7_]+)|(\\b0x[0-9a-fA-F_]+)|(\\b[1-9][0-9_]*(\\.[0-9_]+)?)|[0_]\\b',
relevance: 0
},
{
className: 'number',
begin: '\\?\\w'
},
{
className: 'variable',
begin: '(\\$\\W)|((\\$|\\@\\@?)(\\w+))'
},
IDENTIFIER,
{ // regexp container
begin: '(' + hljs.RE_STARTERS_RE + ')\\s*',
contains: COMMENTS.concat([
{
className: 'regexp',
begin: '/', end: '/[a-z]*',
illegal: '\\n',
contains: [hljs.BACKSLASH_ESCAPE]
}
]),
relevance: 0
}
]));
SUBST.contains = RUBY_DEFAULT_CONTAINS;
FUNCTION.contains[1].contains = RUBY_DEFAULT_CONTAINS;
return {
defaultMode: {
lexems: RUBY_IDENT_RE,
keywords: RUBY_KEYWORDS,
contains: RUBY_DEFAULT_CONTAINS
}
};
}();
/*
Language: Perl
Author: Peter Leonov
*/
hljs.LANGUAGES.perl = function(){
var PERL_KEYWORDS = 'getpwent getservent quotemeta msgrcv scalar kill dbmclose undef lc ' +
'ma syswrite tr send umask sysopen shmwrite vec qx utime local oct semctl localtime ' +
'readpipe do return format read sprintf dbmopen pop getpgrp not getpwnam rewinddir qq' +
'fileno qw endprotoent wait sethostent bless s|0 opendir continue each sleep endgrent ' +
'shutdown dump chomp connect getsockname die socketpair close flock exists index shmget' +
'sub for endpwent redo lstat msgctl setpgrp abs exit select print ref gethostbyaddr ' +
'unshift fcntl syscall goto getnetbyaddr join gmtime symlink semget splice x|0 ' +
'getpeername recv log setsockopt cos last reverse gethostbyname getgrnam study formline ' +
'endhostent times chop length gethostent getnetent pack getprotoent getservbyname rand ' +
'mkdir pos chmod y|0 substr endnetent printf next open msgsnd readdir use unlink ' +
'getsockopt getpriority rindex wantarray hex system getservbyport endservent int chr ' +
'untie rmdir prototype tell listen fork shmread ucfirst setprotoent else sysseek link ' +
'getgrgid shmctl waitpid unpack getnetbyname reset chdir grep split require caller ' +
'lcfirst until warn while values shift telldir getpwuid my getprotobynumber delete and ' +
'sort uc defined srand accept package seekdir getprotobyname semop our rename seek if q|0 ' +
'chroot sysread setpwent no crypt getc chown sqrt write setnetent setpriority foreach ' +
'tie sin msgget map stat getlogin unless elsif truncate exec keys glob tied closedir' +
'ioctl socket readlink eval xor readline binmode setservent eof ord bind alarm pipe ' +
'atan2 getgrent exp time push setgrent gt lt or ne m|0';
var SUBST = {
className: 'subst',
begin: '[$@]\\{', end: '\\}',
keywords: PERL_KEYWORDS,
relevance: 10
};
var VAR1 = {
className: 'variable',
begin: '\\$\\d'
};
var VAR2 = {
className: 'variable',
begin: '[\\$\\%\\@\\*](\\^\\w\\b|#\\w+(\\:\\:\\w+)*|[^\\s\\w{]|{\\w+}|\\w+(\\:\\:\\w*)*)'
};
var STRING_CONTAINS = [hljs.BACKSLASH_ESCAPE, SUBST, VAR1, VAR2];
var METHOD = {
begin: '->',
contains: [
{begin: hljs.IDENT_RE},
{begin: '{', end: '}'}
]
};
var COMMENT = {
className: 'comment',
begin: '^(__END__|__DATA__)', end: '\\n$',
relevance: 5
}
var PERL_DEFAULT_CONTAINS = [
VAR1, VAR2,
hljs.HASH_COMMENT_MODE,
COMMENT,
{
className: 'comment',
begin: '^\\=\\w', end: '\\=cut', endsWithParent: true
},
METHOD,
{
className: 'string',
begin: 'q[qwxr]?\\s*\\(', end: '\\)',
contains: STRING_CONTAINS,
relevance: 5
},
{
className: 'string',
begin: 'q[qwxr]?\\s*\\[', end: '\\]',
contains: STRING_CONTAINS,
relevance: 5
},
{
className: 'string',
begin: 'q[qwxr]?\\s*\\{', end: '\\}',
contains: STRING_CONTAINS,
relevance: 5
},
{
className: 'string',
begin: 'q[qwxr]?\\s*\\|', end: '\\|',
contains: STRING_CONTAINS,
relevance: 5
},
{
className: 'string',
begin: 'q[qwxr]?\\s*\\<', end: '\\>',
contains: STRING_CONTAINS,
relevance: 5
},
{
className: 'string',
begin: 'qw\\s+q', end: 'q',
contains: STRING_CONTAINS,
relevance: 5
},
{
className: 'string',
begin: '\'', end: '\'',
contains: [hljs.BACKSLASH_ESCAPE],
relevance: 0
},
{
className: 'string',
begin: '"', end: '"',
contains: STRING_CONTAINS,
relevance: 0
},
{
className: 'string',
begin: '`', end: '`',
contains: [hljs.BACKSLASH_ESCAPE]
},
{
className: 'string',
begin: '{\\w+}',
relevance: 0
},
{
className: 'string',
begin: '\-?\\w+\\s*\\=\\>',
relevance: 0
},
{
className: 'number',
begin: '(\\b0[0-7_]+)|(\\b0x[0-9a-fA-F_]+)|(\\b[1-9][0-9_]*(\\.[0-9_]+)?)|[0_]\\b',
relevance: 0
},
{ // regexp container
begin: '(' + hljs.RE_STARTERS_RE + '|\\b(split|return|print|reverse|grep)\\b)\\s*',
keywords: 'split return print reverse grep',
relevance: 0,
contains: [
hljs.HASH_COMMENT_MODE,
COMMENT,
{
className: 'regexp',
begin: '(s|tr|y)/(\\\\.|[^/])*/(\\\\.|[^/])*/[a-z]*',
relevance: 10
},
{
className: 'regexp',
begin: '(m|qr)?/', end: '/[a-z]*',
contains: [hljs.BACKSLASH_ESCAPE],
relevance: 0 // allows empty "//" which is a common comment delimiter in other languages
}
]
},
{
className: 'sub',
beginWithKeyword: true, end: '(\\s*\\(.*?\\))?[;{]',
keywords: 'sub',
relevance: 5
},
{
className: 'operator',
begin: '-\\w\\b',
relevance: 0
}
];
SUBST.contains = PERL_DEFAULT_CONTAINS;
METHOD.contains[1].contains = PERL_DEFAULT_CONTAINS;
return {
defaultMode: {
keywords: PERL_KEYWORDS,
contains: PERL_DEFAULT_CONTAINS
}
};
}();
/*
Language: PHP
Author: Victor Karamzin
Contributors: Evgeny Stepanischev , Ivan Sagalaev
*/
hljs.LANGUAGES.php = function() {
var VARIABLE = {
className: 'variable', begin: '\\$+[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
};
var STRINGS = [
hljs.inherit(hljs.APOS_STRING_MODE, {illegal: null}),
hljs.inherit(hljs.QUOTE_STRING_MODE, {illegal: null}),
{
className: 'string',
begin: 'b"', end: '"',
contains: [hljs.BACKSLASH_ESCAPE]
},
{
className: 'string',
begin: 'b\'', end: '\'',
contains: [hljs.BACKSLASH_ESCAPE]
}
];
var NUMBERS = [
hljs.C_NUMBER_MODE, // 0x..., 0..., decimal, float
hljs.BINARY_NUMBER_MODE // 0b...
];
var TITLE = {
className: 'title', begin: hljs.UNDERSCORE_IDENT_RE
};
return {
case_insensitive: true,
defaultMode: {
keywords:
'and include_once list abstract global private echo interface as static endswitch ' +
'array null if endwhile or const for endforeach self var while isset public ' +
'protected exit foreach throw elseif include __FILE__ empty require_once do xor ' +
'return implements parent clone use __CLASS__ __LINE__ else break print eval new ' +
'catch __METHOD__ case exception php_user_filter default die require __FUNCTION__ ' +
'enddeclare final try this switch continue endfor endif declare unset true false ' +
'namespace trait goto instanceof insteadof __DIR__ __NAMESPACE__ __halt_compiler',
contains: [
hljs.C_LINE_COMMENT_MODE,
hljs.HASH_COMMENT_MODE,
{
className: 'comment',
begin: '/\\*', end: '\\*/',
contains: [{
className: 'phpdoc',
begin: '\\s@[A-Za-z]+'
}]
},
{
className: 'comment',
excludeBegin: true,
begin: '__halt_compiler.+?;', endsWithParent: true
},
{
className: 'string',
begin: '<<<[\'"]?\\w+[\'"]?$', end: '^\\w+;',
contains: [hljs.BACKSLASH_ESCAPE]
},
{
className: 'preprocessor',
begin: '<\\?php',
relevance: 10
},
{
className: 'preprocessor',
begin: '\\?>'
},
VARIABLE,
{
className: 'function',
beginWithKeyword: true, end: '{',
keywords: 'function',
illegal: '\\$',
contains: [
TITLE,
{
className: 'params',
begin: '\\(', end: '\\)',
contains: [
'self',
VARIABLE,
hljs.C_BLOCK_COMMENT_MODE
].concat(STRINGS).concat(NUMBERS)
}
]
},
{
className: 'class',
beginWithKeyword: true, end: '{',
keywords: 'class',
illegal: '[:\\(\\$]',
contains: [
{
beginWithKeyword: true, endsWithParent: true,
keywords: 'extends',
contains: [TITLE]
},
TITLE
]
},
{
begin: '=>' // No markup, just a relevance booster
}
].concat(STRINGS).concat(NUMBERS)
}
};
}();
/*
Language: Scala
Author: Jan Berkel
*/
hljs.LANGUAGES.scala = function() {
var ANNOTATION = {
className: 'annotation', begin: '@[A-Za-z]+'
};
var STRING = {
className: 'string',
begin: 'u?r?"""', end: '"""',
relevance: 10
};
return {
defaultMode: {
keywords:
'type yield lazy override def with val var false true sealed abstract private trait ' +
'object null if for while throw finally protected extends import final return else ' +
'break new catch super class case package default try this match continue throws',
contains: [
{
className: 'javadoc',
begin: '/\\*\\*', end: '\\*/',
contains: [{
className: 'javadoctag',
begin: '@[A-Za-z]+'
}],
relevance: 10
},
hljs.C_LINE_COMMENT_MODE, hljs.C_BLOCK_COMMENT_MODE,
hljs.APOS_STRING_MODE, hljs.QUOTE_STRING_MODE, STRING,
{
className: 'class',
begin: '((case )?class |object |trait )', end: '({|$)', // beginWithKeyword won't work because a single "case" shouldn't start this mode
illegal: ':',
keywords: 'case class trait object',
contains: [
{
beginWithKeyword: true,
keywords: 'extends with',
relevance: 10
},
{
className: 'title',
begin: hljs.UNDERSCORE_IDENT_RE
},
{
className: 'params',
begin: '\\(', end: '\\)',
contains: [
hljs.APOS_STRING_MODE, hljs.QUOTE_STRING_MODE, STRING,
ANNOTATION
]
}
]
},
hljs.C_NUMBER_MODE,
ANNOTATION
]
}
};
}();
/*
Language: Go
Author: Stephan Kountso aka StepLg
Contributors: Evgeny Stepanischev
Description: Google go language (golang). For info about language see http://golang.org/
*/
hljs.LANGUAGES.go = function(){
var GO_KEYWORDS = {
keyword:
'break default func interface select case map struct chan else goto package switch ' +
'const fallthrough if range type continue for import return var go defer',
constant:
'true false iota nil',
typename:
'bool byte complex64 complex128 float32 float64 int8 int16 int32 int64 string uint8 ' +
'uint16 uint32 uint64 int uint uintptr rune',
built_in:
'append cap close complex copy imag len make new panic print println real recover delete'
};
return {
defaultMode: {
keywords: GO_KEYWORDS,
illegal: '',
contains: [
hljs.C_LINE_COMMENT_MODE,
hljs.C_BLOCK_COMMENT_MODE,
hljs.QUOTE_STRING_MODE,
{
className: 'string',
begin: '\'', end: '[^\\\\]\'',
relevance: 0
},
{
className: 'string',
begin: '`', end: '`'
},
{
className: 'number',
begin: '[^a-zA-Z_0-9](\\-|\\+)?\\d+(\\.\\d+|\\/\\d+)?((d|e|f|l|s)(\\+|\\-)?\\d+)?',
relevance: 0
},
hljs.C_NUMBER_MODE
]
}
};
}();
/*
Language: HTML, XML
*/
hljs.LANGUAGES.xml = function(){
var XML_IDENT_RE = '[A-Za-z0-9\\._:-]+';
var TAG_INTERNALS = {
endsWithParent: true,
contains: [
{
className: 'attribute',
begin: XML_IDENT_RE,
relevance: 0
},
{
begin: '="', returnBegin: true, end: '"',
contains: [{
className: 'value',
begin: '"', endsWithParent: true
}]
},
{
begin: '=\'', returnBegin: true, end: '\'',
contains: [{
className: 'value',
begin: '\'', endsWithParent: true
}]
},
{
begin: '=',
contains: [{
className: 'value',
begin: '[^\\s/>]+'
}]
}
]
};
return {
case_insensitive: true,
defaultMode: {
contains: [
{
className: 'pi',
begin: '<\\?', end: '\\?>',
relevance: 10
},
{
className: 'doctype',
begin: '',
relevance: 10,
contains: [{begin: '\\[', end: '\\]'}]
},
{
className: 'comment',
begin: '',
relevance: 10
},
{
className: 'cdata',
begin: '<\\!\\[CDATA\\[', end: '\\]\\]>',
relevance: 10
},
{
className: 'tag',
/*
The lookahead pattern (?=...) ensures that 'begin' only matches
'', returnEnd: true,
subLanguage: 'css'
}
},
{
className: 'tag',
// See the comment in the