@atom8n/n8n-editor-ui 2.2.0

package/dist/assets/xml-B_oj6Mle.js

@@ -0,0 +1,2060 @@
+function bash(hljs) {
+	const regex = hljs.regex;
+	const VAR = {};
+	const BRACED_VAR = {
+		begin: /\$\{/,
+		end: /\}/,
+		contains: ["self", {
+			begin: /:-/,
+			contains: [VAR]
+		}]
+	};
+	Object.assign(VAR, {
+		className: "variable",
+		variants: [{ begin: regex.concat(/\$[\w\d#@][\w\d_]*/, `(?![\\w\\d])(?![$])`) }, BRACED_VAR]
+	});
+	const SUBST = {
+		className: "subst",
+		begin: /\$\(/,
+		end: /\)/,
+		contains: [hljs.BACKSLASH_ESCAPE]
+	};
+	const HERE_DOC = {
+		begin: /<<-?\s*(?=\w+)/,
+		starts: { contains: [hljs.END_SAME_AS_BEGIN({
+			begin: /(\w+)/,
+			end: /(\w+)/,
+			className: "string"
+		})] }
+	};
+	const QUOTE_STRING = {
+		className: "string",
+		begin: /"/,
+		end: /"/,
+		contains: [
+			hljs.BACKSLASH_ESCAPE,
+			VAR,
+			SUBST
+		]
+	};
+	SUBST.contains.push(QUOTE_STRING);
+	const ESCAPED_QUOTE = {
+		className: "",
+		begin: /\\"/
+	};
+	const APOS_STRING = {
+		className: "string",
+		begin: /'/,
+		end: /'/
+	};
+	const ARITHMETIC = {
+		begin: /\$?\(\(/,
+		end: /\)\)/,
+		contains: [
+			{
+				begin: /\d+#[0-9a-f]+/,
+				className: "number"
+			},
+			hljs.NUMBER_MODE,
+			VAR
+		]
+	};
+	const KNOWN_SHEBANG = hljs.SHEBANG({
+		binary: `(${[
+			"fish",
+			"bash",
+			"zsh",
+			"sh",
+			"csh",
+			"ksh",
+			"tcsh",
+			"dash",
+			"scsh"
+		].join("|")})`,
+		relevance: 10
+	});
+	const FUNCTION = {
+		className: "function",
+		begin: /\w[\w\d_]*\s*\(\s*\)\s*\{/,
+		returnBegin: true,
+		contains: [hljs.inherit(hljs.TITLE_MODE, { begin: /\w[\w\d_]*/ })],
+		relevance: 0
+	};
+	const KEYWORDS$2 = [
+		"if",
+		"then",
+		"else",
+		"elif",
+		"fi",
+		"for",
+		"while",
+		"until",
+		"in",
+		"do",
+		"done",
+		"case",
+		"esac",
+		"function",
+		"select"
+	];
+	const LITERALS$2 = ["true", "false"];
+	const PATH_MODE = { match: /(\/[a-z._-]+)+/ };
+	const SHELL_BUILT_INS = [
+		"break",
+		"cd",
+		"continue",
+		"eval",
+		"exec",
+		"exit",
+		"export",
+		"getopts",
+		"hash",
+		"pwd",
+		"readonly",
+		"return",
+		"shift",
+		"test",
+		"times",
+		"trap",
+		"umask",
+		"unset"
+	];
+	const BASH_BUILT_INS = [
+		"alias",
+		"bind",
+		"builtin",
+		"caller",
+		"command",
+		"declare",
+		"echo",
+		"enable",
+		"help",
+		"let",
+		"local",
+		"logout",
+		"mapfile",
+		"printf",
+		"read",
+		"readarray",
+		"source",
+		"type",
+		"typeset",
+		"ulimit",
+		"unalias"
+	];
+	const ZSH_BUILT_INS = [
+		"autoload",
+		"bg",
+		"bindkey",
+		"bye",
+		"cap",
+		"chdir",
+		"clone",
+		"comparguments",
+		"compcall",
+		"compctl",
+		"compdescribe",
+		"compfiles",
+		"compgroups",
+		"compquote",
+		"comptags",
+		"comptry",
+		"compvalues",
+		"dirs",
+		"disable",
+		"disown",
+		"echotc",
+		"echoti",
+		"emulate",
+		"fc",
+		"fg",
+		"float",
+		"functions",
+		"getcap",
+		"getln",
+		"history",
+		"integer",
+		"jobs",
+		"kill",
+		"limit",
+		"log",
+		"noglob",
+		"popd",
+		"print",
+		"pushd",
+		"pushln",
+		"rehash",
+		"sched",
+		"setcap",
+		"setopt",
+		"stat",
+		"suspend",
+		"ttyctl",
+		"unfunction",
+		"unhash",
+		"unlimit",
+		"unsetopt",
+		"vared",
+		"wait",
+		"whence",
+		"where",
+		"which",
+		"zcompile",
+		"zformat",
+		"zftp",
+		"zle",
+		"zmodload",
+		"zparseopts",
+		"zprof",
+		"zpty",
+		"zregexparse",
+		"zsocket",
+		"zstyle",
+		"ztcp"
+	];
+	const GNU_CORE_UTILS = [
+		"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"
+	];
+	return {
+		name: "Bash",
+		aliases: ["sh"],
+		keywords: {
+			$pattern: /\b[a-z][a-z0-9._-]+\b/,
+			keyword: KEYWORDS$2,
+			literal: LITERALS$2,
+			built_in: [
+				...SHELL_BUILT_INS,
+				...BASH_BUILT_INS,
+				"set",
+				"shopt",
+				...ZSH_BUILT_INS,
+				...GNU_CORE_UTILS
+			]
+		},
+		contains: [
+			KNOWN_SHEBANG,
+			hljs.SHEBANG(),
+			FUNCTION,
+			ARITHMETIC,
+			hljs.HASH_COMMENT_MODE,
+			HERE_DOC,
+			PATH_MODE,
+			QUOTE_STRING,
+			ESCAPED_QUOTE,
+			APOS_STRING,
+			VAR
+		]
+	};
+}
+var IDENT_RE$1 = "[A-Za-z$_][0-9A-Za-z$_]*";
+var KEYWORDS$1 = [
+	"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"
+];
+var LITERALS$1 = [
+	"true",
+	"false",
+	"null",
+	"undefined",
+	"NaN",
+	"Infinity"
+];
+var TYPES$1 = [
+	"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"
+];
+var ERROR_TYPES$1 = [
+	"Error",
+	"EvalError",
+	"InternalError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"TypeError",
+	"URIError"
+];
+var BUILT_IN_GLOBALS$1 = [
+	"setInterval",
+	"setTimeout",
+	"clearInterval",
+	"clearTimeout",
+	"require",
+	"exports",
+	"eval",
+	"isFinite",
+	"isNaN",
+	"parseFloat",
+	"parseInt",
+	"decodeURI",
+	"decodeURIComponent",
+	"encodeURI",
+	"encodeURIComponent",
+	"escape",
+	"unescape"
+];
+var BUILT_IN_VARIABLES$1 = [
+	"arguments",
+	"this",
+	"super",
+	"console",
+	"window",
+	"document",
+	"localStorage",
+	"sessionStorage",
+	"module",
+	"global"
+];
+var BUILT_INS$1 = [].concat(BUILT_IN_GLOBALS$1, TYPES$1, ERROR_TYPES$1);
+function javascript$1(hljs) {
+	const regex = hljs.regex;
+	const hasClosingTag = (match, { after }) => {
+		const tag = "</" + match[0].slice(1);
+		return match.input.indexOf(tag, after) !== -1;
+	};
+	const IDENT_RE$1$1 = IDENT_RE$1;
+	const FRAGMENT = {
+		begin: "<>",
+		end: "</>"
+	};
+	const XML_SELF_CLOSING = /<[A-Za-z0-9\\._:-]+\s*\/>/;
+	const XML_TAG = {
+		begin: /<[A-Za-z0-9\\._:-]+/,
+		end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+		isTrulyOpeningTag: (match, response) => {
+			const afterMatchIndex = match[0].length + match.index;
+			const nextChar = match.input[afterMatchIndex];
+			if (nextChar === "<" || nextChar === ",") {
+				response.ignoreMatch();
+				return;
+			}
+			if (nextChar === ">") {
+				if (!hasClosingTag(match, { after: afterMatchIndex })) response.ignoreMatch();
+			}
+			let m;
+			const afterMatch = match.input.substring(afterMatchIndex);
+			if (m = afterMatch.match(/^\s*=/)) {
+				response.ignoreMatch();
+				return;
+			}
+			if (m = afterMatch.match(/^\s+extends\s+/)) {
+				if (m.index === 0) {
+					response.ignoreMatch();
+					return;
+				}
+			}
+		}
+	};
+	const KEYWORDS$1$1 = {
+		$pattern: IDENT_RE$1,
+		keyword: KEYWORDS$1,
+		literal: LITERALS$1,
+		built_in: BUILT_INS$1,
+		"variable.language": BUILT_IN_VARIABLES$1
+	};
+	const decimalDigits = "[0-9](_?[0-9])*";
+	const frac = `\\.(${decimalDigits})`;
+	const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`;
+	const NUMBER = {
+		className: "number",
+		variants: [
+			{ begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))[eE][+-]?(${decimalDigits})\\b` },
+			{ begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\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
+	};
+	const SUBST = {
+		className: "subst",
+		begin: "\\$\\{",
+		end: "\\}",
+		keywords: KEYWORDS$1$1,
+		contains: []
+	};
+	const HTML_TEMPLATE = {
+		begin: "html`",
+		end: "",
+		starts: {
+			end: "`",
+			returnEnd: false,
+			contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+			subLanguage: "xml"
+		}
+	};
+	const CSS_TEMPLATE = {
+		begin: "css`",
+		end: "",
+		starts: {
+			end: "`",
+			returnEnd: false,
+			contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+			subLanguage: "css"
+		}
+	};
+	const GRAPHQL_TEMPLATE = {
+		begin: "gql`",
+		end: "",
+		starts: {
+			end: "`",
+			returnEnd: false,
+			contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+			subLanguage: "graphql"
+		}
+	};
+	const TEMPLATE_STRING = {
+		className: "string",
+		begin: "`",
+		end: "`",
+		contains: [hljs.BACKSLASH_ESCAPE, SUBST]
+	};
+	const COMMENT = {
+		className: "comment",
+		variants: [
+			hljs.COMMENT(/\/\*\*(?!\/)/, "\\*/", {
+				relevance: 0,
+				contains: [{
+					begin: "(?=@[A-Za-z]+)",
+					relevance: 0,
+					contains: [
+						{
+							className: "doctag",
+							begin: "@[A-Za-z]+"
+						},
+						{
+							className: "type",
+							begin: "\\{",
+							end: "\\}",
+							excludeEnd: true,
+							excludeBegin: true,
+							relevance: 0
+						},
+						{
+							className: "variable",
+							begin: IDENT_RE$1$1 + "(?=\\s*(-)|$)",
+							endsParent: true,
+							relevance: 0
+						},
+						{
+							begin: /(?=[^\n])\s/,
+							relevance: 0
+						}
+					]
+				}]
+			}),
+			hljs.C_BLOCK_COMMENT_MODE,
+			hljs.C_LINE_COMMENT_MODE
+		]
+	};
+	const SUBST_INTERNALS = [
+		hljs.APOS_STRING_MODE,
+		hljs.QUOTE_STRING_MODE,
+		HTML_TEMPLATE,
+		CSS_TEMPLATE,
+		GRAPHQL_TEMPLATE,
+		TEMPLATE_STRING,
+		{ match: /\$\d+/ },
+		NUMBER
+	];
+	SUBST.contains = SUBST_INTERNALS.concat({
+		begin: /\{/,
+		end: /\}/,
+		keywords: KEYWORDS$1$1,
+		contains: ["self"].concat(SUBST_INTERNALS)
+	});
+	const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains);
+	const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([{
+		begin: /\(/,
+		end: /\)/,
+		keywords: KEYWORDS$1$1,
+		contains: ["self"].concat(SUBST_AND_COMMENTS)
+	}]);
+	const PARAMS = {
+		className: "params",
+		begin: /\(/,
+		end: /\)/,
+		excludeBegin: true,
+		excludeEnd: true,
+		keywords: KEYWORDS$1$1,
+		contains: PARAMS_CONTAINS
+	};
+	const CLASS_OR_EXTENDS = { variants: [{
+		match: [
+			/class/,
+			/\s+/,
+			IDENT_RE$1$1,
+			/\s+/,
+			/extends/,
+			/\s+/,
+			regex.concat(IDENT_RE$1$1, "(", regex.concat(/\./, IDENT_RE$1$1), ")*")
+		],
+		scope: {
+			1: "keyword",
+			3: "title.class",
+			5: "keyword",
+			7: "title.class.inherited"
+		}
+	}, {
+		match: [
+			/class/,
+			/\s+/,
+			IDENT_RE$1$1
+		],
+		scope: {
+			1: "keyword",
+			3: "title.class"
+		}
+	}] };
+	const CLASS_REFERENCE = {
+		relevance: 0,
+		match: regex.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: { _: [...TYPES$1, ...ERROR_TYPES$1] }
+	};
+	const USE_STRICT = {
+		label: "use_strict",
+		className: "meta",
+		relevance: 10,
+		begin: /^\s*['"]use (strict|asm)['"]/
+	};
+	const FUNCTION_DEFINITION = {
+		variants: [{ match: [
+			/function/,
+			/\s+/,
+			IDENT_RE$1$1,
+			/(?=\s*\()/
+		] }, { match: [/function/, /\s*(?=\()/] }],
+		className: {
+			1: "keyword",
+			3: "title.function"
+		},
+		label: "func.def",
+		contains: [PARAMS],
+		illegal: /%/
+	};
+	const UPPER_CASE_CONSTANT = {
+		relevance: 0,
+		match: /\b[A-Z][A-Z_0-9]+\b/,
+		className: "variable.constant"
+	};
+	function noneOf(list) {
+		return regex.concat("(?!", list.join("|"), ")");
+	}
+	const FUNCTION_CALL = {
+		match: regex.concat(/\b/, noneOf([
+			...BUILT_IN_GLOBALS$1,
+			"super",
+			"import"
+		]), IDENT_RE$1$1, regex.lookahead(/\(/)),
+		className: "title.function",
+		relevance: 0
+	};
+	const PROPERTY_ACCESS = {
+		begin: regex.concat(/\./, regex.lookahead(regex.concat(IDENT_RE$1$1, /(?![0-9A-Za-z$_(])/))),
+		end: IDENT_RE$1$1,
+		excludeBegin: true,
+		keywords: "prototype",
+		className: "property",
+		relevance: 0
+	};
+	const GETTER_OR_SETTER = {
+		match: [
+			/get|set/,
+			/\s+/,
+			IDENT_RE$1$1,
+			/(?=\()/
+		],
+		className: {
+			1: "keyword",
+			3: "title.function"
+		},
+		contains: [{ begin: /\(\)/ }, PARAMS]
+	};
+	const FUNC_LEAD_IN_RE = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + hljs.UNDERSCORE_IDENT_RE + ")\\s*=>";
+	const FUNCTION_VARIABLE = {
+		match: [
+			/const|var|let/,
+			/\s+/,
+			IDENT_RE$1$1,
+			/\s*/,
+			/=\s*/,
+			/(async\s*)?/,
+			regex.lookahead(FUNC_LEAD_IN_RE)
+		],
+		keywords: "async",
+		className: {
+			1: "keyword",
+			3: "title.function"
+		},
+		contains: [PARAMS]
+	};
+	return {
+		name: "JavaScript",
+		aliases: [
+			"js",
+			"jsx",
+			"mjs",
+			"cjs"
+		],
+		keywords: KEYWORDS$1$1,
+		exports: {
+			PARAMS_CONTAINS,
+			CLASS_REFERENCE
+		},
+		illegal: /#(?![$_A-z])/,
+		contains: [
+			hljs.SHEBANG({
+				label: "shebang",
+				binary: "node",
+				relevance: 5
+			}),
+			USE_STRICT,
+			hljs.APOS_STRING_MODE,
+			hljs.QUOTE_STRING_MODE,
+			HTML_TEMPLATE,
+			CSS_TEMPLATE,
+			GRAPHQL_TEMPLATE,
+			TEMPLATE_STRING,
+			COMMENT,
+			{ match: /\$\d+/ },
+			NUMBER,
+			CLASS_REFERENCE,
+			{
+				className: "attr",
+				begin: IDENT_RE$1$1 + regex.lookahead(":"),
+				relevance: 0
+			},
+			FUNCTION_VARIABLE,
+			{
+				begin: "(" + hljs.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+				keywords: "return throw case",
+				relevance: 0,
+				contains: [
+					COMMENT,
+					hljs.REGEXP_MODE,
+					{
+						className: "function",
+						begin: FUNC_LEAD_IN_RE,
+						returnBegin: true,
+						end: "\\s*=>",
+						contains: [{
+							className: "params",
+							variants: [
+								{
+									begin: hljs.UNDERSCORE_IDENT_RE,
+									relevance: 0
+								},
+								{
+									className: null,
+									begin: /\(\s*\)/,
+									skip: true
+								},
+								{
+									begin: /\(/,
+									end: /\)/,
+									excludeBegin: true,
+									excludeEnd: true,
+									keywords: KEYWORDS$1$1,
+									contains: PARAMS_CONTAINS
+								}
+							]
+						}]
+					},
+					{
+						begin: /,/,
+						relevance: 0
+					},
+					{
+						match: /\s+/,
+						relevance: 0
+					},
+					{
+						variants: [
+							{
+								begin: FRAGMENT.begin,
+								end: FRAGMENT.end
+							},
+							{ match: XML_SELF_CLOSING },
+							{
+								begin: XML_TAG.begin,
+								"on:begin": XML_TAG.isTrulyOpeningTag,
+								end: XML_TAG.end
+							}
+						],
+						subLanguage: "xml",
+						contains: [{
+							begin: XML_TAG.begin,
+							end: XML_TAG.end,
+							skip: true,
+							contains: ["self"]
+						}]
+					}
+				]
+			},
+			FUNCTION_DEFINITION,
+			{ beginKeywords: "while if switch catch for" },
+			{
+				begin: "\\b(?!function)" + hljs.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+				returnBegin: true,
+				label: "func.def",
+				contains: [PARAMS, hljs.inherit(hljs.TITLE_MODE, {
+					begin: IDENT_RE$1$1,
+					className: "title.function"
+				})]
+			},
+			{
+				match: /\.\.\./,
+				relevance: 0
+			},
+			PROPERTY_ACCESS,
+			{
+				match: "\\$" + IDENT_RE$1$1,
+				relevance: 0
+			},
+			{
+				match: [/\bconstructor(?=\s*\()/],
+				className: { 1: "title.function" },
+				contains: [PARAMS]
+			},
+			FUNCTION_CALL,
+			UPPER_CASE_CONSTANT,
+			CLASS_OR_EXTENDS,
+			GETTER_OR_SETTER,
+			{ match: /\$[(.]/ }
+		]
+	};
+}
+function python(hljs) {
+	const regex = hljs.regex;
+	const IDENT_RE$2 = /[\p{XID_Start}_]\p{XID_Continue}*/u;
+	const RESERVED_WORDS = [
+		"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"
+	];
+	const KEYWORDS$2 = {
+		$pattern: /[A-Za-z]\w+|__\w+__/,
+		keyword: RESERVED_WORDS,
+		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"
+		]
+	};
+	const PROMPT = {
+		className: "meta",
+		begin: /^(>>>|\.\.\.) /
+	};
+	const SUBST = {
+		className: "subst",
+		begin: /\{/,
+		end: /\}/,
+		keywords: KEYWORDS$2,
+		illegal: /#/
+	};
+	const LITERAL_BRACKET = {
+		begin: /\{\{/,
+		relevance: 0
+	};
+	const STRING = {
+		className: "string",
+		contains: [hljs.BACKSLASH_ESCAPE],
+		variants: [
+			{
+				begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,
+				end: /'''/,
+				contains: [hljs.BACKSLASH_ESCAPE, PROMPT],
+				relevance: 10
+			},
+			{
+				begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,
+				end: /"""/,
+				contains: [hljs.BACKSLASH_ESCAPE, PROMPT],
+				relevance: 10
+			},
+			{
+				begin: /([fF][rR]|[rR][fF]|[fF])'''/,
+				end: /'''/,
+				contains: [
+					hljs.BACKSLASH_ESCAPE,
+					PROMPT,
+					LITERAL_BRACKET,
+					SUBST
+				]
+			},
+			{
+				begin: /([fF][rR]|[rR][fF]|[fF])"""/,
+				end: /"""/,
+				contains: [
+					hljs.BACKSLASH_ESCAPE,
+					PROMPT,
+					LITERAL_BRACKET,
+					SUBST
+				]
+			},
+			{
+				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: [
+					hljs.BACKSLASH_ESCAPE,
+					LITERAL_BRACKET,
+					SUBST
+				]
+			},
+			{
+				begin: /([fF][rR]|[rR][fF]|[fF])"/,
+				end: /"/,
+				contains: [
+					hljs.BACKSLASH_ESCAPE,
+					LITERAL_BRACKET,
+					SUBST
+				]
+			},
+			hljs.APOS_STRING_MODE,
+			hljs.QUOTE_STRING_MODE
+		]
+	};
+	const digitpart = "[0-9](_?[0-9])*";
+	const pointfloat = `(\\b(${digitpart}))?\\.(${digitpart})|\\b(${digitpart})\\.`;
+	const lookahead = `\\b|${RESERVED_WORDS.join("|")}`;
+	const NUMBER = {
+		className: "number",
+		relevance: 0,
+		variants: [
+			{ begin: `(\\b(${digitpart})|(${pointfloat}))[eE][+-]?(${digitpart})[jJ]?(?=${lookahead})` },
+			{ begin: `(${pointfloat})[jJ]?` },
+			{ begin: `\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${lookahead})` },
+			{ begin: `\\b0[bB](_?[01])+[lL]?(?=${lookahead})` },
+			{ begin: `\\b0[oO](_?[0-7])+[lL]?(?=${lookahead})` },
+			{ begin: `\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${lookahead})` },
+			{ begin: `\\b(${digitpart})[jJ](?=${lookahead})` }
+		]
+	};
+	const COMMENT_TYPE = {
+		className: "comment",
+		begin: regex.lookahead(/# type:/),
+		end: /$/,
+		keywords: KEYWORDS$2,
+		contains: [{ begin: /# type:/ }, {
+			begin: /#/,
+			end: /\b\B/,
+			endsWithParent: true
+		}]
+	};
+	const PARAMS = {
+		className: "params",
+		variants: [{
+			className: "",
+			begin: /\(\s*\)/,
+			skip: true
+		}, {
+			begin: /\(/,
+			end: /\)/,
+			excludeBegin: true,
+			excludeEnd: true,
+			keywords: KEYWORDS$2,
+			contains: [
+				"self",
+				PROMPT,
+				NUMBER,
+				STRING,
+				hljs.HASH_COMMENT_MODE
+			]
+		}]
+	};
+	SUBST.contains = [
+		STRING,
+		NUMBER,
+		PROMPT
+	];
+	return {
+		name: "Python",
+		aliases: [
+			"py",
+			"gyp",
+			"ipython"
+		],
+		unicodeRegex: true,
+		keywords: KEYWORDS$2,
+		illegal: /(<\/|\?)|=>/,
+		contains: [
+			PROMPT,
+			NUMBER,
+			{ begin: /\bself\b/ },
+			{
+				beginKeywords: "if",
+				relevance: 0
+			},
+			STRING,
+			COMMENT_TYPE,
+			hljs.HASH_COMMENT_MODE,
+			{
+				match: [
+					/\bdef/,
+					/\s+/,
+					IDENT_RE$2
+				],
+				scope: {
+					1: "keyword",
+					3: "title.function"
+				},
+				contains: [PARAMS]
+			},
+			{
+				variants: [{ match: [
+					/\bclass/,
+					/\s+/,
+					IDENT_RE$2,
+					/\s*/,
+					/\(\s*/,
+					IDENT_RE$2,
+					/\s*\)/
+				] }, { match: [
+					/\bclass/,
+					/\s+/,
+					IDENT_RE$2
+				] }],
+				scope: {
+					1: "keyword",
+					3: "title.class",
+					6: "title.class.inherited"
+				}
+			},
+			{
+				className: "meta",
+				begin: /^[\t ]*@/,
+				end: /(?=#)|$/,
+				contains: [
+					NUMBER,
+					PARAMS,
+					STRING
+				]
+			}
+		]
+	};
+}
+var IDENT_RE = "[A-Za-z$_][0-9A-Za-z$_]*";
+var KEYWORDS = [
+	"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"
+];
+var LITERALS = [
+	"true",
+	"false",
+	"null",
+	"undefined",
+	"NaN",
+	"Infinity"
+];
+var TYPES = [
+	"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"
+];
+var ERROR_TYPES = [
+	"Error",
+	"EvalError",
+	"InternalError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"TypeError",
+	"URIError"
+];
+var BUILT_IN_GLOBALS = [
+	"setInterval",
+	"setTimeout",
+	"clearInterval",
+	"clearTimeout",
+	"require",
+	"exports",
+	"eval",
+	"isFinite",
+	"isNaN",
+	"parseFloat",
+	"parseInt",
+	"decodeURI",
+	"decodeURIComponent",
+	"encodeURI",
+	"encodeURIComponent",
+	"escape",
+	"unescape"
+];
+var BUILT_IN_VARIABLES = [
+	"arguments",
+	"this",
+	"super",
+	"console",
+	"window",
+	"document",
+	"localStorage",
+	"sessionStorage",
+	"module",
+	"global"
+];
+var BUILT_INS = [].concat(BUILT_IN_GLOBALS, TYPES, ERROR_TYPES);
+function javascript(hljs) {
+	const regex = hljs.regex;
+	const hasClosingTag = (match, { after }) => {
+		const tag = "</" + match[0].slice(1);
+		return match.input.indexOf(tag, after) !== -1;
+	};
+	const IDENT_RE$1$1 = IDENT_RE;
+	const FRAGMENT = {
+		begin: "<>",
+		end: "</>"
+	};
+	const XML_SELF_CLOSING = /<[A-Za-z0-9\\._:-]+\s*\/>/;
+	const XML_TAG = {
+		begin: /<[A-Za-z0-9\\._:-]+/,
+		end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+		isTrulyOpeningTag: (match, response) => {
+			const afterMatchIndex = match[0].length + match.index;
+			const nextChar = match.input[afterMatchIndex];
+			if (nextChar === "<" || nextChar === ",") {
+				response.ignoreMatch();
+				return;
+			}
+			if (nextChar === ">") {
+				if (!hasClosingTag(match, { after: afterMatchIndex })) response.ignoreMatch();
+			}
+			let m;
+			const afterMatch = match.input.substring(afterMatchIndex);
+			if (m = afterMatch.match(/^\s*=/)) {
+				response.ignoreMatch();
+				return;
+			}
+			if (m = afterMatch.match(/^\s+extends\s+/)) {
+				if (m.index === 0) {
+					response.ignoreMatch();
+					return;
+				}
+			}
+		}
+	};
+	const KEYWORDS$1$1 = {
+		$pattern: IDENT_RE,
+		keyword: KEYWORDS,
+		literal: LITERALS,
+		built_in: BUILT_INS,
+		"variable.language": BUILT_IN_VARIABLES
+	};
+	const decimalDigits = "[0-9](_?[0-9])*";
+	const frac = `\\.(${decimalDigits})`;
+	const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`;
+	const NUMBER = {
+		className: "number",
+		variants: [
+			{ begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))[eE][+-]?(${decimalDigits})\\b` },
+			{ begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\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
+	};
+	const SUBST = {
+		className: "subst",
+		begin: "\\$\\{",
+		end: "\\}",
+		keywords: KEYWORDS$1$1,
+		contains: []
+	};
+	const HTML_TEMPLATE = {
+		begin: "html`",
+		end: "",
+		starts: {
+			end: "`",
+			returnEnd: false,
+			contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+			subLanguage: "xml"
+		}
+	};
+	const CSS_TEMPLATE = {
+		begin: "css`",
+		end: "",
+		starts: {
+			end: "`",
+			returnEnd: false,
+			contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+			subLanguage: "css"
+		}
+	};
+	const GRAPHQL_TEMPLATE = {
+		begin: "gql`",
+		end: "",
+		starts: {
+			end: "`",
+			returnEnd: false,
+			contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+			subLanguage: "graphql"
+		}
+	};
+	const TEMPLATE_STRING = {
+		className: "string",
+		begin: "`",
+		end: "`",
+		contains: [hljs.BACKSLASH_ESCAPE, SUBST]
+	};
+	const COMMENT = {
+		className: "comment",
+		variants: [
+			hljs.COMMENT(/\/\*\*(?!\/)/, "\\*/", {
+				relevance: 0,
+				contains: [{
+					begin: "(?=@[A-Za-z]+)",
+					relevance: 0,
+					contains: [
+						{
+							className: "doctag",
+							begin: "@[A-Za-z]+"
+						},
+						{
+							className: "type",
+							begin: "\\{",
+							end: "\\}",
+							excludeEnd: true,
+							excludeBegin: true,
+							relevance: 0
+						},
+						{
+							className: "variable",
+							begin: IDENT_RE$1$1 + "(?=\\s*(-)|$)",
+							endsParent: true,
+							relevance: 0
+						},
+						{
+							begin: /(?=[^\n])\s/,
+							relevance: 0
+						}
+					]
+				}]
+			}),
+			hljs.C_BLOCK_COMMENT_MODE,
+			hljs.C_LINE_COMMENT_MODE
+		]
+	};
+	const SUBST_INTERNALS = [
+		hljs.APOS_STRING_MODE,
+		hljs.QUOTE_STRING_MODE,
+		HTML_TEMPLATE,
+		CSS_TEMPLATE,
+		GRAPHQL_TEMPLATE,
+		TEMPLATE_STRING,
+		{ match: /\$\d+/ },
+		NUMBER
+	];
+	SUBST.contains = SUBST_INTERNALS.concat({
+		begin: /\{/,
+		end: /\}/,
+		keywords: KEYWORDS$1$1,
+		contains: ["self"].concat(SUBST_INTERNALS)
+	});
+	const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains);
+	const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([{
+		begin: /\(/,
+		end: /\)/,
+		keywords: KEYWORDS$1$1,
+		contains: ["self"].concat(SUBST_AND_COMMENTS)
+	}]);
+	const PARAMS = {
+		className: "params",
+		begin: /\(/,
+		end: /\)/,
+		excludeBegin: true,
+		excludeEnd: true,
+		keywords: KEYWORDS$1$1,
+		contains: PARAMS_CONTAINS
+	};
+	const CLASS_OR_EXTENDS = { variants: [{
+		match: [
+			/class/,
+			/\s+/,
+			IDENT_RE$1$1,
+			/\s+/,
+			/extends/,
+			/\s+/,
+			regex.concat(IDENT_RE$1$1, "(", regex.concat(/\./, IDENT_RE$1$1), ")*")
+		],
+		scope: {
+			1: "keyword",
+			3: "title.class",
+			5: "keyword",
+			7: "title.class.inherited"
+		}
+	}, {
+		match: [
+			/class/,
+			/\s+/,
+			IDENT_RE$1$1
+		],
+		scope: {
+			1: "keyword",
+			3: "title.class"
+		}
+	}] };
+	const CLASS_REFERENCE = {
+		relevance: 0,
+		match: regex.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: { _: [...TYPES, ...ERROR_TYPES] }
+	};
+	const USE_STRICT = {
+		label: "use_strict",
+		className: "meta",
+		relevance: 10,
+		begin: /^\s*['"]use (strict|asm)['"]/
+	};
+	const FUNCTION_DEFINITION = {
+		variants: [{ match: [
+			/function/,
+			/\s+/,
+			IDENT_RE$1$1,
+			/(?=\s*\()/
+		] }, { match: [/function/, /\s*(?=\()/] }],
+		className: {
+			1: "keyword",
+			3: "title.function"
+		},
+		label: "func.def",
+		contains: [PARAMS],
+		illegal: /%/
+	};
+	const UPPER_CASE_CONSTANT = {
+		relevance: 0,
+		match: /\b[A-Z][A-Z_0-9]+\b/,
+		className: "variable.constant"
+	};
+	function noneOf(list) {
+		return regex.concat("(?!", list.join("|"), ")");
+	}
+	const FUNCTION_CALL = {
+		match: regex.concat(/\b/, noneOf([
+			...BUILT_IN_GLOBALS,
+			"super",
+			"import"
+		]), IDENT_RE$1$1, regex.lookahead(/\(/)),
+		className: "title.function",
+		relevance: 0
+	};
+	const PROPERTY_ACCESS = {
+		begin: regex.concat(/\./, regex.lookahead(regex.concat(IDENT_RE$1$1, /(?![0-9A-Za-z$_(])/))),
+		end: IDENT_RE$1$1,
+		excludeBegin: true,
+		keywords: "prototype",
+		className: "property",
+		relevance: 0
+	};
+	const GETTER_OR_SETTER = {
+		match: [
+			/get|set/,
+			/\s+/,
+			IDENT_RE$1$1,
+			/(?=\()/
+		],
+		className: {
+			1: "keyword",
+			3: "title.function"
+		},
+		contains: [{ begin: /\(\)/ }, PARAMS]
+	};
+	const FUNC_LEAD_IN_RE = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + hljs.UNDERSCORE_IDENT_RE + ")\\s*=>";
+	const FUNCTION_VARIABLE = {
+		match: [
+			/const|var|let/,
+			/\s+/,
+			IDENT_RE$1$1,
+			/\s*/,
+			/=\s*/,
+			/(async\s*)?/,
+			regex.lookahead(FUNC_LEAD_IN_RE)
+		],
+		keywords: "async",
+		className: {
+			1: "keyword",
+			3: "title.function"
+		},
+		contains: [PARAMS]
+	};
+	return {
+		name: "JavaScript",
+		aliases: [
+			"js",
+			"jsx",
+			"mjs",
+			"cjs"
+		],
+		keywords: KEYWORDS$1$1,
+		exports: {
+			PARAMS_CONTAINS,
+			CLASS_REFERENCE
+		},
+		illegal: /#(?![$_A-z])/,
+		contains: [
+			hljs.SHEBANG({
+				label: "shebang",
+				binary: "node",
+				relevance: 5
+			}),
+			USE_STRICT,
+			hljs.APOS_STRING_MODE,
+			hljs.QUOTE_STRING_MODE,
+			HTML_TEMPLATE,
+			CSS_TEMPLATE,
+			GRAPHQL_TEMPLATE,
+			TEMPLATE_STRING,
+			COMMENT,
+			{ match: /\$\d+/ },
+			NUMBER,
+			CLASS_REFERENCE,
+			{
+				className: "attr",
+				begin: IDENT_RE$1$1 + regex.lookahead(":"),
+				relevance: 0
+			},
+			FUNCTION_VARIABLE,
+			{
+				begin: "(" + hljs.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+				keywords: "return throw case",
+				relevance: 0,
+				contains: [
+					COMMENT,
+					hljs.REGEXP_MODE,
+					{
+						className: "function",
+						begin: FUNC_LEAD_IN_RE,
+						returnBegin: true,
+						end: "\\s*=>",
+						contains: [{
+							className: "params",
+							variants: [
+								{
+									begin: hljs.UNDERSCORE_IDENT_RE,
+									relevance: 0
+								},
+								{
+									className: null,
+									begin: /\(\s*\)/,
+									skip: true
+								},
+								{
+									begin: /\(/,
+									end: /\)/,
+									excludeBegin: true,
+									excludeEnd: true,
+									keywords: KEYWORDS$1$1,
+									contains: PARAMS_CONTAINS
+								}
+							]
+						}]
+					},
+					{
+						begin: /,/,
+						relevance: 0
+					},
+					{
+						match: /\s+/,
+						relevance: 0
+					},
+					{
+						variants: [
+							{
+								begin: FRAGMENT.begin,
+								end: FRAGMENT.end
+							},
+							{ match: XML_SELF_CLOSING },
+							{
+								begin: XML_TAG.begin,
+								"on:begin": XML_TAG.isTrulyOpeningTag,
+								end: XML_TAG.end
+							}
+						],
+						subLanguage: "xml",
+						contains: [{
+							begin: XML_TAG.begin,
+							end: XML_TAG.end,
+							skip: true,
+							contains: ["self"]
+						}]
+					}
+				]
+			},
+			FUNCTION_DEFINITION,
+			{ beginKeywords: "while if switch catch for" },
+			{
+				begin: "\\b(?!function)" + hljs.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+				returnBegin: true,
+				label: "func.def",
+				contains: [PARAMS, hljs.inherit(hljs.TITLE_MODE, {
+					begin: IDENT_RE$1$1,
+					className: "title.function"
+				})]
+			},
+			{
+				match: /\.\.\./,
+				relevance: 0
+			},
+			PROPERTY_ACCESS,
+			{
+				match: "\\$" + IDENT_RE$1$1,
+				relevance: 0
+			},
+			{
+				match: [/\bconstructor(?=\s*\()/],
+				className: { 1: "title.function" },
+				contains: [PARAMS]
+			},
+			FUNCTION_CALL,
+			UPPER_CASE_CONSTANT,
+			CLASS_OR_EXTENDS,
+			GETTER_OR_SETTER,
+			{ match: /\$[(.]/ }
+		]
+	};
+}
+function typescript(hljs) {
+	const tsLanguage = javascript(hljs);
+	const IDENT_RE$1$1 = IDENT_RE;
+	const TYPES$2 = [
+		"any",
+		"void",
+		"number",
+		"boolean",
+		"string",
+		"object",
+		"never",
+		"symbol",
+		"bigint",
+		"unknown"
+	];
+	const NAMESPACE = {
+		beginKeywords: "namespace",
+		end: /\{/,
+		excludeEnd: true,
+		contains: [tsLanguage.exports.CLASS_REFERENCE]
+	};
+	const INTERFACE = {
+		beginKeywords: "interface",
+		end: /\{/,
+		excludeEnd: true,
+		keywords: {
+			keyword: "interface extends",
+			built_in: TYPES$2
+		},
+		contains: [tsLanguage.exports.CLASS_REFERENCE]
+	};
+	const USE_STRICT = {
+		className: "meta",
+		relevance: 10,
+		begin: /^\s*['"]use strict['"]/
+	};
+	const KEYWORDS$1$1 = {
+		$pattern: IDENT_RE,
+		keyword: KEYWORDS.concat([
+			"type",
+			"namespace",
+			"interface",
+			"public",
+			"private",
+			"protected",
+			"implements",
+			"declare",
+			"abstract",
+			"readonly",
+			"enum",
+			"override"
+		]),
+		literal: LITERALS,
+		built_in: BUILT_INS.concat(TYPES$2),
+		"variable.language": BUILT_IN_VARIABLES
+	};
+	const DECORATOR = {
+		className: "meta",
+		begin: "@" + IDENT_RE$1$1
+	};
+	const swapMode = (mode, label, replacement) => {
+		const indx = mode.contains.findIndex((m) => m.label === label);
+		if (indx === -1) throw new Error("can not find mode to replace");
+		mode.contains.splice(indx, 1, replacement);
+	};
+	Object.assign(tsLanguage.keywords, KEYWORDS$1$1);
+	tsLanguage.exports.PARAMS_CONTAINS.push(DECORATOR);
+	tsLanguage.contains = tsLanguage.contains.concat([
+		DECORATOR,
+		NAMESPACE,
+		INTERFACE
+	]);
+	swapMode(tsLanguage, "shebang", hljs.SHEBANG());
+	swapMode(tsLanguage, "use_strict", USE_STRICT);
+	const functionDeclaration = tsLanguage.contains.find((m) => m.label === "func.def");
+	functionDeclaration.relevance = 0;
+	Object.assign(tsLanguage, {
+		name: "TypeScript",
+		aliases: [
+			"ts",
+			"tsx",
+			"mts",
+			"cts"
+		]
+	});
+	return tsLanguage;
+}
+function xml(hljs) {
+	const regex = hljs.regex;
+	const TAG_NAME_RE = regex.concat(/[\p{L}_]/u, regex.optional(/[\p{L}0-9_.-]*:/u), /[\p{L}0-9_.-]*/u);
+	const XML_IDENT_RE = /[\p{L}0-9._:-]+/u;
+	const XML_ENTITIES = {
+		className: "symbol",
+		begin: /&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/
+	};
+	const XML_META_KEYWORDS = {
+		begin: /\s/,
+		contains: [{
+			className: "keyword",
+			begin: /#?[a-z_][a-z1-9_-]+/,
+			illegal: /\n/
+		}]
+	};
+	const XML_META_PAR_KEYWORDS = hljs.inherit(XML_META_KEYWORDS, {
+		begin: /\(/,
+		end: /\)/
+	});
+	const APOS_META_STRING_MODE = hljs.inherit(hljs.APOS_STRING_MODE, { className: "string" });
+	const QUOTE_META_STRING_MODE = hljs.inherit(hljs.QUOTE_STRING_MODE, { className: "string" });
+	const TAG_INTERNALS = {
+		endsWithParent: true,
+		illegal: /</,
+		relevance: 0,
+		contains: [{
+			className: "attr",
+			begin: XML_IDENT_RE,
+			relevance: 0
+		}, {
+			begin: /=\s*/,
+			relevance: 0,
+			contains: [{
+				className: "string",
+				endsParent: true,
+				variants: [
+					{
+						begin: /"/,
+						end: /"/,
+						contains: [XML_ENTITIES]
+					},
+					{
+						begin: /'/,
+						end: /'/,
+						contains: [XML_ENTITIES]
+					},
+					{ begin: /[^\s"'=<>`]+/ }
+				]
+			}]
+		}]
+	};
+	return {
+		name: "HTML, XML",
+		aliases: [
+			"html",
+			"xhtml",
+			"rss",
+			"atom",
+			"xjb",
+			"xsd",
+			"xsl",
+			"plist",
+			"wsf",
+			"svg"
+		],
+		case_insensitive: true,
+		unicodeRegex: true,
+		contains: [
+			{
+				className: "meta",
+				begin: /<![a-z]/,
+				end: />/,
+				relevance: 10,
+				contains: [
+					XML_META_KEYWORDS,
+					QUOTE_META_STRING_MODE,
+					APOS_META_STRING_MODE,
+					XML_META_PAR_KEYWORDS,
+					{
+						begin: /\[/,
+						end: /\]/,
+						contains: [{
+							className: "meta",
+							begin: /<![a-z]/,
+							end: />/,
+							contains: [
+								XML_META_KEYWORDS,
+								XML_META_PAR_KEYWORDS,
+								QUOTE_META_STRING_MODE,
+								APOS_META_STRING_MODE
+							]
+						}]
+					}
+				]
+			},
+			hljs.COMMENT(/<!--/, /-->/, { relevance: 10 }),
+			{
+				begin: /<!\[CDATA\[/,
+				end: /\]\]>/,
+				relevance: 10
+			},
+			XML_ENTITIES,
+			{
+				className: "meta",
+				end: /\?>/,
+				variants: [{
+					begin: /<\?xml/,
+					relevance: 10,
+					contains: [QUOTE_META_STRING_MODE]
+				}, { begin: /<\?[a-z][a-z0-9]+/ }]
+			},
+			{
+				className: "tag",
+				begin: /<style(?=\s|>)/,
+				end: />/,
+				keywords: { name: "style" },
+				contains: [TAG_INTERNALS],
+				starts: {
+					end: /<\/style>/,
+					returnEnd: true,
+					subLanguage: ["css", "xml"]
+				}
+			},
+			{
+				className: "tag",
+				begin: /<script(?=\s|>)/,
+				end: />/,
+				keywords: { name: "script" },
+				contains: [TAG_INTERNALS],
+				starts: {
+					end: /<\/script>/,
+					returnEnd: true,
+					subLanguage: [
+						"javascript",
+						"handlebars",
+						"xml"
+					]
+				}
+			},
+			{
+				className: "tag",
+				begin: /<>|<\/>/
+			},
+			{
+				className: "tag",
+				begin: regex.concat(/</, regex.lookahead(regex.concat(TAG_NAME_RE, regex.either(/\/>/, />/, /\s/)))),
+				end: /\/?>/,
+				contains: [{
+					className: "name",
+					begin: TAG_NAME_RE,
+					relevance: 0,
+					starts: TAG_INTERNALS
+				}]
+			},
+			{
+				className: "tag",
+				begin: regex.concat(/<\//, regex.lookahead(regex.concat(TAG_NAME_RE, />/))),
+				contains: [{
+					className: "name",
+					begin: TAG_NAME_RE,
+					relevance: 0
+				}, {
+					begin: />/,
+					relevance: 0,
+					endsParent: true
+				}]
+			}
+		]
+	};
+}
+export { bash as a, javascript$1 as i, typescript as n, python as r, xml as t };