diff --git a/transcripts/break-down-the-refactoring-yaks.html b/transcripts/break-down-the-refactoring-yaks.html new file mode 100644 index 0000000..6d4b8d6 --- /dev/null +++ b/transcripts/break-down-the-refactoring-yaks.html @@ -0,0 +1,4256 @@ + + + + + + Session Export + + + + + +
+ + +
+
+
+
+
+ +
+
+ + + + + + + + + + + + + diff --git a/transcripts/break-yaks-down-into-phases.html b/transcripts/break-yaks-down-into-phases.html new file mode 100644 index 0000000..e801e91 --- /dev/null +++ b/transcripts/break-yaks-down-into-phases.html @@ -0,0 +1,4256 @@ + + + + + + Session Export + + + + + +
+ + +
+
+
+
+
+ +
+
+ + + + + + + + + + + + + diff --git a/transcripts/fixed-character-implementation-maybe.html b/transcripts/fixed-character-implementation-maybe.html index 32e32e1..78c11c2 100644 --- a/transcripts/fixed-character-implementation-maybe.html +++ b/transcripts/fixed-character-implementation-maybe.html @@ -1,3595 +1,12415 @@ - + - - - - Session Export - - - - - -
- - -
-
-
-
-
-
-
- + - - + + - - + var hljs = (function () { + 'use strict'; + 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, '''); + } + 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 += ''); + } + value() { + return this.buffer; + } + span(e) { + this.buffer += ``; + } + } + 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) => this._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 || '') + '"', + ); + 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 = '', + 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: [ + { + 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: '', + 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: '' }, + ], + }, + ], + }), + 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: ' { + 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: //, + 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: //, + 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: /\$[@% { + 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: '/, 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 = /[=!<>:]=|\|\||&&|:::?|<-|<<-|->>|->|\|>|[-+*\/?!{{HIGHLIGHT_JS}}|:<=>@^~]|\*\*/, + 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]?/ }, + { 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: '' }, + 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: //, + 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: //, 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: /`]+/ }, + ], + }, + ], + }, + ], + }; + return { + name: 'HTML, XML', + aliases: ['html', 'xhtml', 'rss', 'atom', 'xjb', 'xsd', 'xsl', 'plist', 'wsf', 'svg'], + case_insensitive: !0, + unicodeRegex: !0, + contains: [ + { + className: 'meta', + begin: //, + relevance: 10, + contains: [ + i, + o, + s, + r, + { + begin: /\[/, + end: /\]/, + contains: [ + { + className: 'meta', + begin: //, + contains: [i, r, o, s], + }, + ], + }, + ], + }, + e.COMMENT(//, { relevance: 10 }), + { begin: //, relevance: 10 }, + a, + { + className: 'meta', + end: /\?>/, + variants: [ + { begin: /<\?xml/, relevance: 10, contains: [o] }, + { begin: /<\?[a-z][a-z0-9]+/ }, + ], + }, + { + className: 'tag', + begin: /)/, + end: />/, + keywords: { name: 'style' }, + contains: [l], + starts: { + end: /<\/style>/, + returnEnd: !0, + subLanguage: ['css', 'xml'], + }, + }, + { + className: 'tag', + begin: /)/, + end: />/, + keywords: { name: 'script' }, + contains: [l], + starts: { + end: /<\/script>/, + returnEnd: !0, + subLanguage: ['javascript', 'handlebars', 'xml'], + }, + }, + { + className: 'tag', + begin: /<>|<\/>/, + }, + { + className: 'tag', + begin: n.concat(//, />/, /\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); + - - - + })(); + + diff --git a/transcripts/resolved-circular-dependency.html b/transcripts/resolved-circular-dependency.html new file mode 100644 index 0000000..2cc159a --- /dev/null +++ b/transcripts/resolved-circular-dependency.html @@ -0,0 +1,13112 @@ + + + + + + Session Export + + + + + +
+ + +
+
+
+
+
+ +
+
+ + + + + + + + + + + + + diff --git a/transcripts/yaks-were-not-marked-s-done.html b/transcripts/yaks-were-not-marked-s-done.html new file mode 100644 index 0000000..fa7b163 --- /dev/null +++ b/transcripts/yaks-were-not-marked-s-done.html @@ -0,0 +1,4256 @@ + + + + + + Session Export + + + + + +
+ + +
+
+
+
+
+ +
+
+ + + + + + + + + + + + +