5172 lines
143 KiB
JavaScript
5172 lines
143 KiB
JavaScript
/*!
|
|
Highlight.js v11.0.0-beta1 (git: bc7ef3d912)
|
|
(c) 2006-2021 Ivan Sagalaev and other contributors
|
|
License: BSD-3-Clause
|
|
*/
|
|
var hljs = (function () {
|
|
'use strict';
|
|
|
|
var deepFreezeEs6 = { exports: {} };
|
|
|
|
function deepFreeze(obj) {
|
|
if (obj instanceof Map) {
|
|
obj.clear = obj.delete = obj.set = function () {
|
|
throw new Error('map is read-only');
|
|
};
|
|
} else if (obj instanceof Set) {
|
|
obj.add = obj.clear = obj.delete = function () {
|
|
throw new Error('set is read-only');
|
|
};
|
|
}
|
|
|
|
// Freeze self
|
|
Object.freeze(obj);
|
|
|
|
Object.getOwnPropertyNames(obj).forEach(function (name) {
|
|
var prop = obj[name];
|
|
|
|
// Freeze prop if it is an object
|
|
if (typeof prop == 'object' && !Object.isFrozen(prop)) {
|
|
deepFreeze(prop);
|
|
}
|
|
});
|
|
|
|
return obj;
|
|
}
|
|
|
|
deepFreezeEs6.exports = deepFreeze;
|
|
deepFreezeEs6.exports.default = deepFreeze;
|
|
|
|
var deepFreeze$1 = deepFreezeEs6.exports;
|
|
|
|
|
|
/** @typedef {import('highlight.js').CompiledMode} CompiledMode */
|
|
/** @implements CallbackResponse */
|
|
|
|
class Response {
|
|
/**
|
|
* @param {CompiledMode} mode
|
|
*/
|
|
constructor(mode) {
|
|
// eslint-disable-next-line no-undefined
|
|
if (mode.data === undefined) mode.data = {};
|
|
|
|
this.data = mode.data;
|
|
this.isMatchIgnored = false;
|
|
}
|
|
|
|
ignoreMatch() {
|
|
this.isMatchIgnored = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {string} value
|
|
* @returns {string}
|
|
*/
|
|
function escapeHTML(value) {
|
|
return value
|
|
.replace(/&/g, '&')
|
|
.replace(/</g, '<')
|
|
.replace(/>/g, '>')
|
|
.replace(/"/g, '"')
|
|
.replace(/'/g, ''');
|
|
}
|
|
|
|
/**
|
|
* performs a shallow merge of multiple objects into one
|
|
*
|
|
* @template T
|
|
* @param {T} original
|
|
* @param {Record<string,any>[]} objects
|
|
* @returns {T} a single new object
|
|
*/
|
|
function inherit$1(original, ...objects) {
|
|
/** @type Record<string,any> */
|
|
const result = Object.create(null);
|
|
|
|
for (const key in original) {
|
|
result[key] = original[key];
|
|
}
|
|
objects.forEach(function (obj) {
|
|
for (const key in obj) {
|
|
result[key] = obj[key];
|
|
}
|
|
});
|
|
return /** @type {T} */ (result);
|
|
}
|
|
|
|
/**
|
|
* @typedef {object} Renderer
|
|
* @property {(text: string) => void} addText
|
|
* @property {(node: Node) => void} openNode
|
|
* @property {(node: Node) => void} closeNode
|
|
* @property {() => string} value
|
|
*/
|
|
|
|
/** @typedef {{kind?: string, sublanguage?: boolean}} Node */
|
|
/** @typedef {{walk: (r: Renderer) => void}} Tree */
|
|
/** */
|
|
|
|
const SPAN_CLOSE = '</span>';
|
|
|
|
/**
|
|
* Determines if a node needs to be wrapped in <span>
|
|
*
|
|
* @param {Node} node */
|
|
const emitsWrappingTags = (node) => {
|
|
return !!node.kind;
|
|
};
|
|
|
|
/**
|
|
*
|
|
* @param {string} name
|
|
* @param {{prefix:string}} options
|
|
*/
|
|
const expandScopeName = (name, { prefix }) => {
|
|
if (name.includes(".")) {
|
|
const pieces = name.split(".");
|
|
return [
|
|
`${prefix}${pieces.shift()}`,
|
|
...(pieces.map((x, i) => `${x}${"_".repeat(i + 1)}`))
|
|
].join(" ");
|
|
}
|
|
return `${prefix}${name}`;
|
|
};
|
|
|
|
/** @type {Renderer} */
|
|
class HTMLRenderer {
|
|
/**
|
|
* Creates a new HTMLRenderer
|
|
*
|
|
* @param {Tree} parseTree - the parse tree (must support `walk` API)
|
|
* @param {{classPrefix: string}} options
|
|
*/
|
|
constructor(parseTree, options) {
|
|
this.buffer = "";
|
|
this.classPrefix = options.classPrefix;
|
|
parseTree.walk(this);
|
|
}
|
|
|
|
/**
|
|
* Adds texts to the output stream
|
|
*
|
|
* @param {string} text */
|
|
addText(text) {
|
|
this.buffer += escapeHTML(text);
|
|
}
|
|
|
|
/**
|
|
* Adds a node open to the output stream (if needed)
|
|
*
|
|
* @param {Node} node */
|
|
openNode(node) {
|
|
if (!emitsWrappingTags(node)) return;
|
|
|
|
let scope = node.kind;
|
|
if (node.sublanguage) {
|
|
scope = `language-${scope}`;
|
|
} else {
|
|
scope = expandScopeName(scope, { prefix: this.classPrefix });
|
|
}
|
|
this.span(scope);
|
|
}
|
|
|
|
/**
|
|
* Adds a node close to the output stream (if needed)
|
|
*
|
|
* @param {Node} node */
|
|
closeNode(node) {
|
|
if (!emitsWrappingTags(node)) return;
|
|
|
|
this.buffer += SPAN_CLOSE;
|
|
}
|
|
|
|
/**
|
|
* returns the accumulated buffer
|
|
*/
|
|
value() {
|
|
return this.buffer;
|
|
}
|
|
|
|
// helpers
|
|
|
|
/**
|
|
* Builds a span element
|
|
*
|
|
* @param {string} className */
|
|
span(className) {
|
|
this.buffer += `<span class="${className}">`;
|
|
}
|
|
}
|
|
|
|
/** @typedef {{kind?: string, sublanguage?: boolean, children: Node[]} | string} Node */
|
|
/** @typedef {{kind?: string, sublanguage?: boolean, children: Node[]} } DataNode */
|
|
/** @typedef {import('highlight.js').Emitter} Emitter */
|
|
/** */
|
|
|
|
class TokenTree {
|
|
constructor() {
|
|
/** @type DataNode */
|
|
this.rootNode = { children: [] };
|
|
this.stack = [this.rootNode];
|
|
}
|
|
|
|
get top() {
|
|
return this.stack[this.stack.length - 1];
|
|
}
|
|
|
|
get root() { return this.rootNode; }
|
|
|
|
/** @param {Node} node */
|
|
add(node) {
|
|
this.top.children.push(node);
|
|
}
|
|
|
|
/** @param {string} kind */
|
|
openNode(kind) {
|
|
/** @type Node */
|
|
const node = { kind, children: [] };
|
|
this.add(node);
|
|
this.stack.push(node);
|
|
}
|
|
|
|
closeNode() {
|
|
if (this.stack.length > 1) {
|
|
return this.stack.pop();
|
|
}
|
|
// eslint-disable-next-line no-undefined
|
|
return undefined;
|
|
}
|
|
|
|
closeAllNodes() {
|
|
while (this.closeNode());
|
|
}
|
|
|
|
toJSON() {
|
|
return JSON.stringify(this.rootNode, null, 4);
|
|
}
|
|
|
|
/**
|
|
* @typedef { import("./html_renderer").Renderer } Renderer
|
|
* @param {Renderer} builder
|
|
*/
|
|
walk(builder) {
|
|
// this does not
|
|
return this.constructor._walk(builder, this.rootNode);
|
|
// this works
|
|
// return TokenTree._walk(builder, this.rootNode);
|
|
}
|
|
|
|
/**
|
|
* @param {Renderer} builder
|
|
* @param {Node} node
|
|
*/
|
|
static _walk(builder, node) {
|
|
if (typeof node === "string") {
|
|
builder.addText(node);
|
|
} else if (node.children) {
|
|
builder.openNode(node);
|
|
node.children.forEach((child) => this._walk(builder, child));
|
|
builder.closeNode(node);
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/**
|
|
* @param {Node} node
|
|
*/
|
|
static _collapse(node) {
|
|
if (typeof node === "string") return;
|
|
if (!node.children) return;
|
|
|
|
if (node.children.every(el => typeof el === "string")) {
|
|
// node.text = node.children.join("");
|
|
// delete node.children;
|
|
node.children = [node.children.join("")];
|
|
} else {
|
|
node.children.forEach((child) => {
|
|
TokenTree._collapse(child);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
Currently this is all private API, but this is the minimal API necessary
|
|
that an Emitter must implement to fully support the parser.
|
|
|
|
Minimal interface:
|
|
|
|
- addKeyword(text, kind)
|
|
- addText(text)
|
|
- addSublanguage(emitter, subLanguageName)
|
|
- finalize()
|
|
- openNode(kind)
|
|
- closeNode()
|
|
- closeAllNodes()
|
|
- toHTML()
|
|
|
|
*/
|
|
|
|
/**
|
|
* @implements {Emitter}
|
|
*/
|
|
class TokenTreeEmitter extends TokenTree {
|
|
/**
|
|
* @param {*} options
|
|
*/
|
|
constructor(options) {
|
|
super();
|
|
this.options = options;
|
|
}
|
|
|
|
/**
|
|
* @param {string} text
|
|
* @param {string} kind
|
|
*/
|
|
addKeyword(text, kind) {
|
|
if (text === "") { return; }
|
|
|
|
this.openNode(kind);
|
|
this.addText(text);
|
|
this.closeNode();
|
|
}
|
|
|
|
/**
|
|
* @param {string} text
|
|
*/
|
|
addText(text) {
|
|
if (text === "") { return; }
|
|
|
|
this.add(text);
|
|
}
|
|
|
|
/**
|
|
* @param {Emitter & {root: DataNode}} emitter
|
|
* @param {string} name
|
|
*/
|
|
addSublanguage(emitter, name) {
|
|
/** @type DataNode */
|
|
const node = emitter.root;
|
|
node.kind = name;
|
|
node.sublanguage = true;
|
|
this.add(node);
|
|
}
|
|
|
|
toHTML() {
|
|
const renderer = new HTMLRenderer(this, this.options);
|
|
return renderer.value();
|
|
}
|
|
|
|
finalize() {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {string} value
|
|
* @returns {RegExp}
|
|
* */
|
|
|
|
/**
|
|
* @param {RegExp | string } re
|
|
* @returns {string}
|
|
*/
|
|
function source(re) {
|
|
if (!re) return null;
|
|
if (typeof re === "string") return re;
|
|
|
|
return re.source;
|
|
}
|
|
|
|
/**
|
|
* @param {RegExp | string } re
|
|
* @returns {string}
|
|
*/
|
|
function lookahead(re) {
|
|
return concat('(?=', re, ')');
|
|
}
|
|
|
|
/**
|
|
* @param {RegExp | string } re
|
|
* @returns {string}
|
|
*/
|
|
function optional(re) {
|
|
return concat('(?:', re, ')?');
|
|
}
|
|
|
|
/**
|
|
* @param {...(RegExp | string) } args
|
|
* @returns {string}
|
|
*/
|
|
function concat(...args) {
|
|
const joined = args.map((x) => source(x)).join("");
|
|
return joined;
|
|
}
|
|
|
|
function stripOptionsFromArgs(args) {
|
|
const opts = args[args.length - 1];
|
|
|
|
if (typeof opts === 'object' && opts.constructor === Object) {
|
|
args.splice(args.length - 1, 1);
|
|
return opts;
|
|
} else {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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 opts = stripOptionsFromArgs(args);
|
|
const joined = '(' +
|
|
(opts.capture ? "" : "?:") +
|
|
args.map((x) => source(x)).join("|") + ")";
|
|
return joined;
|
|
}
|
|
|
|
/**
|
|
* @param {RegExp} re
|
|
* @returns {number}
|
|
*/
|
|
function countMatchGroups(re) {
|
|
return (new RegExp(re.toString() + '|')).exec('').length - 1;
|
|
}
|
|
|
|
/**
|
|
* Does lexeme start with a regular expression match at the beginning
|
|
* @param {RegExp} re
|
|
* @param {string} lexeme
|
|
*/
|
|
function startsWith(re, lexeme) {
|
|
const match = re && re.exec(lexeme);
|
|
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]*)|\\./;
|
|
|
|
// **INTERNAL** Not intended for outside usage
|
|
// 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
|
|
// match group, keeping track of the sequencing of those match groups
|
|
// is currently an exercise for the caller. :-)
|
|
/**
|
|
* @param {(string | RegExp)[]} regexps
|
|
* @param {{joinWith: string}} opts
|
|
* @returns {string}
|
|
*/
|
|
function _rewriteBackreferences(regexps, { joinWith }) {
|
|
let numCaptures = 0;
|
|
|
|
return regexps.map((regex) => {
|
|
numCaptures += 1;
|
|
const offset = numCaptures;
|
|
let re = source(regex);
|
|
let out = '';
|
|
|
|
while (re.length > 0) {
|
|
const match = BACKREF_RE.exec(re);
|
|
if (!match) {
|
|
out += re;
|
|
break;
|
|
}
|
|
out += 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);
|
|
} else {
|
|
out += match[0];
|
|
if (match[0] === '(') {
|
|
numCaptures++;
|
|
}
|
|
}
|
|
}
|
|
return out;
|
|
}).map(re => `(${re})`).join(joinWith);
|
|
}
|
|
|
|
/** @typedef {import('highlight.js').Mode} Mode */
|
|
/** @typedef {import('highlight.js').ModeCallback} ModeCallback */
|
|
|
|
// Common regexps
|
|
const MATCH_NOTHING_RE = /\b\B/;
|
|
const IDENT_RE$1 = '[a-zA-Z]\\w*';
|
|
const UNDERSCORE_IDENT_RE = '[a-zA-Z_]\\w*';
|
|
const NUMBER_RE = '\\b\\d+(\\.\\d+)?';
|
|
const C_NUMBER_RE = '(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)'; // 0x..., 0..., decimal, float
|
|
const BINARY_NUMBER_RE = '\\b(0b[01]+)'; // 0b...
|
|
const RE_STARTERS_RE = '!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~';
|
|
|
|
/**
|
|
* @param { Partial<Mode> & {binary?: string | RegExp} } opts
|
|
*/
|
|
const SHEBANG = (opts = {}) => {
|
|
const beginShebang = /^#![ ]*\//;
|
|
if (opts.binary) {
|
|
opts.begin = concat(
|
|
beginShebang,
|
|
/.*\b/,
|
|
opts.binary,
|
|
/\b.*/);
|
|
}
|
|
return inherit$1({
|
|
scope: 'meta',
|
|
begin: beginShebang,
|
|
end: /$/,
|
|
relevance: 0,
|
|
/** @type {ModeCallback} */
|
|
"on:begin": (m, resp) => {
|
|
if (m.index !== 0) resp.ignoreMatch();
|
|
}
|
|
}, opts);
|
|
};
|
|
|
|
// Common modes
|
|
const BACKSLASH_ESCAPE = {
|
|
begin: '\\\\[\\s\\S]', relevance: 0
|
|
};
|
|
const APOS_STRING_MODE = {
|
|
scope: 'string',
|
|
begin: '\'',
|
|
end: '\'',
|
|
illegal: '\\n',
|
|
contains: [BACKSLASH_ESCAPE]
|
|
};
|
|
const QUOTE_STRING_MODE = {
|
|
scope: 'string',
|
|
begin: '"',
|
|
end: '"',
|
|
illegal: '\\n',
|
|
contains: [BACKSLASH_ESCAPE]
|
|
};
|
|
const PHRASAL_WORDS_MODE = {
|
|
begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
|
|
};
|
|
/**
|
|
* Creates a comment mode
|
|
*
|
|
* @param {string | RegExp} begin
|
|
* @param {string | RegExp} end
|
|
* @param {Mode | {}} [modeOptions]
|
|
* @returns {Partial<Mode>}
|
|
*/
|
|
const COMMENT = function (begin, end, modeOptions = {}) {
|
|
const mode = inherit$1(
|
|
{
|
|
scope: 'comment',
|
|
begin,
|
|
end,
|
|
contains: []
|
|
},
|
|
modeOptions
|
|
);
|
|
mode.contains.push({
|
|
scope: 'doctag',
|
|
// hack to avoid the space from being included. the space is necessary to
|
|
// match here to prevent the plain text rule below from gobbling up doctags
|
|
begin: '[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)',
|
|
end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
|
|
excludeBegin: true,
|
|
relevance: 0
|
|
});
|
|
const ENGLISH_WORD = either(
|
|
// list of common 1 and 2 letter words in English
|
|
"I",
|
|
"a",
|
|
"is",
|
|
"so",
|
|
"us",
|
|
"to",
|
|
"at",
|
|
"if",
|
|
"in",
|
|
"it",
|
|
"on",
|
|
// note: this is not an exhaustive list of contractions, just popular ones
|
|
/[A-Za-z]+['](d|ve|re|ll|t|s|n)/, // contractions - can't we'd they're let's, etc
|
|
/[A-Za-z]+[-][a-z]+/, // `no-way`, etc.
|
|
/[A-Za-z][a-z]{2,}/ // allow capitalized words at beginning of sentences
|
|
);
|
|
// looking like plain text, more likely to be a comment
|
|
mode.contains.push(
|
|
{
|
|
// TODO: how to include ", (, ) without breaking grammars that use these for
|
|
// comment delimiters?
|
|
// begin: /[ ]+([()"]?([A-Za-z'-]{3,}|is|a|I|so|us|[tT][oO]|at|if|in|it|on)[.]?[()":]?([.][ ]|[ ]|\))){3}/
|
|
// ---
|
|
|
|
// this tries to find sequences of 3 english words in a row (without any
|
|
// "programming" type syntax) this gives us a strong signal that we've
|
|
// TRULY found a comment - vs perhaps scanning with the wrong language.
|
|
// It's possible to find something that LOOKS like the start of the
|
|
// comment - but then if there is no readable text - good chance it is a
|
|
// false match and not a comment.
|
|
//
|
|
// for a visual example please see:
|
|
// https://github.com/highlightjs/highlight.js/issues/2827
|
|
|
|
begin: concat(
|
|
/[ ]+/, // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
|
|
'(',
|
|
ENGLISH_WORD,
|
|
/[.]?[:]?([.][ ]|[ ])/,
|
|
'){3}') // look for 3 words in a row
|
|
}
|
|
);
|
|
return mode;
|
|
};
|
|
const C_LINE_COMMENT_MODE = COMMENT('//', '$');
|
|
const C_BLOCK_COMMENT_MODE = COMMENT('/\\*', '\\*/');
|
|
const HASH_COMMENT_MODE = COMMENT('#', '$');
|
|
const NUMBER_MODE = {
|
|
scope: 'number',
|
|
begin: NUMBER_RE,
|
|
relevance: 0
|
|
};
|
|
const C_NUMBER_MODE = {
|
|
scope: 'number',
|
|
begin: C_NUMBER_RE,
|
|
relevance: 0
|
|
};
|
|
const BINARY_NUMBER_MODE = {
|
|
scope: 'number',
|
|
begin: BINARY_NUMBER_RE,
|
|
relevance: 0
|
|
};
|
|
const REGEXP_MODE = {
|
|
// this outer rule makes sure we actually have a WHOLE regex and not simply
|
|
// an expression such as:
|
|
//
|
|
// 3 / something
|
|
//
|
|
// (which will then blow up when regex's `illegal` sees the newline)
|
|
begin: /(?=\/[^/\n]*\/)/,
|
|
contains: [{
|
|
scope: 'regexp',
|
|
begin: /\//,
|
|
end: /\/[gimuy]*/,
|
|
illegal: /\n/,
|
|
contains: [
|
|
BACKSLASH_ESCAPE,
|
|
{
|
|
begin: /\[/,
|
|
end: /\]/,
|
|
relevance: 0,
|
|
contains: [BACKSLASH_ESCAPE]
|
|
}
|
|
]
|
|
}]
|
|
};
|
|
const TITLE_MODE = {
|
|
scope: 'title',
|
|
begin: IDENT_RE$1,
|
|
relevance: 0
|
|
};
|
|
const UNDERSCORE_TITLE_MODE = {
|
|
scope: 'title',
|
|
begin: UNDERSCORE_IDENT_RE,
|
|
relevance: 0
|
|
};
|
|
const METHOD_GUARD = {
|
|
// excludes method names from keyword processing
|
|
begin: '\\.\\s*' + UNDERSCORE_IDENT_RE,
|
|
relevance: 0
|
|
};
|
|
|
|
/**
|
|
* Adds end same as begin mechanics to a mode
|
|
*
|
|
* Your mode must include at least a single () match group as that first match
|
|
* group is what is used for comparison
|
|
* @param {Partial<Mode>} mode
|
|
*/
|
|
const END_SAME_AS_BEGIN = function (mode) {
|
|
return Object.assign(mode,
|
|
{
|
|
/** @type {ModeCallback} */
|
|
'on:begin': (m, resp) => { resp.data._beginMatch = m[1]; },
|
|
/** @type {ModeCallback} */
|
|
'on:end': (m, resp) => { if (resp.data._beginMatch !== m[1]) resp.ignoreMatch(); }
|
|
});
|
|
};
|
|
|
|
var MODES$1 = /*#__PURE__*/Object.freeze({
|
|
__proto__: null,
|
|
MATCH_NOTHING_RE: MATCH_NOTHING_RE,
|
|
IDENT_RE: IDENT_RE$1,
|
|
UNDERSCORE_IDENT_RE: UNDERSCORE_IDENT_RE,
|
|
NUMBER_RE: NUMBER_RE,
|
|
C_NUMBER_RE: C_NUMBER_RE,
|
|
BINARY_NUMBER_RE: BINARY_NUMBER_RE,
|
|
RE_STARTERS_RE: RE_STARTERS_RE,
|
|
SHEBANG: SHEBANG,
|
|
BACKSLASH_ESCAPE: BACKSLASH_ESCAPE,
|
|
APOS_STRING_MODE: APOS_STRING_MODE,
|
|
QUOTE_STRING_MODE: QUOTE_STRING_MODE,
|
|
PHRASAL_WORDS_MODE: PHRASAL_WORDS_MODE,
|
|
COMMENT: COMMENT,
|
|
C_LINE_COMMENT_MODE: C_LINE_COMMENT_MODE,
|
|
C_BLOCK_COMMENT_MODE: C_BLOCK_COMMENT_MODE,
|
|
HASH_COMMENT_MODE: HASH_COMMENT_MODE,
|
|
NUMBER_MODE: NUMBER_MODE,
|
|
C_NUMBER_MODE: C_NUMBER_MODE,
|
|
BINARY_NUMBER_MODE: BINARY_NUMBER_MODE,
|
|
REGEXP_MODE: REGEXP_MODE,
|
|
TITLE_MODE: TITLE_MODE,
|
|
UNDERSCORE_TITLE_MODE: UNDERSCORE_TITLE_MODE,
|
|
METHOD_GUARD: METHOD_GUARD,
|
|
END_SAME_AS_BEGIN: END_SAME_AS_BEGIN
|
|
});
|
|
|
|
/**
|
|
@typedef {import('highlight.js').CallbackResponse} CallbackResponse
|
|
@typedef {import('highlight.js').CompilerExt} CompilerExt
|
|
*/
|
|
|
|
// Grammar extensions / plugins
|
|
// See: https://github.com/highlightjs/highlight.js/issues/2833
|
|
|
|
// Grammar extensions allow "syntactic sugar" to be added to the grammar modes
|
|
// without requiring any underlying changes to the compiler internals.
|
|
|
|
// `compileMatch` being the perfect small example of now allowing a grammar
|
|
// author to write `match` when they desire to match a single expression rather
|
|
// than being forced to use `begin`. The extension then just moves `match` into
|
|
// `begin` when it runs. Ie, no features have been added, but we've just made
|
|
// the experience of writing (and reading grammars) a little bit nicer.
|
|
|
|
// ------
|
|
|
|
// TODO: We need negative look-behind support to do this properly
|
|
/**
|
|
* Skip a match if it has a preceding dot
|
|
*
|
|
* This is used for `beginKeywords` to prevent matching expressions such as
|
|
* `bob.keyword.do()`. The mode compiler automatically wires this up as a
|
|
* special _internal_ 'on:begin' callback for modes with `beginKeywords`
|
|
* @param {RegExpMatchArray} match
|
|
* @param {CallbackResponse} response
|
|
*/
|
|
function skipIfHasPrecedingDot(match, response) {
|
|
const before = match.input[match.index - 1];
|
|
if (before === ".") {
|
|
response.ignoreMatch();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @type {CompilerExt}
|
|
*/
|
|
function scopeClassName(mode, _parent) {
|
|
// eslint-disable-next-line no-undefined
|
|
if (mode.className !== undefined) {
|
|
mode.scope = mode.className;
|
|
delete mode.className;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* `beginKeywords` syntactic sugar
|
|
* @type {CompilerExt}
|
|
*/
|
|
function beginKeywords(mode, parent) {
|
|
if (!parent) return;
|
|
if (!mode.beginKeywords) return;
|
|
|
|
// for languages with keywords that include non-word characters checking for
|
|
// a word boundary is not sufficient, so instead we check for a word boundary
|
|
// or whitespace - this does no harm in any case since our keyword engine
|
|
// doesn't allow spaces in keywords anyways and we still check for the boundary
|
|
// first
|
|
mode.begin = '\\b(' + mode.beginKeywords.split(' ').join('|') + ')(?!\\.)(?=\\b|\\s)';
|
|
mode.__beforeBegin = skipIfHasPrecedingDot;
|
|
mode.keywords = mode.keywords || mode.beginKeywords;
|
|
delete mode.beginKeywords;
|
|
|
|
// prevents double relevance, the keywords themselves provide
|
|
// relevance, the mode doesn't need to double it
|
|
// eslint-disable-next-line no-undefined
|
|
if (mode.relevance === undefined) mode.relevance = 0;
|
|
}
|
|
|
|
/**
|
|
* Allow `illegal` to contain an array of illegal values
|
|
* @type {CompilerExt}
|
|
*/
|
|
function compileIllegal(mode, _parent) {
|
|
if (!Array.isArray(mode.illegal)) return;
|
|
|
|
mode.illegal = either(...mode.illegal);
|
|
}
|
|
|
|
/**
|
|
* `match` to match a single expression for readability
|
|
* @type {CompilerExt}
|
|
*/
|
|
function compileMatch(mode, _parent) {
|
|
if (!mode.match) return;
|
|
if (mode.begin || mode.end) throw new Error("begin & end are not supported with match");
|
|
|
|
mode.begin = mode.match;
|
|
delete mode.match;
|
|
}
|
|
|
|
/**
|
|
* provides the default 1 relevance to all modes
|
|
* @type {CompilerExt}
|
|
*/
|
|
function compileRelevance(mode, _parent) {
|
|
// eslint-disable-next-line no-undefined
|
|
if (mode.relevance === undefined) mode.relevance = 1;
|
|
}
|
|
|
|
// allow beforeMatch to act as a "qualifier" for the match
|
|
// the full match begin must be [beforeMatch][begin]
|
|
const beforeMatchExt = (mode, parent) => {
|
|
if (!mode.beforeMatch) return;
|
|
// starts conflicts with endsParent which we need to make sure the child
|
|
// rule is not matched multiple times
|
|
if (mode.starts) throw new Error("beforeMatch cannot be used with starts");
|
|
|
|
const originalMode = Object.assign({}, mode);
|
|
Object.keys(mode).forEach((key) => { delete mode[key]; });
|
|
|
|
mode.keywords = originalMode.keywords;
|
|
mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin));
|
|
mode.starts = {
|
|
relevance: 0,
|
|
contains: [
|
|
Object.assign(originalMode, { endsParent: true })
|
|
]
|
|
};
|
|
mode.relevance = 0;
|
|
|
|
delete originalMode.beforeMatch;
|
|
};
|
|
|
|
// keywords that should have no default relevance value
|
|
const COMMON_KEYWORDS = [
|
|
'of',
|
|
'and',
|
|
'for',
|
|
'in',
|
|
'not',
|
|
'or',
|
|
'if',
|
|
'then',
|
|
'parent', // common variable name
|
|
'list', // common variable name
|
|
'value' // common variable name
|
|
];
|
|
|
|
const DEFAULT_KEYWORD_SCOPE = "keyword";
|
|
|
|
/**
|
|
* Given raw keywords from a language definition, compile them.
|
|
*
|
|
* @param {string | Record<string,string|string[]> | Array<string>} rawKeywords
|
|
* @param {boolean} caseInsensitive
|
|
*/
|
|
function compileKeywords(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) {
|
|
/** @type KeywordDict */
|
|
const compiledKeywords = Object.create(null);
|
|
|
|
// input can be a string of keywords, an array of keywords, or a object with
|
|
// named keys representing scopeName (which can then point to a string or array)
|
|
if (typeof rawKeywords === 'string') {
|
|
compileList(scopeName, rawKeywords.split(" "));
|
|
} else if (Array.isArray(rawKeywords)) {
|
|
compileList(scopeName, rawKeywords);
|
|
} else {
|
|
Object.keys(rawKeywords).forEach(function (scopeName) {
|
|
// collapse all our objects back into the parent object
|
|
Object.assign(
|
|
compiledKeywords,
|
|
compileKeywords(rawKeywords[scopeName], caseInsensitive, scopeName)
|
|
);
|
|
});
|
|
}
|
|
return compiledKeywords;
|
|
|
|
// ---
|
|
|
|
/**
|
|
* Compiles an individual list of keywords
|
|
*
|
|
* Ex: "for if when while|5"
|
|
*
|
|
* @param {string} scopeName
|
|
* @param {Array<string>} keywordList
|
|
*/
|
|
function compileList(scopeName, keywordList) {
|
|
if (caseInsensitive) {
|
|
keywordList = keywordList.map(x => x.toLowerCase());
|
|
}
|
|
keywordList.forEach(function (keyword) {
|
|
const pair = keyword.split('|');
|
|
compiledKeywords[pair[0]] = [scopeName, scoreForKeyword(pair[0], pair[1])];
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the proper score for a given keyword
|
|
*
|
|
* Also takes into account comment keywords, which will be scored 0 UNLESS
|
|
* another score has been manually assigned.
|
|
* @param {string} keyword
|
|
* @param {string} [providedScore]
|
|
*/
|
|
function scoreForKeyword(keyword, providedScore) {
|
|
// manual scores always win over common keywords
|
|
// so you can force a score of 1 if you really insist
|
|
if (providedScore) {
|
|
return Number(providedScore);
|
|
}
|
|
|
|
return commonKeyword(keyword) ? 0 : 1;
|
|
}
|
|
|
|
/**
|
|
* Determines if a given keyword is common or not
|
|
*
|
|
* @param {string} keyword */
|
|
function commonKeyword(keyword) {
|
|
return COMMON_KEYWORDS.includes(keyword.toLowerCase());
|
|
}
|
|
|
|
/*
|
|
|
|
For the reasoning behind this please see:
|
|
https://github.com/highlightjs/highlight.js/issues/2880#issuecomment-747275419
|
|
|
|
*/
|
|
|
|
/**
|
|
* @type {Record<string, boolean>}
|
|
*/
|
|
const seenDeprecations = {};
|
|
|
|
/**
|
|
* @param {string} message
|
|
*/
|
|
const error = (message) => {
|
|
console.error(message);
|
|
};
|
|
|
|
/**
|
|
* @param {string} message
|
|
* @param {any} args
|
|
*/
|
|
const warn = (message, ...args) => {
|
|
console.log(`WARN: ${message}`, ...args);
|
|
};
|
|
|
|
/**
|
|
* @param {string} version
|
|
* @param {string} message
|
|
*/
|
|
const deprecated = (version, message) => {
|
|
if (seenDeprecations[`${version}/${message}`]) return;
|
|
|
|
console.log(`Deprecated as of ${version}. ${message}`);
|
|
seenDeprecations[`${version}/${message}`] = true;
|
|
};
|
|
|
|
/* eslint-disable no-throw-literal */
|
|
|
|
/**
|
|
@typedef {import('highlight.js').CompiledMode} CompiledMode
|
|
*/
|
|
|
|
const MultiClassError = new Error();
|
|
|
|
/**
|
|
* Renumbers labeled scope names to account for additional inner match
|
|
* groups that otherwise would break everything.
|
|
*
|
|
* Lets say we 3 match scopes:
|
|
*
|
|
* { 1 => ..., 2 => ..., 3 => ... }
|
|
*
|
|
* So what we need is a clean match like this:
|
|
*
|
|
* (a)(b)(c) => [ "a", "b", "c" ]
|
|
*
|
|
* But this falls apart with inner match groups:
|
|
*
|
|
* (a)(((b)))(c) => ["a", "b", "b", "b", "c" ]
|
|
*
|
|
* Our scopes are now "out of alignment" and we're repeating `b` 3 times.
|
|
* What needs to happen is the numbers are remapped:
|
|
*
|
|
* { 1 => ..., 2 => ..., 5 => ... }
|
|
*
|
|
* We also need to know that the ONLY groups that should be output
|
|
* are 1, 2, and 5. This function handles this behavior.
|
|
*
|
|
* @param {CompiledMode} mode
|
|
* @param {Array<RegExp>} regexes
|
|
* @param {{key: "beginScope"|"endScope"}} opts
|
|
*/
|
|
function remapScopeNames(mode, regexes, { key }) {
|
|
let offset = 0;
|
|
const scopeNames = mode[key];
|
|
/** @type Record<number,boolean> */
|
|
const emit = {};
|
|
/** @type Record<number,string> */
|
|
const positions = {};
|
|
|
|
for (let i = 1; i <= regexes.length; i++) {
|
|
positions[i + offset] = scopeNames[i];
|
|
emit[i + offset] = true;
|
|
offset += countMatchGroups(regexes[i - 1]);
|
|
}
|
|
// we use _emit to keep track of which match groups are "top-level" to avoid double
|
|
// output from inside match groups
|
|
mode[key] = positions;
|
|
mode[key]._emit = emit;
|
|
mode[key]._multi = true;
|
|
}
|
|
|
|
/**
|
|
* @param {CompiledMode} mode
|
|
*/
|
|
function beginMultiClass(mode) {
|
|
if (!Array.isArray(mode.begin)) return;
|
|
|
|
if (mode.skip || mode.excludeBegin || mode.returnBegin) {
|
|
error("skip, excludeBegin, returnBegin not compatible with beginScope: {}");
|
|
throw MultiClassError;
|
|
}
|
|
|
|
if (typeof mode.beginScope !== "object" || mode.beginScope === null) {
|
|
error("beginScope must be object");
|
|
throw MultiClassError;
|
|
}
|
|
|
|
remapScopeNames(mode, mode.begin, { key: "beginScope" });
|
|
mode.begin = _rewriteBackreferences(mode.begin, { joinWith: "" });
|
|
}
|
|
|
|
/**
|
|
* @param {CompiledMode} mode
|
|
*/
|
|
function endMultiClass(mode) {
|
|
if (!Array.isArray(mode.end)) return;
|
|
|
|
if (mode.skip || mode.excludeEnd || mode.returnEnd) {
|
|
error("skip, excludeEnd, returnEnd not compatible with endScope: {}");
|
|
throw MultiClassError;
|
|
}
|
|
|
|
if (typeof mode.endScope !== "object" || mode.endScope === null) {
|
|
error("endScope must be object");
|
|
throw MultiClassError;
|
|
}
|
|
|
|
remapScopeNames(mode, mode.end, { key: "endScope" });
|
|
mode.end = _rewriteBackreferences(mode.end, { joinWith: "" });
|
|
}
|
|
|
|
/**
|
|
* this exists only to allow `scope: {}` to be used beside `match:`
|
|
* Otherwise `beginScope` would necessary and that would look weird
|
|
|
|
{
|
|
match: [ /def/, /\w+/ ]
|
|
scope: { 1: "keyword" , 2: "title" }
|
|
}
|
|
|
|
* @param {CompiledMode} mode
|
|
*/
|
|
function scopeSugar(mode) {
|
|
if (mode.scope && typeof mode.scope === "object" && mode.scope !== null) {
|
|
mode.beginScope = mode.scope;
|
|
delete mode.scope;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {CompiledMode} mode
|
|
*/
|
|
function MultiClass(mode) {
|
|
scopeSugar(mode);
|
|
|
|
if (typeof mode.beginScope === "string") {
|
|
mode.beginScope = { _wrap: mode.beginScope };
|
|
}
|
|
if (typeof mode.endScope === "string") {
|
|
mode.endScope = { _wrap: mode.endScope };
|
|
}
|
|
|
|
beginMultiClass(mode);
|
|
endMultiClass(mode);
|
|
}
|
|
|
|
/**
|
|
@typedef {import('highlight.js').Mode} Mode
|
|
@typedef {import('highlight.js').CompiledMode} CompiledMode
|
|
@typedef {import('highlight.js').Language} Language
|
|
@typedef {import('highlight.js').HLJSPlugin} HLJSPlugin
|
|
@typedef {import('highlight.js').CompiledLanguage} CompiledLanguage
|
|
*/
|
|
|
|
// compilation
|
|
|
|
/**
|
|
* Compiles a language definition result
|
|
*
|
|
* Given the raw result of a language definition (Language), compiles this so
|
|
* that it is ready for highlighting code.
|
|
* @param {Language} language
|
|
* @returns {CompiledLanguage}
|
|
*/
|
|
function compileLanguage(language) {
|
|
/**
|
|
* Builds a regex with the case sensitivity of the current language
|
|
*
|
|
* @param {RegExp | string} value
|
|
* @param {boolean} [global]
|
|
*/
|
|
function langRe(value, global) {
|
|
return new RegExp(
|
|
source(value),
|
|
'm' + (language.case_insensitive ? 'i' : '') + (global ? 'g' : '')
|
|
);
|
|
}
|
|
|
|
/**
|
|
Stores multiple regular expressions and allows you to quickly search for
|
|
them all in a string simultaneously - returning the first match. It does
|
|
this by creating a huge (a|b|c) regex - each individual item wrapped with ()
|
|
and joined by `|` - using match groups to track position. When a match is
|
|
found checking which position in the array has content allows us to figure
|
|
out which of the original regexes / match groups triggered the match.
|
|
|
|
The match object itself (the result of `Regex.exec`) is returned but also
|
|
enhanced by merging in any meta-data that was registered with the regex.
|
|
This is how we keep track of which mode matched, and what type of rule
|
|
(`illegal`, `begin`, end, etc).
|
|
*/
|
|
class MultiRegex {
|
|
constructor() {
|
|
this.matchIndexes = {};
|
|
// @ts-ignore
|
|
this.regexes = [];
|
|
this.matchAt = 1;
|
|
this.position = 0;
|
|
}
|
|
|
|
// @ts-ignore
|
|
addRule(re, opts) {
|
|
opts.position = this.position++;
|
|
// @ts-ignore
|
|
this.matchIndexes[this.matchAt] = opts;
|
|
this.regexes.push([opts, re]);
|
|
this.matchAt += countMatchGroups(re) + 1;
|
|
}
|
|
|
|
compile() {
|
|
if (this.regexes.length === 0) {
|
|
// avoids the need to check length every time exec is called
|
|
// @ts-ignore
|
|
this.exec = () => null;
|
|
}
|
|
const terminators = this.regexes.map(el => el[1]);
|
|
this.matcherRe = langRe(_rewriteBackreferences(terminators, { joinWith: '|' }), true);
|
|
this.lastIndex = 0;
|
|
}
|
|
|
|
/** @param {string} s */
|
|
exec(s) {
|
|
this.matcherRe.lastIndex = this.lastIndex;
|
|
const match = this.matcherRe.exec(s);
|
|
if (!match) { return null; }
|
|
|
|
// eslint-disable-next-line no-undefined
|
|
const i = match.findIndex((el, i) => i > 0 && el !== undefined);
|
|
// @ts-ignore
|
|
const matchData = this.matchIndexes[i];
|
|
// trim off any earlier non-relevant match groups (ie, the other regex
|
|
// match groups that make up the multi-matcher)
|
|
match.splice(0, i);
|
|
|
|
return Object.assign(match, matchData);
|
|
}
|
|
}
|
|
|
|
/*
|
|
Created to solve the key deficiently with MultiRegex - there is no way to
|
|
test for multiple matches at a single location. Why would we need to do
|
|
that? In the future a more dynamic engine will allow certain matches to be
|
|
ignored. An example: if we matched say the 3rd regex in a large group but
|
|
decided to ignore it - we'd need to started testing again at the 4th
|
|
regex... but MultiRegex itself gives us no real way to do that.
|
|
|
|
So what this class creates MultiRegexs on the fly for whatever search
|
|
position they are needed.
|
|
|
|
NOTE: These additional MultiRegex objects are created dynamically. For most
|
|
grammars most of the time we will never actually need anything more than the
|
|
first MultiRegex - so this shouldn't have too much overhead.
|
|
|
|
Say this is our search group, and we match regex3, but wish to ignore it.
|
|
|
|
regex1 | regex2 | regex3 | regex4 | regex5 ' ie, startAt = 0
|
|
|
|
What we need is a new MultiRegex that only includes the remaining
|
|
possibilities:
|
|
|
|
regex4 | regex5 ' ie, startAt = 3
|
|
|
|
This class wraps all that complexity up in a simple API... `startAt` decides
|
|
where in the array of expressions to start doing the matching. It
|
|
auto-increments, so if a match is found at position 2, then startAt will be
|
|
set to 3. If the end is reached startAt will return to 0.
|
|
|
|
MOST of the time the parser will be setting startAt manually to 0.
|
|
*/
|
|
class ResumableMultiRegex {
|
|
constructor() {
|
|
// @ts-ignore
|
|
this.rules = [];
|
|
// @ts-ignore
|
|
this.multiRegexes = [];
|
|
this.count = 0;
|
|
|
|
this.lastIndex = 0;
|
|
this.regexIndex = 0;
|
|
}
|
|
|
|
// @ts-ignore
|
|
getMatcher(index) {
|
|
if (this.multiRegexes[index]) return this.multiRegexes[index];
|
|
|
|
const matcher = new MultiRegex();
|
|
this.rules.slice(index).forEach(([re, opts]) => matcher.addRule(re, opts));
|
|
matcher.compile();
|
|
this.multiRegexes[index] = matcher;
|
|
return matcher;
|
|
}
|
|
|
|
resumingScanAtSamePosition() {
|
|
return this.regexIndex !== 0;
|
|
}
|
|
|
|
considerAll() {
|
|
this.regexIndex = 0;
|
|
}
|
|
|
|
// @ts-ignore
|
|
addRule(re, opts) {
|
|
this.rules.push([re, opts]);
|
|
if (opts.type === "begin") this.count++;
|
|
}
|
|
|
|
/** @param {string} s */
|
|
exec(s) {
|
|
const m = this.getMatcher(this.regexIndex);
|
|
m.lastIndex = this.lastIndex;
|
|
let result = m.exec(s);
|
|
|
|
// The following is because we have no easy way to say "resume scanning at the
|
|
// existing position but also skip the current rule ONLY". What happens is
|
|
// all prior rules are also skipped which can result in matching the wrong
|
|
// thing. Example of matching "booger":
|
|
|
|
// our matcher is [string, "booger", number]
|
|
//
|
|
// ....booger....
|
|
|
|
// if "booger" is ignored then we'd really need a regex to scan from the
|
|
// SAME position for only: [string, number] but ignoring "booger" (if it
|
|
// was the first match), a simple resume would scan ahead who knows how
|
|
// far looking only for "number", ignoring potential string matches (or
|
|
// future "booger" matches that might be valid.)
|
|
|
|
// So what we do: We execute two matchers, one resuming at the same
|
|
// position, but the second full matcher starting at the position after:
|
|
|
|
// /--- resume first regex match here (for [number])
|
|
// |/---- full match here for [string, "booger", number]
|
|
// vv
|
|
// ....booger....
|
|
|
|
// Which ever results in a match first is then used. So this 3-4 step
|
|
// process essentially allows us to say "match at this position, excluding
|
|
// a prior rule that was ignored".
|
|
//
|
|
// 1. Match "booger" first, ignore. Also proves that [string] does non match.
|
|
// 2. Resume matching for [number]
|
|
// 3. Match at index + 1 for [string, "booger", number]
|
|
// 4. If #2 and #3 result in matches, which came first?
|
|
if (this.resumingScanAtSamePosition()) {
|
|
if (result && result.index === this.lastIndex); else { // use the second matcher result
|
|
const m2 = this.getMatcher(0);
|
|
m2.lastIndex = this.lastIndex + 1;
|
|
result = m2.exec(s);
|
|
}
|
|
}
|
|
|
|
if (result) {
|
|
this.regexIndex += result.position + 1;
|
|
if (this.regexIndex === this.count) {
|
|
// wrap-around to considering all matches again
|
|
this.considerAll();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Given a mode, builds a huge ResumableMultiRegex that can be used to walk
|
|
* the content and find matches.
|
|
*
|
|
* @param {CompiledMode} mode
|
|
* @returns {ResumableMultiRegex}
|
|
*/
|
|
function buildModeRegex(mode) {
|
|
const mm = new ResumableMultiRegex();
|
|
|
|
mode.contains.forEach(term => mm.addRule(term.begin, { rule: term, type: "begin" }));
|
|
|
|
if (mode.terminatorEnd) {
|
|
mm.addRule(mode.terminatorEnd, { type: "end" });
|
|
}
|
|
if (mode.illegal) {
|
|
mm.addRule(mode.illegal, { type: "illegal" });
|
|
}
|
|
|
|
return mm;
|
|
}
|
|
|
|
/** skip vs abort vs ignore
|
|
*
|
|
* @skip - The mode is still entered and exited normally (and contains rules apply),
|
|
* but all content is held and added to the parent buffer rather than being
|
|
* output when the mode ends. Mostly used with `sublanguage` to build up
|
|
* a single large buffer than can be parsed by sublanguage.
|
|
*
|
|
* - The mode begin ands ends normally.
|
|
* - Content matched is added to the parent mode buffer.
|
|
* - The parser cursor is moved forward normally.
|
|
*
|
|
* @abort - A hack placeholder until we have ignore. Aborts the mode (as if it
|
|
* never matched) but DOES NOT continue to match subsequent `contains`
|
|
* modes. Abort is bad/suboptimal because it can result in modes
|
|
* farther down not getting applied because an earlier rule eats the
|
|
* content but then aborts.
|
|
*
|
|
* - The mode does not begin.
|
|
* - Content matched by `begin` is added to the mode buffer.
|
|
* - The parser cursor is moved forward accordingly.
|
|
*
|
|
* @ignore - Ignores the mode (as if it never matched) and continues to match any
|
|
* subsequent `contains` modes. Ignore isn't technically possible with
|
|
* the current parser implementation.
|
|
*
|
|
* - The mode does not begin.
|
|
* - Content matched by `begin` is ignored.
|
|
* - The parser cursor is not moved forward.
|
|
*/
|
|
|
|
/**
|
|
* Compiles an individual mode
|
|
*
|
|
* This can raise an error if the mode contains certain detectable known logic
|
|
* issues.
|
|
* @param {Mode} mode
|
|
* @param {CompiledMode | null} [parent]
|
|
* @returns {CompiledMode | never}
|
|
*/
|
|
function compileMode(mode, parent) {
|
|
const cmode = /** @type CompiledMode */ (mode);
|
|
if (mode.isCompiled) return cmode;
|
|
|
|
[
|
|
scopeClassName,
|
|
// do this early so compiler extensions generally don't have to worry about
|
|
// the distinction between match/begin
|
|
compileMatch,
|
|
MultiClass,
|
|
beforeMatchExt
|
|
].forEach(ext => ext(mode, parent));
|
|
|
|
language.compilerExtensions.forEach(ext => ext(mode, parent));
|
|
|
|
// __beforeBegin is considered private API, internal use only
|
|
mode.__beforeBegin = null;
|
|
|
|
[
|
|
beginKeywords,
|
|
// do this later so compiler extensions that come earlier have access to the
|
|
// raw array if they wanted to perhaps manipulate it, etc.
|
|
compileIllegal,
|
|
// default to 1 relevance if not specified
|
|
compileRelevance
|
|
].forEach(ext => ext(mode, parent));
|
|
|
|
mode.isCompiled = true;
|
|
|
|
let keywordPattern = null;
|
|
if (typeof mode.keywords === "object" && mode.keywords.$pattern) {
|
|
// we need a copy because keywords might be compiled multiple times
|
|
// so we can't go deleting $pattern from the original on the first
|
|
// pass
|
|
mode.keywords = Object.assign({}, mode.keywords);
|
|
keywordPattern = mode.keywords.$pattern;
|
|
delete mode.keywords.$pattern;
|
|
}
|
|
keywordPattern = keywordPattern || /\w+/;
|
|
|
|
if (mode.keywords) {
|
|
mode.keywords = compileKeywords(mode.keywords, language.case_insensitive);
|
|
}
|
|
|
|
cmode.keywordPatternRe = langRe(keywordPattern, true);
|
|
|
|
if (parent) {
|
|
if (!mode.begin) mode.begin = /\B|\b/;
|
|
cmode.beginRe = langRe(mode.begin);
|
|
if (!mode.end && !mode.endsWithParent) mode.end = /\B|\b/;
|
|
if (mode.end) cmode.endRe = langRe(mode.end);
|
|
cmode.terminatorEnd = source(mode.end) || '';
|
|
if (mode.endsWithParent && parent.terminatorEnd) {
|
|
cmode.terminatorEnd += (mode.end ? '|' : '') + parent.terminatorEnd;
|
|
}
|
|
}
|
|
if (mode.illegal) cmode.illegalRe = langRe(/** @type {RegExp | string} */(mode.illegal));
|
|
if (!mode.contains) mode.contains = [];
|
|
|
|
mode.contains = [].concat(...mode.contains.map(function (c) {
|
|
return expandOrCloneMode(c === 'self' ? mode : c);
|
|
}));
|
|
mode.contains.forEach(function (c) { compileMode(/** @type Mode */(c), cmode); });
|
|
|
|
if (mode.starts) {
|
|
compileMode(mode.starts, parent);
|
|
}
|
|
|
|
cmode.matcher = buildModeRegex(cmode);
|
|
return cmode;
|
|
}
|
|
|
|
if (!language.compilerExtensions) language.compilerExtensions = [];
|
|
|
|
// self is not valid at the top-level
|
|
if (language.contains && language.contains.includes('self')) {
|
|
throw new Error("ERR: contains `self` is not supported at the top-level of a language. See documentation.");
|
|
}
|
|
|
|
// we need a null object, which inherit will guarantee
|
|
language.classNameAliases = inherit$1(language.classNameAliases || {});
|
|
|
|
return compileMode(/** @type Mode */(language));
|
|
}
|
|
|
|
/**
|
|
* Determines if a mode has a dependency on it's parent or not
|
|
*
|
|
* If a mode does have a parent dependency then often we need to clone it if
|
|
* it's used in multiple places so that each copy points to the correct parent,
|
|
* where-as modes without a parent can often safely be re-used at the bottom of
|
|
* a mode chain.
|
|
*
|
|
* @param {Mode | null} mode
|
|
* @returns {boolean} - is there a dependency on the parent?
|
|
* */
|
|
function dependencyOnParent(mode) {
|
|
if (!mode) return false;
|
|
|
|
return mode.endsWithParent || dependencyOnParent(mode.starts);
|
|
}
|
|
|
|
/**
|
|
* Expands a mode or clones it if necessary
|
|
*
|
|
* This is necessary for modes with parental dependenceis (see notes on
|
|
* `dependencyOnParent`) and for nodes that have `variants` - which must then be
|
|
* exploded into their own individual modes at compile time.
|
|
*
|
|
* @param {Mode} mode
|
|
* @returns {Mode | Mode[]}
|
|
* */
|
|
function expandOrCloneMode(mode) {
|
|
if (mode.variants && !mode.cachedVariants) {
|
|
mode.cachedVariants = mode.variants.map(function (variant) {
|
|
return inherit$1(mode, { variants: null }, variant);
|
|
});
|
|
}
|
|
|
|
// EXPAND
|
|
// if we have variants then essentially "replace" the mode with the variants
|
|
// this happens in compileMode, where this function is called from
|
|
if (mode.cachedVariants) {
|
|
return mode.cachedVariants;
|
|
}
|
|
|
|
// CLONE
|
|
// if we have dependencies on parents then we need a unique
|
|
// 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 });
|
|
}
|
|
|
|
if (Object.isFrozen(mode)) {
|
|
return inherit$1(mode);
|
|
}
|
|
|
|
// no special dependency issues, just return ourselves
|
|
return mode;
|
|
}
|
|
|
|
var version = "11.0.0-beta1";
|
|
|
|
/*
|
|
Syntax highlighting with language autodetection.
|
|
https://highlightjs.org/
|
|
*/
|
|
|
|
/**
|
|
@typedef {import('highlight.js').Mode} Mode
|
|
@typedef {import('highlight.js').CompiledMode} CompiledMode
|
|
@typedef {import('highlight.js').Language} Language
|
|
@typedef {import('highlight.js').HLJSApi} HLJSApi
|
|
@typedef {import('highlight.js').HLJSPlugin} HLJSPlugin
|
|
@typedef {import('highlight.js').PluginEvent} PluginEvent
|
|
@typedef {import('highlight.js').HLJSOptions} HLJSOptions
|
|
@typedef {import('highlight.js').LanguageFn} LanguageFn
|
|
@typedef {import('highlight.js').HighlightedHTMLElement} HighlightedHTMLElement
|
|
@typedef {import('highlight.js').BeforeHighlightContext} BeforeHighlightContext
|
|
@typedef {import('highlight.js/private').MatchType} MatchType
|
|
@typedef {import('highlight.js/private').KeywordData} KeywordData
|
|
@typedef {import('highlight.js/private').EnhancedMatch} EnhancedMatch
|
|
@typedef {import('highlight.js/private').AnnotatedError} AnnotatedError
|
|
@typedef {import('highlight.js').AutoHighlightResult} AutoHighlightResult
|
|
@typedef {import('highlight.js').HighlightOptions} HighlightOptions
|
|
@typedef {import('highlight.js').HighlightResult} HighlightResult
|
|
*/
|
|
|
|
|
|
const escape = escapeHTML;
|
|
const inherit = inherit$1;
|
|
const NO_MATCH = Symbol("nomatch");
|
|
const MAX_KEYWORD_HITS = 7;
|
|
|
|
/**
|
|
* @param {any} hljs - object that is extended (legacy)
|
|
* @returns {HLJSApi}
|
|
*/
|
|
const HLJS = function (hljs) {
|
|
// Global internal variables used within the highlight.js library.
|
|
/** @type {Record<string, Language>} */
|
|
const languages = Object.create(null);
|
|
/** @type {Record<string, string>} */
|
|
const aliases = Object.create(null);
|
|
/** @type {HLJSPlugin[]} */
|
|
const plugins = [];
|
|
|
|
// safe/production mode - swallows more errors, tries to keep running
|
|
// even if a single syntax or parse hits a fatal error
|
|
let SAFE_MODE = true;
|
|
const LANGUAGE_NOT_FOUND = "Could not find the language '{}', did you forget to load/include a language module?";
|
|
/** @type {Language} */
|
|
const PLAINTEXT_LANGUAGE = { disableAutodetect: true, name: 'Plain text', contains: [] };
|
|
|
|
// Global options used when within external APIs. This is modified when
|
|
// calling the `hljs.configure` function.
|
|
/** @type HLJSOptions */
|
|
let options = {
|
|
ignoreUnescapedHTML: false,
|
|
noHighlightRe: /^(no-?highlight)$/i,
|
|
languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
|
|
classPrefix: 'hljs-',
|
|
cssSelector: 'pre code',
|
|
languages: null,
|
|
// beta configuration options, subject to change, welcome to discuss
|
|
// https://github.com/highlightjs/highlight.js/issues/1086
|
|
__emitter: TokenTreeEmitter
|
|
};
|
|
|
|
/* Utility functions */
|
|
|
|
/**
|
|
* Tests a language name to see if highlighting should be skipped
|
|
* @param {string} languageName
|
|
*/
|
|
function shouldNotHighlight(languageName) {
|
|
return options.noHighlightRe.test(languageName);
|
|
}
|
|
|
|
/**
|
|
* @param {HighlightedHTMLElement} block - the HTML element to determine language for
|
|
*/
|
|
function blockLanguage(block) {
|
|
let classes = block.className + ' ';
|
|
|
|
classes += block.parentNode ? block.parentNode.className : '';
|
|
|
|
// language-* takes precedence over non-prefixed class names.
|
|
const match = options.languageDetectRe.exec(classes);
|
|
if (match) {
|
|
const language = getLanguage(match[1]);
|
|
if (!language) {
|
|
warn(LANGUAGE_NOT_FOUND.replace("{}", match[1]));
|
|
warn("Falling back to no-highlight mode for this block.", block);
|
|
}
|
|
return language ? match[1] : 'no-highlight';
|
|
}
|
|
|
|
return classes
|
|
.split(/\s+/)
|
|
.find((_class) => shouldNotHighlight(_class) || getLanguage(_class));
|
|
}
|
|
|
|
/**
|
|
* Core highlighting function.
|
|
*
|
|
* OLD API
|
|
* highlight(lang, code, ignoreIllegals, continuation)
|
|
*
|
|
* NEW API
|
|
* highlight(code, {lang, ignoreIllegals})
|
|
*
|
|
* @param {string} codeOrLanguageName - the language to use for highlighting
|
|
* @param {string | HighlightOptions} optionsOrCode - the code to highlight
|
|
* @param {boolean} [ignoreIllegals] - whether to ignore illegal matches, default is to bail
|
|
* @param {CompiledMode} [continuation] - current continuation mode, if any
|
|
*
|
|
* @returns {HighlightResult} Result - an object that represents the result
|
|
* @property {string} language - the language name
|
|
* @property {number} relevance - the relevance score
|
|
* @property {string} value - the highlighted HTML code
|
|
* @property {string} code - the original raw code
|
|
* @property {CompiledMode} top - top of the current mode stack
|
|
* @property {boolean} illegal - indicates whether any illegal matches were found
|
|
*/
|
|
function highlight(codeOrLanguageName, optionsOrCode, ignoreIllegals, continuation) {
|
|
let code = "";
|
|
let languageName = "";
|
|
if (typeof optionsOrCode === "object") {
|
|
code = codeOrLanguageName;
|
|
ignoreIllegals = optionsOrCode.ignoreIllegals;
|
|
languageName = optionsOrCode.language;
|
|
// continuation not supported at all via the new API
|
|
// eslint-disable-next-line no-undefined
|
|
continuation = undefined;
|
|
} else {
|
|
// old API
|
|
deprecated("10.7.0", "highlight(lang, code, ...args) has been deprecated.");
|
|
deprecated("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277");
|
|
languageName = codeOrLanguageName;
|
|
code = optionsOrCode;
|
|
}
|
|
|
|
// https://github.com/highlightjs/highlight.js/issues/3149
|
|
// eslint-disable-next-line no-undefined
|
|
if (ignoreIllegals === undefined) { ignoreIllegals = true; }
|
|
|
|
/** @type {BeforeHighlightContext} */
|
|
const context = {
|
|
code,
|
|
language: languageName
|
|
};
|
|
// the plugin can change the desired language or the code to be highlighted
|
|
// just be changing the object it was passed
|
|
fire("before:highlight", context);
|
|
|
|
// a before plugin can usurp the result completely by providing it's own
|
|
// in which case we don't even need to call highlight
|
|
const result = context.result
|
|
? context.result
|
|
: _highlight(context.language, context.code, ignoreIllegals, continuation);
|
|
|
|
result.code = context.code;
|
|
// the plugin can change anything in result to suite it
|
|
fire("after:highlight", result);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* private highlight that's used internally and does not fire callbacks
|
|
*
|
|
* @param {string} languageName - the language to use for highlighting
|
|
* @param {string} codeToHighlight - the code to highlight
|
|
* @param {boolean?} [ignoreIllegals] - whether to ignore illegal matches, default is to bail
|
|
* @param {CompiledMode?} [continuation] - current continuation mode, if any
|
|
* @returns {HighlightResult} - result of the highlight operation
|
|
*/
|
|
function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) {
|
|
const keywordHits = Object.create(null);
|
|
|
|
/**
|
|
* Return keyword data if a match is a keyword
|
|
* @param {CompiledMode} mode - current mode
|
|
* @param {string} matchText - the textual match
|
|
* @returns {KeywordData | false}
|
|
*/
|
|
function keywordData(mode, matchText) {
|
|
return mode.keywords[matchText];
|
|
}
|
|
|
|
function processKeywords() {
|
|
if (!top.keywords) {
|
|
emitter.addText(modeBuffer);
|
|
return;
|
|
}
|
|
|
|
let lastIndex = 0;
|
|
top.keywordPatternRe.lastIndex = 0;
|
|
let match = top.keywordPatternRe.exec(modeBuffer);
|
|
let buf = "";
|
|
|
|
while (match) {
|
|
buf += modeBuffer.substring(lastIndex, match.index);
|
|
const word = language.case_insensitive ? match[0].toLowerCase() : match[0];
|
|
const data = keywordData(top, word);
|
|
if (data) {
|
|
const [kind, keywordRelevance] = data;
|
|
emitter.addText(buf);
|
|
buf = "";
|
|
|
|
keywordHits[word] = (keywordHits[word] || 0) + 1;
|
|
if (keywordHits[word] <= MAX_KEYWORD_HITS) relevance += keywordRelevance;
|
|
if (kind.startsWith("_")) {
|
|
// _ implied for relevance only, do not highlight
|
|
// by applying a class name
|
|
buf += match[0];
|
|
} else {
|
|
const cssClass = language.classNameAliases[kind] || kind;
|
|
emitter.addKeyword(match[0], cssClass);
|
|
}
|
|
} else {
|
|
buf += match[0];
|
|
}
|
|
lastIndex = top.keywordPatternRe.lastIndex;
|
|
match = top.keywordPatternRe.exec(modeBuffer);
|
|
}
|
|
buf += modeBuffer.substr(lastIndex);
|
|
emitter.addText(buf);
|
|
}
|
|
|
|
function processSubLanguage() {
|
|
if (modeBuffer === "") return;
|
|
/** @type HighlightResult */
|
|
let result = null;
|
|
|
|
if (typeof top.subLanguage === 'string') {
|
|
if (!languages[top.subLanguage]) {
|
|
emitter.addText(modeBuffer);
|
|
return;
|
|
}
|
|
result = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]);
|
|
continuations[top.subLanguage] = /** @type {CompiledMode} */ (result._top);
|
|
} else {
|
|
result = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null);
|
|
}
|
|
|
|
// Counting embedded language score towards the host language may be disabled
|
|
// with zeroing the containing mode relevance. Use case in point is Markdown that
|
|
// allows XML everywhere and makes every XML snippet to have a much larger Markdown
|
|
// score.
|
|
if (top.relevance > 0) {
|
|
relevance += result.relevance;
|
|
}
|
|
emitter.addSublanguage(result._emitter, result.language);
|
|
}
|
|
|
|
function processBuffer() {
|
|
if (top.subLanguage != null) {
|
|
processSubLanguage();
|
|
} else {
|
|
processKeywords();
|
|
}
|
|
modeBuffer = '';
|
|
}
|
|
|
|
/**
|
|
* @param {CompiledMode} mode
|
|
* @param {RegExpMatchArray} match
|
|
*/
|
|
function emitMultiClass(scope, match) {
|
|
let i = 1;
|
|
// eslint-disable-next-line no-undefined
|
|
while (match[i] !== undefined) {
|
|
if (!scope._emit[i]) { i++; continue; }
|
|
const klass = language.classNameAliases[scope[i]] || scope[i];
|
|
const text = match[i];
|
|
if (klass) {
|
|
emitter.addKeyword(text, klass);
|
|
} else {
|
|
modeBuffer = text;
|
|
processKeywords();
|
|
modeBuffer = "";
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {CompiledMode} mode - new mode to start
|
|
* @param {RegExpMatchArray} match
|
|
*/
|
|
function startNewMode(mode, match) {
|
|
if (mode.scope && typeof mode.scope === "string") {
|
|
emitter.openNode(language.classNameAliases[mode.scope] || mode.scope);
|
|
}
|
|
if (mode.beginScope) {
|
|
// beginScope just wraps the begin match itself in a scope
|
|
if (mode.beginScope._wrap) {
|
|
emitter.addKeyword(modeBuffer, language.classNameAliases[mode.beginScope._wrap] || mode.beginScope._wrap);
|
|
modeBuffer = "";
|
|
} else if (mode.beginScope._multi) {
|
|
// at this point modeBuffer should just be the match
|
|
emitMultiClass(mode.beginScope, match);
|
|
modeBuffer = "";
|
|
}
|
|
}
|
|
|
|
top = Object.create(mode, { parent: { value: top } });
|
|
return top;
|
|
}
|
|
|
|
/**
|
|
* @param {CompiledMode } mode - the mode to potentially end
|
|
* @param {RegExpMatchArray} match - the latest match
|
|
* @param {string} matchPlusRemainder - match plus remainder of content
|
|
* @returns {CompiledMode | void} - the next mode, or if void continue on in current mode
|
|
*/
|
|
function endOfMode(mode, match, matchPlusRemainder) {
|
|
let matched = startsWith(mode.endRe, matchPlusRemainder);
|
|
|
|
if (matched) {
|
|
if (mode["on:end"]) {
|
|
const resp = new Response(mode);
|
|
mode["on:end"](match, resp);
|
|
if (resp.isMatchIgnored) matched = false;
|
|
}
|
|
|
|
if (matched) {
|
|
while (mode.endsParent && mode.parent) {
|
|
mode = mode.parent;
|
|
}
|
|
return mode;
|
|
}
|
|
}
|
|
// even if on:end fires an `ignore` it's still possible
|
|
// that we might trigger the end node because of a parent mode
|
|
if (mode.endsWithParent) {
|
|
return endOfMode(mode.parent, match, matchPlusRemainder);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handle matching but then ignoring a sequence of text
|
|
*
|
|
* @param {string} lexeme - string containing full match text
|
|
*/
|
|
function doIgnore(lexeme) {
|
|
if (top.matcher.regexIndex === 0) {
|
|
// no more regexes to potentially match here, so we move the cursor forward one
|
|
// space
|
|
modeBuffer += lexeme[0];
|
|
return 1;
|
|
} else {
|
|
// no need to move the cursor, we still have additional regexes to try and
|
|
// match at this very spot
|
|
resumeScanAtSamePosition = true;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handle the start of a new potential mode match
|
|
*
|
|
* @param {EnhancedMatch} match - the current match
|
|
* @returns {number} how far to advance the parse cursor
|
|
*/
|
|
function doBeginMatch(match) {
|
|
const lexeme = match[0];
|
|
const newMode = match.rule;
|
|
|
|
const resp = new Response(newMode);
|
|
// first internal before callbacks, then the public ones
|
|
const beforeCallbacks = [newMode.__beforeBegin, newMode["on:begin"]];
|
|
for (const cb of beforeCallbacks) {
|
|
if (!cb) continue;
|
|
cb(match, resp);
|
|
if (resp.isMatchIgnored) return doIgnore(lexeme);
|
|
}
|
|
|
|
if (newMode.skip) {
|
|
modeBuffer += lexeme;
|
|
} else {
|
|
if (newMode.excludeBegin) {
|
|
modeBuffer += lexeme;
|
|
}
|
|
processBuffer();
|
|
if (!newMode.returnBegin && !newMode.excludeBegin) {
|
|
modeBuffer = lexeme;
|
|
}
|
|
}
|
|
startNewMode(newMode, match);
|
|
return newMode.returnBegin ? 0 : lexeme.length;
|
|
}
|
|
|
|
/**
|
|
* Handle the potential end of mode
|
|
*
|
|
* @param {RegExpMatchArray} match - the current match
|
|
*/
|
|
function doEndMatch(match) {
|
|
const lexeme = match[0];
|
|
const matchPlusRemainder = codeToHighlight.substr(match.index);
|
|
|
|
const endMode = endOfMode(top, match, matchPlusRemainder);
|
|
if (!endMode) { return NO_MATCH; }
|
|
|
|
const origin = top;
|
|
if (top.endScope && top.endScope._wrap) {
|
|
processBuffer();
|
|
emitter.addKeyword(lexeme, top.endScope._wrap);
|
|
} else if (top.endScope && top.endScope._multi) {
|
|
processBuffer();
|
|
emitMultiClass(top.endScope, match);
|
|
} else if (origin.skip) {
|
|
modeBuffer += lexeme;
|
|
} else {
|
|
if (!(origin.returnEnd || origin.excludeEnd)) {
|
|
modeBuffer += lexeme;
|
|
}
|
|
processBuffer();
|
|
if (origin.excludeEnd) {
|
|
modeBuffer = lexeme;
|
|
}
|
|
}
|
|
do {
|
|
if (top.scope && !top.isMultiClass) {
|
|
emitter.closeNode();
|
|
}
|
|
if (!top.skip && !top.subLanguage) {
|
|
relevance += top.relevance;
|
|
}
|
|
top = top.parent;
|
|
} while (top !== endMode.parent);
|
|
if (endMode.starts) {
|
|
startNewMode(endMode.starts, match);
|
|
}
|
|
return origin.returnEnd ? 0 : lexeme.length;
|
|
}
|
|
|
|
function processContinuations() {
|
|
const list = [];
|
|
for (let current = top; current !== language; current = current.parent) {
|
|
if (current.scope) {
|
|
list.unshift(current.scope);
|
|
}
|
|
}
|
|
list.forEach(item => emitter.openNode(item));
|
|
}
|
|
|
|
/** @type {{type?: MatchType, index?: number, rule?: Mode}}} */
|
|
let lastMatch = {};
|
|
|
|
/**
|
|
* Process an individual match
|
|
*
|
|
* @param {string} textBeforeMatch - text preceding the match (since the last match)
|
|
* @param {EnhancedMatch} [match] - the match itself
|
|
*/
|
|
function processLexeme(textBeforeMatch, match) {
|
|
const lexeme = match && match[0];
|
|
|
|
// add non-matched text to the current mode buffer
|
|
modeBuffer += textBeforeMatch;
|
|
|
|
if (lexeme == null) {
|
|
processBuffer();
|
|
return 0;
|
|
}
|
|
|
|
// we've found a 0 width match and we're stuck, so we need to advance
|
|
// this happens when we have badly behaved rules that have optional matchers to the degree that
|
|
// sometimes they can end up matching nothing at all
|
|
// Ref: https://github.com/highlightjs/highlight.js/issues/2140
|
|
if (lastMatch.type === "begin" && match.type === "end" && lastMatch.index === match.index && lexeme === "") {
|
|
// spit the "skipped" character that our regex choked on back into the output sequence
|
|
modeBuffer += codeToHighlight.slice(match.index, match.index + 1);
|
|
if (!SAFE_MODE) {
|
|
/** @type {AnnotatedError} */
|
|
const err = new Error(`0 width match regex (${languageName})`);
|
|
err.languageName = languageName;
|
|
err.badRule = lastMatch.rule;
|
|
throw err;
|
|
}
|
|
return 1;
|
|
}
|
|
lastMatch = match;
|
|
|
|
if (match.type === "begin") {
|
|
return doBeginMatch(match);
|
|
} else if (match.type === "illegal" && !ignoreIllegals) {
|
|
// illegal match, we do not continue processing
|
|
/** @type {AnnotatedError} */
|
|
const err = new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.scope || '<unnamed>') + '"');
|
|
err.mode = top;
|
|
throw err;
|
|
} else if (match.type === "end") {
|
|
const processed = doEndMatch(match);
|
|
if (processed !== NO_MATCH) {
|
|
return processed;
|
|
}
|
|
}
|
|
|
|
// edge case for when illegal matches $ (end of line) which is technically
|
|
// a 0 width match but not a begin/end match so it's not caught by the
|
|
// first handler (when ignoreIllegals is true)
|
|
if (match.type === "illegal" && lexeme === "") {
|
|
// advance so we aren't stuck in an infinite loop
|
|
return 1;
|
|
}
|
|
|
|
// infinite loops are BAD, this is a last ditch catch all. if we have a
|
|
// decent number of iterations yet our index (cursor position in our
|
|
// parsing) still 3x behind our index then something is very wrong
|
|
// so we bail
|
|
if (iterations > 100000 && iterations > match.index * 3) {
|
|
const err = new Error('potential infinite loop, way more iterations than matches');
|
|
throw err;
|
|
}
|
|
|
|
/*
|
|
Why might be find ourselves here? An potential end match that was
|
|
triggered but could not be completed. IE, `doEndMatch` returned NO_MATCH.
|
|
(this could be because a callback requests the match be ignored, etc)
|
|
|
|
This causes no real harm other than stopping a few times too many.
|
|
*/
|
|
|
|
modeBuffer += lexeme;
|
|
return lexeme.length;
|
|
}
|
|
|
|
const language = getLanguage(languageName);
|
|
if (!language) {
|
|
error(LANGUAGE_NOT_FOUND.replace("{}", languageName));
|
|
throw new Error('Unknown language: "' + languageName + '"');
|
|
}
|
|
|
|
const md = compileLanguage(language);
|
|
let result = '';
|
|
/** @type {CompiledMode} */
|
|
let top = continuation || md;
|
|
/** @type Record<string,CompiledMode> */
|
|
const continuations = {}; // keep continuations for sub-languages
|
|
const emitter = new options.__emitter(options);
|
|
processContinuations();
|
|
let modeBuffer = '';
|
|
let relevance = 0;
|
|
let index = 0;
|
|
let iterations = 0;
|
|
let resumeScanAtSamePosition = false;
|
|
|
|
try {
|
|
top.matcher.considerAll();
|
|
|
|
for (; ;) {
|
|
iterations++;
|
|
if (resumeScanAtSamePosition) {
|
|
// only regexes not matched previously will now be
|
|
// considered for a potential match
|
|
resumeScanAtSamePosition = false;
|
|
} else {
|
|
top.matcher.considerAll();
|
|
}
|
|
top.matcher.lastIndex = index;
|
|
|
|
const match = top.matcher.exec(codeToHighlight);
|
|
// console.log("match", match[0], match.rule && match.rule.begin)
|
|
|
|
if (!match) break;
|
|
|
|
const beforeMatch = codeToHighlight.substring(index, match.index);
|
|
const processedCount = processLexeme(beforeMatch, match);
|
|
index = match.index + processedCount;
|
|
}
|
|
processLexeme(codeToHighlight.substr(index));
|
|
emitter.closeAllNodes();
|
|
emitter.finalize();
|
|
result = emitter.toHTML();
|
|
|
|
return {
|
|
language: languageName,
|
|
value: result,
|
|
relevance: relevance,
|
|
illegal: false,
|
|
_emitter: emitter,
|
|
_top: top
|
|
};
|
|
} catch (err) {
|
|
if (err.message && err.message.includes('Illegal')) {
|
|
return {
|
|
language: languageName,
|
|
value: escape(codeToHighlight),
|
|
illegal: true,
|
|
relevance: 0,
|
|
_illegalBy: {
|
|
message: err.message,
|
|
index: index,
|
|
context: codeToHighlight.slice(index - 100, index + 100),
|
|
mode: err.mode,
|
|
resultSoFar: result
|
|
},
|
|
_emitter: emitter
|
|
};
|
|
} else if (SAFE_MODE) {
|
|
return {
|
|
language: languageName,
|
|
value: escape(codeToHighlight),
|
|
illegal: false,
|
|
relevance: 0,
|
|
errorRaised: err,
|
|
_emitter: emitter,
|
|
_top: top
|
|
};
|
|
} else {
|
|
throw err;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* returns a valid highlight result, without actually doing any actual work,
|
|
* auto highlight starts with this and it's possible for small snippets that
|
|
* auto-detection may not find a better match
|
|
* @param {string} code
|
|
* @returns {HighlightResult}
|
|
*/
|
|
function justTextHighlightResult(code) {
|
|
const result = {
|
|
value: escape(code),
|
|
illegal: false,
|
|
relevance: 0,
|
|
_top: PLAINTEXT_LANGUAGE,
|
|
_emitter: new options.__emitter(options)
|
|
};
|
|
result._emitter.addText(code);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
Highlighting with language detection. Accepts a string with the code to
|
|
highlight. Returns an object with the following properties:
|
|
|
|
- language (detected language)
|
|
- relevance (int)
|
|
- value (an HTML string with highlighting markup)
|
|
- secondBest (object with the same structure for second-best heuristically
|
|
detected language, may be absent)
|
|
|
|
@param {string} code
|
|
@param {Array<string>} [languageSubset]
|
|
@returns {AutoHighlightResult}
|
|
*/
|
|
function highlightAuto(code, languageSubset) {
|
|
languageSubset = languageSubset || options.languages || Object.keys(languages);
|
|
const plaintext = justTextHighlightResult(code);
|
|
|
|
const results = languageSubset.filter(getLanguage).filter(autoDetection).map(name =>
|
|
_highlight(name, code, false)
|
|
);
|
|
results.unshift(plaintext); // plaintext is always an option
|
|
|
|
const sorted = results.sort((a, b) => {
|
|
// sort base on relevance
|
|
if (a.relevance !== b.relevance) return b.relevance - a.relevance;
|
|
|
|
// always award the tie to the base language
|
|
// ie if C++ and Arduino are tied, it's more likely to be C++
|
|
if (a.language && b.language) {
|
|
if (getLanguage(a.language).supersetOf === b.language) {
|
|
return 1;
|
|
} else if (getLanguage(b.language).supersetOf === a.language) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// otherwise say they are equal, which has the effect of sorting on
|
|
// relevance while preserving the original ordering - which is how ties
|
|
// have historically been settled, ie the language that comes first always
|
|
// wins in the case of a tie
|
|
return 0;
|
|
});
|
|
|
|
const [best, secondBest] = sorted;
|
|
|
|
/** @type {AutoHighlightResult} */
|
|
const result = best;
|
|
result.secondBest = secondBest;
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Builds new class name for block given the language name
|
|
*
|
|
* @param {HTMLElement} element
|
|
* @param {string} [currentLang]
|
|
* @param {string} [resultLang]
|
|
*/
|
|
function updateClassName(element, currentLang, resultLang) {
|
|
const language = (currentLang && aliases[currentLang]) || resultLang;
|
|
|
|
element.classList.add("hljs");
|
|
element.classList.add(`language-${language}`);
|
|
}
|
|
|
|
/**
|
|
* Applies highlighting to a DOM node containing code.
|
|
*
|
|
* @param {HighlightedHTMLElement} element - the HTML element to highlight
|
|
*/
|
|
function highlightElement(element) {
|
|
/** @type HTMLElement */
|
|
let node = null;
|
|
const language = blockLanguage(element);
|
|
|
|
if (shouldNotHighlight(language)) return;
|
|
|
|
fire("before:highlightElement",
|
|
{ el: element, language: language });
|
|
|
|
// we should be all text, no child nodes
|
|
if (!options.ignoreUnescapedHTML && element.children.length > 0) {
|
|
console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk.");
|
|
console.warn("https://github.com/highlightjs/highlight.js/issues/2886");
|
|
console.warn(element);
|
|
}
|
|
|
|
node = element;
|
|
const text = node.textContent;
|
|
const result = language ? highlight(text, { language, ignoreIllegals: true }) : highlightAuto(text);
|
|
|
|
fire("after:highlightElement", { el: element, result, text });
|
|
|
|
element.innerHTML = result.value;
|
|
updateClassName(element, language, result.language);
|
|
element.result = {
|
|
language: result.language,
|
|
// TODO: remove with version 11.0
|
|
re: result.relevance,
|
|
relevance: result.relevance
|
|
};
|
|
if (result.secondBest) {
|
|
element.secondBest = {
|
|
language: result.secondBest.language,
|
|
relevance: result.secondBest.relevance
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates highlight.js global options with the passed options
|
|
*
|
|
* @param {Partial<HLJSOptions>} userOptions
|
|
*/
|
|
function configure(userOptions) {
|
|
options = inherit(options, userOptions);
|
|
}
|
|
|
|
// TODO: remove v12, deprecated
|
|
const initHighlighting = () => {
|
|
highlightAll();
|
|
deprecated("10.6.0", "initHighlighting() deprecated. Use highlightAll() now.");
|
|
};
|
|
|
|
// TODO: remove v12, deprecated
|
|
function initHighlightingOnLoad() {
|
|
highlightAll();
|
|
deprecated("10.6.0", "initHighlightingOnLoad() deprecated. Use highlightAll() now.");
|
|
}
|
|
|
|
let wantsHighlight = 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;
|
|
}
|
|
|
|
const blocks = document.querySelectorAll(options.cssSelector);
|
|
blocks.forEach(highlightElement);
|
|
}
|
|
|
|
function boot() {
|
|
// if a highlight was requested before DOM was loaded, do now
|
|
if (wantsHighlight) highlightAll();
|
|
}
|
|
|
|
// make sure we are in the browser environment
|
|
if (typeof window !== 'undefined' && window.addEventListener) {
|
|
window.addEventListener('DOMContentLoaded', boot, false);
|
|
}
|
|
|
|
/**
|
|
* Register a language grammar module
|
|
*
|
|
* @param {string} languageName
|
|
* @param {LanguageFn} languageDefinition
|
|
*/
|
|
function registerLanguage(languageName, languageDefinition) {
|
|
let lang = null;
|
|
try {
|
|
lang = languageDefinition(hljs);
|
|
} catch (error$1) {
|
|
error("Language definition for '{}' could not be registered.".replace("{}", languageName));
|
|
// hard or soft error
|
|
if (!SAFE_MODE) { throw error$1; } else { error(error$1); }
|
|
// languages that have serious errors are replaced with essentially a
|
|
// "plaintext" stand-in so that the code blocks will still get normal
|
|
// css classes applied to them - and one bad language won't break the
|
|
// entire highlighter
|
|
lang = PLAINTEXT_LANGUAGE;
|
|
}
|
|
// give it a temporary name if it doesn't have one in the meta-data
|
|
if (!lang.name) lang.name = languageName;
|
|
languages[languageName] = lang;
|
|
lang.rawDefinition = languageDefinition.bind(null, hljs);
|
|
|
|
if (lang.aliases) {
|
|
registerAliases(lang.aliases, { languageName });
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
function listLanguages() {
|
|
return Object.keys(languages);
|
|
}
|
|
|
|
/**
|
|
* @param {string} name - name of the language to retrieve
|
|
* @returns {Language | undefined}
|
|
*/
|
|
function getLanguage(name) {
|
|
name = (name || '').toLowerCase();
|
|
return languages[name] || languages[aliases[name]];
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param {string|string[]} aliasList - single alias or list of aliases
|
|
* @param {{languageName: string}} opts
|
|
*/
|
|
function registerAliases(aliasList, { languageName }) {
|
|
if (typeof aliasList === 'string') {
|
|
aliasList = [aliasList];
|
|
}
|
|
aliasList.forEach(alias => { aliases[alias.toLowerCase()] = languageName; });
|
|
}
|
|
|
|
/**
|
|
* Determines if a given language has auto-detection enabled
|
|
* @param {string} name - name of the language
|
|
*/
|
|
function autoDetection(name) {
|
|
const lang = getLanguage(name);
|
|
return lang && !lang.disableAutodetect;
|
|
}
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param {PluginEvent} event
|
|
* @param {any} args
|
|
*/
|
|
function fire(event, args) {
|
|
const cb = event;
|
|
plugins.forEach(function (plugin) {
|
|
if (plugin[cb]) {
|
|
plugin[cb](args);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @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,
|
|
highlightElement,
|
|
// TODO: Remove with v12 API
|
|
highlightBlock: deprecateHighlightBlock,
|
|
configure,
|
|
initHighlighting,
|
|
initHighlightingOnLoad,
|
|
registerLanguage,
|
|
unregisterLanguage,
|
|
listLanguages,
|
|
getLanguage,
|
|
registerAliases,
|
|
autoDetection,
|
|
inherit,
|
|
addPlugin
|
|
});
|
|
|
|
hljs.debugMode = function () { SAFE_MODE = false; };
|
|
hljs.safeMode = function () { SAFE_MODE = true; };
|
|
hljs.versionString = version;
|
|
|
|
for (const key in MODES$1) {
|
|
// @ts-ignore
|
|
if (typeof MODES$1[key] === "object") {
|
|
// @ts-ignore
|
|
deepFreeze$1(MODES$1[key]);
|
|
}
|
|
}
|
|
|
|
// merge all the modes/regexes into our main object
|
|
Object.assign(hljs, MODES$1);
|
|
|
|
return hljs;
|
|
};
|
|
|
|
// export an "instance" of the highlighter
|
|
var HighlightJS = HLJS({});
|
|
|
|
/*
|
|
Language: Bash
|
|
Author: vah <vahtenberg@gmail.com>
|
|
Contributrors: Benjamin Pannell <contact@sierrasoftworks.com>
|
|
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
|
|
};
|
|
|
|
const KEYWORDS = [
|
|
"if",
|
|
"then",
|
|
"else",
|
|
"elif",
|
|
"fi",
|
|
"for",
|
|
"while",
|
|
"in",
|
|
"do",
|
|
"done",
|
|
"case",
|
|
"esac",
|
|
"function"
|
|
];
|
|
|
|
const LITERALS = [
|
|
"true",
|
|
"false"
|
|
];
|
|
|
|
return {
|
|
name: 'Bash',
|
|
aliases: ['sh'],
|
|
keywords: {
|
|
$pattern: /\b[a-z._-]+\b/,
|
|
keyword: KEYWORDS,
|
|
literal: LITERALS,
|
|
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
|
|
]
|
|
};
|
|
}
|
|
|
|
|
|
const MODES = (hljs) => {
|
|
return {
|
|
IMPORTANT: {
|
|
scope: 'meta',
|
|
begin: '!important'
|
|
},
|
|
HEXCOLOR: {
|
|
scope: 'number',
|
|
begin: '#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})'
|
|
},
|
|
ATTRIBUTE_SELECTOR_MODE: {
|
|
scope: 'selector-attr',
|
|
begin: /\[/,
|
|
end: /\]/,
|
|
illegal: '$',
|
|
contains: [
|
|
hljs.APOS_STRING_MODE,
|
|
hljs.QUOTE_STRING_MODE
|
|
]
|
|
},
|
|
CSS_NUMBER_MODE: {
|
|
scope: 'number',
|
|
begin: hljs.NUMBER_RE + '(' +
|
|
'%|em|ex|ch|rem' +
|
|
'|vw|vh|vmin|vmax' +
|
|
'|cm|mm|in|pt|pc|px' +
|
|
'|deg|grad|rad|turn' +
|
|
'|s|ms' +
|
|
'|Hz|kHz' +
|
|
'|dpi|dpcm|dppx' +
|
|
')?',
|
|
relevance: 0
|
|
}
|
|
};
|
|
};
|
|
|
|
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-smoothing',
|
|
'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);
|
|
|
|
|
|
// 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
|
|
};
|
|
|
|
|
|
/**
|
|
* Allows recursive regex expressions to a given depth
|
|
*
|
|
* ie: recurRegex("(abc~~~)", /~~~/g, 2) becomes:
|
|
* (abc(abc(abc)))
|
|
*
|
|
* @param {string} re
|
|
* @param {RegExp} substitution (should be a g mode regex)
|
|
* @param {number} depth
|
|
* @returns {string}``
|
|
*/
|
|
function recurRegex(re, substitution, depth) {
|
|
if (depth === -1) return "";
|
|
|
|
return re.replace(substitution, _ => {
|
|
return recurRegex(re, substitution, depth - 1);
|
|
});
|
|
}
|
|
|
|
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",
|
|
"BigInt64Array",
|
|
"BigUint64Array",
|
|
"BigInt"
|
|
];
|
|
|
|
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,
|
|
TYPES,
|
|
ERROR_TYPES
|
|
);
|
|
|
|
/*
|
|
Language: JavaScript
|
|
Description: JavaScript (JS) is a lightweight, interpreted, or just-in-time compiled programming language with first-class functions.
|
|
Category: common, scripting, web
|
|
Website: https://developer.mozilla.org/en-US/docs/Web/JavaScript
|
|
*/
|
|
|
|
/** @type LanguageFn */
|
|
function javascript(hljs) {
|
|
/**
|
|
* Takes a string like "<Booger" and checks to see
|
|
* if we can find a matching "</Booger" later in the
|
|
* content.
|
|
* @param {RegExpMatchArray} match
|
|
* @param {{after:number}} param1
|
|
*/
|
|
const hasClosingTag = (match, { after }) => {
|
|
const tag = "</" + match[0].slice(1);
|
|
const pos = match.input.indexOf(tag, after);
|
|
return pos !== -1;
|
|
};
|
|
|
|
const IDENT_RE$1 = IDENT_RE;
|
|
const FRAGMENT = {
|
|
begin: '<>',
|
|
end: '</>'
|
|
};
|
|
const XML_TAG = {
|
|
begin: /<[A-Za-z0-9\\._:-]+/,
|
|
end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
|
|
/**
|
|
* @param {RegExpMatchArray} match
|
|
* @param {CallbackResponse} response
|
|
*/
|
|
isTrulyOpeningTag: (match, response) => {
|
|
const afterMatchIndex = match[0].length + match.index;
|
|
const nextChar = match.input[afterMatchIndex];
|
|
// nested type?
|
|
// HTML should not include another raw `<` inside a tag
|
|
// But a type might: `<Array<Array<number>>`, etc.
|
|
if (nextChar === "<") {
|
|
response.ignoreMatch();
|
|
return;
|
|
}
|
|
// <something>
|
|
// 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,
|
|
"variable.language": BUILT_IN_VARIABLES
|
|
};
|
|
|
|
// 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: [
|
|
{
|
|
begin: '(?=@[A-Za-z]+)',
|
|
relevance: 0,
|
|
contains: [
|
|
{
|
|
className: 'doctag',
|
|
begin: '@[A-Za-z]+'
|
|
},
|
|
{
|
|
className: 'type',
|
|
begin: '\\{',
|
|
end: '\\}',
|
|
excludeEnd: true,
|
|
excludeBegin: true,
|
|
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
|
|
};
|
|
|
|
// ES6 classes
|
|
const CLASS_OR_EXTENDS = {
|
|
variants: [
|
|
{
|
|
match: [
|
|
/class/,
|
|
/\s+/,
|
|
IDENT_RE$1
|
|
],
|
|
scope: {
|
|
1: "keyword",
|
|
3: "title.class"
|
|
}
|
|
},
|
|
{
|
|
match: [
|
|
/extends/,
|
|
/\s+/,
|
|
concat(IDENT_RE$1, "(", concat(/\./, IDENT_RE$1), ")*")
|
|
],
|
|
scope: {
|
|
1: "keyword",
|
|
3: "title.class.inherited"
|
|
}
|
|
}
|
|
]
|
|
};
|
|
|
|
const CLASS_REFERENCE = {
|
|
relevance: 0,
|
|
match: /\b[A-Z][a-z]+([A-Z][a-z]+)*/,
|
|
className: "title.class",
|
|
keywords: {
|
|
_: [
|
|
// se we still get relevance credit for JS library classes
|
|
...TYPES,
|
|
...ERROR_TYPES
|
|
]
|
|
}
|
|
};
|
|
|
|
const USE_STRICT = {
|
|
label: "use_strict",
|
|
className: 'meta',
|
|
relevance: 10,
|
|
begin: /^\s*['"]use (strict|asm)['"]/
|
|
};
|
|
|
|
const FUNCTION_DEFINITION = {
|
|
variants: [
|
|
{
|
|
match: [
|
|
/function/,
|
|
/\s+/,
|
|
IDENT_RE$1,
|
|
/(?=\s*\()/
|
|
]
|
|
},
|
|
// anonymous function
|
|
{
|
|
match: [
|
|
/function/,
|
|
/\s*(?=\()/
|
|
]
|
|
}
|
|
],
|
|
className: {
|
|
1: "keyword",
|
|
3: "title.function"
|
|
},
|
|
label: "func.def",
|
|
contains: [PARAMS],
|
|
illegal: /%/
|
|
};
|
|
|
|
const UPPER_CASE_CONSTANT = {
|
|
relevance: 0,
|
|
match: /\b[A-Z][A-Z_]+\b/,
|
|
className: "variable.constant"
|
|
};
|
|
|
|
function noneOf(list) {
|
|
return concat("(?!", list.join("|"), ")");
|
|
}
|
|
|
|
const FUNCTION_CALL = {
|
|
match: concat(
|
|
/\b/,
|
|
noneOf([
|
|
...BUILT_IN_GLOBALS,
|
|
"super"
|
|
]),
|
|
IDENT_RE$1, lookahead(/\(/)),
|
|
className: "title.function",
|
|
relevance: 0
|
|
};
|
|
|
|
const PROPERTY_ACCESS = {
|
|
begin: concat(/\./, lookahead(
|
|
concat(IDENT_RE$1, /(?![0-9A-Za-z$_(])/)
|
|
)),
|
|
end: IDENT_RE$1,
|
|
excludeBegin: true,
|
|
keywords: "prototype",
|
|
className: "property",
|
|
relevance: 0
|
|
};
|
|
|
|
const GETTER_OR_SETTER = {
|
|
match: [
|
|
/get|set/,
|
|
/\s+/,
|
|
IDENT_RE$1,
|
|
/(?=\()/
|
|
],
|
|
className: {
|
|
1: "keyword",
|
|
3: "title.function"
|
|
},
|
|
contains: [
|
|
{ // eat to avoid empty params
|
|
begin: /\(\)/
|
|
},
|
|
PARAMS
|
|
]
|
|
};
|
|
|
|
const FUNC_LEAD_IN_RE = '(\\(' +
|
|
'[^()]*(\\(' +
|
|
'[^()]*(\\(' +
|
|
'[^()]*' +
|
|
'\\)[^()]*)*' +
|
|
'\\)[^()]*)*' +
|
|
'\\)|' + hljs.UNDERSCORE_IDENT_RE + ')\\s*=>';
|
|
|
|
const FUNCTION_VARIABLE = {
|
|
match: [
|
|
/const|var|let/, /\s+/,
|
|
IDENT_RE$1, /\s*/,
|
|
/=\s*/,
|
|
lookahead(FUNC_LEAD_IN_RE)
|
|
],
|
|
className: {
|
|
1: "keyword",
|
|
3: "title.function"
|
|
},
|
|
contains: [
|
|
PARAMS
|
|
]
|
|
};
|
|
|
|
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
|
|
}),
|
|
USE_STRICT,
|
|
hljs.APOS_STRING_MODE,
|
|
hljs.QUOTE_STRING_MODE,
|
|
HTML_TEMPLATE,
|
|
CSS_TEMPLATE,
|
|
TEMPLATE_STRING,
|
|
COMMENT,
|
|
NUMBER,
|
|
CLASS_REFERENCE,
|
|
{
|
|
className: 'attr',
|
|
begin: IDENT_RE$1 + lookahead(':'),
|
|
relevance: 0
|
|
},
|
|
FUNCTION_VARIABLE,
|
|
{ // "value" container
|
|
begin: '(' + hljs.RE_STARTERS_RE + '|\\b(case|return|throw)\\b)\\s*',
|
|
keywords: 'return throw case',
|
|
relevance: 0,
|
|
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: FUNC_LEAD_IN_RE,
|
|
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
|
|
},
|
|
{
|
|
match: /\s+/,
|
|
relevance: 0
|
|
},
|
|
{ // 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']
|
|
}
|
|
]
|
|
}
|
|
],
|
|
},
|
|
FUNCTION_DEFINITION,
|
|
{
|
|
// prevent this from getting swallowed up by function
|
|
// since they appear "function like"
|
|
beginKeywords: "while if switch catch for"
|
|
},
|
|
{
|
|
// 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: '\\b(?!function)' + hljs.UNDERSCORE_IDENT_RE +
|
|
'\\(' + // first parens
|
|
'[^()]*(\\(' +
|
|
'[^()]*(\\(' +
|
|
'[^()]*' +
|
|
'\\)[^()]*)*' +
|
|
'\\)[^()]*)*' +
|
|
'\\)\\s*\\{', // end parens
|
|
returnBegin: true,
|
|
label: "func.def",
|
|
contains: [
|
|
PARAMS,
|
|
hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1, className: "title.function" })
|
|
]
|
|
},
|
|
// catch ... so it won't trigger the property rule below
|
|
{
|
|
match: /\.\.\./,
|
|
relevance: 0
|
|
},
|
|
PROPERTY_ACCESS,
|
|
// hack: prevents detection of keywords in some circumstances
|
|
// .keyword()
|
|
// $keyword = x
|
|
{
|
|
match: '\\$' + IDENT_RE$1,
|
|
relevance: 0
|
|
},
|
|
{
|
|
match: [/\bconstructor(?=\s*\()/],
|
|
className: { 1: "title.function" },
|
|
contains: [PARAMS]
|
|
},
|
|
FUNCTION_CALL,
|
|
UPPER_CASE_CONSTANT,
|
|
CLASS_OR_EXTENDS,
|
|
GETTER_OR_SETTER,
|
|
{
|
|
match: /\$[(.]/ // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
|
|
}
|
|
]
|
|
};
|
|
}
|
|
|
|
/*
|
|
Language: JSON
|
|
Description: JSON (JavaScript Object Notation) is a lightweight data-interchange format.
|
|
Author: Ivan Sagalaev <maniac@softwaremaniacs.org>
|
|
Website: http://www.json.org
|
|
Category: common, protocols, web
|
|
*/
|
|
|
|
function json(hljs) {
|
|
const ATTRIBUTE = {
|
|
className: 'attr',
|
|
begin: /"(\\.|[^\\"\r\n])*"(?=\s*:)/,
|
|
relevance: 1.01
|
|
};
|
|
const PUNCTUATION = {
|
|
match: /[{}[\],:]/,
|
|
className: "punctuation",
|
|
relevance: 0
|
|
};
|
|
// normally we would rely on `keywords` for this but using a mode here allows us
|
|
// to use the very tight `illegal: \S` rule later to flag any other character
|
|
// as illegal indicating that despite looking like JSON we do not truly have
|
|
// JSON and thus improve false-positively greatly since JSON will try and claim
|
|
// all sorts of JSON looking stuff
|
|
const LITERALS = {
|
|
beginKeywords: [
|
|
"true",
|
|
"false",
|
|
"null"
|
|
].join(" ")
|
|
};
|
|
|
|
return {
|
|
name: 'JSON',
|
|
contains: [
|
|
ATTRIBUTE,
|
|
PUNCTUATION,
|
|
hljs.QUOTE_STRING_MODE,
|
|
LITERALS,
|
|
hljs.C_NUMBER_MODE,
|
|
hljs.C_LINE_COMMENT_MODE,
|
|
hljs.C_BLOCK_COMMENT_MODE
|
|
],
|
|
illegal: '\\S'
|
|
};
|
|
}
|
|
|
|
|
|
/** @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: '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: 'string'
|
|
});
|
|
const QUOTE_META_STRING_MODE = hljs.inherit(hljs.QUOTE_STRING_MODE, {
|
|
className: 'string'
|
|
});
|
|
const TAG_INTERNALS = {
|
|
endsWithParent: true,
|
|
illegal: /</,
|
|
relevance: 0,
|
|
contains: [
|
|
{
|
|
className: 'attr',
|
|
begin: XML_IDENT_RE,
|
|
relevance: 0
|
|
},
|
|
{
|
|
begin: /=\s*/,
|
|
relevance: 0,
|
|
contains: [
|
|
{
|
|
className: 'string',
|
|
endsParent: true,
|
|
variants: [
|
|
{
|
|
begin: /"/,
|
|
end: /"/,
|
|
contains: [XML_ENTITIES]
|
|
},
|
|
{
|
|
begin: /'/,
|
|
end: /'/,
|
|
contains: [XML_ENTITIES]
|
|
},
|
|
{
|
|
begin: /[^\s"'=<>`]+/
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
]
|
|
};
|
|
return {
|
|
name: 'HTML, XML',
|
|
aliases: [
|
|
'html',
|
|
'xhtml',
|
|
'rss',
|
|
'atom',
|
|
'xjb',
|
|
'xsd',
|
|
'xsl',
|
|
'plist',
|
|
'wsf',
|
|
'svg'
|
|
],
|
|
case_insensitive: true,
|
|
contains: [
|
|
{
|
|
className: 'meta',
|
|
begin: /<![a-z]/,
|
|
end: />/,
|
|
relevance: 10,
|
|
contains: [
|
|
XML_META_KEYWORDS,
|
|
QUOTE_META_STRING_MODE,
|
|
APOS_META_STRING_MODE,
|
|
XML_META_PAR_KEYWORDS,
|
|
{
|
|
begin: /\[/,
|
|
end: /\]/,
|
|
contains: [
|
|
{
|
|
className: 'meta',
|
|
begin: /<![a-z]/,
|
|
end: />/,
|
|
contains: [
|
|
XML_META_KEYWORDS,
|
|
XML_META_PAR_KEYWORDS,
|
|
QUOTE_META_STRING_MODE,
|
|
APOS_META_STRING_MODE
|
|
]
|
|
}
|
|
]
|
|
}
|
|
]
|
|
},
|
|
hljs.COMMENT(
|
|
/<!--/,
|
|
/-->/,
|
|
{
|
|
relevance: 10
|
|
}
|
|
),
|
|
{
|
|
begin: /<!\[CDATA\[/,
|
|
end: /\]\]>/,
|
|
relevance: 10
|
|
},
|
|
XML_ENTITIES,
|
|
{
|
|
className: 'meta',
|
|
begin: /<\?xml/,
|
|
end: /\?>/,
|
|
relevance: 10
|
|
},
|
|
{
|
|
className: 'tag',
|
|
/*
|
|
The lookahead pattern (?=...) ensures that 'begin' only matches
|
|
'<style' as a single word, followed by a whitespace or an
|
|
ending bracket.
|
|
*/
|
|
begin: /<style(?=\s|>)/,
|
|
end: />/,
|
|
keywords: {
|
|
name: 'style'
|
|
},
|
|
contains: [TAG_INTERNALS],
|
|
starts: {
|
|
end: /<\/style>/,
|
|
returnEnd: true,
|
|
subLanguage: [
|
|
'css',
|
|
'xml'
|
|
]
|
|
}
|
|
},
|
|
{
|
|
className: 'tag',
|
|
// See the comment in the <style tag about the lookahead pattern
|
|
begin: /<script(?=\s|>)/,
|
|
end: />/,
|
|
keywords: {
|
|
name: 'script'
|
|
},
|
|
contains: [TAG_INTERNALS],
|
|
starts: {
|
|
end: /<\/script>/,
|
|
returnEnd: true,
|
|
subLanguage: [
|
|
'javascript',
|
|
'handlebars',
|
|
'xml'
|
|
]
|
|
}
|
|
},
|
|
// we need this for now for jSX
|
|
{
|
|
className: 'tag',
|
|
begin: /<>|<\/>/
|
|
},
|
|
// open tag
|
|
{
|
|
className: 'tag',
|
|
begin: concat(
|
|
/</,
|
|
lookahead(concat(
|
|
TAG_NAME_RE,
|
|
// <tag/>
|
|
// <tag>
|
|
// <tag ...
|
|
either(/\/>/, />/, /\s/)
|
|
))
|
|
),
|
|
end: /\/?>/,
|
|
contains: [
|
|
{
|
|
className: 'name',
|
|
begin: TAG_NAME_RE,
|
|
relevance: 0,
|
|
starts: TAG_INTERNALS
|
|
}
|
|
]
|
|
},
|
|
// close tag
|
|
{
|
|
className: 'tag',
|
|
begin: concat(
|
|
/<\//,
|
|
lookahead(concat(
|
|
TAG_NAME_RE, />/
|
|
))
|
|
),
|
|
contains: [
|
|
{
|
|
className: 'name',
|
|
begin: TAG_NAME_RE,
|
|
relevance: 0
|
|
},
|
|
{
|
|
begin: />/,
|
|
relevance: 0,
|
|
endsParent: true
|
|
}
|
|
]
|
|
}
|
|
]
|
|
};
|
|
}
|
|
|
|
/*
|
|
Language: Markdown
|
|
Requires: xml.js
|
|
Author: John Crepezzi <john.crepezzi@gmail.com>
|
|
Website: https://daringfireball.net/projects/markdown/
|
|
Category: common, markup
|
|
*/
|
|
|
|
function markdown(hljs) {
|
|
const INLINE_HTML = {
|
|
begin: /<\/?[A-Za-z_]/,
|
|
end: '>',
|
|
subLanguage: 'xml',
|
|
relevance: 0
|
|
};
|
|
const HORIZONTAL_RULE = {
|
|
begin: '^[-\\*]{3,}',
|
|
end: '$'
|
|
};
|
|
const CODE = {
|
|
className: 'code',
|
|
variants: [
|
|
// TODO: fix to allow these to work with sublanguage also
|
|
{
|
|
begin: '(`{3,})[^`](.|\\n)*?\\1`*[ ]*'
|
|
},
|
|
{
|
|
begin: '(~{3,})[^~](.|\\n)*?\\1~*[ ]*'
|
|
},
|
|
// needed to allow markdown as a sublanguage to work
|
|
{
|
|
begin: '```',
|
|
end: '```+[ ]*$'
|
|
},
|
|
{
|
|
begin: '~~~',
|
|
end: '~~~+[ ]*$'
|
|
},
|
|
{
|
|
begin: '`.+?`'
|
|
},
|
|
{
|
|
begin: '(?=^( {4}|\\t))',
|
|
// use contains to gobble up multiple lines to allow the block to be whatever size
|
|
// but only have a single open/close tag vs one per line
|
|
contains: [
|
|
{
|
|
begin: '^( {4}|\\t)',
|
|
end: '(\\n)$'
|
|
}
|
|
],
|
|
relevance: 0
|
|
}
|
|
]
|
|
};
|
|
const LIST = {
|
|
className: 'bullet',
|
|
begin: '^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)',
|
|
end: '\\s+',
|
|
excludeEnd: true
|
|
};
|
|
const LINK_REFERENCE = {
|
|
begin: /^\[[^\n]+\]:/,
|
|
returnBegin: true,
|
|
contains: [
|
|
{
|
|
className: 'symbol',
|
|
begin: /\[/,
|
|
end: /\]/,
|
|
excludeBegin: true,
|
|
excludeEnd: true
|
|
},
|
|
{
|
|
className: 'link',
|
|
begin: /:\s*/,
|
|
end: /$/,
|
|
excludeBegin: true
|
|
}
|
|
]
|
|
};
|
|
const URL_SCHEME = /[A-Za-z][A-Za-z0-9+.-]*/;
|
|
const LINK = {
|
|
variants: [
|
|
// too much like nested array access in so many languages
|
|
// to have any real relevance
|
|
{
|
|
begin: /\[.+?\]\[.*?\]/,
|
|
relevance: 0
|
|
},
|
|
// popular internet URLs
|
|
{
|
|
begin: /\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
|
|
relevance: 2
|
|
},
|
|
{
|
|
begin: concat(/\[.+?\]\(/, URL_SCHEME, /:\/\/.*?\)/),
|
|
relevance: 2
|
|
},
|
|
// relative urls
|
|
{
|
|
begin: /\[.+?\]\([./?&#].*?\)/,
|
|
relevance: 1
|
|
},
|
|
// whatever else, lower relevance (might not be a link at all)
|
|
{
|
|
begin: /\[.+?\]\(.*?\)/,
|
|
relevance: 0
|
|
}
|
|
],
|
|
returnBegin: true,
|
|
contains: [
|
|
{
|
|
className: 'string',
|
|
relevance: 0,
|
|
begin: '\\[',
|
|
end: '\\]',
|
|
excludeBegin: true,
|
|
returnEnd: true
|
|
},
|
|
{
|
|
className: 'link',
|
|
relevance: 0,
|
|
begin: '\\]\\(',
|
|
end: '\\)',
|
|
excludeBegin: true,
|
|
excludeEnd: true
|
|
},
|
|
{
|
|
className: 'symbol',
|
|
relevance: 0,
|
|
begin: '\\]\\[',
|
|
end: '\\]',
|
|
excludeBegin: true,
|
|
excludeEnd: true
|
|
}
|
|
]
|
|
};
|
|
const BOLD = {
|
|
className: 'strong',
|
|
contains: [], // defined later
|
|
variants: [
|
|
{
|
|
begin: /_{2}/,
|
|
end: /_{2}/
|
|
},
|
|
{
|
|
begin: /\*{2}/,
|
|
end: /\*{2}/
|
|
}
|
|
]
|
|
};
|
|
const ITALIC = {
|
|
className: 'emphasis',
|
|
contains: [], // defined later
|
|
variants: [
|
|
{
|
|
begin: /\*(?!\*)/,
|
|
end: /\*/
|
|
},
|
|
{
|
|
begin: /_(?!_)/,
|
|
end: /_/,
|
|
relevance: 0
|
|
}
|
|
]
|
|
};
|
|
BOLD.contains.push(ITALIC);
|
|
ITALIC.contains.push(BOLD);
|
|
|
|
let CONTAINABLE = [
|
|
INLINE_HTML,
|
|
LINK
|
|
];
|
|
|
|
BOLD.contains = BOLD.contains.concat(CONTAINABLE);
|
|
ITALIC.contains = ITALIC.contains.concat(CONTAINABLE);
|
|
|
|
CONTAINABLE = CONTAINABLE.concat(BOLD, ITALIC);
|
|
|
|
const HEADER = {
|
|
className: 'section',
|
|
variants: [
|
|
{
|
|
begin: '^#{1,6}',
|
|
end: '$',
|
|
contains: CONTAINABLE
|
|
},
|
|
{
|
|
begin: '(?=^.+?\\n[=-]{2,}$)',
|
|
contains: [
|
|
{
|
|
begin: '^[=-]*$'
|
|
},
|
|
{
|
|
begin: '^',
|
|
end: "\\n",
|
|
contains: CONTAINABLE
|
|
}
|
|
]
|
|
}
|
|
]
|
|
};
|
|
|
|
const BLOCKQUOTE = {
|
|
className: 'quote',
|
|
begin: '^>\\s+',
|
|
contains: CONTAINABLE,
|
|
end: '$'
|
|
};
|
|
|
|
return {
|
|
name: 'Markdown',
|
|
aliases: [
|
|
'md',
|
|
'mkdown',
|
|
'mkd'
|
|
],
|
|
contains: [
|
|
HEADER,
|
|
INLINE_HTML,
|
|
LIST,
|
|
BOLD,
|
|
ITALIC,
|
|
BLOCKQUOTE,
|
|
CODE,
|
|
HORIZONTAL_RULE,
|
|
LINK,
|
|
LINK_REFERENCE
|
|
]
|
|
};
|
|
}
|
|
|
|
|
|
/*
|
|
Language: Plain text
|
|
Author: Egor Rogov (e.rogov@postgrespro.ru)
|
|
Description: Plain text without any highlighting.
|
|
Category: common
|
|
*/
|
|
|
|
function plaintext(hljs) {
|
|
return {
|
|
name: 'Plain text',
|
|
aliases: [
|
|
'text',
|
|
'txt'
|
|
],
|
|
disableAutodetect: true
|
|
};
|
|
}
|
|
|
|
|
|
/*
|
|
Language: SCSS
|
|
Description: Scss is an extension of the syntax of CSS.
|
|
Author: Kurt Emch <kurt@kurtemch.com>
|
|
Website: https://sass-lang.com
|
|
Category: common, css, web
|
|
*/
|
|
|
|
/** @type LanguageFn */
|
|
function scss(hljs) {
|
|
const modes = MODES(hljs);
|
|
const PSEUDO_ELEMENTS$1 = PSEUDO_ELEMENTS;
|
|
const PSEUDO_CLASSES$1 = PSEUDO_CLASSES;
|
|
|
|
const AT_IDENTIFIER = '@[a-z-]+'; // @font-face
|
|
const AT_MODIFIERS = "and or not only";
|
|
const IDENT_RE = '[a-zA-Z-][a-zA-Z0-9_-]*';
|
|
const VARIABLE = {
|
|
className: 'variable',
|
|
begin: '(\\$' + IDENT_RE + ')\\b'
|
|
};
|
|
|
|
return {
|
|
name: 'SCSS',
|
|
case_insensitive: true,
|
|
illegal: '[=/|\']',
|
|
contains: [
|
|
hljs.C_LINE_COMMENT_MODE,
|
|
hljs.C_BLOCK_COMMENT_MODE,
|
|
{
|
|
className: 'selector-id',
|
|
begin: '#[A-Za-z0-9_-]+',
|
|
relevance: 0
|
|
},
|
|
{
|
|
className: 'selector-class',
|
|
begin: '\\.[A-Za-z0-9_-]+',
|
|
relevance: 0
|
|
},
|
|
modes.ATTRIBUTE_SELECTOR_MODE,
|
|
{
|
|
className: 'selector-tag',
|
|
begin: '\\b(' + TAGS.join('|') + ')\\b',
|
|
// was there, before, but why?
|
|
relevance: 0
|
|
},
|
|
{
|
|
className: 'selector-pseudo',
|
|
begin: ':(' + PSEUDO_CLASSES$1.join('|') + ')'
|
|
},
|
|
{
|
|
className: 'selector-pseudo',
|
|
begin: '::(' + PSEUDO_ELEMENTS$1.join('|') + ')'
|
|
},
|
|
VARIABLE,
|
|
{ // pseudo-selector params
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
contains: [modes.CSS_NUMBER_MODE]
|
|
},
|
|
{
|
|
className: 'attribute',
|
|
begin: '\\b(' + ATTRIBUTES.join('|') + ')\\b'
|
|
},
|
|
{
|
|
begin: '\\b(whitespace|wait|w-resize|visible|vertical-text|vertical-ideographic|uppercase|upper-roman|upper-alpha|underline|transparent|top|thin|thick|text|text-top|text-bottom|tb-rl|table-header-group|table-footer-group|sw-resize|super|strict|static|square|solid|small-caps|separate|se-resize|scroll|s-resize|rtl|row-resize|ridge|right|repeat|repeat-y|repeat-x|relative|progress|pointer|overline|outside|outset|oblique|nowrap|not-allowed|normal|none|nw-resize|no-repeat|no-drop|newspaper|ne-resize|n-resize|move|middle|medium|ltr|lr-tb|lowercase|lower-roman|lower-alpha|loose|list-item|line|line-through|line-edge|lighter|left|keep-all|justify|italic|inter-word|inter-ideograph|inside|inset|inline|inline-block|inherit|inactive|ideograph-space|ideograph-parenthesis|ideograph-numeric|ideograph-alpha|horizontal|hidden|help|hand|groove|fixed|ellipsis|e-resize|double|dotted|distribute|distribute-space|distribute-letter|distribute-all-lines|disc|disabled|default|decimal|dashed|crosshair|collapse|col-resize|circle|char|center|capitalize|break-word|break-all|bottom|both|bolder|bold|block|bidi-override|below|baseline|auto|always|all-scroll|absolute|table|table-cell)\\b'
|
|
},
|
|
{
|
|
begin: ':',
|
|
end: ';',
|
|
contains: [
|
|
VARIABLE,
|
|
modes.HEXCOLOR,
|
|
modes.CSS_NUMBER_MODE,
|
|
hljs.QUOTE_STRING_MODE,
|
|
hljs.APOS_STRING_MODE,
|
|
modes.IMPORTANT
|
|
]
|
|
},
|
|
// matching these here allows us to treat them more like regular CSS
|
|
// rules so everything between the {} gets regular rule highlighting,
|
|
// which is what we want for page and font-face
|
|
{
|
|
begin: '@(page|font-face)',
|
|
keywords: {
|
|
$pattern: AT_IDENTIFIER,
|
|
keyword: '@page @font-face'
|
|
}
|
|
},
|
|
{
|
|
begin: '@',
|
|
end: '[{;]',
|
|
returnBegin: true,
|
|
keywords: {
|
|
$pattern: /[a-z-]+/,
|
|
keyword: AT_MODIFIERS,
|
|
attribute: MEDIA_FEATURES.join(" ")
|
|
},
|
|
contains: [
|
|
{
|
|
begin: AT_IDENTIFIER,
|
|
className: "keyword"
|
|
},
|
|
{
|
|
begin: /[a-z-]+(?=:)/,
|
|
className: "attribute"
|
|
},
|
|
VARIABLE,
|
|
hljs.QUOTE_STRING_MODE,
|
|
hljs.APOS_STRING_MODE,
|
|
modes.HEXCOLOR,
|
|
modes.CSS_NUMBER_MODE
|
|
]
|
|
}
|
|
]
|
|
};
|
|
}
|
|
|
|
/*
|
|
Language: Shell Session
|
|
Requires: bash.js
|
|
Author: TSUYUSATO Kitsune <make.just.on@gmail.com>
|
|
Category: common
|
|
Audit: 2020
|
|
*/
|
|
|
|
/** @type LanguageFn */
|
|
function shell(hljs) {
|
|
return {
|
|
name: 'Shell Session',
|
|
aliases: ['console', 'shellsession'],
|
|
contains: [
|
|
{
|
|
className: 'meta',
|
|
// We cannot add \s (spaces) in the regular expression otherwise it will be too broad and produce unexpected result.
|
|
// For instance, in the following example, it would match "echo /path/to/home >" as a prompt:
|
|
// echo /path/to/home > t.exe
|
|
begin: /^\s{0,3}[/~\w\d[\]()@-]*[>%$#][ ]?/,
|
|
starts: {
|
|
end: /[^\\](?=\s*$)/,
|
|
subLanguage: 'bash'
|
|
}
|
|
}
|
|
]
|
|
};
|
|
}
|
|
|
|
|
|
const keywordWrapper = keyword => concat(
|
|
/\b/,
|
|
keyword,
|
|
/\w$/.test(keyword) ? /\b/ : /\B/
|
|
);
|
|
|
|
// Keywords that require a leading dot.
|
|
const dotKeywords = [
|
|
'Protocol', // contextual
|
|
'Type' // contextual
|
|
].map(keywordWrapper);
|
|
|
|
// Keywords that may have a leading dot.
|
|
const optionalDotKeywords = [
|
|
'init',
|
|
'self'
|
|
].map(keywordWrapper);
|
|
|
|
// should register as keyword, not type
|
|
const keywordTypes = [
|
|
'Any',
|
|
'Self'
|
|
];
|
|
|
|
// Regular keywords and literals.
|
|
const keywords = [
|
|
// strings below will be fed into the regular `keywords` engine while regex
|
|
// will result in additional modes being created to scan for those keywords to
|
|
// avoid conflicts with other rules
|
|
'actor',
|
|
'associatedtype',
|
|
'async',
|
|
'await',
|
|
/as\?/, // operator
|
|
/as!/, // operator
|
|
'as', // operator
|
|
'break',
|
|
'case',
|
|
'catch',
|
|
'class',
|
|
'continue',
|
|
'convenience', // contextual
|
|
'default',
|
|
'defer',
|
|
'deinit',
|
|
'didSet', // contextual
|
|
'do',
|
|
'dynamic', // contextual
|
|
'else',
|
|
'enum',
|
|
'extension',
|
|
'fallthrough',
|
|
/fileprivate\(set\)/,
|
|
'fileprivate',
|
|
'final', // contextual
|
|
'for',
|
|
'func',
|
|
'get', // contextual
|
|
'guard',
|
|
'if',
|
|
'import',
|
|
'indirect', // contextual
|
|
'infix', // contextual
|
|
/init\?/,
|
|
/init!/,
|
|
'inout',
|
|
/internal\(set\)/,
|
|
'internal',
|
|
'in',
|
|
'is', // operator
|
|
'lazy', // contextual
|
|
'let',
|
|
'mutating', // contextual
|
|
'nonmutating', // contextual
|
|
/open\(set\)/, // contextual
|
|
'open', // contextual
|
|
'operator',
|
|
'optional', // contextual
|
|
'override', // contextual
|
|
'postfix', // contextual
|
|
'precedencegroup',
|
|
'prefix', // contextual
|
|
/private\(set\)/,
|
|
'private',
|
|
'protocol',
|
|
/public\(set\)/,
|
|
'public',
|
|
'repeat',
|
|
'required', // contextual
|
|
'rethrows',
|
|
'return',
|
|
'set', // contextual
|
|
'some', // contextual
|
|
'static',
|
|
'struct',
|
|
'subscript',
|
|
'super',
|
|
'switch',
|
|
'throws',
|
|
'throw',
|
|
/try\?/, // operator
|
|
/try!/, // operator
|
|
'try', // operator
|
|
'typealias',
|
|
/unowned\(safe\)/, // contextual
|
|
/unowned\(unsafe\)/, // contextual
|
|
'unowned', // contextual
|
|
'var',
|
|
'weak', // contextual
|
|
'where',
|
|
'while',
|
|
'willSet' // contextual
|
|
];
|
|
|
|
// NOTE: Contextual keywords are reserved only in specific contexts.
|
|
// Ideally, these should be matched using modes to avoid false positives.
|
|
|
|
// Literals.
|
|
const literals = [
|
|
'false',
|
|
'nil',
|
|
'true'
|
|
];
|
|
|
|
// Keywords used in precedence groups.
|
|
const precedencegroupKeywords = [
|
|
'assignment',
|
|
'associativity',
|
|
'higherThan',
|
|
'left',
|
|
'lowerThan',
|
|
'none',
|
|
'right'
|
|
];
|
|
|
|
// Keywords that start with a number sign (#).
|
|
// #available is handled separately.
|
|
const numberSignKeywords = [
|
|
'#colorLiteral',
|
|
'#column',
|
|
'#dsohandle',
|
|
'#else',
|
|
'#elseif',
|
|
'#endif',
|
|
'#error',
|
|
'#file',
|
|
'#fileID',
|
|
'#fileLiteral',
|
|
'#filePath',
|
|
'#function',
|
|
'#if',
|
|
'#imageLiteral',
|
|
'#keyPath',
|
|
'#line',
|
|
'#selector',
|
|
'#sourceLocation',
|
|
'#warn_unqualified_access',
|
|
'#warning'
|
|
];
|
|
|
|
// Global functions in the Standard Library.
|
|
const builtIns$1 = [
|
|
'abs',
|
|
'all',
|
|
'any',
|
|
'assert',
|
|
'assertionFailure',
|
|
'debugPrint',
|
|
'dump',
|
|
'fatalError',
|
|
'getVaList',
|
|
'isKnownUniquelyReferenced',
|
|
'max',
|
|
'min',
|
|
'numericCast',
|
|
'pointwiseMax',
|
|
'pointwiseMin',
|
|
'precondition',
|
|
'preconditionFailure',
|
|
'print',
|
|
'readLine',
|
|
'repeatElement',
|
|
'sequence',
|
|
'stride',
|
|
'swap',
|
|
'swift_unboxFromSwiftValueWithType',
|
|
'transcode',
|
|
'type',
|
|
'unsafeBitCast',
|
|
'unsafeDowncast',
|
|
'withExtendedLifetime',
|
|
'withUnsafeMutablePointer',
|
|
'withUnsafePointer',
|
|
'withVaList',
|
|
'withoutActuallyEscaping',
|
|
'zip'
|
|
];
|
|
|
|
// Valid first characters for operators.
|
|
const operatorHead = either(
|
|
/[/=\-+!*%<>&|^~?]/,
|
|
/[\u00A1-\u00A7]/,
|
|
/[\u00A9\u00AB]/,
|
|
/[\u00AC\u00AE]/,
|
|
/[\u00B0\u00B1]/,
|
|
/[\u00B6\u00BB\u00BF\u00D7\u00F7]/,
|
|
/[\u2016-\u2017]/,
|
|
/[\u2020-\u2027]/,
|
|
/[\u2030-\u203E]/,
|
|
/[\u2041-\u2053]/,
|
|
/[\u2055-\u205E]/,
|
|
/[\u2190-\u23FF]/,
|
|
/[\u2500-\u2775]/,
|
|
/[\u2794-\u2BFF]/,
|
|
/[\u2E00-\u2E7F]/,
|
|
/[\u3001-\u3003]/,
|
|
/[\u3008-\u3020]/,
|
|
/[\u3030]/
|
|
);
|
|
|
|
// Valid characters for operators.
|
|
const operatorCharacter = either(
|
|
operatorHead,
|
|
/[\u0300-\u036F]/,
|
|
/[\u1DC0-\u1DFF]/,
|
|
/[\u20D0-\u20FF]/,
|
|
/[\uFE00-\uFE0F]/,
|
|
/[\uFE20-\uFE2F]/
|
|
// TODO: The following characters are also allowed, but the regex isn't supported yet.
|
|
// /[\u{E0100}-\u{E01EF}]/u
|
|
);
|
|
|
|
// Valid operator.
|
|
const operator = concat(operatorHead, operatorCharacter, '*');
|
|
|
|
// Valid first characters for identifiers.
|
|
const identifierHead = either(
|
|
/[a-zA-Z_]/,
|
|
/[\u00A8\u00AA\u00AD\u00AF\u00B2-\u00B5\u00B7-\u00BA]/,
|
|
/[\u00BC-\u00BE\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF]/,
|
|
/[\u0100-\u02FF\u0370-\u167F\u1681-\u180D\u180F-\u1DBF]/,
|
|
/[\u1E00-\u1FFF]/,
|
|
/[\u200B-\u200D\u202A-\u202E\u203F-\u2040\u2054\u2060-\u206F]/,
|
|
/[\u2070-\u20CF\u2100-\u218F\u2460-\u24FF\u2776-\u2793]/,
|
|
/[\u2C00-\u2DFF\u2E80-\u2FFF]/,
|
|
/[\u3004-\u3007\u3021-\u302F\u3031-\u303F\u3040-\uD7FF]/,
|
|
/[\uF900-\uFD3D\uFD40-\uFDCF\uFDF0-\uFE1F\uFE30-\uFE44]/,
|
|
/[\uFE47-\uFEFE\uFF00-\uFFFD]/ // Should be /[\uFE47-\uFFFD]/, but we have to exclude FEFF.
|
|
// The following characters are also allowed, but the regexes aren't supported yet.
|
|
// /[\u{10000}-\u{1FFFD}\u{20000-\u{2FFFD}\u{30000}-\u{3FFFD}\u{40000}-\u{4FFFD}]/u,
|
|
// /[\u{50000}-\u{5FFFD}\u{60000-\u{6FFFD}\u{70000}-\u{7FFFD}\u{80000}-\u{8FFFD}]/u,
|
|
// /[\u{90000}-\u{9FFFD}\u{A0000-\u{AFFFD}\u{B0000}-\u{BFFFD}\u{C0000}-\u{CFFFD}]/u,
|
|
// /[\u{D0000}-\u{DFFFD}\u{E0000-\u{EFFFD}]/u
|
|
);
|
|
|
|
// Valid characters for identifiers.
|
|
const identifierCharacter = either(
|
|
identifierHead,
|
|
/\d/,
|
|
/[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/
|
|
);
|
|
|
|
// Valid identifier.
|
|
const identifier = concat(identifierHead, identifierCharacter, '*');
|
|
|
|
// Valid type identifier.
|
|
const typeIdentifier = concat(/[A-Z]/, identifierCharacter, '*');
|
|
|
|
// Built-in attributes, which are highlighted as keywords.
|
|
// @available is handled separately.
|
|
const keywordAttributes = [
|
|
'autoclosure',
|
|
concat(/convention\(/, either('swift', 'block', 'c'), /\)/),
|
|
'discardableResult',
|
|
'dynamicCallable',
|
|
'dynamicMemberLookup',
|
|
'escaping',
|
|
'frozen',
|
|
'GKInspectable',
|
|
'IBAction',
|
|
'IBDesignable',
|
|
'IBInspectable',
|
|
'IBOutlet',
|
|
'IBSegueAction',
|
|
'inlinable',
|
|
'main',
|
|
'nonobjc',
|
|
'NSApplicationMain',
|
|
'NSCopying',
|
|
'NSManaged',
|
|
concat(/objc\(/, identifier, /\)/),
|
|
'objc',
|
|
'objcMembers',
|
|
'propertyWrapper',
|
|
'requires_stored_property_inits',
|
|
'resultBuilder',
|
|
'testable',
|
|
'UIApplicationMain',
|
|
'unknown',
|
|
'usableFromInline'
|
|
];
|
|
|
|
// Contextual keywords used in @available and #available.
|
|
const availabilityKeywords = [
|
|
'iOS',
|
|
'iOSApplicationExtension',
|
|
'macOS',
|
|
'macOSApplicationExtension',
|
|
'macCatalyst',
|
|
'macCatalystApplicationExtension',
|
|
'watchOS',
|
|
'watchOSApplicationExtension',
|
|
'tvOS',
|
|
'tvOSApplicationExtension',
|
|
'swift'
|
|
];
|
|
|
|
|
|
/*
|
|
Language: TypeScript
|
|
Author: Panu Horsmalahti <panu.horsmalahti@iki.fi>
|
|
Contributors: Ike Ku <dempfi@yahoo.com>
|
|
Description: TypeScript is a strict superset of JavaScript
|
|
Website: https://www.typescriptlang.org
|
|
Category: common, scripting
|
|
*/
|
|
|
|
/** @type LanguageFn */
|
|
function typescript(hljs) {
|
|
const IDENT_RE$1 = IDENT_RE;
|
|
const NAMESPACE = {
|
|
beginKeywords: 'namespace', end: /\{/, excludeEnd: true
|
|
};
|
|
const INTERFACE = {
|
|
beginKeywords: 'interface', end: /\{/, excludeEnd: true,
|
|
keywords: 'interface extends'
|
|
};
|
|
const USE_STRICT = {
|
|
className: 'meta',
|
|
relevance: 10,
|
|
begin: /^\s*['"]use strict['"]/
|
|
};
|
|
const TYPES = [
|
|
"any",
|
|
"void",
|
|
"number",
|
|
"boolean",
|
|
"string",
|
|
"object",
|
|
"never",
|
|
"enum"
|
|
];
|
|
const TS_SPECIFIC_KEYWORDS = [
|
|
"type",
|
|
"namespace",
|
|
"typedef",
|
|
"interface",
|
|
"public",
|
|
"private",
|
|
"protected",
|
|
"implements",
|
|
"declare",
|
|
"abstract",
|
|
"readonly"
|
|
];
|
|
const KEYWORDS$1 = {
|
|
$pattern: IDENT_RE,
|
|
keyword: KEYWORDS.concat(TS_SPECIFIC_KEYWORDS),
|
|
literal: LITERALS,
|
|
built_in: BUILT_INS.concat(TYPES),
|
|
"variable.language": BUILT_IN_VARIABLES
|
|
};
|
|
const DECORATOR = {
|
|
className: 'meta',
|
|
begin: '@' + IDENT_RE$1,
|
|
};
|
|
|
|
const swapMode = (mode, label, replacement) => {
|
|
const indx = mode.contains.findIndex(m => m.label === label);
|
|
if (indx === -1) { throw new Error("can not find mode to replace"); }
|
|
mode.contains.splice(indx, 1, replacement);
|
|
};
|
|
|
|
const tsLanguage = javascript(hljs);
|
|
|
|
// this should update anywhere keywords is used since
|
|
// it will be the same actual JS object
|
|
Object.assign(tsLanguage.keywords, KEYWORDS$1);
|
|
|
|
tsLanguage.exports.PARAMS_CONTAINS.push(DECORATOR);
|
|
tsLanguage.contains = tsLanguage.contains.concat([
|
|
DECORATOR,
|
|
NAMESPACE,
|
|
INTERFACE,
|
|
]);
|
|
|
|
// TS gets a simpler shebang rule than JS
|
|
swapMode(tsLanguage, "shebang", hljs.SHEBANG());
|
|
// JS use strict rule purposely excludes `asm` which makes no sense
|
|
swapMode(tsLanguage, "use_strict", USE_STRICT);
|
|
|
|
const functionDeclaration = tsLanguage.contains.find(m => m.label === "func.def");
|
|
functionDeclaration.relevance = 0; // () => {} is more typical in TypeScript
|
|
|
|
Object.assign(tsLanguage, {
|
|
name: 'TypeScript',
|
|
aliases: ['ts', 'tsx']
|
|
});
|
|
|
|
return tsLanguage;
|
|
}
|
|
|
|
|
|
/*
|
|
Language: YAML
|
|
Description: Yet Another Markdown Language
|
|
Author: Stefan Wienert <stwienert@gmail.com>
|
|
Contributors: Carl Baxter <carl@cbax.tech>
|
|
Requires: ruby.js
|
|
Website: https://yaml.org
|
|
Category: common, config
|
|
*/
|
|
function yaml(hljs) {
|
|
const LITERALS = 'true false yes no null';
|
|
|
|
// YAML spec allows non-reserved URI characters in tags.
|
|
const URI_CHARACTERS = '[\\w#;/?:@&=+$,.~*\'()[\\]]+';
|
|
|
|
// Define keys as starting with a word character
|
|
// ...containing word chars, spaces, colons, forward-slashes, hyphens and periods
|
|
// ...and ending with a colon followed immediately by a space, tab or newline.
|
|
// The YAML spec allows for much more than this, but this covers most use-cases.
|
|
const KEY = {
|
|
className: 'attr',
|
|
variants: [
|
|
{
|
|
begin: '\\w[\\w :\\/.-]*:(?=[ \t]|$)'
|
|
},
|
|
{ // double quoted keys
|
|
begin: '"\\w[\\w :\\/.-]*":(?=[ \t]|$)'
|
|
},
|
|
{ // single quoted keys
|
|
begin: '\'\\w[\\w :\\/.-]*\':(?=[ \t]|$)'
|
|
}
|
|
]
|
|
};
|
|
|
|
const TEMPLATE_VARIABLES = {
|
|
className: 'template-variable',
|
|
variants: [
|
|
{ // jinja templates Ansible
|
|
begin: /\{\{/,
|
|
end: /\}\}/
|
|
},
|
|
{ // Ruby i18n
|
|
begin: /%\{/,
|
|
end: /\}/
|
|
}
|
|
]
|
|
};
|
|
const STRING = {
|
|
className: 'string',
|
|
relevance: 0,
|
|
variants: [
|
|
{
|
|
begin: /'/,
|
|
end: /'/
|
|
},
|
|
{
|
|
begin: /"/,
|
|
end: /"/
|
|
},
|
|
{
|
|
begin: /\S+/
|
|
}
|
|
],
|
|
contains: [
|
|
hljs.BACKSLASH_ESCAPE,
|
|
TEMPLATE_VARIABLES
|
|
]
|
|
};
|
|
|
|
// Strings inside of value containers (objects) can't contain braces,
|
|
// brackets, or commas
|
|
const CONTAINER_STRING = hljs.inherit(STRING, {
|
|
variants: [
|
|
{
|
|
begin: /'/,
|
|
end: /'/
|
|
},
|
|
{
|
|
begin: /"/,
|
|
end: /"/
|
|
},
|
|
{
|
|
begin: /[^\s,{}[\]]+/
|
|
}
|
|
]
|
|
});
|
|
|
|
const DATE_RE = '[0-9]{4}(-[0-9][0-9]){0,2}';
|
|
const TIME_RE = '([Tt \\t][0-9][0-9]?(:[0-9][0-9]){2})?';
|
|
const FRACTION_RE = '(\\.[0-9]*)?';
|
|
const ZONE_RE = '([ \\t])*(Z|[-+][0-9][0-9]?(:[0-9][0-9])?)?';
|
|
const TIMESTAMP = {
|
|
className: 'number',
|
|
begin: '\\b' + DATE_RE + TIME_RE + FRACTION_RE + ZONE_RE + '\\b'
|
|
};
|
|
|
|
const VALUE_CONTAINER = {
|
|
end: ',',
|
|
endsWithParent: true,
|
|
excludeEnd: true,
|
|
keywords: LITERALS,
|
|
relevance: 0
|
|
};
|
|
const OBJECT = {
|
|
begin: /\{/,
|
|
end: /\}/,
|
|
contains: [VALUE_CONTAINER],
|
|
illegal: '\\n',
|
|
relevance: 0
|
|
};
|
|
const ARRAY = {
|
|
begin: '\\[',
|
|
end: '\\]',
|
|
contains: [VALUE_CONTAINER],
|
|
illegal: '\\n',
|
|
relevance: 0
|
|
};
|
|
|
|
const MODES = [
|
|
KEY,
|
|
{
|
|
className: 'meta',
|
|
begin: '^---\\s*$',
|
|
relevance: 10
|
|
},
|
|
{ // multi line string
|
|
// Blocks start with a | or > followed by a newline
|
|
//
|
|
// Indentation of subsequent lines must be the same to
|
|
// be considered part of the block
|
|
className: 'string',
|
|
begin: '[\\|>]([1-9]?[+-])?[ ]*\\n( +)[^ ][^\\n]*\\n(\\2[^\\n]+\\n?)*'
|
|
},
|
|
{ // Ruby/Rails erb
|
|
begin: '<%[%=-]?',
|
|
end: '[%-]?%>',
|
|
subLanguage: 'ruby',
|
|
excludeBegin: true,
|
|
excludeEnd: true,
|
|
relevance: 0
|
|
},
|
|
{ // named tags
|
|
className: 'type',
|
|
begin: '!\\w+!' + URI_CHARACTERS
|
|
},
|
|
// https://yaml.org/spec/1.2/spec.html#id2784064
|
|
{ // verbatim tags
|
|
className: 'type',
|
|
begin: '!<' + URI_CHARACTERS + ">"
|
|
},
|
|
{ // primary tags
|
|
className: 'type',
|
|
begin: '!' + URI_CHARACTERS
|
|
},
|
|
{ // secondary tags
|
|
className: 'type',
|
|
begin: '!!' + URI_CHARACTERS
|
|
},
|
|
{ // fragment id &ref
|
|
className: 'meta',
|
|
begin: '&' + hljs.UNDERSCORE_IDENT_RE + '$'
|
|
},
|
|
{ // fragment reference *ref
|
|
className: 'meta',
|
|
begin: '\\*' + hljs.UNDERSCORE_IDENT_RE + '$'
|
|
},
|
|
{ // array listing
|
|
className: 'bullet',
|
|
// TODO: remove |$ hack when we have proper look-ahead support
|
|
begin: '-(?=[ ]|$)',
|
|
relevance: 0
|
|
},
|
|
hljs.HASH_COMMENT_MODE,
|
|
{
|
|
beginKeywords: LITERALS,
|
|
keywords: {
|
|
literal: LITERALS
|
|
}
|
|
},
|
|
TIMESTAMP,
|
|
// numbers are any valid C-style number that
|
|
// sit isolated from other words
|
|
{
|
|
className: 'number',
|
|
begin: hljs.C_NUMBER_RE + '\\b',
|
|
relevance: 0
|
|
},
|
|
OBJECT,
|
|
ARRAY,
|
|
STRING
|
|
];
|
|
|
|
const VALUE_MODES = [...MODES];
|
|
VALUE_MODES.pop();
|
|
VALUE_MODES.push(CONTAINER_STRING);
|
|
VALUE_CONTAINER.contains = VALUE_MODES;
|
|
|
|
return {
|
|
name: 'YAML',
|
|
case_insensitive: true,
|
|
aliases: ['yml'],
|
|
contains: MODES
|
|
};
|
|
}
|
|
|
|
var builtIns = /*#__PURE__*/Object.freeze({
|
|
__proto__: null,
|
|
grmr_bash: bash,
|
|
grmr_scss: scss,
|
|
grmr_css: scss,
|
|
grmr_javascript: javascript,
|
|
grmr_json: json,
|
|
grmr_json5: json,
|
|
grmr_xml: xml,
|
|
grmr_markdown: markdown,
|
|
grmr_plaintext: plaintext,
|
|
grmr_shell: shell,
|
|
grmr_typescript: typescript,
|
|
grmr_yaml: yaml
|
|
});
|
|
|
|
const hljs = HighlightJS;
|
|
|
|
for (const key of Object.keys(builtIns)) {
|
|
const languageName = key.replace("grmr_", "");
|
|
hljs.registerLanguage(languageName, builtIns[key]);
|
|
}
|
|
|
|
return hljs;
|
|
|
|
}());
|
|
if (typeof exports === 'object' && typeof module !== 'undefined') { module.exports = hljs; }
|