@webskill/chatbot 0.0.1

package/dist/kotlin-Za8DfsXK.js

@@ -0,0 +1,83 @@
+import { t as clike } from "./clike-BvmU1AL7.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/kotlin.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+kotlin.displayName = "kotlin";
+kotlin.aliases = ["kt", "kts"];
+/** @param {Refractor} Prism */
+function kotlin(Prism) {
+	Prism.register(clike);
+	(function(Prism) {
+		Prism.languages.kotlin = Prism.languages.extend("clike", {
+			keyword: {
+				pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
+				lookbehind: true
+			},
+			function: [{
+				pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/,
+				greedy: true
+			}, {
+				pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/,
+				lookbehind: true,
+				greedy: true
+			}],
+			number: /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,
+			operator: /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/
+		});
+		delete Prism.languages.kotlin["class-name"];
+		var interpolationInside = {
+			"interpolation-punctuation": {
+				pattern: /^\$\{?|\}$/,
+				alias: "punctuation"
+			},
+			expression: {
+				pattern: /[\s\S]+/,
+				inside: Prism.languages.kotlin
+			}
+		};
+		Prism.languages.insertBefore("kotlin", "string", {
+			"string-literal": [{
+				pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
+				alias: "multiline",
+				inside: {
+					interpolation: {
+						pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+						inside: interpolationInside
+					},
+					string: /[\s\S]+/
+				}
+			}, {
+				pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/,
+				alias: "singleline",
+				inside: {
+					interpolation: {
+						pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+						lookbehind: true,
+						inside: interpolationInside
+					},
+					string: /[\s\S]+/
+				}
+			}],
+			char: {
+				pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/,
+				greedy: true
+			}
+		});
+		delete Prism.languages.kotlin["string"];
+		Prism.languages.insertBefore("kotlin", "keyword", { annotation: {
+			pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
+			alias: "builtin"
+		} });
+		Prism.languages.insertBefore("kotlin", "function", { label: {
+			pattern: /\b\w+@|@\w+\b/,
+			alias: "symbol"
+		} });
+		Prism.languages.kt = Prism.languages.kotlin;
+		Prism.languages.kts = Prism.languages.kotlin;
+	})(Prism);
+}
+
+//#endregion
+export { kotlin as default };

package/dist/kumir-wWKTT1Tn.js

@@ -0,0 +1,95 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/kumir.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+kumir.displayName = "kumir";
+kumir.aliases = ["kum"];
+/** @param {Refractor} Prism */
+function kumir(Prism) {
+	(function(Prism) {
+		/**
+		* Regular expression for characters that are not allowed in identifiers.
+		*
+		* @type {string}
+		*/
+		var nonId = /\s\x00-\x1f\x22-\x2f\x3a-\x3f\x5b-\x5e\x60\x7b-\x7e/.source;
+		/**
+		* Surround a regular expression for IDs with patterns for non-ID sequences.
+		*
+		* @param {string} pattern A regular expression for identifiers.
+		* @param {string} [flags] The regular expression flags.
+		* @returns {RegExp} A wrapped regular expression for identifiers.
+		*/
+		function wrapId(pattern, flags) {
+			return RegExp(pattern.replace(/<nonId>/g, nonId), flags);
+		}
+		Prism.languages.kumir = {
+			comment: { pattern: /\|.*/ },
+			prolog: {
+				pattern: /#.*/,
+				greedy: true
+			},
+			string: {
+				pattern: /"[^\n\r"]*"|'[^\n\r']*'/,
+				greedy: true
+			},
+			boolean: {
+				pattern: wrapId(/(^|[<nonId>])(?:да|нет)(?=[<nonId>]|$)/.source),
+				lookbehind: true
+			},
+			"operator-word": {
+				pattern: wrapId(/(^|[<nonId>])(?:и|или|не)(?=[<nonId>]|$)/.source),
+				lookbehind: true,
+				alias: "keyword"
+			},
+			"system-variable": {
+				pattern: wrapId(/(^|[<nonId>])знач(?=[<nonId>]|$)/.source),
+				lookbehind: true,
+				alias: "keyword"
+			},
+			type: [{
+				pattern: wrapId(/(^|[<nonId>])(?:вещ|лит|лог|сим|цел)(?:\x20*таб)?(?=[<nonId>]|$)/.source),
+				lookbehind: true,
+				alias: "builtin"
+			}, {
+				pattern: wrapId(/(^|[<nonId>])(?:компл|сканкод|файл|цвет)(?=[<nonId>]|$)/.source),
+				lookbehind: true,
+				alias: "important"
+			}],
+			/**
+			* Should be performed after searching for type names because of "таб".
+			* "таб" is a reserved word, but never used without a preceding type name.
+			* "НАЗНАЧИТЬ", "Фввод", and "Фвывод" are not reserved words.
+			*/
+			keyword: {
+				pattern: wrapId(/(^|[<nonId>])(?:алг|арг(?:\x20*рез)?|ввод|ВКЛЮЧИТЬ|вс[её]|выбор|вывод|выход|дано|для|до|дс|если|иначе|исп|использовать|кон(?:(?:\x20+|_)исп)?|кц(?:(?:\x20+|_)при)?|надо|нач|нс|нц|от|пауза|пока|при|раза?|рез|стоп|таб|то|утв|шаг)(?=[<nonId>]|$)/.source),
+				lookbehind: true
+			},
+			/** Should be performed after searching for reserved words. */
+			name: {
+				pattern: wrapId(/(^|[<nonId>])[^\d<nonId>][^<nonId>]*(?:\x20+[^<nonId>]+)*(?=[<nonId>]|$)/.source),
+				lookbehind: true
+			},
+			/** Should be performed after searching for names. */
+			number: {
+				pattern: wrapId(/(^|[<nonId>])(?:\B\$[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)(?=[<nonId>]|$)/.source, "i"),
+				lookbehind: true
+			},
+			/** Should be performed after searching for words. */
+			punctuation: /:=|[(),:;\[\]]/,
+			/**
+			* Should be performed after searching for
+			* - numeric constants (because of "+" and "-");
+			* - punctuation marks (because of ":=" and "=").
+			*/
+			"operator-char": {
+				pattern: /\*\*?|<[=>]?|>=?|[-+/=]/,
+				alias: "operator"
+			}
+		};
+		Prism.languages.kum = Prism.languages.kumir;
+	})(Prism);
+}
+
+//#endregion
+export { kumir as default };

package/dist/kusto-K-lfyykQ.js

@@ -0,0 +1,45 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/kusto.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+kusto.displayName = "kusto";
+kusto.aliases = [];
+/** @param {Refractor} Prism */
+function kusto(Prism) {
+	Prism.languages.kusto = {
+		comment: {
+			pattern: /\/\/.*/,
+			greedy: true
+		},
+		string: {
+			pattern: /```[\s\S]*?```|[hH]?(?:"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\.)*'|@(?:"[^\r\n"]*"|'[^\r\n']*'))/,
+			greedy: true
+		},
+		verb: {
+			pattern: /(\|\s*)[a-z][\w-]*/i,
+			lookbehind: true,
+			alias: "keyword"
+		},
+		command: {
+			pattern: /\.[a-z][a-z\d-]*\b/,
+			alias: "keyword"
+		},
+		"class-name": /\b(?:bool|datetime|decimal|dynamic|guid|int|long|real|string|timespan)\b/,
+		keyword: /\b(?:access|alias|and|anti|as|asc|auto|between|by|(?:contains|(?:ends|starts)with|has(?:perfix|suffix)?)(?:_cs)?|database|declare|desc|external|from|fullouter|has_all|in|ingestion|inline|inner|innerunique|into|(?:left|right)(?:anti(?:semi)?|inner|outer|semi)?|let|like|local|not|of|on|or|pattern|print|query_parameters|range|restrict|schema|set|step|table|tables|to|view|where|with|matches\s+regex|nulls\s+(?:first|last))(?![\w-])/,
+		boolean: /\b(?:false|null|true)\b/,
+		function: /\b[a-z_]\w*(?=\s*\()/,
+		datetime: [{
+			pattern: /\b(?:(?:Fri|Friday|Mon|Monday|Sat|Saturday|Sun|Sunday|Thu|Thursday|Tue|Tuesday|Wed|Wednesday)\s*,\s*)?\d{1,2}(?:\s+|-)(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)(?:\s+|-)\d{2}\s+\d{2}:\d{2}(?::\d{2})?(?:\s*(?:\b(?:[A-Z]|(?:[ECMT][DS]|GM|U)T)|[+-]\d{4}))?\b/,
+			alias: "number"
+		}, {
+			pattern: /[+-]?\b(?:\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?|\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)Z?/,
+			alias: "number"
+		}],
+		number: /\b(?:0x[0-9A-Fa-f]+|\d+(?:\.\d+)?(?:[Ee][+-]?\d+)?)(?:(?:min|sec|[mnµ]s|[dhms]|microsecond|tick)\b)?|[+-]?\binf\b/,
+		operator: /=>|[!=]~|[!=<>]=?|[-+*/%|]|\.\./,
+		punctuation: /[()\[\]{},;.:]/
+	};
+}
+
+//#endregion
+export { kusto as default };

package/dist/lasso-BQ0d-ec4.js

@@ -0,0 +1,132 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/lasso.js
+var require_lasso = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function lasso(hljs) {
+		const LASSO_IDENT_RE = "[a-zA-Z_][\\w.]*";
+		const LASSO_CLOSE_RE = "\\]|\\?>";
+		const LASSO_KEYWORDS = {
+			$pattern: "[a-zA-Z_][\\w.]*|&[lg]t;",
+			literal: "true false none minimal full all void and or not bw nbw ew new cn ncn lt lte gt gte eq neq rx nrx ft",
+			built_in: "array date decimal duration integer map pair string tag xml null boolean bytes keyword list locale queue set stack staticarray local var variable global data self inherited currentcapture givenblock",
+			keyword: "cache database_names database_schemanames database_tablenames define_tag define_type email_batch encode_set html_comment handle handle_error header if inline iterate ljax_target link link_currentaction link_currentgroup link_currentrecord link_detail link_firstgroup link_firstrecord link_lastgroup link_lastrecord link_nextgroup link_nextrecord link_prevgroup link_prevrecord log loop namespace_using output_none portal private protect records referer referrer repeating resultset rows search_args search_arguments select sort_args sort_arguments thread_atomic value_list while abort case else fail_if fail_ifnot fail if_empty if_false if_null if_true loop_abort loop_continue loop_count params params_up return return_value run_children soap_definetag soap_lastrequest soap_lastresponse tag_name ascending average by define descending do equals frozen group handle_failure import in into join let match max min on order parent protected provide public require returnhome skip split_thread sum take thread to trait type where with yield yieldhome"
+		};
+		const HTML_COMMENT = hljs.COMMENT("<!--", "-->", { relevance: 0 });
+		const LASSO_NOPROCESS = {
+			className: "meta",
+			begin: "\\[noprocess\\]",
+			starts: {
+				end: "\\[/noprocess\\]",
+				returnEnd: true,
+				contains: [HTML_COMMENT]
+			}
+		};
+		const LASSO_START = {
+			className: "meta",
+			begin: "\\[/noprocess|<\\?(lasso(script)?|=)"
+		};
+		const LASSO_CODE = [
+			hljs.C_LINE_COMMENT_MODE,
+			hljs.C_BLOCK_COMMENT_MODE,
+			hljs.inherit(hljs.C_NUMBER_MODE, { begin: hljs.C_NUMBER_RE + "|(-?infinity|NaN)\\b" }),
+			hljs.inherit(hljs.APOS_STRING_MODE, { illegal: null }),
+			hljs.inherit(hljs.QUOTE_STRING_MODE, { illegal: null }),
+			{
+				className: "string",
+				begin: "`",
+				end: "`"
+			},
+			{ variants: [{ begin: "[#$][a-zA-Z_][\\w.]*" }, {
+				begin: "#",
+				end: "\\d+",
+				illegal: "\\W"
+			}] },
+			{
+				className: "type",
+				begin: "::\\s*",
+				end: LASSO_IDENT_RE,
+				illegal: "\\W"
+			},
+			{
+				className: "params",
+				variants: [{
+					begin: "-(?!infinity)[a-zA-Z_][\\w.]*",
+					relevance: 0
+				}, { begin: "(\\.\\.\\.)" }]
+			},
+			{
+				begin: /(->|\.)\s*/,
+				relevance: 0,
+				contains: [{
+					className: "symbol",
+					begin: "'[a-zA-Z_][\\w.]*'"
+				}]
+			},
+			{
+				className: "class",
+				beginKeywords: "define",
+				returnEnd: true,
+				end: "\\(|=>",
+				contains: [hljs.inherit(hljs.TITLE_MODE, { begin: "[a-zA-Z_][\\w.]*(=(?!>))?|[-+*/%](?!>)" })]
+			}
+		];
+		return {
+			name: "Lasso",
+			aliases: ["ls", "lassoscript"],
+			case_insensitive: true,
+			keywords: LASSO_KEYWORDS,
+			contains: [
+				{
+					className: "meta",
+					begin: LASSO_CLOSE_RE,
+					relevance: 0,
+					starts: {
+						end: "\\[|<\\?(lasso(script)?|=)",
+						returnEnd: true,
+						relevance: 0,
+						contains: [HTML_COMMENT]
+					}
+				},
+				LASSO_NOPROCESS,
+				LASSO_START,
+				{
+					className: "meta",
+					begin: "\\[no_square_brackets",
+					starts: {
+						end: "\\[/no_square_brackets\\]",
+						keywords: LASSO_KEYWORDS,
+						contains: [
+							{
+								className: "meta",
+								begin: LASSO_CLOSE_RE,
+								relevance: 0,
+								starts: {
+									end: "\\[noprocess\\]|<\\?(lasso(script)?|=)",
+									returnEnd: true,
+									contains: [HTML_COMMENT]
+								}
+							},
+							LASSO_NOPROCESS,
+							LASSO_START
+						].concat(LASSO_CODE)
+					}
+				},
+				{
+					className: "meta",
+					begin: "\\[",
+					relevance: 0
+				},
+				{
+					className: "meta",
+					begin: "^#!",
+					end: "lasso9$",
+					relevance: 10
+				}
+			].concat(LASSO_CODE)
+		};
+	}
+	module.exports = lasso;
+}));
+
+//#endregion
+export default require_lasso();

package/dist/latex-CbDOwO4M.js

@@ -0,0 +1,56 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/latex.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+latex.displayName = "latex";
+latex.aliases = ["context", "tex"];
+/** @param {Refractor} Prism */
+function latex(Prism) {
+	(function(Prism) {
+		var funcPattern = /\\(?:[^a-z()[\]]|[a-z*]+)/i;
+		var insideEqu = { "equation-command": {
+			pattern: funcPattern,
+			alias: "regex"
+		} };
+		Prism.languages.latex = {
+			comment: /%.*/,
+			cdata: {
+				pattern: /(\\begin\{((?:lstlisting|verbatim)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
+				lookbehind: true
+			},
+			equation: [{
+				pattern: /\$\$(?:\\[\s\S]|[^\\$])+\$\$|\$(?:\\[\s\S]|[^\\$])+\$|\\\([\s\S]*?\\\)|\\\[[\s\S]*?\\\]/,
+				inside: insideEqu,
+				alias: "string"
+			}, {
+				pattern: /(\\begin\{((?:align|eqnarray|equation|gather|math|multline)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
+				lookbehind: true,
+				inside: insideEqu,
+				alias: "string"
+			}],
+			keyword: {
+				pattern: /(\\(?:begin|cite|documentclass|end|label|ref|usepackage)(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
+				lookbehind: true
+			},
+			url: {
+				pattern: /(\\url\{)[^}]+(?=\})/,
+				lookbehind: true
+			},
+			headline: {
+				pattern: /(\\(?:chapter|frametitle|paragraph|part|section|subparagraph|subsection|subsubparagraph|subsubsection|subsubsubparagraph)\*?(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
+				lookbehind: true,
+				alias: "class-name"
+			},
+			function: {
+				pattern: funcPattern,
+				alias: "selector"
+			},
+			punctuation: /[[\]{}&]/
+		};
+		Prism.languages.tex = Prism.languages.latex;
+		Prism.languages.context = Prism.languages.latex;
+	})(Prism);
+}
+
+//#endregion
+export { latex as default };

package/dist/latex-hQ09OoNB.js

@@ -0,0 +1,235 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/latex.js
+var require_latex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* @param {string} value
+	* @returns {RegExp}
+	* */
+	/**
+	* @param {RegExp | string } re
+	* @returns {string}
+	*/
+	function source(re) {
+		if (!re) return null;
+		if (typeof re === "string") return re;
+		return re.source;
+	}
+	/**
+	* Any of the passed expresssions may match
+	*
+	* Creates a huge this | this | that | that match
+	* @param {(RegExp | string)[] } args
+	* @returns {string}
+	*/
+	function either(...args) {
+		return "(" + args.map((x) => source(x)).join("|") + ")";
+	}
+	/** @type LanguageFn */
+	function latex(hljs) {
+		const KNOWN_CONTROL_WORDS = either(...[
+			"(?:NeedsTeXFormat|RequirePackage|GetIdInfo)",
+			"Provides(?:Expl)?(?:Package|Class|File)",
+			"(?:DeclareOption|ProcessOptions)",
+			"(?:documentclass|usepackage|input|include)",
+			"makeat(?:letter|other)",
+			"ExplSyntax(?:On|Off)",
+			"(?:new|renew|provide)?command",
+			"(?:re)newenvironment",
+			"(?:New|Renew|Provide|Declare)(?:Expandable)?DocumentCommand",
+			"(?:New|Renew|Provide|Declare)DocumentEnvironment",
+			"(?:(?:e|g|x)?def|let)",
+			"(?:begin|end)",
+			"(?:part|chapter|(?:sub){0,2}section|(?:sub)?paragraph)",
+			"caption",
+			"(?:label|(?:eq|page|name)?ref|(?:paren|foot|super)?cite)",
+			"(?:alpha|beta|[Gg]amma|[Dd]elta|(?:var)?epsilon|zeta|eta|[Tt]heta|vartheta)",
+			"(?:iota|(?:var)?kappa|[Ll]ambda|mu|nu|[Xx]i|[Pp]i|varpi|(?:var)rho)",
+			"(?:[Ss]igma|varsigma|tau|[Uu]psilon|[Pp]hi|varphi|chi|[Pp]si|[Oo]mega)",
+			"(?:frac|sum|prod|lim|infty|times|sqrt|leq|geq|left|right|middle|[bB]igg?)",
+			"(?:[lr]angle|q?quad|[lcvdi]?dots|d?dot|hat|tilde|bar)"
+		].map((word) => word + "(?![a-zA-Z@:_])"));
+		const L3_REGEX = new RegExp([
+			"(?:__)?[a-zA-Z]{2,}_[a-zA-Z](?:_?[a-zA-Z])+:[a-zA-Z]*",
+			"[lgc]__?[a-zA-Z](?:_?[a-zA-Z])*_[a-zA-Z]{2,}",
+			"[qs]__?[a-zA-Z](?:_?[a-zA-Z])+",
+			"use(?:_i)?:[a-zA-Z]*",
+			"(?:else|fi|or):",
+			"(?:if|cs|exp):w",
+			"(?:hbox|vbox):n",
+			"::[a-zA-Z]_unbraced",
+			"::[a-zA-Z:]"
+		].map((pattern) => pattern + "(?![a-zA-Z:_])").join("|"));
+		const L2_VARIANTS = [{ begin: /[a-zA-Z@]+/ }, { begin: /[^a-zA-Z@]?/ }];
+		const DOUBLE_CARET_VARIANTS = [
+			{ begin: /\^{6}[0-9a-f]{6}/ },
+			{ begin: /\^{5}[0-9a-f]{5}/ },
+			{ begin: /\^{4}[0-9a-f]{4}/ },
+			{ begin: /\^{3}[0-9a-f]{3}/ },
+			{ begin: /\^{2}[0-9a-f]{2}/ },
+			{ begin: /\^{2}[\u0000-\u007f]/ }
+		];
+		const EVERYTHING_BUT_VERBATIM = [
+			{
+				className: "keyword",
+				begin: /\\/,
+				relevance: 0,
+				contains: [
+					{
+						endsParent: true,
+						begin: KNOWN_CONTROL_WORDS
+					},
+					{
+						endsParent: true,
+						begin: L3_REGEX
+					},
+					{
+						endsParent: true,
+						variants: DOUBLE_CARET_VARIANTS
+					},
+					{
+						endsParent: true,
+						relevance: 0,
+						variants: L2_VARIANTS
+					}
+				]
+			},
+			{
+				className: "params",
+				relevance: 0,
+				begin: /#+\d?/
+			},
+			{ variants: DOUBLE_CARET_VARIANTS },
+			{
+				className: "built_in",
+				relevance: 0,
+				begin: /[$&^_]/
+			},
+			{
+				className: "meta",
+				begin: "% !TeX",
+				end: "$",
+				relevance: 10
+			},
+			hljs.COMMENT("%", "$", { relevance: 0 })
+		];
+		const BRACE_GROUP_NO_VERBATIM = {
+			begin: /\{/,
+			end: /\}/,
+			relevance: 0,
+			contains: ["self", ...EVERYTHING_BUT_VERBATIM]
+		};
+		const ARGUMENT_BRACES = hljs.inherit(BRACE_GROUP_NO_VERBATIM, {
+			relevance: 0,
+			endsParent: true,
+			contains: [BRACE_GROUP_NO_VERBATIM, ...EVERYTHING_BUT_VERBATIM]
+		});
+		const ARGUMENT_BRACKETS = {
+			begin: /\[/,
+			end: /\]/,
+			endsParent: true,
+			relevance: 0,
+			contains: [BRACE_GROUP_NO_VERBATIM, ...EVERYTHING_BUT_VERBATIM]
+		};
+		const SPACE_GOBBLER = {
+			begin: /\s+/,
+			relevance: 0
+		};
+		const ARGUMENT_M = [ARGUMENT_BRACES];
+		const ARGUMENT_O = [ARGUMENT_BRACKETS];
+		const ARGUMENT_AND_THEN = function(arg, starts_mode) {
+			return {
+				contains: [SPACE_GOBBLER],
+				starts: {
+					relevance: 0,
+					contains: arg,
+					starts: starts_mode
+				}
+			};
+		};
+		const CSNAME = function(csname, starts_mode) {
+			return {
+				begin: "\\\\" + csname + "(?![a-zA-Z@:_])",
+				keywords: {
+					$pattern: /\\[a-zA-Z]+/,
+					keyword: "\\" + csname
+				},
+				relevance: 0,
+				contains: [SPACE_GOBBLER],
+				starts: starts_mode
+			};
+		};
+		const BEGIN_ENV = function(envname, starts_mode) {
+			return hljs.inherit({
+				begin: "\\\\begin(?=[ 	]*(\\r?\\n[ 	]*)?\\{" + envname + "\\})",
+				keywords: {
+					$pattern: /\\[a-zA-Z]+/,
+					keyword: "\\begin"
+				},
+				relevance: 0
+			}, ARGUMENT_AND_THEN(ARGUMENT_M, starts_mode));
+		};
+		const VERBATIM_DELIMITED_EQUAL = (innerName = "string") => {
+			return hljs.END_SAME_AS_BEGIN({
+				className: innerName,
+				begin: /(.|\r?\n)/,
+				end: /(.|\r?\n)/,
+				excludeBegin: true,
+				excludeEnd: true,
+				endsParent: true
+			});
+		};
+		const VERBATIM_DELIMITED_ENV = function(envname) {
+			return {
+				className: "string",
+				end: "(?=\\\\end\\{" + envname + "\\})"
+			};
+		};
+		const VERBATIM_DELIMITED_BRACES = (innerName = "string") => {
+			return {
+				relevance: 0,
+				begin: /\{/,
+				starts: {
+					endsParent: true,
+					contains: [{
+						className: innerName,
+						end: /(?=\})/,
+						endsParent: true,
+						contains: [{
+							begin: /\{/,
+							end: /\}/,
+							relevance: 0,
+							contains: ["self"]
+						}]
+					}]
+				}
+			};
+		};
+		return {
+			name: "LaTeX",
+			aliases: ["tex"],
+			contains: [...[
+				...["verb", "lstinline"].map((csname) => CSNAME(csname, { contains: [VERBATIM_DELIMITED_EQUAL()] })),
+				CSNAME("mint", ARGUMENT_AND_THEN(ARGUMENT_M, { contains: [VERBATIM_DELIMITED_EQUAL()] })),
+				CSNAME("mintinline", ARGUMENT_AND_THEN(ARGUMENT_M, { contains: [VERBATIM_DELIMITED_BRACES(), VERBATIM_DELIMITED_EQUAL()] })),
+				CSNAME("url", { contains: [VERBATIM_DELIMITED_BRACES("link"), VERBATIM_DELIMITED_BRACES("link")] }),
+				CSNAME("hyperref", { contains: [VERBATIM_DELIMITED_BRACES("link")] }),
+				CSNAME("href", ARGUMENT_AND_THEN(ARGUMENT_O, { contains: [VERBATIM_DELIMITED_BRACES("link")] })),
+				...[].concat(...["", "\\*"].map((suffix) => [
+					BEGIN_ENV("verbatim" + suffix, VERBATIM_DELIMITED_ENV("verbatim" + suffix)),
+					BEGIN_ENV("filecontents" + suffix, ARGUMENT_AND_THEN(ARGUMENT_M, VERBATIM_DELIMITED_ENV("filecontents" + suffix))),
+					...[
+						"",
+						"B",
+						"L"
+					].map((prefix) => BEGIN_ENV(prefix + "Verbatim" + suffix, ARGUMENT_AND_THEN(ARGUMENT_O, VERBATIM_DELIMITED_ENV(prefix + "Verbatim" + suffix))))
+				])),
+				BEGIN_ENV("minted", ARGUMENT_AND_THEN(ARGUMENT_O, ARGUMENT_AND_THEN(ARGUMENT_M, VERBATIM_DELIMITED_ENV("minted"))))
+			], ...EVERYTHING_BUT_VERBATIM]
+		};
+	}
+	module.exports = latex;
+}));
+
+//#endregion
+export default require_latex();