404 Not found
+ +The requested URL doesn’t exist. Remove any “www.” at the beginning of the URL.
+From abc0de079b895af1b705894eb2b63596e3e37274 Mon Sep 17 00:00:00 2001
From: David Luevano Alvarado The requested URL doesn’t exist. Remove any “www.” at the beginning of the URL.
- Welcome to the official pyssg website. This is as of now serving as a testing ground when I'm making changes to it.
-
- Get the RSS feed: https://pyssg.xyz/rss.xml
- Welcome to the official pyssg website. This is as of now serving as a testing ground when I’m making changes to it. Get the RSS feed: https://pyssg.xyz/rss.xml404 Not found
+
+ pyssg
-
Get the RSS feed: https://pyssg.xyz/rss.xml
]]>
`
+ };
+
+ const VuePlugin = {
+ install(Vue) {
+ Vue.component('highlightjs', Component);
+ }
+ };
+
+ return { Component, VuePlugin };
+ }
+
+ /*
+ Syntax highlighting with language autodetection.
+ https://highlightjs.org/
+ */
+
+ const escape$1 = escapeHTML;
+ const inherit$1 = inherit;
+
+ const { nodeStream: nodeStream$1, mergeStreams: mergeStreams$1 } = utils;
+ const NO_MATCH = Symbol("nomatch");
+
+ /**
+ * @param {any} hljs - object that is extended (legacy)
+ * @returns {HLJSApi}
+ */
+ const HLJS = function(hljs) {
+ // Convenience variables for build-in objects
+ /** @type {unknown[]} */
+ const ArrayProto = [];
+
+ // Global internal variables used within the highlight.js library.
+ /** @type {Record blocks on a page
+ *
+ * @type {Function & {called?: boolean}}
+ */
+ const initHighlighting = () => {
+ if (initHighlighting.called) return;
+ initHighlighting.called = true;
+
+ const blocks = document.querySelectorAll('pre code');
+ ArrayProto.forEach.call(blocks, highlightBlock);
+ };
+
+ // Higlights all when DOMContentLoaded fires
+ function initHighlightingOnLoad() {
+ // @ts-ignore
+ window.addEventListener('DOMContentLoaded', initHighlighting, false);
+ }
+
+ /**
+ * Register a language grammar module
+ *
+ * @param {string} languageName
+ * @param {LanguageFn} languageDefinition
+ */
+ function registerLanguage(languageName, languageDefinition) {
+ let lang = null;
+ try {
+ lang = languageDefinition(hljs);
+ } catch (error) {
+ console.error("Language definition for '{}' could not be registered.".replace("{}", languageName));
+ // hard or soft error
+ if (!SAFE_MODE) { throw error; } else { console.error(error); }
+ // languages that have serious errors are replaced with essentially a
+ // "plaintext" stand-in so that the code blocks will still get normal
+ // css classes applied to them - and one bad language won't break the
+ // entire highlighter
+ lang = PLAINTEXT_LANGUAGE;
+ }
+ // give it a temporary name if it doesn't have one in the meta-data
+ if (!lang.name) lang.name = languageName;
+ languages[languageName] = lang;
+ lang.rawDefinition = languageDefinition.bind(null, hljs);
+
+ if (lang.aliases) {
+ registerAliases(lang.aliases, { languageName });
+ }
+ }
+
+ /**
+ * @returns {string[]} List of language internal names
+ */
+ function listLanguages() {
+ return Object.keys(languages);
+ }
+
+ /**
+ intended usage: When one language truly requires another
+
+ Unlike `getLanguage`, this will throw when the requested language
+ is not available.
+
+ @param {string} name - name of the language to fetch/require
+ @returns {Language | never}
+ */
+ function requireLanguage(name) {
+ console.warn("requireLanguage is deprecated and will be removed entirely in the future.");
+ console.warn("Please see https://github.com/highlightjs/highlight.js/pull/2844");
+
+ const lang = getLanguage(name);
+ if (lang) { return lang; }
+
+ const err = new Error('The \'{}\' language is required, but not loaded.'.replace('{}', name));
+ throw err;
+ }
+
+ /**
+ * @param {string} name - name of the language to retrieve
+ * @returns {Language | undefined}
+ */
+ function getLanguage(name) {
+ name = (name || '').toLowerCase();
+ return languages[name] || languages[aliases[name]];
+ }
+
+ /**
+ *
+ * @param {string|string[]} aliasList - single alias or list of aliases
+ * @param {{languageName: string}} opts
+ */
+ function registerAliases(aliasList, { languageName }) {
+ if (typeof aliasList === 'string') {
+ aliasList = [aliasList];
+ }
+ aliasList.forEach(alias => { aliases[alias] = languageName; });
+ }
+
+ /**
+ * Determines if a given language has auto-detection enabled
+ * @param {string} name - name of the language
+ */
+ function autoDetection(name) {
+ const lang = getLanguage(name);
+ return lang && !lang.disableAutodetect;
+ }
+
+ /**
+ * @param {HLJSPlugin} plugin
+ */
+ function addPlugin(plugin) {
+ plugins.push(plugin);
+ }
+
+ /**
+ *
+ * @param {PluginEvent} event
+ * @param {any} args
+ */
+ function fire(event, args) {
+ const cb = event;
+ plugins.forEach(function(plugin) {
+ if (plugin[cb]) {
+ plugin[cb](args);
+ }
+ });
+ }
+
+ /**
+ Note: fixMarkup is deprecated and will be removed entirely in v11
+
+ @param {string} arg
+ @returns {string}
+ */
+ function deprecateFixMarkup(arg) {
+ console.warn("fixMarkup is deprecated and will be removed entirely in v11.0");
+ console.warn("Please see https://github.com/highlightjs/highlight.js/issues/2534");
+
+ return fixMarkup(arg);
+ }
+
+ /* Interface definition */
+ Object.assign(hljs, {
+ highlight,
+ highlightAuto,
+ fixMarkup: deprecateFixMarkup,
+ highlightBlock,
+ configure,
+ initHighlighting,
+ initHighlightingOnLoad,
+ registerLanguage,
+ listLanguages,
+ getLanguage,
+ registerAliases,
+ requireLanguage,
+ autoDetection,
+ inherit: inherit$1,
+ addPlugin,
+ // plugins for frameworks
+ vuePlugin: BuildVuePlugin(hljs).VuePlugin
+ });
+
+ hljs.debugMode = function() { SAFE_MODE = false; };
+ hljs.safeMode = function() { SAFE_MODE = true; };
+ hljs.versionString = version;
+
+ for (const key in MODES) {
+ // @ts-ignore
+ if (typeof MODES[key] === "object") {
+ // @ts-ignore
+ deepFreezeEs6(MODES[key]);
+ }
+ }
+
+ // merge all the modes/regexs into our main object
+ Object.assign(hljs, MODES);
+
+ return hljs;
+ };
+
+ // export an "instance" of the highlighter
+ var highlight = HLJS({});
+
+ return highlight;
+
+}());
+if (typeof exports === 'object' && typeof module !== 'undefined') { module.exports = hljs; }
+
+hljs.registerLanguage('apache', function () {
+ 'use strict';
+
+ /*
+ Language: Apache config
+ Author: Ruslan Keba
+ Contributors: Ivan Sagalaev
+ Website: https://httpd.apache.org
+ Description: language definition for Apache configuration files (httpd.conf & .htaccess)
+ Category: common, config
+ */
+
+ /** @type LanguageFn */
+ function apache(hljs) {
+ const NUMBER_REF = {
+ className: 'number',
+ begin: '[\\$%]\\d+'
+ };
+ const NUMBER = {
+ className: 'number',
+ begin: '\\d+'
+ };
+ const IP_ADDRESS = {
+ className: "number",
+ begin: '\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}(:\\d{1,5})?'
+ };
+ const PORT_NUMBER = {
+ className: "number",
+ begin: ":\\d{1,5}"
+ };
+ return {
+ name: 'Apache config',
+ aliases: ['apacheconf'],
+ case_insensitive: true,
+ contains: [
+ hljs.HASH_COMMENT_MODE,
+ {
+ className: 'section',
+ begin: '?',
+ end: '>',
+ contains: [
+ IP_ADDRESS,
+ PORT_NUMBER,
+ // low relevance prevents us from claming XML/HTML where this rule would
+ // match strings inside of XML tags
+ hljs.inherit(hljs.QUOTE_STRING_MODE, { relevance: 0 })
+ ]
+ },
+ {
+ className: 'attribute',
+ begin: /\w+/,
+ relevance: 0,
+ // keywords aren’t needed for highlighting per se, they only boost relevance
+ // for a very generally defined mode (starts with a word, ends with line-end
+ keywords: { nomarkup:
+ 'order deny allow setenv rewriterule rewriteengine rewritecond documentroot ' +
+ 'sethandler errordocument loadmodule options header listen serverroot ' +
+ 'servername' },
+ starts: {
+ end: /$/,
+ relevance: 0,
+ keywords: { literal: 'on off all deny allow' },
+ contains: [
+ {
+ className: 'meta',
+ begin: '\\s\\[',
+ end: '\\]$'
+ },
+ {
+ className: 'variable',
+ begin: '[\\$%]\\{',
+ end: '\\}',
+ contains: ['self',
+ NUMBER_REF]
+ },
+ IP_ADDRESS,
+ NUMBER,
+ hljs.QUOTE_STRING_MODE
+ ]
+ }
+ }
+ ],
+ illegal: /\S/
+ };
+ }
+
+ return apache;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('bash', function () {
+ 'use strict';
+
+ /**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function source(re) {
+ if (!re) return null;
+ if (typeof re === "string") return re;
+
+ return re.source;
+ }
+
+ /**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+ function concat(...args) {
+ const joined = args.map((x) => source(x)).join("");
+ return joined;
+ }
+
+ /*
+ Language: Bash
+ Author: vah
+ Contributrors: Benjamin Pannell
+ Website: https://www.gnu.org/software/bash/
+ Category: common
+ */
+
+ /** @type LanguageFn */
+ function bash(hljs) {
+ const VAR = {};
+ const BRACED_VAR = {
+ begin: /\$\{/,
+ end:/\}/,
+ contains: [
+ "self",
+ {
+ begin: /:-/,
+ contains: [ VAR ]
+ } // default values
+ ]
+ };
+ Object.assign(VAR,{
+ className: 'variable',
+ variants: [
+ {begin: concat(/\$[\w\d#@][\w\d_]*/,
+ // negative look-ahead tries to avoid matching patterns that are not
+ // Perl at all like $ident$, @ident@, etc.
+ `(?![\\w\\d])(?![$])`) },
+ BRACED_VAR
+ ]
+ });
+
+ const SUBST = {
+ className: 'subst',
+ begin: /\$\(/, end: /\)/,
+ contains: [hljs.BACKSLASH_ESCAPE]
+ };
+ const HERE_DOC = {
+ begin: /<<-?\s*(?=\w+)/,
+ starts: {
+ contains: [
+ hljs.END_SAME_AS_BEGIN({
+ begin: /(\w+)/,
+ end: /(\w+)/,
+ className: 'string'
+ })
+ ]
+ }
+ };
+ const QUOTE_STRING = {
+ className: 'string',
+ begin: /"/, end: /"/,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ VAR,
+ SUBST
+ ]
+ };
+ SUBST.contains.push(QUOTE_STRING);
+ const ESCAPED_QUOTE = {
+ className: '',
+ begin: /\\"/
+
+ };
+ const APOS_STRING = {
+ className: 'string',
+ begin: /'/, end: /'/
+ };
+ const ARITHMETIC = {
+ begin: /\$\(\(/,
+ end: /\)\)/,
+ contains: [
+ { begin: /\d+#[0-9a-f]+/, className: "number" },
+ hljs.NUMBER_MODE,
+ VAR
+ ]
+ };
+ const SH_LIKE_SHELLS = [
+ "fish",
+ "bash",
+ "zsh",
+ "sh",
+ "csh",
+ "ksh",
+ "tcsh",
+ "dash",
+ "scsh",
+ ];
+ const KNOWN_SHEBANG = hljs.SHEBANG({
+ binary: `(${SH_LIKE_SHELLS.join("|")})`,
+ relevance: 10
+ });
+ const FUNCTION = {
+ className: 'function',
+ begin: /\w[\w\d_]*\s*\(\s*\)\s*\{/,
+ returnBegin: true,
+ contains: [hljs.inherit(hljs.TITLE_MODE, {begin: /\w[\w\d_]*/})],
+ relevance: 0
+ };
+
+ return {
+ name: 'Bash',
+ aliases: ['sh', 'zsh'],
+ keywords: {
+ $pattern: /\b[a-z._-]+\b/,
+ keyword:
+ 'if then else elif fi for while in do done case esac function',
+ literal:
+ 'true false',
+ built_in:
+ // Shell built-ins
+ // http://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
+ 'break cd continue eval exec exit export getopts hash pwd readonly return shift test times ' +
+ 'trap umask unset ' +
+ // Bash built-ins
+ 'alias bind builtin caller command declare echo enable help let local logout mapfile printf ' +
+ 'read readarray source type typeset ulimit unalias ' +
+ // Shell modifiers
+ 'set shopt ' +
+ // Zsh built-ins
+ 'autoload bg bindkey bye cap chdir clone comparguments compcall compctl compdescribe compfiles ' +
+ 'compgroups compquote comptags comptry compvalues dirs disable disown echotc echoti emulate ' +
+ 'fc fg float functions getcap getln history integer jobs kill limit log noglob popd print ' +
+ 'pushd pushln rehash sched setcap setopt stat suspend ttyctl unfunction unhash unlimit ' +
+ 'unsetopt vared wait whence where which zcompile zformat zftp zle zmodload zparseopts zprof ' +
+ 'zpty zregexparse zsocket zstyle ztcp'
+ },
+ contains: [
+ KNOWN_SHEBANG, // to catch known shells and boost relevancy
+ hljs.SHEBANG(), // to catch unknown shells but still highlight the shebang
+ FUNCTION,
+ ARITHMETIC,
+ hljs.HASH_COMMENT_MODE,
+ HERE_DOC,
+ QUOTE_STRING,
+ ESCAPED_QUOTE,
+ APOS_STRING,
+ VAR
+ ]
+ };
+ }
+
+ return bash;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('c', function () {
+ 'use strict';
+
+ /*
+ Language: C-like foundation grammar for C/C++ grammars
+ Author: Ivan Sagalaev
+ Contributors: Evgeny Stepanischev , Zaven Muradyan , Roel Deckers , Sam Wu , Jordi Petit , Pieter Vantorre , Google Inc. (David Benjamin)
+ */
+
+ /* In the future the intention is to split out the C/C++ grammars distinctly
+ since they are separate languages. They will likely share a common foundation
+ though, and this file sets the groundwork for that - so that we get the breaking
+ change in v10 and don't have to change the requirements again later.
+
+ See: https://github.com/highlightjs/highlight.js/issues/2146
+ */
+
+ /** @type LanguageFn */
+ function cLike(hljs) {
+ function optional(s) {
+ return '(?:' + s + ')?';
+ }
+ // added for historic reasons because `hljs.C_LINE_COMMENT_MODE` does
+ // not include such support nor can we be sure all the grammars depending
+ // on it would desire this behavior
+ var C_LINE_COMMENT_MODE = hljs.COMMENT('//', '$', {
+ contains: [{begin: /\\\n/}]
+ });
+ var DECLTYPE_AUTO_RE = 'decltype\\(auto\\)';
+ var NAMESPACE_RE = '[a-zA-Z_]\\w*::';
+ var TEMPLATE_ARGUMENT_RE = '<.*?>';
+ var FUNCTION_TYPE_RE = '(' +
+ DECLTYPE_AUTO_RE + '|' +
+ optional(NAMESPACE_RE) +'[a-zA-Z_]\\w*' + optional(TEMPLATE_ARGUMENT_RE) +
+ ')';
+ var CPP_PRIMITIVE_TYPES = {
+ className: 'keyword',
+ begin: '\\b[a-z\\d_]*_t\\b'
+ };
+
+ // https://en.cppreference.com/w/cpp/language/escape
+ // \\ \x \xFF \u2837 \u00323747 \374
+ var CHARACTER_ESCAPES = '\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)';
+ var STRINGS = {
+ className: 'string',
+ variants: [
+ {
+ begin: '(u8?|U|L)?"', end: '"',
+ illegal: '\\n',
+ contains: [hljs.BACKSLASH_ESCAPE]
+ },
+ {
+ begin: '(u8?|U|L)?\'(' + CHARACTER_ESCAPES + "|.)", end: '\'',
+ illegal: '.'
+ },
+ hljs.END_SAME_AS_BEGIN({
+ begin: /(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,
+ end: /\)([^()\\ ]{0,16})"/,
+ })
+ ]
+ };
+
+ var NUMBERS = {
+ className: 'number',
+ variants: [
+ { begin: '\\b(0b[01\']+)' },
+ { begin: '(-?)\\b([\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)(u|U|l|L|ul|UL|f|F|b|B)' },
+ { begin: '(-?)(\\b0[xX][a-fA-F0-9\']+|(\\b[\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)([eE][-+]?[\\d\']+)?)' }
+ ],
+ relevance: 0
+ };
+
+ var PREPROCESSOR = {
+ className: 'meta',
+ begin: /#\s*[a-z]+\b/, end: /$/,
+ keywords: {
+ 'meta-keyword':
+ 'if else elif endif define undef warning error line ' +
+ 'pragma _Pragma ifdef ifndef include'
+ },
+ contains: [
+ {
+ begin: /\\\n/, relevance: 0
+ },
+ hljs.inherit(STRINGS, {className: 'meta-string'}),
+ {
+ className: 'meta-string',
+ begin: /<.*?>/, end: /$/,
+ illegal: '\\n',
+ },
+ C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ };
+
+ var TITLE_MODE = {
+ className: 'title',
+ begin: optional(NAMESPACE_RE) + hljs.IDENT_RE,
+ relevance: 0
+ };
+
+ var FUNCTION_TITLE = optional(NAMESPACE_RE) + hljs.IDENT_RE + '\\s*\\(';
+
+ var CPP_KEYWORDS = {
+ keyword: 'int float while private char char8_t char16_t char32_t catch import module export virtual operator sizeof ' +
+ 'dynamic_cast|10 typedef const_cast|10 const for static_cast|10 union namespace ' +
+ 'unsigned long volatile static protected bool template mutable if public friend ' +
+ 'do goto auto void enum else break extern using asm case typeid wchar_t ' +
+ 'short reinterpret_cast|10 default double register explicit signed typename try this ' +
+ 'switch continue inline delete alignas alignof constexpr consteval constinit decltype ' +
+ 'concept co_await co_return co_yield requires ' +
+ 'noexcept static_assert thread_local restrict final override ' +
+ 'atomic_bool atomic_char atomic_schar ' +
+ 'atomic_uchar atomic_short atomic_ushort atomic_int atomic_uint atomic_long atomic_ulong atomic_llong ' +
+ 'atomic_ullong new throw return ' +
+ 'and and_eq bitand bitor compl not not_eq or or_eq xor xor_eq',
+ built_in: 'std string wstring cin cout cerr clog stdin stdout stderr stringstream istringstream ostringstream ' +
+ 'auto_ptr deque list queue stack vector map set pair bitset multiset multimap unordered_set ' +
+ 'unordered_map unordered_multiset unordered_multimap priority_queue make_pair array shared_ptr abort terminate abs acos ' +
+ 'asin atan2 atan calloc ceil cosh cos exit exp fabs floor fmod fprintf fputs free frexp ' +
+ 'fscanf future isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper ' +
+ 'isxdigit tolower toupper labs ldexp log10 log malloc realloc memchr memcmp memcpy memset modf pow ' +
+ 'printf putchar puts scanf sinh sin snprintf sprintf sqrt sscanf strcat strchr strcmp ' +
+ 'strcpy strcspn strlen strncat strncmp strncpy strpbrk strrchr strspn strstr tanh tan ' +
+ 'vfprintf vprintf vsprintf endl initializer_list unique_ptr _Bool complex _Complex imaginary _Imaginary',
+ literal: 'true false nullptr NULL'
+ };
+
+ var EXPRESSION_CONTAINS = [
+ PREPROCESSOR,
+ CPP_PRIMITIVE_TYPES,
+ C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ NUMBERS,
+ STRINGS
+ ];
+
+ var EXPRESSION_CONTEXT = {
+ // This mode covers expression context where we can't expect a function
+ // definition and shouldn't highlight anything that looks like one:
+ // `return some()`, `else if()`, `(x*sum(1, 2))`
+ variants: [
+ {begin: /=/, end: /;/},
+ {begin: /\(/, end: /\)/},
+ {beginKeywords: 'new throw return else', end: /;/}
+ ],
+ keywords: CPP_KEYWORDS,
+ contains: EXPRESSION_CONTAINS.concat([
+ {
+ begin: /\(/, end: /\)/,
+ keywords: CPP_KEYWORDS,
+ contains: EXPRESSION_CONTAINS.concat(['self']),
+ relevance: 0
+ }
+ ]),
+ relevance: 0
+ };
+
+ var FUNCTION_DECLARATION = {
+ className: 'function',
+ begin: '(' + FUNCTION_TYPE_RE + '[\\*&\\s]+)+' + FUNCTION_TITLE,
+ returnBegin: true, end: /[{;=]/,
+ excludeEnd: true,
+ keywords: CPP_KEYWORDS,
+ illegal: /[^\w\s\*&:<>]/,
+ contains: [
+
+ { // to prevent it from being confused as the function title
+ begin: DECLTYPE_AUTO_RE,
+ keywords: CPP_KEYWORDS,
+ relevance: 0,
+ },
+ {
+ begin: FUNCTION_TITLE, returnBegin: true,
+ contains: [TITLE_MODE],
+ relevance: 0
+ },
+ {
+ className: 'params',
+ begin: /\(/, end: /\)/,
+ keywords: CPP_KEYWORDS,
+ relevance: 0,
+ contains: [
+ C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ STRINGS,
+ NUMBERS,
+ CPP_PRIMITIVE_TYPES,
+ // Count matching parentheses.
+ {
+ begin: /\(/, end: /\)/,
+ keywords: CPP_KEYWORDS,
+ relevance: 0,
+ contains: [
+ 'self',
+ C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ STRINGS,
+ NUMBERS,
+ CPP_PRIMITIVE_TYPES
+ ]
+ }
+ ]
+ },
+ CPP_PRIMITIVE_TYPES,
+ C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ PREPROCESSOR
+ ]
+ };
+
+ return {
+ aliases: ['c', 'cc', 'h', 'c++', 'h++', 'hpp', 'hh', 'hxx', 'cxx'],
+ keywords: CPP_KEYWORDS,
+ // the base c-like language will NEVER be auto-detected, rather the
+ // derivitives: c, c++, arduino turn auto-detect back on for themselves
+ disableAutodetect: true,
+ illegal: '',
+ contains: [].concat(
+ EXPRESSION_CONTEXT,
+ FUNCTION_DECLARATION,
+ EXPRESSION_CONTAINS,
+ [
+ PREPROCESSOR,
+ { // containers: ie, `vector rooms (9);`
+ begin: '\\b(deque|list|queue|priority_queue|pair|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array)\\s*<', end: '>',
+ keywords: CPP_KEYWORDS,
+ contains: ['self', CPP_PRIMITIVE_TYPES]
+ },
+ {
+ begin: hljs.IDENT_RE + '::',
+ keywords: CPP_KEYWORDS
+ },
+ {
+ className: 'class',
+ beginKeywords: 'enum class struct union', end: /[{;:<>=]/,
+ contains: [
+ { beginKeywords: "final class struct" },
+ hljs.TITLE_MODE
+ ]
+ }
+ ]),
+ exports: {
+ preprocessor: PREPROCESSOR,
+ strings: STRINGS,
+ keywords: CPP_KEYWORDS
+ }
+ };
+ }
+
+ /*
+ Language: C
+ Category: common, system
+ Website: https://en.wikipedia.org/wiki/C_(programming_language)
+ */
+
+ /** @type LanguageFn */
+ function c(hljs) {
+ const lang = cLike(hljs);
+ // Until C is actually different than C++ there is no reason to auto-detect C
+ // as it's own language since it would just fail auto-detect testing or
+ // simply match with C++.
+ //
+ // See further comments in c-like.js.
+
+ // lang.disableAutodetect = false;
+ lang.name = 'C';
+ lang.aliases = ['c', 'h'];
+ return lang;
+ }
+
+ return c;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('coffeescript', function () {
+ 'use strict';
+
+ const KEYWORDS = [
+ "as", // for exports
+ "in",
+ "of",
+ "if",
+ "for",
+ "while",
+ "finally",
+ "var",
+ "new",
+ "function",
+ "do",
+ "return",
+ "void",
+ "else",
+ "break",
+ "catch",
+ "instanceof",
+ "with",
+ "throw",
+ "case",
+ "default",
+ "try",
+ "switch",
+ "continue",
+ "typeof",
+ "delete",
+ "let",
+ "yield",
+ "const",
+ "class",
+ // JS handles these with a special rule
+ // "get",
+ // "set",
+ "debugger",
+ "async",
+ "await",
+ "static",
+ "import",
+ "from",
+ "export",
+ "extends"
+ ];
+ const LITERALS = [
+ "true",
+ "false",
+ "null",
+ "undefined",
+ "NaN",
+ "Infinity"
+ ];
+
+ const TYPES = [
+ "Intl",
+ "DataView",
+ "Number",
+ "Math",
+ "Date",
+ "String",
+ "RegExp",
+ "Object",
+ "Function",
+ "Boolean",
+ "Error",
+ "Symbol",
+ "Set",
+ "Map",
+ "WeakSet",
+ "WeakMap",
+ "Proxy",
+ "Reflect",
+ "JSON",
+ "Promise",
+ "Float64Array",
+ "Int16Array",
+ "Int32Array",
+ "Int8Array",
+ "Uint16Array",
+ "Uint32Array",
+ "Float32Array",
+ "Array",
+ "Uint8Array",
+ "Uint8ClampedArray",
+ "ArrayBuffer"
+ ];
+
+ const ERROR_TYPES = [
+ "EvalError",
+ "InternalError",
+ "RangeError",
+ "ReferenceError",
+ "SyntaxError",
+ "TypeError",
+ "URIError"
+ ];
+
+ const BUILT_IN_GLOBALS = [
+ "setInterval",
+ "setTimeout",
+ "clearInterval",
+ "clearTimeout",
+
+ "require",
+ "exports",
+
+ "eval",
+ "isFinite",
+ "isNaN",
+ "parseFloat",
+ "parseInt",
+ "decodeURI",
+ "decodeURIComponent",
+ "encodeURI",
+ "encodeURIComponent",
+ "escape",
+ "unescape"
+ ];
+
+ const BUILT_IN_VARIABLES = [
+ "arguments",
+ "this",
+ "super",
+ "console",
+ "window",
+ "document",
+ "localStorage",
+ "module",
+ "global" // Node.js
+ ];
+
+ const BUILT_INS = [].concat(
+ BUILT_IN_GLOBALS,
+ BUILT_IN_VARIABLES,
+ TYPES,
+ ERROR_TYPES
+ );
+
+ /*
+ Language: CoffeeScript
+ Author: Dmytrii Nagirniak
+ Contributors: Oleg Efimov , Cédric Néhémie
+ Description: CoffeeScript is a programming language that transcompiles to JavaScript. For info about language see http://coffeescript.org/
+ Category: common, scripting
+ Website: https://coffeescript.org
+ */
+
+ /** @type LanguageFn */
+ function coffeescript(hljs) {
+ const COFFEE_BUILT_INS = [
+ 'npm',
+ 'print'
+ ];
+ const COFFEE_LITERALS = [
+ 'yes',
+ 'no',
+ 'on',
+ 'off'
+ ];
+ const COFFEE_KEYWORDS = [
+ 'then',
+ 'unless',
+ 'until',
+ 'loop',
+ 'by',
+ 'when',
+ 'and',
+ 'or',
+ 'is',
+ 'isnt',
+ 'not'
+ ];
+ const NOT_VALID_KEYWORDS = [
+ "var",
+ "const",
+ "let",
+ "function",
+ "static"
+ ];
+ const excluding = (list) =>
+ (kw) => !list.includes(kw);
+ const KEYWORDS$1 = {
+ keyword: KEYWORDS.concat(COFFEE_KEYWORDS).filter(excluding(NOT_VALID_KEYWORDS)).join(" "),
+ literal: LITERALS.concat(COFFEE_LITERALS).join(" "),
+ built_in: BUILT_INS.concat(COFFEE_BUILT_INS).join(" ")
+ };
+ const JS_IDENT_RE = '[A-Za-z$_][0-9A-Za-z$_]*';
+ const SUBST = {
+ className: 'subst',
+ begin: /#\{/,
+ end: /\}/,
+ keywords: KEYWORDS$1
+ };
+ const EXPRESSIONS = [
+ hljs.BINARY_NUMBER_MODE,
+ hljs.inherit(hljs.C_NUMBER_MODE, {
+ starts: {
+ end: '(\\s*/)?',
+ relevance: 0
+ }
+ }), // a number tries to eat the following slash to prevent treating it as a regexp
+ {
+ className: 'string',
+ variants: [
+ {
+ begin: /'''/,
+ end: /'''/,
+ contains: [hljs.BACKSLASH_ESCAPE]
+ },
+ {
+ begin: /'/,
+ end: /'/,
+ contains: [hljs.BACKSLASH_ESCAPE]
+ },
+ {
+ begin: /"""/,
+ end: /"""/,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ SUBST
+ ]
+ },
+ {
+ begin: /"/,
+ end: /"/,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ SUBST
+ ]
+ }
+ ]
+ },
+ {
+ className: 'regexp',
+ variants: [
+ {
+ begin: '///',
+ end: '///',
+ contains: [
+ SUBST,
+ hljs.HASH_COMMENT_MODE
+ ]
+ },
+ {
+ begin: '//[gim]{0,3}(?=\\W)',
+ relevance: 0
+ },
+ {
+ // regex can't start with space to parse x / 2 / 3 as two divisions
+ // regex can't start with *, and it supports an "illegal" in the main mode
+ begin: /\/(?![ *]).*?(?![\\]).\/[gim]{0,3}(?=\W)/
+ }
+ ]
+ },
+ {
+ begin: '@' + JS_IDENT_RE // relevance booster
+ },
+ {
+ subLanguage: 'javascript',
+ excludeBegin: true,
+ excludeEnd: true,
+ variants: [
+ {
+ begin: '```',
+ end: '```'
+ },
+ {
+ begin: '`',
+ end: '`'
+ }
+ ]
+ }
+ ];
+ SUBST.contains = EXPRESSIONS;
+
+ const TITLE = hljs.inherit(hljs.TITLE_MODE, {
+ begin: JS_IDENT_RE
+ });
+ const PARAMS_RE = '(\\(.*\\))?\\s*\\B[-=]>';
+ const PARAMS = {
+ className: 'params',
+ begin: '\\([^\\(]',
+ returnBegin: true,
+ /* We need another contained nameless mode to not have every nested
+ pair of parens to be called "params" */
+ contains: [{
+ begin: /\(/,
+ end: /\)/,
+ keywords: KEYWORDS$1,
+ contains: ['self'].concat(EXPRESSIONS)
+ }]
+ };
+
+ return {
+ name: 'CoffeeScript',
+ aliases: [
+ 'coffee',
+ 'cson',
+ 'iced'
+ ],
+ keywords: KEYWORDS$1,
+ illegal: /\/\*/,
+ contains: EXPRESSIONS.concat([
+ hljs.COMMENT('###', '###'),
+ hljs.HASH_COMMENT_MODE,
+ {
+ className: 'function',
+ begin: '^\\s*' + JS_IDENT_RE + '\\s*=\\s*' + PARAMS_RE,
+ end: '[-=]>',
+ returnBegin: true,
+ contains: [
+ TITLE,
+ PARAMS
+ ]
+ },
+ {
+ // anonymous function start
+ begin: /[:\(,=]\s*/,
+ relevance: 0,
+ contains: [{
+ className: 'function',
+ begin: PARAMS_RE,
+ end: '[-=]>',
+ returnBegin: true,
+ contains: [PARAMS]
+ }]
+ },
+ {
+ className: 'class',
+ beginKeywords: 'class',
+ end: '$',
+ illegal: /[:="\[\]]/,
+ contains: [
+ {
+ beginKeywords: 'extends',
+ endsWithParent: true,
+ illegal: /[:="\[\]]/,
+ contains: [TITLE]
+ },
+ TITLE
+ ]
+ },
+ {
+ begin: JS_IDENT_RE + ':',
+ end: ':',
+ returnBegin: true,
+ returnEnd: true,
+ relevance: 0
+ }
+ ])
+ };
+ }
+
+ return coffeescript;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('cpp', function () {
+ 'use strict';
+
+ /*
+ Language: C-like foundation grammar for C/C++ grammars
+ Author: Ivan Sagalaev
+ Contributors: Evgeny Stepanischev , Zaven Muradyan , Roel Deckers , Sam Wu , Jordi Petit , Pieter Vantorre , Google Inc. (David Benjamin)
+ */
+
+ /* In the future the intention is to split out the C/C++ grammars distinctly
+ since they are separate languages. They will likely share a common foundation
+ though, and this file sets the groundwork for that - so that we get the breaking
+ change in v10 and don't have to change the requirements again later.
+
+ See: https://github.com/highlightjs/highlight.js/issues/2146
+ */
+
+ /** @type LanguageFn */
+ function cLike(hljs) {
+ function optional(s) {
+ return '(?:' + s + ')?';
+ }
+ // added for historic reasons because `hljs.C_LINE_COMMENT_MODE` does
+ // not include such support nor can we be sure all the grammars depending
+ // on it would desire this behavior
+ var C_LINE_COMMENT_MODE = hljs.COMMENT('//', '$', {
+ contains: [{begin: /\\\n/}]
+ });
+ var DECLTYPE_AUTO_RE = 'decltype\\(auto\\)';
+ var NAMESPACE_RE = '[a-zA-Z_]\\w*::';
+ var TEMPLATE_ARGUMENT_RE = '<.*?>';
+ var FUNCTION_TYPE_RE = '(' +
+ DECLTYPE_AUTO_RE + '|' +
+ optional(NAMESPACE_RE) +'[a-zA-Z_]\\w*' + optional(TEMPLATE_ARGUMENT_RE) +
+ ')';
+ var CPP_PRIMITIVE_TYPES = {
+ className: 'keyword',
+ begin: '\\b[a-z\\d_]*_t\\b'
+ };
+
+ // https://en.cppreference.com/w/cpp/language/escape
+ // \\ \x \xFF \u2837 \u00323747 \374
+ var CHARACTER_ESCAPES = '\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)';
+ var STRINGS = {
+ className: 'string',
+ variants: [
+ {
+ begin: '(u8?|U|L)?"', end: '"',
+ illegal: '\\n',
+ contains: [hljs.BACKSLASH_ESCAPE]
+ },
+ {
+ begin: '(u8?|U|L)?\'(' + CHARACTER_ESCAPES + "|.)", end: '\'',
+ illegal: '.'
+ },
+ hljs.END_SAME_AS_BEGIN({
+ begin: /(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,
+ end: /\)([^()\\ ]{0,16})"/,
+ })
+ ]
+ };
+
+ var NUMBERS = {
+ className: 'number',
+ variants: [
+ { begin: '\\b(0b[01\']+)' },
+ { begin: '(-?)\\b([\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)(u|U|l|L|ul|UL|f|F|b|B)' },
+ { begin: '(-?)(\\b0[xX][a-fA-F0-9\']+|(\\b[\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)([eE][-+]?[\\d\']+)?)' }
+ ],
+ relevance: 0
+ };
+
+ var PREPROCESSOR = {
+ className: 'meta',
+ begin: /#\s*[a-z]+\b/, end: /$/,
+ keywords: {
+ 'meta-keyword':
+ 'if else elif endif define undef warning error line ' +
+ 'pragma _Pragma ifdef ifndef include'
+ },
+ contains: [
+ {
+ begin: /\\\n/, relevance: 0
+ },
+ hljs.inherit(STRINGS, {className: 'meta-string'}),
+ {
+ className: 'meta-string',
+ begin: /<.*?>/, end: /$/,
+ illegal: '\\n',
+ },
+ C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ };
+
+ var TITLE_MODE = {
+ className: 'title',
+ begin: optional(NAMESPACE_RE) + hljs.IDENT_RE,
+ relevance: 0
+ };
+
+ var FUNCTION_TITLE = optional(NAMESPACE_RE) + hljs.IDENT_RE + '\\s*\\(';
+
+ var CPP_KEYWORDS = {
+ keyword: 'int float while private char char8_t char16_t char32_t catch import module export virtual operator sizeof ' +
+ 'dynamic_cast|10 typedef const_cast|10 const for static_cast|10 union namespace ' +
+ 'unsigned long volatile static protected bool template mutable if public friend ' +
+ 'do goto auto void enum else break extern using asm case typeid wchar_t ' +
+ 'short reinterpret_cast|10 default double register explicit signed typename try this ' +
+ 'switch continue inline delete alignas alignof constexpr consteval constinit decltype ' +
+ 'concept co_await co_return co_yield requires ' +
+ 'noexcept static_assert thread_local restrict final override ' +
+ 'atomic_bool atomic_char atomic_schar ' +
+ 'atomic_uchar atomic_short atomic_ushort atomic_int atomic_uint atomic_long atomic_ulong atomic_llong ' +
+ 'atomic_ullong new throw return ' +
+ 'and and_eq bitand bitor compl not not_eq or or_eq xor xor_eq',
+ built_in: 'std string wstring cin cout cerr clog stdin stdout stderr stringstream istringstream ostringstream ' +
+ 'auto_ptr deque list queue stack vector map set pair bitset multiset multimap unordered_set ' +
+ 'unordered_map unordered_multiset unordered_multimap priority_queue make_pair array shared_ptr abort terminate abs acos ' +
+ 'asin atan2 atan calloc ceil cosh cos exit exp fabs floor fmod fprintf fputs free frexp ' +
+ 'fscanf future isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper ' +
+ 'isxdigit tolower toupper labs ldexp log10 log malloc realloc memchr memcmp memcpy memset modf pow ' +
+ 'printf putchar puts scanf sinh sin snprintf sprintf sqrt sscanf strcat strchr strcmp ' +
+ 'strcpy strcspn strlen strncat strncmp strncpy strpbrk strrchr strspn strstr tanh tan ' +
+ 'vfprintf vprintf vsprintf endl initializer_list unique_ptr _Bool complex _Complex imaginary _Imaginary',
+ literal: 'true false nullptr NULL'
+ };
+
+ var EXPRESSION_CONTAINS = [
+ PREPROCESSOR,
+ CPP_PRIMITIVE_TYPES,
+ C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ NUMBERS,
+ STRINGS
+ ];
+
+ var EXPRESSION_CONTEXT = {
+ // This mode covers expression context where we can't expect a function
+ // definition and shouldn't highlight anything that looks like one:
+ // `return some()`, `else if()`, `(x*sum(1, 2))`
+ variants: [
+ {begin: /=/, end: /;/},
+ {begin: /\(/, end: /\)/},
+ {beginKeywords: 'new throw return else', end: /;/}
+ ],
+ keywords: CPP_KEYWORDS,
+ contains: EXPRESSION_CONTAINS.concat([
+ {
+ begin: /\(/, end: /\)/,
+ keywords: CPP_KEYWORDS,
+ contains: EXPRESSION_CONTAINS.concat(['self']),
+ relevance: 0
+ }
+ ]),
+ relevance: 0
+ };
+
+ var FUNCTION_DECLARATION = {
+ className: 'function',
+ begin: '(' + FUNCTION_TYPE_RE + '[\\*&\\s]+)+' + FUNCTION_TITLE,
+ returnBegin: true, end: /[{;=]/,
+ excludeEnd: true,
+ keywords: CPP_KEYWORDS,
+ illegal: /[^\w\s\*&:<>]/,
+ contains: [
+
+ { // to prevent it from being confused as the function title
+ begin: DECLTYPE_AUTO_RE,
+ keywords: CPP_KEYWORDS,
+ relevance: 0,
+ },
+ {
+ begin: FUNCTION_TITLE, returnBegin: true,
+ contains: [TITLE_MODE],
+ relevance: 0
+ },
+ {
+ className: 'params',
+ begin: /\(/, end: /\)/,
+ keywords: CPP_KEYWORDS,
+ relevance: 0,
+ contains: [
+ C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ STRINGS,
+ NUMBERS,
+ CPP_PRIMITIVE_TYPES,
+ // Count matching parentheses.
+ {
+ begin: /\(/, end: /\)/,
+ keywords: CPP_KEYWORDS,
+ relevance: 0,
+ contains: [
+ 'self',
+ C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ STRINGS,
+ NUMBERS,
+ CPP_PRIMITIVE_TYPES
+ ]
+ }
+ ]
+ },
+ CPP_PRIMITIVE_TYPES,
+ C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ PREPROCESSOR
+ ]
+ };
+
+ return {
+ aliases: ['c', 'cc', 'h', 'c++', 'h++', 'hpp', 'hh', 'hxx', 'cxx'],
+ keywords: CPP_KEYWORDS,
+ // the base c-like language will NEVER be auto-detected, rather the
+ // derivitives: c, c++, arduino turn auto-detect back on for themselves
+ disableAutodetect: true,
+ illegal: '',
+ contains: [].concat(
+ EXPRESSION_CONTEXT,
+ FUNCTION_DECLARATION,
+ EXPRESSION_CONTAINS,
+ [
+ PREPROCESSOR,
+ { // containers: ie, `vector rooms (9);`
+ begin: '\\b(deque|list|queue|priority_queue|pair|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array)\\s*<', end: '>',
+ keywords: CPP_KEYWORDS,
+ contains: ['self', CPP_PRIMITIVE_TYPES]
+ },
+ {
+ begin: hljs.IDENT_RE + '::',
+ keywords: CPP_KEYWORDS
+ },
+ {
+ className: 'class',
+ beginKeywords: 'enum class struct union', end: /[{;:<>=]/,
+ contains: [
+ { beginKeywords: "final class struct" },
+ hljs.TITLE_MODE
+ ]
+ }
+ ]),
+ exports: {
+ preprocessor: PREPROCESSOR,
+ strings: STRINGS,
+ keywords: CPP_KEYWORDS
+ }
+ };
+ }
+
+ /*
+ Language: C++
+ Category: common, system
+ Website: https://isocpp.org
+ */
+
+ /** @type LanguageFn */
+ function cpp(hljs) {
+ const lang = cLike(hljs);
+ // return auto-detection back on
+ lang.disableAutodetect = false;
+ lang.name = 'C++';
+ lang.aliases = ['cc', 'c++', 'h++', 'hpp', 'hh', 'hxx', 'cxx'];
+ return lang;
+ }
+
+ return cpp;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('csharp', function () {
+ 'use strict';
+
+ /*
+ Language: C#
+ Author: Jason Diamond
+ Contributor: Nicolas LLOBERA , Pieter Vantorre , David Pine
+ Website: https://docs.microsoft.com/en-us/dotnet/csharp/
+ Category: common
+ */
+
+ /** @type LanguageFn */
+ function csharp(hljs) {
+ var BUILT_IN_KEYWORDS = [
+ 'bool',
+ 'byte',
+ 'char',
+ 'decimal',
+ 'delegate',
+ 'double',
+ 'dynamic',
+ 'enum',
+ 'float',
+ 'int',
+ 'long',
+ 'nint',
+ 'nuint',
+ 'object',
+ 'sbyte',
+ 'short',
+ 'string',
+ 'ulong',
+ 'unit',
+ 'ushort'
+ ];
+ var FUNCTION_MODIFIERS = [
+ 'public',
+ 'private',
+ 'protected',
+ 'static',
+ 'internal',
+ 'protected',
+ 'abstract',
+ 'async',
+ 'extern',
+ 'override',
+ 'unsafe',
+ 'virtual',
+ 'new',
+ 'sealed',
+ 'partial'
+ ];
+ var LITERAL_KEYWORDS = [
+ 'default',
+ 'false',
+ 'null',
+ 'true'
+ ];
+ var NORMAL_KEYWORDS = [
+ 'abstract',
+ 'as',
+ 'base',
+ 'break',
+ 'case',
+ 'class',
+ 'const',
+ 'continue',
+ 'do',
+ 'else',
+ 'event',
+ 'explicit',
+ 'extern',
+ 'finally',
+ 'fixed',
+ 'for',
+ 'foreach',
+ 'goto',
+ 'if',
+ 'implicit',
+ 'in',
+ 'interface',
+ 'internal',
+ 'is',
+ 'lock',
+ 'namespace',
+ 'new',
+ 'operator',
+ 'out',
+ 'override',
+ 'params',
+ 'private',
+ 'protected',
+ 'public',
+ 'readonly',
+ 'record',
+ 'ref',
+ 'return',
+ 'sealed',
+ 'sizeof',
+ 'stackalloc',
+ 'static',
+ 'struct',
+ 'switch',
+ 'this',
+ 'throw',
+ 'try',
+ 'typeof',
+ 'unchecked',
+ 'unsafe',
+ 'using',
+ 'virtual',
+ 'void',
+ 'volatile',
+ 'while'
+ ];
+ var CONTEXTUAL_KEYWORDS = [
+ 'add',
+ 'alias',
+ 'and',
+ 'ascending',
+ 'async',
+ 'await',
+ 'by',
+ 'descending',
+ 'equals',
+ 'from',
+ 'get',
+ 'global',
+ 'group',
+ 'init',
+ 'into',
+ 'join',
+ 'let',
+ 'nameof',
+ 'not',
+ 'notnull',
+ 'on',
+ 'or',
+ 'orderby',
+ 'partial',
+ 'remove',
+ 'select',
+ 'set',
+ 'unmanaged',
+ 'value|0',
+ 'var',
+ 'when',
+ 'where',
+ 'with',
+ 'yield'
+ ];
+
+ var KEYWORDS = {
+ keyword: NORMAL_KEYWORDS.concat(CONTEXTUAL_KEYWORDS).join(' '),
+ built_in: BUILT_IN_KEYWORDS.join(' '),
+ literal: LITERAL_KEYWORDS.join(' ')
+ };
+ var TITLE_MODE = hljs.inherit(hljs.TITLE_MODE, {begin: '[a-zA-Z](\\.?\\w)*'});
+ var NUMBERS = {
+ className: 'number',
+ variants: [
+ { begin: '\\b(0b[01\']+)' },
+ { begin: '(-?)\\b([\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)(u|U|l|L|ul|UL|f|F|b|B)' },
+ { begin: '(-?)(\\b0[xX][a-fA-F0-9\']+|(\\b[\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)([eE][-+]?[\\d\']+)?)' }
+ ],
+ relevance: 0
+ };
+ var VERBATIM_STRING = {
+ className: 'string',
+ begin: '@"', end: '"',
+ contains: [{begin: '""'}]
+ };
+ var VERBATIM_STRING_NO_LF = hljs.inherit(VERBATIM_STRING, {illegal: /\n/});
+ var SUBST = {
+ className: 'subst',
+ begin: /\{/, end: /\}/,
+ keywords: KEYWORDS
+ };
+ var SUBST_NO_LF = hljs.inherit(SUBST, {illegal: /\n/});
+ var INTERPOLATED_STRING = {
+ className: 'string',
+ begin: /\$"/, end: '"',
+ illegal: /\n/,
+ contains: [{begin: /\{\{/}, {begin: /\}\}/}, hljs.BACKSLASH_ESCAPE, SUBST_NO_LF]
+ };
+ var INTERPOLATED_VERBATIM_STRING = {
+ className: 'string',
+ begin: /\$@"/, end: '"',
+ contains: [{begin: /\{\{/}, {begin: /\}\}/}, {begin: '""'}, SUBST]
+ };
+ var INTERPOLATED_VERBATIM_STRING_NO_LF = hljs.inherit(INTERPOLATED_VERBATIM_STRING, {
+ illegal: /\n/,
+ contains: [{begin: /\{\{/}, {begin: /\}\}/}, {begin: '""'}, SUBST_NO_LF]
+ });
+ SUBST.contains = [
+ INTERPOLATED_VERBATIM_STRING,
+ INTERPOLATED_STRING,
+ VERBATIM_STRING,
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ NUMBERS,
+ hljs.C_BLOCK_COMMENT_MODE
+ ];
+ SUBST_NO_LF.contains = [
+ INTERPOLATED_VERBATIM_STRING_NO_LF,
+ INTERPOLATED_STRING,
+ VERBATIM_STRING_NO_LF,
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ NUMBERS,
+ hljs.inherit(hljs.C_BLOCK_COMMENT_MODE, {illegal: /\n/})
+ ];
+ var STRING = {
+ variants: [
+ INTERPOLATED_VERBATIM_STRING,
+ INTERPOLATED_STRING,
+ VERBATIM_STRING,
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE
+ ]
+ };
+
+ var GENERIC_MODIFIER = {
+ begin: "<",
+ end: ">",
+ contains: [
+ { beginKeywords: "in out"},
+ TITLE_MODE
+ ]
+ };
+ var TYPE_IDENT_RE = hljs.IDENT_RE + '(<' + hljs.IDENT_RE + '(\\s*,\\s*' + hljs.IDENT_RE + ')*>)?(\\[\\])?';
+ var AT_IDENTIFIER = {
+ // prevents expressions like `@class` from incorrect flagging
+ // `class` as a keyword
+ begin: "@" + hljs.IDENT_RE,
+ relevance: 0
+ };
+
+ return {
+ name: 'C#',
+ aliases: ['cs', 'c#'],
+ keywords: KEYWORDS,
+ illegal: /::/,
+ contains: [
+ hljs.COMMENT(
+ '///',
+ '$',
+ {
+ returnBegin: true,
+ contains: [
+ {
+ className: 'doctag',
+ variants: [
+ {
+ begin: '///', relevance: 0
+ },
+ {
+ begin: ''
+ },
+ {
+ begin: '?', end: '>'
+ }
+ ]
+ }
+ ]
+ }
+ ),
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ {
+ className: 'meta',
+ begin: '#', end: '$',
+ keywords: {
+ 'meta-keyword': 'if else elif endif define undef warning error line region endregion pragma checksum'
+ }
+ },
+ STRING,
+ NUMBERS,
+ {
+ beginKeywords: 'class interface',
+ relevance: 0,
+ end: /[{;=]/,
+ illegal: /[^\s:,]/,
+ contains: [
+ { beginKeywords: "where class" },
+ TITLE_MODE,
+ GENERIC_MODIFIER,
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ },
+ {
+ beginKeywords: 'namespace',
+ relevance: 0,
+ end: /[{;=]/,
+ illegal: /[^\s:]/,
+ contains: [
+ TITLE_MODE,
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ },
+ {
+ beginKeywords: 'record',
+ relevance: 0,
+ end: /[{;=]/,
+ illegal: /[^\s:]/,
+ contains: [
+ TITLE_MODE,
+ GENERIC_MODIFIER,
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ },
+ {
+ // [Attributes("")]
+ className: 'meta',
+ begin: '^\\s*\\[', excludeBegin: true, end: '\\]', excludeEnd: true,
+ contains: [
+ {className: 'meta-string', begin: /"/, end: /"/}
+ ]
+ },
+ {
+ // Expression keywords prevent 'keyword Name(...)' from being
+ // recognized as a function definition
+ beginKeywords: 'new return throw await else',
+ relevance: 0
+ },
+ {
+ className: 'function',
+ begin: '(' + TYPE_IDENT_RE + '\\s+)+' + hljs.IDENT_RE + '\\s*(<.+>)?\\s*\\(', returnBegin: true,
+ end: /\s*[{;=]/, excludeEnd: true,
+ keywords: KEYWORDS,
+ contains: [
+ // prevents these from being highlighted `title`
+ {
+ beginKeywords: FUNCTION_MODIFIERS.join(" "),
+ relevance: 0
+ },
+ {
+ begin: hljs.IDENT_RE + '\\s*(<.+>)?\\s*\\(', returnBegin: true,
+ contains: [
+ hljs.TITLE_MODE,
+ GENERIC_MODIFIER
+ ],
+ relevance: 0
+ },
+ {
+ className: 'params',
+ begin: /\(/, end: /\)/,
+ excludeBegin: true,
+ excludeEnd: true,
+ keywords: KEYWORDS,
+ relevance: 0,
+ contains: [
+ STRING,
+ NUMBERS,
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ },
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ },
+ AT_IDENTIFIER
+ ]
+ };
+ }
+
+ return csharp;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('css', function () {
+ 'use strict';
+
+ /*
+ Language: CSS
+ Category: common, css
+ Website: https://developer.mozilla.org/en-US/docs/Web/CSS
+ */
+
+ /** @type LanguageFn */
+ function css(hljs) {
+ var FUNCTION_LIKE = {
+ begin: /[\w-]+\(/, returnBegin: true,
+ contains: [
+ {
+ className: 'built_in',
+ begin: /[\w-]+/
+ },
+ {
+ begin: /\(/, end: /\)/,
+ contains: [
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ hljs.CSS_NUMBER_MODE,
+ ]
+ }
+ ]
+ };
+ var ATTRIBUTE = {
+ className: 'attribute',
+ begin: /\S/, end: ':', excludeEnd: true,
+ starts: {
+ endsWithParent: true, excludeEnd: true,
+ contains: [
+ FUNCTION_LIKE,
+ hljs.CSS_NUMBER_MODE,
+ hljs.QUOTE_STRING_MODE,
+ hljs.APOS_STRING_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ {
+ className: 'number', begin: '#[0-9A-Fa-f]+'
+ },
+ {
+ className: 'meta', begin: '!important'
+ }
+ ]
+ }
+ };
+ var AT_IDENTIFIER = '@[a-z-]+'; // @font-face
+ var AT_MODIFIERS = "and or not only";
+ var AT_PROPERTY_RE = /@-?\w[\w]*(-\w+)*/; // @-webkit-keyframes
+ var IDENT_RE = '[a-zA-Z-][a-zA-Z0-9_-]*';
+ var RULE = {
+ begin: /([*]\s?)?(?:[A-Z_.\-\\]+|--[a-zA-Z0-9_-]+)\s*(\/\*\*\/)?:/, returnBegin: true, end: ';', endsWithParent: true,
+ contains: [
+ ATTRIBUTE
+ ]
+ };
+
+ return {
+ name: 'CSS',
+ case_insensitive: true,
+ illegal: /[=|'\$]/,
+ contains: [
+ hljs.C_BLOCK_COMMENT_MODE,
+ {
+ className: 'selector-id', begin: /#[A-Za-z0-9_-]+/
+ },
+ {
+ className: 'selector-class', begin: '\\.' + IDENT_RE
+ },
+ {
+ className: 'selector-attr',
+ begin: /\[/, end: /\]/,
+ illegal: '$',
+ contains: [
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ ]
+ },
+ {
+ className: 'selector-pseudo',
+ begin: /:(:)?[a-zA-Z0-9_+()"'.-]+/
+ },
+ // matching these here allows us to treat them more like regular CSS
+ // rules so everything between the {} gets regular rule highlighting,
+ // which is what we want for page and font-face
+ {
+ begin: '@(page|font-face)',
+ lexemes: AT_IDENTIFIER,
+ keywords: '@page @font-face'
+ },
+ {
+ begin: '@', end: '[{;]', // at_rule eating first "{" is a good thing
+ // because it doesn’t let it to be parsed as
+ // a rule set but instead drops parser into
+ // the default mode which is how it should be.
+ illegal: /:/, // break on Less variables @var: ...
+ returnBegin: true,
+ contains: [
+ {
+ className: 'keyword',
+ begin: AT_PROPERTY_RE
+ },
+ {
+ begin: /\s/, endsWithParent: true, excludeEnd: true,
+ relevance: 0,
+ keywords: AT_MODIFIERS,
+ contains: [
+ {
+ begin: /[a-z-]+:/,
+ className:"attribute"
+ },
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ hljs.CSS_NUMBER_MODE
+ ]
+ }
+ ]
+ },
+ {
+ className: 'selector-tag', begin: IDENT_RE,
+ relevance: 0
+ },
+ {
+ begin: /\{/, end: /\}/,
+ illegal: /\S/,
+ contains: [
+ hljs.C_BLOCK_COMMENT_MODE,
+ { begin: /;/ }, // empty ; rule
+ RULE,
+ ]
+ }
+ ]
+ };
+ }
+
+ return css;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('diff', function () {
+ 'use strict';
+
+ /*
+ Language: Diff
+ Description: Unified and context diff
+ Author: Vasily Polovnyov
+ Website: https://www.gnu.org/software/diffutils/
+ Category: common
+ */
+
+ /** @type LanguageFn */
+ function diff(hljs) {
+ return {
+ name: 'Diff',
+ aliases: ['patch'],
+ contains: [
+ {
+ className: 'meta',
+ relevance: 10,
+ variants: [
+ {
+ begin: /^@@ +-\d+,\d+ +\+\d+,\d+ +@@/
+ },
+ {
+ begin: /^\*\*\* +\d+,\d+ +\*\*\*\*$/
+ },
+ {
+ begin: /^--- +\d+,\d+ +----$/
+ }
+ ]
+ },
+ {
+ className: 'comment',
+ variants: [
+ {
+ begin: /Index: /,
+ end: /$/
+ },
+ {
+ begin: /^index/,
+ end: /$/
+ },
+ {
+ begin: /={3,}/,
+ end: /$/
+ },
+ {
+ begin: /^-{3}/,
+ end: /$/
+ },
+ {
+ begin: /^\*{3} /,
+ end: /$/
+ },
+ {
+ begin: /^\+{3}/,
+ end: /$/
+ },
+ {
+ begin: /^\*{15}$/
+ },
+ {
+ begin: /^diff --git/,
+ end: /$/
+ }
+ ]
+ },
+ {
+ className: 'addition',
+ begin: /^\+/,
+ end: /$/
+ },
+ {
+ className: 'deletion',
+ begin: /^-/,
+ end: /$/
+ },
+ {
+ className: 'addition',
+ begin: /^!/,
+ end: /$/
+ }
+ ]
+ };
+ }
+
+ return diff;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('go', function () {
+ 'use strict';
+
+ /*
+ Language: Go
+ Author: Stephan Kountso aka StepLg
+ Contributors: Evgeny Stepanischev
+ Description: Google go language (golang). For info about language
+ Website: http://golang.org/
+ Category: common, system
+ */
+
+ function go(hljs) {
+ const 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 ' +
+ 'bool byte complex64 complex128 float32 float64 int8 int16 int32 int64 string uint8 ' +
+ 'uint16 uint32 uint64 int uint uintptr rune',
+ literal:
+ 'true false iota nil',
+ built_in:
+ 'append cap close complex copy imag len make new panic print println real recover delete'
+ };
+ return {
+ name: 'Go',
+ aliases: ['golang'],
+ keywords: GO_KEYWORDS,
+ illegal: '',
+ contains: [
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ {
+ className: 'string',
+ variants: [
+ hljs.QUOTE_STRING_MODE,
+ hljs.APOS_STRING_MODE,
+ {
+ begin: '`',
+ end: '`'
+ }
+ ]
+ },
+ {
+ className: 'number',
+ variants: [
+ {
+ begin: hljs.C_NUMBER_RE + '[i]',
+ relevance: 1
+ },
+ hljs.C_NUMBER_MODE
+ ]
+ },
+ {
+ begin: /:=/ // relevance booster
+ },
+ {
+ className: 'function',
+ beginKeywords: 'func',
+ end: '\\s*(\\{|$)',
+ excludeEnd: true,
+ contains: [
+ hljs.TITLE_MODE,
+ {
+ className: 'params',
+ begin: /\(/,
+ end: /\)/,
+ keywords: GO_KEYWORDS,
+ illegal: /["']/
+ }
+ ]
+ }
+ ]
+ };
+ }
+
+ return go;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('http', function () {
+ 'use strict';
+
+ /*
+ Language: HTTP
+ Description: HTTP request and response headers with automatic body highlighting
+ Author: Ivan Sagalaev
+ Category: common, protocols
+ Website: https://developer.mozilla.org/en-US/docs/Web/HTTP/Overview
+ */
+
+ function http(hljs) {
+ var VERSION = 'HTTP/[0-9\\.]+';
+ return {
+ name: 'HTTP',
+ aliases: ['https'],
+ illegal: '\\S',
+ contains: [
+ {
+ begin: '^' + VERSION, end: '$',
+ contains: [{className: 'number', begin: '\\b\\d{3}\\b'}]
+ },
+ {
+ begin: '^[A-Z]+ (.*?) ' + VERSION + '$', returnBegin: true, end: '$',
+ contains: [
+ {
+ className: 'string',
+ begin: ' ', end: ' ',
+ excludeBegin: true, excludeEnd: true
+ },
+ {
+ begin: VERSION
+ },
+ {
+ className: 'keyword',
+ begin: '[A-Z]+'
+ }
+ ]
+ },
+ {
+ className: 'attribute',
+ begin: '^\\w', end: ': ', excludeEnd: true,
+ illegal: '\\n|\\s|=',
+ starts: {end: '$', relevance: 0}
+ },
+ {
+ begin: '\\n\\n',
+ starts: {subLanguage: [], endsWithParent: true}
+ }
+ ]
+ };
+ }
+
+ return http;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('ini', function () {
+ 'use strict';
+
+ /**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function source(re) {
+ if (!re) return null;
+ if (typeof re === "string") return re;
+
+ return re.source;
+ }
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function lookahead(re) {
+ return concat('(?=', re, ')');
+ }
+
+ /**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+ function concat(...args) {
+ const joined = args.map((x) => source(x)).join("");
+ return joined;
+ }
+
+ /**
+ * Any of the passed expresssions may match
+ *
+ * Creates a huge this | this | that | that match
+ * @param {(RegExp | string)[] } args
+ * @returns {string}
+ */
+ function either(...args) {
+ const joined = '(' + args.map((x) => source(x)).join("|") + ")";
+ return joined;
+ }
+
+ /*
+ Language: TOML, also INI
+ Description: TOML aims to be a minimal configuration file format that's easy to read due to obvious semantics.
+ Contributors: Guillaume Gomez
+ Category: common, config
+ Website: https://github.com/toml-lang/toml
+ */
+
+ function ini(hljs) {
+ const NUMBERS = {
+ className: 'number',
+ relevance: 0,
+ variants: [
+ {
+ begin: /([+-]+)?[\d]+_[\d_]+/
+ },
+ {
+ begin: hljs.NUMBER_RE
+ }
+ ]
+ };
+ const COMMENTS = hljs.COMMENT();
+ COMMENTS.variants = [
+ {
+ begin: /;/,
+ end: /$/
+ },
+ {
+ begin: /#/,
+ end: /$/
+ }
+ ];
+ const VARIABLES = {
+ className: 'variable',
+ variants: [
+ {
+ begin: /\$[\w\d"][\w\d_]*/
+ },
+ {
+ begin: /\$\{(.*?)\}/
+ }
+ ]
+ };
+ const LITERALS = {
+ className: 'literal',
+ begin: /\bon|off|true|false|yes|no\b/
+ };
+ const STRINGS = {
+ className: "string",
+ contains: [hljs.BACKSLASH_ESCAPE],
+ variants: [
+ {
+ begin: "'''",
+ end: "'''",
+ relevance: 10
+ },
+ {
+ begin: '"""',
+ end: '"""',
+ relevance: 10
+ },
+ {
+ begin: '"',
+ end: '"'
+ },
+ {
+ begin: "'",
+ end: "'"
+ }
+ ]
+ };
+ const ARRAY = {
+ begin: /\[/,
+ end: /\]/,
+ contains: [
+ COMMENTS,
+ LITERALS,
+ VARIABLES,
+ STRINGS,
+ NUMBERS,
+ 'self'
+ ],
+ relevance: 0
+ };
+
+ const BARE_KEY = /[A-Za-z0-9_-]+/;
+ const QUOTED_KEY_DOUBLE_QUOTE = /"(\\"|[^"])*"/;
+ const QUOTED_KEY_SINGLE_QUOTE = /'[^']*'/;
+ const ANY_KEY = either(
+ BARE_KEY, QUOTED_KEY_DOUBLE_QUOTE, QUOTED_KEY_SINGLE_QUOTE
+ );
+ const DOTTED_KEY = concat(
+ ANY_KEY, '(\\s*\\.\\s*', ANY_KEY, ')*',
+ lookahead(/\s*=\s*[^#\s]/)
+ );
+
+ return {
+ name: 'TOML, also INI',
+ aliases: ['toml'],
+ case_insensitive: true,
+ illegal: /\S/,
+ contains: [
+ COMMENTS,
+ {
+ className: 'section',
+ begin: /\[+/,
+ end: /\]+/
+ },
+ {
+ begin: DOTTED_KEY,
+ className: 'attr',
+ starts: {
+ end: /$/,
+ contains: [
+ COMMENTS,
+ ARRAY,
+ LITERALS,
+ VARIABLES,
+ STRINGS,
+ NUMBERS
+ ]
+ }
+ }
+ ]
+ };
+ }
+
+ return ini;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('java', function () {
+ 'use strict';
+
+ /*
+ Language: Java
+ Author: Vsevolod Solovyov
+ Category: common, enterprise
+ Website: https://www.java.com/
+ */
+
+ function java(hljs) {
+ var JAVA_IDENT_RE = '[\u00C0-\u02B8a-zA-Z_$][\u00C0-\u02B8a-zA-Z_$0-9]*';
+ var GENERIC_IDENT_RE = JAVA_IDENT_RE + '(<' + JAVA_IDENT_RE + '(\\s*,\\s*' + JAVA_IDENT_RE + ')*>)?';
+ var KEYWORDS = 'false synchronized int abstract float private char boolean var static null if const ' +
+ 'for true while long strictfp finally protected import native final void ' +
+ 'enum else break transient catch instanceof byte super volatile case assert short ' +
+ 'package default double public try this switch continue throws protected public private ' +
+ 'module requires exports do';
+
+ var ANNOTATION = {
+ className: 'meta',
+ begin: '@' + JAVA_IDENT_RE,
+ contains: [
+ {
+ begin: /\(/,
+ end: /\)/,
+ contains: ["self"] // allow nested () inside our annotation
+ },
+ ]
+ };
+
+ // https://docs.oracle.com/javase/specs/jls/se15/html/jls-3.html#jls-3.10
+ var decimalDigits = '[0-9](_*[0-9])*';
+ var frac = `\\.(${decimalDigits})`;
+ var hexDigits = '[0-9a-fA-F](_*[0-9a-fA-F])*';
+ var NUMBER = {
+ className: 'number',
+ variants: [
+ // DecimalFloatingPointLiteral
+ // including ExponentPart
+ { begin: `(\\b(${decimalDigits})((${frac})|\\.)?|(${frac}))` +
+ `[eE][+-]?(${decimalDigits})[fFdD]?\\b` },
+ // excluding ExponentPart
+ { begin: `\\b(${decimalDigits})((${frac})[fFdD]?\\b|\\.([fFdD]\\b)?)` },
+ { begin: `(${frac})[fFdD]?\\b` },
+ { begin: `\\b(${decimalDigits})[fFdD]\\b` },
+
+ // HexadecimalFloatingPointLiteral
+ { begin: `\\b0[xX]((${hexDigits})\\.?|(${hexDigits})?\\.(${hexDigits}))` +
+ `[pP][+-]?(${decimalDigits})[fFdD]?\\b` },
+
+ // DecimalIntegerLiteral
+ { begin: '\\b(0|[1-9](_*[0-9])*)[lL]?\\b' },
+
+ // HexIntegerLiteral
+ { begin: `\\b0[xX](${hexDigits})[lL]?\\b` },
+
+ // OctalIntegerLiteral
+ { begin: '\\b0(_*[0-7])*[lL]?\\b' },
+
+ // BinaryIntegerLiteral
+ { begin: '\\b0[bB][01](_*[01])*[lL]?\\b' },
+ ],
+ relevance: 0
+ };
+
+ return {
+ name: 'Java',
+ aliases: ['jsp'],
+ keywords: KEYWORDS,
+ illegal: /<\/|#/,
+ contains: [
+ hljs.COMMENT(
+ '/\\*\\*',
+ '\\*/',
+ {
+ relevance: 0,
+ contains: [
+ {
+ // eat up @'s in emails to prevent them to be recognized as doctags
+ begin: /\w+@/, relevance: 0
+ },
+ {
+ className: 'doctag',
+ begin: '@[A-Za-z]+'
+ }
+ ]
+ }
+ ),
+ // relevance boost
+ {
+ begin: /import java\.[a-z]+\./,
+ keywords: "import",
+ relevance: 2
+ },
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ {
+ className: 'class',
+ beginKeywords: 'class interface enum', end: /[{;=]/, excludeEnd: true,
+ keywords: 'class interface enum',
+ illegal: /[:"\[\]]/,
+ contains: [
+ { beginKeywords: 'extends implements' },
+ hljs.UNDERSCORE_TITLE_MODE
+ ]
+ },
+ {
+ // Expression keywords prevent 'keyword Name(...)' from being
+ // recognized as a function definition
+ beginKeywords: 'new throw return else',
+ relevance: 0
+ },
+ {
+ className: 'class',
+ begin: 'record\\s+' + hljs.UNDERSCORE_IDENT_RE + '\\s*\\(',
+ returnBegin: true,
+ excludeEnd: true,
+ end: /[{;=]/,
+ keywords: KEYWORDS,
+ contains: [
+ { beginKeywords: "record" },
+ {
+ begin: hljs.UNDERSCORE_IDENT_RE + '\\s*\\(',
+ returnBegin: true,
+ relevance: 0,
+ contains: [hljs.UNDERSCORE_TITLE_MODE]
+ },
+ {
+ className: 'params',
+ begin: /\(/, end: /\)/,
+ keywords: KEYWORDS,
+ relevance: 0,
+ contains: [
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ },
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ },
+ {
+ className: 'function',
+ begin: '(' + GENERIC_IDENT_RE + '\\s+)+' + hljs.UNDERSCORE_IDENT_RE + '\\s*\\(', returnBegin: true, end: /[{;=]/,
+ excludeEnd: true,
+ keywords: KEYWORDS,
+ contains: [
+ {
+ begin: hljs.UNDERSCORE_IDENT_RE + '\\s*\\(', returnBegin: true,
+ relevance: 0,
+ contains: [hljs.UNDERSCORE_TITLE_MODE]
+ },
+ {
+ className: 'params',
+ begin: /\(/, end: /\)/,
+ keywords: KEYWORDS,
+ relevance: 0,
+ contains: [
+ ANNOTATION,
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ NUMBER,
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ },
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE
+ ]
+ },
+ NUMBER,
+ ANNOTATION
+ ]
+ };
+ }
+
+ return java;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('javascript', function () {
+ 'use strict';
+
+ const IDENT_RE = '[A-Za-z$_][0-9A-Za-z$_]*';
+ const KEYWORDS = [
+ "as", // for exports
+ "in",
+ "of",
+ "if",
+ "for",
+ "while",
+ "finally",
+ "var",
+ "new",
+ "function",
+ "do",
+ "return",
+ "void",
+ "else",
+ "break",
+ "catch",
+ "instanceof",
+ "with",
+ "throw",
+ "case",
+ "default",
+ "try",
+ "switch",
+ "continue",
+ "typeof",
+ "delete",
+ "let",
+ "yield",
+ "const",
+ "class",
+ // JS handles these with a special rule
+ // "get",
+ // "set",
+ "debugger",
+ "async",
+ "await",
+ "static",
+ "import",
+ "from",
+ "export",
+ "extends"
+ ];
+ const LITERALS = [
+ "true",
+ "false",
+ "null",
+ "undefined",
+ "NaN",
+ "Infinity"
+ ];
+
+ const TYPES = [
+ "Intl",
+ "DataView",
+ "Number",
+ "Math",
+ "Date",
+ "String",
+ "RegExp",
+ "Object",
+ "Function",
+ "Boolean",
+ "Error",
+ "Symbol",
+ "Set",
+ "Map",
+ "WeakSet",
+ "WeakMap",
+ "Proxy",
+ "Reflect",
+ "JSON",
+ "Promise",
+ "Float64Array",
+ "Int16Array",
+ "Int32Array",
+ "Int8Array",
+ "Uint16Array",
+ "Uint32Array",
+ "Float32Array",
+ "Array",
+ "Uint8Array",
+ "Uint8ClampedArray",
+ "ArrayBuffer"
+ ];
+
+ const ERROR_TYPES = [
+ "EvalError",
+ "InternalError",
+ "RangeError",
+ "ReferenceError",
+ "SyntaxError",
+ "TypeError",
+ "URIError"
+ ];
+
+ const BUILT_IN_GLOBALS = [
+ "setInterval",
+ "setTimeout",
+ "clearInterval",
+ "clearTimeout",
+
+ "require",
+ "exports",
+
+ "eval",
+ "isFinite",
+ "isNaN",
+ "parseFloat",
+ "parseInt",
+ "decodeURI",
+ "decodeURIComponent",
+ "encodeURI",
+ "encodeURIComponent",
+ "escape",
+ "unescape"
+ ];
+
+ const BUILT_IN_VARIABLES = [
+ "arguments",
+ "this",
+ "super",
+ "console",
+ "window",
+ "document",
+ "localStorage",
+ "module",
+ "global" // Node.js
+ ];
+
+ const BUILT_INS = [].concat(
+ BUILT_IN_GLOBALS,
+ BUILT_IN_VARIABLES,
+ TYPES,
+ ERROR_TYPES
+ );
+
+ /**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function source(re) {
+ if (!re) return null;
+ if (typeof re === "string") return re;
+
+ return re.source;
+ }
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function lookahead(re) {
+ return concat('(?=', re, ')');
+ }
+
+ /**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+ function concat(...args) {
+ const joined = args.map((x) => source(x)).join("");
+ return joined;
+ }
+
+ /*
+ Language: JavaScript
+ Description: JavaScript (JS) is a lightweight, interpreted, or just-in-time compiled programming language with first-class functions.
+ Category: common, scripting
+ Website: https://developer.mozilla.org/en-US/docs/Web/JavaScript
+ */
+
+ /** @type LanguageFn */
+ function javascript(hljs) {
+ /**
+ * Takes a string like " {
+ const tag = "" + match[0].slice(1);
+ const pos = match.input.indexOf(tag, after);
+ return pos !== -1;
+ };
+
+ const IDENT_RE$1 = IDENT_RE;
+ const FRAGMENT = {
+ begin: '<>',
+ end: '>'
+ };
+ const XML_TAG = {
+ begin: /<[A-Za-z0-9\\._:-]+/,
+ end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+ /**
+ * @param {RegExpMatchArray} match
+ * @param {CallbackResponse} response
+ */
+ isTrulyOpeningTag: (match, response) => {
+ const afterMatchIndex = match[0].length + match.index;
+ const nextChar = match.input[afterMatchIndex];
+ // nested type?
+ // HTML should not include another raw `<` inside a tag
+ // But a type might: `>`, etc.
+ if (nextChar === "<") {
+ response.ignoreMatch();
+ return;
+ }
+ //
+ // This is now either a tag or a type.
+ if (nextChar === ">") {
+ // if we cannot find a matching closing tag, then we
+ // will ignore it
+ if (!hasClosingTag(match, { after: afterMatchIndex })) {
+ response.ignoreMatch();
+ }
+ }
+ }
+ };
+ const KEYWORDS$1 = {
+ $pattern: IDENT_RE,
+ keyword: KEYWORDS.join(" "),
+ literal: LITERALS.join(" "),
+ built_in: BUILT_INS.join(" ")
+ };
+
+ // https://tc39.es/ecma262/#sec-literals-numeric-literals
+ const decimalDigits = '[0-9](_?[0-9])*';
+ const frac = `\\.(${decimalDigits})`;
+ // DecimalIntegerLiteral, including Annex B NonOctalDecimalIntegerLiteral
+ // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+ const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`;
+ const NUMBER = {
+ className: 'number',
+ variants: [
+ // DecimalLiteral
+ { begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))` +
+ `[eE][+-]?(${decimalDigits})\\b` },
+ { begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\b` },
+
+ // DecimalBigIntegerLiteral
+ { begin: `\\b(0|[1-9](_?[0-9])*)n\\b` },
+
+ // NonDecimalIntegerLiteral
+ { begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" },
+ { begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" },
+ { begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" },
+
+ // LegacyOctalIntegerLiteral (does not include underscore separators)
+ // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+ { begin: "\\b0[0-7]+n?\\b" },
+ ],
+ relevance: 0
+ };
+
+ const SUBST = {
+ className: 'subst',
+ begin: '\\$\\{',
+ end: '\\}',
+ keywords: KEYWORDS$1,
+ contains: [] // defined later
+ };
+ const HTML_TEMPLATE = {
+ begin: 'html`',
+ end: '',
+ starts: {
+ end: '`',
+ returnEnd: false,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ SUBST
+ ],
+ subLanguage: 'xml'
+ }
+ };
+ const CSS_TEMPLATE = {
+ begin: 'css`',
+ end: '',
+ starts: {
+ end: '`',
+ returnEnd: false,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ SUBST
+ ],
+ subLanguage: 'css'
+ }
+ };
+ const TEMPLATE_STRING = {
+ className: 'string',
+ begin: '`',
+ end: '`',
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ SUBST
+ ]
+ };
+ const JSDOC_COMMENT = hljs.COMMENT(
+ '/\\*\\*',
+ '\\*/',
+ {
+ relevance: 0,
+ contains: [
+ {
+ className: 'doctag',
+ begin: '@[A-Za-z]+',
+ contains: [
+ {
+ className: 'type',
+ begin: '\\{',
+ end: '\\}',
+ relevance: 0
+ },
+ {
+ className: 'variable',
+ begin: IDENT_RE$1 + '(?=\\s*(-)|$)',
+ endsParent: true,
+ relevance: 0
+ },
+ // eat spaces (not newlines) so we can find
+ // types or variables
+ {
+ begin: /(?=[^\n])\s/,
+ relevance: 0
+ }
+ ]
+ }
+ ]
+ }
+ );
+ const COMMENT = {
+ className: "comment",
+ variants: [
+ JSDOC_COMMENT,
+ hljs.C_BLOCK_COMMENT_MODE,
+ hljs.C_LINE_COMMENT_MODE
+ ]
+ };
+ const SUBST_INTERNALS = [
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ HTML_TEMPLATE,
+ CSS_TEMPLATE,
+ TEMPLATE_STRING,
+ NUMBER,
+ hljs.REGEXP_MODE
+ ];
+ SUBST.contains = SUBST_INTERNALS
+ .concat({
+ // we need to pair up {} inside our subst to prevent
+ // it from ending too early by matching another }
+ begin: /\{/,
+ end: /\}/,
+ keywords: KEYWORDS$1,
+ contains: [
+ "self"
+ ].concat(SUBST_INTERNALS)
+ });
+ const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains);
+ const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([
+ // eat recursive parens in sub expressions
+ {
+ begin: /\(/,
+ end: /\)/,
+ keywords: KEYWORDS$1,
+ contains: ["self"].concat(SUBST_AND_COMMENTS)
+ }
+ ]);
+ const PARAMS = {
+ className: 'params',
+ begin: /\(/,
+ end: /\)/,
+ excludeBegin: true,
+ excludeEnd: true,
+ keywords: KEYWORDS$1,
+ contains: PARAMS_CONTAINS
+ };
+
+ return {
+ name: 'Javascript',
+ aliases: ['js', 'jsx', 'mjs', 'cjs'],
+ keywords: KEYWORDS$1,
+ // this will be extended by TypeScript
+ exports: { PARAMS_CONTAINS },
+ illegal: /#(?![$_A-z])/,
+ contains: [
+ hljs.SHEBANG({
+ label: "shebang",
+ binary: "node",
+ relevance: 5
+ }),
+ {
+ label: "use_strict",
+ className: 'meta',
+ relevance: 10,
+ begin: /^\s*['"]use (strict|asm)['"]/
+ },
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ HTML_TEMPLATE,
+ CSS_TEMPLATE,
+ TEMPLATE_STRING,
+ COMMENT,
+ NUMBER,
+ { // object attr container
+ begin: concat(/[{,\n]\s*/,
+ // we need to look ahead to make sure that we actually have an
+ // attribute coming up so we don't steal a comma from a potential
+ // "value" container
+ //
+ // NOTE: this might not work how you think. We don't actually always
+ // enter this mode and stay. Instead it might merely match `,
+ // ` and then immediately end after the , because it
+ // fails to find any actual attrs. But this still does the job because
+ // it prevents the value contain rule from grabbing this instead and
+ // prevening this rule from firing when we actually DO have keys.
+ lookahead(concat(
+ // we also need to allow for multiple possible comments inbetween
+ // the first key:value pairing
+ /(((\/\/.*$)|(\/\*(\*[^/]|[^*])*\*\/))\s*)*/,
+ IDENT_RE$1 + '\\s*:'))),
+ relevance: 0,
+ contains: [
+ {
+ className: 'attr',
+ begin: IDENT_RE$1 + lookahead('\\s*:'),
+ relevance: 0
+ }
+ ]
+ },
+ { // "value" container
+ begin: '(' + hljs.RE_STARTERS_RE + '|\\b(case|return|throw)\\b)\\s*',
+ keywords: 'return throw case',
+ contains: [
+ COMMENT,
+ hljs.REGEXP_MODE,
+ {
+ className: 'function',
+ // we have to count the parens to make sure we actually have the
+ // correct bounding ( ) before the =>. There could be any number of
+ // sub-expressions inside also surrounded by parens.
+ begin: '(\\(' +
+ '[^()]*(\\(' +
+ '[^()]*(\\(' +
+ '[^()]*' +
+ '\\))*[^()]*' +
+ '\\))*[^()]*' +
+ '\\)|' + hljs.UNDERSCORE_IDENT_RE + ')\\s*=>',
+ returnBegin: true,
+ end: '\\s*=>',
+ contains: [
+ {
+ className: 'params',
+ variants: [
+ {
+ begin: hljs.UNDERSCORE_IDENT_RE,
+ relevance: 0
+ },
+ {
+ className: null,
+ begin: /\(\s*\)/,
+ skip: true
+ },
+ {
+ begin: /\(/,
+ end: /\)/,
+ excludeBegin: true,
+ excludeEnd: true,
+ keywords: KEYWORDS$1,
+ contains: PARAMS_CONTAINS
+ }
+ ]
+ }
+ ]
+ },
+ { // could be a comma delimited list of params to a function call
+ begin: /,/, relevance: 0
+ },
+ {
+ className: '',
+ begin: /\s/,
+ end: /\s*/,
+ skip: true
+ },
+ { // JSX
+ variants: [
+ { begin: FRAGMENT.begin, end: FRAGMENT.end },
+ {
+ begin: XML_TAG.begin,
+ // we carefully check the opening tag to see if it truly
+ // is a tag and not a false positive
+ 'on:begin': XML_TAG.isTrulyOpeningTag,
+ end: XML_TAG.end
+ }
+ ],
+ subLanguage: 'xml',
+ contains: [
+ {
+ begin: XML_TAG.begin,
+ end: XML_TAG.end,
+ skip: true,
+ contains: ['self']
+ }
+ ]
+ }
+ ],
+ relevance: 0
+ },
+ {
+ className: 'function',
+ beginKeywords: 'function',
+ end: /[{;]/,
+ excludeEnd: true,
+ keywords: KEYWORDS$1,
+ contains: [
+ 'self',
+ hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+ PARAMS
+ ],
+ illegal: /%/
+ },
+ {
+ // prevent this from getting swallowed up by function
+ // since they appear "function like"
+ beginKeywords: "while if switch catch for"
+ },
+ {
+ className: 'function',
+ // we have to count the parens to make sure we actually have the correct
+ // bounding ( ). There could be any number of sub-expressions inside
+ // also surrounded by parens.
+ begin: hljs.UNDERSCORE_IDENT_RE +
+ '\\(' + // first parens
+ '[^()]*(\\(' +
+ '[^()]*(\\(' +
+ '[^()]*' +
+ '\\))*[^()]*' +
+ '\\))*[^()]*' +
+ '\\)\\s*\\{', // end parens
+ returnBegin:true,
+ contains: [
+ PARAMS,
+ hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+ ]
+ },
+ // hack: prevents detection of keywords in some circumstances
+ // .keyword()
+ // $keyword = x
+ {
+ variants: [
+ { begin: '\\.' + IDENT_RE$1 },
+ { begin: '\\$' + IDENT_RE$1 }
+ ],
+ relevance: 0
+ },
+ { // ES6 class
+ className: 'class',
+ beginKeywords: 'class',
+ end: /[{;=]/,
+ excludeEnd: true,
+ illegal: /[:"[\]]/,
+ contains: [
+ { beginKeywords: 'extends' },
+ hljs.UNDERSCORE_TITLE_MODE
+ ]
+ },
+ {
+ begin: /\b(?=constructor)/,
+ end: /[{;]/,
+ excludeEnd: true,
+ contains: [
+ hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+ 'self',
+ PARAMS
+ ]
+ },
+ {
+ begin: '(get|set)\\s+(?=' + IDENT_RE$1 + '\\()',
+ end: /\{/,
+ keywords: "get set",
+ contains: [
+ hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+ { begin: /\(\)/ }, // eat to avoid empty params
+ PARAMS
+ ]
+ },
+ {
+ begin: /\$[(.]/ // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+ }
+ ]
+ };
+ }
+
+ return javascript;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('json', function () {
+ 'use strict';
+
+ /*
+ Language: JSON
+ Description: JSON (JavaScript Object Notation) is a lightweight data-interchange format.
+ Author: Ivan Sagalaev
+ Website: http://www.json.org
+ Category: common, protocols
+ */
+
+ function json(hljs) {
+ const LITERALS = {
+ literal: 'true false null'
+ };
+ const ALLOWED_COMMENTS = [
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE
+ ];
+ const TYPES = [
+ hljs.QUOTE_STRING_MODE,
+ hljs.C_NUMBER_MODE
+ ];
+ const VALUE_CONTAINER = {
+ end: ',',
+ endsWithParent: true,
+ excludeEnd: true,
+ contains: TYPES,
+ keywords: LITERALS
+ };
+ const OBJECT = {
+ begin: /\{/,
+ end: /\}/,
+ contains: [
+ {
+ className: 'attr',
+ begin: /"/,
+ end: /"/,
+ contains: [hljs.BACKSLASH_ESCAPE],
+ illegal: '\\n'
+ },
+ hljs.inherit(VALUE_CONTAINER, {
+ begin: /:/
+ })
+ ].concat(ALLOWED_COMMENTS),
+ illegal: '\\S'
+ };
+ const ARRAY = {
+ begin: '\\[',
+ end: '\\]',
+ contains: [hljs.inherit(VALUE_CONTAINER)], // inherit is a workaround for a bug that makes shared modes with endsWithParent compile only the ending of one of the parents
+ illegal: '\\S'
+ };
+ TYPES.push(OBJECT, ARRAY);
+ ALLOWED_COMMENTS.forEach(function(rule) {
+ TYPES.push(rule);
+ });
+ return {
+ name: 'JSON',
+ contains: TYPES,
+ keywords: LITERALS,
+ illegal: '\\S'
+ };
+ }
+
+ return json;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('kotlin', function () {
+ 'use strict';
+
+ /*
+ Language: Kotlin
+ Description: Kotlin is an OSS statically typed programming language that targets the JVM, Android, JavaScript and Native.
+ Author: Sergey Mashkov
+ Website: https://kotlinlang.org
+ Category: common
+ */
+
+ function kotlin(hljs) {
+ const KEYWORDS = {
+ keyword:
+ 'abstract as val var vararg get set class object open private protected public noinline ' +
+ 'crossinline dynamic final enum if else do while for when throw try catch finally ' +
+ 'import package is in fun override companion reified inline lateinit init ' +
+ 'interface annotation data sealed internal infix operator out by constructor super ' +
+ 'tailrec where const inner suspend typealias external expect actual',
+ built_in:
+ 'Byte Short Char Int Long Boolean Float Double Void Unit Nothing',
+ literal:
+ 'true false null'
+ };
+ const KEYWORDS_WITH_LABEL = {
+ className: 'keyword',
+ begin: /\b(break|continue|return|this)\b/,
+ starts: {
+ contains: [
+ {
+ className: 'symbol',
+ begin: /@\w+/
+ }
+ ]
+ }
+ };
+ const LABEL = {
+ className: 'symbol',
+ begin: hljs.UNDERSCORE_IDENT_RE + '@'
+ };
+
+ // for string templates
+ const SUBST = {
+ className: 'subst',
+ begin: /\$\{/,
+ end: /\}/,
+ contains: [ hljs.C_NUMBER_MODE ]
+ };
+ const VARIABLE = {
+ className: 'variable',
+ begin: '\\$' + hljs.UNDERSCORE_IDENT_RE
+ };
+ const STRING = {
+ className: 'string',
+ variants: [
+ {
+ begin: '"""',
+ end: '"""(?=[^"])',
+ contains: [
+ VARIABLE,
+ SUBST
+ ]
+ },
+ // Can't use built-in modes easily, as we want to use STRING in the meta
+ // context as 'meta-string' and there's no syntax to remove explicitly set
+ // classNames in built-in modes.
+ {
+ begin: '\'',
+ end: '\'',
+ illegal: /\n/,
+ contains: [ hljs.BACKSLASH_ESCAPE ]
+ },
+ {
+ begin: '"',
+ end: '"',
+ illegal: /\n/,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ VARIABLE,
+ SUBST
+ ]
+ }
+ ]
+ };
+ SUBST.contains.push(STRING);
+
+ const ANNOTATION_USE_SITE = {
+ className: 'meta',
+ begin: '@(?:file|property|field|get|set|receiver|param|setparam|delegate)\\s*:(?:\\s*' + hljs.UNDERSCORE_IDENT_RE + ')?'
+ };
+ const ANNOTATION = {
+ className: 'meta',
+ begin: '@' + hljs.UNDERSCORE_IDENT_RE,
+ contains: [
+ {
+ begin: /\(/,
+ end: /\)/,
+ contains: [
+ hljs.inherit(STRING, {
+ className: 'meta-string'
+ })
+ ]
+ }
+ ]
+ };
+
+ // https://kotlinlang.org/docs/reference/whatsnew11.html#underscores-in-numeric-literals
+ // According to the doc above, the number mode of kotlin is the same as java 8,
+ // so the code below is copied from java.js
+ const KOTLIN_NUMBER_RE = '\\b' +
+ '(' +
+ '0[bB]([01]+[01_]+[01]+|[01]+)' + // 0b...
+ '|' +
+ '0[xX]([a-fA-F0-9]+[a-fA-F0-9_]+[a-fA-F0-9]+|[a-fA-F0-9]+)' + // 0x...
+ '|' +
+ '(' +
+ '([\\d]+[\\d_]+[\\d]+|[\\d]+)(\\.([\\d]+[\\d_]+[\\d]+|[\\d]+))?' +
+ '|' +
+ '\\.([\\d]+[\\d_]+[\\d]+|[\\d]+)' +
+ ')' +
+ '([eE][-+]?\\d+)?' + // octal, decimal, float
+ ')' +
+ '[lLfF]?';
+ const KOTLIN_NUMBER_MODE = {
+ className: 'number',
+ begin: KOTLIN_NUMBER_RE,
+ relevance: 0
+ };
+ const KOTLIN_NESTED_COMMENT = hljs.COMMENT(
+ '/\\*', '\\*/',
+ {
+ contains: [ hljs.C_BLOCK_COMMENT_MODE ]
+ }
+ );
+ const KOTLIN_PAREN_TYPE = {
+ variants: [
+ {
+ className: 'type',
+ begin: hljs.UNDERSCORE_IDENT_RE
+ },
+ {
+ begin: /\(/,
+ end: /\)/,
+ contains: [] // defined later
+ }
+ ]
+ };
+ const KOTLIN_PAREN_TYPE2 = KOTLIN_PAREN_TYPE;
+ KOTLIN_PAREN_TYPE2.variants[1].contains = [ KOTLIN_PAREN_TYPE ];
+ KOTLIN_PAREN_TYPE.variants[1].contains = [ KOTLIN_PAREN_TYPE2 ];
+
+ return {
+ name: 'Kotlin',
+ aliases: [ 'kt' ],
+ keywords: KEYWORDS,
+ contains: [
+ hljs.COMMENT(
+ '/\\*\\*',
+ '\\*/',
+ {
+ relevance: 0,
+ contains: [
+ {
+ className: 'doctag',
+ begin: '@[A-Za-z]+'
+ }
+ ]
+ }
+ ),
+ hljs.C_LINE_COMMENT_MODE,
+ KOTLIN_NESTED_COMMENT,
+ KEYWORDS_WITH_LABEL,
+ LABEL,
+ ANNOTATION_USE_SITE,
+ ANNOTATION,
+ {
+ className: 'function',
+ beginKeywords: 'fun',
+ end: '[(]|$',
+ returnBegin: true,
+ excludeEnd: true,
+ keywords: KEYWORDS,
+ illegal: /fun\s+(<.*>)?[^\s\(]+(\s+[^\s\(]+)\s*=/,
+ relevance: 5,
+ contains: [
+ {
+ begin: hljs.UNDERSCORE_IDENT_RE + '\\s*\\(',
+ returnBegin: true,
+ relevance: 0,
+ contains: [ hljs.UNDERSCORE_TITLE_MODE ]
+ },
+ {
+ className: 'type',
+ begin: /,
+ end: />/,
+ keywords: 'reified',
+ relevance: 0
+ },
+ {
+ className: 'params',
+ begin: /\(/,
+ end: /\)/,
+ endsParent: true,
+ keywords: KEYWORDS,
+ relevance: 0,
+ contains: [
+ {
+ begin: /:/,
+ end: /[=,\/]/,
+ endsWithParent: true,
+ contains: [
+ KOTLIN_PAREN_TYPE,
+ hljs.C_LINE_COMMENT_MODE,
+ KOTLIN_NESTED_COMMENT
+ ],
+ relevance: 0
+ },
+ hljs.C_LINE_COMMENT_MODE,
+ KOTLIN_NESTED_COMMENT,
+ ANNOTATION_USE_SITE,
+ ANNOTATION,
+ STRING,
+ hljs.C_NUMBER_MODE
+ ]
+ },
+ KOTLIN_NESTED_COMMENT
+ ]
+ },
+ {
+ className: 'class',
+ beginKeywords: 'class interface trait', // remove 'trait' when removed from KEYWORDS
+ end: /[:\{(]|$/,
+ excludeEnd: true,
+ illegal: 'extends implements',
+ contains: [
+ {
+ beginKeywords: 'public protected internal private constructor'
+ },
+ hljs.UNDERSCORE_TITLE_MODE,
+ {
+ className: 'type',
+ begin: /,
+ end: />/,
+ excludeBegin: true,
+ excludeEnd: true,
+ relevance: 0
+ },
+ {
+ className: 'type',
+ begin: /[,:]\s*/,
+ end: /[<\(,]|$/,
+ excludeBegin: true,
+ returnEnd: true
+ },
+ ANNOTATION_USE_SITE,
+ ANNOTATION
+ ]
+ },
+ STRING,
+ {
+ className: 'meta',
+ begin: "^#!/usr/bin/env",
+ end: '$',
+ illegal: '\n'
+ },
+ KOTLIN_NUMBER_MODE
+ ]
+ };
+ }
+
+ return kotlin;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('less', function () {
+ 'use strict';
+
+ /*
+ Language: Less
+ Description: It's CSS, with just a little more.
+ Author: Max Mikhailov
+ Website: http://lesscss.org
+ Category: common, css
+ */
+
+ function less(hljs) {
+ var IDENT_RE = '[\\w-]+'; // yes, Less identifiers may begin with a digit
+ var INTERP_IDENT_RE = '(' + IDENT_RE + '|@\\{' + IDENT_RE + '\\})';
+
+ /* Generic Modes */
+
+ var RULES = [], VALUE = []; // forward def. for recursive modes
+
+ var STRING_MODE = function(c) { return {
+ // Less strings are not multiline (also include '~' for more consistent coloring of "escaped" strings)
+ className: 'string', begin: '~?' + c + '.*?' + c
+ };};
+
+ var IDENT_MODE = function(name, begin, relevance) { return {
+ className: name, begin: begin, relevance: relevance
+ };};
+
+ var PARENS_MODE = {
+ // used only to properly balance nested parens inside mixin call, def. arg list
+ begin: '\\(', end: '\\)', contains: VALUE, relevance: 0
+ };
+
+ // generic Less highlighter (used almost everywhere except selectors):
+ VALUE.push(
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ STRING_MODE("'"),
+ STRING_MODE('"'),
+ hljs.CSS_NUMBER_MODE, // fixme: it does not include dot for numbers like .5em :(
+ {
+ begin: '(url|data-uri)\\(',
+ starts: {className: 'string', end: '[\\)\\n]', excludeEnd: true}
+ },
+ IDENT_MODE('number', '#[0-9A-Fa-f]+\\b'),
+ PARENS_MODE,
+ IDENT_MODE('variable', '@@?' + IDENT_RE, 10),
+ IDENT_MODE('variable', '@\\{' + IDENT_RE + '\\}'),
+ IDENT_MODE('built_in', '~?`[^`]*?`'), // inline javascript (or whatever host language) *multiline* string
+ { // @media features (it’s here to not duplicate things in AT_RULE_MODE with extra PARENS_MODE overriding):
+ className: 'attribute', begin: IDENT_RE + '\\s*:', end: ':', returnBegin: true, excludeEnd: true
+ },
+ {
+ className: 'meta',
+ begin: '!important'
+ }
+ );
+
+ var VALUE_WITH_RULESETS = VALUE.concat({
+ begin: /\{/, end: /\}/, contains: RULES
+ });
+
+ var MIXIN_GUARD_MODE = {
+ beginKeywords: 'when', endsWithParent: true,
+ contains: [{beginKeywords: 'and not'}].concat(VALUE) // using this form to override VALUE’s 'function' match
+ };
+
+ /* Rule-Level Modes */
+
+ var RULE_MODE = {
+ begin: INTERP_IDENT_RE + '\\s*:', returnBegin: true, end: '[;}]',
+ relevance: 0,
+ contains: [
+ {
+ className: 'attribute',
+ begin: INTERP_IDENT_RE, end: ':', excludeEnd: true,
+ starts: {
+ endsWithParent: true, illegal: '[<=$]',
+ relevance: 0,
+ contains: VALUE
+ }
+ }
+ ]
+ };
+
+ var AT_RULE_MODE = {
+ className: 'keyword',
+ begin: '@(import|media|charset|font-face|(-[a-z]+-)?keyframes|supports|document|namespace|page|viewport|host)\\b',
+ starts: {end: '[;{}]', returnEnd: true, contains: VALUE, relevance: 0}
+ };
+
+ // variable definitions and calls
+ var VAR_RULE_MODE = {
+ className: 'variable',
+ variants: [
+ // using more strict pattern for higher relevance to increase chances of Less detection.
+ // this is *the only* Less specific statement used in most of the sources, so...
+ // (we’ll still often loose to the css-parser unless there's '//' comment,
+ // simply because 1 variable just can't beat 99 properties :)
+ {begin: '@' + IDENT_RE + '\\s*:', relevance: 15},
+ {begin: '@' + IDENT_RE}
+ ],
+ starts: {end: '[;}]', returnEnd: true, contains: VALUE_WITH_RULESETS}
+ };
+
+ var SELECTOR_MODE = {
+ // first parse unambiguous selectors (i.e. those not starting with tag)
+ // then fall into the scary lookahead-discriminator variant.
+ // this mode also handles mixin definitions and calls
+ variants: [{
+ begin: '[\\.#:&\\[>]', end: '[;{}]' // mixin calls end with ';'
+ }, {
+ begin: INTERP_IDENT_RE, end: /\{/
+ }],
+ returnBegin: true,
+ returnEnd: true,
+ illegal: '[<=\'$"]',
+ relevance: 0,
+ contains: [
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ MIXIN_GUARD_MODE,
+ IDENT_MODE('keyword', 'all\\b'),
+ IDENT_MODE('variable', '@\\{' + IDENT_RE + '\\}'), // otherwise it’s identified as tag
+ IDENT_MODE('selector-tag', INTERP_IDENT_RE + '%?', 0), // '%' for more consistent coloring of @keyframes "tags"
+ IDENT_MODE('selector-id', '#' + INTERP_IDENT_RE),
+ IDENT_MODE('selector-class', '\\.' + INTERP_IDENT_RE, 0),
+ IDENT_MODE('selector-tag', '&', 0),
+ {className: 'selector-attr', begin: '\\[', end: '\\]'},
+ {className: 'selector-pseudo', begin: /:(:)?[a-zA-Z0-9_\-+()"'.]+/},
+ {begin: '\\(', end: '\\)', contains: VALUE_WITH_RULESETS}, // argument list of parametric mixins
+ {begin: '!important'} // eat !important after mixin call or it will be colored as tag
+ ]
+ };
+
+ RULES.push(
+ hljs.C_LINE_COMMENT_MODE,
+ hljs.C_BLOCK_COMMENT_MODE,
+ AT_RULE_MODE,
+ VAR_RULE_MODE,
+ RULE_MODE,
+ SELECTOR_MODE
+ );
+
+ return {
+ name: 'Less',
+ case_insensitive: true,
+ illegal: '[=>\'/<($"]',
+ contains: RULES
+ };
+ }
+
+ return less;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('lua', function () {
+ 'use strict';
+
+ /*
+ Language: Lua
+ Description: Lua is a powerful, efficient, lightweight, embeddable scripting language.
+ Author: Andrew Fedorov
+ Category: common, scripting
+ Website: https://www.lua.org
+ */
+
+ function lua(hljs) {
+ const OPENING_LONG_BRACKET = '\\[=*\\[';
+ const CLOSING_LONG_BRACKET = '\\]=*\\]';
+ const LONG_BRACKETS = {
+ begin: OPENING_LONG_BRACKET,
+ end: CLOSING_LONG_BRACKET,
+ contains: ['self']
+ };
+ const COMMENTS = [
+ hljs.COMMENT('--(?!' + OPENING_LONG_BRACKET + ')', '$'),
+ hljs.COMMENT(
+ '--' + OPENING_LONG_BRACKET,
+ CLOSING_LONG_BRACKET,
+ {
+ contains: [LONG_BRACKETS],
+ relevance: 10
+ }
+ )
+ ];
+ return {
+ name: 'Lua',
+ keywords: {
+ $pattern: hljs.UNDERSCORE_IDENT_RE,
+ literal: "true false nil",
+ keyword: "and break do else elseif end for goto if in local not or repeat return then until while",
+ built_in:
+ // Metatags and globals:
+ '_G _ENV _VERSION __index __newindex __mode __call __metatable __tostring __len ' +
+ '__gc __add __sub __mul __div __mod __pow __concat __unm __eq __lt __le assert ' +
+ // Standard methods and properties:
+ 'collectgarbage dofile error getfenv getmetatable ipairs load loadfile loadstring ' +
+ 'module next pairs pcall print rawequal rawget rawset require select setfenv ' +
+ 'setmetatable tonumber tostring type unpack xpcall arg self ' +
+ // Library methods and properties (one line per library):
+ 'coroutine resume yield status wrap create running debug getupvalue ' +
+ 'debug sethook getmetatable gethook setmetatable setlocal traceback setfenv getinfo setupvalue getlocal getregistry getfenv ' +
+ 'io lines write close flush open output type read stderr stdin input stdout popen tmpfile ' +
+ 'math log max acos huge ldexp pi cos tanh pow deg tan cosh sinh random randomseed frexp ceil floor rad abs sqrt modf asin min mod fmod log10 atan2 exp sin atan ' +
+ 'os exit setlocale date getenv difftime remove time clock tmpname rename execute package preload loadlib loaded loaders cpath config path seeall ' +
+ 'string sub upper len gfind rep find match char dump gmatch reverse byte format gsub lower ' +
+ 'table setn insert getn foreachi maxn foreach concat sort remove'
+ },
+ contains: COMMENTS.concat([
+ {
+ className: 'function',
+ beginKeywords: 'function',
+ end: '\\)',
+ contains: [
+ hljs.inherit(hljs.TITLE_MODE, {
+ begin: '([_a-zA-Z]\\w*\\.)*([_a-zA-Z]\\w*:)?[_a-zA-Z]\\w*'
+ }),
+ {
+ className: 'params',
+ begin: '\\(',
+ endsWithParent: true,
+ contains: COMMENTS
+ }
+ ].concat(COMMENTS)
+ },
+ hljs.C_NUMBER_MODE,
+ hljs.APOS_STRING_MODE,
+ hljs.QUOTE_STRING_MODE,
+ {
+ className: 'string',
+ begin: OPENING_LONG_BRACKET,
+ end: CLOSING_LONG_BRACKET,
+ contains: [LONG_BRACKETS],
+ relevance: 5
+ }
+ ])
+ };
+ }
+
+ return lua;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('makefile', function () {
+ 'use strict';
+
+ /*
+ Language: Makefile
+ Author: Ivan Sagalaev
+ Contributors: Joël Porquet
+ Website: https://www.gnu.org/software/make/manual/html_node/Introduction.html
+ Category: common
+ */
+
+ function makefile(hljs) {
+ /* Variables: simple (eg $(var)) and special (eg $@) */
+ const VARIABLE = {
+ className: 'variable',
+ variants: [
+ {
+ begin: '\\$\\(' + hljs.UNDERSCORE_IDENT_RE + '\\)',
+ contains: [ hljs.BACKSLASH_ESCAPE ]
+ },
+ {
+ begin: /\$[@%\^\+\*]/
+ }
+ ]
+ };
+ /* Quoted string with variables inside */
+ const QUOTE_STRING = {
+ className: 'string',
+ begin: /"/,
+ end: /"/,
+ contains: [
+ hljs.BACKSLASH_ESCAPE,
+ VARIABLE
+ ]
+ };
+ /* Function: $(func arg,...) */
+ const FUNC = {
+ className: 'variable',
+ begin: /\$\([\w-]+\s/,
+ end: /\)/,
+ keywords: {
+ built_in:
+ 'subst patsubst strip findstring filter filter-out sort ' +
+ 'word wordlist firstword lastword dir notdir suffix basename ' +
+ 'addsuffix addprefix join wildcard realpath abspath error warning ' +
+ 'shell origin flavor foreach if or and call eval file value'
+ },
+ contains: [ VARIABLE ]
+ };
+ /* Variable assignment */
+ const ASSIGNMENT = {
+ begin: '^' + hljs.UNDERSCORE_IDENT_RE + '\\s*(?=[:+?]?=)'
+ };
+ /* Meta targets (.PHONY) */
+ const META = {
+ className: 'meta',
+ begin: /^\.PHONY:/,
+ end: /$/,
+ keywords: {
+ $pattern: /[\.\w]+/,
+ 'meta-keyword': '.PHONY'
+ }
+ };
+ /* Targets */
+ const TARGET = {
+ className: 'section',
+ begin: /^[^\s]+:/,
+ end: /$/,
+ contains: [ VARIABLE ]
+ };
+ return {
+ name: 'Makefile',
+ aliases: [
+ 'mk',
+ 'mak'
+ ],
+ keywords: {
+ $pattern: /[\w-]+/,
+ keyword: 'define endef undefine ifdef ifndef ifeq ifneq else endif ' +
+ 'include -include sinclude override export unexport private vpath'
+ },
+ contains: [
+ hljs.HASH_COMMENT_MODE,
+ VARIABLE,
+ QUOTE_STRING,
+ FUNC,
+ ASSIGNMENT,
+ META,
+ TARGET
+ ]
+ };
+ }
+
+ return makefile;
+
+ return module.exports.definer || module.exports;
+
+}());
+
+hljs.registerLanguage('xml', function () {
+ 'use strict';
+
+ /**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function source(re) {
+ if (!re) return null;
+ if (typeof re === "string") return re;
+
+ return re.source;
+ }
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function lookahead(re) {
+ return concat('(?=', re, ')');
+ }
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function optional(re) {
+ return concat('(', re, ')?');
+ }
+
+ /**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+ function concat(...args) {
+ const joined = args.map((x) => source(x)).join("");
+ return joined;
+ }
+
+ /**
+ * Any of the passed expresssions may match
+ *
+ * Creates a huge this | this | that | that match
+ * @param {(RegExp | string)[] } args
+ * @returns {string}
+ */
+ function either(...args) {
+ const joined = '(' + args.map((x) => source(x)).join("|") + ")";
+ return joined;
+ }
+
+ /*
+ Language: HTML, XML
+ Website: https://www.w3.org/XML/
+ Category: common
+ */
+
+ /** @type LanguageFn */
+ function xml(hljs) {
+ // Element names can contain letters, digits, hyphens, underscores, and periods
+ const TAG_NAME_RE = concat(/[A-Z_]/, optional(/[A-Z0-9_.-]+:/), /[A-Z0-9_.-]*/);
+ const XML_IDENT_RE = '[A-Za-z0-9\\._:-]+';
+ const XML_ENTITIES = {
+ className: 'symbol',
+ begin: '&[a-z]+;|[0-9]+;|[a-f0-9]+;'
+ };
+ const XML_META_KEYWORDS = {
+ begin: '\\s',
+ contains: [
+ {
+ className: 'meta-keyword',
+ begin: '#?[a-z_][a-z1-9_-]+',
+ illegal: '\\n'
+ }
+ ]
+ };
+ const XML_META_PAR_KEYWORDS = hljs.inherit(XML_META_KEYWORDS, {
+ begin: '\\(',
+ end: '\\)'
+ });
+ const APOS_META_STRING_MODE = hljs.inherit(hljs.APOS_STRING_MODE, {
+ className: 'meta-string'
+ });
+ const QUOTE_META_STRING_MODE = hljs.inherit(hljs.QUOTE_STRING_MODE, {
+ className: 'meta-string'
+ });
+ const TAG_INTERNALS = {
+ endsWithParent: true,
+ illegal: /,
+ relevance: 0,
+ contains: [
+ {
+ className: 'attr',
+ begin: XML_IDENT_RE,
+ relevance: 0
+ },
+ {
+ begin: /=\s*/,
+ relevance: 0,
+ contains: [
+ {
+ className: 'string',
+ endsParent: true,
+ variants: [
+ {
+ begin: /"/,
+ end: /"/,
+ contains: [ XML_ENTITIES ]
+ },
+ {
+ begin: /'/,
+ end: /'/,
+ contains: [ XML_ENTITIES ]
+ },
+ {
+ begin: /[^\s"'=<>`]+/
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ };
+ return {
+ name: 'HTML, XML',
+ aliases: [
+ 'html',
+ 'xhtml',
+ 'rss',
+ 'atom',
+ 'xjb',
+ 'xsd',
+ 'xsl',
+ 'plist',
+ 'wsf',
+ 'svg'
+ ],
+ case_insensitive: true,
+ contains: [
+ {
+ className: 'meta',
+ begin: '',
+ relevance: 10,
+ contains: [
+ XML_META_KEYWORDS,
+ QUOTE_META_STRING_MODE,
+ APOS_META_STRING_MODE,
+ XML_META_PAR_KEYWORDS,
+ {
+ begin: '\\[',
+ end: '\\]',
+ contains: [
+ {
+ className: 'meta',
+ begin: '',
+ contains: [
+ XML_META_KEYWORDS,
+ XML_META_PAR_KEYWORDS,
+ QUOTE_META_STRING_MODE,
+ APOS_META_STRING_MODE
+ ]
+ }
+ ]
+ }
+ ]
+ },
+ hljs.COMMENT(
+ '',
+ {
+ relevance: 10
+ }
+ ),
+ {
+ begin: '',
+ relevance: 10
+ },
+ XML_ENTITIES,
+ {
+ className: 'meta',
+ begin: /<\?xml/,
+ end: /\?>/,
+ relevance: 10
+ },
+ {
+ className: 'tag',
+ /*
+ The lookahead pattern (?=...) ensures that 'begin' only matches
+ '',
+ returnEnd: true,
+ subLanguage: [
+ 'css',
+ 'xml'
+ ]
+ }
+ },
+ {
+ className: 'tag',
+ // See the comment in the ",returnEnd:!0,
+subLanguage:["css","xml"]}},{className:"tag",begin:"