From aee7ef0dc9d086af8bcbdf99787efa2ba7c205c0 Mon Sep 17 00:00:00 2001 From: Penar Musaraj Date: Thu, 18 Mar 2021 18:21:23 -0400 Subject: [PATCH] DEV: Fix build due to highlight.js branch issue (#12441) Highlight.js changed their default branch from master to main. This switches to the @highlightjs/cdn-assets package, thus sidestepping the problem. It's a slightly cleaner integration though (no need to build locally anymore). --- .../discourse/app/lib/highlight-syntax.js | 2 +- lib/tasks/javascript.rake | 15 +- package.json | 2 +- .../assets/javascripts/highlightjs/README.md | 4 +- .../javascripts/highlightjs/highlight.js | 11093 +++++++++++++++- .../javascripts/highlightjs/highlight.min.js | 1436 +- .../highlightjs/languages/arcade.min.js | 8 +- .../highlightjs/languages/arduino.min.js | 10 +- .../highlightjs/languages/autoit.min.js | 10 +- .../highlightjs/languages/c-like.min.js | 14 +- .../highlightjs/languages/c.min.js | 2 +- .../highlightjs/languages/clean.min.js | 2 +- .../highlightjs/languages/coffeescript.min.js | 2 +- .../highlightjs/languages/cos.min.js | 2 +- .../highlightjs/languages/cpp.min.js | 10 +- .../highlightjs/languages/css.min.js | 2 +- .../highlightjs/languages/gml.min.js | 6 +- .../highlightjs/languages/isbl.min.js | 2 +- .../highlightjs/languages/javascript.min.js | 28 +- .../highlightjs/languages/kotlin.min.js | 6 +- .../highlightjs/languages/latex.min.js | 2 +- .../highlightjs/languages/less.min.js | 2 +- .../highlightjs/languages/livescript.min.js | 18 +- .../highlightjs/languages/nim.min.js | 3 +- .../highlightjs/languages/php.min.js | 33 +- .../highlightjs/languages/python.min.js | 41 +- .../highlightjs/languages/routeros.min.js | 4 +- .../highlightjs/languages/sas.min.js | 2 +- .../highlightjs/languages/scss.min.js | 6 +- .../highlightjs/languages/smali.min.js | 8 +- .../highlightjs/languages/sqf.min.js | 2 +- .../highlightjs/languages/stylus.min.js | 6 +- .../highlightjs/languages/tcl.min.js | 19 +- .../highlightjs/languages/typescript.min.js | 16 +- .../highlightjs/languages/yaml.min.js | 2 +- .../javascripts/highlightjs/package.json | 290 +- yarn.lock | 9 +- 37 files changed, 12641 insertions(+), 478 deletions(-) diff --git a/app/assets/javascripts/discourse/app/lib/highlight-syntax.js b/app/assets/javascripts/discourse/app/lib/highlight-syntax.js index de2c634e24c..3a1a5d9b864 100644 --- a/app/assets/javascripts/discourse/app/lib/highlight-syntax.js +++ b/app/assets/javascripts/discourse/app/lib/highlight-syntax.js @@ -40,7 +40,7 @@ export default function highlightSyntax(elem, siteSettings, session) { } e.classList.remove("lang-auto"); - hljs.highlightElement(e); + hljs.highlightBlock(e); }); }); } diff --git a/lib/tasks/javascript.rake b/lib/tasks/javascript.rake index 43048b55efc..2bfebd5f59c 100644 --- a/lib/tasks/javascript.rake +++ b/lib/tasks/javascript.rake @@ -101,7 +101,7 @@ def dependencies }, { source: 'handlebars/dist/handlebars.runtime.js' }, { - source: 'highlight.js/build/.', + source: '@highlightjs/cdn-assets/.', destination: 'highlightjs' }, { source: 'jquery.autoellipsis/src/jquery.autoellipsis.js', @@ -265,16 +265,9 @@ task 'javascript:update' => 'clean_up' do filename = f[:destination] end - # Highlight.js needs building - if src.include? "highlight.js" - puts "Install Highlight.js dependencies" - system("cd node_modules/highlight.js && yarn install") - - puts "Build Highlight.js" - system("cd node_modules/highlight.js && node tools/build.js -t cdn") - - puts "Cleanup unused styles folder" - system("rm -rf node_modules/highlight.js/build/styles") + if src.include? "highlightjs" + puts "Cleanup highlightjs styles and install smaller test bundle" + system("rm -rf node_modules/@highlightjs/cdn-assets/styles") # We don't need every language for tests langs = ['javascript', 'sql', 'ruby'] diff --git a/package.json b/package.json index 340a22c1e9e..4cdf6817856 100644 --- a/package.json +++ b/package.json @@ -18,7 +18,7 @@ "diffhtml": "^1.0.0-beta.18", "eslint-config-discourse": "^1.1.8", "handlebars": "^4.7.0", - "highlight.js": "https://github.com/highlightjs/highlight.js", + "@highlightjs/cdn-assets": "^10.6.0", "intersection-observer": "^0.5.1", "jquery": "3.5.1", "jquery-color": "3.0.0-alpha.1", diff --git a/vendor/assets/javascripts/highlightjs/README.md b/vendor/assets/javascripts/highlightjs/README.md index a237670e521..0a70f6241fe 100644 --- a/vendor/assets/javascripts/highlightjs/README.md +++ b/vendor/assets/javascripts/highlightjs/README.md @@ -38,8 +38,8 @@ The Github project may be found at: . -A list of the Core Team and contributors can be found in the [CONTRIBUTORS.md][8] file. +Authors and contributors are listed in the [AUTHORS.txt][8] file. [1]: https://www.npmjs.com/package/highlight.js [7]: https://github.com/highlightjs/highlight.js/blob/master/LICENSE -[8]: https://github.com/highlightjs/highlight.js/blob/master/CONTRIBUTORS.md +[8]: https://github.com/highlightjs/highlight.js/blob/master/AUTHORS.txt diff --git a/vendor/assets/javascripts/highlightjs/highlight.js b/vendor/assets/javascripts/highlightjs/highlight.js index 8f085767692..420545ceae1 100644 --- a/vendor/assets/javascripts/highlightjs/highlight.js +++ b/vendor/assets/javascripts/highlightjs/highlight.js @@ -1,7 +1,7 @@ /* - Highlight.js 10.6.0 (7f3240ea) + Highlight.js 10.6.0 (eb122d3b) License: BSD-3-Clause - Copyright (c) 2006-2021, Ivan Sagalaev + Copyright (c) 2006-2020, Ivan Sagalaev */ var hljs = (function () { 'use strict'; @@ -71,7 +71,7 @@ var hljs = (function () { * @param {Record[]} objects * @returns {T} a single new object */ - function inherit$1(original, ...objects) { + function inherit(original, ...objects) { /** @type Record */ const result = Object.create(null); @@ -339,7 +339,7 @@ var hljs = (function () { * @param {string} value * @returns {RegExp} * */ - function escape$1(value) { + function escape(value) { return new RegExp(value.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&'), 'm'); } @@ -393,15 +393,6 @@ var hljs = (function () { return match && match.index === 0; } - // BACKREF_RE matches an open parenthesis or backreference. To avoid - // an incorrect parse, it additionally matches the following: - // - [...] elements, where the meaning of parentheses and escapes change - // - other escape sequences, so we do not misparse escape sequences as - // interesting elements - // - non-matching or lookahead parentheses, which do not capture. These - // follow the '(' with a '?'. - const BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./; - // join logically computes regexps.join(separator), but fixes the // backreferences so they continue to match. // it also places each individual regular expression into it's own @@ -413,34 +404,45 @@ var hljs = (function () { * @returns {string} */ function join(regexps, separator = "|") { + // backreferenceRe matches an open parenthesis or backreference. To avoid + // an incorrect parse, it additionally matches the following: + // - [...] elements, where the meaning of parentheses and escapes change + // - other escape sequences, so we do not misparse escape sequences as + // interesting elements + // - non-matching or lookahead parentheses, which do not capture. These + // follow the '(' with a '?'. + const backreferenceRe = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./; let numCaptures = 0; - - return regexps.map((regex) => { + let ret = ''; + for (let i = 0; i < regexps.length; i++) { numCaptures += 1; const offset = numCaptures; - let re = source(regex); - let out = ''; - + let re = source(regexps[i]); + if (i > 0) { + ret += separator; + } + ret += "("; while (re.length > 0) { - const match = BACKREF_RE.exec(re); - if (!match) { - out += re; + const match = backreferenceRe.exec(re); + if (match == null) { + ret += re; break; } - out += re.substring(0, match.index); + ret += re.substring(0, match.index); re = re.substring(match.index + match[0].length); if (match[0][0] === '\\' && match[1]) { // Adjust the backreference. - out += '\\' + String(Number(match[1]) + offset); + ret += '\\' + String(Number(match[1]) + offset); } else { - out += match[0]; + ret += match[0]; if (match[0] === '(') { numCaptures++; } } } - return out; - }).map(re => `(${re})`).join(separator); + ret += ")"; + } + return ret; } // Common regexps @@ -464,7 +466,7 @@ var hljs = (function () { opts.binary, /\b.*/); } - return inherit$1({ + return inherit({ className: 'meta', begin: beginShebang, end: /$/, @@ -506,7 +508,7 @@ var hljs = (function () { * @returns {Partial} */ const COMMENT = function(begin, end, modeOptions = {}) { - const mode = inherit$1( + const mode = inherit( { className: 'comment', begin, @@ -1170,7 +1172,7 @@ var hljs = (function () { } // we need a null object, which inherit will guarantee - language.classNameAliases = inherit$1(language.classNameAliases || {}); + language.classNameAliases = inherit(language.classNameAliases || {}); return compileMode(/** @type Mode */ (language)); } @@ -1205,7 +1207,7 @@ var hljs = (function () { function expandOrCloneMode(mode) { if (mode.variants && !mode.cachedVariants) { mode.cachedVariants = mode.variants.map(function(variant) { - return inherit$1(mode, { variants: null }, variant); + return inherit(mode, { variants: null }, variant); }); } @@ -1221,11 +1223,11 @@ var hljs = (function () { // instance of ourselves, so we can be reused with many // different parents without issue if (dependencyOnParent(mode)) { - return inherit$1(mode, { starts: mode.starts ? inherit$1(mode.starts) : null }); + return inherit(mode, { starts: mode.starts ? inherit(mode.starts) : null }); } if (Object.isFrozen(mode)) { - return inherit$1(mode); + return inherit(mode); } // no special dependency issues, just return ourselves @@ -1306,8 +1308,8 @@ var hljs = (function () { /** @type {HLJSPlugin} */ const mergeHTMLPlugin = { - "after:highlightElement": ({ el, result, text }) => { - const originalStream = nodeStream(el); + "after:highlightBlock": ({ block, result, text }) => { + const originalStream = nodeStream(block); if (!originalStream.length) return; const resultNode = document.createElement('div'); @@ -1492,8 +1494,8 @@ var hljs = (function () { https://highlightjs.org/ */ - const escape = escapeHTML; - const inherit = inherit$1; + const escape$1 = escapeHTML; + const inherit$1 = inherit; const NO_MATCH = Symbol("nomatch"); /** @@ -1775,7 +1777,7 @@ var hljs = (function () { } if (newMode && newMode.endSameAsBegin) { - newMode.endRe = escape$1(lexeme); + newMode.endRe = escape(lexeme); } if (newMode.skip) { @@ -2004,14 +2006,14 @@ var hljs = (function () { }, sofar: result, relevance: 0, - value: escape(codeToHighlight), + value: escape$1(codeToHighlight), emitter: emitter }; } else if (SAFE_MODE) { return { illegal: false, relevance: 0, - value: escape(codeToHighlight), + value: escape$1(codeToHighlight), emitter: emitter, language: languageName, top: top, @@ -2034,7 +2036,7 @@ var hljs = (function () { const result = { relevance: 0, emitter: new options.__emitter(options), - value: escape(code), + value: escape$1(code), illegal: false, top: PLAINTEXT_LANGUAGE }; @@ -2135,12 +2137,12 @@ var hljs = (function () { /** @type {HLJSPlugin} */ const brPlugin = { - "before:highlightElement": ({ el }) => { + "before:highlightBlock": ({ block }) => { if (options.useBR) { - el.innerHTML = el.innerHTML.replace(/\n/g, '').replace(//g, '\n'); + block.innerHTML = block.innerHTML.replace(/\n/g, '').replace(//g, '\n'); } }, - "after:highlightElement": ({ result }) => { + "after:highlightBlock": ({ result }) => { if (options.useBR) { result.value = result.value.replace(/\n/g, "
"); } @@ -2150,7 +2152,7 @@ var hljs = (function () { const TAB_REPLACE_RE = /^(<[^>]+>|\t)+/gm; /** @type {HLJSPlugin} */ const tabReplacePlugin = { - "after:highlightElement": ({ result }) => { + "after:highlightBlock": ({ result }) => { if (options.tabReplace) { result.value = result.value.replace(TAB_REPLACE_RE, (m) => m.replace(/\t/g, options.tabReplace) @@ -2165,23 +2167,21 @@ var hljs = (function () { * * @param {HighlightedHTMLElement} element - the HTML element to highlight */ - function highlightElement(element) { + function highlightBlock(element) { /** @type HTMLElement */ let node = null; const language = blockLanguage(element); if (shouldNotHighlight(language)) return; - // support for v10 API - fire("before:highlightElement", - { el: element, language: language }); + fire("before:highlightBlock", + { block: element, language: language }); node = element; const text = node.textContent; const result = language ? highlight(language, text, true) : highlightAuto(text); - // support for v10 API - fire("after:highlightElement", { el: element, result, text }); + fire("after:highlightBlock", { block: element, result, text }); element.innerHTML = result.value; updateClassName(element, language, result.language); @@ -2211,7 +2211,7 @@ var hljs = (function () { deprecated("10.3.0", "'useBR' will be removed entirely in v11.0"); deprecated("10.3.0", "Please see https://github.com/highlightjs/highlight.js/issues/2559"); } - options = inherit(options, userOptions); + options = inherit$1(options, userOptions); } /** @@ -2227,7 +2227,7 @@ var hljs = (function () { deprecated("10.6.0", "initHighlighting() is deprecated. Use highlightAll() instead."); const blocks = document.querySelectorAll('pre code'); - blocks.forEach(highlightElement); + blocks.forEach(highlightBlock); }; // Higlights all when DOMContentLoaded fires @@ -2238,22 +2238,21 @@ var hljs = (function () { } let wantsHighlight = false; + let domLoaded = false; /** * auto-highlights all pre>code elements on the page */ function highlightAll() { // if we are called too early in the loading process - if (document.readyState === "loading") { - wantsHighlight = true; - return; - } + if (!domLoaded) { wantsHighlight = true; return; } const blocks = document.querySelectorAll('pre code'); - blocks.forEach(highlightElement); + blocks.forEach(highlightBlock); } function boot() { + domLoaded = true; // if a highlight was requested before DOM was loaded, do now if (wantsHighlight) highlightAll(); } @@ -2293,20 +2292,6 @@ var hljs = (function () { } } - /** - * Remove a language grammar module - * - * @param {string} languageName - */ - function unregisterLanguage(languageName) { - delete languages[languageName]; - for (const alias of Object.keys(aliases)) { - if (aliases[alias] === languageName) { - delete aliases[alias]; - } - } - } - /** * @returns {string[]} List of language internal names */ @@ -2352,7 +2337,7 @@ var hljs = (function () { if (typeof aliasList === 'string') { aliasList = [aliasList]; } - aliasList.forEach(alias => { aliases[alias.toLowerCase()] = languageName; }); + aliasList.forEach(alias => { aliases[alias] = languageName; }); } /** @@ -2364,34 +2349,10 @@ var hljs = (function () { return lang && !lang.disableAutodetect; } - /** - * Upgrades the old highlightBlock plugins to the new - * highlightElement API - * @param {HLJSPlugin} plugin - */ - function upgradePluginAPI(plugin) { - // TODO: remove with v12 - if (plugin["before:highlightBlock"] && !plugin["before:highlightElement"]) { - plugin["before:highlightElement"] = (data) => { - plugin["before:highlightBlock"]( - Object.assign({ block: data.el }, data) - ); - }; - } - if (plugin["after:highlightBlock"] && !plugin["after:highlightElement"]) { - plugin["after:highlightElement"] = (data) => { - plugin["after:highlightBlock"]( - Object.assign({ block: data.el }, data) - ); - }; - } - } - /** * @param {HLJSPlugin} plugin */ function addPlugin(plugin) { - upgradePluginAPI(plugin); plugins.push(plugin); } @@ -2422,37 +2383,23 @@ var hljs = (function () { return fixMarkup(arg); } - /** - * - * @param {HighlightedHTMLElement} el - */ - function deprecateHighlightBlock(el) { - deprecated("10.7.0", "highlightBlock will be removed entirely in v12.0"); - deprecated("10.7.0", "Please use highlightElement now."); - - return highlightElement(el); - } - /* Interface definition */ Object.assign(hljs, { highlight, highlightAuto, highlightAll, fixMarkup: deprecateFixMarkup, - highlightElement, - // TODO: Remove with v12 API - highlightBlock: deprecateHighlightBlock, + highlightBlock, configure, initHighlighting, initHighlightingOnLoad, registerLanguage, - unregisterLanguage, listLanguages, getLanguage, registerAliases, requireLanguage, autoDetection, - inherit, + inherit: inherit$1, addPlugin, // plugins for frameworks vuePlugin: BuildVuePlugin(hljs).VuePlugin @@ -2487,3 +2434,10925 @@ var hljs = (function () { }()); 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 + Audit: 2020 + */ + + /** @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'; + + /** + * @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 optional(re) { + return concat('(', re, ')?'); + } + + /** + * @param {...(RegExp | string) } args + * @returns {string} + */ + function concat(...args) { + const joined = args.map((x) => source(x)).join(""); + return joined; + } + + /* + Language: C + Category: common, system + Website: https://en.wikipedia.org/wiki/C_(programming_language) + */ + + /** @type LanguageFn */ + function c(hljs) { + // 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 + const C_LINE_COMMENT_MODE = hljs.COMMENT('//', '$', { + contains: [ + { + begin: /\\\n/ + } + ] + }); + const DECLTYPE_AUTO_RE = 'decltype\\(auto\\)'; + const NAMESPACE_RE = '[a-zA-Z_]\\w*::'; + const TEMPLATE_ARGUMENT_RE = '<[^<>]+>'; + const FUNCTION_TYPE_RE = '(' + + DECLTYPE_AUTO_RE + '|' + + optional(NAMESPACE_RE) + + '[a-zA-Z_]\\w*' + optional(TEMPLATE_ARGUMENT_RE) + + ')'; + const 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 + const CHARACTER_ESCAPES = '\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)'; + const 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})"/ + }) + ] + }; + + const NUMBERS = { + className: 'number', + variants: [ + { + begin: '\\b(0b[01\']+)' + }, + { + begin: '(-?)\\b([\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)' + }, + { + begin: '(-?)(\\b0[xX][a-fA-F0-9\']+|(\\b[\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)([eE][-+]?[\\d\']+)?)' + } + ], + relevance: 0 + }; + + const 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 + ] + }; + + const TITLE_MODE = { + className: 'title', + begin: optional(NAMESPACE_RE) + hljs.IDENT_RE, + relevance: 0 + }; + + const FUNCTION_TITLE = optional(NAMESPACE_RE) + hljs.IDENT_RE + '\\s*\\('; + + const 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' + }; + + const EXPRESSION_CONTAINS = [ + PREPROCESSOR, + CPP_PRIMITIVE_TYPES, + C_LINE_COMMENT_MODE, + hljs.C_BLOCK_COMMENT_MODE, + NUMBERS, + STRINGS + ]; + + const 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 + }; + + const 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 { + name: "C", + aliases: [ + 'c', + 'h' + ], + keywords: CPP_KEYWORDS, + // Until differentiations are added between `c` and `cpp`, `c` will + // not be auto-detected to avoid auto-detect conflicts between C and C++ + disableAutodetect: true, + illegal: ' 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 + } + }; + } + + 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)), + literal: LITERALS.concat(COFFEE_LITERALS), + built_in: BUILT_INS.concat(COFFEE_BUILT_INS) + }; + 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 POSSIBLE_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*' + POSSIBLE_PARAMS_RE, + end: '[-=]>', + returnBegin: true, + contains: [ + TITLE, + PARAMS + ] + }, + { + // anonymous function start + begin: /[:\(,=]\s*/, + relevance: 0, + contains: [{ + className: 'function', + begin: POSSIBLE_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'; + + /** + * @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 optional(re) { + return concat('(', re, ')?'); + } + + /** + * @param {...(RegExp | string) } args + * @returns {string} + */ + function concat(...args) { + const joined = args.map((x) => source(x)).join(""); + return joined; + } + + /* + Language: C++ + Category: common, system + Website: https://isocpp.org + */ + + /** @type LanguageFn */ + function cpp(hljs) { + // 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 + const C_LINE_COMMENT_MODE = hljs.COMMENT('//', '$', { + contains: [ + { + begin: /\\\n/ + } + ] + }); + const DECLTYPE_AUTO_RE = 'decltype\\(auto\\)'; + const NAMESPACE_RE = '[a-zA-Z_]\\w*::'; + const TEMPLATE_ARGUMENT_RE = '<[^<>]+>'; + const FUNCTION_TYPE_RE = '(' + + DECLTYPE_AUTO_RE + '|' + + optional(NAMESPACE_RE) + + '[a-zA-Z_]\\w*' + optional(TEMPLATE_ARGUMENT_RE) + + ')'; + const 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 + const CHARACTER_ESCAPES = '\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)'; + const 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})"/ + }) + ] + }; + + const NUMBERS = { + className: 'number', + variants: [ + { + begin: '\\b(0b[01\']+)' + }, + { + begin: '(-?)\\b([\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)' + }, + { + begin: '(-?)(\\b0[xX][a-fA-F0-9\']+|(\\b[\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)([eE][-+]?[\\d\']+)?)' + } + ], + relevance: 0 + }; + + const 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 + ] + }; + + const TITLE_MODE = { + className: 'title', + begin: optional(NAMESPACE_RE) + hljs.IDENT_RE, + relevance: 0 + }; + + const FUNCTION_TITLE = optional(NAMESPACE_RE) + hljs.IDENT_RE + '\\s*\\('; + + const 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' + }; + + const EXPRESSION_CONTAINS = [ + PREPROCESSOR, + CPP_PRIMITIVE_TYPES, + C_LINE_COMMENT_MODE, + hljs.C_BLOCK_COMMENT_MODE, + NUMBERS, + STRINGS + ]; + + const 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 + }; + + const 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 { + name: 'C++', + aliases: [ + 'cc', + 'c++', + 'h++', + 'hpp', + 'hh', + 'hxx', + 'cxx' + ], + keywords: CPP_KEYWORDS, + illegal: ' 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 + } + }; + } + + 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), + built_in: BUILT_IN_KEYWORDS, + literal: LITERAL_KEYWORDS + }; + 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: '' + } + ] + } + ] + } + ), + 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'; + + const MODES = (hljs) => { + return { + IMPORTANT: { + className: 'meta', + begin: '!important' + }, + HEXCOLOR: { + className: 'number', + begin: '#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})' + }, + ATTRIBUTE_SELECTOR_MODE: { + className: 'selector-attr', + begin: /\[/, + end: /\]/, + illegal: '$', + contains: [ + hljs.APOS_STRING_MODE, + hljs.QUOTE_STRING_MODE + ] + } + }; + }; + + const TAGS = [ + 'a', + 'abbr', + 'address', + 'article', + 'aside', + 'audio', + 'b', + 'blockquote', + 'body', + 'button', + 'canvas', + 'caption', + 'cite', + 'code', + 'dd', + 'del', + 'details', + 'dfn', + 'div', + 'dl', + 'dt', + 'em', + 'fieldset', + 'figcaption', + 'figure', + 'footer', + 'form', + 'h1', + 'h2', + 'h3', + 'h4', + 'h5', + 'h6', + 'header', + 'hgroup', + 'html', + 'i', + 'iframe', + 'img', + 'input', + 'ins', + 'kbd', + 'label', + 'legend', + 'li', + 'main', + 'mark', + 'menu', + 'nav', + 'object', + 'ol', + 'p', + 'q', + 'quote', + 'samp', + 'section', + 'span', + 'strong', + 'summary', + 'sup', + 'table', + 'tbody', + 'td', + 'textarea', + 'tfoot', + 'th', + 'thead', + 'time', + 'tr', + 'ul', + 'var', + 'video' + ]; + + const MEDIA_FEATURES = [ + 'any-hover', + 'any-pointer', + 'aspect-ratio', + 'color', + 'color-gamut', + 'color-index', + 'device-aspect-ratio', + 'device-height', + 'device-width', + 'display-mode', + 'forced-colors', + 'grid', + 'height', + 'hover', + 'inverted-colors', + 'monochrome', + 'orientation', + 'overflow-block', + 'overflow-inline', + 'pointer', + 'prefers-color-scheme', + 'prefers-contrast', + 'prefers-reduced-motion', + 'prefers-reduced-transparency', + 'resolution', + 'scan', + 'scripting', + 'update', + 'width', + // TODO: find a better solution? + 'min-width', + 'max-width', + 'min-height', + 'max-height' + ]; + + // https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-classes + const PSEUDO_CLASSES = [ + 'active', + 'any-link', + 'blank', + 'checked', + 'current', + 'default', + 'defined', + 'dir', // dir() + 'disabled', + 'drop', + 'empty', + 'enabled', + 'first', + 'first-child', + 'first-of-type', + 'fullscreen', + 'future', + 'focus', + 'focus-visible', + 'focus-within', + 'has', // has() + 'host', // host or host() + 'host-context', // host-context() + 'hover', + 'indeterminate', + 'in-range', + 'invalid', + 'is', // is() + 'lang', // lang() + 'last-child', + 'last-of-type', + 'left', + 'link', + 'local-link', + 'not', // not() + 'nth-child', // nth-child() + 'nth-col', // nth-col() + 'nth-last-child', // nth-last-child() + 'nth-last-col', // nth-last-col() + 'nth-last-of-type', //nth-last-of-type() + 'nth-of-type', //nth-of-type() + 'only-child', + 'only-of-type', + 'optional', + 'out-of-range', + 'past', + 'placeholder-shown', + 'read-only', + 'read-write', + 'required', + 'right', + 'root', + 'scope', + 'target', + 'target-within', + 'user-invalid', + 'valid', + 'visited', + 'where' // where() + ]; + + // https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-elements + const PSEUDO_ELEMENTS = [ + 'after', + 'backdrop', + 'before', + 'cue', + 'cue-region', + 'first-letter', + 'first-line', + 'grammar-error', + 'marker', + 'part', + 'placeholder', + 'selection', + 'slotted', + 'spelling-error' + ]; + + const ATTRIBUTES = [ + 'align-content', + 'align-items', + 'align-self', + 'animation', + 'animation-delay', + 'animation-direction', + 'animation-duration', + 'animation-fill-mode', + 'animation-iteration-count', + 'animation-name', + 'animation-play-state', + 'animation-timing-function', + 'auto', + 'backface-visibility', + 'background', + 'background-attachment', + 'background-clip', + 'background-color', + 'background-image', + 'background-origin', + 'background-position', + 'background-repeat', + 'background-size', + 'border', + 'border-bottom', + 'border-bottom-color', + 'border-bottom-left-radius', + 'border-bottom-right-radius', + 'border-bottom-style', + 'border-bottom-width', + 'border-collapse', + 'border-color', + 'border-image', + 'border-image-outset', + 'border-image-repeat', + 'border-image-slice', + 'border-image-source', + 'border-image-width', + 'border-left', + 'border-left-color', + 'border-left-style', + 'border-left-width', + 'border-radius', + 'border-right', + 'border-right-color', + 'border-right-style', + 'border-right-width', + 'border-spacing', + 'border-style', + 'border-top', + 'border-top-color', + 'border-top-left-radius', + 'border-top-right-radius', + 'border-top-style', + 'border-top-width', + 'border-width', + 'bottom', + 'box-decoration-break', + 'box-shadow', + 'box-sizing', + 'break-after', + 'break-before', + 'break-inside', + 'caption-side', + 'clear', + 'clip', + 'clip-path', + 'color', + 'column-count', + 'column-fill', + 'column-gap', + 'column-rule', + 'column-rule-color', + 'column-rule-style', + 'column-rule-width', + 'column-span', + 'column-width', + 'columns', + 'content', + 'counter-increment', + 'counter-reset', + 'cursor', + 'direction', + 'display', + 'empty-cells', + 'filter', + 'flex', + 'flex-basis', + 'flex-direction', + 'flex-flow', + 'flex-grow', + 'flex-shrink', + 'flex-wrap', + 'float', + 'font', + 'font-display', + 'font-family', + 'font-feature-settings', + 'font-kerning', + 'font-language-override', + 'font-size', + 'font-size-adjust', + 'font-stretch', + 'font-style', + 'font-variant', + 'font-variant-ligatures', + 'font-variation-settings', + 'font-weight', + 'height', + 'hyphens', + 'icon', + 'image-orientation', + 'image-rendering', + 'image-resolution', + 'ime-mode', + 'inherit', + 'initial', + 'justify-content', + 'left', + 'letter-spacing', + 'line-height', + 'list-style', + 'list-style-image', + 'list-style-position', + 'list-style-type', + 'margin', + 'margin-bottom', + 'margin-left', + 'margin-right', + 'margin-top', + 'marks', + 'mask', + 'max-height', + 'max-width', + 'min-height', + 'min-width', + 'nav-down', + 'nav-index', + 'nav-left', + 'nav-right', + 'nav-up', + 'none', + 'normal', + 'object-fit', + 'object-position', + 'opacity', + 'order', + 'orphans', + 'outline', + 'outline-color', + 'outline-offset', + 'outline-style', + 'outline-width', + 'overflow', + 'overflow-wrap', + 'overflow-x', + 'overflow-y', + 'padding', + 'padding-bottom', + 'padding-left', + 'padding-right', + 'padding-top', + 'page-break-after', + 'page-break-before', + 'page-break-inside', + 'perspective', + 'perspective-origin', + 'pointer-events', + 'position', + 'quotes', + 'resize', + 'right', + 'src', // @font-face + 'tab-size', + 'table-layout', + 'text-align', + 'text-align-last', + 'text-decoration', + 'text-decoration-color', + 'text-decoration-line', + 'text-decoration-style', + 'text-indent', + 'text-overflow', + 'text-rendering', + 'text-shadow', + 'text-transform', + 'text-underline-position', + 'top', + 'transform', + 'transform-origin', + 'transform-style', + 'transition', + 'transition-delay', + 'transition-duration', + 'transition-property', + 'transition-timing-function', + 'unicode-bidi', + 'vertical-align', + 'visibility', + 'white-space', + 'widows', + 'width', + 'word-break', + 'word-spacing', + 'word-wrap', + 'z-index' + // reverse makes sure longer attributes `font-weight` are matched fully + // instead of getting false positives on say `font` + ].reverse(); + + /** + * @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: CSS + Category: common, css + Website: https://developer.mozilla.org/en-US/docs/Web/CSS + */ + + /** @type LanguageFn */ + function css(hljs) { + const modes = MODES(hljs); + const FUNCTION_DISPATCH = { + className: "built_in", + begin: /[\w-]+(?=\()/ + }; + const VENDOR_PREFIX = { + begin: /-(webkit|moz|ms|o)-(?=[a-z])/ + }; + const AT_MODIFIERS = "and or not only"; + const AT_PROPERTY_RE = /@-?\w[\w]*(-\w+)*/; // @-webkit-keyframes + const IDENT_RE = '[a-zA-Z-][a-zA-Z0-9_-]*'; + const STRINGS = [ + hljs.APOS_STRING_MODE, + hljs.QUOTE_STRING_MODE + ]; + + return { + name: 'CSS', + case_insensitive: true, + illegal: /[=|'\$]/, + keywords: { + keyframePosition: "from to" + }, + classNameAliases: { + // for visual continuity with `tag {}` and because we + // don't have a great class for this? + keyframePosition: "selector-tag" + }, + contains: [ + hljs.C_BLOCK_COMMENT_MODE, + VENDOR_PREFIX, + // to recognize keyframe 40% etc which are outside the scope of our + // attribute value mode + hljs.CSS_NUMBER_MODE, + { + className: 'selector-id', + begin: /#[A-Za-z0-9_-]+/, + relevance: 0 + }, + { + className: 'selector-class', + begin: '\\.' + IDENT_RE, + relevance: 0 + }, + modes.ATTRIBUTE_SELECTOR_MODE, + { + className: 'selector-pseudo', + variants: [ + { + begin: ':(' + PSEUDO_CLASSES.join('|') + ')' + }, + { + begin: '::(' + PSEUDO_ELEMENTS.join('|') + ')' + } + ] + }, + // we may actually need this (12/2020) + // { // pseudo-selector params + // begin: /\(/, + // end: /\)/, + // contains: [ hljs.CSS_NUMBER_MODE ] + // }, + { + className: 'attribute', + begin: '\\b(' + ATTRIBUTES.join('|') + ')\\b' + }, + // attribute values + { + begin: ':', + end: '[;}]', + contains: [ + modes.HEXCOLOR, + modes.IMPORTANT, + hljs.CSS_NUMBER_MODE, + ...STRINGS, + // needed to highlight these as strings and to avoid issues with + // illegal characters that might be inside urls that would tigger the + // languages illegal stack + { + begin: /(url|data-uri)\(/, + end: /\)/, + relevance: 0, // from keywords + keywords: { + built_in: "url data-uri" + }, + contains: [ + { + className: "string", + // any character other than `)` as in `url()` will be the start + // of a string, which ends with `)` (from the parent mode) + begin: /[^)]/, + endsWithParent: true, + excludeEnd: true + } + ] + }, + FUNCTION_DISPATCH + ] + }, + { + begin: lookahead(/@/), + end: '[{;]', + relevance: 0, + illegal: /:/, // break on Less variables @var: ... + contains: [ + { + className: 'keyword', + begin: AT_PROPERTY_RE + }, + { + begin: /\s/, + endsWithParent: true, + excludeEnd: true, + relevance: 0, + keywords: { + $pattern: /[a-z-]+/, + keyword: AT_MODIFIERS, + attribute: MEDIA_FEATURES.join(" ") + }, + contains: [ + { + begin: /[a-z-]+(?=:)/, + className: "attribute" + }, + ...STRINGS, + hljs.CSS_NUMBER_MODE + ] + } + ] + }, + { + className: 'selector-tag', + begin: '\\b(' + TAGS.join('|') + ')\\b' + } + ] + }; + } + + 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: ' source(x)).join(""); + return joined; + } + + /* + 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) { + const VERSION = 'HTTP/(2|1\\.[01])'; + const HEADER_NAME = /[A-Za-z][A-Za-z0-9-]*/; + const HEADERS_AND_BODY = [ + { + className: 'attribute', + begin: concat('^', HEADER_NAME, '(?=\\:\\s)'), + starts: { + contains: [ + { + className: "punctuation", + begin: /: /, + relevance: 0, + starts: { + end: '$', + relevance: 0 + } + } + ] + } + }, + { + begin: '\\n\\n', + starts: { subLanguage: [], endsWithParent: true } + } + ]; + + return { + name: 'HTTP', + aliases: ['https'], + illegal: /\S/, + contains: [ + // response + { + begin: '^(?=' + VERSION + " \\d{3})", + end: /$/, + contains: [ + { + className: "meta", + begin: VERSION + }, + { + className: 'number', begin: '\\b\\d{3}\\b' + } + ], + starts: { + end: /\b\B/, + illegal: /\S/, + contains: HEADERS_AND_BODY + } + }, + // request + { + begin: '(?=^[A-Z]+ (.*?) ' + VERSION + '$)', + end: /$/, + contains: [ + { + className: 'string', + begin: ' ', + end: ' ', + excludeBegin: true, + excludeEnd: true + }, + { + className: "meta", + begin: VERSION + }, + { + className: 'keyword', + begin: '[A-Z]+' + } + ], + starts: { + end: /\b\B/, + illegal: /\S/, + contains: HEADERS_AND_BODY + } + } + ] + }; + } + + 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'; + + // 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 NUMERIC = { + 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 + }; + + /* + 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 + }, + ] + }; + const NUMBER = NUMERIC; + + 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, + // TODO: can this be removed somehow? + // an extra boost because Java is more popular than other languages with + // this same syntax feature (this is just to preserve our tests passing + // for now) + relevance: 1, + 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 = "', + 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, + literal: LITERALS, + built_in: BUILT_INS + }; + + // 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'; + + // 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 NUMERIC = { + 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 + }; + + /* + 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_MODE = NUMERIC; + 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, + relevance: 5, + contains: [ + { + begin: hljs.UNDERSCORE_IDENT_RE + '\\s*\\(', + returnBegin: true, + relevance: 0, + contains: [ hljs.UNDERSCORE_TITLE_MODE ] + }, + { + className: 'type', + begin: //, + 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: //, + 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'; + + const MODES = (hljs) => { + return { + IMPORTANT: { + className: 'meta', + begin: '!important' + }, + HEXCOLOR: { + className: 'number', + begin: '#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})' + }, + ATTRIBUTE_SELECTOR_MODE: { + className: 'selector-attr', + begin: /\[/, + end: /\]/, + illegal: '$', + contains: [ + hljs.APOS_STRING_MODE, + hljs.QUOTE_STRING_MODE + ] + } + }; + }; + + const TAGS = [ + 'a', + 'abbr', + 'address', + 'article', + 'aside', + 'audio', + 'b', + 'blockquote', + 'body', + 'button', + 'canvas', + 'caption', + 'cite', + 'code', + 'dd', + 'del', + 'details', + 'dfn', + 'div', + 'dl', + 'dt', + 'em', + 'fieldset', + 'figcaption', + 'figure', + 'footer', + 'form', + 'h1', + 'h2', + 'h3', + 'h4', + 'h5', + 'h6', + 'header', + 'hgroup', + 'html', + 'i', + 'iframe', + 'img', + 'input', + 'ins', + 'kbd', + 'label', + 'legend', + 'li', + 'main', + 'mark', + 'menu', + 'nav', + 'object', + 'ol', + 'p', + 'q', + 'quote', + 'samp', + 'section', + 'span', + 'strong', + 'summary', + 'sup', + 'table', + 'tbody', + 'td', + 'textarea', + 'tfoot', + 'th', + 'thead', + 'time', + 'tr', + 'ul', + 'var', + 'video' + ]; + + const MEDIA_FEATURES = [ + 'any-hover', + 'any-pointer', + 'aspect-ratio', + 'color', + 'color-gamut', + 'color-index', + 'device-aspect-ratio', + 'device-height', + 'device-width', + 'display-mode', + 'forced-colors', + 'grid', + 'height', + 'hover', + 'inverted-colors', + 'monochrome', + 'orientation', + 'overflow-block', + 'overflow-inline', + 'pointer', + 'prefers-color-scheme', + 'prefers-contrast', + 'prefers-reduced-motion', + 'prefers-reduced-transparency', + 'resolution', + 'scan', + 'scripting', + 'update', + 'width', + // TODO: find a better solution? + 'min-width', + 'max-width', + 'min-height', + 'max-height' + ]; + + // https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-classes + const PSEUDO_CLASSES = [ + 'active', + 'any-link', + 'blank', + 'checked', + 'current', + 'default', + 'defined', + 'dir', // dir() + 'disabled', + 'drop', + 'empty', + 'enabled', + 'first', + 'first-child', + 'first-of-type', + 'fullscreen', + 'future', + 'focus', + 'focus-visible', + 'focus-within', + 'has', // has() + 'host', // host or host() + 'host-context', // host-context() + 'hover', + 'indeterminate', + 'in-range', + 'invalid', + 'is', // is() + 'lang', // lang() + 'last-child', + 'last-of-type', + 'left', + 'link', + 'local-link', + 'not', // not() + 'nth-child', // nth-child() + 'nth-col', // nth-col() + 'nth-last-child', // nth-last-child() + 'nth-last-col', // nth-last-col() + 'nth-last-of-type', //nth-last-of-type() + 'nth-of-type', //nth-of-type() + 'only-child', + 'only-of-type', + 'optional', + 'out-of-range', + 'past', + 'placeholder-shown', + 'read-only', + 'read-write', + 'required', + 'right', + 'root', + 'scope', + 'target', + 'target-within', + 'user-invalid', + 'valid', + 'visited', + 'where' // where() + ]; + + // https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-elements + const PSEUDO_ELEMENTS = [ + 'after', + 'backdrop', + 'before', + 'cue', + 'cue-region', + 'first-letter', + 'first-line', + 'grammar-error', + 'marker', + 'part', + 'placeholder', + 'selection', + 'slotted', + 'spelling-error' + ]; + + const ATTRIBUTES = [ + 'align-content', + 'align-items', + 'align-self', + 'animation', + 'animation-delay', + 'animation-direction', + 'animation-duration', + 'animation-fill-mode', + 'animation-iteration-count', + 'animation-name', + 'animation-play-state', + 'animation-timing-function', + 'auto', + 'backface-visibility', + 'background', + 'background-attachment', + 'background-clip', + 'background-color', + 'background-image', + 'background-origin', + 'background-position', + 'background-repeat', + 'background-size', + 'border', + 'border-bottom', + 'border-bottom-color', + 'border-bottom-left-radius', + 'border-bottom-right-radius', + 'border-bottom-style', + 'border-bottom-width', + 'border-collapse', + 'border-color', + 'border-image', + 'border-image-outset', + 'border-image-repeat', + 'border-image-slice', + 'border-image-source', + 'border-image-width', + 'border-left', + 'border-left-color', + 'border-left-style', + 'border-left-width', + 'border-radius', + 'border-right', + 'border-right-color', + 'border-right-style', + 'border-right-width', + 'border-spacing', + 'border-style', + 'border-top', + 'border-top-color', + 'border-top-left-radius', + 'border-top-right-radius', + 'border-top-style', + 'border-top-width', + 'border-width', + 'bottom', + 'box-decoration-break', + 'box-shadow', + 'box-sizing', + 'break-after', + 'break-before', + 'break-inside', + 'caption-side', + 'clear', + 'clip', + 'clip-path', + 'color', + 'column-count', + 'column-fill', + 'column-gap', + 'column-rule', + 'column-rule-color', + 'column-rule-style', + 'column-rule-width', + 'column-span', + 'column-width', + 'columns', + 'content', + 'counter-increment', + 'counter-reset', + 'cursor', + 'direction', + 'display', + 'empty-cells', + 'filter', + 'flex', + 'flex-basis', + 'flex-direction', + 'flex-flow', + 'flex-grow', + 'flex-shrink', + 'flex-wrap', + 'float', + 'font', + 'font-display', + 'font-family', + 'font-feature-settings', + 'font-kerning', + 'font-language-override', + 'font-size', + 'font-size-adjust', + 'font-stretch', + 'font-style', + 'font-variant', + 'font-variant-ligatures', + 'font-variation-settings', + 'font-weight', + 'height', + 'hyphens', + 'icon', + 'image-orientation', + 'image-rendering', + 'image-resolution', + 'ime-mode', + 'inherit', + 'initial', + 'justify-content', + 'left', + 'letter-spacing', + 'line-height', + 'list-style', + 'list-style-image', + 'list-style-position', + 'list-style-type', + 'margin', + 'margin-bottom', + 'margin-left', + 'margin-right', + 'margin-top', + 'marks', + 'mask', + 'max-height', + 'max-width', + 'min-height', + 'min-width', + 'nav-down', + 'nav-index', + 'nav-left', + 'nav-right', + 'nav-up', + 'none', + 'normal', + 'object-fit', + 'object-position', + 'opacity', + 'order', + 'orphans', + 'outline', + 'outline-color', + 'outline-offset', + 'outline-style', + 'outline-width', + 'overflow', + 'overflow-wrap', + 'overflow-x', + 'overflow-y', + 'padding', + 'padding-bottom', + 'padding-left', + 'padding-right', + 'padding-top', + 'page-break-after', + 'page-break-before', + 'page-break-inside', + 'perspective', + 'perspective-origin', + 'pointer-events', + 'position', + 'quotes', + 'resize', + 'right', + 'src', // @font-face + 'tab-size', + 'table-layout', + 'text-align', + 'text-align-last', + 'text-decoration', + 'text-decoration-color', + 'text-decoration-line', + 'text-decoration-style', + 'text-indent', + 'text-overflow', + 'text-rendering', + 'text-shadow', + 'text-transform', + 'text-underline-position', + 'top', + 'transform', + 'transform-origin', + 'transform-style', + 'transition', + 'transition-delay', + 'transition-duration', + 'transition-property', + 'transition-timing-function', + 'unicode-bidi', + 'vertical-align', + 'visibility', + 'white-space', + 'widows', + 'width', + 'word-break', + 'word-spacing', + 'word-wrap', + 'z-index' + // reverse makes sure longer attributes `font-weight` are matched fully + // instead of getting false positives on say `font` + ].reverse(); + + // some grammars use them all as a single group + const PSEUDO_SELECTORS = PSEUDO_CLASSES.concat(PSEUDO_ELEMENTS); + + /* + Language: Less + Description: It's CSS, with just a little more. + Author: Max Mikhailov + Website: http://lesscss.org + Category: common, css + */ + + /** @type LanguageFn */ + function less(hljs) { + const modes = MODES(hljs); + const PSEUDO_SELECTORS$1 = PSEUDO_SELECTORS; + + const AT_MODIFIERS = "and or not only"; + const IDENT_RE = '[\\w-]+'; // yes, Less identifiers may begin with a digit + const INTERP_IDENT_RE = '(' + IDENT_RE + '|@\\{' + IDENT_RE + '\\})'; + + /* Generic Modes */ + + const RULES = []; const VALUE_MODES = []; // forward def. for recursive modes + + const STRING_MODE = function(c) { + return { + // Less strings are not multiline (also include '~' for more consistent coloring of "escaped" strings) + className: 'string', + begin: '~?' + c + '.*?' + c + }; + }; + + const IDENT_MODE = function(name, begin, relevance) { + return { + className: name, + begin: begin, + relevance: relevance + }; + }; + + const AT_KEYWORDS = { + $pattern: /[a-z-]+/, + keyword: AT_MODIFIERS, + attribute: MEDIA_FEATURES.join(" ") + }; + + const PARENS_MODE = { + // used only to properly balance nested parens inside mixin call, def. arg list + begin: '\\(', + end: '\\)', + contains: VALUE_MODES, + keywords: AT_KEYWORDS, + relevance: 0 + }; + + // generic Less highlighter (used almost everywhere except selectors): + VALUE_MODES.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 + } + }, + modes.HEXCOLOR, + 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 + }, + modes.IMPORTANT + ); + + const VALUE_WITH_RULESETS = VALUE_MODES.concat({ + begin: /\{/, + end: /\}/, + contains: RULES + }); + + const MIXIN_GUARD_MODE = { + beginKeywords: 'when', + endsWithParent: true, + contains: [ + { + beginKeywords: 'and not' + } + ].concat(VALUE_MODES) // using this form to override VALUE’s 'function' match + }; + + /* Rule-Level Modes */ + + const RULE_MODE = { + begin: INTERP_IDENT_RE + '\\s*:', + returnBegin: true, + end: /[;}]/, + relevance: 0, + contains: [ + { + begin: /-(webkit|moz|ms|o)-/ + }, + { + className: 'attribute', + begin: '\\b(' + ATTRIBUTES.join('|') + ')\\b', + end: /(?=:)/, + starts: { + endsWithParent: true, + illegal: '[<=$]', + relevance: 0, + contains: VALUE_MODES + } + } + ] + }; + + const AT_RULE_MODE = { + className: 'keyword', + begin: '@(import|media|charset|font-face|(-[a-z]+-)?keyframes|supports|document|namespace|page|viewport|host)\\b', + starts: { + end: '[;{}]', + keywords: AT_KEYWORDS, + returnEnd: true, + contains: VALUE_MODES, + relevance: 0 + } + }; + + // variable definitions and calls + const 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 + } + }; + + const 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 + { + begin: '\\b(' + TAGS.join('|') + ')\\b', + className: 'selector-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), + modes.ATTRIBUTE_SELECTOR_MODE, + { + className: 'selector-pseudo', + begin: ':(' + PSEUDO_CLASSES.join('|') + ')' + }, + { + className: 'selector-pseudo', + begin: '::(' + PSEUDO_ELEMENTS.join('|') + ')' + }, + { + 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 + ] + }; + + const PSEUDO_SELECTOR_MODE = { + begin: IDENT_RE + ':(:)?' + `(${PSEUDO_SELECTORS$1.join('|')})`, + returnBegin: true, + contains: [ SELECTOR_MODE ] + }; + + RULES.push( + hljs.C_LINE_COMMENT_MODE, + hljs.C_BLOCK_COMMENT_MODE, + AT_RULE_MODE, + VAR_RULE_MODE, + PSEUDO_SELECTOR_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: /\$[@% 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 + Audit: 2020 + */ + + /** @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]+;|&#x[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: /`]+/ + } + ] + } + ] + } + ] + }; + 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 + ')/, + end: />/, + keywords: { + name: 'style' + }, + contains: [ TAG_INTERNALS ], + starts: { + end: /<\/style>/, + returnEnd: true, + subLanguage: [ + 'css', + 'xml' + ] + } + }, + { + className: 'tag', + // See the comment in the