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