8423 lines
177 KiB
JavaScript
8423 lines
177 KiB
JavaScript
/*!
|
|
Highlight.js v11.9.0 (git: f47103d4f1)
|
|
(c) 2006-2023 undefined and other contributors
|
|
License: BSD-3-Clause
|
|
*/
|
|
var hljs = (() => {
|
|
function e(n) {
|
|
return (
|
|
n instanceof Map
|
|
? (n.clear =
|
|
n.delete =
|
|
n.set =
|
|
() => {
|
|
throw Error("map is read-only");
|
|
})
|
|
: n instanceof Set &&
|
|
(n.add =
|
|
n.clear =
|
|
n.delete =
|
|
() => {
|
|
throw Error("set is read-only");
|
|
}),
|
|
Object.freeze(n),
|
|
Object.getOwnPropertyNames(n).forEach((t) => {
|
|
const a = n[t],
|
|
i = typeof a;
|
|
("object" !== i && "function" !== i) || Object.isFrozen(a) || e(a);
|
|
}),
|
|
n
|
|
);
|
|
}
|
|
class n {
|
|
constructor(e) {
|
|
void 0 === e.data && (e.data = {}),
|
|
(this.data = e.data),
|
|
(this.isMatchIgnored = !1);
|
|
}
|
|
ignoreMatch() {
|
|
this.isMatchIgnored = !0;
|
|
}
|
|
}
|
|
function t(e) {
|
|
return e
|
|
.replace(/&/g, "&")
|
|
.replace(/</g, "<")
|
|
.replace(/>/g, ">")
|
|
.replace(/"/g, """)
|
|
.replace(/'/g, "'");
|
|
}
|
|
function a(e, ...n) {
|
|
const t = Object.create(null);
|
|
for (const n in e) t[n] = e[n];
|
|
return (
|
|
n.forEach((e) => {
|
|
for (const n in e) t[n] = e[n];
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
const i = (e) => !!e.scope;
|
|
class r {
|
|
constructor(e, n) {
|
|
(this.buffer = ""), (this.classPrefix = n.classPrefix), e.walk(this);
|
|
}
|
|
addText(e) {
|
|
this.buffer += t(e);
|
|
}
|
|
openNode(e) {
|
|
if (!i(e)) return;
|
|
const n = ((e, { prefix: n }) => {
|
|
if (e.startsWith("language:"))
|
|
return e.replace("language:", "language-");
|
|
if (e.includes(".")) {
|
|
const t = e.split(".");
|
|
return [
|
|
`${n}${t.shift()}`,
|
|
...t.map((e, n) => `${e}${"_".repeat(n + 1)}`),
|
|
].join(" ");
|
|
}
|
|
return `${n}${e}`;
|
|
})(e.scope, { prefix: this.classPrefix });
|
|
this.span(n);
|
|
}
|
|
closeNode(e) {
|
|
i(e) && (this.buffer += "</span>");
|
|
}
|
|
value() {
|
|
return this.buffer;
|
|
}
|
|
span(e) {
|
|
this.buffer += `<span class="${e}">`;
|
|
}
|
|
}
|
|
const s = (e = {}) => {
|
|
const n = { children: [] };
|
|
return Object.assign(n, e), n;
|
|
};
|
|
class o {
|
|
constructor() {
|
|
(this.rootNode = s()), (this.stack = [this.rootNode]);
|
|
}
|
|
get top() {
|
|
return this.stack[this.stack.length - 1];
|
|
}
|
|
get root() {
|
|
return this.rootNode;
|
|
}
|
|
add(e) {
|
|
this.top.children.push(e);
|
|
}
|
|
openNode(e) {
|
|
const n = s({ scope: e });
|
|
this.add(n), this.stack.push(n);
|
|
}
|
|
closeNode() {
|
|
if (this.stack.length > 1) return this.stack.pop();
|
|
}
|
|
closeAllNodes() {
|
|
for (; this.closeNode(); );
|
|
}
|
|
toJSON() {
|
|
return JSON.stringify(this.rootNode, null, 4);
|
|
}
|
|
walk(e) {
|
|
return this.constructor._walk(e, this.rootNode);
|
|
}
|
|
static _walk(e, n) {
|
|
return (
|
|
"string" == typeof n
|
|
? e.addText(n)
|
|
: n.children &&
|
|
(e.openNode(n),
|
|
n.children.forEach((n) => o._walk(e, n)),
|
|
e.closeNode(n)),
|
|
e
|
|
);
|
|
}
|
|
static _collapse(e) {
|
|
"string" != typeof e &&
|
|
e.children &&
|
|
(e.children.every((e) => "string" == typeof e)
|
|
? (e.children = [e.children.join("")])
|
|
: e.children.forEach((e) => {
|
|
o._collapse(e);
|
|
}));
|
|
}
|
|
}
|
|
class l extends o {
|
|
constructor(e) {
|
|
super(), (this.options = e);
|
|
}
|
|
addText(e) {
|
|
"" !== e && this.add(e);
|
|
}
|
|
startScope(e) {
|
|
this.openNode(e);
|
|
}
|
|
endScope() {
|
|
this.closeNode();
|
|
}
|
|
__addSublanguage(e, n) {
|
|
const t = e.root;
|
|
n && (t.scope = "language:" + n), this.add(t);
|
|
}
|
|
toHTML() {
|
|
return new r(this, this.options).value();
|
|
}
|
|
finalize() {
|
|
return this.closeAllNodes(), !0;
|
|
}
|
|
}
|
|
function c(e) {
|
|
return e ? ("string" == typeof e ? e : e.source) : null;
|
|
}
|
|
function d(e) {
|
|
return b("(?=", e, ")");
|
|
}
|
|
function g(e) {
|
|
return b("(?:", e, ")*");
|
|
}
|
|
function u(e) {
|
|
return b("(?:", e, ")?");
|
|
}
|
|
function b(...e) {
|
|
return e.map((e) => c(e)).join("");
|
|
}
|
|
function m(...e) {
|
|
const n = ((e) => {
|
|
const n = e[e.length - 1];
|
|
return "object" == typeof n && n.constructor === Object
|
|
? (e.splice(e.length - 1, 1), n)
|
|
: {};
|
|
})(e);
|
|
return "(" + (n.capture ? "" : "?:") + e.map((e) => c(e)).join("|") + ")";
|
|
}
|
|
function p(e) {
|
|
return RegExp(e.toString() + "|").exec("").length - 1;
|
|
}
|
|
const _ = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
|
|
function h(e, { joinWith: n }) {
|
|
let t = 0;
|
|
return e
|
|
.map((e) => {
|
|
t += 1;
|
|
const n = t;
|
|
let a = c(e),
|
|
i = "";
|
|
for (; a.length > 0; ) {
|
|
const e = _.exec(a);
|
|
if (!e) {
|
|
i += a;
|
|
break;
|
|
}
|
|
(i += a.substring(0, e.index)),
|
|
(a = a.substring(e.index + e[0].length)),
|
|
"\\" === e[0][0] && e[1]
|
|
? (i += "\\" + (Number(e[1]) + n))
|
|
: ((i += e[0]), "(" === e[0] && t++);
|
|
}
|
|
return i;
|
|
})
|
|
.map((e) => `(${e})`)
|
|
.join(n);
|
|
}
|
|
const f = "[a-zA-Z]\\w*",
|
|
E = "[a-zA-Z_]\\w*",
|
|
y = "\\b\\d+(\\.\\d+)?",
|
|
N =
|
|
"(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",
|
|
w = "\\b(0b[01]+)",
|
|
v = {
|
|
begin: "\\\\[\\s\\S]",
|
|
relevance: 0,
|
|
},
|
|
O = {
|
|
scope: "string",
|
|
begin: "'",
|
|
end: "'",
|
|
illegal: "\\n",
|
|
contains: [v],
|
|
},
|
|
k = {
|
|
scope: "string",
|
|
begin: '"',
|
|
end: '"',
|
|
illegal: "\\n",
|
|
contains: [v],
|
|
},
|
|
x = (e, n, t = {}) => {
|
|
const i = a({ scope: "comment", begin: e, end: n, contains: [] }, t);
|
|
i.contains.push({
|
|
scope: "doctag",
|
|
begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
|
|
end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
|
|
excludeBegin: !0,
|
|
relevance: 0,
|
|
});
|
|
const r = m(
|
|
"I",
|
|
"a",
|
|
"is",
|
|
"so",
|
|
"us",
|
|
"to",
|
|
"at",
|
|
"if",
|
|
"in",
|
|
"it",
|
|
"on",
|
|
/[A-Za-z]+['](d|ve|re|ll|t|s|n)/,
|
|
/[A-Za-z]+[-][a-z]+/,
|
|
/[A-Za-z][a-z]{2,}/,
|
|
);
|
|
return (
|
|
i.contains.push({
|
|
begin: b(/[ ]+/, "(", r, /[.]?[:]?([.][ ]|[ ])/, "){3}"),
|
|
}),
|
|
i
|
|
);
|
|
},
|
|
M = x("//", "$"),
|
|
S = x("/\\*", "\\*/"),
|
|
A = x("#", "$");
|
|
var C = Object.freeze({
|
|
__proto__: null,
|
|
APOS_STRING_MODE: O,
|
|
BACKSLASH_ESCAPE: v,
|
|
BINARY_NUMBER_MODE: {
|
|
scope: "number",
|
|
begin: w,
|
|
relevance: 0,
|
|
},
|
|
BINARY_NUMBER_RE: w,
|
|
COMMENT: x,
|
|
C_BLOCK_COMMENT_MODE: S,
|
|
C_LINE_COMMENT_MODE: M,
|
|
C_NUMBER_MODE: { scope: "number", begin: N, relevance: 0 },
|
|
C_NUMBER_RE: N,
|
|
END_SAME_AS_BEGIN: (e) =>
|
|
Object.assign(e, {
|
|
"on:begin": (e, n) => {
|
|
n.data._beginMatch = e[1];
|
|
},
|
|
"on:end": (e, n) => {
|
|
n.data._beginMatch !== e[1] && n.ignoreMatch();
|
|
},
|
|
}),
|
|
HASH_COMMENT_MODE: A,
|
|
IDENT_RE: f,
|
|
MATCH_NOTHING_RE: /\b\B/,
|
|
METHOD_GUARD: { begin: "\\.\\s*" + E, relevance: 0 },
|
|
NUMBER_MODE: { scope: "number", begin: y, relevance: 0 },
|
|
NUMBER_RE: y,
|
|
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/,
|
|
},
|
|
QUOTE_STRING_MODE: k,
|
|
REGEXP_MODE: {
|
|
scope: "regexp",
|
|
begin: /\/(?=[^/\n]*\/)/,
|
|
end: /\/[gimuy]*/,
|
|
contains: [v, { begin: /\[/, end: /\]/, relevance: 0, contains: [v] }],
|
|
},
|
|
RE_STARTERS_RE:
|
|
"!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",
|
|
SHEBANG: (e = {}) => {
|
|
const n = /^#![ ]*\//;
|
|
return (
|
|
e.binary && (e.begin = b(n, /.*\b/, e.binary, /\b.*/)),
|
|
a(
|
|
{
|
|
scope: "meta",
|
|
begin: n,
|
|
end: /$/,
|
|
relevance: 0,
|
|
"on:begin": (e, n) => {
|
|
0 !== e.index && n.ignoreMatch();
|
|
},
|
|
},
|
|
e,
|
|
)
|
|
);
|
|
},
|
|
TITLE_MODE: { scope: "title", begin: f, relevance: 0 },
|
|
UNDERSCORE_IDENT_RE: E,
|
|
UNDERSCORE_TITLE_MODE: { scope: "title", begin: E, relevance: 0 },
|
|
});
|
|
function T(e, n) {
|
|
"." === e.input[e.index - 1] && n.ignoreMatch();
|
|
}
|
|
function R(e, n) {
|
|
void 0 !== e.className && ((e.scope = e.className), delete e.className);
|
|
}
|
|
function D(e, n) {
|
|
n &&
|
|
e.beginKeywords &&
|
|
((e.begin =
|
|
"\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)"),
|
|
(e.__beforeBegin = T),
|
|
(e.keywords = e.keywords || e.beginKeywords),
|
|
delete e.beginKeywords,
|
|
void 0 === e.relevance && (e.relevance = 0));
|
|
}
|
|
function I(e, n) {
|
|
Array.isArray(e.illegal) && (e.illegal = m(...e.illegal));
|
|
}
|
|
function L(e, n) {
|
|
if (e.match) {
|
|
if (e.begin || e.end)
|
|
throw Error("begin & end are not supported with match");
|
|
(e.begin = e.match), delete e.match;
|
|
}
|
|
}
|
|
function B(e, n) {
|
|
void 0 === e.relevance && (e.relevance = 1);
|
|
}
|
|
const $ = (e, n) => {
|
|
if (!e.beforeMatch) return;
|
|
if (e.starts) throw Error("beforeMatch cannot be used with starts");
|
|
const t = Object.assign({}, e);
|
|
Object.keys(e).forEach((n) => {
|
|
delete e[n];
|
|
}),
|
|
(e.keywords = t.keywords),
|
|
(e.begin = b(t.beforeMatch, d(t.begin))),
|
|
(e.starts = {
|
|
relevance: 0,
|
|
contains: [Object.assign(t, { endsParent: !0 })],
|
|
}),
|
|
(e.relevance = 0),
|
|
delete t.beforeMatch;
|
|
},
|
|
z = [
|
|
"of",
|
|
"and",
|
|
"for",
|
|
"in",
|
|
"not",
|
|
"or",
|
|
"if",
|
|
"then",
|
|
"parent",
|
|
"list",
|
|
"value",
|
|
],
|
|
F = "keyword";
|
|
function U(e, n, t = F) {
|
|
const a = Object.create(null);
|
|
return (
|
|
"string" == typeof e
|
|
? i(t, e.split(" "))
|
|
: Array.isArray(e)
|
|
? i(t, e)
|
|
: Object.keys(e).forEach((t) => {
|
|
Object.assign(a, U(e[t], n, t));
|
|
}),
|
|
a
|
|
);
|
|
function i(e, t) {
|
|
n && (t = t.map((e) => e.toLowerCase())),
|
|
t.forEach((n) => {
|
|
const t = n.split("|");
|
|
a[t[0]] = [e, j(t[0], t[1])];
|
|
});
|
|
}
|
|
}
|
|
function j(e, n) {
|
|
return n ? Number(n) : ((e) => z.includes(e.toLowerCase()))(e) ? 0 : 1;
|
|
}
|
|
const P = {},
|
|
K = (e) => {
|
|
console.error(e);
|
|
},
|
|
H = (e, ...n) => {
|
|
console.log("WARN: " + e, ...n);
|
|
},
|
|
q = (e, n) => {
|
|
P[`${e}/${n}`] ||
|
|
(console.log(`Deprecated as of ${e}. ${n}`), (P[`${e}/${n}`] = !0));
|
|
},
|
|
G = Error();
|
|
function Z(e, n, { key: t }) {
|
|
let a = 0;
|
|
const i = e[t],
|
|
r = {},
|
|
s = {};
|
|
for (let e = 1; e <= n.length; e++)
|
|
(s[e + a] = i[e]), (r[e + a] = !0), (a += p(n[e - 1]));
|
|
(e[t] = s), (e[t]._emit = r), (e[t]._multi = !0);
|
|
}
|
|
function W(e) {
|
|
((e) => {
|
|
e.scope &&
|
|
"object" == typeof e.scope &&
|
|
null !== e.scope &&
|
|
((e.beginScope = e.scope), delete e.scope);
|
|
})(e),
|
|
"string" == typeof e.beginScope &&
|
|
(e.beginScope = {
|
|
_wrap: e.beginScope,
|
|
}),
|
|
"string" == typeof e.endScope && (e.endScope = { _wrap: e.endScope }),
|
|
((e) => {
|
|
if (Array.isArray(e.begin)) {
|
|
if (e.skip || e.excludeBegin || e.returnBegin)
|
|
throw (
|
|
(K(
|
|
"skip, excludeBegin, returnBegin not compatible with beginScope: {}",
|
|
),
|
|
G)
|
|
);
|
|
if ("object" != typeof e.beginScope || null === e.beginScope)
|
|
throw (K("beginScope must be object"), G);
|
|
Z(e, e.begin, { key: "beginScope" }),
|
|
(e.begin = h(e.begin, { joinWith: "" }));
|
|
}
|
|
})(e),
|
|
((e) => {
|
|
if (Array.isArray(e.end)) {
|
|
if (e.skip || e.excludeEnd || e.returnEnd)
|
|
throw (
|
|
(K(
|
|
"skip, excludeEnd, returnEnd not compatible with endScope: {}",
|
|
),
|
|
G)
|
|
);
|
|
if ("object" != typeof e.endScope || null === e.endScope)
|
|
throw (K("endScope must be object"), G);
|
|
Z(e, e.end, { key: "endScope" }),
|
|
(e.end = h(e.end, { joinWith: "" }));
|
|
}
|
|
})(e);
|
|
}
|
|
function Q(e) {
|
|
function n(n, t) {
|
|
return RegExp(
|
|
c(n),
|
|
"m" +
|
|
(e.case_insensitive ? "i" : "") +
|
|
(e.unicodeRegex ? "u" : "") +
|
|
(t ? "g" : ""),
|
|
);
|
|
}
|
|
class t {
|
|
constructor() {
|
|
(this.matchIndexes = {}),
|
|
(this.regexes = []),
|
|
(this.matchAt = 1),
|
|
(this.position = 0);
|
|
}
|
|
addRule(e, n) {
|
|
(n.position = this.position++),
|
|
(this.matchIndexes[this.matchAt] = n),
|
|
this.regexes.push([n, e]),
|
|
(this.matchAt += p(e) + 1);
|
|
}
|
|
compile() {
|
|
0 === this.regexes.length && (this.exec = () => null);
|
|
const e = this.regexes.map((e) => e[1]);
|
|
(this.matcherRe = n(h(e, { joinWith: "|" }), !0)), (this.lastIndex = 0);
|
|
}
|
|
exec(e) {
|
|
this.matcherRe.lastIndex = this.lastIndex;
|
|
const n = this.matcherRe.exec(e);
|
|
if (!n) return null;
|
|
const t = n.findIndex((e, n) => n > 0 && void 0 !== e),
|
|
a = this.matchIndexes[t];
|
|
return n.splice(0, t), Object.assign(n, a);
|
|
}
|
|
}
|
|
class i {
|
|
constructor() {
|
|
(this.rules = []),
|
|
(this.multiRegexes = []),
|
|
(this.count = 0),
|
|
(this.lastIndex = 0),
|
|
(this.regexIndex = 0);
|
|
}
|
|
getMatcher(e) {
|
|
if (this.multiRegexes[e]) return this.multiRegexes[e];
|
|
const n = new t();
|
|
return (
|
|
this.rules.slice(e).forEach(([e, t]) => n.addRule(e, t)),
|
|
n.compile(),
|
|
(this.multiRegexes[e] = n),
|
|
n
|
|
);
|
|
}
|
|
resumingScanAtSamePosition() {
|
|
return 0 !== this.regexIndex;
|
|
}
|
|
considerAll() {
|
|
this.regexIndex = 0;
|
|
}
|
|
addRule(e, n) {
|
|
this.rules.push([e, n]), "begin" === n.type && this.count++;
|
|
}
|
|
exec(e) {
|
|
const n = this.getMatcher(this.regexIndex);
|
|
n.lastIndex = this.lastIndex;
|
|
let t = n.exec(e);
|
|
if (this.resumingScanAtSamePosition())
|
|
if (t && t.index === this.lastIndex);
|
|
else {
|
|
const n = this.getMatcher(0);
|
|
(n.lastIndex = this.lastIndex + 1), (t = n.exec(e));
|
|
}
|
|
return (
|
|
t &&
|
|
((this.regexIndex += t.position + 1),
|
|
this.regexIndex === this.count && this.considerAll()),
|
|
t
|
|
);
|
|
}
|
|
}
|
|
if (
|
|
(e.compilerExtensions || (e.compilerExtensions = []),
|
|
e.contains && e.contains.includes("self"))
|
|
)
|
|
throw Error(
|
|
"ERR: contains `self` is not supported at the top-level of a language. See documentation.",
|
|
);
|
|
return (
|
|
(e.classNameAliases = a(e.classNameAliases || {})),
|
|
(function t(r, s) {
|
|
const o = r;
|
|
if (r.isCompiled) return o;
|
|
[R, L, W, $].forEach((e) => e(r, s)),
|
|
e.compilerExtensions.forEach((e) => e(r, s)),
|
|
(r.__beforeBegin = null),
|
|
[D, I, B].forEach((e) => e(r, s)),
|
|
(r.isCompiled = !0);
|
|
let l = null;
|
|
return (
|
|
"object" == typeof r.keywords &&
|
|
r.keywords.$pattern &&
|
|
((r.keywords = Object.assign({}, r.keywords)),
|
|
(l = r.keywords.$pattern),
|
|
delete r.keywords.$pattern),
|
|
(l = l || /\w+/),
|
|
r.keywords && (r.keywords = U(r.keywords, e.case_insensitive)),
|
|
(o.keywordPatternRe = n(l, !0)),
|
|
s &&
|
|
(r.begin || (r.begin = /\B|\b/),
|
|
(o.beginRe = n(o.begin)),
|
|
r.end || r.endsWithParent || (r.end = /\B|\b/),
|
|
r.end && (o.endRe = n(o.end)),
|
|
(o.terminatorEnd = c(o.end) || ""),
|
|
r.endsWithParent &&
|
|
s.terminatorEnd &&
|
|
(o.terminatorEnd += (r.end ? "|" : "") + s.terminatorEnd)),
|
|
r.illegal && (o.illegalRe = n(r.illegal)),
|
|
r.contains || (r.contains = []),
|
|
(r.contains = [].concat(
|
|
...r.contains.map((e) =>
|
|
((e) => (
|
|
e.variants &&
|
|
!e.cachedVariants &&
|
|
(e.cachedVariants = e.variants.map((n) =>
|
|
a(
|
|
e,
|
|
{
|
|
variants: null,
|
|
},
|
|
n,
|
|
),
|
|
)),
|
|
e.cachedVariants
|
|
? e.cachedVariants
|
|
: X(e)
|
|
? a(e, {
|
|
starts: e.starts ? a(e.starts) : null,
|
|
})
|
|
: Object.isFrozen(e)
|
|
? a(e)
|
|
: e
|
|
))("self" === e ? r : e),
|
|
),
|
|
)),
|
|
r.contains.forEach((e) => {
|
|
t(e, o);
|
|
}),
|
|
r.starts && t(r.starts, s),
|
|
(o.matcher = ((e) => {
|
|
const n = new i();
|
|
return (
|
|
e.contains.forEach((e) =>
|
|
n.addRule(e.begin, { rule: e, type: "begin" }),
|
|
),
|
|
e.terminatorEnd && n.addRule(e.terminatorEnd, { type: "end" }),
|
|
e.illegal && n.addRule(e.illegal, { type: "illegal" }),
|
|
n
|
|
);
|
|
})(o)),
|
|
o
|
|
);
|
|
})(e)
|
|
);
|
|
}
|
|
function X(e) {
|
|
return !!e && (e.endsWithParent || X(e.starts));
|
|
}
|
|
class V extends Error {
|
|
constructor(e, n) {
|
|
super(e), (this.name = "HTMLInjectionError"), (this.html = n);
|
|
}
|
|
}
|
|
const J = t,
|
|
Y = a,
|
|
ee = Symbol("nomatch"),
|
|
ne = (t) => {
|
|
const a = Object.create(null),
|
|
i = Object.create(null),
|
|
r = [];
|
|
let s = !0;
|
|
const o =
|
|
"Could not find the language '{}', did you forget to load/include a language module?",
|
|
c = {
|
|
disableAutodetect: !0,
|
|
name: "Plain text",
|
|
contains: [],
|
|
};
|
|
let p = {
|
|
ignoreUnescapedHTML: !1,
|
|
throwUnescapedHTML: !1,
|
|
noHighlightRe: /^(no-?highlight)$/i,
|
|
languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
|
|
classPrefix: "hljs-",
|
|
cssSelector: "pre code",
|
|
languages: null,
|
|
__emitter: l,
|
|
};
|
|
function _(e) {
|
|
return p.noHighlightRe.test(e);
|
|
}
|
|
function h(e, n, t) {
|
|
let a = "",
|
|
i = "";
|
|
"object" == typeof n
|
|
? ((a = e), (t = n.ignoreIllegals), (i = n.language))
|
|
: (q("10.7.0", "highlight(lang, code, ...args) has been deprecated."),
|
|
q(
|
|
"10.7.0",
|
|
"Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277",
|
|
),
|
|
(i = e),
|
|
(a = n)),
|
|
void 0 === t && (t = !0);
|
|
const r = { code: a, language: i };
|
|
x("before:highlight", r);
|
|
const s = r.result ? r.result : f(r.language, r.code, t);
|
|
return (s.code = r.code), x("after:highlight", s), s;
|
|
}
|
|
function f(e, t, i, r) {
|
|
const l = Object.create(null);
|
|
function c() {
|
|
if (!x.keywords) return void S.addText(A);
|
|
let e = 0;
|
|
x.keywordPatternRe.lastIndex = 0;
|
|
let n = x.keywordPatternRe.exec(A),
|
|
t = "";
|
|
for (; n; ) {
|
|
t += A.substring(e, n.index);
|
|
const i = w.case_insensitive ? n[0].toLowerCase() : n[0],
|
|
r = ((a = i), x.keywords[a]);
|
|
if (r) {
|
|
const [e, a] = r;
|
|
if (
|
|
(S.addText(t),
|
|
(t = ""),
|
|
(l[i] = (l[i] || 0) + 1),
|
|
l[i] <= 7 && (C += a),
|
|
e.startsWith("_"))
|
|
)
|
|
t += n[0];
|
|
else {
|
|
const t = w.classNameAliases[e] || e;
|
|
g(n[0], t);
|
|
}
|
|
} else t += n[0];
|
|
(e = x.keywordPatternRe.lastIndex),
|
|
(n = x.keywordPatternRe.exec(A));
|
|
}
|
|
var a;
|
|
(t += A.substring(e)), S.addText(t);
|
|
}
|
|
function d() {
|
|
null != x.subLanguage
|
|
? (() => {
|
|
if ("" === A) return;
|
|
let e = null;
|
|
if ("string" == typeof x.subLanguage) {
|
|
if (!a[x.subLanguage]) return void S.addText(A);
|
|
(e = f(x.subLanguage, A, !0, M[x.subLanguage])),
|
|
(M[x.subLanguage] = e._top);
|
|
} else e = E(A, x.subLanguage.length ? x.subLanguage : null);
|
|
x.relevance > 0 && (C += e.relevance),
|
|
S.__addSublanguage(e._emitter, e.language);
|
|
})()
|
|
: c(),
|
|
(A = "");
|
|
}
|
|
function g(e, n) {
|
|
"" !== e && (S.startScope(n), S.addText(e), S.endScope());
|
|
}
|
|
function u(e, n) {
|
|
let t = 1;
|
|
const a = n.length - 1;
|
|
for (; t <= a; ) {
|
|
if (!e._emit[t]) {
|
|
t++;
|
|
continue;
|
|
}
|
|
const a = w.classNameAliases[e[t]] || e[t],
|
|
i = n[t];
|
|
a ? g(i, a) : ((A = i), c(), (A = "")), t++;
|
|
}
|
|
}
|
|
function b(e, n) {
|
|
return (
|
|
e.scope &&
|
|
"string" == typeof e.scope &&
|
|
S.openNode(w.classNameAliases[e.scope] || e.scope),
|
|
e.beginScope &&
|
|
(e.beginScope._wrap
|
|
? (g(
|
|
A,
|
|
w.classNameAliases[e.beginScope._wrap] ||
|
|
e.beginScope._wrap,
|
|
),
|
|
(A = ""))
|
|
: e.beginScope._multi && (u(e.beginScope, n), (A = ""))),
|
|
(x = Object.create(e, {
|
|
parent: {
|
|
value: x,
|
|
},
|
|
})),
|
|
x
|
|
);
|
|
}
|
|
function m(e, t, a) {
|
|
let i = ((e, n) => {
|
|
const t = e && e.exec(n);
|
|
return t && 0 === t.index;
|
|
})(e.endRe, a);
|
|
if (i) {
|
|
if (e["on:end"]) {
|
|
const a = new n(e);
|
|
e["on:end"](t, a), a.isMatchIgnored && (i = !1);
|
|
}
|
|
if (i) {
|
|
for (; e.endsParent && e.parent; ) e = e.parent;
|
|
return e;
|
|
}
|
|
}
|
|
if (e.endsWithParent) return m(e.parent, t, a);
|
|
}
|
|
function _(e) {
|
|
return 0 === x.matcher.regexIndex ? ((A += e[0]), 1) : ((D = !0), 0);
|
|
}
|
|
function h(e) {
|
|
const n = e[0],
|
|
a = t.substring(e.index),
|
|
i = m(x, e, a);
|
|
if (!i) return ee;
|
|
const r = x;
|
|
x.endScope && x.endScope._wrap
|
|
? (d(), g(n, x.endScope._wrap))
|
|
: x.endScope && x.endScope._multi
|
|
? (d(), u(x.endScope, e))
|
|
: r.skip
|
|
? (A += n)
|
|
: (r.returnEnd || r.excludeEnd || (A += n),
|
|
d(),
|
|
r.excludeEnd && (A = n));
|
|
do {
|
|
x.scope && S.closeNode(),
|
|
x.skip || x.subLanguage || (C += x.relevance),
|
|
(x = x.parent);
|
|
} while (x !== i.parent);
|
|
return i.starts && b(i.starts, e), r.returnEnd ? 0 : n.length;
|
|
}
|
|
let y = {};
|
|
function N(a, r) {
|
|
const o = r && r[0];
|
|
if (((A += a), null == o)) return d(), 0;
|
|
if (
|
|
"begin" === y.type &&
|
|
"end" === r.type &&
|
|
y.index === r.index &&
|
|
"" === o
|
|
) {
|
|
if (((A += t.slice(r.index, r.index + 1)), !s)) {
|
|
const n = Error(`0 width match regex (${e})`);
|
|
throw ((n.languageName = e), (n.badRule = y.rule), n);
|
|
}
|
|
return 1;
|
|
}
|
|
if (((y = r), "begin" === r.type))
|
|
return ((e) => {
|
|
const t = e[0],
|
|
a = e.rule,
|
|
i = new n(a),
|
|
r = [a.__beforeBegin, a["on:begin"]];
|
|
for (const n of r)
|
|
if (n && (n(e, i), i.isMatchIgnored)) return _(t);
|
|
return (
|
|
a.skip
|
|
? (A += t)
|
|
: (a.excludeBegin && (A += t),
|
|
d(),
|
|
a.returnBegin || a.excludeBegin || (A = t)),
|
|
b(a, e),
|
|
a.returnBegin ? 0 : t.length
|
|
);
|
|
})(r);
|
|
if ("illegal" === r.type && !i) {
|
|
const e = Error(
|
|
'Illegal lexeme "' +
|
|
o +
|
|
'" for mode "' +
|
|
(x.scope || "<unnamed>") +
|
|
'"',
|
|
);
|
|
throw ((e.mode = x), e);
|
|
}
|
|
if ("end" === r.type) {
|
|
const e = h(r);
|
|
if (e !== ee) return e;
|
|
}
|
|
if ("illegal" === r.type && "" === o) return 1;
|
|
if (R > 1e5 && R > 3 * r.index)
|
|
throw Error(
|
|
"potential infinite loop, way more iterations than matches",
|
|
);
|
|
return (A += o), o.length;
|
|
}
|
|
const w = v(e);
|
|
if (!w)
|
|
throw (K(o.replace("{}", e)), Error('Unknown language: "' + e + '"'));
|
|
const O = Q(w);
|
|
let k = "",
|
|
x = r || O;
|
|
const M = {},
|
|
S = new p.__emitter(p);
|
|
(() => {
|
|
const e = [];
|
|
for (let n = x; n !== w; n = n.parent) n.scope && e.unshift(n.scope);
|
|
e.forEach((e) => S.openNode(e));
|
|
})();
|
|
let A = "",
|
|
C = 0,
|
|
T = 0,
|
|
R = 0,
|
|
D = !1;
|
|
try {
|
|
if (w.__emitTokens) w.__emitTokens(t, S);
|
|
else {
|
|
for (x.matcher.considerAll(); ; ) {
|
|
R++,
|
|
D ? (D = !1) : x.matcher.considerAll(),
|
|
(x.matcher.lastIndex = T);
|
|
const e = x.matcher.exec(t);
|
|
if (!e) break;
|
|
const n = N(t.substring(T, e.index), e);
|
|
T = e.index + n;
|
|
}
|
|
N(t.substring(T));
|
|
}
|
|
return (
|
|
S.finalize(),
|
|
(k = S.toHTML()),
|
|
{
|
|
language: e,
|
|
value: k,
|
|
relevance: C,
|
|
illegal: !1,
|
|
_emitter: S,
|
|
_top: x,
|
|
}
|
|
);
|
|
} catch (n) {
|
|
if (n.message && n.message.includes("Illegal"))
|
|
return {
|
|
language: e,
|
|
value: J(t),
|
|
illegal: !0,
|
|
relevance: 0,
|
|
_illegalBy: {
|
|
message: n.message,
|
|
index: T,
|
|
context: t.slice(T - 100, T + 100),
|
|
mode: n.mode,
|
|
resultSoFar: k,
|
|
},
|
|
_emitter: S,
|
|
};
|
|
if (s)
|
|
return {
|
|
language: e,
|
|
value: J(t),
|
|
illegal: !1,
|
|
relevance: 0,
|
|
errorRaised: n,
|
|
_emitter: S,
|
|
_top: x,
|
|
};
|
|
throw n;
|
|
}
|
|
}
|
|
function E(e, n) {
|
|
n = n || p.languages || Object.keys(a);
|
|
const t = ((e) => {
|
|
const n = {
|
|
value: J(e),
|
|
illegal: !1,
|
|
relevance: 0,
|
|
_top: c,
|
|
_emitter: new p.__emitter(p),
|
|
};
|
|
return n._emitter.addText(e), n;
|
|
})(e),
|
|
i = n
|
|
.filter(v)
|
|
.filter(k)
|
|
.map((n) => f(n, e, !1));
|
|
i.unshift(t);
|
|
const r = i.sort((e, n) => {
|
|
if (e.relevance !== n.relevance) return n.relevance - e.relevance;
|
|
if (e.language && n.language) {
|
|
if (v(e.language).supersetOf === n.language) return 1;
|
|
if (v(n.language).supersetOf === e.language) return -1;
|
|
}
|
|
return 0;
|
|
}),
|
|
[s, o] = r,
|
|
l = s;
|
|
return (l.secondBest = o), l;
|
|
}
|
|
function y(e) {
|
|
let n = null;
|
|
const t = ((e) => {
|
|
let n = e.className + " ";
|
|
n += e.parentNode ? e.parentNode.className : "";
|
|
const t = p.languageDetectRe.exec(n);
|
|
if (t) {
|
|
const n = v(t[1]);
|
|
return (
|
|
n ||
|
|
(H(o.replace("{}", t[1])),
|
|
H("Falling back to no-highlight mode for this block.", e)),
|
|
n ? t[1] : "no-highlight"
|
|
);
|
|
}
|
|
return n.split(/\s+/).find((e) => _(e) || v(e));
|
|
})(e);
|
|
if (_(t)) return;
|
|
if (
|
|
(x("before:highlightElement", { el: e, language: t }),
|
|
e.dataset.highlighted)
|
|
)
|
|
return void console.log(
|
|
"Element previously highlighted. To highlight again, first unset `dataset.highlighted`.",
|
|
e,
|
|
);
|
|
if (
|
|
e.children.length > 0 &&
|
|
(p.ignoreUnescapedHTML ||
|
|
(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/wiki/security",
|
|
),
|
|
console.warn("The element with unescaped HTML:"),
|
|
console.warn(e)),
|
|
p.throwUnescapedHTML)
|
|
)
|
|
throw new V(
|
|
"One of your code blocks includes unescaped HTML.",
|
|
e.innerHTML,
|
|
);
|
|
n = e;
|
|
const a = n.textContent,
|
|
r = t ? h(a, { language: t, ignoreIllegals: !0 }) : E(a);
|
|
(e.innerHTML = r.value),
|
|
(e.dataset.highlighted = "yes"),
|
|
((e, n, t) => {
|
|
const a = (n && i[n]) || t;
|
|
e.classList.add("hljs"), e.classList.add("language-" + a);
|
|
})(e, t, r.language),
|
|
(e.result = {
|
|
language: r.language,
|
|
re: r.relevance,
|
|
relevance: r.relevance,
|
|
}),
|
|
r.secondBest &&
|
|
(e.secondBest = {
|
|
language: r.secondBest.language,
|
|
relevance: r.secondBest.relevance,
|
|
}),
|
|
x("after:highlightElement", { el: e, result: r, text: a });
|
|
}
|
|
let N = !1;
|
|
function w() {
|
|
"loading" !== document.readyState
|
|
? document.querySelectorAll(p.cssSelector).forEach(y)
|
|
: (N = !0);
|
|
}
|
|
function v(e) {
|
|
return (e = (e || "").toLowerCase()), a[e] || a[i[e]];
|
|
}
|
|
function O(e, { languageName: n }) {
|
|
"string" == typeof e && (e = [e]),
|
|
e.forEach((e) => {
|
|
i[e.toLowerCase()] = n;
|
|
});
|
|
}
|
|
function k(e) {
|
|
const n = v(e);
|
|
return n && !n.disableAutodetect;
|
|
}
|
|
function x(e, n) {
|
|
const t = e;
|
|
r.forEach((e) => {
|
|
e[t] && e[t](n);
|
|
});
|
|
}
|
|
"undefined" != typeof window &&
|
|
window.addEventListener &&
|
|
window.addEventListener(
|
|
"DOMContentLoaded",
|
|
() => {
|
|
N && w();
|
|
},
|
|
!1,
|
|
),
|
|
Object.assign(t, {
|
|
highlight: h,
|
|
highlightAuto: E,
|
|
highlightAll: w,
|
|
highlightElement: y,
|
|
highlightBlock: (e) => (
|
|
q("10.7.0", "highlightBlock will be removed entirely in v12.0"),
|
|
q("10.7.0", "Please use highlightElement now."),
|
|
y(e)
|
|
),
|
|
configure: (e) => {
|
|
p = Y(p, e);
|
|
},
|
|
initHighlighting: () => {
|
|
w(),
|
|
q(
|
|
"10.6.0",
|
|
"initHighlighting() deprecated. Use highlightAll() now.",
|
|
);
|
|
},
|
|
initHighlightingOnLoad: () => {
|
|
w(),
|
|
q(
|
|
"10.6.0",
|
|
"initHighlightingOnLoad() deprecated. Use highlightAll() now.",
|
|
);
|
|
},
|
|
registerLanguage: (e, n) => {
|
|
let i = null;
|
|
try {
|
|
i = n(t);
|
|
} catch (n) {
|
|
if (
|
|
(K(
|
|
"Language definition for '{}' could not be registered.".replace(
|
|
"{}",
|
|
e,
|
|
),
|
|
),
|
|
!s)
|
|
)
|
|
throw n;
|
|
K(n), (i = c);
|
|
}
|
|
i.name || (i.name = e),
|
|
(a[e] = i),
|
|
(i.rawDefinition = n.bind(null, t)),
|
|
i.aliases &&
|
|
O(i.aliases, {
|
|
languageName: e,
|
|
});
|
|
},
|
|
unregisterLanguage: (e) => {
|
|
delete a[e];
|
|
for (const n of Object.keys(i)) i[n] === e && delete i[n];
|
|
},
|
|
listLanguages: () => Object.keys(a),
|
|
getLanguage: v,
|
|
registerAliases: O,
|
|
autoDetection: k,
|
|
inherit: Y,
|
|
addPlugin: (e) => {
|
|
((e) => {
|
|
e["before:highlightBlock"] &&
|
|
!e["before:highlightElement"] &&
|
|
(e["before:highlightElement"] = (n) => {
|
|
e["before:highlightBlock"](Object.assign({ block: n.el }, n));
|
|
}),
|
|
e["after:highlightBlock"] &&
|
|
!e["after:highlightElement"] &&
|
|
(e["after:highlightElement"] = (n) => {
|
|
e["after:highlightBlock"](
|
|
Object.assign({ block: n.el }, n),
|
|
);
|
|
});
|
|
})(e),
|
|
r.push(e);
|
|
},
|
|
removePlugin: (e) => {
|
|
const n = r.indexOf(e);
|
|
-1 !== n && r.splice(n, 1);
|
|
},
|
|
}),
|
|
(t.debugMode = () => {
|
|
s = !1;
|
|
}),
|
|
(t.safeMode = () => {
|
|
s = !0;
|
|
}),
|
|
(t.versionString = "11.9.0"),
|
|
(t.regex = {
|
|
concat: b,
|
|
lookahead: d,
|
|
either: m,
|
|
optional: u,
|
|
anyNumberOfTimes: g,
|
|
});
|
|
for (const n in C) "object" == typeof C[n] && e(C[n]);
|
|
return Object.assign(t, C), t;
|
|
},
|
|
te = ne({});
|
|
te.newInstance = () => ne({});
|
|
var ae = te;
|
|
const ie = (e) => ({
|
|
IMPORTANT: {
|
|
scope: "meta",
|
|
begin: "!important",
|
|
},
|
|
BLOCK_COMMENT: e.C_BLOCK_COMMENT_MODE,
|
|
HEXCOLOR: {
|
|
scope: "number",
|
|
begin: /#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/,
|
|
},
|
|
FUNCTION_DISPATCH: { className: "built_in", begin: /[\w-]+(?=\()/ },
|
|
ATTRIBUTE_SELECTOR_MODE: {
|
|
scope: "selector-attr",
|
|
begin: /\[/,
|
|
end: /\]/,
|
|
illegal: "$",
|
|
contains: [e.APOS_STRING_MODE, e.QUOTE_STRING_MODE],
|
|
},
|
|
CSS_NUMBER_MODE: {
|
|
scope: "number",
|
|
begin:
|
|
e.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,
|
|
},
|
|
CSS_VARIABLE: { className: "attr", begin: /--[A-Za-z_][A-Za-z0-9_-]*/ },
|
|
}),
|
|
re = [
|
|
"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",
|
|
],
|
|
se = [
|
|
"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",
|
|
"min-width",
|
|
"max-width",
|
|
"min-height",
|
|
"max-height",
|
|
],
|
|
oe = [
|
|
"active",
|
|
"any-link",
|
|
"blank",
|
|
"checked",
|
|
"current",
|
|
"default",
|
|
"defined",
|
|
"dir",
|
|
"disabled",
|
|
"drop",
|
|
"empty",
|
|
"enabled",
|
|
"first",
|
|
"first-child",
|
|
"first-of-type",
|
|
"fullscreen",
|
|
"future",
|
|
"focus",
|
|
"focus-visible",
|
|
"focus-within",
|
|
"has",
|
|
"host",
|
|
"host-context",
|
|
"hover",
|
|
"indeterminate",
|
|
"in-range",
|
|
"invalid",
|
|
"is",
|
|
"lang",
|
|
"last-child",
|
|
"last-of-type",
|
|
"left",
|
|
"link",
|
|
"local-link",
|
|
"not",
|
|
"nth-child",
|
|
"nth-col",
|
|
"nth-last-child",
|
|
"nth-last-col",
|
|
"nth-last-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",
|
|
],
|
|
le = [
|
|
"after",
|
|
"backdrop",
|
|
"before",
|
|
"cue",
|
|
"cue-region",
|
|
"first-letter",
|
|
"first-line",
|
|
"grammar-error",
|
|
"marker",
|
|
"part",
|
|
"placeholder",
|
|
"selection",
|
|
"slotted",
|
|
"spelling-error",
|
|
],
|
|
ce = [
|
|
"align-content",
|
|
"align-items",
|
|
"align-self",
|
|
"all",
|
|
"animation",
|
|
"animation-delay",
|
|
"animation-direction",
|
|
"animation-duration",
|
|
"animation-fill-mode",
|
|
"animation-iteration-count",
|
|
"animation-name",
|
|
"animation-play-state",
|
|
"animation-timing-function",
|
|
"backface-visibility",
|
|
"background",
|
|
"background-attachment",
|
|
"background-blend-mode",
|
|
"background-clip",
|
|
"background-color",
|
|
"background-image",
|
|
"background-origin",
|
|
"background-position",
|
|
"background-repeat",
|
|
"background-size",
|
|
"block-size",
|
|
"border",
|
|
"border-block",
|
|
"border-block-color",
|
|
"border-block-end",
|
|
"border-block-end-color",
|
|
"border-block-end-style",
|
|
"border-block-end-width",
|
|
"border-block-start",
|
|
"border-block-start-color",
|
|
"border-block-start-style",
|
|
"border-block-start-width",
|
|
"border-block-style",
|
|
"border-block-width",
|
|
"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-inline",
|
|
"border-inline-color",
|
|
"border-inline-end",
|
|
"border-inline-end-color",
|
|
"border-inline-end-style",
|
|
"border-inline-end-width",
|
|
"border-inline-start",
|
|
"border-inline-start-color",
|
|
"border-inline-start-style",
|
|
"border-inline-start-width",
|
|
"border-inline-style",
|
|
"border-inline-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",
|
|
"caret-color",
|
|
"clear",
|
|
"clip",
|
|
"clip-path",
|
|
"clip-rule",
|
|
"color",
|
|
"column-count",
|
|
"column-fill",
|
|
"column-gap",
|
|
"column-rule",
|
|
"column-rule-color",
|
|
"column-rule-style",
|
|
"column-rule-width",
|
|
"column-span",
|
|
"column-width",
|
|
"columns",
|
|
"contain",
|
|
"content",
|
|
"content-visibility",
|
|
"counter-increment",
|
|
"counter-reset",
|
|
"cue",
|
|
"cue-after",
|
|
"cue-before",
|
|
"cursor",
|
|
"direction",
|
|
"display",
|
|
"empty-cells",
|
|
"filter",
|
|
"flex",
|
|
"flex-basis",
|
|
"flex-direction",
|
|
"flex-flow",
|
|
"flex-grow",
|
|
"flex-shrink",
|
|
"flex-wrap",
|
|
"float",
|
|
"flow",
|
|
"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-synthesis",
|
|
"font-variant",
|
|
"font-variant-caps",
|
|
"font-variant-east-asian",
|
|
"font-variant-ligatures",
|
|
"font-variant-numeric",
|
|
"font-variant-position",
|
|
"font-variation-settings",
|
|
"font-weight",
|
|
"gap",
|
|
"glyph-orientation-vertical",
|
|
"grid",
|
|
"grid-area",
|
|
"grid-auto-columns",
|
|
"grid-auto-flow",
|
|
"grid-auto-rows",
|
|
"grid-column",
|
|
"grid-column-end",
|
|
"grid-column-start",
|
|
"grid-gap",
|
|
"grid-row",
|
|
"grid-row-end",
|
|
"grid-row-start",
|
|
"grid-template",
|
|
"grid-template-areas",
|
|
"grid-template-columns",
|
|
"grid-template-rows",
|
|
"hanging-punctuation",
|
|
"height",
|
|
"hyphens",
|
|
"icon",
|
|
"image-orientation",
|
|
"image-rendering",
|
|
"image-resolution",
|
|
"ime-mode",
|
|
"inline-size",
|
|
"isolation",
|
|
"justify-content",
|
|
"left",
|
|
"letter-spacing",
|
|
"line-break",
|
|
"line-height",
|
|
"list-style",
|
|
"list-style-image",
|
|
"list-style-position",
|
|
"list-style-type",
|
|
"margin",
|
|
"margin-block",
|
|
"margin-block-end",
|
|
"margin-block-start",
|
|
"margin-bottom",
|
|
"margin-inline",
|
|
"margin-inline-end",
|
|
"margin-inline-start",
|
|
"margin-left",
|
|
"margin-right",
|
|
"margin-top",
|
|
"marks",
|
|
"mask",
|
|
"mask-border",
|
|
"mask-border-mode",
|
|
"mask-border-outset",
|
|
"mask-border-repeat",
|
|
"mask-border-slice",
|
|
"mask-border-source",
|
|
"mask-border-width",
|
|
"mask-clip",
|
|
"mask-composite",
|
|
"mask-image",
|
|
"mask-mode",
|
|
"mask-origin",
|
|
"mask-position",
|
|
"mask-repeat",
|
|
"mask-size",
|
|
"mask-type",
|
|
"max-block-size",
|
|
"max-height",
|
|
"max-inline-size",
|
|
"max-width",
|
|
"min-block-size",
|
|
"min-height",
|
|
"min-inline-size",
|
|
"min-width",
|
|
"mix-blend-mode",
|
|
"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-block",
|
|
"padding-block-end",
|
|
"padding-block-start",
|
|
"padding-bottom",
|
|
"padding-inline",
|
|
"padding-inline-end",
|
|
"padding-inline-start",
|
|
"padding-left",
|
|
"padding-right",
|
|
"padding-top",
|
|
"page-break-after",
|
|
"page-break-before",
|
|
"page-break-inside",
|
|
"pause",
|
|
"pause-after",
|
|
"pause-before",
|
|
"perspective",
|
|
"perspective-origin",
|
|
"pointer-events",
|
|
"position",
|
|
"quotes",
|
|
"resize",
|
|
"rest",
|
|
"rest-after",
|
|
"rest-before",
|
|
"right",
|
|
"row-gap",
|
|
"scroll-margin",
|
|
"scroll-margin-block",
|
|
"scroll-margin-block-end",
|
|
"scroll-margin-block-start",
|
|
"scroll-margin-bottom",
|
|
"scroll-margin-inline",
|
|
"scroll-margin-inline-end",
|
|
"scroll-margin-inline-start",
|
|
"scroll-margin-left",
|
|
"scroll-margin-right",
|
|
"scroll-margin-top",
|
|
"scroll-padding",
|
|
"scroll-padding-block",
|
|
"scroll-padding-block-end",
|
|
"scroll-padding-block-start",
|
|
"scroll-padding-bottom",
|
|
"scroll-padding-inline",
|
|
"scroll-padding-inline-end",
|
|
"scroll-padding-inline-start",
|
|
"scroll-padding-left",
|
|
"scroll-padding-right",
|
|
"scroll-padding-top",
|
|
"scroll-snap-align",
|
|
"scroll-snap-stop",
|
|
"scroll-snap-type",
|
|
"scrollbar-color",
|
|
"scrollbar-gutter",
|
|
"scrollbar-width",
|
|
"shape-image-threshold",
|
|
"shape-margin",
|
|
"shape-outside",
|
|
"speak",
|
|
"speak-as",
|
|
"src",
|
|
"tab-size",
|
|
"table-layout",
|
|
"text-align",
|
|
"text-align-all",
|
|
"text-align-last",
|
|
"text-combine-upright",
|
|
"text-decoration",
|
|
"text-decoration-color",
|
|
"text-decoration-line",
|
|
"text-decoration-style",
|
|
"text-emphasis",
|
|
"text-emphasis-color",
|
|
"text-emphasis-position",
|
|
"text-emphasis-style",
|
|
"text-indent",
|
|
"text-justify",
|
|
"text-orientation",
|
|
"text-overflow",
|
|
"text-rendering",
|
|
"text-shadow",
|
|
"text-transform",
|
|
"text-underline-position",
|
|
"top",
|
|
"transform",
|
|
"transform-box",
|
|
"transform-origin",
|
|
"transform-style",
|
|
"transition",
|
|
"transition-delay",
|
|
"transition-duration",
|
|
"transition-property",
|
|
"transition-timing-function",
|
|
"unicode-bidi",
|
|
"vertical-align",
|
|
"visibility",
|
|
"voice-balance",
|
|
"voice-duration",
|
|
"voice-family",
|
|
"voice-pitch",
|
|
"voice-range",
|
|
"voice-rate",
|
|
"voice-stress",
|
|
"voice-volume",
|
|
"white-space",
|
|
"widows",
|
|
"width",
|
|
"will-change",
|
|
"word-break",
|
|
"word-spacing",
|
|
"word-wrap",
|
|
"writing-mode",
|
|
"z-index",
|
|
].reverse(),
|
|
de = oe.concat(le);
|
|
var ge = "[0-9](_*[0-9])*",
|
|
ue = `\\.(${ge})`,
|
|
be = "[0-9a-fA-F](_*[0-9a-fA-F])*",
|
|
me = {
|
|
className: "number",
|
|
variants: [
|
|
{
|
|
begin: `(\\b(${ge})((${ue})|\\.)?|(${ue}))[eE][+-]?(${ge})[fFdD]?\\b`,
|
|
},
|
|
{
|
|
begin: `\\b(${ge})((${ue})[fFdD]?\\b|\\.([fFdD]\\b)?)`,
|
|
},
|
|
{
|
|
begin: `(${ue})[fFdD]?\\b`,
|
|
},
|
|
{ begin: `\\b(${ge})[fFdD]\\b` },
|
|
{
|
|
begin: `\\b0[xX]((${be})\\.?|(${be})?\\.(${be}))[pP][+-]?(${ge})[fFdD]?\\b`,
|
|
},
|
|
{
|
|
begin: "\\b(0|[1-9](_*[0-9])*)[lL]?\\b",
|
|
},
|
|
{ begin: `\\b0[xX](${be})[lL]?\\b` },
|
|
{
|
|
begin: "\\b0(_*[0-7])*[lL]?\\b",
|
|
},
|
|
{ begin: "\\b0[bB][01](_*[01])*[lL]?\\b" },
|
|
],
|
|
relevance: 0,
|
|
};
|
|
function pe(e, n, t) {
|
|
return -1 === t ? "" : e.replace(n, (a) => pe(e, n, t - 1));
|
|
}
|
|
const _e = "[A-Za-z$_][0-9A-Za-z$_]*",
|
|
he = [
|
|
"as",
|
|
"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",
|
|
"debugger",
|
|
"async",
|
|
"await",
|
|
"static",
|
|
"import",
|
|
"from",
|
|
"export",
|
|
"extends",
|
|
],
|
|
fe = ["true", "false", "null", "undefined", "NaN", "Infinity"],
|
|
Ee = [
|
|
"Object",
|
|
"Function",
|
|
"Boolean",
|
|
"Symbol",
|
|
"Math",
|
|
"Date",
|
|
"Number",
|
|
"BigInt",
|
|
"String",
|
|
"RegExp",
|
|
"Array",
|
|
"Float32Array",
|
|
"Float64Array",
|
|
"Int8Array",
|
|
"Uint8Array",
|
|
"Uint8ClampedArray",
|
|
"Int16Array",
|
|
"Int32Array",
|
|
"Uint16Array",
|
|
"Uint32Array",
|
|
"BigInt64Array",
|
|
"BigUint64Array",
|
|
"Set",
|
|
"Map",
|
|
"WeakSet",
|
|
"WeakMap",
|
|
"ArrayBuffer",
|
|
"SharedArrayBuffer",
|
|
"Atomics",
|
|
"DataView",
|
|
"JSON",
|
|
"Promise",
|
|
"Generator",
|
|
"GeneratorFunction",
|
|
"AsyncFunction",
|
|
"Reflect",
|
|
"Proxy",
|
|
"Intl",
|
|
"WebAssembly",
|
|
],
|
|
ye = [
|
|
"Error",
|
|
"EvalError",
|
|
"InternalError",
|
|
"RangeError",
|
|
"ReferenceError",
|
|
"SyntaxError",
|
|
"TypeError",
|
|
"URIError",
|
|
],
|
|
Ne = [
|
|
"setInterval",
|
|
"setTimeout",
|
|
"clearInterval",
|
|
"clearTimeout",
|
|
"require",
|
|
"exports",
|
|
"eval",
|
|
"isFinite",
|
|
"isNaN",
|
|
"parseFloat",
|
|
"parseInt",
|
|
"decodeURI",
|
|
"decodeURIComponent",
|
|
"encodeURI",
|
|
"encodeURIComponent",
|
|
"escape",
|
|
"unescape",
|
|
],
|
|
we = [
|
|
"arguments",
|
|
"this",
|
|
"super",
|
|
"console",
|
|
"window",
|
|
"document",
|
|
"localStorage",
|
|
"sessionStorage",
|
|
"module",
|
|
"global",
|
|
],
|
|
ve = [].concat(Ne, Ee, ye);
|
|
function Oe(e) {
|
|
const n = e.regex,
|
|
t = _e,
|
|
a = {
|
|
begin: /<[A-Za-z0-9\\._:-]+/,
|
|
end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
|
|
isTrulyOpeningTag: (e, n) => {
|
|
const t = e[0].length + e.index,
|
|
a = e.input[t];
|
|
if ("<" === a || "," === a) return void n.ignoreMatch();
|
|
let i;
|
|
">" === a &&
|
|
(((e, { after: n }) => {
|
|
const t = "</" + e[0].slice(1);
|
|
return -1 !== e.input.indexOf(t, n);
|
|
})(e, { after: t }) ||
|
|
n.ignoreMatch());
|
|
const r = e.input.substring(t);
|
|
((i = r.match(/^\s*=/)) ||
|
|
((i = r.match(/^\s+extends\s+/)) && 0 === i.index)) &&
|
|
n.ignoreMatch();
|
|
},
|
|
},
|
|
i = {
|
|
$pattern: _e,
|
|
keyword: he,
|
|
literal: fe,
|
|
built_in: ve,
|
|
"variable.language": we,
|
|
},
|
|
r = "[0-9](_?[0-9])*",
|
|
s = `\\.(${r})`,
|
|
o = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*",
|
|
l = {
|
|
className: "number",
|
|
variants: [
|
|
{
|
|
begin: `(\\b(${o})((${s})|\\.)?|(${s}))[eE][+-]?(${r})\\b`,
|
|
},
|
|
{
|
|
begin: `\\b(${o})\\b((${s})\\b|\\.)?|(${s})\\b`,
|
|
},
|
|
{
|
|
begin: "\\b(0|[1-9](_?[0-9])*)n\\b",
|
|
},
|
|
{
|
|
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" },
|
|
{
|
|
begin: "\\b0[0-7]+n?\\b",
|
|
},
|
|
],
|
|
relevance: 0,
|
|
},
|
|
c = {
|
|
className: "subst",
|
|
begin: "\\$\\{",
|
|
end: "\\}",
|
|
keywords: i,
|
|
contains: [],
|
|
},
|
|
d = {
|
|
begin: "html`",
|
|
end: "",
|
|
starts: {
|
|
end: "`",
|
|
returnEnd: !1,
|
|
contains: [e.BACKSLASH_ESCAPE, c],
|
|
subLanguage: "xml",
|
|
},
|
|
},
|
|
g = {
|
|
begin: "css`",
|
|
end: "",
|
|
starts: {
|
|
end: "`",
|
|
returnEnd: !1,
|
|
contains: [e.BACKSLASH_ESCAPE, c],
|
|
subLanguage: "css",
|
|
},
|
|
},
|
|
u = {
|
|
begin: "gql`",
|
|
end: "",
|
|
starts: {
|
|
end: "`",
|
|
returnEnd: !1,
|
|
contains: [e.BACKSLASH_ESCAPE, c],
|
|
subLanguage: "graphql",
|
|
},
|
|
},
|
|
b = {
|
|
className: "string",
|
|
begin: "`",
|
|
end: "`",
|
|
contains: [e.BACKSLASH_ESCAPE, c],
|
|
},
|
|
m = {
|
|
className: "comment",
|
|
variants: [
|
|
e.COMMENT(/\/\*\*(?!\/)/, "\\*/", {
|
|
relevance: 0,
|
|
contains: [
|
|
{
|
|
begin: "(?=@[A-Za-z]+)",
|
|
relevance: 0,
|
|
contains: [
|
|
{ className: "doctag", begin: "@[A-Za-z]+" },
|
|
{
|
|
className: "type",
|
|
begin: "\\{",
|
|
end: "\\}",
|
|
excludeEnd: !0,
|
|
excludeBegin: !0,
|
|
relevance: 0,
|
|
},
|
|
{
|
|
className: "variable",
|
|
begin: t + "(?=\\s*(-)|$)",
|
|
endsParent: !0,
|
|
relevance: 0,
|
|
},
|
|
{ begin: /(?=[^\n])\s/, relevance: 0 },
|
|
],
|
|
},
|
|
],
|
|
}),
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
e.C_LINE_COMMENT_MODE,
|
|
],
|
|
},
|
|
p = [
|
|
e.APOS_STRING_MODE,
|
|
e.QUOTE_STRING_MODE,
|
|
d,
|
|
g,
|
|
u,
|
|
b,
|
|
{ match: /\$\d+/ },
|
|
l,
|
|
];
|
|
c.contains = p.concat({
|
|
begin: /\{/,
|
|
end: /\}/,
|
|
keywords: i,
|
|
contains: ["self"].concat(p),
|
|
});
|
|
const _ = [].concat(m, c.contains),
|
|
h = _.concat([
|
|
{ begin: /\(/, end: /\)/, keywords: i, contains: ["self"].concat(_) },
|
|
]),
|
|
f = {
|
|
className: "params",
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
excludeBegin: !0,
|
|
excludeEnd: !0,
|
|
keywords: i,
|
|
contains: h,
|
|
},
|
|
E = {
|
|
variants: [
|
|
{
|
|
match: [
|
|
/class/,
|
|
/\s+/,
|
|
t,
|
|
/\s+/,
|
|
/extends/,
|
|
/\s+/,
|
|
n.concat(t, "(", n.concat(/\./, t), ")*"),
|
|
],
|
|
scope: {
|
|
1: "keyword",
|
|
3: "title.class",
|
|
5: "keyword",
|
|
7: "title.class.inherited",
|
|
},
|
|
},
|
|
{
|
|
match: [/class/, /\s+/, t],
|
|
scope: { 1: "keyword", 3: "title.class" },
|
|
},
|
|
],
|
|
},
|
|
y = {
|
|
relevance: 0,
|
|
match: n.either(
|
|
/\bJSON/,
|
|
/\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,
|
|
/\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/,
|
|
/\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/,
|
|
),
|
|
className: "title.class",
|
|
keywords: { _: [...Ee, ...ye] },
|
|
},
|
|
N = {
|
|
variants: [
|
|
{
|
|
match: [/function/, /\s+/, t, /(?=\s*\()/],
|
|
},
|
|
{ match: [/function/, /\s*(?=\()/] },
|
|
],
|
|
className: { 1: "keyword", 3: "title.function" },
|
|
label: "func.def",
|
|
contains: [f],
|
|
illegal: /%/,
|
|
},
|
|
w = {
|
|
match: n.concat(
|
|
/\b/,
|
|
((v = [...Ne, "super", "import"]), n.concat("(?!", v.join("|"), ")")),
|
|
t,
|
|
n.lookahead(/\(/),
|
|
),
|
|
className: "title.function",
|
|
relevance: 0,
|
|
};
|
|
var v;
|
|
const O = {
|
|
begin: n.concat(/\./, n.lookahead(n.concat(t, /(?![0-9A-Za-z$_(])/))),
|
|
end: t,
|
|
excludeBegin: !0,
|
|
keywords: "prototype",
|
|
className: "property",
|
|
relevance: 0,
|
|
},
|
|
k = {
|
|
match: [/get|set/, /\s+/, t, /(?=\()/],
|
|
className: { 1: "keyword", 3: "title.function" },
|
|
contains: [{ begin: /\(\)/ }, f],
|
|
},
|
|
x =
|
|
"(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" +
|
|
e.UNDERSCORE_IDENT_RE +
|
|
")\\s*=>",
|
|
M = {
|
|
match: [
|
|
/const|var|let/,
|
|
/\s+/,
|
|
t,
|
|
/\s*/,
|
|
/=\s*/,
|
|
/(async\s*)?/,
|
|
n.lookahead(x),
|
|
],
|
|
keywords: "async",
|
|
className: { 1: "keyword", 3: "title.function" },
|
|
contains: [f],
|
|
};
|
|
return {
|
|
name: "JavaScript",
|
|
aliases: ["js", "jsx", "mjs", "cjs"],
|
|
keywords: i,
|
|
exports: {
|
|
PARAMS_CONTAINS: h,
|
|
CLASS_REFERENCE: y,
|
|
},
|
|
illegal: /#(?![$_A-z])/,
|
|
contains: [
|
|
e.SHEBANG({ label: "shebang", binary: "node", relevance: 5 }),
|
|
{
|
|
label: "use_strict",
|
|
className: "meta",
|
|
relevance: 10,
|
|
begin: /^\s*['"]use (strict|asm)['"]/,
|
|
},
|
|
e.APOS_STRING_MODE,
|
|
e.QUOTE_STRING_MODE,
|
|
d,
|
|
g,
|
|
u,
|
|
b,
|
|
m,
|
|
{ match: /\$\d+/ },
|
|
l,
|
|
y,
|
|
{
|
|
className: "attr",
|
|
begin: t + n.lookahead(":"),
|
|
relevance: 0,
|
|
},
|
|
M,
|
|
{
|
|
begin: "(" + e.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
|
|
keywords: "return throw case",
|
|
relevance: 0,
|
|
contains: [
|
|
m,
|
|
e.REGEXP_MODE,
|
|
{
|
|
className: "function",
|
|
begin: x,
|
|
returnBegin: !0,
|
|
end: "\\s*=>",
|
|
contains: [
|
|
{
|
|
className: "params",
|
|
variants: [
|
|
{ begin: e.UNDERSCORE_IDENT_RE, relevance: 0 },
|
|
{
|
|
className: null,
|
|
begin: /\(\s*\)/,
|
|
skip: !0,
|
|
},
|
|
{
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
excludeBegin: !0,
|
|
excludeEnd: !0,
|
|
keywords: i,
|
|
contains: h,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{ begin: /,/, relevance: 0 },
|
|
{ match: /\s+/, relevance: 0 },
|
|
{
|
|
variants: [
|
|
{ begin: "<>", end: "</>" },
|
|
{
|
|
match: /<[A-Za-z0-9\\._:-]+\s*\/>/,
|
|
},
|
|
{ begin: a.begin, "on:begin": a.isTrulyOpeningTag, end: a.end },
|
|
],
|
|
subLanguage: "xml",
|
|
contains: [
|
|
{
|
|
begin: a.begin,
|
|
end: a.end,
|
|
skip: !0,
|
|
contains: ["self"],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
N,
|
|
{
|
|
beginKeywords: "while if switch catch for",
|
|
},
|
|
{
|
|
begin:
|
|
"\\b(?!function)" +
|
|
e.UNDERSCORE_IDENT_RE +
|
|
"\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
|
|
returnBegin: !0,
|
|
label: "func.def",
|
|
contains: [
|
|
f,
|
|
e.inherit(e.TITLE_MODE, { begin: t, className: "title.function" }),
|
|
],
|
|
},
|
|
{ match: /\.\.\./, relevance: 0 },
|
|
O,
|
|
{ match: "\\$" + t, relevance: 0 },
|
|
{
|
|
match: [/\bconstructor(?=\s*\()/],
|
|
className: { 1: "title.function" },
|
|
contains: [f],
|
|
},
|
|
w,
|
|
{
|
|
relevance: 0,
|
|
match: /\b[A-Z][A-Z_0-9]+\b/,
|
|
className: "variable.constant",
|
|
},
|
|
E,
|
|
k,
|
|
{ match: /\$[(.]/ },
|
|
],
|
|
};
|
|
}
|
|
const ke = (e) => b(/\b/, e, /\w$/.test(e) ? /\b/ : /\B/),
|
|
xe = ["Protocol", "Type"].map(ke),
|
|
Me = ["init", "self"].map(ke),
|
|
Se = ["Any", "Self"],
|
|
Ae = [
|
|
"actor",
|
|
"any",
|
|
"associatedtype",
|
|
"async",
|
|
"await",
|
|
/as\?/,
|
|
/as!/,
|
|
"as",
|
|
"borrowing",
|
|
"break",
|
|
"case",
|
|
"catch",
|
|
"class",
|
|
"consume",
|
|
"consuming",
|
|
"continue",
|
|
"convenience",
|
|
"copy",
|
|
"default",
|
|
"defer",
|
|
"deinit",
|
|
"didSet",
|
|
"distributed",
|
|
"do",
|
|
"dynamic",
|
|
"each",
|
|
"else",
|
|
"enum",
|
|
"extension",
|
|
"fallthrough",
|
|
/fileprivate\(set\)/,
|
|
"fileprivate",
|
|
"final",
|
|
"for",
|
|
"func",
|
|
"get",
|
|
"guard",
|
|
"if",
|
|
"import",
|
|
"indirect",
|
|
"infix",
|
|
/init\?/,
|
|
/init!/,
|
|
"inout",
|
|
/internal\(set\)/,
|
|
"internal",
|
|
"in",
|
|
"is",
|
|
"isolated",
|
|
"nonisolated",
|
|
"lazy",
|
|
"let",
|
|
"macro",
|
|
"mutating",
|
|
"nonmutating",
|
|
/open\(set\)/,
|
|
"open",
|
|
"operator",
|
|
"optional",
|
|
"override",
|
|
"postfix",
|
|
"precedencegroup",
|
|
"prefix",
|
|
/private\(set\)/,
|
|
"private",
|
|
"protocol",
|
|
/public\(set\)/,
|
|
"public",
|
|
"repeat",
|
|
"required",
|
|
"rethrows",
|
|
"return",
|
|
"set",
|
|
"some",
|
|
"static",
|
|
"struct",
|
|
"subscript",
|
|
"super",
|
|
"switch",
|
|
"throws",
|
|
"throw",
|
|
/try\?/,
|
|
/try!/,
|
|
"try",
|
|
"typealias",
|
|
/unowned\(safe\)/,
|
|
/unowned\(unsafe\)/,
|
|
"unowned",
|
|
"var",
|
|
"weak",
|
|
"where",
|
|
"while",
|
|
"willSet",
|
|
],
|
|
Ce = ["false", "nil", "true"],
|
|
Te = [
|
|
"assignment",
|
|
"associativity",
|
|
"higherThan",
|
|
"left",
|
|
"lowerThan",
|
|
"none",
|
|
"right",
|
|
],
|
|
Re = [
|
|
"#colorLiteral",
|
|
"#column",
|
|
"#dsohandle",
|
|
"#else",
|
|
"#elseif",
|
|
"#endif",
|
|
"#error",
|
|
"#file",
|
|
"#fileID",
|
|
"#fileLiteral",
|
|
"#filePath",
|
|
"#function",
|
|
"#if",
|
|
"#imageLiteral",
|
|
"#keyPath",
|
|
"#line",
|
|
"#selector",
|
|
"#sourceLocation",
|
|
"#warning",
|
|
],
|
|
De = [
|
|
"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",
|
|
],
|
|
Ie = m(
|
|
/[/=\-+!*%<>&|^~?]/,
|
|
/[\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]/,
|
|
),
|
|
Le = m(
|
|
Ie,
|
|
/[\u0300-\u036F]/,
|
|
/[\u1DC0-\u1DFF]/,
|
|
/[\u20D0-\u20FF]/,
|
|
/[\uFE00-\uFE0F]/,
|
|
/[\uFE20-\uFE2F]/,
|
|
),
|
|
Be = b(Ie, Le, "*"),
|
|
$e = m(
|
|
/[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]/,
|
|
),
|
|
ze = m($e, /\d/, /[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/),
|
|
Fe = b($e, ze, "*"),
|
|
Ue = b(/[A-Z]/, ze, "*"),
|
|
je = [
|
|
"attached",
|
|
"autoclosure",
|
|
b(/convention\(/, m("swift", "block", "c"), /\)/),
|
|
"discardableResult",
|
|
"dynamicCallable",
|
|
"dynamicMemberLookup",
|
|
"escaping",
|
|
"freestanding",
|
|
"frozen",
|
|
"GKInspectable",
|
|
"IBAction",
|
|
"IBDesignable",
|
|
"IBInspectable",
|
|
"IBOutlet",
|
|
"IBSegueAction",
|
|
"inlinable",
|
|
"main",
|
|
"nonobjc",
|
|
"NSApplicationMain",
|
|
"NSCopying",
|
|
"NSManaged",
|
|
b(/objc\(/, Fe, /\)/),
|
|
"objc",
|
|
"objcMembers",
|
|
"propertyWrapper",
|
|
"requires_stored_property_inits",
|
|
"resultBuilder",
|
|
"Sendable",
|
|
"testable",
|
|
"UIApplicationMain",
|
|
"unchecked",
|
|
"unknown",
|
|
"usableFromInline",
|
|
"warn_unqualified_access",
|
|
],
|
|
Pe = [
|
|
"iOS",
|
|
"iOSApplicationExtension",
|
|
"macOS",
|
|
"macOSApplicationExtension",
|
|
"macCatalyst",
|
|
"macCatalystApplicationExtension",
|
|
"watchOS",
|
|
"watchOSApplicationExtension",
|
|
"tvOS",
|
|
"tvOSApplicationExtension",
|
|
"swift",
|
|
];
|
|
var Ke = Object.freeze({
|
|
__proto__: null,
|
|
grmr_bash: (e) => {
|
|
const n = e.regex,
|
|
t = {},
|
|
a = {
|
|
begin: /\$\{/,
|
|
end: /\}/,
|
|
contains: ["self", { begin: /:-/, contains: [t] }],
|
|
};
|
|
Object.assign(t, {
|
|
className: "variable",
|
|
variants: [
|
|
{
|
|
begin: n.concat(/\$[\w\d#@][\w\d_]*/, "(?![\\w\\d])(?![$])"),
|
|
},
|
|
a,
|
|
],
|
|
});
|
|
const i = {
|
|
className: "subst",
|
|
begin: /\$\(/,
|
|
end: /\)/,
|
|
contains: [e.BACKSLASH_ESCAPE],
|
|
},
|
|
r = {
|
|
begin: /<<-?\s*(?=\w+)/,
|
|
starts: {
|
|
contains: [
|
|
e.END_SAME_AS_BEGIN({
|
|
begin: /(\w+)/,
|
|
end: /(\w+)/,
|
|
className: "string",
|
|
}),
|
|
],
|
|
},
|
|
},
|
|
s = {
|
|
className: "string",
|
|
begin: /"/,
|
|
end: /"/,
|
|
contains: [e.BACKSLASH_ESCAPE, t, i],
|
|
};
|
|
i.contains.push(s);
|
|
const o = {
|
|
begin: /\$?\(\(/,
|
|
end: /\)\)/,
|
|
contains: [
|
|
{ begin: /\d+#[0-9a-f]+/, className: "number" },
|
|
e.NUMBER_MODE,
|
|
t,
|
|
],
|
|
},
|
|
l = e.SHEBANG({
|
|
binary: "(fish|bash|zsh|sh|csh|ksh|tcsh|dash|scsh)",
|
|
relevance: 10,
|
|
}),
|
|
c = {
|
|
className: "function",
|
|
begin: /\w[\w\d_]*\s*\(\s*\)\s*\{/,
|
|
returnBegin: !0,
|
|
contains: [e.inherit(e.TITLE_MODE, { begin: /\w[\w\d_]*/ })],
|
|
relevance: 0,
|
|
};
|
|
return {
|
|
name: "Bash",
|
|
aliases: ["sh"],
|
|
keywords: {
|
|
$pattern: /\b[a-z][a-z0-9._-]+\b/,
|
|
keyword: [
|
|
"if",
|
|
"then",
|
|
"else",
|
|
"elif",
|
|
"fi",
|
|
"for",
|
|
"while",
|
|
"until",
|
|
"in",
|
|
"do",
|
|
"done",
|
|
"case",
|
|
"esac",
|
|
"function",
|
|
"select",
|
|
],
|
|
literal: ["true", "false"],
|
|
built_in: [
|
|
"break",
|
|
"cd",
|
|
"continue",
|
|
"eval",
|
|
"exec",
|
|
"exit",
|
|
"export",
|
|
"getopts",
|
|
"hash",
|
|
"pwd",
|
|
"readonly",
|
|
"return",
|
|
"shift",
|
|
"test",
|
|
"times",
|
|
"trap",
|
|
"umask",
|
|
"unset",
|
|
"alias",
|
|
"bind",
|
|
"builtin",
|
|
"caller",
|
|
"command",
|
|
"declare",
|
|
"echo",
|
|
"enable",
|
|
"help",
|
|
"let",
|
|
"local",
|
|
"logout",
|
|
"mapfile",
|
|
"printf",
|
|
"read",
|
|
"readarray",
|
|
"source",
|
|
"type",
|
|
"typeset",
|
|
"ulimit",
|
|
"unalias",
|
|
"set",
|
|
"shopt",
|
|
"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",
|
|
"chcon",
|
|
"chgrp",
|
|
"chown",
|
|
"chmod",
|
|
"cp",
|
|
"dd",
|
|
"df",
|
|
"dir",
|
|
"dircolors",
|
|
"ln",
|
|
"ls",
|
|
"mkdir",
|
|
"mkfifo",
|
|
"mknod",
|
|
"mktemp",
|
|
"mv",
|
|
"realpath",
|
|
"rm",
|
|
"rmdir",
|
|
"shred",
|
|
"sync",
|
|
"touch",
|
|
"truncate",
|
|
"vdir",
|
|
"b2sum",
|
|
"base32",
|
|
"base64",
|
|
"cat",
|
|
"cksum",
|
|
"comm",
|
|
"csplit",
|
|
"cut",
|
|
"expand",
|
|
"fmt",
|
|
"fold",
|
|
"head",
|
|
"join",
|
|
"md5sum",
|
|
"nl",
|
|
"numfmt",
|
|
"od",
|
|
"paste",
|
|
"ptx",
|
|
"pr",
|
|
"sha1sum",
|
|
"sha224sum",
|
|
"sha256sum",
|
|
"sha384sum",
|
|
"sha512sum",
|
|
"shuf",
|
|
"sort",
|
|
"split",
|
|
"sum",
|
|
"tac",
|
|
"tail",
|
|
"tr",
|
|
"tsort",
|
|
"unexpand",
|
|
"uniq",
|
|
"wc",
|
|
"arch",
|
|
"basename",
|
|
"chroot",
|
|
"date",
|
|
"dirname",
|
|
"du",
|
|
"echo",
|
|
"env",
|
|
"expr",
|
|
"factor",
|
|
"groups",
|
|
"hostid",
|
|
"id",
|
|
"link",
|
|
"logname",
|
|
"nice",
|
|
"nohup",
|
|
"nproc",
|
|
"pathchk",
|
|
"pinky",
|
|
"printenv",
|
|
"printf",
|
|
"pwd",
|
|
"readlink",
|
|
"runcon",
|
|
"seq",
|
|
"sleep",
|
|
"stat",
|
|
"stdbuf",
|
|
"stty",
|
|
"tee",
|
|
"test",
|
|
"timeout",
|
|
"tty",
|
|
"uname",
|
|
"unlink",
|
|
"uptime",
|
|
"users",
|
|
"who",
|
|
"whoami",
|
|
"yes",
|
|
],
|
|
},
|
|
contains: [
|
|
l,
|
|
e.SHEBANG(),
|
|
c,
|
|
o,
|
|
e.HASH_COMMENT_MODE,
|
|
r,
|
|
{ match: /(\/[a-z._-]+)+/ },
|
|
s,
|
|
{
|
|
match: /\\"/,
|
|
},
|
|
{ className: "string", begin: /'/, end: /'/ },
|
|
{ match: /\\'/ },
|
|
t,
|
|
],
|
|
};
|
|
},
|
|
grmr_c: (e) => {
|
|
const n = e.regex,
|
|
t = e.COMMENT("//", "$", { contains: [{ begin: /\\\n/ }] }),
|
|
a = "decltype\\(auto\\)",
|
|
i = "[a-zA-Z_]\\w*::",
|
|
r =
|
|
"(" +
|
|
a +
|
|
"|" +
|
|
n.optional(i) +
|
|
"[a-zA-Z_]\\w*" +
|
|
n.optional("<[^<>]+>") +
|
|
")",
|
|
s = {
|
|
className: "type",
|
|
variants: [
|
|
{ begin: "\\b[a-z\\d_]*_t\\b" },
|
|
{
|
|
match: /\batomic_[a-z]{3,6}\b/,
|
|
},
|
|
],
|
|
},
|
|
o = {
|
|
className: "string",
|
|
variants: [
|
|
{
|
|
begin: '(u8?|U|L)?"',
|
|
end: '"',
|
|
illegal: "\\n",
|
|
contains: [e.BACKSLASH_ESCAPE],
|
|
},
|
|
{
|
|
begin:
|
|
"(u8?|U|L)?'(\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)|.)",
|
|
end: "'",
|
|
illegal: ".",
|
|
},
|
|
e.END_SAME_AS_BEGIN({
|
|
begin: /(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,
|
|
end: /\)([^()\\ ]{0,16})"/,
|
|
}),
|
|
],
|
|
},
|
|
l = {
|
|
className: "number",
|
|
variants: [
|
|
{ begin: "\\b(0b[01']+)" },
|
|
{
|
|
begin:
|
|
"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)",
|
|
},
|
|
{
|
|
begin:
|
|
"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)",
|
|
},
|
|
],
|
|
relevance: 0,
|
|
},
|
|
c = {
|
|
className: "meta",
|
|
begin: /#\s*[a-z]+\b/,
|
|
end: /$/,
|
|
keywords: {
|
|
keyword:
|
|
"if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include",
|
|
},
|
|
contains: [
|
|
{ begin: /\\\n/, relevance: 0 },
|
|
e.inherit(o, { className: "string" }),
|
|
{
|
|
className: "string",
|
|
begin: /<.*?>/,
|
|
},
|
|
t,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
],
|
|
},
|
|
d = {
|
|
className: "title",
|
|
begin: n.optional(i) + e.IDENT_RE,
|
|
relevance: 0,
|
|
},
|
|
g = n.optional(i) + e.IDENT_RE + "\\s*\\(",
|
|
u = {
|
|
keyword: [
|
|
"asm",
|
|
"auto",
|
|
"break",
|
|
"case",
|
|
"continue",
|
|
"default",
|
|
"do",
|
|
"else",
|
|
"enum",
|
|
"extern",
|
|
"for",
|
|
"fortran",
|
|
"goto",
|
|
"if",
|
|
"inline",
|
|
"register",
|
|
"restrict",
|
|
"return",
|
|
"sizeof",
|
|
"struct",
|
|
"switch",
|
|
"typedef",
|
|
"union",
|
|
"volatile",
|
|
"while",
|
|
"_Alignas",
|
|
"_Alignof",
|
|
"_Atomic",
|
|
"_Generic",
|
|
"_Noreturn",
|
|
"_Static_assert",
|
|
"_Thread_local",
|
|
"alignas",
|
|
"alignof",
|
|
"noreturn",
|
|
"static_assert",
|
|
"thread_local",
|
|
"_Pragma",
|
|
],
|
|
type: [
|
|
"float",
|
|
"double",
|
|
"signed",
|
|
"unsigned",
|
|
"int",
|
|
"short",
|
|
"long",
|
|
"char",
|
|
"void",
|
|
"_Bool",
|
|
"_Complex",
|
|
"_Imaginary",
|
|
"_Decimal32",
|
|
"_Decimal64",
|
|
"_Decimal128",
|
|
"const",
|
|
"static",
|
|
"complex",
|
|
"bool",
|
|
"imaginary",
|
|
],
|
|
literal: "true false NULL",
|
|
built_in:
|
|
"std string wstring cin cout cerr clog stdin stdout stderr stringstream istringstream ostringstream auto_ptr deque list queue stack vector map set pair bitset multiset multimap unordered_set unordered_map unordered_multiset unordered_multimap priority_queue make_pair array shared_ptr abort terminate abs acos asin atan2 atan calloc ceil cosh cos exit exp fabs floor fmod fprintf fputs free frexp fscanf future isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit tolower toupper labs ldexp log10 log malloc realloc memchr memcmp memcpy memset modf pow printf putchar puts scanf sinh sin snprintf sprintf sqrt sscanf strcat strchr strcmp strcpy strcspn strlen strncat strncmp strncpy strpbrk strrchr strspn strstr tanh tan vfprintf vprintf vsprintf endl initializer_list unique_ptr",
|
|
},
|
|
b = [c, s, t, e.C_BLOCK_COMMENT_MODE, l, o],
|
|
m = {
|
|
variants: [
|
|
{ begin: /=/, end: /;/ },
|
|
{
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
},
|
|
{ beginKeywords: "new throw return else", end: /;/ },
|
|
],
|
|
keywords: u,
|
|
contains: b.concat([
|
|
{
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
keywords: u,
|
|
contains: b.concat(["self"]),
|
|
relevance: 0,
|
|
},
|
|
]),
|
|
relevance: 0,
|
|
},
|
|
p = {
|
|
begin: "(" + r + "[\\*&\\s]+)+" + g,
|
|
returnBegin: !0,
|
|
end: /[{;=]/,
|
|
excludeEnd: !0,
|
|
keywords: u,
|
|
illegal: /[^\w\s*&:<>.]/,
|
|
contains: [
|
|
{ begin: a, keywords: u, relevance: 0 },
|
|
{
|
|
begin: g,
|
|
returnBegin: !0,
|
|
contains: [e.inherit(d, { className: "title.function" })],
|
|
relevance: 0,
|
|
},
|
|
{ relevance: 0, match: /,/ },
|
|
{
|
|
className: "params",
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
keywords: u,
|
|
relevance: 0,
|
|
contains: [
|
|
t,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
o,
|
|
l,
|
|
s,
|
|
{
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
keywords: u,
|
|
relevance: 0,
|
|
contains: ["self", t, e.C_BLOCK_COMMENT_MODE, o, l, s],
|
|
},
|
|
],
|
|
},
|
|
s,
|
|
t,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
c,
|
|
],
|
|
};
|
|
return {
|
|
name: "C",
|
|
aliases: ["h"],
|
|
keywords: u,
|
|
disableAutodetect: !0,
|
|
illegal: "</",
|
|
contains: [].concat(m, p, b, [
|
|
c,
|
|
{
|
|
begin: e.IDENT_RE + "::",
|
|
keywords: u,
|
|
},
|
|
{
|
|
className: "class",
|
|
beginKeywords: "enum class struct union",
|
|
end: /[{;:<>=]/,
|
|
contains: [
|
|
{
|
|
beginKeywords: "final class struct",
|
|
},
|
|
e.TITLE_MODE,
|
|
],
|
|
},
|
|
]),
|
|
exports: { preprocessor: c, strings: o, keywords: u },
|
|
};
|
|
},
|
|
grmr_cpp: (e) => {
|
|
const n = e.regex,
|
|
t = e.COMMENT("//", "$", {
|
|
contains: [{ begin: /\\\n/ }],
|
|
}),
|
|
a = "decltype\\(auto\\)",
|
|
i = "[a-zA-Z_]\\w*::",
|
|
r =
|
|
"(?!struct)(" +
|
|
a +
|
|
"|" +
|
|
n.optional(i) +
|
|
"[a-zA-Z_]\\w*" +
|
|
n.optional("<[^<>]+>") +
|
|
")",
|
|
s = {
|
|
className: "type",
|
|
begin: "\\b[a-z\\d_]*_t\\b",
|
|
},
|
|
o = {
|
|
className: "string",
|
|
variants: [
|
|
{
|
|
begin: '(u8?|U|L)?"',
|
|
end: '"',
|
|
illegal: "\\n",
|
|
contains: [e.BACKSLASH_ESCAPE],
|
|
},
|
|
{
|
|
begin:
|
|
"(u8?|U|L)?'(\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)|.)",
|
|
end: "'",
|
|
illegal: ".",
|
|
},
|
|
e.END_SAME_AS_BEGIN({
|
|
begin: /(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,
|
|
end: /\)([^()\\ ]{0,16})"/,
|
|
}),
|
|
],
|
|
},
|
|
l = {
|
|
className: "number",
|
|
variants: [
|
|
{ begin: "\\b(0b[01']+)" },
|
|
{
|
|
begin:
|
|
"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)",
|
|
},
|
|
{
|
|
begin:
|
|
"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)",
|
|
},
|
|
],
|
|
relevance: 0,
|
|
},
|
|
c = {
|
|
className: "meta",
|
|
begin: /#\s*[a-z]+\b/,
|
|
end: /$/,
|
|
keywords: {
|
|
keyword:
|
|
"if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include",
|
|
},
|
|
contains: [
|
|
{ begin: /\\\n/, relevance: 0 },
|
|
e.inherit(o, { className: "string" }),
|
|
{
|
|
className: "string",
|
|
begin: /<.*?>/,
|
|
},
|
|
t,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
],
|
|
},
|
|
d = {
|
|
className: "title",
|
|
begin: n.optional(i) + e.IDENT_RE,
|
|
relevance: 0,
|
|
},
|
|
g = n.optional(i) + e.IDENT_RE + "\\s*\\(",
|
|
u = {
|
|
type: [
|
|
"bool",
|
|
"char",
|
|
"char16_t",
|
|
"char32_t",
|
|
"char8_t",
|
|
"double",
|
|
"float",
|
|
"int",
|
|
"long",
|
|
"short",
|
|
"void",
|
|
"wchar_t",
|
|
"unsigned",
|
|
"signed",
|
|
"const",
|
|
"static",
|
|
],
|
|
keyword: [
|
|
"alignas",
|
|
"alignof",
|
|
"and",
|
|
"and_eq",
|
|
"asm",
|
|
"atomic_cancel",
|
|
"atomic_commit",
|
|
"atomic_noexcept",
|
|
"auto",
|
|
"bitand",
|
|
"bitor",
|
|
"break",
|
|
"case",
|
|
"catch",
|
|
"class",
|
|
"co_await",
|
|
"co_return",
|
|
"co_yield",
|
|
"compl",
|
|
"concept",
|
|
"const_cast|10",
|
|
"consteval",
|
|
"constexpr",
|
|
"constinit",
|
|
"continue",
|
|
"decltype",
|
|
"default",
|
|
"delete",
|
|
"do",
|
|
"dynamic_cast|10",
|
|
"else",
|
|
"enum",
|
|
"explicit",
|
|
"export",
|
|
"extern",
|
|
"false",
|
|
"final",
|
|
"for",
|
|
"friend",
|
|
"goto",
|
|
"if",
|
|
"import",
|
|
"inline",
|
|
"module",
|
|
"mutable",
|
|
"namespace",
|
|
"new",
|
|
"noexcept",
|
|
"not",
|
|
"not_eq",
|
|
"nullptr",
|
|
"operator",
|
|
"or",
|
|
"or_eq",
|
|
"override",
|
|
"private",
|
|
"protected",
|
|
"public",
|
|
"reflexpr",
|
|
"register",
|
|
"reinterpret_cast|10",
|
|
"requires",
|
|
"return",
|
|
"sizeof",
|
|
"static_assert",
|
|
"static_cast|10",
|
|
"struct",
|
|
"switch",
|
|
"synchronized",
|
|
"template",
|
|
"this",
|
|
"thread_local",
|
|
"throw",
|
|
"transaction_safe",
|
|
"transaction_safe_dynamic",
|
|
"true",
|
|
"try",
|
|
"typedef",
|
|
"typeid",
|
|
"typename",
|
|
"union",
|
|
"using",
|
|
"virtual",
|
|
"volatile",
|
|
"while",
|
|
"xor",
|
|
"xor_eq",
|
|
],
|
|
literal: ["NULL", "false", "nullopt", "nullptr", "true"],
|
|
built_in: ["_Pragma"],
|
|
_type_hints: [
|
|
"any",
|
|
"auto_ptr",
|
|
"barrier",
|
|
"binary_semaphore",
|
|
"bitset",
|
|
"complex",
|
|
"condition_variable",
|
|
"condition_variable_any",
|
|
"counting_semaphore",
|
|
"deque",
|
|
"false_type",
|
|
"future",
|
|
"imaginary",
|
|
"initializer_list",
|
|
"istringstream",
|
|
"jthread",
|
|
"latch",
|
|
"lock_guard",
|
|
"multimap",
|
|
"multiset",
|
|
"mutex",
|
|
"optional",
|
|
"ostringstream",
|
|
"packaged_task",
|
|
"pair",
|
|
"promise",
|
|
"priority_queue",
|
|
"queue",
|
|
"recursive_mutex",
|
|
"recursive_timed_mutex",
|
|
"scoped_lock",
|
|
"set",
|
|
"shared_future",
|
|
"shared_lock",
|
|
"shared_mutex",
|
|
"shared_timed_mutex",
|
|
"shared_ptr",
|
|
"stack",
|
|
"string_view",
|
|
"stringstream",
|
|
"timed_mutex",
|
|
"thread",
|
|
"true_type",
|
|
"tuple",
|
|
"unique_lock",
|
|
"unique_ptr",
|
|
"unordered_map",
|
|
"unordered_multimap",
|
|
"unordered_multiset",
|
|
"unordered_set",
|
|
"variant",
|
|
"vector",
|
|
"weak_ptr",
|
|
"wstring",
|
|
"wstring_view",
|
|
],
|
|
},
|
|
b = {
|
|
className: "function.dispatch",
|
|
relevance: 0,
|
|
keywords: {
|
|
_hint: [
|
|
"abort",
|
|
"abs",
|
|
"acos",
|
|
"apply",
|
|
"as_const",
|
|
"asin",
|
|
"atan",
|
|
"atan2",
|
|
"calloc",
|
|
"ceil",
|
|
"cerr",
|
|
"cin",
|
|
"clog",
|
|
"cos",
|
|
"cosh",
|
|
"cout",
|
|
"declval",
|
|
"endl",
|
|
"exchange",
|
|
"exit",
|
|
"exp",
|
|
"fabs",
|
|
"floor",
|
|
"fmod",
|
|
"forward",
|
|
"fprintf",
|
|
"fputs",
|
|
"free",
|
|
"frexp",
|
|
"fscanf",
|
|
"future",
|
|
"invoke",
|
|
"isalnum",
|
|
"isalpha",
|
|
"iscntrl",
|
|
"isdigit",
|
|
"isgraph",
|
|
"islower",
|
|
"isprint",
|
|
"ispunct",
|
|
"isspace",
|
|
"isupper",
|
|
"isxdigit",
|
|
"labs",
|
|
"launder",
|
|
"ldexp",
|
|
"log",
|
|
"log10",
|
|
"make_pair",
|
|
"make_shared",
|
|
"make_shared_for_overwrite",
|
|
"make_tuple",
|
|
"make_unique",
|
|
"malloc",
|
|
"memchr",
|
|
"memcmp",
|
|
"memcpy",
|
|
"memset",
|
|
"modf",
|
|
"move",
|
|
"pow",
|
|
"printf",
|
|
"putchar",
|
|
"puts",
|
|
"realloc",
|
|
"scanf",
|
|
"sin",
|
|
"sinh",
|
|
"snprintf",
|
|
"sprintf",
|
|
"sqrt",
|
|
"sscanf",
|
|
"std",
|
|
"stderr",
|
|
"stdin",
|
|
"stdout",
|
|
"strcat",
|
|
"strchr",
|
|
"strcmp",
|
|
"strcpy",
|
|
"strcspn",
|
|
"strlen",
|
|
"strncat",
|
|
"strncmp",
|
|
"strncpy",
|
|
"strpbrk",
|
|
"strrchr",
|
|
"strspn",
|
|
"strstr",
|
|
"swap",
|
|
"tan",
|
|
"tanh",
|
|
"terminate",
|
|
"to_underlying",
|
|
"tolower",
|
|
"toupper",
|
|
"vfprintf",
|
|
"visit",
|
|
"vprintf",
|
|
"vsprintf",
|
|
],
|
|
},
|
|
begin: n.concat(
|
|
/\b/,
|
|
/(?!decltype)/,
|
|
/(?!if)/,
|
|
/(?!for)/,
|
|
/(?!switch)/,
|
|
/(?!while)/,
|
|
e.IDENT_RE,
|
|
n.lookahead(/(<[^<>]+>|)\s*\(/),
|
|
),
|
|
},
|
|
m = [b, c, s, t, e.C_BLOCK_COMMENT_MODE, l, o],
|
|
p = {
|
|
variants: [
|
|
{ begin: /=/, end: /;/ },
|
|
{
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
},
|
|
{ beginKeywords: "new throw return else", end: /;/ },
|
|
],
|
|
keywords: u,
|
|
contains: m.concat([
|
|
{
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
keywords: u,
|
|
contains: m.concat(["self"]),
|
|
relevance: 0,
|
|
},
|
|
]),
|
|
relevance: 0,
|
|
},
|
|
_ = {
|
|
className: "function",
|
|
begin: "(" + r + "[\\*&\\s]+)+" + g,
|
|
returnBegin: !0,
|
|
end: /[{;=]/,
|
|
excludeEnd: !0,
|
|
keywords: u,
|
|
illegal: /[^\w\s*&:<>.]/,
|
|
contains: [
|
|
{ begin: a, keywords: u, relevance: 0 },
|
|
{
|
|
begin: g,
|
|
returnBegin: !0,
|
|
contains: [d],
|
|
relevance: 0,
|
|
},
|
|
{ begin: /::/, relevance: 0 },
|
|
{
|
|
begin: /:/,
|
|
endsWithParent: !0,
|
|
contains: [o, l],
|
|
},
|
|
{ relevance: 0, match: /,/ },
|
|
{
|
|
className: "params",
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
keywords: u,
|
|
relevance: 0,
|
|
contains: [
|
|
t,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
o,
|
|
l,
|
|
s,
|
|
{
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
keywords: u,
|
|
relevance: 0,
|
|
contains: ["self", t, e.C_BLOCK_COMMENT_MODE, o, l, s],
|
|
},
|
|
],
|
|
},
|
|
s,
|
|
t,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
c,
|
|
],
|
|
};
|
|
return {
|
|
name: "C++",
|
|
aliases: ["cc", "c++", "h++", "hpp", "hh", "hxx", "cxx"],
|
|
keywords: u,
|
|
illegal: "</",
|
|
classNameAliases: { "function.dispatch": "built_in" },
|
|
contains: [].concat(p, _, b, m, [
|
|
c,
|
|
{
|
|
begin:
|
|
"\\b(deque|list|queue|priority_queue|pair|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array|tuple|optional|variant|function)\\s*<(?!<)",
|
|
end: ">",
|
|
keywords: u,
|
|
contains: ["self", s],
|
|
},
|
|
{ begin: e.IDENT_RE + "::", keywords: u },
|
|
{
|
|
match: [
|
|
/\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/,
|
|
/\s+/,
|
|
/\w+/,
|
|
],
|
|
className: { 1: "keyword", 3: "title.class" },
|
|
},
|
|
]),
|
|
};
|
|
},
|
|
grmr_csharp: (e) => {
|
|
const n = {
|
|
keyword: [
|
|
"abstract",
|
|
"as",
|
|
"base",
|
|
"break",
|
|
"case",
|
|
"catch",
|
|
"class",
|
|
"const",
|
|
"continue",
|
|
"do",
|
|
"else",
|
|
"event",
|
|
"explicit",
|
|
"extern",
|
|
"finally",
|
|
"fixed",
|
|
"for",
|
|
"foreach",
|
|
"goto",
|
|
"if",
|
|
"implicit",
|
|
"in",
|
|
"interface",
|
|
"internal",
|
|
"is",
|
|
"lock",
|
|
"namespace",
|
|
"new",
|
|
"operator",
|
|
"out",
|
|
"override",
|
|
"params",
|
|
"private",
|
|
"protected",
|
|
"public",
|
|
"readonly",
|
|
"record",
|
|
"ref",
|
|
"return",
|
|
"scoped",
|
|
"sealed",
|
|
"sizeof",
|
|
"stackalloc",
|
|
"static",
|
|
"struct",
|
|
"switch",
|
|
"this",
|
|
"throw",
|
|
"try",
|
|
"typeof",
|
|
"unchecked",
|
|
"unsafe",
|
|
"using",
|
|
"virtual",
|
|
"void",
|
|
"volatile",
|
|
"while",
|
|
].concat([
|
|
"add",
|
|
"alias",
|
|
"and",
|
|
"ascending",
|
|
"async",
|
|
"await",
|
|
"by",
|
|
"descending",
|
|
"equals",
|
|
"from",
|
|
"get",
|
|
"global",
|
|
"group",
|
|
"init",
|
|
"into",
|
|
"join",
|
|
"let",
|
|
"nameof",
|
|
"not",
|
|
"notnull",
|
|
"on",
|
|
"or",
|
|
"orderby",
|
|
"partial",
|
|
"remove",
|
|
"select",
|
|
"set",
|
|
"unmanaged",
|
|
"value|0",
|
|
"var",
|
|
"when",
|
|
"where",
|
|
"with",
|
|
"yield",
|
|
]),
|
|
built_in: [
|
|
"bool",
|
|
"byte",
|
|
"char",
|
|
"decimal",
|
|
"delegate",
|
|
"double",
|
|
"dynamic",
|
|
"enum",
|
|
"float",
|
|
"int",
|
|
"long",
|
|
"nint",
|
|
"nuint",
|
|
"object",
|
|
"sbyte",
|
|
"short",
|
|
"string",
|
|
"ulong",
|
|
"uint",
|
|
"ushort",
|
|
],
|
|
literal: ["default", "false", "null", "true"],
|
|
},
|
|
t = e.inherit(e.TITLE_MODE, {
|
|
begin: "[a-zA-Z](\\.?\\w)*",
|
|
}),
|
|
a = {
|
|
className: "number",
|
|
variants: [
|
|
{
|
|
begin: "\\b(0b[01']+)",
|
|
},
|
|
{
|
|
begin:
|
|
"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)(u|U|l|L|ul|UL|f|F|b|B)",
|
|
},
|
|
{
|
|
begin:
|
|
"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)",
|
|
},
|
|
],
|
|
relevance: 0,
|
|
},
|
|
i = {
|
|
className: "string",
|
|
begin: '@"',
|
|
end: '"',
|
|
contains: [{ begin: '""' }],
|
|
},
|
|
r = e.inherit(i, { illegal: /\n/ }),
|
|
s = { className: "subst", begin: /\{/, end: /\}/, keywords: n },
|
|
o = e.inherit(s, { illegal: /\n/ }),
|
|
l = {
|
|
className: "string",
|
|
begin: /\$"/,
|
|
end: '"',
|
|
illegal: /\n/,
|
|
contains: [
|
|
{ begin: /\{\{/ },
|
|
{ begin: /\}\}/ },
|
|
e.BACKSLASH_ESCAPE,
|
|
o,
|
|
],
|
|
},
|
|
c = {
|
|
className: "string",
|
|
begin: /\$@"/,
|
|
end: '"',
|
|
contains: [
|
|
{
|
|
begin: /\{\{/,
|
|
},
|
|
{ begin: /\}\}/ },
|
|
{ begin: '""' },
|
|
s,
|
|
],
|
|
},
|
|
d = e.inherit(c, {
|
|
illegal: /\n/,
|
|
contains: [{ begin: /\{\{/ }, { begin: /\}\}/ }, { begin: '""' }, o],
|
|
});
|
|
(s.contains = [
|
|
c,
|
|
l,
|
|
i,
|
|
e.APOS_STRING_MODE,
|
|
e.QUOTE_STRING_MODE,
|
|
a,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
]),
|
|
(o.contains = [
|
|
d,
|
|
l,
|
|
r,
|
|
e.APOS_STRING_MODE,
|
|
e.QUOTE_STRING_MODE,
|
|
a,
|
|
e.inherit(e.C_BLOCK_COMMENT_MODE, {
|
|
illegal: /\n/,
|
|
}),
|
|
]);
|
|
const g = {
|
|
variants: [c, l, i, e.APOS_STRING_MODE, e.QUOTE_STRING_MODE],
|
|
},
|
|
u = {
|
|
begin: "<",
|
|
end: ">",
|
|
contains: [{ beginKeywords: "in out" }, t],
|
|
},
|
|
b =
|
|
e.IDENT_RE +
|
|
"(<" +
|
|
e.IDENT_RE +
|
|
"(\\s*,\\s*" +
|
|
e.IDENT_RE +
|
|
")*>)?(\\[\\])?",
|
|
m = {
|
|
begin: "@" + e.IDENT_RE,
|
|
relevance: 0,
|
|
};
|
|
return {
|
|
name: "C#",
|
|
aliases: ["cs", "c#"],
|
|
keywords: n,
|
|
illegal: /::/,
|
|
contains: [
|
|
e.COMMENT("///", "$", {
|
|
returnBegin: !0,
|
|
contains: [
|
|
{
|
|
className: "doctag",
|
|
variants: [
|
|
{ begin: "///", relevance: 0 },
|
|
{
|
|
begin: "\x3c!--|--\x3e",
|
|
},
|
|
{ begin: "</?", end: ">" },
|
|
],
|
|
},
|
|
],
|
|
}),
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
{
|
|
className: "meta",
|
|
begin: "#",
|
|
end: "$",
|
|
keywords: {
|
|
keyword:
|
|
"if else elif endif define undef warning error line region endregion pragma checksum",
|
|
},
|
|
},
|
|
g,
|
|
a,
|
|
{
|
|
beginKeywords: "class interface",
|
|
relevance: 0,
|
|
end: /[{;=]/,
|
|
illegal: /[^\s:,]/,
|
|
contains: [
|
|
{ beginKeywords: "where class" },
|
|
t,
|
|
u,
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
],
|
|
},
|
|
{
|
|
beginKeywords: "namespace",
|
|
relevance: 0,
|
|
end: /[{;=]/,
|
|
illegal: /[^\s:]/,
|
|
contains: [t, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE],
|
|
},
|
|
{
|
|
beginKeywords: "record",
|
|
relevance: 0,
|
|
end: /[{;=]/,
|
|
illegal: /[^\s:]/,
|
|
contains: [t, u, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE],
|
|
},
|
|
{
|
|
className: "meta",
|
|
begin: "^\\s*\\[(?=[\\w])",
|
|
excludeBegin: !0,
|
|
end: "\\]",
|
|
excludeEnd: !0,
|
|
contains: [
|
|
{
|
|
className: "string",
|
|
begin: /"/,
|
|
end: /"/,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
beginKeywords: "new return throw await else",
|
|
relevance: 0,
|
|
},
|
|
{
|
|
className: "function",
|
|
begin: "(" + b + "\\s+)+" + e.IDENT_RE + "\\s*(<[^=]+>\\s*)?\\(",
|
|
returnBegin: !0,
|
|
end: /\s*[{;=]/,
|
|
excludeEnd: !0,
|
|
keywords: n,
|
|
contains: [
|
|
{
|
|
beginKeywords:
|
|
"public private protected static internal protected abstract async extern override unsafe virtual new sealed partial",
|
|
relevance: 0,
|
|
},
|
|
{
|
|
begin: e.IDENT_RE + "\\s*(<[^=]+>\\s*)?\\(",
|
|
returnBegin: !0,
|
|
contains: [e.TITLE_MODE, u],
|
|
relevance: 0,
|
|
},
|
|
{ match: /\(\)/ },
|
|
{
|
|
className: "params",
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
excludeBegin: !0,
|
|
excludeEnd: !0,
|
|
keywords: n,
|
|
relevance: 0,
|
|
contains: [g, a, e.C_BLOCK_COMMENT_MODE],
|
|
},
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
],
|
|
},
|
|
m,
|
|
],
|
|
};
|
|
},
|
|
grmr_css: (e) => {
|
|
const n = e.regex,
|
|
t = ie(e),
|
|
a = [e.APOS_STRING_MODE, e.QUOTE_STRING_MODE];
|
|
return {
|
|
name: "CSS",
|
|
case_insensitive: !0,
|
|
illegal: /[=|'$]/,
|
|
keywords: {
|
|
keyframePosition: "from to",
|
|
},
|
|
classNameAliases: { keyframePosition: "selector-tag" },
|
|
contains: [
|
|
t.BLOCK_COMMENT,
|
|
{ begin: /-(webkit|moz|ms|o)-(?=[a-z])/ },
|
|
t.CSS_NUMBER_MODE,
|
|
{ className: "selector-id", begin: /#[A-Za-z0-9_-]+/, relevance: 0 },
|
|
{
|
|
className: "selector-class",
|
|
begin: "\\.[a-zA-Z-][a-zA-Z0-9_-]*",
|
|
relevance: 0,
|
|
},
|
|
t.ATTRIBUTE_SELECTOR_MODE,
|
|
{
|
|
className: "selector-pseudo",
|
|
variants: [
|
|
{
|
|
begin: ":(" + oe.join("|") + ")",
|
|
},
|
|
{ begin: ":(:)?(" + le.join("|") + ")" },
|
|
],
|
|
},
|
|
t.CSS_VARIABLE,
|
|
{ className: "attribute", begin: "\\b(" + ce.join("|") + ")\\b" },
|
|
{
|
|
begin: /:/,
|
|
end: /[;}{]/,
|
|
contains: [
|
|
t.BLOCK_COMMENT,
|
|
t.HEXCOLOR,
|
|
t.IMPORTANT,
|
|
t.CSS_NUMBER_MODE,
|
|
...a,
|
|
{
|
|
begin: /(url|data-uri)\(/,
|
|
end: /\)/,
|
|
relevance: 0,
|
|
keywords: { built_in: "url data-uri" },
|
|
contains: [
|
|
...a,
|
|
{
|
|
className: "string",
|
|
begin: /[^)]/,
|
|
endsWithParent: !0,
|
|
excludeEnd: !0,
|
|
},
|
|
],
|
|
},
|
|
t.FUNCTION_DISPATCH,
|
|
],
|
|
},
|
|
{
|
|
begin: n.lookahead(/@/),
|
|
end: "[{;]",
|
|
relevance: 0,
|
|
illegal: /:/,
|
|
contains: [
|
|
{ className: "keyword", begin: /@-?\w[\w]*(-\w+)*/ },
|
|
{
|
|
begin: /\s/,
|
|
endsWithParent: !0,
|
|
excludeEnd: !0,
|
|
relevance: 0,
|
|
keywords: {
|
|
$pattern: /[a-z-]+/,
|
|
keyword: "and or not only",
|
|
attribute: se.join(" "),
|
|
},
|
|
contains: [
|
|
{
|
|
begin: /[a-z-]+(?=:)/,
|
|
className: "attribute",
|
|
},
|
|
...a,
|
|
t.CSS_NUMBER_MODE,
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
className: "selector-tag",
|
|
begin: "\\b(" + re.join("|") + ")\\b",
|
|
},
|
|
],
|
|
};
|
|
},
|
|
grmr_diff: (e) => {
|
|
const n = e.regex;
|
|
return {
|
|
name: "Diff",
|
|
aliases: ["patch"],
|
|
contains: [
|
|
{
|
|
className: "meta",
|
|
relevance: 10,
|
|
match: n.either(
|
|
/^@@ +-\d+,\d+ +\+\d+,\d+ +@@/,
|
|
/^\*\*\* +\d+,\d+ +\*\*\*\*$/,
|
|
/^--- +\d+,\d+ +----$/,
|
|
),
|
|
},
|
|
{
|
|
className: "comment",
|
|
variants: [
|
|
{
|
|
begin: n.either(
|
|
/Index: /,
|
|
/^index/,
|
|
/={3,}/,
|
|
/^-{3}/,
|
|
/^\*{3} /,
|
|
/^\+{3}/,
|
|
/^diff --git/,
|
|
),
|
|
end: /$/,
|
|
},
|
|
{ match: /^\*{15}$/ },
|
|
],
|
|
},
|
|
{ className: "addition", begin: /^\+/, end: /$/ },
|
|
{
|
|
className: "deletion",
|
|
begin: /^-/,
|
|
end: /$/,
|
|
},
|
|
{ className: "addition", begin: /^!/, end: /$/ },
|
|
],
|
|
};
|
|
},
|
|
grmr_go: (e) => {
|
|
const n = {
|
|
keyword: [
|
|
"break",
|
|
"case",
|
|
"chan",
|
|
"const",
|
|
"continue",
|
|
"default",
|
|
"defer",
|
|
"else",
|
|
"fallthrough",
|
|
"for",
|
|
"func",
|
|
"go",
|
|
"goto",
|
|
"if",
|
|
"import",
|
|
"interface",
|
|
"map",
|
|
"package",
|
|
"range",
|
|
"return",
|
|
"select",
|
|
"struct",
|
|
"switch",
|
|
"type",
|
|
"var",
|
|
],
|
|
type: [
|
|
"bool",
|
|
"byte",
|
|
"complex64",
|
|
"complex128",
|
|
"error",
|
|
"float32",
|
|
"float64",
|
|
"int8",
|
|
"int16",
|
|
"int32",
|
|
"int64",
|
|
"string",
|
|
"uint8",
|
|
"uint16",
|
|
"uint32",
|
|
"uint64",
|
|
"int",
|
|
"uint",
|
|
"uintptr",
|
|
"rune",
|
|
],
|
|
literal: ["true", "false", "iota", "nil"],
|
|
built_in: [
|
|
"append",
|
|
"cap",
|
|
"close",
|
|
"complex",
|
|
"copy",
|
|
"imag",
|
|
"len",
|
|
"make",
|
|
"new",
|
|
"panic",
|
|
"print",
|
|
"println",
|
|
"real",
|
|
"recover",
|
|
"delete",
|
|
],
|
|
};
|
|
return {
|
|
name: "Go",
|
|
aliases: ["golang"],
|
|
keywords: n,
|
|
illegal: "</",
|
|
contains: [
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
{
|
|
className: "string",
|
|
variants: [
|
|
e.QUOTE_STRING_MODE,
|
|
e.APOS_STRING_MODE,
|
|
{ begin: "`", end: "`" },
|
|
],
|
|
},
|
|
{
|
|
className: "number",
|
|
variants: [
|
|
{ begin: e.C_NUMBER_RE + "[i]", relevance: 1 },
|
|
e.C_NUMBER_MODE,
|
|
],
|
|
},
|
|
{ begin: /:=/ },
|
|
{
|
|
className: "function",
|
|
beginKeywords: "func",
|
|
end: "\\s*(\\{|$)",
|
|
excludeEnd: !0,
|
|
contains: [
|
|
e.TITLE_MODE,
|
|
{
|
|
className: "params",
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
endsParent: !0,
|
|
keywords: n,
|
|
illegal: /["']/,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
},
|
|
grmr_graphql: (e) => {
|
|
const n = e.regex;
|
|
return {
|
|
name: "GraphQL",
|
|
aliases: ["gql"],
|
|
case_insensitive: !0,
|
|
disableAutodetect: !1,
|
|
keywords: {
|
|
keyword: [
|
|
"query",
|
|
"mutation",
|
|
"subscription",
|
|
"type",
|
|
"input",
|
|
"schema",
|
|
"directive",
|
|
"interface",
|
|
"union",
|
|
"scalar",
|
|
"fragment",
|
|
"enum",
|
|
"on",
|
|
],
|
|
literal: ["true", "false", "null"],
|
|
},
|
|
contains: [
|
|
e.HASH_COMMENT_MODE,
|
|
e.QUOTE_STRING_MODE,
|
|
e.NUMBER_MODE,
|
|
{
|
|
scope: "punctuation",
|
|
match: /[.]{3}/,
|
|
relevance: 0,
|
|
},
|
|
{ scope: "punctuation", begin: /[!():=[\]{|}]{1}/, relevance: 0 },
|
|
{
|
|
scope: "variable",
|
|
begin: /\$/,
|
|
end: /\W/,
|
|
excludeEnd: !0,
|
|
relevance: 0,
|
|
},
|
|
{ scope: "meta", match: /@\w+/, excludeEnd: !0 },
|
|
{
|
|
scope: "symbol",
|
|
begin: n.concat(/[_A-Za-z][_0-9A-Za-z]*/, n.lookahead(/\s*:/)),
|
|
relevance: 0,
|
|
},
|
|
],
|
|
illegal: [/[;<']/, /BEGIN/],
|
|
};
|
|
},
|
|
grmr_ini: (e) => {
|
|
const n = e.regex,
|
|
t = {
|
|
className: "number",
|
|
relevance: 0,
|
|
variants: [
|
|
{ begin: /([+-]+)?[\d]+_[\d_]+/ },
|
|
{
|
|
begin: e.NUMBER_RE,
|
|
},
|
|
],
|
|
},
|
|
a = e.COMMENT();
|
|
a.variants = [
|
|
{ begin: /;/, end: /$/ },
|
|
{ begin: /#/, end: /$/ },
|
|
];
|
|
const i = {
|
|
className: "variable",
|
|
variants: [
|
|
{ begin: /\$[\w\d"][\w\d_]*/ },
|
|
{
|
|
begin: /\$\{(.*?)\}/,
|
|
},
|
|
],
|
|
},
|
|
r = { className: "literal", begin: /\bon|off|true|false|yes|no\b/ },
|
|
s = {
|
|
className: "string",
|
|
contains: [e.BACKSLASH_ESCAPE],
|
|
variants: [
|
|
{ begin: "'''", end: "'''", relevance: 10 },
|
|
{
|
|
begin: '"""',
|
|
end: '"""',
|
|
relevance: 10,
|
|
},
|
|
{ begin: '"', end: '"' },
|
|
{ begin: "'", end: "'" },
|
|
],
|
|
},
|
|
o = {
|
|
begin: /\[/,
|
|
end: /\]/,
|
|
contains: [a, r, i, s, t, "self"],
|
|
relevance: 0,
|
|
},
|
|
l = n.either(/[A-Za-z0-9_-]+/, /"(\\"|[^"])*"/, /'[^']*'/);
|
|
return {
|
|
name: "TOML, also INI",
|
|
aliases: ["toml"],
|
|
case_insensitive: !0,
|
|
illegal: /\S/,
|
|
contains: [
|
|
a,
|
|
{ className: "section", begin: /\[+/, end: /\]+/ },
|
|
{
|
|
begin: n.concat(
|
|
l,
|
|
"(\\s*\\.\\s*",
|
|
l,
|
|
")*",
|
|
n.lookahead(/\s*=\s*[^#\s]/),
|
|
),
|
|
className: "attr",
|
|
starts: { end: /$/, contains: [a, o, r, i, s, t] },
|
|
},
|
|
],
|
|
};
|
|
},
|
|
grmr_java: (e) => {
|
|
const n = e.regex,
|
|
t = "[\xc0-\u02b8a-zA-Z_$][\xc0-\u02b8a-zA-Z_$0-9]*",
|
|
a = t + pe("(?:<" + t + "~~~(?:\\s*,\\s*" + t + "~~~)*>)?", /~~~/g, 2),
|
|
i = {
|
|
keyword: [
|
|
"synchronized",
|
|
"abstract",
|
|
"private",
|
|
"var",
|
|
"static",
|
|
"if",
|
|
"const ",
|
|
"for",
|
|
"while",
|
|
"strictfp",
|
|
"finally",
|
|
"protected",
|
|
"import",
|
|
"native",
|
|
"final",
|
|
"void",
|
|
"enum",
|
|
"else",
|
|
"break",
|
|
"transient",
|
|
"catch",
|
|
"instanceof",
|
|
"volatile",
|
|
"case",
|
|
"assert",
|
|
"package",
|
|
"default",
|
|
"public",
|
|
"try",
|
|
"switch",
|
|
"continue",
|
|
"throws",
|
|
"protected",
|
|
"public",
|
|
"private",
|
|
"module",
|
|
"requires",
|
|
"exports",
|
|
"do",
|
|
"sealed",
|
|
"yield",
|
|
"permits",
|
|
],
|
|
literal: ["false", "true", "null"],
|
|
type: [
|
|
"char",
|
|
"boolean",
|
|
"long",
|
|
"float",
|
|
"int",
|
|
"byte",
|
|
"short",
|
|
"double",
|
|
],
|
|
built_in: ["super", "this"],
|
|
},
|
|
r = {
|
|
className: "meta",
|
|
begin: "@" + t,
|
|
contains: [
|
|
{
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
contains: ["self"],
|
|
},
|
|
],
|
|
},
|
|
s = {
|
|
className: "params",
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
keywords: i,
|
|
relevance: 0,
|
|
contains: [e.C_BLOCK_COMMENT_MODE],
|
|
endsParent: !0,
|
|
};
|
|
return {
|
|
name: "Java",
|
|
aliases: ["jsp"],
|
|
keywords: i,
|
|
illegal: /<\/|#/,
|
|
contains: [
|
|
e.COMMENT("/\\*\\*", "\\*/", {
|
|
relevance: 0,
|
|
contains: [
|
|
{ begin: /\w+@/, relevance: 0 },
|
|
{ className: "doctag", begin: "@[A-Za-z]+" },
|
|
],
|
|
}),
|
|
{
|
|
begin: /import java\.[a-z]+\./,
|
|
keywords: "import",
|
|
relevance: 2,
|
|
},
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
{
|
|
begin: /"""/,
|
|
end: /"""/,
|
|
className: "string",
|
|
contains: [e.BACKSLASH_ESCAPE],
|
|
},
|
|
e.APOS_STRING_MODE,
|
|
e.QUOTE_STRING_MODE,
|
|
{
|
|
match: [
|
|
/\b(?:class|interface|enum|extends|implements|new)/,
|
|
/\s+/,
|
|
t,
|
|
],
|
|
className: {
|
|
1: "keyword",
|
|
3: "title.class",
|
|
},
|
|
},
|
|
{ match: /non-sealed/, scope: "keyword" },
|
|
{
|
|
begin: [n.concat(/(?!else)/, t), /\s+/, t, /\s+/, /=(?!=)/],
|
|
className: { 1: "type", 3: "variable", 5: "operator" },
|
|
},
|
|
{
|
|
begin: [/record/, /\s+/, t],
|
|
className: { 1: "keyword", 3: "title.class" },
|
|
contains: [s, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE],
|
|
},
|
|
{
|
|
beginKeywords: "new throw return else",
|
|
relevance: 0,
|
|
},
|
|
{
|
|
begin: ["(?:" + a + "\\s+)", e.UNDERSCORE_IDENT_RE, /\s*(?=\()/],
|
|
className: {
|
|
2: "title.function",
|
|
},
|
|
keywords: i,
|
|
contains: [
|
|
{
|
|
className: "params",
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
keywords: i,
|
|
relevance: 0,
|
|
contains: [
|
|
r,
|
|
e.APOS_STRING_MODE,
|
|
e.QUOTE_STRING_MODE,
|
|
me,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
],
|
|
},
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
],
|
|
},
|
|
me,
|
|
r,
|
|
],
|
|
};
|
|
},
|
|
grmr_javascript: Oe,
|
|
grmr_json: (e) => {
|
|
const n = ["true", "false", "null"],
|
|
t = { scope: "literal", beginKeywords: n.join(" ") };
|
|
return {
|
|
name: "JSON",
|
|
keywords: { literal: n },
|
|
contains: [
|
|
{
|
|
className: "attr",
|
|
begin: /"(\\.|[^\\"\r\n])*"(?=\s*:)/,
|
|
relevance: 1.01,
|
|
},
|
|
{
|
|
match: /[{}[\],:]/,
|
|
className: "punctuation",
|
|
relevance: 0,
|
|
},
|
|
e.QUOTE_STRING_MODE,
|
|
t,
|
|
e.C_NUMBER_MODE,
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
],
|
|
illegal: "\\S",
|
|
};
|
|
},
|
|
grmr_kotlin: (e) => {
|
|
const n = {
|
|
keyword:
|
|
"abstract as val var vararg get set class object open private protected public noinline crossinline dynamic final enum if else do while for when throw try catch finally import package is in fun override companion reified inline lateinit init interface annotation data sealed internal infix operator out by constructor super tailrec where const inner suspend typealias external expect actual",
|
|
built_in:
|
|
"Byte Short Char Int Long Boolean Float Double Void Unit Nothing",
|
|
literal: "true false null",
|
|
},
|
|
t = { className: "symbol", begin: e.UNDERSCORE_IDENT_RE + "@" },
|
|
a = {
|
|
className: "subst",
|
|
begin: /\$\{/,
|
|
end: /\}/,
|
|
contains: [e.C_NUMBER_MODE],
|
|
},
|
|
i = {
|
|
className: "variable",
|
|
begin: "\\$" + e.UNDERSCORE_IDENT_RE,
|
|
},
|
|
r = {
|
|
className: "string",
|
|
variants: [
|
|
{ begin: '"""', end: '"""(?=[^"])', contains: [i, a] },
|
|
{
|
|
begin: "'",
|
|
end: "'",
|
|
illegal: /\n/,
|
|
contains: [e.BACKSLASH_ESCAPE],
|
|
},
|
|
{
|
|
begin: '"',
|
|
end: '"',
|
|
illegal: /\n/,
|
|
contains: [e.BACKSLASH_ESCAPE, i, a],
|
|
},
|
|
],
|
|
};
|
|
a.contains.push(r);
|
|
const s = {
|
|
className: "meta",
|
|
begin:
|
|
"@(?:file|property|field|get|set|receiver|param|setparam|delegate)\\s*:(?:\\s*" +
|
|
e.UNDERSCORE_IDENT_RE +
|
|
")?",
|
|
},
|
|
o = {
|
|
className: "meta",
|
|
begin: "@" + e.UNDERSCORE_IDENT_RE,
|
|
contains: [
|
|
{
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
contains: [e.inherit(r, { className: "string" }), "self"],
|
|
},
|
|
],
|
|
},
|
|
l = me,
|
|
c = e.COMMENT("/\\*", "\\*/", { contains: [e.C_BLOCK_COMMENT_MODE] }),
|
|
d = {
|
|
variants: [
|
|
{ className: "type", begin: e.UNDERSCORE_IDENT_RE },
|
|
{ begin: /\(/, end: /\)/, contains: [] },
|
|
],
|
|
},
|
|
g = d;
|
|
return (
|
|
(g.variants[1].contains = [d]),
|
|
(d.variants[1].contains = [g]),
|
|
{
|
|
name: "Kotlin",
|
|
aliases: ["kt", "kts"],
|
|
keywords: n,
|
|
contains: [
|
|
e.COMMENT("/\\*\\*", "\\*/", {
|
|
relevance: 0,
|
|
contains: [{ className: "doctag", begin: "@[A-Za-z]+" }],
|
|
}),
|
|
e.C_LINE_COMMENT_MODE,
|
|
c,
|
|
{
|
|
className: "keyword",
|
|
begin: /\b(break|continue|return|this)\b/,
|
|
starts: { contains: [{ className: "symbol", begin: /@\w+/ }] },
|
|
},
|
|
t,
|
|
s,
|
|
o,
|
|
{
|
|
className: "function",
|
|
beginKeywords: "fun",
|
|
end: "[(]|$",
|
|
returnBegin: !0,
|
|
excludeEnd: !0,
|
|
keywords: n,
|
|
relevance: 5,
|
|
contains: [
|
|
{
|
|
begin: e.UNDERSCORE_IDENT_RE + "\\s*\\(",
|
|
returnBegin: !0,
|
|
relevance: 0,
|
|
contains: [e.UNDERSCORE_TITLE_MODE],
|
|
},
|
|
{
|
|
className: "type",
|
|
begin: /</,
|
|
end: />/,
|
|
keywords: "reified",
|
|
relevance: 0,
|
|
},
|
|
{
|
|
className: "params",
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
endsParent: !0,
|
|
keywords: n,
|
|
relevance: 0,
|
|
contains: [
|
|
{
|
|
begin: /:/,
|
|
end: /[=,/]/,
|
|
endsWithParent: !0,
|
|
contains: [d, e.C_LINE_COMMENT_MODE, c],
|
|
relevance: 0,
|
|
},
|
|
e.C_LINE_COMMENT_MODE,
|
|
c,
|
|
s,
|
|
o,
|
|
r,
|
|
e.C_NUMBER_MODE,
|
|
],
|
|
},
|
|
c,
|
|
],
|
|
},
|
|
{
|
|
begin: [/class|interface|trait/, /\s+/, e.UNDERSCORE_IDENT_RE],
|
|
beginScope: {
|
|
3: "title.class",
|
|
},
|
|
keywords: "class interface trait",
|
|
end: /[:{(]|$/,
|
|
excludeEnd: !0,
|
|
illegal: "extends implements",
|
|
contains: [
|
|
{
|
|
beginKeywords:
|
|
"public protected internal private constructor",
|
|
},
|
|
e.UNDERSCORE_TITLE_MODE,
|
|
{
|
|
className: "type",
|
|
begin: /</,
|
|
end: />/,
|
|
excludeBegin: !0,
|
|
excludeEnd: !0,
|
|
relevance: 0,
|
|
},
|
|
{
|
|
className: "type",
|
|
begin: /[,:]\s*/,
|
|
end: /[<(,){\s]|$/,
|
|
excludeBegin: !0,
|
|
returnEnd: !0,
|
|
},
|
|
s,
|
|
o,
|
|
],
|
|
},
|
|
r,
|
|
{
|
|
className: "meta",
|
|
begin: "^#!/usr/bin/env",
|
|
end: "$",
|
|
illegal: "\n",
|
|
},
|
|
l,
|
|
],
|
|
}
|
|
);
|
|
},
|
|
grmr_less: (e) => {
|
|
const n = ie(e),
|
|
t = de,
|
|
a = "[\\w-]+",
|
|
i = "(" + a + "|@\\{" + a + "\\})",
|
|
r = [],
|
|
s = [],
|
|
o = (e) => ({
|
|
className: "string",
|
|
begin: "~?" + e + ".*?" + e,
|
|
}),
|
|
l = (e, n, t) => ({ className: e, begin: n, relevance: t }),
|
|
c = {
|
|
$pattern: /[a-z-]+/,
|
|
keyword: "and or not only",
|
|
attribute: se.join(" "),
|
|
},
|
|
d = {
|
|
begin: "\\(",
|
|
end: "\\)",
|
|
contains: s,
|
|
keywords: c,
|
|
relevance: 0,
|
|
};
|
|
s.push(
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
o("'"),
|
|
o('"'),
|
|
n.CSS_NUMBER_MODE,
|
|
{
|
|
begin: "(url|data-uri)\\(",
|
|
starts: { className: "string", end: "[\\)\\n]", excludeEnd: !0 },
|
|
},
|
|
n.HEXCOLOR,
|
|
d,
|
|
l("variable", "@@?" + a, 10),
|
|
l("variable", "@\\{" + a + "\\}"),
|
|
l("built_in", "~?`[^`]*?`"),
|
|
{
|
|
className: "attribute",
|
|
begin: a + "\\s*:",
|
|
end: ":",
|
|
returnBegin: !0,
|
|
excludeEnd: !0,
|
|
},
|
|
n.IMPORTANT,
|
|
{ beginKeywords: "and not" },
|
|
n.FUNCTION_DISPATCH,
|
|
);
|
|
const g = s.concat({
|
|
begin: /\{/,
|
|
end: /\}/,
|
|
contains: r,
|
|
}),
|
|
u = {
|
|
beginKeywords: "when",
|
|
endsWithParent: !0,
|
|
contains: [{ beginKeywords: "and not" }].concat(s),
|
|
},
|
|
b = {
|
|
begin: i + "\\s*:",
|
|
returnBegin: !0,
|
|
end: /[;}]/,
|
|
relevance: 0,
|
|
contains: [
|
|
{ begin: /-(webkit|moz|ms|o)-/ },
|
|
n.CSS_VARIABLE,
|
|
{
|
|
className: "attribute",
|
|
begin: "\\b(" + ce.join("|") + ")\\b",
|
|
end: /(?=:)/,
|
|
starts: {
|
|
endsWithParent: !0,
|
|
illegal: "[<=$]",
|
|
relevance: 0,
|
|
contains: s,
|
|
},
|
|
},
|
|
],
|
|
},
|
|
m = {
|
|
className: "keyword",
|
|
begin:
|
|
"@(import|media|charset|font-face|(-[a-z]+-)?keyframes|supports|document|namespace|page|viewport|host)\\b",
|
|
starts: {
|
|
end: "[;{}]",
|
|
keywords: c,
|
|
returnEnd: !0,
|
|
contains: s,
|
|
relevance: 0,
|
|
},
|
|
},
|
|
p = {
|
|
className: "variable",
|
|
variants: [
|
|
{ begin: "@" + a + "\\s*:", relevance: 15 },
|
|
{ begin: "@" + a },
|
|
],
|
|
starts: { end: "[;}]", returnEnd: !0, contains: g },
|
|
},
|
|
_ = {
|
|
variants: [
|
|
{
|
|
begin: "[\\.#:&\\[>]",
|
|
end: "[;{}]",
|
|
},
|
|
{ begin: i, end: /\{/ },
|
|
],
|
|
returnBegin: !0,
|
|
returnEnd: !0,
|
|
illegal: "[<='$\"]",
|
|
relevance: 0,
|
|
contains: [
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
u,
|
|
l("keyword", "all\\b"),
|
|
l("variable", "@\\{" + a + "\\}"),
|
|
{
|
|
begin: "\\b(" + re.join("|") + ")\\b",
|
|
className: "selector-tag",
|
|
},
|
|
n.CSS_NUMBER_MODE,
|
|
l("selector-tag", i, 0),
|
|
l("selector-id", "#" + i),
|
|
l("selector-class", "\\." + i, 0),
|
|
l("selector-tag", "&", 0),
|
|
n.ATTRIBUTE_SELECTOR_MODE,
|
|
{
|
|
className: "selector-pseudo",
|
|
begin: ":(" + oe.join("|") + ")",
|
|
},
|
|
{
|
|
className: "selector-pseudo",
|
|
begin: ":(:)?(" + le.join("|") + ")",
|
|
},
|
|
{ begin: /\(/, end: /\)/, relevance: 0, contains: g },
|
|
{ begin: "!important" },
|
|
n.FUNCTION_DISPATCH,
|
|
],
|
|
},
|
|
h = {
|
|
begin: a + ":(:)?" + `(${t.join("|")})`,
|
|
returnBegin: !0,
|
|
contains: [_],
|
|
};
|
|
return (
|
|
r.push(
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
m,
|
|
p,
|
|
h,
|
|
b,
|
|
_,
|
|
u,
|
|
n.FUNCTION_DISPATCH,
|
|
),
|
|
{
|
|
name: "Less",
|
|
case_insensitive: !0,
|
|
illegal: "[=>'/<($\"]",
|
|
contains: r,
|
|
}
|
|
);
|
|
},
|
|
grmr_lua: (e) => {
|
|
const n = "\\[=*\\[",
|
|
t = "\\]=*\\]",
|
|
a = { begin: n, end: t, contains: ["self"] },
|
|
i = [
|
|
e.COMMENT("--(?!" + n + ")", "$"),
|
|
e.COMMENT("--" + n, t, { contains: [a], relevance: 10 }),
|
|
];
|
|
return {
|
|
name: "Lua",
|
|
keywords: {
|
|
$pattern: e.UNDERSCORE_IDENT_RE,
|
|
literal: "true false nil",
|
|
keyword:
|
|
"and break do else elseif end for goto if in local not or repeat return then until while",
|
|
built_in:
|
|
"_G _ENV _VERSION __index __newindex __mode __call __metatable __tostring __len __gc __add __sub __mul __div __mod __pow __concat __unm __eq __lt __le assert collectgarbage dofile error getfenv getmetatable ipairs load loadfile loadstring module next pairs pcall print rawequal rawget rawset require select setfenv setmetatable tonumber tostring type unpack xpcall arg self coroutine resume yield status wrap create running debug getupvalue debug sethook getmetatable gethook setmetatable setlocal traceback setfenv getinfo setupvalue getlocal getregistry getfenv io lines write close flush open output type read stderr stdin input stdout popen tmpfile math log max acos huge ldexp pi cos tanh pow deg tan cosh sinh random randomseed frexp ceil floor rad abs sqrt modf asin min mod fmod log10 atan2 exp sin atan os exit setlocale date getenv difftime remove time clock tmpname rename execute package preload loadlib loaded loaders cpath config path seeall string sub upper len gfind rep find match char dump gmatch reverse byte format gsub lower table setn insert getn foreachi maxn foreach concat sort remove",
|
|
},
|
|
contains: i.concat([
|
|
{
|
|
className: "function",
|
|
beginKeywords: "function",
|
|
end: "\\)",
|
|
contains: [
|
|
e.inherit(e.TITLE_MODE, {
|
|
begin: "([_a-zA-Z]\\w*\\.)*([_a-zA-Z]\\w*:)?[_a-zA-Z]\\w*",
|
|
}),
|
|
{
|
|
className: "params",
|
|
begin: "\\(",
|
|
endsWithParent: !0,
|
|
contains: i,
|
|
},
|
|
].concat(i),
|
|
},
|
|
e.C_NUMBER_MODE,
|
|
e.APOS_STRING_MODE,
|
|
e.QUOTE_STRING_MODE,
|
|
{
|
|
className: "string",
|
|
begin: n,
|
|
end: t,
|
|
contains: [a],
|
|
relevance: 5,
|
|
},
|
|
]),
|
|
};
|
|
},
|
|
grmr_makefile: (e) => {
|
|
const n = {
|
|
className: "variable",
|
|
variants: [
|
|
{
|
|
begin: "\\$\\(" + e.UNDERSCORE_IDENT_RE + "\\)",
|
|
contains: [e.BACKSLASH_ESCAPE],
|
|
},
|
|
{ begin: /\$[@%<?^+*]/ },
|
|
],
|
|
},
|
|
t = {
|
|
className: "string",
|
|
begin: /"/,
|
|
end: /"/,
|
|
contains: [e.BACKSLASH_ESCAPE, n],
|
|
},
|
|
a = {
|
|
className: "variable",
|
|
begin: /\$\([\w-]+\s/,
|
|
end: /\)/,
|
|
keywords: {
|
|
built_in:
|
|
"subst patsubst strip findstring filter filter-out sort word wordlist firstword lastword dir notdir suffix basename addsuffix addprefix join wildcard realpath abspath error warning shell origin flavor foreach if or and call eval file value",
|
|
},
|
|
contains: [n],
|
|
},
|
|
i = { begin: "^" + e.UNDERSCORE_IDENT_RE + "\\s*(?=[:+?]?=)" },
|
|
r = {
|
|
className: "section",
|
|
begin: /^[^\s]+:/,
|
|
end: /$/,
|
|
contains: [n],
|
|
};
|
|
return {
|
|
name: "Makefile",
|
|
aliases: ["mk", "mak", "make"],
|
|
keywords: {
|
|
$pattern: /[\w-]+/,
|
|
keyword:
|
|
"define endef undefine ifdef ifndef ifeq ifneq else endif include -include sinclude override export unexport private vpath",
|
|
},
|
|
contains: [
|
|
e.HASH_COMMENT_MODE,
|
|
n,
|
|
t,
|
|
a,
|
|
i,
|
|
{
|
|
className: "meta",
|
|
begin: /^\.PHONY:/,
|
|
end: /$/,
|
|
keywords: { $pattern: /[.\w]+/, keyword: ".PHONY" },
|
|
},
|
|
r,
|
|
],
|
|
};
|
|
},
|
|
grmr_markdown: (e) => {
|
|
const n = {
|
|
begin: /<\/?[A-Za-z_]/,
|
|
end: ">",
|
|
subLanguage: "xml",
|
|
relevance: 0,
|
|
},
|
|
t = {
|
|
variants: [
|
|
{ begin: /\[.+?\]\[.*?\]/, relevance: 0 },
|
|
{
|
|
begin:
|
|
/\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
|
|
relevance: 2,
|
|
},
|
|
{
|
|
begin: e.regex.concat(
|
|
/\[.+?\]\(/,
|
|
/[A-Za-z][A-Za-z0-9+.-]*/,
|
|
/:\/\/.*?\)/,
|
|
),
|
|
relevance: 2,
|
|
},
|
|
{ begin: /\[.+?\]\([./?&#].*?\)/, relevance: 1 },
|
|
{
|
|
begin: /\[.*?\]\(.*?\)/,
|
|
relevance: 0,
|
|
},
|
|
],
|
|
returnBegin: !0,
|
|
contains: [
|
|
{ match: /\[(?=\])/ },
|
|
{
|
|
className: "string",
|
|
relevance: 0,
|
|
begin: "\\[",
|
|
end: "\\]",
|
|
excludeBegin: !0,
|
|
returnEnd: !0,
|
|
},
|
|
{
|
|
className: "link",
|
|
relevance: 0,
|
|
begin: "\\]\\(",
|
|
end: "\\)",
|
|
excludeBegin: !0,
|
|
excludeEnd: !0,
|
|
},
|
|
{
|
|
className: "symbol",
|
|
relevance: 0,
|
|
begin: "\\]\\[",
|
|
end: "\\]",
|
|
excludeBegin: !0,
|
|
excludeEnd: !0,
|
|
},
|
|
],
|
|
},
|
|
a = {
|
|
className: "strong",
|
|
contains: [],
|
|
variants: [
|
|
{ begin: /_{2}(?!\s)/, end: /_{2}/ },
|
|
{ begin: /\*{2}(?!\s)/, end: /\*{2}/ },
|
|
],
|
|
},
|
|
i = {
|
|
className: "emphasis",
|
|
contains: [],
|
|
variants: [
|
|
{ begin: /\*(?![*\s])/, end: /\*/ },
|
|
{
|
|
begin: /_(?![_\s])/,
|
|
end: /_/,
|
|
relevance: 0,
|
|
},
|
|
],
|
|
},
|
|
r = e.inherit(a, { contains: [] }),
|
|
s = e.inherit(i, { contains: [] });
|
|
a.contains.push(s), i.contains.push(r);
|
|
let o = [n, t];
|
|
return (
|
|
[a, i, r, s].forEach((e) => {
|
|
e.contains = e.contains.concat(o);
|
|
}),
|
|
(o = o.concat(a, i)),
|
|
{
|
|
name: "Markdown",
|
|
aliases: ["md", "mkdown", "mkd"],
|
|
contains: [
|
|
{
|
|
className: "section",
|
|
variants: [
|
|
{ begin: "^#{1,6}", end: "$", contains: o },
|
|
{
|
|
begin: "(?=^.+?\\n[=-]{2,}$)",
|
|
contains: [
|
|
{ begin: "^[=-]*$" },
|
|
{ begin: "^", end: "\\n", contains: o },
|
|
],
|
|
},
|
|
],
|
|
},
|
|
n,
|
|
{
|
|
className: "bullet",
|
|
begin: "^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)",
|
|
end: "\\s+",
|
|
excludeEnd: !0,
|
|
},
|
|
a,
|
|
i,
|
|
{ className: "quote", begin: "^>\\s+", contains: o, end: "$" },
|
|
{
|
|
className: "code",
|
|
variants: [
|
|
{ begin: "(`{3,})[^`](.|\\n)*?\\1`*[ ]*" },
|
|
{
|
|
begin: "(~{3,})[^~](.|\\n)*?\\1~*[ ]*",
|
|
},
|
|
{ begin: "```", end: "```+[ ]*$" },
|
|
{
|
|
begin: "~~~",
|
|
end: "~~~+[ ]*$",
|
|
},
|
|
{ begin: "`.+?`" },
|
|
{
|
|
begin: "(?=^( {4}|\\t))",
|
|
contains: [{ begin: "^( {4}|\\t)", end: "(\\n)$" }],
|
|
relevance: 0,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
begin: "^[-\\*]{3,}",
|
|
end: "$",
|
|
},
|
|
t,
|
|
{
|
|
begin: /^\[[^\n]+\]:/,
|
|
returnBegin: !0,
|
|
contains: [
|
|
{
|
|
className: "symbol",
|
|
begin: /\[/,
|
|
end: /\]/,
|
|
excludeBegin: !0,
|
|
excludeEnd: !0,
|
|
},
|
|
{
|
|
className: "link",
|
|
begin: /:\s*/,
|
|
end: /$/,
|
|
excludeBegin: !0,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
}
|
|
);
|
|
},
|
|
grmr_objectivec: (e) => {
|
|
const n = /[a-zA-Z@][a-zA-Z0-9_]*/,
|
|
t = {
|
|
$pattern: n,
|
|
keyword: ["@interface", "@class", "@protocol", "@implementation"],
|
|
};
|
|
return {
|
|
name: "Objective-C",
|
|
aliases: ["mm", "objc", "obj-c", "obj-c++", "objective-c++"],
|
|
keywords: {
|
|
"variable.language": ["this", "super"],
|
|
$pattern: n,
|
|
keyword: [
|
|
"while",
|
|
"export",
|
|
"sizeof",
|
|
"typedef",
|
|
"const",
|
|
"struct",
|
|
"for",
|
|
"union",
|
|
"volatile",
|
|
"static",
|
|
"mutable",
|
|
"if",
|
|
"do",
|
|
"return",
|
|
"goto",
|
|
"enum",
|
|
"else",
|
|
"break",
|
|
"extern",
|
|
"asm",
|
|
"case",
|
|
"default",
|
|
"register",
|
|
"explicit",
|
|
"typename",
|
|
"switch",
|
|
"continue",
|
|
"inline",
|
|
"readonly",
|
|
"assign",
|
|
"readwrite",
|
|
"self",
|
|
"@synchronized",
|
|
"id",
|
|
"typeof",
|
|
"nonatomic",
|
|
"IBOutlet",
|
|
"IBAction",
|
|
"strong",
|
|
"weak",
|
|
"copy",
|
|
"in",
|
|
"out",
|
|
"inout",
|
|
"bycopy",
|
|
"byref",
|
|
"oneway",
|
|
"__strong",
|
|
"__weak",
|
|
"__block",
|
|
"__autoreleasing",
|
|
"@private",
|
|
"@protected",
|
|
"@public",
|
|
"@try",
|
|
"@property",
|
|
"@end",
|
|
"@throw",
|
|
"@catch",
|
|
"@finally",
|
|
"@autoreleasepool",
|
|
"@synthesize",
|
|
"@dynamic",
|
|
"@selector",
|
|
"@optional",
|
|
"@required",
|
|
"@encode",
|
|
"@package",
|
|
"@import",
|
|
"@defs",
|
|
"@compatibility_alias",
|
|
"__bridge",
|
|
"__bridge_transfer",
|
|
"__bridge_retained",
|
|
"__bridge_retain",
|
|
"__covariant",
|
|
"__contravariant",
|
|
"__kindof",
|
|
"_Nonnull",
|
|
"_Nullable",
|
|
"_Null_unspecified",
|
|
"__FUNCTION__",
|
|
"__PRETTY_FUNCTION__",
|
|
"__attribute__",
|
|
"getter",
|
|
"setter",
|
|
"retain",
|
|
"unsafe_unretained",
|
|
"nonnull",
|
|
"nullable",
|
|
"null_unspecified",
|
|
"null_resettable",
|
|
"class",
|
|
"instancetype",
|
|
"NS_DESIGNATED_INITIALIZER",
|
|
"NS_UNAVAILABLE",
|
|
"NS_REQUIRES_SUPER",
|
|
"NS_RETURNS_INNER_POINTER",
|
|
"NS_INLINE",
|
|
"NS_AVAILABLE",
|
|
"NS_DEPRECATED",
|
|
"NS_ENUM",
|
|
"NS_OPTIONS",
|
|
"NS_SWIFT_UNAVAILABLE",
|
|
"NS_ASSUME_NONNULL_BEGIN",
|
|
"NS_ASSUME_NONNULL_END",
|
|
"NS_REFINED_FOR_SWIFT",
|
|
"NS_SWIFT_NAME",
|
|
"NS_SWIFT_NOTHROW",
|
|
"NS_DURING",
|
|
"NS_HANDLER",
|
|
"NS_ENDHANDLER",
|
|
"NS_VALUERETURN",
|
|
"NS_VOIDRETURN",
|
|
],
|
|
literal: [
|
|
"false",
|
|
"true",
|
|
"FALSE",
|
|
"TRUE",
|
|
"nil",
|
|
"YES",
|
|
"NO",
|
|
"NULL",
|
|
],
|
|
built_in: [
|
|
"dispatch_once_t",
|
|
"dispatch_queue_t",
|
|
"dispatch_sync",
|
|
"dispatch_async",
|
|
"dispatch_once",
|
|
],
|
|
type: [
|
|
"int",
|
|
"float",
|
|
"char",
|
|
"unsigned",
|
|
"signed",
|
|
"short",
|
|
"long",
|
|
"double",
|
|
"wchar_t",
|
|
"unichar",
|
|
"void",
|
|
"bool",
|
|
"BOOL",
|
|
"id|0",
|
|
"_Bool",
|
|
],
|
|
},
|
|
illegal: "</",
|
|
contains: [
|
|
{
|
|
className: "built_in",
|
|
begin:
|
|
"\\b(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)\\w+",
|
|
},
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
e.C_NUMBER_MODE,
|
|
e.QUOTE_STRING_MODE,
|
|
e.APOS_STRING_MODE,
|
|
{
|
|
className: "string",
|
|
variants: [
|
|
{
|
|
begin: '@"',
|
|
end: '"',
|
|
illegal: "\\n",
|
|
contains: [e.BACKSLASH_ESCAPE],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
className: "meta",
|
|
begin: /#\s*[a-z]+\b/,
|
|
end: /$/,
|
|
keywords: {
|
|
keyword:
|
|
"if else elif endif define undef warning error line pragma ifdef ifndef include",
|
|
},
|
|
contains: [
|
|
{ begin: /\\\n/, relevance: 0 },
|
|
e.inherit(e.QUOTE_STRING_MODE, {
|
|
className: "string",
|
|
}),
|
|
{ className: "string", begin: /<.*?>/, end: /$/, illegal: "\\n" },
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
],
|
|
},
|
|
{
|
|
className: "class",
|
|
begin: "(" + t.keyword.join("|") + ")\\b",
|
|
end: /(\{|$)/,
|
|
excludeEnd: !0,
|
|
keywords: t,
|
|
contains: [e.UNDERSCORE_TITLE_MODE],
|
|
},
|
|
{ begin: "\\." + e.UNDERSCORE_IDENT_RE, relevance: 0 },
|
|
],
|
|
};
|
|
},
|
|
grmr_perl: (e) => {
|
|
const n = e.regex,
|
|
t = /[dualxmsipngr]{0,12}/,
|
|
a = {
|
|
$pattern: /[\w.]+/,
|
|
keyword:
|
|
"abs accept alarm and atan2 bind binmode bless break caller chdir chmod chomp chop chown chr chroot close closedir connect continue cos crypt dbmclose dbmopen defined delete die do dump each else elsif endgrent endhostent endnetent endprotoent endpwent endservent eof eval exec exists exit exp fcntl fileno flock for foreach fork format formline getc getgrent getgrgid getgrnam gethostbyaddr gethostbyname gethostent getlogin getnetbyaddr getnetbyname getnetent getpeername getpgrp getpriority getprotobyname getprotobynumber getprotoent getpwent getpwnam getpwuid getservbyname getservbyport getservent getsockname getsockopt given glob gmtime goto grep gt hex if index int ioctl join keys kill last lc lcfirst length link listen local localtime log lstat lt ma map mkdir msgctl msgget msgrcv msgsnd my ne next no not oct open opendir or ord our pack package pipe pop pos print printf prototype push q|0 qq quotemeta qw qx rand read readdir readline readlink readpipe recv redo ref rename require reset return reverse rewinddir rindex rmdir say scalar seek seekdir select semctl semget semop send setgrent sethostent setnetent setpgrp setpriority setprotoent setpwent setservent setsockopt shift shmctl shmget shmread shmwrite shutdown sin sleep socket socketpair sort splice split sprintf sqrt srand stat state study sub substr symlink syscall sysopen sysread sysseek system syswrite tell telldir tie tied time times tr truncate uc ucfirst umask undef unless unlink unpack unshift untie until use utime values vec wait waitpid wantarray warn when while write x|0 xor y|0",
|
|
},
|
|
i = { className: "subst", begin: "[$@]\\{", end: "\\}", keywords: a },
|
|
r = { begin: /->\{/, end: /\}/ },
|
|
s = {
|
|
variants: [
|
|
{ begin: /\$\d/ },
|
|
{
|
|
begin: n.concat(
|
|
/[$%@](\^\w\b|#\w+(::\w+)*|\{\w+\}|\w+(::\w*)*)/,
|
|
"(?![A-Za-z])(?![@$%])",
|
|
),
|
|
},
|
|
{ begin: /[$%@][^\s\w{]/, relevance: 0 },
|
|
],
|
|
},
|
|
o = [e.BACKSLASH_ESCAPE, i, s],
|
|
l = [/!/, /\//, /\|/, /\?/, /'/, /"/, /#/],
|
|
c = (e, a, i = "\\1") => {
|
|
const r = "\\1" === i ? i : n.concat(i, a);
|
|
return n.concat(
|
|
n.concat("(?:", e, ")"),
|
|
a,
|
|
/(?:\\.|[^\\/])*?/,
|
|
r,
|
|
/(?:\\.|[^\\/])*?/,
|
|
i,
|
|
t,
|
|
);
|
|
},
|
|
d = (e, a, i) =>
|
|
n.concat(n.concat("(?:", e, ")"), a, /(?:\\.|[^\\/])*?/, i, t),
|
|
g = [
|
|
s,
|
|
e.HASH_COMMENT_MODE,
|
|
e.COMMENT(/^=\w/, /=cut/, {
|
|
endsWithParent: !0,
|
|
}),
|
|
r,
|
|
{
|
|
className: "string",
|
|
contains: o,
|
|
variants: [
|
|
{
|
|
begin: "q[qwxr]?\\s*\\(",
|
|
end: "\\)",
|
|
relevance: 5,
|
|
},
|
|
{ begin: "q[qwxr]?\\s*\\[", end: "\\]", relevance: 5 },
|
|
{ begin: "q[qwxr]?\\s*\\{", end: "\\}", relevance: 5 },
|
|
{
|
|
begin: "q[qwxr]?\\s*\\|",
|
|
end: "\\|",
|
|
relevance: 5,
|
|
},
|
|
{ begin: "q[qwxr]?\\s*<", end: ">", relevance: 5 },
|
|
{ begin: "qw\\s+q", end: "q", relevance: 5 },
|
|
{ begin: "'", end: "'", contains: [e.BACKSLASH_ESCAPE] },
|
|
{ begin: '"', end: '"' },
|
|
{ begin: "`", end: "`", contains: [e.BACKSLASH_ESCAPE] },
|
|
{ begin: /\{\w+\}/, relevance: 0 },
|
|
{
|
|
begin: "-?\\w+\\s*=>",
|
|
relevance: 0,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
className: "number",
|
|
begin:
|
|
"(\\b0[0-7_]+)|(\\b0x[0-9a-fA-F_]+)|(\\b[1-9][0-9_]*(\\.[0-9_]+)?)|[0_]\\b",
|
|
relevance: 0,
|
|
},
|
|
{
|
|
begin:
|
|
"(\\/\\/|" +
|
|
e.RE_STARTERS_RE +
|
|
"|\\b(split|return|print|reverse|grep)\\b)\\s*",
|
|
keywords: "split return print reverse grep",
|
|
relevance: 0,
|
|
contains: [
|
|
e.HASH_COMMENT_MODE,
|
|
{
|
|
className: "regexp",
|
|
variants: [
|
|
{
|
|
begin: c("s|tr|y", n.either(...l, { capture: !0 })),
|
|
},
|
|
{ begin: c("s|tr|y", "\\(", "\\)") },
|
|
{
|
|
begin: c("s|tr|y", "\\[", "\\]"),
|
|
},
|
|
{ begin: c("s|tr|y", "\\{", "\\}") },
|
|
],
|
|
relevance: 2,
|
|
},
|
|
{
|
|
className: "regexp",
|
|
variants: [
|
|
{ begin: /(m|qr)\/\//, relevance: 0 },
|
|
{
|
|
begin: d("(?:m|qr)?", /\//, /\//),
|
|
},
|
|
{ begin: d("m|qr", n.either(...l, { capture: !0 }), /\1/) },
|
|
{ begin: d("m|qr", /\(/, /\)/) },
|
|
{ begin: d("m|qr", /\[/, /\]/) },
|
|
{
|
|
begin: d("m|qr", /\{/, /\}/),
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
className: "function",
|
|
beginKeywords: "sub",
|
|
end: "(\\s*\\(.*?\\))?[;{]",
|
|
excludeEnd: !0,
|
|
relevance: 5,
|
|
contains: [e.TITLE_MODE],
|
|
},
|
|
{
|
|
begin: "-\\w\\b",
|
|
relevance: 0,
|
|
},
|
|
{
|
|
begin: "^__DATA__$",
|
|
end: "^__END__$",
|
|
subLanguage: "mojolicious",
|
|
contains: [{ begin: "^@@.*", end: "$", className: "comment" }],
|
|
},
|
|
];
|
|
return (
|
|
(i.contains = g),
|
|
(r.contains = g),
|
|
{ name: "Perl", aliases: ["pl", "pm"], keywords: a, contains: g }
|
|
);
|
|
},
|
|
grmr_php: (e) => {
|
|
const n = e.regex,
|
|
t = /(?![A-Za-z0-9])(?![$])/,
|
|
a = n.concat(/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/, t),
|
|
i = n.concat(
|
|
/(\\?[A-Z][a-z0-9_\x7f-\xff]+|\\?[A-Z]+(?=[A-Z][a-z0-9_\x7f-\xff])){1,}/,
|
|
t,
|
|
),
|
|
r = {
|
|
scope: "variable",
|
|
match: "\\$+" + a,
|
|
},
|
|
s = {
|
|
scope: "subst",
|
|
variants: [
|
|
{ begin: /\$\w+/ },
|
|
{
|
|
begin: /\{\$/,
|
|
end: /\}/,
|
|
},
|
|
],
|
|
},
|
|
o = e.inherit(e.APOS_STRING_MODE, { illegal: null }),
|
|
l = "[ \t\n]",
|
|
c = {
|
|
scope: "string",
|
|
variants: [
|
|
e.inherit(e.QUOTE_STRING_MODE, {
|
|
illegal: null,
|
|
contains: e.QUOTE_STRING_MODE.contains.concat(s),
|
|
}),
|
|
o,
|
|
{
|
|
begin: /<<<[ \t]*(?:(\w+)|"(\w+)")\n/,
|
|
end: /[ \t]*(\w+)\b/,
|
|
contains: e.QUOTE_STRING_MODE.contains.concat(s),
|
|
"on:begin": (e, n) => {
|
|
n.data._beginMatch = e[1] || e[2];
|
|
},
|
|
"on:end": (e, n) => {
|
|
n.data._beginMatch !== e[1] && n.ignoreMatch();
|
|
},
|
|
},
|
|
e.END_SAME_AS_BEGIN({
|
|
begin: /<<<[ \t]*'(\w+)'\n/,
|
|
end: /[ \t]*(\w+)\b/,
|
|
}),
|
|
],
|
|
},
|
|
d = {
|
|
scope: "number",
|
|
variants: [
|
|
{
|
|
begin: "\\b0[bB][01]+(?:_[01]+)*\\b",
|
|
},
|
|
{ begin: "\\b0[oO][0-7]+(?:_[0-7]+)*\\b" },
|
|
{
|
|
begin: "\\b0[xX][\\da-fA-F]+(?:_[\\da-fA-F]+)*\\b",
|
|
},
|
|
{
|
|
begin:
|
|
"(?:\\b\\d+(?:_\\d+)*(\\.(?:\\d+(?:_\\d+)*))?|\\B\\.\\d+)(?:[eE][+-]?\\d+)?",
|
|
},
|
|
],
|
|
relevance: 0,
|
|
},
|
|
g = ["false", "null", "true"],
|
|
u = [
|
|
"__CLASS__",
|
|
"__DIR__",
|
|
"__FILE__",
|
|
"__FUNCTION__",
|
|
"__COMPILER_HALT_OFFSET__",
|
|
"__LINE__",
|
|
"__METHOD__",
|
|
"__NAMESPACE__",
|
|
"__TRAIT__",
|
|
"die",
|
|
"echo",
|
|
"exit",
|
|
"include",
|
|
"include_once",
|
|
"print",
|
|
"require",
|
|
"require_once",
|
|
"array",
|
|
"abstract",
|
|
"and",
|
|
"as",
|
|
"binary",
|
|
"bool",
|
|
"boolean",
|
|
"break",
|
|
"callable",
|
|
"case",
|
|
"catch",
|
|
"class",
|
|
"clone",
|
|
"const",
|
|
"continue",
|
|
"declare",
|
|
"default",
|
|
"do",
|
|
"double",
|
|
"else",
|
|
"elseif",
|
|
"empty",
|
|
"enddeclare",
|
|
"endfor",
|
|
"endforeach",
|
|
"endif",
|
|
"endswitch",
|
|
"endwhile",
|
|
"enum",
|
|
"eval",
|
|
"extends",
|
|
"final",
|
|
"finally",
|
|
"float",
|
|
"for",
|
|
"foreach",
|
|
"from",
|
|
"global",
|
|
"goto",
|
|
"if",
|
|
"implements",
|
|
"instanceof",
|
|
"insteadof",
|
|
"int",
|
|
"integer",
|
|
"interface",
|
|
"isset",
|
|
"iterable",
|
|
"list",
|
|
"match|0",
|
|
"mixed",
|
|
"new",
|
|
"never",
|
|
"object",
|
|
"or",
|
|
"private",
|
|
"protected",
|
|
"public",
|
|
"readonly",
|
|
"real",
|
|
"return",
|
|
"string",
|
|
"switch",
|
|
"throw",
|
|
"trait",
|
|
"try",
|
|
"unset",
|
|
"use",
|
|
"var",
|
|
"void",
|
|
"while",
|
|
"xor",
|
|
"yield",
|
|
],
|
|
b = [
|
|
"Error|0",
|
|
"AppendIterator",
|
|
"ArgumentCountError",
|
|
"ArithmeticError",
|
|
"ArrayIterator",
|
|
"ArrayObject",
|
|
"AssertionError",
|
|
"BadFunctionCallException",
|
|
"BadMethodCallException",
|
|
"CachingIterator",
|
|
"CallbackFilterIterator",
|
|
"CompileError",
|
|
"Countable",
|
|
"DirectoryIterator",
|
|
"DivisionByZeroError",
|
|
"DomainException",
|
|
"EmptyIterator",
|
|
"ErrorException",
|
|
"Exception",
|
|
"FilesystemIterator",
|
|
"FilterIterator",
|
|
"GlobIterator",
|
|
"InfiniteIterator",
|
|
"InvalidArgumentException",
|
|
"IteratorIterator",
|
|
"LengthException",
|
|
"LimitIterator",
|
|
"LogicException",
|
|
"MultipleIterator",
|
|
"NoRewindIterator",
|
|
"OutOfBoundsException",
|
|
"OutOfRangeException",
|
|
"OuterIterator",
|
|
"OverflowException",
|
|
"ParentIterator",
|
|
"ParseError",
|
|
"RangeException",
|
|
"RecursiveArrayIterator",
|
|
"RecursiveCachingIterator",
|
|
"RecursiveCallbackFilterIterator",
|
|
"RecursiveDirectoryIterator",
|
|
"RecursiveFilterIterator",
|
|
"RecursiveIterator",
|
|
"RecursiveIteratorIterator",
|
|
"RecursiveRegexIterator",
|
|
"RecursiveTreeIterator",
|
|
"RegexIterator",
|
|
"RuntimeException",
|
|
"SeekableIterator",
|
|
"SplDoublyLinkedList",
|
|
"SplFileInfo",
|
|
"SplFileObject",
|
|
"SplFixedArray",
|
|
"SplHeap",
|
|
"SplMaxHeap",
|
|
"SplMinHeap",
|
|
"SplObjectStorage",
|
|
"SplObserver",
|
|
"SplPriorityQueue",
|
|
"SplQueue",
|
|
"SplStack",
|
|
"SplSubject",
|
|
"SplTempFileObject",
|
|
"TypeError",
|
|
"UnderflowException",
|
|
"UnexpectedValueException",
|
|
"UnhandledMatchError",
|
|
"ArrayAccess",
|
|
"BackedEnum",
|
|
"Closure",
|
|
"Fiber",
|
|
"Generator",
|
|
"Iterator",
|
|
"IteratorAggregate",
|
|
"Serializable",
|
|
"Stringable",
|
|
"Throwable",
|
|
"Traversable",
|
|
"UnitEnum",
|
|
"WeakReference",
|
|
"WeakMap",
|
|
"Directory",
|
|
"__PHP_Incomplete_Class",
|
|
"parent",
|
|
"php_user_filter",
|
|
"self",
|
|
"static",
|
|
"stdClass",
|
|
],
|
|
m = {
|
|
keyword: u,
|
|
literal: ((e) => {
|
|
const n = [];
|
|
return (
|
|
e.forEach((e) => {
|
|
n.push(e),
|
|
e.toLowerCase() === e
|
|
? n.push(e.toUpperCase())
|
|
: n.push(e.toLowerCase());
|
|
}),
|
|
n
|
|
);
|
|
})(g),
|
|
built_in: b,
|
|
},
|
|
p = (e) => e.map((e) => e.replace(/\|\d+$/, "")),
|
|
_ = {
|
|
variants: [
|
|
{
|
|
match: [
|
|
/new/,
|
|
n.concat(l, "+"),
|
|
n.concat("(?!", p(b).join("\\b|"), "\\b)"),
|
|
i,
|
|
],
|
|
scope: {
|
|
1: "keyword",
|
|
4: "title.class",
|
|
},
|
|
},
|
|
],
|
|
},
|
|
h = n.concat(a, "\\b(?!\\()"),
|
|
f = {
|
|
variants: [
|
|
{
|
|
match: [n.concat(/::/, n.lookahead(/(?!class\b)/)), h],
|
|
scope: { 2: "variable.constant" },
|
|
},
|
|
{ match: [/::/, /class/], scope: { 2: "variable.language" } },
|
|
{
|
|
match: [i, n.concat(/::/, n.lookahead(/(?!class\b)/)), h],
|
|
scope: { 1: "title.class", 3: "variable.constant" },
|
|
},
|
|
{
|
|
match: [i, n.concat("::", n.lookahead(/(?!class\b)/))],
|
|
scope: { 1: "title.class" },
|
|
},
|
|
{
|
|
match: [i, /::/, /class/],
|
|
scope: { 1: "title.class", 3: "variable.language" },
|
|
},
|
|
],
|
|
},
|
|
E = {
|
|
scope: "attr",
|
|
match: n.concat(a, n.lookahead(":"), n.lookahead(/(?!::)/)),
|
|
},
|
|
y = {
|
|
relevance: 0,
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
keywords: m,
|
|
contains: [E, r, f, e.C_BLOCK_COMMENT_MODE, c, d, _],
|
|
},
|
|
N = {
|
|
relevance: 0,
|
|
match: [
|
|
/\b/,
|
|
n.concat(
|
|
"(?!fn\\b|function\\b|",
|
|
p(u).join("\\b|"),
|
|
"|",
|
|
p(b).join("\\b|"),
|
|
"\\b)",
|
|
),
|
|
a,
|
|
n.concat(l, "*"),
|
|
n.lookahead(/(?=\()/),
|
|
],
|
|
scope: { 3: "title.function.invoke" },
|
|
contains: [y],
|
|
};
|
|
y.contains.push(N);
|
|
const w = [E, f, e.C_BLOCK_COMMENT_MODE, c, d, _];
|
|
return {
|
|
case_insensitive: !1,
|
|
keywords: m,
|
|
contains: [
|
|
{
|
|
begin: n.concat(/#\[\s*/, i),
|
|
beginScope: "meta",
|
|
end: /]/,
|
|
endScope: "meta",
|
|
keywords: { literal: g, keyword: ["new", "array"] },
|
|
contains: [
|
|
{
|
|
begin: /\[/,
|
|
end: /]/,
|
|
keywords: { literal: g, keyword: ["new", "array"] },
|
|
contains: ["self", ...w],
|
|
},
|
|
...w,
|
|
{ scope: "meta", match: i },
|
|
],
|
|
},
|
|
e.HASH_COMMENT_MODE,
|
|
e.COMMENT("//", "$"),
|
|
e.COMMENT("/\\*", "\\*/", {
|
|
contains: [
|
|
{
|
|
scope: "doctag",
|
|
match: "@[A-Za-z]+",
|
|
},
|
|
],
|
|
}),
|
|
{
|
|
match: /__halt_compiler\(\);/,
|
|
keywords: "__halt_compiler",
|
|
starts: {
|
|
scope: "comment",
|
|
end: e.MATCH_NOTHING_RE,
|
|
contains: [{ match: /\?>/, scope: "meta", endsParent: !0 }],
|
|
},
|
|
},
|
|
{
|
|
scope: "meta",
|
|
variants: [
|
|
{
|
|
begin: /<\?php/,
|
|
relevance: 10,
|
|
},
|
|
{ begin: /<\?=/ },
|
|
{ begin: /<\?/, relevance: 0.1 },
|
|
{
|
|
begin: /\?>/,
|
|
},
|
|
],
|
|
},
|
|
{ scope: "variable.language", match: /\$this\b/ },
|
|
r,
|
|
N,
|
|
f,
|
|
{
|
|
match: [/const/, /\s/, a],
|
|
scope: { 1: "keyword", 3: "variable.constant" },
|
|
},
|
|
_,
|
|
{
|
|
scope: "function",
|
|
relevance: 0,
|
|
beginKeywords: "fn function",
|
|
end: /[;{]/,
|
|
excludeEnd: !0,
|
|
illegal: "[$%\\[]",
|
|
contains: [
|
|
{ beginKeywords: "use" },
|
|
e.UNDERSCORE_TITLE_MODE,
|
|
{ begin: "=>", endsParent: !0 },
|
|
{
|
|
scope: "params",
|
|
begin: "\\(",
|
|
end: "\\)",
|
|
excludeBegin: !0,
|
|
excludeEnd: !0,
|
|
keywords: m,
|
|
contains: ["self", r, f, e.C_BLOCK_COMMENT_MODE, c, d],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
scope: "class",
|
|
variants: [
|
|
{
|
|
beginKeywords: "enum",
|
|
illegal: /[($"]/,
|
|
},
|
|
{ beginKeywords: "class interface trait", illegal: /[:($"]/ },
|
|
],
|
|
relevance: 0,
|
|
end: /\{/,
|
|
excludeEnd: !0,
|
|
contains: [
|
|
{
|
|
beginKeywords: "extends implements",
|
|
},
|
|
e.UNDERSCORE_TITLE_MODE,
|
|
],
|
|
},
|
|
{
|
|
beginKeywords: "namespace",
|
|
relevance: 0,
|
|
end: ";",
|
|
illegal: /[.']/,
|
|
contains: [
|
|
e.inherit(e.UNDERSCORE_TITLE_MODE, { scope: "title.class" }),
|
|
],
|
|
},
|
|
{
|
|
beginKeywords: "use",
|
|
relevance: 0,
|
|
end: ";",
|
|
contains: [
|
|
{
|
|
match: /\b(as|const|function)\b/,
|
|
scope: "keyword",
|
|
},
|
|
e.UNDERSCORE_TITLE_MODE,
|
|
],
|
|
},
|
|
c,
|
|
d,
|
|
],
|
|
};
|
|
},
|
|
grmr_php_template: (e) => ({
|
|
name: "PHP template",
|
|
subLanguage: "xml",
|
|
contains: [
|
|
{
|
|
begin: /<\?(php|=)?/,
|
|
end: /\?>/,
|
|
subLanguage: "php",
|
|
contains: [
|
|
{ begin: "/\\*", end: "\\*/", skip: !0 },
|
|
{ begin: 'b"', end: '"', skip: !0 },
|
|
{ begin: "b'", end: "'", skip: !0 },
|
|
e.inherit(e.APOS_STRING_MODE, {
|
|
illegal: null,
|
|
className: null,
|
|
contains: null,
|
|
skip: !0,
|
|
}),
|
|
e.inherit(e.QUOTE_STRING_MODE, {
|
|
illegal: null,
|
|
className: null,
|
|
contains: null,
|
|
skip: !0,
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
}),
|
|
grmr_plaintext: (e) => ({
|
|
name: "Plain text",
|
|
aliases: ["text", "txt"],
|
|
disableAutodetect: !0,
|
|
}),
|
|
grmr_python: (e) => {
|
|
const n = e.regex,
|
|
t = /[\p{XID_Start}_]\p{XID_Continue}*/u,
|
|
a = [
|
|
"and",
|
|
"as",
|
|
"assert",
|
|
"async",
|
|
"await",
|
|
"break",
|
|
"case",
|
|
"class",
|
|
"continue",
|
|
"def",
|
|
"del",
|
|
"elif",
|
|
"else",
|
|
"except",
|
|
"finally",
|
|
"for",
|
|
"from",
|
|
"global",
|
|
"if",
|
|
"import",
|
|
"in",
|
|
"is",
|
|
"lambda",
|
|
"match",
|
|
"nonlocal|10",
|
|
"not",
|
|
"or",
|
|
"pass",
|
|
"raise",
|
|
"return",
|
|
"try",
|
|
"while",
|
|
"with",
|
|
"yield",
|
|
],
|
|
i = {
|
|
$pattern: /[A-Za-z]\w+|__\w+__/,
|
|
keyword: a,
|
|
built_in: [
|
|
"__import__",
|
|
"abs",
|
|
"all",
|
|
"any",
|
|
"ascii",
|
|
"bin",
|
|
"bool",
|
|
"breakpoint",
|
|
"bytearray",
|
|
"bytes",
|
|
"callable",
|
|
"chr",
|
|
"classmethod",
|
|
"compile",
|
|
"complex",
|
|
"delattr",
|
|
"dict",
|
|
"dir",
|
|
"divmod",
|
|
"enumerate",
|
|
"eval",
|
|
"exec",
|
|
"filter",
|
|
"float",
|
|
"format",
|
|
"frozenset",
|
|
"getattr",
|
|
"globals",
|
|
"hasattr",
|
|
"hash",
|
|
"help",
|
|
"hex",
|
|
"id",
|
|
"input",
|
|
"int",
|
|
"isinstance",
|
|
"issubclass",
|
|
"iter",
|
|
"len",
|
|
"list",
|
|
"locals",
|
|
"map",
|
|
"max",
|
|
"memoryview",
|
|
"min",
|
|
"next",
|
|
"object",
|
|
"oct",
|
|
"open",
|
|
"ord",
|
|
"pow",
|
|
"print",
|
|
"property",
|
|
"range",
|
|
"repr",
|
|
"reversed",
|
|
"round",
|
|
"set",
|
|
"setattr",
|
|
"slice",
|
|
"sorted",
|
|
"staticmethod",
|
|
"str",
|
|
"sum",
|
|
"super",
|
|
"tuple",
|
|
"type",
|
|
"vars",
|
|
"zip",
|
|
],
|
|
literal: [
|
|
"__debug__",
|
|
"Ellipsis",
|
|
"False",
|
|
"None",
|
|
"NotImplemented",
|
|
"True",
|
|
],
|
|
type: [
|
|
"Any",
|
|
"Callable",
|
|
"Coroutine",
|
|
"Dict",
|
|
"List",
|
|
"Literal",
|
|
"Generic",
|
|
"Optional",
|
|
"Sequence",
|
|
"Set",
|
|
"Tuple",
|
|
"Type",
|
|
"Union",
|
|
],
|
|
},
|
|
r = { className: "meta", begin: /^(>>>|\.\.\.) / },
|
|
s = {
|
|
className: "subst",
|
|
begin: /\{/,
|
|
end: /\}/,
|
|
keywords: i,
|
|
illegal: /#/,
|
|
},
|
|
o = { begin: /\{\{/, relevance: 0 },
|
|
l = {
|
|
className: "string",
|
|
contains: [e.BACKSLASH_ESCAPE],
|
|
variants: [
|
|
{
|
|
begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,
|
|
end: /'''/,
|
|
contains: [e.BACKSLASH_ESCAPE, r],
|
|
relevance: 10,
|
|
},
|
|
{
|
|
begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,
|
|
end: /"""/,
|
|
contains: [e.BACKSLASH_ESCAPE, r],
|
|
relevance: 10,
|
|
},
|
|
{
|
|
begin: /([fF][rR]|[rR][fF]|[fF])'''/,
|
|
end: /'''/,
|
|
contains: [e.BACKSLASH_ESCAPE, r, o, s],
|
|
},
|
|
{
|
|
begin: /([fF][rR]|[rR][fF]|[fF])"""/,
|
|
end: /"""/,
|
|
contains: [e.BACKSLASH_ESCAPE, r, o, s],
|
|
},
|
|
{ begin: /([uU]|[rR])'/, end: /'/, relevance: 10 },
|
|
{ begin: /([uU]|[rR])"/, end: /"/, relevance: 10 },
|
|
{
|
|
begin: /([bB]|[bB][rR]|[rR][bB])'/,
|
|
end: /'/,
|
|
},
|
|
{ begin: /([bB]|[bB][rR]|[rR][bB])"/, end: /"/ },
|
|
{
|
|
begin: /([fF][rR]|[rR][fF]|[fF])'/,
|
|
end: /'/,
|
|
contains: [e.BACKSLASH_ESCAPE, o, s],
|
|
},
|
|
{
|
|
begin: /([fF][rR]|[rR][fF]|[fF])"/,
|
|
end: /"/,
|
|
contains: [e.BACKSLASH_ESCAPE, o, s],
|
|
},
|
|
e.APOS_STRING_MODE,
|
|
e.QUOTE_STRING_MODE,
|
|
],
|
|
},
|
|
c = "[0-9](_?[0-9])*",
|
|
d = `(\\b(${c}))?\\.(${c})|\\b(${c})\\.`,
|
|
g = "\\b|" + a.join("|"),
|
|
u = {
|
|
className: "number",
|
|
relevance: 0,
|
|
variants: [
|
|
{
|
|
begin: `(\\b(${c})|(${d}))[eE][+-]?(${c})[jJ]?(?=${g})`,
|
|
},
|
|
{ begin: `(${d})[jJ]?` },
|
|
{
|
|
begin: `\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${g})`,
|
|
},
|
|
{
|
|
begin: `\\b0[bB](_?[01])+[lL]?(?=${g})`,
|
|
},
|
|
{ begin: `\\b0[oO](_?[0-7])+[lL]?(?=${g})` },
|
|
{ begin: `\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${g})` },
|
|
{ begin: `\\b(${c})[jJ](?=${g})` },
|
|
],
|
|
},
|
|
b = {
|
|
className: "comment",
|
|
begin: n.lookahead(/# type:/),
|
|
end: /$/,
|
|
keywords: i,
|
|
contains: [
|
|
{ begin: /# type:/ },
|
|
{ begin: /#/, end: /\b\B/, endsWithParent: !0 },
|
|
],
|
|
},
|
|
m = {
|
|
className: "params",
|
|
variants: [
|
|
{ className: "", begin: /\(\s*\)/, skip: !0 },
|
|
{
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
excludeBegin: !0,
|
|
excludeEnd: !0,
|
|
keywords: i,
|
|
contains: ["self", r, u, l, e.HASH_COMMENT_MODE],
|
|
},
|
|
],
|
|
};
|
|
return (
|
|
(s.contains = [l, u, r]),
|
|
{
|
|
name: "Python",
|
|
aliases: ["py", "gyp", "ipython"],
|
|
unicodeRegex: !0,
|
|
keywords: i,
|
|
illegal: /(<\/|\?)|=>/,
|
|
contains: [
|
|
r,
|
|
u,
|
|
{ begin: /\bself\b/ },
|
|
{ beginKeywords: "if", relevance: 0 },
|
|
l,
|
|
b,
|
|
e.HASH_COMMENT_MODE,
|
|
{
|
|
match: [/\bdef/, /\s+/, t],
|
|
scope: {
|
|
1: "keyword",
|
|
3: "title.function",
|
|
},
|
|
contains: [m],
|
|
},
|
|
{
|
|
variants: [
|
|
{
|
|
match: [/\bclass/, /\s+/, t, /\s*/, /\(\s*/, t, /\s*\)/],
|
|
},
|
|
{ match: [/\bclass/, /\s+/, t] },
|
|
],
|
|
scope: {
|
|
1: "keyword",
|
|
3: "title.class",
|
|
6: "title.class.inherited",
|
|
},
|
|
},
|
|
{
|
|
className: "meta",
|
|
begin: /^[\t ]*@/,
|
|
end: /(?=#)|$/,
|
|
contains: [u, m, l],
|
|
},
|
|
],
|
|
}
|
|
);
|
|
},
|
|
grmr_python_repl: (e) => ({
|
|
aliases: ["pycon"],
|
|
contains: [
|
|
{
|
|
className: "meta.prompt",
|
|
starts: { end: / |$/, starts: { end: "$", subLanguage: "python" } },
|
|
variants: [
|
|
{
|
|
begin: /^>>>(?=[ ]|$)/,
|
|
},
|
|
{ begin: /^\.\.\.(?=[ ]|$)/ },
|
|
],
|
|
},
|
|
],
|
|
}),
|
|
grmr_r: (e) => {
|
|
const n = e.regex,
|
|
t = /(?:(?:[a-zA-Z]|\.[._a-zA-Z])[._a-zA-Z0-9]*)|\.(?!\d)/,
|
|
a = n.either(
|
|
/0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*[pP][+-]?\d+i?/,
|
|
/0[xX][0-9a-fA-F]+(?:[pP][+-]?\d+)?[Li]?/,
|
|
/(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?[Li]?/,
|
|
),
|
|
i = /[=!<>:]=|\|\||&&|:::?|<-|<<-|->>|->|\|>|[-+*/?!$&|:<=>@^~]|\*\*/,
|
|
r = n.either(/[()]/, /[{}]/, /\[\[/, /[[\]]/, /\\/, /,/);
|
|
return {
|
|
name: "R",
|
|
keywords: {
|
|
$pattern: t,
|
|
keyword: "function if in break next repeat else for while",
|
|
literal:
|
|
"NULL NA TRUE FALSE Inf NaN NA_integer_|10 NA_real_|10 NA_character_|10 NA_complex_|10",
|
|
built_in:
|
|
"LETTERS letters month.abb month.name pi T F abs acos acosh all any anyNA Arg as.call as.character as.complex as.double as.environment as.integer as.logical as.null.default as.numeric as.raw asin asinh atan atanh attr attributes baseenv browser c call ceiling class Conj cos cosh cospi cummax cummin cumprod cumsum digamma dim dimnames emptyenv exp expression floor forceAndCall gamma gc.time globalenv Im interactive invisible is.array is.atomic is.call is.character is.complex is.double is.environment is.expression is.finite is.function is.infinite is.integer is.language is.list is.logical is.matrix is.na is.name is.nan is.null is.numeric is.object is.pairlist is.raw is.recursive is.single is.symbol lazyLoadDBfetch length lgamma list log max min missing Mod names nargs nzchar oldClass on.exit pos.to.env proc.time prod quote range Re rep retracemem return round seq_along seq_len seq.int sign signif sin sinh sinpi sqrt standardGeneric substitute sum switch tan tanh tanpi tracemem trigamma trunc unclass untracemem UseMethod xtfrm",
|
|
},
|
|
contains: [
|
|
e.COMMENT(/#'/, /$/, {
|
|
contains: [
|
|
{
|
|
scope: "doctag",
|
|
match: /@examples/,
|
|
starts: {
|
|
end: n.lookahead(
|
|
n.either(/\n^#'\s*(?=@[a-zA-Z]+)/, /\n^(?!#')/),
|
|
),
|
|
endsParent: !0,
|
|
},
|
|
},
|
|
{
|
|
scope: "doctag",
|
|
begin: "@param",
|
|
end: /$/,
|
|
contains: [
|
|
{
|
|
scope: "variable",
|
|
variants: [{ match: t }, { match: /`(?:\\.|[^`\\])+`/ }],
|
|
endsParent: !0,
|
|
},
|
|
],
|
|
},
|
|
{ scope: "doctag", match: /@[a-zA-Z]+/ },
|
|
{ scope: "keyword", match: /\\[a-zA-Z]+/ },
|
|
],
|
|
}),
|
|
e.HASH_COMMENT_MODE,
|
|
{
|
|
scope: "string",
|
|
contains: [e.BACKSLASH_ESCAPE],
|
|
variants: [
|
|
e.END_SAME_AS_BEGIN({ begin: /[rR]"(-*)\(/, end: /\)(-*)"/ }),
|
|
e.END_SAME_AS_BEGIN({ begin: /[rR]"(-*)\{/, end: /\}(-*)"/ }),
|
|
e.END_SAME_AS_BEGIN({ begin: /[rR]"(-*)\[/, end: /\](-*)"/ }),
|
|
e.END_SAME_AS_BEGIN({ begin: /[rR]'(-*)\(/, end: /\)(-*)'/ }),
|
|
e.END_SAME_AS_BEGIN({ begin: /[rR]'(-*)\{/, end: /\}(-*)'/ }),
|
|
e.END_SAME_AS_BEGIN({ begin: /[rR]'(-*)\[/, end: /\](-*)'/ }),
|
|
{ begin: '"', end: '"', relevance: 0 },
|
|
{ begin: "'", end: "'", relevance: 0 },
|
|
],
|
|
},
|
|
{
|
|
relevance: 0,
|
|
variants: [
|
|
{
|
|
scope: {
|
|
1: "operator",
|
|
2: "number",
|
|
},
|
|
match: [i, a],
|
|
},
|
|
{ scope: { 1: "operator", 2: "number" }, match: [/%[^%]*%/, a] },
|
|
{ scope: { 1: "punctuation", 2: "number" }, match: [r, a] },
|
|
{
|
|
scope: {
|
|
2: "number",
|
|
},
|
|
match: [/[^a-zA-Z0-9._]|^/, a],
|
|
},
|
|
],
|
|
},
|
|
{ scope: { 3: "operator" }, match: [t, /\s+/, /<-/, /\s+/] },
|
|
{
|
|
scope: "operator",
|
|
relevance: 0,
|
|
variants: [
|
|
{ match: i },
|
|
{
|
|
match: /%[^%]*%/,
|
|
},
|
|
],
|
|
},
|
|
{ scope: "punctuation", relevance: 0, match: r },
|
|
{ begin: "`", end: "`", contains: [{ begin: /\\./ }] },
|
|
],
|
|
};
|
|
},
|
|
grmr_ruby: (e) => {
|
|
const n = e.regex,
|
|
t =
|
|
"([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)",
|
|
a = n.either(/\b([A-Z]+[a-z0-9]+)+/, /\b([A-Z]+[a-z0-9]+)+[A-Z]+/),
|
|
i = n.concat(a, /(::\w+)*/),
|
|
r = {
|
|
"variable.constant": ["__FILE__", "__LINE__", "__ENCODING__"],
|
|
"variable.language": ["self", "super"],
|
|
keyword: [
|
|
"alias",
|
|
"and",
|
|
"begin",
|
|
"BEGIN",
|
|
"break",
|
|
"case",
|
|
"class",
|
|
"defined",
|
|
"do",
|
|
"else",
|
|
"elsif",
|
|
"end",
|
|
"END",
|
|
"ensure",
|
|
"for",
|
|
"if",
|
|
"in",
|
|
"module",
|
|
"next",
|
|
"not",
|
|
"or",
|
|
"redo",
|
|
"require",
|
|
"rescue",
|
|
"retry",
|
|
"return",
|
|
"then",
|
|
"undef",
|
|
"unless",
|
|
"until",
|
|
"when",
|
|
"while",
|
|
"yield",
|
|
"include",
|
|
"extend",
|
|
"prepend",
|
|
"public",
|
|
"private",
|
|
"protected",
|
|
"raise",
|
|
"throw",
|
|
],
|
|
built_in: [
|
|
"proc",
|
|
"lambda",
|
|
"attr_accessor",
|
|
"attr_reader",
|
|
"attr_writer",
|
|
"define_method",
|
|
"private_constant",
|
|
"module_function",
|
|
],
|
|
literal: ["true", "false", "nil"],
|
|
},
|
|
s = { className: "doctag", begin: "@[A-Za-z]+" },
|
|
o = {
|
|
begin: "#<",
|
|
end: ">",
|
|
},
|
|
l = [
|
|
e.COMMENT("#", "$", { contains: [s] }),
|
|
e.COMMENT("^=begin", "^=end", { contains: [s], relevance: 10 }),
|
|
e.COMMENT("^__END__", e.MATCH_NOTHING_RE),
|
|
],
|
|
c = { className: "subst", begin: /#\{/, end: /\}/, keywords: r },
|
|
d = {
|
|
className: "string",
|
|
contains: [e.BACKSLASH_ESCAPE, c],
|
|
variants: [
|
|
{ begin: /'/, end: /'/ },
|
|
{ begin: /"/, end: /"/ },
|
|
{ begin: /`/, end: /`/ },
|
|
{
|
|
begin: /%[qQwWx]?\(/,
|
|
end: /\)/,
|
|
},
|
|
{ begin: /%[qQwWx]?\[/, end: /\]/ },
|
|
{
|
|
begin: /%[qQwWx]?\{/,
|
|
end: /\}/,
|
|
},
|
|
{ begin: /%[qQwWx]?</, end: />/ },
|
|
{ begin: /%[qQwWx]?\//, end: /\// },
|
|
{ begin: /%[qQwWx]?%/, end: /%/ },
|
|
{ begin: /%[qQwWx]?-/, end: /-/ },
|
|
{
|
|
begin: /%[qQwWx]?\|/,
|
|
end: /\|/,
|
|
},
|
|
{ begin: /\B\?(\\\d{1,3})/ },
|
|
{
|
|
begin: /\B\?(\\x[A-Fa-f0-9]{1,2})/,
|
|
},
|
|
{ begin: /\B\?(\\u\{?[A-Fa-f0-9]{1,6}\}?)/ },
|
|
{
|
|
begin: /\B\?(\\M-\\C-|\\M-\\c|\\c\\M-|\\M-|\\C-\\M-)[\x20-\x7e]/,
|
|
},
|
|
{
|
|
begin: /\B\?\\(c|C-)[\x20-\x7e]/,
|
|
},
|
|
{ begin: /\B\?\\?\S/ },
|
|
{
|
|
begin: n.concat(
|
|
/<<[-~]?'?/,
|
|
n.lookahead(/(\w+)(?=\W)[^\n]*\n(?:[^\n]*\n)*?\s*\1\b/),
|
|
),
|
|
contains: [
|
|
e.END_SAME_AS_BEGIN({
|
|
begin: /(\w+)/,
|
|
end: /(\w+)/,
|
|
contains: [e.BACKSLASH_ESCAPE, c],
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
},
|
|
g = "[0-9](_?[0-9])*",
|
|
u = {
|
|
className: "number",
|
|
relevance: 0,
|
|
variants: [
|
|
{
|
|
begin: `\\b([1-9](_?[0-9])*|0)(\\.(${g}))?([eE][+-]?(${g})|r)?i?\\b`,
|
|
},
|
|
{
|
|
begin: "\\b0[dD][0-9](_?[0-9])*r?i?\\b",
|
|
},
|
|
{ begin: "\\b0[bB][0-1](_?[0-1])*r?i?\\b" },
|
|
{ begin: "\\b0[oO][0-7](_?[0-7])*r?i?\\b" },
|
|
{
|
|
begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*r?i?\\b",
|
|
},
|
|
{
|
|
begin: "\\b0(_?[0-7])+r?i?\\b",
|
|
},
|
|
],
|
|
},
|
|
b = {
|
|
variants: [
|
|
{ match: /\(\)/ },
|
|
{
|
|
className: "params",
|
|
begin: /\(/,
|
|
end: /(?=\))/,
|
|
excludeBegin: !0,
|
|
endsParent: !0,
|
|
keywords: r,
|
|
},
|
|
],
|
|
},
|
|
m = [
|
|
d,
|
|
{
|
|
variants: [
|
|
{ match: [/class\s+/, i, /\s+<\s+/, i] },
|
|
{
|
|
match: [/\b(class|module)\s+/, i],
|
|
},
|
|
],
|
|
scope: { 2: "title.class", 4: "title.class.inherited" },
|
|
keywords: r,
|
|
},
|
|
{
|
|
match: [/(include|extend)\s+/, i],
|
|
scope: {
|
|
2: "title.class",
|
|
},
|
|
keywords: r,
|
|
},
|
|
{
|
|
relevance: 0,
|
|
match: [i, /\.new[. (]/],
|
|
scope: {
|
|
1: "title.class",
|
|
},
|
|
},
|
|
{
|
|
relevance: 0,
|
|
match: /\b[A-Z][A-Z_0-9]+\b/,
|
|
className: "variable.constant",
|
|
},
|
|
{ relevance: 0, match: a, scope: "title.class" },
|
|
{
|
|
match: [/def/, /\s+/, t],
|
|
scope: { 1: "keyword", 3: "title.function" },
|
|
contains: [b],
|
|
},
|
|
{
|
|
begin: e.IDENT_RE + "::",
|
|
},
|
|
{
|
|
className: "symbol",
|
|
begin: e.UNDERSCORE_IDENT_RE + "(!|\\?)?:",
|
|
relevance: 0,
|
|
},
|
|
{
|
|
className: "symbol",
|
|
begin: ":(?!\\s)",
|
|
contains: [d, { begin: t }],
|
|
relevance: 0,
|
|
},
|
|
u,
|
|
{
|
|
className: "variable",
|
|
begin: "(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])",
|
|
},
|
|
{
|
|
className: "params",
|
|
begin: /\|/,
|
|
end: /\|/,
|
|
excludeBegin: !0,
|
|
excludeEnd: !0,
|
|
relevance: 0,
|
|
keywords: r,
|
|
},
|
|
{
|
|
begin: "(" + e.RE_STARTERS_RE + "|unless)\\s*",
|
|
keywords: "unless",
|
|
contains: [
|
|
{
|
|
className: "regexp",
|
|
contains: [e.BACKSLASH_ESCAPE, c],
|
|
illegal: /\n/,
|
|
variants: [
|
|
{ begin: "/", end: "/[a-z]*" },
|
|
{ begin: /%r\{/, end: /\}[a-z]*/ },
|
|
{
|
|
begin: "%r\\(",
|
|
end: "\\)[a-z]*",
|
|
},
|
|
{ begin: "%r!", end: "![a-z]*" },
|
|
{ begin: "%r\\[", end: "\\][a-z]*" },
|
|
],
|
|
},
|
|
].concat(o, l),
|
|
relevance: 0,
|
|
},
|
|
].concat(o, l);
|
|
(c.contains = m), (b.contains = m);
|
|
const p = [
|
|
{ begin: /^\s*=>/, starts: { end: "$", contains: m } },
|
|
{
|
|
className: "meta.prompt",
|
|
begin:
|
|
"^([>?]>|[\\w#]+\\(\\w+\\):\\d+:\\d+[>*]|(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>)(?=[ ])",
|
|
starts: { end: "$", keywords: r, contains: m },
|
|
},
|
|
];
|
|
return (
|
|
l.unshift(o),
|
|
{
|
|
name: "Ruby",
|
|
aliases: ["rb", "gemspec", "podspec", "thor", "irb"],
|
|
keywords: r,
|
|
illegal: /\/\*/,
|
|
contains: [e.SHEBANG({ binary: "ruby" })]
|
|
.concat(p)
|
|
.concat(l)
|
|
.concat(m),
|
|
}
|
|
);
|
|
},
|
|
grmr_rust: (e) => {
|
|
const n = e.regex,
|
|
t = {
|
|
className: "title.function.invoke",
|
|
relevance: 0,
|
|
begin: n.concat(
|
|
/\b/,
|
|
/(?!let|for|while|if|else|match\b)/,
|
|
e.IDENT_RE,
|
|
n.lookahead(/\s*\(/),
|
|
),
|
|
},
|
|
a = "([ui](8|16|32|64|128|size)|f(32|64))?",
|
|
i = [
|
|
"drop ",
|
|
"Copy",
|
|
"Send",
|
|
"Sized",
|
|
"Sync",
|
|
"Drop",
|
|
"Fn",
|
|
"FnMut",
|
|
"FnOnce",
|
|
"ToOwned",
|
|
"Clone",
|
|
"Debug",
|
|
"PartialEq",
|
|
"PartialOrd",
|
|
"Eq",
|
|
"Ord",
|
|
"AsRef",
|
|
"AsMut",
|
|
"Into",
|
|
"From",
|
|
"Default",
|
|
"Iterator",
|
|
"Extend",
|
|
"IntoIterator",
|
|
"DoubleEndedIterator",
|
|
"ExactSizeIterator",
|
|
"SliceConcatExt",
|
|
"ToString",
|
|
"assert!",
|
|
"assert_eq!",
|
|
"bitflags!",
|
|
"bytes!",
|
|
"cfg!",
|
|
"col!",
|
|
"concat!",
|
|
"concat_idents!",
|
|
"debug_assert!",
|
|
"debug_assert_eq!",
|
|
"env!",
|
|
"eprintln!",
|
|
"panic!",
|
|
"file!",
|
|
"format!",
|
|
"format_args!",
|
|
"include_bytes!",
|
|
"include_str!",
|
|
"line!",
|
|
"local_data_key!",
|
|
"module_path!",
|
|
"option_env!",
|
|
"print!",
|
|
"println!",
|
|
"select!",
|
|
"stringify!",
|
|
"try!",
|
|
"unimplemented!",
|
|
"unreachable!",
|
|
"vec!",
|
|
"write!",
|
|
"writeln!",
|
|
"macro_rules!",
|
|
"assert_ne!",
|
|
"debug_assert_ne!",
|
|
],
|
|
r = [
|
|
"i8",
|
|
"i16",
|
|
"i32",
|
|
"i64",
|
|
"i128",
|
|
"isize",
|
|
"u8",
|
|
"u16",
|
|
"u32",
|
|
"u64",
|
|
"u128",
|
|
"usize",
|
|
"f32",
|
|
"f64",
|
|
"str",
|
|
"char",
|
|
"bool",
|
|
"Box",
|
|
"Option",
|
|
"Result",
|
|
"String",
|
|
"Vec",
|
|
];
|
|
return {
|
|
name: "Rust",
|
|
aliases: ["rs"],
|
|
keywords: {
|
|
$pattern: e.IDENT_RE + "!?",
|
|
type: r,
|
|
keyword: [
|
|
"abstract",
|
|
"as",
|
|
"async",
|
|
"await",
|
|
"become",
|
|
"box",
|
|
"break",
|
|
"const",
|
|
"continue",
|
|
"crate",
|
|
"do",
|
|
"dyn",
|
|
"else",
|
|
"enum",
|
|
"extern",
|
|
"false",
|
|
"final",
|
|
"fn",
|
|
"for",
|
|
"if",
|
|
"impl",
|
|
"in",
|
|
"let",
|
|
"loop",
|
|
"macro",
|
|
"match",
|
|
"mod",
|
|
"move",
|
|
"mut",
|
|
"override",
|
|
"priv",
|
|
"pub",
|
|
"ref",
|
|
"return",
|
|
"self",
|
|
"Self",
|
|
"static",
|
|
"struct",
|
|
"super",
|
|
"trait",
|
|
"true",
|
|
"try",
|
|
"type",
|
|
"typeof",
|
|
"unsafe",
|
|
"unsized",
|
|
"use",
|
|
"virtual",
|
|
"where",
|
|
"while",
|
|
"yield",
|
|
],
|
|
literal: ["true", "false", "Some", "None", "Ok", "Err"],
|
|
built_in: i,
|
|
},
|
|
illegal: "</",
|
|
contains: [
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.COMMENT("/\\*", "\\*/", { contains: ["self"] }),
|
|
e.inherit(e.QUOTE_STRING_MODE, { begin: /b?"/, illegal: null }),
|
|
{
|
|
className: "string",
|
|
variants: [
|
|
{ begin: /b?r(#*)"(.|\n)*?"\1(?!#)/ },
|
|
{
|
|
begin: /b?'\\?(x\w{2}|u\w{4}|U\w{8}|.)'/,
|
|
},
|
|
],
|
|
},
|
|
{ className: "symbol", begin: /'[a-zA-Z_][a-zA-Z0-9_]*/ },
|
|
{
|
|
className: "number",
|
|
variants: [
|
|
{
|
|
begin: "\\b0b([01_]+)" + a,
|
|
},
|
|
{ begin: "\\b0o([0-7_]+)" + a },
|
|
{
|
|
begin: "\\b0x([A-Fa-f0-9_]+)" + a,
|
|
},
|
|
{
|
|
begin: "\\b(\\d[\\d_]*(\\.[0-9_]+)?([eE][+-]?[0-9_]+)?)" + a,
|
|
},
|
|
],
|
|
relevance: 0,
|
|
},
|
|
{
|
|
begin: [/fn/, /\s+/, e.UNDERSCORE_IDENT_RE],
|
|
className: { 1: "keyword", 3: "title.function" },
|
|
},
|
|
{
|
|
className: "meta",
|
|
begin: "#!?\\[",
|
|
end: "\\]",
|
|
contains: [
|
|
{
|
|
className: "string",
|
|
begin: /"/,
|
|
end: /"/,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
begin: [/let/, /\s+/, /(?:mut\s+)?/, e.UNDERSCORE_IDENT_RE],
|
|
className: { 1: "keyword", 3: "keyword", 4: "variable" },
|
|
},
|
|
{
|
|
begin: [/for/, /\s+/, e.UNDERSCORE_IDENT_RE, /\s+/, /in/],
|
|
className: { 1: "keyword", 3: "variable", 5: "keyword" },
|
|
},
|
|
{
|
|
begin: [/type/, /\s+/, e.UNDERSCORE_IDENT_RE],
|
|
className: { 1: "keyword", 3: "title.class" },
|
|
},
|
|
{
|
|
begin: [
|
|
/(?:trait|enum|struct|union|impl|for)/,
|
|
/\s+/,
|
|
e.UNDERSCORE_IDENT_RE,
|
|
],
|
|
className: { 1: "keyword", 3: "title.class" },
|
|
},
|
|
{
|
|
begin: e.IDENT_RE + "::",
|
|
keywords: {
|
|
keyword: "Self",
|
|
built_in: i,
|
|
type: r,
|
|
},
|
|
},
|
|
{ className: "punctuation", begin: "->" },
|
|
t,
|
|
],
|
|
};
|
|
},
|
|
grmr_scss: (e) => {
|
|
const n = ie(e),
|
|
t = le,
|
|
a = oe,
|
|
i = "@[a-z-]+",
|
|
r = {
|
|
className: "variable",
|
|
begin: "(\\$[a-zA-Z-][a-zA-Z0-9_-]*)\\b",
|
|
relevance: 0,
|
|
};
|
|
return {
|
|
name: "SCSS",
|
|
case_insensitive: !0,
|
|
illegal: "[=/|']",
|
|
contains: [
|
|
e.C_LINE_COMMENT_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
n.CSS_NUMBER_MODE,
|
|
{
|
|
className: "selector-id",
|
|
begin: "#[A-Za-z0-9_-]+",
|
|
relevance: 0,
|
|
},
|
|
{
|
|
className: "selector-class",
|
|
begin: "\\.[A-Za-z0-9_-]+",
|
|
relevance: 0,
|
|
},
|
|
n.ATTRIBUTE_SELECTOR_MODE,
|
|
{
|
|
className: "selector-tag",
|
|
begin: "\\b(" + re.join("|") + ")\\b",
|
|
relevance: 0,
|
|
},
|
|
{ className: "selector-pseudo", begin: ":(" + a.join("|") + ")" },
|
|
{ className: "selector-pseudo", begin: ":(:)?(" + t.join("|") + ")" },
|
|
r,
|
|
{ begin: /\(/, end: /\)/, contains: [n.CSS_NUMBER_MODE] },
|
|
n.CSS_VARIABLE,
|
|
{ className: "attribute", begin: "\\b(" + ce.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: /[;}{]/,
|
|
relevance: 0,
|
|
contains: [
|
|
n.BLOCK_COMMENT,
|
|
r,
|
|
n.HEXCOLOR,
|
|
n.CSS_NUMBER_MODE,
|
|
e.QUOTE_STRING_MODE,
|
|
e.APOS_STRING_MODE,
|
|
n.IMPORTANT,
|
|
n.FUNCTION_DISPATCH,
|
|
],
|
|
},
|
|
{
|
|
begin: "@(page|font-face)",
|
|
keywords: { $pattern: i, keyword: "@page @font-face" },
|
|
},
|
|
{
|
|
begin: "@",
|
|
end: "[{;]",
|
|
returnBegin: !0,
|
|
keywords: {
|
|
$pattern: /[a-z-]+/,
|
|
keyword: "and or not only",
|
|
attribute: se.join(" "),
|
|
},
|
|
contains: [
|
|
{ begin: i, className: "keyword" },
|
|
{ begin: /[a-z-]+(?=:)/, className: "attribute" },
|
|
r,
|
|
e.QUOTE_STRING_MODE,
|
|
e.APOS_STRING_MODE,
|
|
n.HEXCOLOR,
|
|
n.CSS_NUMBER_MODE,
|
|
],
|
|
},
|
|
n.FUNCTION_DISPATCH,
|
|
],
|
|
};
|
|
},
|
|
grmr_shell: (e) => ({
|
|
name: "Shell Session",
|
|
aliases: ["console", "shellsession"],
|
|
contains: [
|
|
{
|
|
className: "meta.prompt",
|
|
begin: /^\s{0,3}[/~\w\d[\]()@-]*[>%$#][ ]?/,
|
|
starts: { end: /[^\\](?=\s*$)/, subLanguage: "bash" },
|
|
},
|
|
],
|
|
}),
|
|
grmr_sql: (e) => {
|
|
const n = e.regex,
|
|
t = e.COMMENT("--", "$"),
|
|
a = ["true", "false", "unknown"],
|
|
i = [
|
|
"bigint",
|
|
"binary",
|
|
"blob",
|
|
"boolean",
|
|
"char",
|
|
"character",
|
|
"clob",
|
|
"date",
|
|
"dec",
|
|
"decfloat",
|
|
"decimal",
|
|
"float",
|
|
"int",
|
|
"integer",
|
|
"interval",
|
|
"nchar",
|
|
"nclob",
|
|
"national",
|
|
"numeric",
|
|
"real",
|
|
"row",
|
|
"smallint",
|
|
"time",
|
|
"timestamp",
|
|
"varchar",
|
|
"varying",
|
|
"varbinary",
|
|
],
|
|
r = [
|
|
"abs",
|
|
"acos",
|
|
"array_agg",
|
|
"asin",
|
|
"atan",
|
|
"avg",
|
|
"cast",
|
|
"ceil",
|
|
"ceiling",
|
|
"coalesce",
|
|
"corr",
|
|
"cos",
|
|
"cosh",
|
|
"count",
|
|
"covar_pop",
|
|
"covar_samp",
|
|
"cume_dist",
|
|
"dense_rank",
|
|
"deref",
|
|
"element",
|
|
"exp",
|
|
"extract",
|
|
"first_value",
|
|
"floor",
|
|
"json_array",
|
|
"json_arrayagg",
|
|
"json_exists",
|
|
"json_object",
|
|
"json_objectagg",
|
|
"json_query",
|
|
"json_table",
|
|
"json_table_primitive",
|
|
"json_value",
|
|
"lag",
|
|
"last_value",
|
|
"lead",
|
|
"listagg",
|
|
"ln",
|
|
"log",
|
|
"log10",
|
|
"lower",
|
|
"max",
|
|
"min",
|
|
"mod",
|
|
"nth_value",
|
|
"ntile",
|
|
"nullif",
|
|
"percent_rank",
|
|
"percentile_cont",
|
|
"percentile_disc",
|
|
"position",
|
|
"position_regex",
|
|
"power",
|
|
"rank",
|
|
"regr_avgx",
|
|
"regr_avgy",
|
|
"regr_count",
|
|
"regr_intercept",
|
|
"regr_r2",
|
|
"regr_slope",
|
|
"regr_sxx",
|
|
"regr_sxy",
|
|
"regr_syy",
|
|
"row_number",
|
|
"sin",
|
|
"sinh",
|
|
"sqrt",
|
|
"stddev_pop",
|
|
"stddev_samp",
|
|
"substring",
|
|
"substring_regex",
|
|
"sum",
|
|
"tan",
|
|
"tanh",
|
|
"translate",
|
|
"translate_regex",
|
|
"treat",
|
|
"trim",
|
|
"trim_array",
|
|
"unnest",
|
|
"upper",
|
|
"value_of",
|
|
"var_pop",
|
|
"var_samp",
|
|
"width_bucket",
|
|
],
|
|
s = [
|
|
"create table",
|
|
"insert into",
|
|
"primary key",
|
|
"foreign key",
|
|
"not null",
|
|
"alter table",
|
|
"add constraint",
|
|
"grouping sets",
|
|
"on overflow",
|
|
"character set",
|
|
"respect nulls",
|
|
"ignore nulls",
|
|
"nulls first",
|
|
"nulls last",
|
|
"depth first",
|
|
"breadth first",
|
|
],
|
|
o = r,
|
|
l = [
|
|
"abs",
|
|
"acos",
|
|
"all",
|
|
"allocate",
|
|
"alter",
|
|
"and",
|
|
"any",
|
|
"are",
|
|
"array",
|
|
"array_agg",
|
|
"array_max_cardinality",
|
|
"as",
|
|
"asensitive",
|
|
"asin",
|
|
"asymmetric",
|
|
"at",
|
|
"atan",
|
|
"atomic",
|
|
"authorization",
|
|
"avg",
|
|
"begin",
|
|
"begin_frame",
|
|
"begin_partition",
|
|
"between",
|
|
"bigint",
|
|
"binary",
|
|
"blob",
|
|
"boolean",
|
|
"both",
|
|
"by",
|
|
"call",
|
|
"called",
|
|
"cardinality",
|
|
"cascaded",
|
|
"case",
|
|
"cast",
|
|
"ceil",
|
|
"ceiling",
|
|
"char",
|
|
"char_length",
|
|
"character",
|
|
"character_length",
|
|
"check",
|
|
"classifier",
|
|
"clob",
|
|
"close",
|
|
"coalesce",
|
|
"collate",
|
|
"collect",
|
|
"column",
|
|
"commit",
|
|
"condition",
|
|
"connect",
|
|
"constraint",
|
|
"contains",
|
|
"convert",
|
|
"copy",
|
|
"corr",
|
|
"corresponding",
|
|
"cos",
|
|
"cosh",
|
|
"count",
|
|
"covar_pop",
|
|
"covar_samp",
|
|
"create",
|
|
"cross",
|
|
"cube",
|
|
"cume_dist",
|
|
"current",
|
|
"current_catalog",
|
|
"current_date",
|
|
"current_default_transform_group",
|
|
"current_path",
|
|
"current_role",
|
|
"current_row",
|
|
"current_schema",
|
|
"current_time",
|
|
"current_timestamp",
|
|
"current_path",
|
|
"current_role",
|
|
"current_transform_group_for_type",
|
|
"current_user",
|
|
"cursor",
|
|
"cycle",
|
|
"date",
|
|
"day",
|
|
"deallocate",
|
|
"dec",
|
|
"decimal",
|
|
"decfloat",
|
|
"declare",
|
|
"default",
|
|
"define",
|
|
"delete",
|
|
"dense_rank",
|
|
"deref",
|
|
"describe",
|
|
"deterministic",
|
|
"disconnect",
|
|
"distinct",
|
|
"double",
|
|
"drop",
|
|
"dynamic",
|
|
"each",
|
|
"element",
|
|
"else",
|
|
"empty",
|
|
"end",
|
|
"end_frame",
|
|
"end_partition",
|
|
"end-exec",
|
|
"equals",
|
|
"escape",
|
|
"every",
|
|
"except",
|
|
"exec",
|
|
"execute",
|
|
"exists",
|
|
"exp",
|
|
"external",
|
|
"extract",
|
|
"false",
|
|
"fetch",
|
|
"filter",
|
|
"first_value",
|
|
"float",
|
|
"floor",
|
|
"for",
|
|
"foreign",
|
|
"frame_row",
|
|
"free",
|
|
"from",
|
|
"full",
|
|
"function",
|
|
"fusion",
|
|
"get",
|
|
"global",
|
|
"grant",
|
|
"group",
|
|
"grouping",
|
|
"groups",
|
|
"having",
|
|
"hold",
|
|
"hour",
|
|
"identity",
|
|
"in",
|
|
"indicator",
|
|
"initial",
|
|
"inner",
|
|
"inout",
|
|
"insensitive",
|
|
"insert",
|
|
"int",
|
|
"integer",
|
|
"intersect",
|
|
"intersection",
|
|
"interval",
|
|
"into",
|
|
"is",
|
|
"join",
|
|
"json_array",
|
|
"json_arrayagg",
|
|
"json_exists",
|
|
"json_object",
|
|
"json_objectagg",
|
|
"json_query",
|
|
"json_table",
|
|
"json_table_primitive",
|
|
"json_value",
|
|
"lag",
|
|
"language",
|
|
"large",
|
|
"last_value",
|
|
"lateral",
|
|
"lead",
|
|
"leading",
|
|
"left",
|
|
"like",
|
|
"like_regex",
|
|
"listagg",
|
|
"ln",
|
|
"local",
|
|
"localtime",
|
|
"localtimestamp",
|
|
"log",
|
|
"log10",
|
|
"lower",
|
|
"match",
|
|
"match_number",
|
|
"match_recognize",
|
|
"matches",
|
|
"max",
|
|
"member",
|
|
"merge",
|
|
"method",
|
|
"min",
|
|
"minute",
|
|
"mod",
|
|
"modifies",
|
|
"module",
|
|
"month",
|
|
"multiset",
|
|
"national",
|
|
"natural",
|
|
"nchar",
|
|
"nclob",
|
|
"new",
|
|
"no",
|
|
"none",
|
|
"normalize",
|
|
"not",
|
|
"nth_value",
|
|
"ntile",
|
|
"null",
|
|
"nullif",
|
|
"numeric",
|
|
"octet_length",
|
|
"occurrences_regex",
|
|
"of",
|
|
"offset",
|
|
"old",
|
|
"omit",
|
|
"on",
|
|
"one",
|
|
"only",
|
|
"open",
|
|
"or",
|
|
"order",
|
|
"out",
|
|
"outer",
|
|
"over",
|
|
"overlaps",
|
|
"overlay",
|
|
"parameter",
|
|
"partition",
|
|
"pattern",
|
|
"per",
|
|
"percent",
|
|
"percent_rank",
|
|
"percentile_cont",
|
|
"percentile_disc",
|
|
"period",
|
|
"portion",
|
|
"position",
|
|
"position_regex",
|
|
"power",
|
|
"precedes",
|
|
"precision",
|
|
"prepare",
|
|
"primary",
|
|
"procedure",
|
|
"ptf",
|
|
"range",
|
|
"rank",
|
|
"reads",
|
|
"real",
|
|
"recursive",
|
|
"ref",
|
|
"references",
|
|
"referencing",
|
|
"regr_avgx",
|
|
"regr_avgy",
|
|
"regr_count",
|
|
"regr_intercept",
|
|
"regr_r2",
|
|
"regr_slope",
|
|
"regr_sxx",
|
|
"regr_sxy",
|
|
"regr_syy",
|
|
"release",
|
|
"result",
|
|
"return",
|
|
"returns",
|
|
"revoke",
|
|
"right",
|
|
"rollback",
|
|
"rollup",
|
|
"row",
|
|
"row_number",
|
|
"rows",
|
|
"running",
|
|
"savepoint",
|
|
"scope",
|
|
"scroll",
|
|
"search",
|
|
"second",
|
|
"seek",
|
|
"select",
|
|
"sensitive",
|
|
"session_user",
|
|
"set",
|
|
"show",
|
|
"similar",
|
|
"sin",
|
|
"sinh",
|
|
"skip",
|
|
"smallint",
|
|
"some",
|
|
"specific",
|
|
"specifictype",
|
|
"sql",
|
|
"sqlexception",
|
|
"sqlstate",
|
|
"sqlwarning",
|
|
"sqrt",
|
|
"start",
|
|
"static",
|
|
"stddev_pop",
|
|
"stddev_samp",
|
|
"submultiset",
|
|
"subset",
|
|
"substring",
|
|
"substring_regex",
|
|
"succeeds",
|
|
"sum",
|
|
"symmetric",
|
|
"system",
|
|
"system_time",
|
|
"system_user",
|
|
"table",
|
|
"tablesample",
|
|
"tan",
|
|
"tanh",
|
|
"then",
|
|
"time",
|
|
"timestamp",
|
|
"timezone_hour",
|
|
"timezone_minute",
|
|
"to",
|
|
"trailing",
|
|
"translate",
|
|
"translate_regex",
|
|
"translation",
|
|
"treat",
|
|
"trigger",
|
|
"trim",
|
|
"trim_array",
|
|
"true",
|
|
"truncate",
|
|
"uescape",
|
|
"union",
|
|
"unique",
|
|
"unknown",
|
|
"unnest",
|
|
"update",
|
|
"upper",
|
|
"user",
|
|
"using",
|
|
"value",
|
|
"values",
|
|
"value_of",
|
|
"var_pop",
|
|
"var_samp",
|
|
"varbinary",
|
|
"varchar",
|
|
"varying",
|
|
"versioning",
|
|
"when",
|
|
"whenever",
|
|
"where",
|
|
"width_bucket",
|
|
"window",
|
|
"with",
|
|
"within",
|
|
"without",
|
|
"year",
|
|
"add",
|
|
"asc",
|
|
"collation",
|
|
"desc",
|
|
"final",
|
|
"first",
|
|
"last",
|
|
"view",
|
|
].filter((e) => !r.includes(e)),
|
|
c = {
|
|
begin: n.concat(/\b/, n.either(...o), /\s*\(/),
|
|
relevance: 0,
|
|
keywords: { built_in: o },
|
|
};
|
|
return {
|
|
name: "SQL",
|
|
case_insensitive: !0,
|
|
illegal: /[{}]|<\//,
|
|
keywords: {
|
|
$pattern: /\b[\w.]+/,
|
|
keyword: ((e, { exceptions: n, when: t } = {}) => {
|
|
const a = t;
|
|
return (
|
|
(n = n || []),
|
|
e.map((e) =>
|
|
e.match(/\|\d+$/) || n.includes(e) ? e : a(e) ? e + "|0" : e,
|
|
)
|
|
);
|
|
})(l, { when: (e) => e.length < 3 }),
|
|
literal: a,
|
|
type: i,
|
|
built_in: [
|
|
"current_catalog",
|
|
"current_date",
|
|
"current_default_transform_group",
|
|
"current_path",
|
|
"current_role",
|
|
"current_schema",
|
|
"current_transform_group_for_type",
|
|
"current_user",
|
|
"session_user",
|
|
"system_time",
|
|
"system_user",
|
|
"current_time",
|
|
"localtime",
|
|
"current_timestamp",
|
|
"localtimestamp",
|
|
],
|
|
},
|
|
contains: [
|
|
{
|
|
begin: n.either(...s),
|
|
relevance: 0,
|
|
keywords: {
|
|
$pattern: /[\w.]+/,
|
|
keyword: l.concat(s),
|
|
literal: a,
|
|
type: i,
|
|
},
|
|
},
|
|
{
|
|
className: "type",
|
|
begin: n.either(
|
|
"double precision",
|
|
"large object",
|
|
"with timezone",
|
|
"without timezone",
|
|
),
|
|
},
|
|
c,
|
|
{ className: "variable", begin: /@[a-z0-9][a-z0-9_]*/ },
|
|
{
|
|
className: "string",
|
|
variants: [{ begin: /'/, end: /'/, contains: [{ begin: /''/ }] }],
|
|
},
|
|
{ begin: /"/, end: /"/, contains: [{ begin: /""/ }] },
|
|
e.C_NUMBER_MODE,
|
|
e.C_BLOCK_COMMENT_MODE,
|
|
t,
|
|
{
|
|
className: "operator",
|
|
begin: /[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/,
|
|
relevance: 0,
|
|
},
|
|
],
|
|
};
|
|
},
|
|
grmr_swift: (e) => {
|
|
const n = { match: /\s+/, relevance: 0 },
|
|
t = e.COMMENT("/\\*", "\\*/", { contains: ["self"] }),
|
|
a = [e.C_LINE_COMMENT_MODE, t],
|
|
i = {
|
|
match: [/\./, m(...xe, ...Me)],
|
|
className: { 2: "keyword" },
|
|
},
|
|
r = { match: b(/\./, m(...Ae)), relevance: 0 },
|
|
s = Ae.filter((e) => "string" == typeof e).concat(["_|0"]),
|
|
o = {
|
|
variants: [
|
|
{
|
|
className: "keyword",
|
|
match: m(
|
|
...Ae.filter((e) => "string" != typeof e)
|
|
.concat(Se)
|
|
.map(ke),
|
|
...Me,
|
|
),
|
|
},
|
|
],
|
|
},
|
|
l = {
|
|
$pattern: m(/\b\w+/, /#\w+/),
|
|
keyword: s.concat(Re),
|
|
literal: Ce,
|
|
},
|
|
c = [i, r, o],
|
|
g = [
|
|
{
|
|
match: b(/\./, m(...De)),
|
|
relevance: 0,
|
|
},
|
|
{ className: "built_in", match: b(/\b/, m(...De), /(?=\()/) },
|
|
],
|
|
u = { match: /->/, relevance: 0 },
|
|
p = [
|
|
u,
|
|
{
|
|
className: "operator",
|
|
relevance: 0,
|
|
variants: [{ match: Be }, { match: `\\.(\\.|${Le})+` }],
|
|
},
|
|
],
|
|
_ = "([0-9]_*)+",
|
|
h = "([0-9a-fA-F]_*)+",
|
|
f = {
|
|
className: "number",
|
|
relevance: 0,
|
|
variants: [
|
|
{ match: `\\b(${_})(\\.(${_}))?([eE][+-]?(${_}))?\\b` },
|
|
{
|
|
match: `\\b0x(${h})(\\.(${h}))?([pP][+-]?(${_}))?\\b`,
|
|
},
|
|
{ match: /\b0o([0-7]_*)+\b/ },
|
|
{ match: /\b0b([01]_*)+\b/ },
|
|
],
|
|
},
|
|
E = (e = "") => ({
|
|
className: "subst",
|
|
variants: [
|
|
{
|
|
match: b(/\\/, e, /[0\\tnr"']/),
|
|
},
|
|
{ match: b(/\\/, e, /u\{[0-9a-fA-F]{1,8}\}/) },
|
|
],
|
|
}),
|
|
y = (e = "") => ({
|
|
className: "subst",
|
|
match: b(/\\/, e, /[\t ]*(?:[\r\n]|\r\n)/),
|
|
}),
|
|
N = (e = "") => ({
|
|
className: "subst",
|
|
label: "interpol",
|
|
begin: b(/\\/, e, /\(/),
|
|
end: /\)/,
|
|
}),
|
|
w = (e = "") => ({
|
|
begin: b(e, /"""/),
|
|
end: b(/"""/, e),
|
|
contains: [E(e), y(e), N(e)],
|
|
}),
|
|
v = (e = "") => ({
|
|
begin: b(e, /"/),
|
|
end: b(/"/, e),
|
|
contains: [E(e), N(e)],
|
|
}),
|
|
O = {
|
|
className: "string",
|
|
variants: [
|
|
w(),
|
|
w("#"),
|
|
w("##"),
|
|
w("###"),
|
|
v(),
|
|
v("#"),
|
|
v("##"),
|
|
v("###"),
|
|
],
|
|
},
|
|
k = [
|
|
e.BACKSLASH_ESCAPE,
|
|
{
|
|
begin: /\[/,
|
|
end: /\]/,
|
|
relevance: 0,
|
|
contains: [e.BACKSLASH_ESCAPE],
|
|
},
|
|
],
|
|
x = { begin: /\/[^\s](?=[^/\n]*\/)/, end: /\//, contains: k },
|
|
M = (e) => {
|
|
const n = b(e, /\//),
|
|
t = b(/\//, e);
|
|
return {
|
|
begin: n,
|
|
end: t,
|
|
contains: [
|
|
...k,
|
|
{ scope: "comment", begin: `#(?!.*${t})`, end: /$/ },
|
|
],
|
|
};
|
|
},
|
|
S = {
|
|
scope: "regexp",
|
|
variants: [M("###"), M("##"), M("#"), x],
|
|
},
|
|
A = { match: b(/`/, Fe, /`/) },
|
|
C = [
|
|
A,
|
|
{ className: "variable", match: /\$\d+/ },
|
|
{ className: "variable", match: `\\$${ze}+` },
|
|
],
|
|
T = [
|
|
{
|
|
match: /(@|#(un)?)available/,
|
|
scope: "keyword",
|
|
starts: {
|
|
contains: [
|
|
{
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
keywords: Pe,
|
|
contains: [...p, f, O],
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{
|
|
scope: "keyword",
|
|
match: b(/@/, m(...je)),
|
|
},
|
|
{ scope: "meta", match: b(/@/, Fe) },
|
|
],
|
|
R = {
|
|
match: d(/\b[A-Z]/),
|
|
relevance: 0,
|
|
contains: [
|
|
{
|
|
className: "type",
|
|
match: b(
|
|
/(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)/,
|
|
ze,
|
|
"+",
|
|
),
|
|
},
|
|
{ className: "type", match: Ue, relevance: 0 },
|
|
{ match: /[?!]+/, relevance: 0 },
|
|
{
|
|
match: /\.\.\./,
|
|
relevance: 0,
|
|
},
|
|
{ match: b(/\s+&\s+/, d(Ue)), relevance: 0 },
|
|
],
|
|
},
|
|
D = {
|
|
begin: /</,
|
|
end: />/,
|
|
keywords: l,
|
|
contains: [...a, ...c, ...T, u, R],
|
|
};
|
|
R.contains.push(D);
|
|
const I = {
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
relevance: 0,
|
|
keywords: l,
|
|
contains: [
|
|
"self",
|
|
{
|
|
match: b(Fe, /\s*:/),
|
|
keywords: "_|0",
|
|
relevance: 0,
|
|
},
|
|
...a,
|
|
S,
|
|
...c,
|
|
...g,
|
|
...p,
|
|
f,
|
|
O,
|
|
...C,
|
|
...T,
|
|
R,
|
|
],
|
|
},
|
|
L = {
|
|
begin: /</,
|
|
end: />/,
|
|
keywords: "repeat each",
|
|
contains: [...a, R],
|
|
},
|
|
B = {
|
|
begin: /\(/,
|
|
end: /\)/,
|
|
keywords: l,
|
|
contains: [
|
|
{
|
|
begin: m(d(b(Fe, /\s*:/)), d(b(Fe, /\s+/, Fe, /\s*:/))),
|
|
end: /:/,
|
|
relevance: 0,
|
|
contains: [
|
|
{ className: "keyword", match: /\b_\b/ },
|
|
{ className: "params", match: Fe },
|
|
],
|
|
},
|
|
...a,
|
|
...c,
|
|
...p,
|
|
f,
|
|
O,
|
|
...T,
|
|
R,
|
|
I,
|
|
],
|
|
endsParent: !0,
|
|
illegal: /["']/,
|
|
},
|
|
$ = {
|
|
match: [/(func|macro)/, /\s+/, m(A.match, Fe, Be)],
|
|
className: { 1: "keyword", 3: "title.function" },
|
|
contains: [L, B, n],
|
|
illegal: [/\[/, /%/],
|
|
},
|
|
z = {
|
|
match: [/\b(?:subscript|init[?!]?)/, /\s*(?=[<(])/],
|
|
className: { 1: "keyword" },
|
|
contains: [L, B, n],
|
|
illegal: /\[|%/,
|
|
},
|
|
F = {
|
|
match: [/operator/, /\s+/, Be],
|
|
className: {
|
|
1: "keyword",
|
|
3: "title",
|
|
},
|
|
},
|
|
U = {
|
|
begin: [/precedencegroup/, /\s+/, Ue],
|
|
className: {
|
|
1: "keyword",
|
|
3: "title",
|
|
},
|
|
contains: [R],
|
|
keywords: [...Te, ...Ce],
|
|
end: /}/,
|
|
};
|
|
for (const e of O.variants) {
|
|
const n = e.contains.find((e) => "interpol" === e.label);
|
|
n.keywords = l;
|
|
const t = [...c, ...g, ...p, f, O, ...C];
|
|
n.contains = [
|
|
...t,
|
|
{ begin: /\(/, end: /\)/, contains: ["self", ...t] },
|
|
];
|
|
}
|
|
return {
|
|
name: "Swift",
|
|
keywords: l,
|
|
contains: [
|
|
...a,
|
|
$,
|
|
z,
|
|
{
|
|
beginKeywords: "struct protocol class extension enum actor",
|
|
end: "\\{",
|
|
excludeEnd: !0,
|
|
keywords: l,
|
|
contains: [
|
|
e.inherit(e.TITLE_MODE, {
|
|
className: "title.class",
|
|
begin: /[A-Za-z$_][\u00C0-\u02B80-9A-Za-z$_]*/,
|
|
}),
|
|
...c,
|
|
],
|
|
},
|
|
F,
|
|
U,
|
|
{ beginKeywords: "import", end: /$/, contains: [...a], relevance: 0 },
|
|
S,
|
|
...c,
|
|
...g,
|
|
...p,
|
|
f,
|
|
O,
|
|
...C,
|
|
...T,
|
|
R,
|
|
I,
|
|
],
|
|
};
|
|
},
|
|
grmr_typescript: (e) => {
|
|
const n = Oe(e),
|
|
t = _e,
|
|
a = [
|
|
"any",
|
|
"void",
|
|
"number",
|
|
"boolean",
|
|
"string",
|
|
"object",
|
|
"never",
|
|
"symbol",
|
|
"bigint",
|
|
"unknown",
|
|
],
|
|
i = {
|
|
beginKeywords: "namespace",
|
|
end: /\{/,
|
|
excludeEnd: !0,
|
|
contains: [n.exports.CLASS_REFERENCE],
|
|
},
|
|
r = {
|
|
beginKeywords: "interface",
|
|
end: /\{/,
|
|
excludeEnd: !0,
|
|
keywords: { keyword: "interface extends", built_in: a },
|
|
contains: [n.exports.CLASS_REFERENCE],
|
|
},
|
|
s = {
|
|
$pattern: _e,
|
|
keyword: he.concat([
|
|
"type",
|
|
"namespace",
|
|
"interface",
|
|
"public",
|
|
"private",
|
|
"protected",
|
|
"implements",
|
|
"declare",
|
|
"abstract",
|
|
"readonly",
|
|
"enum",
|
|
"override",
|
|
]),
|
|
literal: fe,
|
|
built_in: ve.concat(a),
|
|
"variable.language": we,
|
|
},
|
|
o = { className: "meta", begin: "@" + t },
|
|
l = (e, n, t) => {
|
|
const a = e.contains.findIndex((e) => e.label === n);
|
|
if (-1 === a) throw Error("can not find mode to replace");
|
|
e.contains.splice(a, 1, t);
|
|
};
|
|
return (
|
|
Object.assign(n.keywords, s),
|
|
n.exports.PARAMS_CONTAINS.push(o),
|
|
(n.contains = n.contains.concat([o, i, r])),
|
|
l(n, "shebang", e.SHEBANG()),
|
|
l(n, "use_strict", {
|
|
className: "meta",
|
|
relevance: 10,
|
|
begin: /^\s*['"]use strict['"]/,
|
|
}),
|
|
(n.contains.find((e) => "func.def" === e.label).relevance = 0),
|
|
Object.assign(n, {
|
|
name: "TypeScript",
|
|
aliases: ["ts", "tsx", "mts", "cts"],
|
|
}),
|
|
n
|
|
);
|
|
},
|
|
grmr_vbnet: (e) => {
|
|
const n = e.regex,
|
|
t = /\d{1,2}\/\d{1,2}\/\d{4}/,
|
|
a = /\d{4}-\d{1,2}-\d{1,2}/,
|
|
i = /(\d|1[012])(:\d+){0,2} *(AM|PM)/,
|
|
r = /\d{1,2}(:\d{1,2}){1,2}/,
|
|
s = {
|
|
className: "literal",
|
|
variants: [
|
|
{ begin: n.concat(/# */, n.either(a, t), / *#/) },
|
|
{
|
|
begin: n.concat(/# */, r, / *#/),
|
|
},
|
|
{ begin: n.concat(/# */, i, / *#/) },
|
|
{
|
|
begin: n.concat(
|
|
/# */,
|
|
n.either(a, t),
|
|
/ +/,
|
|
n.either(i, r),
|
|
/ *#/,
|
|
),
|
|
},
|
|
],
|
|
},
|
|
o = e.COMMENT(/'''/, /$/, {
|
|
contains: [{ className: "doctag", begin: /<\/?/, end: />/ }],
|
|
}),
|
|
l = e.COMMENT(null, /$/, {
|
|
variants: [{ begin: /'/ }, { begin: /([\t ]|^)REM(?=\s)/ }],
|
|
});
|
|
return {
|
|
name: "Visual Basic .NET",
|
|
aliases: ["vb"],
|
|
case_insensitive: !0,
|
|
classNameAliases: { label: "symbol" },
|
|
keywords: {
|
|
keyword:
|
|
"addhandler alias aggregate ansi as async assembly auto binary by byref byval call case catch class compare const continue custom declare default delegate dim distinct do each equals else elseif end enum erase error event exit explicit finally for friend from function get global goto group handles if implements imports in inherits interface into iterator join key let lib loop me mid module mustinherit mustoverride mybase myclass namespace narrowing new next notinheritable notoverridable of off on operator option optional order overloads overridable overrides paramarray partial preserve private property protected public raiseevent readonly redim removehandler resume return select set shadows shared skip static step stop structure strict sub synclock take text then throw to try unicode until using when where while widening with withevents writeonly yield",
|
|
built_in:
|
|
"addressof and andalso await directcast gettype getxmlnamespace is isfalse isnot istrue like mod nameof new not or orelse trycast typeof xor cbool cbyte cchar cdate cdbl cdec cint clng cobj csbyte cshort csng cstr cuint culng cushort",
|
|
type: "boolean byte char date decimal double integer long object sbyte short single string uinteger ulong ushort",
|
|
literal: "true false nothing",
|
|
},
|
|
illegal: "//|\\{|\\}|endif|gosub|variant|wend|^\\$ ",
|
|
contains: [
|
|
{
|
|
className: "string",
|
|
begin: /"(""|[^/n])"C\b/,
|
|
},
|
|
{
|
|
className: "string",
|
|
begin: /"/,
|
|
end: /"/,
|
|
illegal: /\n/,
|
|
contains: [{ begin: /""/ }],
|
|
},
|
|
s,
|
|
{
|
|
className: "number",
|
|
relevance: 0,
|
|
variants: [
|
|
{
|
|
begin:
|
|
/\b\d[\d_]*((\.[\d_]+(E[+-]?[\d_]+)?)|(E[+-]?[\d_]+))[RFD@!#]?/,
|
|
},
|
|
{ begin: /\b\d[\d_]*((U?[SIL])|[%&])?/ },
|
|
{ begin: /&H[\dA-F_]+((U?[SIL])|[%&])?/ },
|
|
{
|
|
begin: /&O[0-7_]+((U?[SIL])|[%&])?/,
|
|
},
|
|
{ begin: /&B[01_]+((U?[SIL])|[%&])?/ },
|
|
],
|
|
},
|
|
{
|
|
className: "label",
|
|
begin: /^\w+:/,
|
|
},
|
|
o,
|
|
l,
|
|
{
|
|
className: "meta",
|
|
begin:
|
|
/[\t ]*#(const|disable|else|elseif|enable|end|externalsource|if|region)\b/,
|
|
end: /$/,
|
|
keywords: {
|
|
keyword:
|
|
"const disable else elseif enable end externalsource if region then",
|
|
},
|
|
contains: [l],
|
|
},
|
|
],
|
|
};
|
|
},
|
|
grmr_wasm: (e) => {
|
|
e.regex;
|
|
const n = e.COMMENT(/\(;/, /;\)/);
|
|
return (
|
|
n.contains.push("self"),
|
|
{
|
|
name: "WebAssembly",
|
|
keywords: {
|
|
$pattern: /[\w.]+/,
|
|
keyword: [
|
|
"anyfunc",
|
|
"block",
|
|
"br",
|
|
"br_if",
|
|
"br_table",
|
|
"call",
|
|
"call_indirect",
|
|
"data",
|
|
"drop",
|
|
"elem",
|
|
"else",
|
|
"end",
|
|
"export",
|
|
"func",
|
|
"global.get",
|
|
"global.set",
|
|
"local.get",
|
|
"local.set",
|
|
"local.tee",
|
|
"get_global",
|
|
"get_local",
|
|
"global",
|
|
"if",
|
|
"import",
|
|
"local",
|
|
"loop",
|
|
"memory",
|
|
"memory.grow",
|
|
"memory.size",
|
|
"module",
|
|
"mut",
|
|
"nop",
|
|
"offset",
|
|
"param",
|
|
"result",
|
|
"return",
|
|
"select",
|
|
"set_global",
|
|
"set_local",
|
|
"start",
|
|
"table",
|
|
"tee_local",
|
|
"then",
|
|
"type",
|
|
"unreachable",
|
|
],
|
|
},
|
|
contains: [
|
|
e.COMMENT(/;;/, /$/),
|
|
n,
|
|
{
|
|
match: [/(?:offset|align)/, /\s*/, /=/],
|
|
className: { 1: "keyword", 3: "operator" },
|
|
},
|
|
{ className: "variable", begin: /\$[\w_]+/ },
|
|
{
|
|
match: /(\((?!;)|\))+/,
|
|
className: "punctuation",
|
|
relevance: 0,
|
|
},
|
|
{
|
|
begin: [/(?:func|call|call_indirect)/, /\s+/, /\$[^\s)]+/],
|
|
className: { 1: "keyword", 3: "title.function" },
|
|
},
|
|
e.QUOTE_STRING_MODE,
|
|
{ match: /(i32|i64|f32|f64)(?!\.)/, className: "type" },
|
|
{
|
|
className: "keyword",
|
|
match:
|
|
/\b(f32|f64|i32|i64)(?:\.(?:abs|add|and|ceil|clz|const|convert_[su]\/i(?:32|64)|copysign|ctz|demote\/f64|div(?:_[su])?|eqz?|extend_[su]\/i32|floor|ge(?:_[su])?|gt(?:_[su])?|le(?:_[su])?|load(?:(?:8|16|32)_[su])?|lt(?:_[su])?|max|min|mul|nearest|neg?|or|popcnt|promote\/f32|reinterpret\/[fi](?:32|64)|rem_[su]|rot[lr]|shl|shr_[su]|store(?:8|16|32)?|sqrt|sub|trunc(?:_[su]\/f(?:32|64))?|wrap\/i64|xor))\b/,
|
|
},
|
|
{
|
|
className: "number",
|
|
relevance: 0,
|
|
match:
|
|
/[+-]?\b(?:\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?|0x[\da-fA-F](?:_?[\da-fA-F])*(?:\.[\da-fA-F](?:_?[\da-fA-D])*)?(?:[pP][+-]?\d(?:_?\d)*)?)\b|\binf\b|\bnan(?::0x[\da-fA-F](?:_?[\da-fA-D])*)?\b/,
|
|
},
|
|
],
|
|
}
|
|
);
|
|
},
|
|
grmr_xml: (e) => {
|
|
const n = e.regex,
|
|
t = n.concat(
|
|
/[\p{L}_]/u,
|
|
n.optional(/[\p{L}0-9_.-]*:/u),
|
|
/[\p{L}0-9_.-]*/u,
|
|
),
|
|
a = {
|
|
className: "symbol",
|
|
begin: /&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/,
|
|
},
|
|
i = {
|
|
begin: /\s/,
|
|
contains: [
|
|
{
|
|
className: "keyword",
|
|
begin: /#?[a-z_][a-z1-9_-]+/,
|
|
illegal: /\n/,
|
|
},
|
|
],
|
|
},
|
|
r = e.inherit(i, { begin: /\(/, end: /\)/ }),
|
|
s = e.inherit(e.APOS_STRING_MODE, {
|
|
className: "string",
|
|
}),
|
|
o = e.inherit(e.QUOTE_STRING_MODE, { className: "string" }),
|
|
l = {
|
|
endsWithParent: !0,
|
|
illegal: /</,
|
|
relevance: 0,
|
|
contains: [
|
|
{ className: "attr", begin: /[\p{L}0-9._:-]+/u, relevance: 0 },
|
|
{
|
|
begin: /=\s*/,
|
|
relevance: 0,
|
|
contains: [
|
|
{
|
|
className: "string",
|
|
endsParent: !0,
|
|
variants: [
|
|
{ begin: /"/, end: /"/, contains: [a] },
|
|
{
|
|
begin: /'/,
|
|
end: /'/,
|
|
contains: [a],
|
|
},
|
|
{ begin: /[^\s"'=<>`]+/ },
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
return {
|
|
name: "HTML, XML",
|
|
aliases: [
|
|
"html",
|
|
"xhtml",
|
|
"rss",
|
|
"atom",
|
|
"xjb",
|
|
"xsd",
|
|
"xsl",
|
|
"plist",
|
|
"wsf",
|
|
"svg",
|
|
],
|
|
case_insensitive: !0,
|
|
unicodeRegex: !0,
|
|
contains: [
|
|
{
|
|
className: "meta",
|
|
begin: /<![a-z]/,
|
|
end: />/,
|
|
relevance: 10,
|
|
contains: [
|
|
i,
|
|
o,
|
|
s,
|
|
r,
|
|
{
|
|
begin: /\[/,
|
|
end: /\]/,
|
|
contains: [
|
|
{
|
|
className: "meta",
|
|
begin: /<![a-z]/,
|
|
end: />/,
|
|
contains: [i, r, o, s],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
e.COMMENT(/<!--/, /-->/, { relevance: 10 }),
|
|
{ begin: /<!\[CDATA\[/, end: /\]\]>/, relevance: 10 },
|
|
a,
|
|
{
|
|
className: "meta",
|
|
end: /\?>/,
|
|
variants: [
|
|
{ begin: /<\?xml/, relevance: 10, contains: [o] },
|
|
{ begin: /<\?[a-z][a-z0-9]+/ },
|
|
],
|
|
},
|
|
{
|
|
className: "tag",
|
|
begin: /<style(?=\s|>)/,
|
|
end: />/,
|
|
keywords: { name: "style" },
|
|
contains: [l],
|
|
starts: {
|
|
end: /<\/style>/,
|
|
returnEnd: !0,
|
|
subLanguage: ["css", "xml"],
|
|
},
|
|
},
|
|
{
|
|
className: "tag",
|
|
begin: /<script(?=\s|>)/,
|
|
end: />/,
|
|
keywords: { name: "script" },
|
|
contains: [l],
|
|
starts: {
|
|
end: /<\/script>/,
|
|
returnEnd: !0,
|
|
subLanguage: ["javascript", "handlebars", "xml"],
|
|
},
|
|
},
|
|
{
|
|
className: "tag",
|
|
begin: /<>|<\/>/,
|
|
},
|
|
{
|
|
className: "tag",
|
|
begin: n.concat(
|
|
/</,
|
|
n.lookahead(n.concat(t, n.either(/\/>/, />/, /\s/))),
|
|
),
|
|
end: /\/?>/,
|
|
contains: [
|
|
{ className: "name", begin: t, relevance: 0, starts: l },
|
|
],
|
|
},
|
|
{
|
|
className: "tag",
|
|
begin: n.concat(/<\//, n.lookahead(n.concat(t, />/))),
|
|
contains: [
|
|
{
|
|
className: "name",
|
|
begin: t,
|
|
relevance: 0,
|
|
},
|
|
{ begin: />/, relevance: 0, endsParent: !0 },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
},
|
|
grmr_yaml: (e) => {
|
|
const n = "true false yes no null",
|
|
t = "[\\w#;/?:@&=+$,.~*'()[\\]]+",
|
|
a = {
|
|
className: "string",
|
|
relevance: 0,
|
|
variants: [
|
|
{ begin: /'/, end: /'/ },
|
|
{ begin: /"/, end: /"/ },
|
|
{ begin: /\S+/ },
|
|
],
|
|
contains: [
|
|
e.BACKSLASH_ESCAPE,
|
|
{
|
|
className: "template-variable",
|
|
variants: [
|
|
{ begin: /\{\{/, end: /\}\}/ },
|
|
{ begin: /%\{/, end: /\}/ },
|
|
],
|
|
},
|
|
],
|
|
},
|
|
i = e.inherit(a, {
|
|
variants: [
|
|
{ begin: /'/, end: /'/ },
|
|
{ begin: /"/, end: /"/ },
|
|
{ begin: /[^\s,{}[\]]+/ },
|
|
],
|
|
}),
|
|
r = {
|
|
end: ",",
|
|
endsWithParent: !0,
|
|
excludeEnd: !0,
|
|
keywords: n,
|
|
relevance: 0,
|
|
},
|
|
s = {
|
|
begin: /\{/,
|
|
end: /\}/,
|
|
contains: [r],
|
|
illegal: "\\n",
|
|
relevance: 0,
|
|
},
|
|
o = {
|
|
begin: "\\[",
|
|
end: "\\]",
|
|
contains: [r],
|
|
illegal: "\\n",
|
|
relevance: 0,
|
|
},
|
|
l = [
|
|
{
|
|
className: "attr",
|
|
variants: [
|
|
{
|
|
begin: "\\w[\\w :\\/.-]*:(?=[ \t]|$)",
|
|
},
|
|
{ begin: '"\\w[\\w :\\/.-]*":(?=[ \t]|$)' },
|
|
{
|
|
begin: "'\\w[\\w :\\/.-]*':(?=[ \t]|$)",
|
|
},
|
|
],
|
|
},
|
|
{ className: "meta", begin: "^---\\s*$", relevance: 10 },
|
|
{
|
|
className: "string",
|
|
begin:
|
|
"[\\|>]([1-9]?[+-])?[ ]*\\n( +)[^ ][^\\n]*\\n(\\2[^\\n]+\\n?)*",
|
|
},
|
|
{
|
|
begin: "<%[%=-]?",
|
|
end: "[%-]?%>",
|
|
subLanguage: "ruby",
|
|
excludeBegin: !0,
|
|
excludeEnd: !0,
|
|
relevance: 0,
|
|
},
|
|
{ className: "type", begin: "!\\w+!" + t },
|
|
{ className: "type", begin: "!<" + t + ">" },
|
|
{ className: "type", begin: "!" + t },
|
|
{ className: "type", begin: "!!" + t },
|
|
{ className: "meta", begin: "&" + e.UNDERSCORE_IDENT_RE + "$" },
|
|
{ className: "meta", begin: "\\*" + e.UNDERSCORE_IDENT_RE + "$" },
|
|
{ className: "bullet", begin: "-(?=[ ]|$)", relevance: 0 },
|
|
e.HASH_COMMENT_MODE,
|
|
{ beginKeywords: n, keywords: { literal: n } },
|
|
{
|
|
className: "number",
|
|
begin:
|
|
"\\b[0-9]{4}(-[0-9][0-9]){0,2}([Tt \\t][0-9][0-9]?(:[0-9][0-9]){2})?(\\.[0-9]*)?([ \\t])*(Z|[-+][0-9][0-9]?(:[0-9][0-9])?)?\\b",
|
|
},
|
|
{ className: "number", begin: e.C_NUMBER_RE + "\\b", relevance: 0 },
|
|
s,
|
|
o,
|
|
a,
|
|
],
|
|
c = [...l];
|
|
return (
|
|
c.pop(),
|
|
c.push(i),
|
|
(r.contains = c),
|
|
{ name: "YAML", case_insensitive: !0, aliases: ["yml"], contains: l }
|
|
);
|
|
},
|
|
});
|
|
const He = ae;
|
|
for (const e of Object.keys(Ke)) {
|
|
const n = e.replace("grmr_", "").replace("_", "-");
|
|
He.registerLanguage(n, Ke[e]);
|
|
}
|
|
return He;
|
|
})();
|
|
"object" == typeof exports &&
|
|
"undefined" != typeof module &&
|
|
(module.exports = hljs);
|