litedown 1.0.0

package/dist/index.es.js

@@ -0,0 +1,4013 @@
+import { useCallback, useRef, useState } from "react";
+var __create = Object.create, __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __commonJSMin = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports), __copyProps = (e, t, n, r) => {
+	if (t && typeof t == "object" || typeof t == "function") for (var s = __getOwnPropNames(t), l = 0, u = s.length, d; l < u; l++) d = s[l], !__hasOwnProp.call(e, d) && d !== n && __defProp(e, d, {
+		get: ((e) => t[e]).bind(null, d),
+		enumerable: !(r = __getOwnPropDesc(t, d)) || r.enumerable
+	});
+	return e;
+}, __toESM = (e, t, n) => (n = e == null ? {} : __create(__getProtoOf(e)), __copyProps(t || !e || !e.__esModule ? __defProp(n, "default", {
+	value: e,
+	enumerable: !0
+}) : n, e)), SYMBOLS = {
+	alpha: "α",
+	beta: "β",
+	gamma: "γ",
+	delta: "δ",
+	epsilon: "ε",
+	varepsilon: "ɛ",
+	zeta: "ζ",
+	eta: "η",
+	theta: "θ",
+	vartheta: "ϑ",
+	iota: "ι",
+	kappa: "κ",
+	lambda: "λ",
+	mu: "μ",
+	nu: "ν",
+	xi: "ξ",
+	pi: "π",
+	varpi: "ϖ",
+	rho: "ρ",
+	varrho: "ϱ",
+	sigma: "σ",
+	varsigma: "ς",
+	tau: "τ",
+	upsilon: "υ",
+	phi: "ϕ",
+	varphi: "φ",
+	chi: "χ",
+	psi: "ψ",
+	omega: "ω",
+	Gamma: "Γ",
+	Delta: "Δ",
+	Theta: "Θ",
+	Lambda: "Λ",
+	Xi: "Ξ",
+	Pi: "Π",
+	Sigma: "Σ",
+	Upsilon: "Υ",
+	Phi: "Φ",
+	Psi: "Ψ",
+	Omega: "Ω",
+	times: "×",
+	div: "÷",
+	cdot: "·",
+	pm: "±",
+	mp: "∓",
+	leq: "≤",
+	le: "≤",
+	geq: "≥",
+	ge: "≥",
+	neq: "≠",
+	ne: "≠",
+	approx: "≈",
+	equiv: "≡",
+	sim: "∼",
+	simeq: "≃",
+	ll: "≪",
+	gg: "≫",
+	subset: "⊂",
+	supset: "⊃",
+	subseteq: "⊆",
+	supseteq: "⊇",
+	in: "∈",
+	notin: "∉",
+	cup: "∪",
+	cap: "∩",
+	setminus: "∖",
+	land: "∧",
+	lor: "∨",
+	lnot: "¬",
+	neg: "¬",
+	forall: "∀",
+	exists: "∃",
+	nexists: "∄",
+	Rightarrow: "⇒",
+	Leftarrow: "⇐",
+	Leftrightarrow: "⇔",
+	rightarrow: "→",
+	to: "→",
+	leftarrow: "←",
+	leftrightarrow: "↔",
+	uparrow: "↑",
+	downarrow: "↓",
+	mapsto: "↦",
+	implies: "⟹",
+	iff: "⟺",
+	infty: "∞",
+	infinity: "∞",
+	partial: "∂",
+	nabla: "∇",
+	emptyset: "∅",
+	varnothing: "∅",
+	ldots: "…",
+	cdots: "⋯",
+	vdots: "⋮",
+	ddots: "⋱",
+	prime: "′",
+	angle: "∠",
+	triangle: "△",
+	star: "⋆",
+	ast: "∗",
+	circ: "∘",
+	bullet: "∙",
+	dagger: "†",
+	ddagger: "‡",
+	hbar: "ℏ",
+	ell: "ℓ",
+	Re: "ℜ",
+	Im: "ℑ",
+	aleph: "ℵ",
+	quad: " ",
+	qquad: "  ",
+	",": " ",
+	";": " ",
+	"!": "",
+	hat: "̂",
+	bar: "̄",
+	dot: "̇",
+	ddot: "̈",
+	tilde: "̃",
+	vec: "⃗"
+}, LARGE_OPS = {
+	sum: "∑",
+	prod: "∏",
+	coprod: "∐",
+	int: "∫",
+	iint: "∬",
+	iiint: "∭",
+	oint: "∮",
+	bigcup: "⋃",
+	bigcap: "⋂",
+	bigoplus: "⨁",
+	bigotimes: "⨂",
+	bigvee: "⋁",
+	bigwedge: "⋀",
+	lim: "lim",
+	sup: "sup",
+	inf: "inf",
+	max: "max",
+	min: "min",
+	arg: "arg",
+	det: "det",
+	gcd: "gcd",
+	log: "log",
+	ln: "ln",
+	exp: "exp",
+	sin: "sin",
+	cos: "cos",
+	tan: "tan",
+	sec: "sec",
+	csc: "csc",
+	cot: "cot",
+	sinh: "sinh",
+	cosh: "cosh",
+	tanh: "tanh",
+	arcsin: "arcsin",
+	arccos: "arccos",
+	arctan: "arctan",
+	Pr: "Pr",
+	hom: "hom",
+	ker: "ker",
+	dim: "dim",
+	deg: "deg"
+}, DELIMITERS = {
+	"(": "(",
+	")": ")",
+	"[": "[",
+	"]": "]",
+	"\\{": "{",
+	"\\}": "}",
+	lbrace: "{",
+	rbrace: "}",
+	langle: "⟨",
+	rangle: "⟩",
+	lfloor: "⌊",
+	rfloor: "⌋",
+	lceil: "⌈",
+	rceil: "⌉",
+	"|": "|",
+	"\\|": "‖",
+	vert: "|",
+	Vert: "‖",
+	".": ""
+}, FONT_COMMANDS = {
+	mathbb: "double-struck",
+	mathbf: "bold",
+	mathit: "italic",
+	mathrm: "normal",
+	mathcal: "script",
+	mathfrak: "fraktur",
+	mathsf: "sans-serif",
+	mathtt: "monospace",
+	boldsymbol: "bold-italic",
+	textbf: "bold",
+	textit: "italic",
+	textrm: "normal",
+	text: "normal"
+}, DOUBLE_STRUCK = {
+	A: "𝔸",
+	B: "𝔹",
+	C: "ℂ",
+	D: "𝔻",
+	E: "𝔼",
+	F: "𝔽",
+	G: "𝔾",
+	H: "ℍ",
+	I: "𝕀",
+	J: "𝕁",
+	K: "𝕂",
+	L: "𝕃",
+	M: "𝕄",
+	N: "ℕ",
+	O: "𝕆",
+	P: "ℙ",
+	Q: "ℚ",
+	R: "ℝ",
+	S: "𝕊",
+	T: "𝕋",
+	U: "𝕌",
+	V: "𝕍",
+	W: "𝕎",
+	X: "𝕏",
+	Y: "𝕐",
+	Z: "ℤ",
+	0: "𝟘",
+	1: "𝟙",
+	2: "𝟚",
+	3: "𝟛",
+	4: "𝟜",
+	5: "𝟝",
+	6: "𝟞",
+	7: "𝟟",
+	8: "𝟠",
+	9: "𝟡"
+};
+function escapeHtml$2(e) {
+	return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function parseGroup(e, t) {
+	if (t >= e.length) return {
+		content: "",
+		end: t
+	};
+	if (e[t] === "{") {
+		let n = 1, r = t + 1;
+		for (; r < e.length && n > 0;) e[r] === "{" ? n++ : e[r] === "}" && n--, r++;
+		return {
+			content: e.slice(t + 1, r - 1),
+			end: r
+		};
+	}
+	if (e[t] === "\\") {
+		let n = e.slice(t).match(/^\\([a-zA-Z]+|.)/);
+		if (n) return {
+			content: e.slice(t, t + n[0].length),
+			end: t + n[0].length
+		};
+	}
+	return {
+		content: e[t],
+		end: t + 1
+	};
+}
+function latexToMathML(e) {
+	return tokensToMathML(tokenize(e.trim()));
+}
+function tokenize(e) {
+	let t = [], n = 0;
+	for (; n < e.length;) {
+		let r = e[n];
+		if (r === " " || r === "	") {
+			n++;
+			continue;
+		}
+		if (r === "\\" && e[n + 1] === "\\") {
+			t.push({
+				type: "newline",
+				value: "\\\\"
+			}), n += 2;
+			continue;
+		}
+		if (r === "&") {
+			t.push({
+				type: "ampersand",
+				value: "&"
+			}), n++;
+			continue;
+		}
+		if (r === "^") {
+			n++;
+			let r = parseGroup(e, n);
+			t.push({
+				type: "superscript",
+				value: r.content
+			}), n = r.end;
+			continue;
+		}
+		if (r === "_") {
+			n++;
+			let r = parseGroup(e, n);
+			t.push({
+				type: "subscript",
+				value: r.content
+			}), n = r.end;
+			continue;
+		}
+		if (r === "{") {
+			let r = 1, i = n + 1;
+			for (; i < e.length && r > 0;) e[i] === "{" ? r++ : e[i] === "}" && r--, i++;
+			t.push({
+				type: "group",
+				value: e.slice(n + 1, i - 1)
+			}), n = i;
+			continue;
+		}
+		if (r === "\\") {
+			let r = e.slice(n).match(/^\\([a-zA-Z]+|[^a-zA-Z])/);
+			if (r) {
+				t.push({
+					type: "command",
+					value: r[1]
+				}), n += r[0].length;
+				continue;
+			}
+		}
+		t.push({
+			type: "text",
+			value: r
+		}), n++;
+	}
+	return t;
+}
+function tokensToMathML(e) {
+	let t = "", n = 0;
+	for (; n < e.length;) {
+		let r = e[n], i = e[n + 1];
+		if (r.type === "command") {
+			let a = r.value;
+			if (FONT_COMMANDS[a]) {
+				let e = FONT_COMMANDS[a];
+				if (i) {
+					let r = (i.type, i.value);
+					if (a === "mathbb") {
+						let e = r.split("").map((e) => DOUBLE_STRUCK[e] || e).join("");
+						t += `<mi>${e}</mi>`;
+					} else a === "text" || a === "textrm" ? t += `<mtext>${escapeHtml$2(r)}</mtext>` : t += `<mi mathvariant="${e}">${escapeHtml$2(r)}</mi>`;
+					n += 2;
+					continue;
+				}
+			}
+			if (a === "frac" || a === "dfrac" || a === "tfrac") {
+				let r = e[n + 1], i = e[n + 2];
+				if (r && i) {
+					let e = r.type === "group" ? latexToMathML(r.value) : renderToken(r), a = i.type === "group" ? latexToMathML(i.value) : renderToken(i);
+					t += `<mfrac>${e}${a}</mfrac>`, n += 3;
+					continue;
+				}
+			}
+			if (a === "sqrt" && i && i.type === "group") {
+				let e = latexToMathML(i.value);
+				t += `<msqrt>${e}</msqrt>`, n += 2;
+				continue;
+			}
+			if ((a === "overline" || a === "bar") && i) {
+				let e = i.type === "group" ? latexToMathML(i.value) : renderToken(i);
+				t += `<mover>${e}<mo>¯</mo></mover>`, n += 2;
+				continue;
+			}
+			if (a === "underline" && i) {
+				let e = i.type === "group" ? latexToMathML(i.value) : renderToken(i);
+				t += `<munder>${e}<mo>_</mo></munder>`, n += 2;
+				continue;
+			}
+			if ((a === "hat" || a === "widehat") && i) {
+				let e = i.type === "group" ? latexToMathML(i.value) : renderToken(i);
+				t += `<mover>${e}<mo>^</mo></mover>`, n += 2;
+				continue;
+			}
+			if ((a === "tilde" || a === "widetilde") && i) {
+				let e = i.type === "group" ? latexToMathML(i.value) : renderToken(i);
+				t += `<mover>${e}<mo>˜</mo></mover>`, n += 2;
+				continue;
+			}
+			if (a === "vec" && i) {
+				let e = i.type === "group" ? latexToMathML(i.value) : renderToken(i);
+				t += `<mover>${e}<mo>→</mo></mover>`, n += 2;
+				continue;
+			}
+			if (a === "dot" && i) {
+				let e = i.type === "group" ? latexToMathML(i.value) : renderToken(i);
+				t += `<mover>${e}<mo>˙</mo></mover>`, n += 2;
+				continue;
+			}
+			if (a === "ddot" && i) {
+				let e = i.type === "group" ? latexToMathML(i.value) : renderToken(i);
+				t += `<mover>${e}<mo>¨</mo></mover>`, n += 2;
+				continue;
+			}
+			if (a === "left") {
+				let r = 1, a = n + 1, o = "";
+				i && (i.type === "text" ? (o = DELIMITERS[i.value] || i.value, a = n + 2) : i.type === "command" && (o = DELIMITERS[i.value] || SYMBOLS[i.value] || i.value, a = n + 2));
+				let s = "", c = [];
+				for (; a < e.length;) {
+					if (e[a].type === "command" && e[a].value === "left" && r++, e[a].type === "command" && e[a].value === "right" && (r--, r === 0)) {
+						if (a + 1 < e.length) {
+							let t = e[a + 1];
+							t.type === "text" ? s = DELIMITERS[t.value] || t.value : t.type === "command" && (s = DELIMITERS[t.value] || SYMBOLS[t.value] || t.value), a += 2;
+						} else a++;
+						break;
+					}
+					r > 0 && c.push(e[a]), a++;
+				}
+				let l = tokensToMathML(c);
+				t += `<mrow><mo stretchy="true">${o}</mo>${l}<mo stretchy="true">${s}</mo></mrow>`, n = a;
+				continue;
+			}
+			if (a === "right") {
+				n++;
+				continue;
+			}
+			if (LARGE_OPS[a]) {
+				let r = LARGE_OPS[a], o = /^[a-z]+$/i.test(r), s = "", c = "", l = 1;
+				i && i.type === "subscript" ? (s = latexToMathML(i.value), l++, e[n + l] && e[n + l].type === "superscript" && (c = latexToMathML(e[n + l].value), l++)) : i && i.type === "superscript" && (c = latexToMathML(i.value), l++, e[n + l] && e[n + l].type === "subscript" && (s = latexToMathML(e[n + l].value), l++));
+				let u = o ? `<mo>${r}</mo>` : `<mo largeop="true">${r}</mo>`;
+				s && c ? t += `<munderover>${u}${s}${c}</munderover>` : s ? t += `<munder>${u}${s}</munder>` : c ? t += `<mover>${u}${c}</mover>` : t += u, n += l;
+				continue;
+			}
+			if (a === "begin" && i && i.type === "group") {
+				let r = i.value, a = n + 2, o = 1, s = [];
+				for (; a < e.length;) {
+					if (e[a].type === "command" && e[a].value === "begin" && o++, e[a].type === "command" && e[a].value === "end" && (o--, o === 0)) {
+						a += 2;
+						break;
+					}
+					s.push(e[a]), a++;
+				}
+				r === "matrix" || r === "pmatrix" || r === "bmatrix" || r === "vmatrix" || r === "Bmatrix" || r === "Vmatrix" ? t += renderMatrix(s, r) : r === "cases" ? t += renderCases(s) : r === "aligned" || r === "align" || r === "align*" ? t += renderAligned(s) : t += tokensToMathML(s), n = a;
+				continue;
+			}
+			if (a === "end") {
+				n += 2;
+				continue;
+			}
+			if (a === "binom") {
+				let r = e[n + 1], i = e[n + 2];
+				if (r && i) {
+					let e = r.type === "group" ? latexToMathML(r.value) : renderToken(r), a = i.type === "group" ? latexToMathML(i.value) : renderToken(i);
+					t += `<mrow><mo></mo><mfrac linethickness="0">${e}${a}</mfrac><mo></mo></mrow>`, n += 3;
+					continue;
+				}
+			}
+			if (a === "color" && i && i.type === "group") {
+				let r = i.value, a = e[n + 2];
+				if (a) {
+					let e = a.type === "group" ? latexToMathML(a.value) : renderToken(a);
+					t += `<mstyle mathcolor="${escapeHtml$2(r)}">${e}</mstyle>`, n += 3;
+				} else n += 2;
+				continue;
+			}
+			if (a === "boxed" && i) {
+				let e = i.type === "group" ? latexToMathML(i.value) : renderToken(i);
+				t += `<menclose notation="box">${e}</menclose>`, n += 2;
+				continue;
+			}
+			if (a === "cancel" && i) {
+				let e = i.type === "group" ? latexToMathML(i.value) : renderToken(i);
+				t += `<menclose notation="updiagonalstrike">${e}</menclose>`, n += 2;
+				continue;
+			}
+			if (a === "operatorname" && i && i.type === "group") {
+				t += `<mo>${escapeHtml$2(i.value)}</mo>`, n += 2;
+				continue;
+			}
+			if (a === "quad" || a === "qquad" || a === "," || a === ";" || a === "!" || a === " ") {
+				t += `<mspace width="${a === "qquad" ? "2em" : a === "quad" ? "1em" : a === ";" ? "0.28em" : a === "," ? "0.17em" : "0"}"/>`, n++;
+				continue;
+			}
+			if (SYMBOLS[a]) {
+				t += `<mo>${SYMBOLS[a]}</mo>`, n++;
+				continue;
+			}
+			if (DELIMITERS[a]) {
+				t += `<mo>${DELIMITERS[a]}</mo>`, n++;
+				continue;
+			}
+			t += `<mo>\\${escapeHtml$2(a)}</mo>`, n++;
+			continue;
+		}
+		if (r.type === "text" || r.type === "group") {
+			let a = r.type === "group" ? `<mrow>${latexToMathML(r.value)}</mrow>` : renderChar(r.value), o = "", s = "", c = 1;
+			i && i.type === "subscript" ? (o = latexToMathML(i.value), c++, e[n + c] && e[n + c].type === "superscript" && (s = latexToMathML(e[n + c].value), c++)) : i && i.type === "superscript" && (s = latexToMathML(i.value), c++, e[n + c] && e[n + c].type === "subscript" && (o = latexToMathML(e[n + c].value), c++)), o && s ? t += `<msubsup>${a}${o}${s}</msubsup>` : o ? t += `<msub>${a}${o}</msub>` : s ? t += `<msup>${a}${s}</msup>` : t += a, n += c;
+			continue;
+		}
+		if (r.type === "subscript") {
+			let e = latexToMathML(r.value);
+			t += `<msub><mrow></mrow>${e}</msub>`, n++;
+			continue;
+		}
+		if (r.type === "superscript") {
+			let e = latexToMathML(r.value);
+			t += `<msup><mrow></mrow>${e}</msup>`, n++;
+			continue;
+		}
+		if (r.type === "newline") {
+			t += "<mspace linebreak=\"newline\"/>", n++;
+			continue;
+		}
+		if (r.type === "ampersand") {
+			n++;
+			continue;
+		}
+		t += renderToken(r), n++;
+	}
+	return t;
+}
+function renderChar(e) {
+	return /[0-9]/.test(e) ? `<mn>${e}</mn>` : /[a-zA-Z]/.test(e) ? `<mi>${e}</mi>` : [
+		"+",
+		"-",
+		"=",
+		"<",
+		">",
+		"!",
+		"/",
+		"|",
+		",",
+		".",
+		":",
+		"?"
+	].includes(e) ? `<mo>${escapeHtml$2(e)}</mo>` : e === "(" || e === ")" || e === "[" || e === "]" ? `<mo>${e}</mo>` : `<mo>${escapeHtml$2(e)}</mo>`;
+}
+function renderToken(e) {
+	return e.type === "text" ? renderChar(e.value) : e.type === "group" ? `<mrow>${latexToMathML(e.value)}</mrow>` : e.type === "command" ? SYMBOLS[e.value] ? `<mo>${SYMBOLS[e.value]}</mo>` : LARGE_OPS[e.value] ? `<mo>${LARGE_OPS[e.value]}</mo>` : `<mi>${escapeHtml$2(e.value)}</mi>` : "";
+}
+function renderMatrix(e, t) {
+	let n = [[]], r = n[0];
+	for (let t of e) t.type === "newline" ? (n.push([]), r = n[n.length - 1]) : r.push(t);
+	let i = "";
+	for (let e of n) {
+		if (e.length === 0) continue;
+		let t = [[]], n = t[0];
+		for (let r of e) r.type === "ampersand" ? (t.push([]), n = t[t.length - 1]) : n.push(r);
+		i += "<mtr>";
+		for (let e of t) i += `<mtd columnalign="center">${tokensToMathML(e)}</mtd>`;
+		i += "</mtr>";
+	}
+	let a = `(<mtable columnspacing="0.5em" rowspacing="0.2em">${i}</mtable>)`;
+	switch (t) {
+		case "pmatrix": return `<mrow><mo></mo>${a}<mo></mo></mrow>`;
+		case "bmatrix": return `<mrow><mo>[</mo>${a}<mo>]</mo></mrow>`;
+		case "vmatrix": return `<mrow><mo>|</mo>${a}<mo>|</mo></mrow>`;
+		case "Bmatrix": return `<mrow><mo>{</mo>${a}<mo>}</mo></mrow>`;
+		case "Vmatrix": return `<mrow><mo>‖</mo>${a}<mo>‖</mo></mrow>`;
+		default: return a;
+	}
+}
+function renderCases(e) {
+	let t = [[]], n = t[0];
+	for (let r of e) r.type === "newline" ? (t.push([]), n = t[t.length - 1]) : n.push(r);
+	let r = "";
+	for (let e of t) {
+		if (e.length === 0) continue;
+		let t = [[]], n = t[0];
+		for (let r of e) r.type === "ampersand" ? (t.push([]), n = t[t.length - 1]) : n.push(r);
+		r += "<mtr>";
+		for (let e of t) r += `<mtd columnalign="left" rowalign="center">${tokensToMathML(e)}</mtd>`;
+		r += "</mtr>";
+	}
+	return `<mrow><mo stretchy="true" minsize="1.2em">{</mo><mtable columnalign="left" columnspacing="0em" rowspacing="0.1em">${r}</mtable></mrow>`;
+}
+function renderAligned(e) {
+	let t = [[]], n = t[0];
+	for (let r of e) r.type === "newline" ? (t.push([]), n = t[t.length - 1]) : n.push(r);
+	let r = "";
+	for (let e of t) {
+		if (e.length === 0) continue;
+		let t = [[]], n = t[0];
+		for (let r of e) r.type === "ampersand" ? (t.push([]), n = t[t.length - 1]) : n.push(r);
+		r += "<mtr>";
+		for (let e = 0; e < t.length; e++) {
+			let n = e % 2 == 0 ? "right" : "left";
+			r += `<mtd columnalign="${n}">${tokensToMathML(t[e])}</mtd>`;
+		}
+		r += "</mtr>";
+	}
+	return `<mtable columnalign="right left" columnspacing="1em" rowspacing="0.3em">${r}</mtable>`;
+}
+function renderInlineMath(e) {
+	try {
+		return `<math xmlns="http://www.w3.org/1998/Math/MathML">${latexToMathML(e)}</math>`;
+	} catch {
+		return `<code class="math-error">${escapeHtml$2(e)}</code>`;
+	}
+}
+function renderDisplayMath(e) {
+	try {
+		return `<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">${latexToMathML(e)}</math>`;
+	} catch {
+		return `<pre class="math-error"><code>${escapeHtml$2(e)}</code></pre>`;
+	}
+}
+var import_prism = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((e, t) => {
+	/**
+	* Prism: Lightweight, robust, elegant syntax highlighting
+	*
+	* @license MIT <https://opensource.org/licenses/MIT>
+	* @author Lea Verou <https://lea.verou.me>
+	* @namespace
+	* @public
+	*/
+	var n = function(e) {
+		var t = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, n = 0, r = {}, i = {
+			manual: e.Prism && e.Prism.manual,
+			disableWorkerMessageHandler: e.Prism && e.Prism.disableWorkerMessageHandler,
+			util: {
+				encode: function e(t) {
+					return t instanceof a ? new a(t.type, e(t.content), t.alias) : Array.isArray(t) ? t.map(e) : t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\u00a0/g, " ");
+				},
+				type: function(e) {
+					return Object.prototype.toString.call(e).slice(8, -1);
+				},
+				objId: function(e) {
+					return e.__id || Object.defineProperty(e, "__id", { value: ++n }), e.__id;
+				},
+				clone: function e(t, n) {
+					n ||= {};
+					var r, a;
+					switch (i.util.type(t)) {
+						case "Object":
+							if (a = i.util.objId(t), n[a]) return n[a];
+							for (var o in r = {}, n[a] = r, t) t.hasOwnProperty(o) && (r[o] = e(t[o], n));
+							return r;
+						case "Array": return a = i.util.objId(t), n[a] ? n[a] : (r = [], n[a] = r, t.forEach(function(t, i) {
+							r[i] = e(t, n);
+						}), r);
+						default: return t;
+					}
+				},
+				getLanguage: function(e) {
+					for (; e;) {
+						var n = t.exec(e.className);
+						if (n) return n[1].toLowerCase();
+						e = e.parentElement;
+					}
+					return "none";
+				},
+				setLanguage: function(e, n) {
+					e.className = e.className.replace(RegExp(t, "gi"), ""), e.classList.add("language-" + n);
+				},
+				currentScript: function() {
+					if (typeof document > "u") return null;
+					if (document.currentScript && document.currentScript.tagName === "SCRIPT") return document.currentScript;
+					try {
+						throw Error();
+					} catch (r) {
+						var e = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(r.stack) || [])[1];
+						if (e) {
+							var t = document.getElementsByTagName("script");
+							for (var n in t) if (t[n].src == e) return t[n];
+						}
+						return null;
+					}
+				},
+				isActive: function(e, t, n) {
+					for (var r = "no-" + t; e;) {
+						var i = e.classList;
+						if (i.contains(t)) return !0;
+						if (i.contains(r)) return !1;
+						e = e.parentElement;
+					}
+					return !!n;
+				}
+			},
+			languages: {
+				plain: r,
+				plaintext: r,
+				text: r,
+				txt: r,
+				extend: function(e, t) {
+					var n = i.util.clone(i.languages[e]);
+					for (var r in t) n[r] = t[r];
+					return n;
+				},
+				insertBefore: function(e, t, n, r) {
+					r ||= i.languages;
+					var a = r[e], o = {};
+					for (var s in a) if (a.hasOwnProperty(s)) {
+						if (s == t) for (var c in n) n.hasOwnProperty(c) && (o[c] = n[c]);
+						n.hasOwnProperty(s) || (o[s] = a[s]);
+					}
+					var l = r[e];
+					return r[e] = o, i.languages.DFS(i.languages, function(t, n) {
+						n === l && t != e && (this[t] = o);
+					}), o;
+				},
+				DFS: function e(t, n, r, a) {
+					a ||= {};
+					var o = i.util.objId;
+					for (var s in t) if (t.hasOwnProperty(s)) {
+						n.call(t, s, t[s], r || s);
+						var c = t[s], l = i.util.type(c);
+						l === "Object" && !a[o(c)] ? (a[o(c)] = !0, e(c, n, null, a)) : l === "Array" && !a[o(c)] && (a[o(c)] = !0, e(c, n, s, a));
+					}
+				}
+			},
+			plugins: {},
+			highlightAll: function(e, t) {
+				i.highlightAllUnder(document, e, t);
+			},
+			highlightAllUnder: function(e, t, n) {
+				var r = {
+					callback: n,
+					container: e,
+					selector: "code[class*=\"language-\"], [class*=\"language-\"] code, code[class*=\"lang-\"], [class*=\"lang-\"] code"
+				};
+				i.hooks.run("before-highlightall", r), r.elements = Array.prototype.slice.apply(r.container.querySelectorAll(r.selector)), i.hooks.run("before-all-elements-highlight", r);
+				for (var a = 0, o; o = r.elements[a++];) i.highlightElement(o, t === !0, r.callback);
+			},
+			highlightElement: function(t, n, r) {
+				var a = i.util.getLanguage(t), o = i.languages[a];
+				i.util.setLanguage(t, a);
+				var s = t.parentElement;
+				s && s.nodeName.toLowerCase() === "pre" && i.util.setLanguage(s, a);
+				var c = {
+					element: t,
+					language: a,
+					grammar: o,
+					code: t.textContent
+				};
+				function l(e) {
+					c.highlightedCode = e, i.hooks.run("before-insert", c), c.element.innerHTML = c.highlightedCode, i.hooks.run("after-highlight", c), i.hooks.run("complete", c), r && r.call(c.element);
+				}
+				if (i.hooks.run("before-sanity-check", c), s = c.element.parentElement, s && s.nodeName.toLowerCase() === "pre" && !s.hasAttribute("tabindex") && s.setAttribute("tabindex", "0"), !c.code) {
+					i.hooks.run("complete", c), r && r.call(c.element);
+					return;
+				}
+				if (i.hooks.run("before-highlight", c), !c.grammar) {
+					l(i.util.encode(c.code));
+					return;
+				}
+				if (n && e.Worker) {
+					var u = new Worker(i.filename);
+					u.onmessage = function(e) {
+						l(e.data);
+					}, u.postMessage(JSON.stringify({
+						language: c.language,
+						code: c.code,
+						immediateClose: !0
+					}));
+				} else l(i.highlight(c.code, c.grammar, c.language));
+			},
+			highlight: function(e, t, n) {
+				var r = {
+					code: e,
+					grammar: t,
+					language: n
+				};
+				if (i.hooks.run("before-tokenize", r), !r.grammar) throw Error("The language \"" + r.language + "\" has no grammar.");
+				return r.tokens = i.tokenize(r.code, r.grammar), i.hooks.run("after-tokenize", r), a.stringify(i.util.encode(r.tokens), r.language);
+			},
+			tokenize: function(e, t) {
+				var n = t.rest;
+				if (n) {
+					for (var r in n) t[r] = n[r];
+					delete t.rest;
+				}
+				var i = new c();
+				return l(i, i.head, e), s(e, i, t, i.head, 0), d(i);
+			},
+			hooks: {
+				all: {},
+				add: function(e, t) {
+					var n = i.hooks.all;
+					n[e] = n[e] || [], n[e].push(t);
+				},
+				run: function(e, t) {
+					var n = i.hooks.all[e];
+					if (!(!n || !n.length)) for (var r = 0, a; a = n[r++];) a(t);
+				}
+			},
+			Token: a
+		};
+		e.Prism = i;
+		function a(e, t, n, r) {
+			this.type = e, this.content = t, this.alias = n, this.length = (r || "").length | 0;
+		}
+		a.stringify = function e(t, n) {
+			if (typeof t == "string") return t;
+			if (Array.isArray(t)) {
+				var r = "";
+				return t.forEach(function(t) {
+					r += e(t, n);
+				}), r;
+			}
+			var a = {
+				type: t.type,
+				content: e(t.content, n),
+				tag: "span",
+				classes: ["token", t.type],
+				attributes: {},
+				language: n
+			}, o = t.alias;
+			o && (Array.isArray(o) ? Array.prototype.push.apply(a.classes, o) : a.classes.push(o)), i.hooks.run("wrap", a);
+			var s = "";
+			for (var c in a.attributes) s += " " + c + "=\"" + (a.attributes[c] || "").replace(/"/g, "&quot;") + "\"";
+			return "<" + a.tag + " class=\"" + a.classes.join(" ") + "\"" + s + ">" + a.content + "</" + a.tag + ">";
+		};
+		function o(e, t, n, r) {
+			e.lastIndex = t;
+			var i = e.exec(n);
+			if (i && r && i[1]) {
+				var a = i[1].length;
+				i.index += a, i[0] = i[0].slice(a);
+			}
+			return i;
+		}
+		function s(e, t, n, r, c, d) {
+			for (var f in n) if (!(!n.hasOwnProperty(f) || !n[f])) {
+				var p = n[f];
+				p = Array.isArray(p) ? p : [p];
+				for (var m = 0; m < p.length; ++m) {
+					if (d && d.cause == f + "," + m) return;
+					var h = p[m], g = h.inside, _ = !!h.lookbehind, v = !!h.greedy, y = h.alias;
+					if (v && !h.pattern.global) {
+						var b = h.pattern.toString().match(/[imsuy]*$/)[0];
+						h.pattern = RegExp(h.pattern.source, b + "g");
+					}
+					for (var x = h.pattern || h, S = r.next, C = c; S !== t.tail && !(d && C >= d.reach); C += S.value.length, S = S.next) {
+						var w = S.value;
+						if (t.length > e.length) return;
+						if (!(w instanceof a)) {
+							var T = 1, E;
+							if (v) {
+								if (E = o(x, C, e, _), !E || E.index >= e.length) break;
+								var D = E.index, O = E.index + E[0].length, k = C;
+								for (k += S.value.length; D >= k;) S = S.next, k += S.value.length;
+								if (k -= S.value.length, C = k, S.value instanceof a) continue;
+								for (var A = S; A !== t.tail && (k < O || typeof A.value == "string"); A = A.next) T++, k += A.value.length;
+								T--, w = e.slice(C, k), E.index -= C;
+							} else if (E = o(x, 0, w, _), !E) continue;
+							var D = E.index, j = E[0], M = w.slice(0, D), N = w.slice(D + j.length), P = C + w.length;
+							d && P > d.reach && (d.reach = P);
+							var F = S.prev;
+							M && (F = l(t, F, M), C += M.length), u(t, F, T);
+							var I = new a(f, g ? i.tokenize(j, g) : j, y, j);
+							if (S = l(t, F, I), N && l(t, S, N), T > 1) {
+								var L = {
+									cause: f + "," + m,
+									reach: P
+								};
+								s(e, t, n, S.prev, C, L), d && L.reach > d.reach && (d.reach = L.reach);
+							}
+						}
+					}
+				}
+			}
+		}
+		function c() {
+			var e = {
+				value: null,
+				prev: null,
+				next: null
+			}, t = {
+				value: null,
+				prev: e,
+				next: null
+			};
+			e.next = t, this.head = e, this.tail = t, this.length = 0;
+		}
+		function l(e, t, n) {
+			var r = t.next, i = {
+				value: n,
+				prev: t,
+				next: r
+			};
+			return t.next = i, r.prev = i, e.length++, i;
+		}
+		function u(e, t, n) {
+			for (var r = t.next, i = 0; i < n && r !== e.tail; i++) r = r.next;
+			t.next = r, r.prev = t, e.length -= i;
+		}
+		function d(e) {
+			for (var t = [], n = e.head.next; n !== e.tail;) t.push(n.value), n = n.next;
+			return t;
+		}
+		if (!e.document) return e.addEventListener && (i.disableWorkerMessageHandler || e.addEventListener("message", function(t) {
+			var n = JSON.parse(t.data), r = n.language, a = n.code, o = n.immediateClose;
+			e.postMessage(i.highlight(a, i.languages[r], r)), o && e.close();
+		}, !1)), i;
+		var f = i.util.currentScript();
+		f && (i.filename = f.src, f.hasAttribute("data-manual") && (i.manual = !0));
+		function p() {
+			i.manual || i.highlightAll();
+		}
+		if (!i.manual) {
+			var m = document.readyState;
+			m === "loading" || m === "interactive" && f && f.defer ? document.addEventListener("DOMContentLoaded", p) : window.requestAnimationFrame ? window.requestAnimationFrame(p) : window.setTimeout(p, 16);
+		}
+		return i;
+	}(typeof window < "u" ? window : typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? self : {});
+	t !== void 0 && t.exports && (t.exports = n), typeof global < "u" && (global.Prism = n), n.languages.markup = {
+		comment: {
+			pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+			greedy: !0
+		},
+		prolog: {
+			pattern: /<\?[\s\S]+?\?>/,
+			greedy: !0
+		},
+		doctype: {
+			pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+			greedy: !0,
+			inside: {
+				"internal-subset": {
+					pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+					lookbehind: !0,
+					greedy: !0,
+					inside: null
+				},
+				string: {
+					pattern: /"[^"]*"|'[^']*'/,
+					greedy: !0
+				},
+				punctuation: /^<!|>$|[[\]]/,
+				"doctype-tag": /^DOCTYPE/i,
+				name: /[^\s<>'"]+/
+			}
+		},
+		cdata: {
+			pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+			greedy: !0
+		},
+		tag: {
+			pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+			greedy: !0,
+			inside: {
+				tag: {
+					pattern: /^<\/?[^\s>\/]+/,
+					inside: {
+						punctuation: /^<\/?/,
+						namespace: /^[^\s>\/:]+:/
+					}
+				},
+				"special-attr": [],
+				"attr-value": {
+					pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+					inside: { punctuation: [{
+						pattern: /^=/,
+						alias: "attr-equals"
+					}, {
+						pattern: /^(\s*)["']|["']$/,
+						lookbehind: !0
+					}] }
+				},
+				punctuation: /\/?>/,
+				"attr-name": {
+					pattern: /[^\s>\/]+/,
+					inside: { namespace: /^[^\s>\/:]+:/ }
+				}
+			}
+		},
+		entity: [{
+			pattern: /&[\da-z]{1,8};/i,
+			alias: "named-entity"
+		}, /&#x?[\da-f]{1,8};/i]
+	}, n.languages.markup.tag.inside["attr-value"].inside.entity = n.languages.markup.entity, n.languages.markup.doctype.inside["internal-subset"].inside = n.languages.markup, n.hooks.add("wrap", function(e) {
+		e.type === "entity" && (e.attributes.title = e.content.replace(/&amp;/, "&"));
+	}), Object.defineProperty(n.languages.markup.tag, "addInlined", { value: function(e, t) {
+		var r = {};
+		r["language-" + t] = {
+			pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+			lookbehind: !0,
+			inside: n.languages[t]
+		}, r.cdata = /^<!\[CDATA\[|\]\]>$/i;
+		var i = { "included-cdata": {
+			pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+			inside: r
+		} };
+		i["language-" + t] = {
+			pattern: /[\s\S]+/,
+			inside: n.languages[t]
+		};
+		var a = {};
+		a[e] = {
+			pattern: RegExp("(<__[^>]*>)(?:<!\\[CDATA\\[(?:[^\\]]|\\](?!\\]>))*\\]\\]>|(?!<!\\[CDATA\\[)[\\s\\S])*?(?=<\\/__>)".replace(/__/g, function() {
+				return e;
+			}), "i"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: i
+		}, n.languages.insertBefore("markup", "cdata", a);
+	} }), Object.defineProperty(n.languages.markup.tag, "addAttribute", { value: function(e, t) {
+		n.languages.markup.tag.inside["special-attr"].push({
+			pattern: RegExp("(^|[\"'\\s])(?:" + e + ")\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+(?=[\\s>]))", "i"),
+			lookbehind: !0,
+			inside: {
+				"attr-name": /^[^\s=]+/,
+				"attr-value": {
+					pattern: /=[\s\S]+/,
+					inside: {
+						value: {
+							pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+							lookbehind: !0,
+							alias: [t, "language-" + t],
+							inside: n.languages[t]
+						},
+						punctuation: [{
+							pattern: /^=/,
+							alias: "attr-equals"
+						}, /"|'/]
+					}
+				}
+			}
+		});
+	} }), n.languages.html = n.languages.markup, n.languages.mathml = n.languages.markup, n.languages.svg = n.languages.markup, n.languages.xml = n.languages.extend("markup", {}), n.languages.ssml = n.languages.xml, n.languages.atom = n.languages.xml, n.languages.rss = n.languages.xml, (function(e) {
+		var t = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+		e.languages.css = {
+			comment: /\/\*[\s\S]*?\*\//,
+			atrule: {
+				pattern: RegExp("@[\\w-](?:[^;{\\s\"']|\\s+(?!\\s)|" + t.source + ")*?(?:;|(?=\\s*\\{))"),
+				inside: {
+					rule: /^@[\w-]+/,
+					"selector-function-argument": {
+						pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+						lookbehind: !0,
+						alias: "selector"
+					},
+					keyword: {
+						pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+						lookbehind: !0
+					}
+				}
+			},
+			url: {
+				pattern: RegExp("\\burl\\((?:" + t.source + "|(?:[^\\\\\\r\\n()\"']|\\\\[\\s\\S])*)\\)", "i"),
+				greedy: !0,
+				inside: {
+					function: /^url/i,
+					punctuation: /^\(|\)$/,
+					string: {
+						pattern: RegExp("^" + t.source + "$"),
+						alias: "url"
+					}
+				}
+			},
+			selector: {
+				pattern: RegExp("(^|[{}\\s])[^{}\\s](?:[^{};\"'\\s]|\\s+(?![\\s{])|" + t.source + ")*(?=\\s*\\{)"),
+				lookbehind: !0
+			},
+			string: {
+				pattern: t,
+				greedy: !0
+			},
+			property: {
+				pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+				lookbehind: !0
+			},
+			important: /!important\b/i,
+			function: {
+				pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+				lookbehind: !0
+			},
+			punctuation: /[(){};:,]/
+		}, e.languages.css.atrule.inside.rest = e.languages.css;
+		var n = e.languages.markup;
+		n && (n.tag.addInlined("style", "css"), n.tag.addAttribute("style", "css"));
+	})(n), n.languages.clike = {
+		comment: [{
+			pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+			lookbehind: !0,
+			greedy: !0
+		}, {
+			pattern: /(^|[^\\:])\/\/.*/,
+			lookbehind: !0,
+			greedy: !0
+		}],
+		string: {
+			pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+			greedy: !0
+		},
+		"class-name": {
+			pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
+			lookbehind: !0,
+			inside: { punctuation: /[.\\]/ }
+		},
+		keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
+		boolean: /\b(?:false|true)\b/,
+		function: /\b\w+(?=\()/,
+		number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+		operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
+		punctuation: /[{}[\];(),.:]/
+	}, n.languages.javascript = n.languages.extend("clike", {
+		"class-name": [n.languages.clike["class-name"], {
+			pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
+			lookbehind: !0
+		}],
+		keyword: [{
+			pattern: /((?:^|\})\s*)catch\b/,
+			lookbehind: !0
+		}, {
+			pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
+			lookbehind: !0
+		}],
+		function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+		number: {
+			pattern: RegExp("(^|[^\\w$])(?:NaN|Infinity|0[bB][01]+(?:_[01]+)*n?|0[oO][0-7]+(?:_[0-7]+)*n?|0[xX][\\dA-Fa-f]+(?:_[\\dA-Fa-f]+)*n?|\\d+(?:_\\d+)*n|(?:\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\.\\d+(?:_\\d+)*)(?:[Ee][+-]?\\d+(?:_\\d+)*)?)(?![\\w$])"),
+			lookbehind: !0
+		},
+		operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
+	}), n.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, n.languages.insertBefore("javascript", "keyword", {
+		regex: {
+			pattern: RegExp("((?:^|[^$\\w\\xA0-\\uFFFF.\"'\\])\\s]|\\b(?:return|yield))\\s*)\\/(?:(?:\\[(?:[^\\]\\\\\\r\\n]|\\\\.)*\\]|\\\\.|[^/\\\\\\[\\r\\n])+\\/[dgimyus]{0,7}|(?:\\[(?:[^[\\]\\\\\\r\\n]|\\\\.|\\[(?:[^[\\]\\\\\\r\\n]|\\\\.|\\[(?:[^[\\]\\\\\\r\\n]|\\\\.)*\\])*\\])*\\]|\\\\.|[^/\\\\\\[\\r\\n])+\\/[dgimyus]{0,7}v[dgimyus]{0,7})(?=(?:\\s|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/)*(?:$|[\\r\\n,.;:})\\]]|\\/\\/))"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				"regex-source": {
+					pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+					lookbehind: !0,
+					alias: "language-regex",
+					inside: n.languages.regex
+				},
+				"regex-delimiter": /^\/|\/$/,
+				"regex-flags": /^[a-z]+$/
+			}
+		},
+		"function-variable": {
+			pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
+			alias: "function"
+		},
+		parameter: [
+			{
+				pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
+				lookbehind: !0,
+				inside: n.languages.javascript
+			},
+			{
+				pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+				lookbehind: !0,
+				inside: n.languages.javascript
+			},
+			{
+				pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+				lookbehind: !0,
+				inside: n.languages.javascript
+			},
+			{
+				pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
+				lookbehind: !0,
+				inside: n.languages.javascript
+			}
+		],
+		constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
+	}), n.languages.insertBefore("javascript", "string", {
+		hashbang: {
+			pattern: /^#!.*/,
+			greedy: !0,
+			alias: "comment"
+		},
+		"template-string": {
+			pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+			greedy: !0,
+			inside: {
+				"template-punctuation": {
+					pattern: /^`|`$/,
+					alias: "string"
+				},
+				interpolation: {
+					pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+					lookbehind: !0,
+					inside: {
+						"interpolation-punctuation": {
+							pattern: /^\$\{|\}$/,
+							alias: "punctuation"
+						},
+						rest: n.languages.javascript
+					}
+				},
+				string: /[\s\S]+/
+			}
+		},
+		"string-property": {
+			pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
+			lookbehind: !0,
+			greedy: !0,
+			alias: "property"
+		}
+	}), n.languages.insertBefore("javascript", "operator", { "literal-property": {
+		pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
+		lookbehind: !0,
+		alias: "property"
+	} }), n.languages.markup && (n.languages.markup.tag.addInlined("script", "javascript"), n.languages.markup.tag.addAttribute("on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)", "javascript")), n.languages.js = n.languages.javascript, (function() {
+		if (n === void 0 || typeof document > "u") return;
+		Element.prototype.matches || (Element.prototype.matches = Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector);
+		var e = "Loading…", t = function(e, t) {
+			return "✖ Error " + e + " while fetching file: " + t;
+		}, r = "✖ Error: File does not exist or is empty", i = {
+			js: "javascript",
+			py: "python",
+			rb: "ruby",
+			ps1: "powershell",
+			psm1: "powershell",
+			sh: "bash",
+			bat: "batch",
+			h: "c",
+			tex: "latex"
+		}, a = "data-src-status", o = "loading", s = "loaded", c = "failed", l = "pre[data-src]:not([" + a + "=\"" + s + "\"]):not([" + a + "=\"" + o + "\"])";
+		function u(e, n, i) {
+			var a = new XMLHttpRequest();
+			a.open("GET", e, !0), a.onreadystatechange = function() {
+				a.readyState == 4 && (a.status < 400 && a.responseText ? n(a.responseText) : a.status >= 400 ? i(t(a.status, a.statusText)) : i(r));
+			}, a.send(null);
+		}
+		function d(e) {
+			var t = /^\s*(\d+)\s*(?:(,)\s*(?:(\d+)\s*)?)?$/.exec(e || "");
+			if (t) {
+				var n = Number(t[1]), r = t[2], i = t[3];
+				return r ? i ? [n, Number(i)] : [n, void 0] : [n, n];
+			}
+		}
+		n.hooks.add("before-highlightall", function(e) {
+			e.selector += ", " + l;
+		}), n.hooks.add("before-sanity-check", function(t) {
+			var r = t.element;
+			if (r.matches(l)) {
+				t.code = "", r.setAttribute(a, o);
+				var f = r.appendChild(document.createElement("CODE"));
+				f.textContent = e;
+				var p = r.getAttribute("data-src"), m = t.language;
+				if (m === "none") {
+					var h = (/\.(\w+)$/.exec(p) || [, "none"])[1];
+					m = i[h] || h;
+				}
+				n.util.setLanguage(f, m), n.util.setLanguage(r, m);
+				var g = n.plugins.autoloader;
+				g && g.loadLanguages(m), u(p, function(e) {
+					r.setAttribute(a, s);
+					var t = d(r.getAttribute("data-range"));
+					if (t) {
+						var i = e.split(/\r\n?|\n/g), o = t[0], c = t[1] == null ? i.length : t[1];
+						o < 0 && (o += i.length), o = Math.max(0, Math.min(o - 1, i.length)), c < 0 && (c += i.length), c = Math.max(0, Math.min(c, i.length)), e = i.slice(o, c).join("\n"), r.hasAttribute("data-start") || r.setAttribute("data-start", String(o + 1));
+					}
+					f.textContent = e, n.highlightElement(f);
+				}, function(e) {
+					r.setAttribute(a, c), f.textContent = e;
+				});
+			}
+		}), n.plugins.fileHighlight = { highlight: function(e) {
+			for (var t = (e || document).querySelectorAll(l), r = 0, i; i = t[r++];) n.highlightElement(i);
+		} };
+		var f = !1;
+		n.fileHighlight = function() {
+			f ||= (console.warn("Prism.fileHighlight is deprecated. Use `Prism.plugins.fileHighlight.highlight` instead."), !0), n.plugins.fileHighlight.highlight.apply(this, arguments);
+		};
+	})();
+})))(), 1);
+Prism.languages.javascript = Prism.languages.extend("clike", {
+	"class-name": [Prism.languages.clike["class-name"], {
+		pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
+		lookbehind: !0
+	}],
+	keyword: [{
+		pattern: /((?:^|\})\s*)catch\b/,
+		lookbehind: !0
+	}, {
+		pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
+		lookbehind: !0
+	}],
+	function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+	number: {
+		pattern: RegExp("(^|[^\\w$])(?:NaN|Infinity|0[bB][01]+(?:_[01]+)*n?|0[oO][0-7]+(?:_[0-7]+)*n?|0[xX][\\dA-Fa-f]+(?:_[\\dA-Fa-f]+)*n?|\\d+(?:_\\d+)*n|(?:\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\.\\d+(?:_\\d+)*)(?:[Ee][+-]?\\d+(?:_\\d+)*)?)(?![\\w$])"),
+		lookbehind: !0
+	},
+	operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
+}), Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, Prism.languages.insertBefore("javascript", "keyword", {
+	regex: {
+		pattern: RegExp("((?:^|[^$\\w\\xA0-\\uFFFF.\"'\\])\\s]|\\b(?:return|yield))\\s*)\\/(?:(?:\\[(?:[^\\]\\\\\\r\\n]|\\\\.)*\\]|\\\\.|[^/\\\\\\[\\r\\n])+\\/[dgimyus]{0,7}|(?:\\[(?:[^[\\]\\\\\\r\\n]|\\\\.|\\[(?:[^[\\]\\\\\\r\\n]|\\\\.|\\[(?:[^[\\]\\\\\\r\\n]|\\\\.)*\\])*\\])*\\]|\\\\.|[^/\\\\\\[\\r\\n])+\\/[dgimyus]{0,7}v[dgimyus]{0,7})(?=(?:\\s|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/)*(?:$|[\\r\\n,.;:})\\]]|\\/\\/))"),
+		lookbehind: !0,
+		greedy: !0,
+		inside: {
+			"regex-source": {
+				pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+				lookbehind: !0,
+				alias: "language-regex",
+				inside: Prism.languages.regex
+			},
+			"regex-delimiter": /^\/|\/$/,
+			"regex-flags": /^[a-z]+$/
+		}
+	},
+	"function-variable": {
+		pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
+		alias: "function"
+	},
+	parameter: [
+		{
+			pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
+			lookbehind: !0,
+			inside: Prism.languages.javascript
+		},
+		{
+			pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+			lookbehind: !0,
+			inside: Prism.languages.javascript
+		},
+		{
+			pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+			lookbehind: !0,
+			inside: Prism.languages.javascript
+		},
+		{
+			pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
+			lookbehind: !0,
+			inside: Prism.languages.javascript
+		}
+	],
+	constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
+}), Prism.languages.insertBefore("javascript", "string", {
+	hashbang: {
+		pattern: /^#!.*/,
+		greedy: !0,
+		alias: "comment"
+	},
+	"template-string": {
+		pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+		greedy: !0,
+		inside: {
+			"template-punctuation": {
+				pattern: /^`|`$/,
+				alias: "string"
+			},
+			interpolation: {
+				pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+				lookbehind: !0,
+				inside: {
+					"interpolation-punctuation": {
+						pattern: /^\$\{|\}$/,
+						alias: "punctuation"
+					},
+					rest: Prism.languages.javascript
+				}
+			},
+			string: /[\s\S]+/
+		}
+	},
+	"string-property": {
+		pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
+		lookbehind: !0,
+		greedy: !0,
+		alias: "property"
+	}
+}), Prism.languages.insertBefore("javascript", "operator", { "literal-property": {
+	pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
+	lookbehind: !0,
+	alias: "property"
+} }), Prism.languages.markup && (Prism.languages.markup.tag.addInlined("script", "javascript"), Prism.languages.markup.tag.addAttribute("on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)", "javascript")), Prism.languages.js = Prism.languages.javascript, (function(e) {
+	e.languages.typescript = e.languages.extend("javascript", {
+		"class-name": {
+			pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
+			lookbehind: !0,
+			greedy: !0,
+			inside: null
+		},
+		builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
+	}), e.languages.typescript.keyword.push(/\b(?:abstract|declare|is|keyof|readonly|require)\b/, /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/, /\btype\b(?=\s*(?:[\{*]|$))/), delete e.languages.typescript.parameter, delete e.languages.typescript["literal-property"];
+	var t = e.languages.extend("typescript", {});
+	delete t["class-name"], e.languages.typescript["class-name"].inside = t, e.languages.insertBefore("typescript", "function", {
+		decorator: {
+			pattern: /@[$\w\xA0-\uFFFF]+/,
+			inside: {
+				at: {
+					pattern: /^@/,
+					alias: "operator"
+				},
+				function: /^[\s\S]+/
+			}
+		},
+		"generic-function": {
+			pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
+			greedy: !0,
+			inside: {
+				function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
+				generic: {
+					pattern: /<[\s\S]+/,
+					alias: "class-name",
+					inside: t
+				}
+			}
+		}
+	}), e.languages.ts = e.languages.typescript;
+})(Prism), (function(e) {
+	var t = e.util.clone(e.languages.javascript), n = "(?:\\s|\\/\\/.*(?!.)|\\/\\*(?:[^*]|\\*(?!\\/))\\*\\/)", r = "(?:\\{(?:\\{(?:\\{[^{}]*\\}|[^{}])*\\}|[^{}])*\\})", i = "(?:\\{<S>*\\.{3}(?:[^{}]|<BRACES>)*\\})";
+	function a(e, t) {
+		return e = e.replace(/<S>/g, function() {
+			return n;
+		}).replace(/<BRACES>/g, function() {
+			return r;
+		}).replace(/<SPREAD>/g, function() {
+			return i;
+		}), RegExp(e, t);
+	}
+	i = a(i).source, e.languages.jsx = e.languages.extend("markup", t), e.languages.jsx.tag.pattern = a("<\\/?(?:[\\w.:-]+(?:<S>+(?:[\\w.:$-]+(?:=(?:\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"|'(?:\\\\[\\s\\S]|[^\\\\'])*'|[^\\s{'\"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\\/?)?>"), e.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/, e.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/, e.languages.jsx.tag.inside.tag.inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/, e.languages.jsx.tag.inside.comment = t.comment, e.languages.insertBefore("inside", "attr-name", { spread: {
+		pattern: a("<SPREAD>"),
+		inside: e.languages.jsx
+	} }, e.languages.jsx.tag), e.languages.insertBefore("inside", "special-attr", { script: {
+		pattern: a("=<BRACES>"),
+		alias: "language-javascript",
+		inside: {
+			"script-punctuation": {
+				pattern: /^=(?=\{)/,
+				alias: "punctuation"
+			},
+			rest: e.languages.jsx
+		}
+	} }, e.languages.jsx.tag);
+	var o = function(e) {
+		return e ? typeof e == "string" ? e : typeof e.content == "string" ? e.content : e.content.map(o).join("") : "";
+	}, s = function(t) {
+		for (var n = [], r = 0; r < t.length; r++) {
+			var i = t[r], a = !1;
+			if (typeof i != "string" && (i.type === "tag" && i.content[0] && i.content[0].type === "tag" ? i.content[0].content[0].content === "</" ? n.length > 0 && n[n.length - 1].tagName === o(i.content[0].content[1]) && n.pop() : i.content[i.content.length - 1].content === "/>" || n.push({
+				tagName: o(i.content[0].content[1]),
+				openedBraces: 0
+			}) : n.length > 0 && i.type === "punctuation" && i.content === "{" ? n[n.length - 1].openedBraces++ : n.length > 0 && n[n.length - 1].openedBraces > 0 && i.type === "punctuation" && i.content === "}" ? n[n.length - 1].openedBraces-- : a = !0), (a || typeof i == "string") && n.length > 0 && n[n.length - 1].openedBraces === 0) {
+				var c = o(i);
+				r < t.length - 1 && (typeof t[r + 1] == "string" || t[r + 1].type === "plain-text") && (c += o(t[r + 1]), t.splice(r + 1, 1)), r > 0 && (typeof t[r - 1] == "string" || t[r - 1].type === "plain-text") && (c = o(t[r - 1]) + c, t.splice(r - 1, 1), r--), t[r] = new e.Token("plain-text", c, null, c);
+			}
+			i.content && typeof i.content != "string" && s(i.content);
+		}
+	};
+	e.hooks.add("after-tokenize", function(e) {
+		e.language !== "jsx" && e.language !== "tsx" || s(e.tokens);
+	});
+})(Prism), (function(e) {
+	var t = e.util.clone(e.languages.typescript);
+	e.languages.tsx = e.languages.extend("jsx", t), delete e.languages.tsx.parameter, delete e.languages.tsx["literal-property"];
+	var n = e.languages.tsx.tag;
+	n.pattern = RegExp("(^|[^\\w$]|(?=<\\/))(?:" + n.pattern.source + ")", n.pattern.flags), n.lookbehind = !0;
+})(Prism), (function(e) {
+	var t = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+	e.languages.css = {
+		comment: /\/\*[\s\S]*?\*\//,
+		atrule: {
+			pattern: RegExp("@[\\w-](?:[^;{\\s\"']|\\s+(?!\\s)|" + t.source + ")*?(?:;|(?=\\s*\\{))"),
+			inside: {
+				rule: /^@[\w-]+/,
+				"selector-function-argument": {
+					pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+					lookbehind: !0,
+					alias: "selector"
+				},
+				keyword: {
+					pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+					lookbehind: !0
+				}
+			}
+		},
+		url: {
+			pattern: RegExp("\\burl\\((?:" + t.source + "|(?:[^\\\\\\r\\n()\"']|\\\\[\\s\\S])*)\\)", "i"),
+			greedy: !0,
+			inside: {
+				function: /^url/i,
+				punctuation: /^\(|\)$/,
+				string: {
+					pattern: RegExp("^" + t.source + "$"),
+					alias: "url"
+				}
+			}
+		},
+		selector: {
+			pattern: RegExp("(^|[{}\\s])[^{}\\s](?:[^{};\"'\\s]|\\s+(?![\\s{])|" + t.source + ")*(?=\\s*\\{)"),
+			lookbehind: !0
+		},
+		string: {
+			pattern: t,
+			greedy: !0
+		},
+		property: {
+			pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+			lookbehind: !0
+		},
+		important: /!important\b/i,
+		function: {
+			pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+			lookbehind: !0
+		},
+		punctuation: /[(){};:,]/
+	}, e.languages.css.atrule.inside.rest = e.languages.css;
+	var n = e.languages.markup;
+	n && (n.tag.addInlined("style", "css"), n.tag.addAttribute("style", "css"));
+})(Prism), Prism.languages.python = {
+	comment: {
+		pattern: /(^|[^\\])#.*/,
+		lookbehind: !0,
+		greedy: !0
+	},
+	"string-interpolation": {
+		pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+		greedy: !0,
+		inside: {
+			interpolation: {
+				pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
+				lookbehind: !0,
+				inside: {
+					"format-spec": {
+						pattern: /(:)[^:(){}]+(?=\}$)/,
+						lookbehind: !0
+					},
+					"conversion-option": {
+						pattern: /![sra](?=[:}]$)/,
+						alias: "punctuation"
+					},
+					rest: null
+				}
+			},
+			string: /[\s\S]+/
+		}
+	},
+	"triple-quoted-string": {
+		pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
+		greedy: !0,
+		alias: "string"
+	},
+	string: {
+		pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+		greedy: !0
+	},
+	function: {
+		pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+		lookbehind: !0
+	},
+	"class-name": {
+		pattern: /(\bclass\s+)\w+/i,
+		lookbehind: !0
+	},
+	decorator: {
+		pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
+		lookbehind: !0,
+		alias: ["annotation", "punctuation"],
+		inside: { punctuation: /\./ }
+	},
+	keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+	builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+	boolean: /\b(?:False|None|True)\b/,
+	number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+	operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+	punctuation: /[{}[\];(),.:]/
+}, Prism.languages.python["string-interpolation"].inside.interpolation.inside.rest = Prism.languages.python, Prism.languages.py = Prism.languages.python, (function(e) {
+	var t = "\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b", n = {
+		pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
+		lookbehind: !0,
+		alias: "punctuation",
+		inside: null
+	}, r = {
+		bash: n,
+		environment: {
+			pattern: RegExp("\\$" + t),
+			alias: "constant"
+		},
+		variable: [
+			{
+				pattern: /\$?\(\([\s\S]+?\)\)/,
+				greedy: !0,
+				inside: {
+					variable: [{
+						pattern: /(^\$\(\([\s\S]+)\)\)/,
+						lookbehind: !0
+					}, /^\$\(\(/],
+					number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+					operator: /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
+					punctuation: /\(\(?|\)\)?|,|;/
+				}
+			},
+			{
+				pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
+				greedy: !0,
+				inside: { variable: /^\$\(|^`|\)$|`$/ }
+			},
+			{
+				pattern: /\$\{[^}]+\}/,
+				greedy: !0,
+				inside: {
+					operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
+					punctuation: /[\[\]]/,
+					environment: {
+						pattern: RegExp("(\\{)" + t),
+						lookbehind: !0,
+						alias: "constant"
+					}
+				}
+			},
+			/\$(?:\w+|[#?*!@$])/
+		],
+		entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
+	};
+	e.languages.bash = {
+		shebang: {
+			pattern: /^#!\s*\/.*/,
+			alias: "important"
+		},
+		comment: {
+			pattern: /(^|[^"{\\$])#.*/,
+			lookbehind: !0
+		},
+		"function-name": [{
+			pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
+			lookbehind: !0,
+			alias: "function"
+		}, {
+			pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
+			alias: "function"
+		}],
+		"for-or-select": {
+			pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
+			alias: "variable",
+			lookbehind: !0
+		},
+		"assign-left": {
+			pattern: /(^|[\s;|&]|[<>]\()\w+(?:\.\w+)*(?=\+?=)/,
+			inside: { environment: {
+				pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + t),
+				lookbehind: !0,
+				alias: "constant"
+			} },
+			alias: "variable",
+			lookbehind: !0
+		},
+		parameter: {
+			pattern: /(^|\s)-{1,2}(?:\w+:[+-]?)?\w+(?:\.\w+)*(?=[=\s]|$)/,
+			alias: "variable",
+			lookbehind: !0
+		},
+		string: [
+			{
+				pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
+				lookbehind: !0,
+				greedy: !0,
+				inside: r
+			},
+			{
+				pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
+				lookbehind: !0,
+				greedy: !0,
+				inside: { bash: n }
+			},
+			{
+				pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
+				lookbehind: !0,
+				greedy: !0,
+				inside: r
+			},
+			{
+				pattern: /(^|[^$\\])'[^']*'/,
+				lookbehind: !0,
+				greedy: !0
+			},
+			{
+				pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
+				greedy: !0,
+				inside: { entity: r.entity }
+			}
+		],
+		environment: {
+			pattern: RegExp("\\$?" + t),
+			alias: "constant"
+		},
+		variable: r.variable,
+		function: {
+			pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cargo|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|java|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|sysctl|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
+			lookbehind: !0
+		},
+		keyword: {
+			pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
+			lookbehind: !0
+		},
+		builtin: {
+			pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
+			lookbehind: !0,
+			alias: "class-name"
+		},
+		boolean: {
+			pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
+			lookbehind: !0
+		},
+		"file-descriptor": {
+			pattern: /\B&\d\b/,
+			alias: "important"
+		},
+		operator: {
+			pattern: /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
+			inside: { "file-descriptor": {
+				pattern: /^\d/,
+				alias: "important"
+			} }
+		},
+		punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
+		number: {
+			pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
+			lookbehind: !0
+		}
+	}, n.inside = e.languages.bash;
+	for (var i = [
+		"comment",
+		"function-name",
+		"for-or-select",
+		"assign-left",
+		"parameter",
+		"string",
+		"environment",
+		"function",
+		"keyword",
+		"builtin",
+		"boolean",
+		"file-descriptor",
+		"operator",
+		"punctuation",
+		"number"
+	], a = r.variable[1].inside, o = 0; o < i.length; o++) a[i[o]] = e.languages.bash[i[o]];
+	e.languages.sh = e.languages.bash, e.languages.shell = e.languages.bash;
+})(Prism), Prism.languages.json = {
+	property: {
+		pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
+		lookbehind: !0,
+		greedy: !0
+	},
+	string: {
+		pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
+		lookbehind: !0,
+		greedy: !0
+	},
+	comment: {
+		pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+		greedy: !0
+	},
+	number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+	punctuation: /[{}[\],]/,
+	operator: /:/,
+	boolean: /\b(?:false|true)\b/,
+	null: {
+		pattern: /\bnull\b/,
+		alias: "keyword"
+	}
+}, Prism.languages.webmanifest = Prism.languages.json, (function(e) {
+	var t = "(?:\\\\.|[^\\\\\\n\\r]|(?:\\n|\\r\\n?)(?![\\r\\n]))";
+	function n(e) {
+		return e = e.replace(/<inner>/g, function() {
+			return t;
+		}), RegExp("((?:^|[^\\\\])(?:\\\\{2})*)(?:" + e + ")");
+	}
+	var r = "(?:\\\\.|``(?:[^`\\r\\n]|`(?!`))+``|`[^`\\r\\n]+`|[^\\\\|\\r\\n`])+", i = "\\|?__(?:\\|__)+\\|?(?:(?:\\n|\\r\\n?)|(?![\\s\\S]))".replace(/__/g, function() {
+		return r;
+	}), a = "\\|?[ \\t]*:?-{3,}:?[ \\t]*(?:\\|[ \\t]*:?-{3,}:?[ \\t]*)+\\|?(?:\\n|\\r\\n?)";
+	e.languages.markdown = e.languages.extend("markup", {}), e.languages.insertBefore("markdown", "prolog", {
+		"front-matter-block": {
+			pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				punctuation: /^---|---$/,
+				"front-matter": {
+					pattern: /\S+(?:\s+\S+)*/,
+					alias: ["yaml", "language-yaml"],
+					inside: e.languages.yaml
+				}
+			}
+		},
+		blockquote: {
+			pattern: /^>(?:[\t ]*>)*/m,
+			alias: "punctuation"
+		},
+		table: {
+			pattern: RegExp("^" + i + a + "(?:" + i + ")*", "m"),
+			inside: {
+				"table-data-rows": {
+					pattern: RegExp("^(" + i + a + ")(?:" + i + ")*$"),
+					lookbehind: !0,
+					inside: {
+						"table-data": {
+							pattern: RegExp(r),
+							inside: e.languages.markdown
+						},
+						punctuation: /\|/
+					}
+				},
+				"table-line": {
+					pattern: RegExp("^(" + i + ")" + a + "$"),
+					lookbehind: !0,
+					inside: { punctuation: /\||:?-{3,}:?/ }
+				},
+				"table-header-row": {
+					pattern: RegExp("^" + i + "$"),
+					inside: {
+						"table-header": {
+							pattern: RegExp(r),
+							alias: "important",
+							inside: e.languages.markdown
+						},
+						punctuation: /\|/
+					}
+				}
+			}
+		},
+		code: [{
+			pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
+			lookbehind: !0,
+			alias: "keyword"
+		}, {
+			pattern: /^```[\s\S]*?^```$/m,
+			greedy: !0,
+			inside: {
+				"code-block": {
+					pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
+					lookbehind: !0
+				},
+				"code-language": {
+					pattern: /^(```).+/,
+					lookbehind: !0
+				},
+				punctuation: /```/
+			}
+		}],
+		title: [{
+			pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
+			alias: "important",
+			inside: { punctuation: /==+$|--+$/ }
+		}, {
+			pattern: /(^\s*)#.+/m,
+			lookbehind: !0,
+			alias: "important",
+			inside: { punctuation: /^#+|#+$/ }
+		}],
+		hr: {
+			pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
+			lookbehind: !0,
+			alias: "punctuation"
+		},
+		list: {
+			pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
+			lookbehind: !0,
+			alias: "punctuation"
+		},
+		"url-reference": {
+			pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
+			inside: {
+				variable: {
+					pattern: /^(!?\[)[^\]]+/,
+					lookbehind: !0
+				},
+				string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
+				punctuation: /^[\[\]!:]|[<>]/
+			},
+			alias: "url"
+		},
+		bold: {
+			pattern: n("\\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\\b|\\*\\*(?:(?!\\*)<inner>|\\*(?:(?!\\*)<inner>)+\\*)+\\*\\*"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				content: {
+					pattern: /(^..)[\s\S]+(?=..$)/,
+					lookbehind: !0,
+					inside: {}
+				},
+				punctuation: /\*\*|__/
+			}
+		},
+		italic: {
+			pattern: n("\\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\\b|\\*(?:(?!\\*)<inner>|\\*\\*(?:(?!\\*)<inner>)+\\*\\*)+\\*"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				content: {
+					pattern: /(^.)[\s\S]+(?=.$)/,
+					lookbehind: !0,
+					inside: {}
+				},
+				punctuation: /[*_]/
+			}
+		},
+		strike: {
+			pattern: n("(~~?)(?:(?!~)<inner>)+\\2"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				content: {
+					pattern: /(^~~?)[\s\S]+(?=\1$)/,
+					lookbehind: !0,
+					inside: {}
+				},
+				punctuation: /~~?/
+			}
+		},
+		"code-snippet": {
+			pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
+			lookbehind: !0,
+			greedy: !0,
+			alias: ["code", "keyword"]
+		},
+		url: {
+			pattern: n("!?\\[(?:(?!\\])<inner>)+\\](?:\\([^\\s)]+(?:[\\t ]+\"(?:\\\\.|[^\"\\\\])*\")?\\)|[ \\t]?\\[(?:(?!\\])<inner>)+\\])"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				operator: /^!/,
+				content: {
+					pattern: /(^\[)[^\]]+(?=\])/,
+					lookbehind: !0,
+					inside: {}
+				},
+				variable: {
+					pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
+					lookbehind: !0
+				},
+				url: {
+					pattern: /(^\]\()[^\s)]+/,
+					lookbehind: !0
+				},
+				string: {
+					pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
+					lookbehind: !0
+				}
+			}
+		}
+	}), [
+		"url",
+		"bold",
+		"italic",
+		"strike"
+	].forEach(function(t) {
+		[
+			"url",
+			"bold",
+			"italic",
+			"strike",
+			"code-snippet"
+		].forEach(function(n) {
+			t !== n && (e.languages.markdown[t].inside.content.inside[n] = e.languages.markdown[n]);
+		});
+	}), e.hooks.add("after-tokenize", function(e) {
+		if (e.language !== "markdown" && e.language !== "md") return;
+		function t(e) {
+			if (!(!e || typeof e == "string")) for (var n = 0, r = e.length; n < r; n++) {
+				var i = e[n];
+				if (i.type !== "code") {
+					t(i.content);
+					continue;
+				}
+				var a = i.content[1], o = i.content[3];
+				if (a && o && a.type === "code-language" && o.type === "code-block" && typeof a.content == "string") {
+					var s = a.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
+					s = (/[a-z][\w-]*/i.exec(s) || [""])[0].toLowerCase();
+					var c = "language-" + s;
+					o.alias ? typeof o.alias == "string" ? o.alias = [o.alias, c] : o.alias.push(c) : o.alias = [c];
+				}
+			}
+		}
+		t(e.tokens);
+	}), e.hooks.add("wrap", function(t) {
+		if (t.type === "code-block") {
+			for (var n = "", r = 0, i = t.classes.length; r < i; r++) {
+				var a = t.classes[r], o = /language-(.+)/.exec(a);
+				if (o) {
+					n = o[1];
+					break;
+				}
+			}
+			var s = e.languages[n];
+			if (s) t.content = e.highlight(l(t.content), s, n);
+			else if (n && n !== "none" && e.plugins.autoloader) {
+				var c = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 0x2386f26fc10000);
+				t.attributes.id = c, e.plugins.autoloader.loadLanguages(n, function() {
+					var t = document.getElementById(c);
+					t && (t.innerHTML = e.highlight(t.textContent, e.languages[n], n));
+				});
+			}
+		}
+	});
+	var o = RegExp(e.languages.markup.tag.pattern.source, "gi"), s = {
+		amp: "&",
+		lt: "<",
+		gt: ">",
+		quot: "\""
+	}, c = String.fromCodePoint || String.fromCharCode;
+	function l(e) {
+		var t = e.replace(o, "");
+		return t = t.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(e, t) {
+			return t = t.toLowerCase(), t[0] === "#" ? c(t[1] === "x" ? parseInt(t.slice(2), 16) : Number(t.slice(1))) : s[t] || e;
+		}), t;
+	}
+	e.languages.md = e.languages.markdown;
+})(Prism), (function(e) {
+	var t = /[*&][^\s[\]{},]+/, n = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, r = "(?:" + n.source + "(?:[ 	]+" + t.source + ")?|" + t.source + "(?:[ 	]+" + n.source + ")?)", i = "(?:[^\\s\\x00-\\x08\\x0e-\\x1f!\"#%&'*,\\-:>?@[\\]`{|}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]|[?:-]<PLAIN>)(?:[ \\t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*".replace(/<PLAIN>/g, function() {
+		return "[^\\s\\x00-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]";
+	}), a = "\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"|'(?:[^'\\\\\\r\\n]|\\\\.)*'";
+	function o(e, t) {
+		t = (t || "").replace(/m/g, "") + "m";
+		var n = "([:\\-,[{]\\s*(?:\\s<<prop>>[ \\t]+)?)(?:<<value>>)(?=[ \\t]*(?:$|,|\\]|\\}|(?:[\\r\\n]\\s*)?#))".replace(/<<prop>>/g, function() {
+			return r;
+		}).replace(/<<value>>/g, function() {
+			return e;
+		});
+		return RegExp(n, t);
+	}
+	e.languages.yaml = {
+		scalar: {
+			pattern: RegExp("([\\-:]\\s*(?:\\s<<prop>>[ \\t]+)?[|>])[ \\t]*(?:((?:\\r?\\n|\\r)[ \\t]+)\\S[^\\r\\n]*(?:\\2[^\\r\\n]+)*)".replace(/<<prop>>/g, function() {
+				return r;
+			})),
+			lookbehind: !0,
+			alias: "string"
+		},
+		comment: /#.*/,
+		key: {
+			pattern: RegExp("((?:^|[:\\-,[{\\r\\n?])[ \\t]*(?:<<prop>>[ \\t]+)?)<<key>>(?=\\s*:\\s)".replace(/<<prop>>/g, function() {
+				return r;
+			}).replace(/<<key>>/g, function() {
+				return "(?:" + i + "|" + a + ")";
+			})),
+			lookbehind: !0,
+			greedy: !0,
+			alias: "atrule"
+		},
+		directive: {
+			pattern: /(^[ \t]*)%.+/m,
+			lookbehind: !0,
+			alias: "important"
+		},
+		datetime: {
+			pattern: o("\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ \\t]+)\\d\\d?:\\d{2}:\\d{2}(?:\\.\\d*)?(?:[ \\t]*(?:Z|[-+]\\d\\d?(?::\\d{2})?))?|\\d{4}-\\d{2}-\\d{2}|\\d\\d?:\\d{2}(?::\\d{2}(?:\\.\\d*)?)?"),
+			lookbehind: !0,
+			alias: "number"
+		},
+		boolean: {
+			pattern: o("false|true", "i"),
+			lookbehind: !0,
+			alias: "important"
+		},
+		null: {
+			pattern: o("null|~", "i"),
+			lookbehind: !0,
+			alias: "important"
+		},
+		string: {
+			pattern: o(a),
+			lookbehind: !0,
+			greedy: !0
+		},
+		number: {
+			pattern: o("[+-]?(?:0x[\\da-f]+|0o[0-7]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)", "i"),
+			lookbehind: !0
+		},
+		tag: n,
+		important: t,
+		punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
+	}, e.languages.yml = e.languages.yaml;
+})(Prism), Prism.languages.sql = {
+	comment: {
+		pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
+		lookbehind: !0
+	},
+	variable: [{
+		pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/,
+		greedy: !0
+	}, /@[\w.$]+/],
+	string: {
+		pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/,
+		greedy: !0,
+		lookbehind: !0
+	},
+	identifier: {
+		pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/,
+		greedy: !0,
+		lookbehind: !0,
+		inside: { punctuation: /^`|`$/ }
+	},
+	function: /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i,
+	keyword: /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i,
+	boolean: /\b(?:FALSE|NULL|TRUE)\b/i,
+	number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
+	operator: /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,
+	punctuation: /[;[\]()`,.]/
+}, (function(e) {
+	for (var t = "\\/\\*(?:[^*/]|\\*(?!\\/)|\\/(?!\\*)|<self>)*\\*\\/", n = 0; n < 2; n++) t = t.replace(/<self>/g, function() {
+		return t;
+	});
+	t = t.replace(/<self>/g, function() {
+		return "[^\\s\\S]";
+	}), e.languages.rust = {
+		comment: [{
+			pattern: RegExp("(^|[^\\\\])" + t),
+			lookbehind: !0,
+			greedy: !0
+		}, {
+			pattern: /(^|[^\\:])\/\/.*/,
+			lookbehind: !0,
+			greedy: !0
+		}],
+		string: {
+			pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
+			greedy: !0
+		},
+		char: {
+			pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
+			greedy: !0
+		},
+		attribute: {
+			pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
+			greedy: !0,
+			alias: "attr-name",
+			inside: { string: null }
+		},
+		"closure-params": {
+			pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				"closure-punctuation": {
+					pattern: /^\||\|$/,
+					alias: "punctuation"
+				},
+				rest: null
+			}
+		},
+		"lifetime-annotation": {
+			pattern: /'\w+/,
+			alias: "symbol"
+		},
+		"fragment-specifier": {
+			pattern: /(\$\w+:)[a-z]+/,
+			lookbehind: !0,
+			alias: "punctuation"
+		},
+		variable: /\$\w+/,
+		"function-definition": {
+			pattern: /(\bfn\s+)\w+/,
+			lookbehind: !0,
+			alias: "function"
+		},
+		"type-definition": {
+			pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
+			lookbehind: !0,
+			alias: "class-name"
+		},
+		"module-declaration": [{
+			pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
+			lookbehind: !0,
+			alias: "namespace"
+		}, {
+			pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
+			lookbehind: !0,
+			alias: "namespace",
+			inside: { punctuation: /::/ }
+		}],
+		keyword: [/\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/, /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/],
+		function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
+		macro: {
+			pattern: /\b\w+!/,
+			alias: "property"
+		},
+		constant: /\b[A-Z_][A-Z_\d]+\b/,
+		"class-name": /\b[A-Z]\w*\b/,
+		namespace: {
+			pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
+			inside: { punctuation: /::/ }
+		},
+		number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
+		boolean: /\b(?:false|true)\b/,
+		punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
+		operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
+	}, e.languages.rust["closure-params"].inside.rest = e.languages.rust, e.languages.rust.attribute.inside.string = e.languages.rust.string;
+})(Prism), Prism.languages.go = Prism.languages.extend("clike", {
+	string: {
+		pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/,
+		lookbehind: !0,
+		greedy: !0
+	},
+	keyword: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,
+	boolean: /\b(?:_|false|iota|nil|true)\b/,
+	number: [
+		/\b0(?:b[01_]+|o[0-7_]+)i?\b/i,
+		/\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i,
+		/(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i
+	],
+	operator: /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
+	builtin: /\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/
+}), Prism.languages.insertBefore("go", "string", { char: {
+	pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/,
+	greedy: !0
+} }), delete Prism.languages.go["class-name"], (function(e) {
+	var t = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/, n = "(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*", r = {
+		pattern: RegExp("(^|[^\\w.])" + n + "[A-Z](?:[\\d_A-Z]*[a-z]\\w*)?\\b"),
+		lookbehind: !0,
+		inside: {
+			namespace: {
+				pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+				inside: { punctuation: /\./ }
+			},
+			punctuation: /\./
+		}
+	};
+	e.languages.java = e.languages.extend("clike", {
+		string: {
+			pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
+			lookbehind: !0,
+			greedy: !0
+		},
+		"class-name": [
+			r,
+			{
+				pattern: RegExp("(^|[^\\w.])" + n + "[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()]|\\s*(?:\\[[\\s,]*\\]\\s*)?::\\s*new\\b)"),
+				lookbehind: !0,
+				inside: r.inside
+			},
+			{
+				pattern: RegExp("(\\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\\s+)" + n + "[A-Z]\\w*\\b"),
+				lookbehind: !0,
+				inside: r.inside
+			}
+		],
+		keyword: t,
+		function: [e.languages.clike.function, {
+			pattern: /(::\s*)[a-z_]\w*/,
+			lookbehind: !0
+		}],
+		number: /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
+		operator: {
+			pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
+			lookbehind: !0
+		},
+		constant: /\b[A-Z][A-Z_\d]+\b/
+	}), e.languages.insertBefore("java", "string", {
+		"triple-quoted-string": {
+			pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
+			greedy: !0,
+			alias: "string"
+		},
+		char: {
+			pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
+			greedy: !0
+		}
+	}), e.languages.insertBefore("java", "class-name", {
+		annotation: {
+			pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
+			lookbehind: !0,
+			alias: "punctuation"
+		},
+		generics: {
+			pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
+			inside: {
+				"class-name": r,
+				keyword: t,
+				punctuation: /[<>(),.:]/,
+				operator: /[?&|]/
+			}
+		},
+		import: [{
+			pattern: RegExp("(\\bimport\\s+)" + n + "(?:[A-Z]\\w*|\\*)(?=\\s*;)"),
+			lookbehind: !0,
+			inside: {
+				namespace: r.inside.namespace,
+				punctuation: /\./,
+				operator: /\*/,
+				"class-name": /\w+/
+			}
+		}, {
+			pattern: RegExp("(\\bimport\\s+static\\s+)" + n + "(?:\\w+|\\*)(?=\\s*;)"),
+			lookbehind: !0,
+			alias: "static",
+			inside: {
+				namespace: r.inside.namespace,
+				static: /\b\w+$/,
+				punctuation: /\./,
+				operator: /\*/,
+				"class-name": /\w+/
+			}
+		}],
+		namespace: {
+			pattern: RegExp("(\\b(?:exports|import(?:\\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\\s+)(?!<keyword>)[a-z]\\w*(?:\\.[a-z]\\w*)*\\.?".replace(/<keyword>/g, function() {
+				return t.source;
+			})),
+			lookbehind: !0,
+			inside: { punctuation: /\./ }
+		}
+	});
+})(Prism), Prism.languages.c = Prism.languages.extend("clike", {
+	comment: {
+		pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
+		greedy: !0
+	},
+	string: {
+		pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+		greedy: !0
+	},
+	"class-name": {
+		pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
+		lookbehind: !0
+	},
+	keyword: /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
+	function: /\b[a-z_]\w*(?=\s*\()/i,
+	number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
+	operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
+}), Prism.languages.insertBefore("c", "string", { char: {
+	pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
+	greedy: !0
+} }), Prism.languages.insertBefore("c", "string", { macro: {
+	pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
+	lookbehind: !0,
+	greedy: !0,
+	alias: "property",
+	inside: {
+		string: [{
+			pattern: /^(#\s*include\s*)<[^>]+>/,
+			lookbehind: !0
+		}, Prism.languages.c.string],
+		char: Prism.languages.c.char,
+		comment: Prism.languages.c.comment,
+		"macro-name": [{
+			pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
+			lookbehind: !0
+		}, {
+			pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
+			lookbehind: !0,
+			alias: "function"
+		}],
+		directive: {
+			pattern: /^(#\s*)[a-z]+/,
+			lookbehind: !0,
+			alias: "keyword"
+		},
+		"directive-hash": /^#/,
+		punctuation: /##|\\(?=[\r\n])/,
+		expression: {
+			pattern: /\S[\s\S]*/,
+			inside: Prism.languages.c
+		}
+	}
+} }), Prism.languages.insertBefore("c", "function", { constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/ }), delete Prism.languages.c.boolean, (function(e) {
+	var t = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/, n = "\\b(?!<keyword>)\\w+(?:\\s*\\.\\s*\\w+)*\\b".replace(/<keyword>/g, function() {
+		return t.source;
+	});
+	e.languages.cpp = e.languages.extend("c", {
+		"class-name": [
+			{
+				pattern: RegExp("(\\b(?:class|concept|enum|struct|typename)\\s+)(?!<keyword>)\\w+".replace(/<keyword>/g, function() {
+					return t.source;
+				})),
+				lookbehind: !0
+			},
+			/\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,
+			/\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i,
+			/\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
+		],
+		keyword: t,
+		number: {
+			pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
+			greedy: !0
+		},
+		operator: />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
+		boolean: /\b(?:false|true)\b/
+	}), e.languages.insertBefore("cpp", "string", {
+		module: {
+			pattern: RegExp("(\\b(?:import|module)\\s+)(?:\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\"\\\\\\r\\n])*\"|<[^<>\\r\\n]*>|" + "<mod-name>(?:\\s*:\\s*<mod-name>)?|:\\s*<mod-name>".replace(/<mod-name>/g, function() {
+				return n;
+			}) + ")"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				string: /^[<"][\s\S]+/,
+				operator: /:/,
+				punctuation: /\./
+			}
+		},
+		"raw-string": {
+			pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
+			alias: "string",
+			greedy: !0
+		}
+	}), e.languages.insertBefore("cpp", "keyword", { "generic-function": {
+		pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
+		inside: {
+			function: /^\w+/,
+			generic: {
+				pattern: /<[\s\S]+/,
+				alias: "class-name",
+				inside: e.languages.cpp
+			}
+		}
+	} }), e.languages.insertBefore("cpp", "operator", { "double-colon": {
+		pattern: /::/,
+		alias: "punctuation"
+	} }), e.languages.insertBefore("cpp", "class-name", { "base-clause": {
+		pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
+		lookbehind: !0,
+		greedy: !0,
+		inside: e.languages.extend("cpp", {})
+	} }), e.languages.insertBefore("inside", "double-colon", { "class-name": /\b[a-z_]\w*\b(?!\s*::)/i }, e.languages.cpp["base-clause"]);
+})(Prism), (function(e) {
+	function t(e, t) {
+		return e.replace(/<<(\d+)>>/g, function(e, n) {
+			return "(?:" + t[+n] + ")";
+		});
+	}
+	function n(e, n, r) {
+		return RegExp(t(e, n), r || "");
+	}
+	function r(e, t) {
+		for (var n = 0; n < t; n++) e = e.replace(/<<self>>/g, function() {
+			return "(?:" + e + ")";
+		});
+		return e.replace(/<<self>>/g, "[^\\s\\S]");
+	}
+	var i = {
+		type: "bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void",
+		typeDeclaration: "class enum interface record struct",
+		contextual: "add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)",
+		other: "abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield"
+	};
+	function a(e) {
+		return "\\b(?:" + e.trim().replace(/ /g, "|") + ")\\b";
+	}
+	var o = a(i.typeDeclaration), s = RegExp(a(i.type + " " + i.typeDeclaration + " " + i.contextual + " " + i.other)), c = a(i.typeDeclaration + " " + i.contextual + " " + i.other), l = a(i.type + " " + i.typeDeclaration + " " + i.other), u = r("<(?:[^<>;=+\\-*/%&|^]|<<self>>)*>", 2), d = r("\\((?:[^()]|<<self>>)*\\)", 2), f = "@?\\b[A-Za-z_]\\w*\\b", p = t("<<0>>(?:\\s*<<1>>)?", [f, u]), m = t("(?!<<0>>)<<1>>(?:\\s*\\.\\s*<<1>>)*", [c, p]), h = "\\[\\s*(?:,\\s*)*\\]", g = t("<<0>>(?:\\s*(?:\\?\\s*)?<<1>>)*(?:\\s*\\?)?", [m, h]), _ = t("(?:<<0>>|<<1>>)(?:\\s*(?:\\?\\s*)?<<2>>)*(?:\\s*\\?)?", [
+		t("\\(<<0>>+(?:,<<0>>+)+\\)", [t("[^,()<>[\\];=+\\-*/%&|^]|<<0>>|<<1>>|<<2>>", [
+			u,
+			d,
+			h
+		])]),
+		m,
+		h
+	]), v = {
+		keyword: s,
+		punctuation: /[<>()?,.:[\]]/
+	}, y = "'(?:[^\\r\\n'\\\\]|\\\\.|\\\\[Uux][\\da-fA-F]{1,8})'", b = "\"(?:\\\\.|[^\\\\\"\\r\\n])*\"", x = "@\"(?:\"\"|\\\\[\\s\\S]|[^\\\\\"])*\"(?!\")";
+	e.languages.csharp = e.languages.extend("clike", {
+		string: [{
+			pattern: n("(^|[^$\\\\])<<0>>", [x]),
+			lookbehind: !0,
+			greedy: !0
+		}, {
+			pattern: n("(^|[^@$\\\\])<<0>>", [b]),
+			lookbehind: !0,
+			greedy: !0
+		}],
+		"class-name": [
+			{
+				pattern: n("(\\busing\\s+static\\s+)<<0>>(?=\\s*;)", [m]),
+				lookbehind: !0,
+				inside: v
+			},
+			{
+				pattern: n("(\\busing\\s+<<0>>\\s*=\\s*)<<1>>(?=\\s*;)", [f, _]),
+				lookbehind: !0,
+				inside: v
+			},
+			{
+				pattern: n("(\\busing\\s+)<<0>>(?=\\s*=)", [f]),
+				lookbehind: !0
+			},
+			{
+				pattern: n("(\\b<<0>>\\s+)<<1>>", [o, p]),
+				lookbehind: !0,
+				inside: v
+			},
+			{
+				pattern: n("(\\bcatch\\s*\\(\\s*)<<0>>", [m]),
+				lookbehind: !0,
+				inside: v
+			},
+			{
+				pattern: n("(\\bwhere\\s+)<<0>>", [f]),
+				lookbehind: !0
+			},
+			{
+				pattern: n("(\\b(?:is(?:\\s+not)?|as)\\s+)<<0>>", [g]),
+				lookbehind: !0,
+				inside: v
+			},
+			{
+				pattern: n("\\b<<0>>(?=\\s+(?!<<1>>|with\\s*\\{)<<2>>(?:\\s*[=,;:{)\\]]|\\s+(?:in|when)\\b))", [
+					_,
+					l,
+					f
+				]),
+				inside: v
+			}
+		],
+		keyword: s,
+		number: /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
+		operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
+		punctuation: /\?\.?|::|[{}[\];(),.:]/
+	}), e.languages.insertBefore("csharp", "number", { range: {
+		pattern: /\.\./,
+		alias: "operator"
+	} }), e.languages.insertBefore("csharp", "punctuation", { "named-parameter": {
+		pattern: n("([(,]\\s*)<<0>>(?=\\s*:)", [f]),
+		lookbehind: !0,
+		alias: "punctuation"
+	} }), e.languages.insertBefore("csharp", "class-name", {
+		namespace: {
+			pattern: n("(\\b(?:namespace|using)\\s+)<<0>>(?:\\s*\\.\\s*<<0>>)*(?=\\s*[;{])", [f]),
+			lookbehind: !0,
+			inside: { punctuation: /\./ }
+		},
+		"type-expression": {
+			pattern: n("(\\b(?:default|sizeof|typeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<<0>>)*(?=\\s*\\))", [d]),
+			lookbehind: !0,
+			alias: "class-name",
+			inside: v
+		},
+		"return-type": {
+			pattern: n("<<0>>(?=\\s+(?:<<1>>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))", [_, m]),
+			inside: v,
+			alias: "class-name"
+		},
+		"constructor-invocation": {
+			pattern: n("(\\bnew\\s+)<<0>>(?=\\s*[[({])", [_]),
+			lookbehind: !0,
+			inside: v,
+			alias: "class-name"
+		},
+		"generic-method": {
+			pattern: n("<<0>>\\s*<<1>>(?=\\s*\\()", [f, u]),
+			inside: {
+				function: n("^<<0>>", [f]),
+				generic: {
+					pattern: RegExp(u),
+					alias: "class-name",
+					inside: v
+				}
+			}
+		},
+		"type-list": {
+			pattern: n("\\b((?:<<0>>\\s+<<1>>|record\\s+<<1>>\\s*<<5>>|where\\s+<<2>>)\\s*:\\s*)(?:<<3>>|<<4>>|<<1>>\\s*<<5>>|<<6>>)(?:\\s*,\\s*(?:<<3>>|<<4>>|<<6>>))*(?=\\s*(?:where|[{;]|=>|$))", [
+				o,
+				p,
+				f,
+				_,
+				s.source,
+				d,
+				"\\bnew\\s*\\(\\s*\\)"
+			]),
+			lookbehind: !0,
+			inside: {
+				"record-arguments": {
+					pattern: n("(^(?!new\\s*\\()<<0>>\\s*)<<1>>", [p, d]),
+					lookbehind: !0,
+					greedy: !0,
+					inside: e.languages.csharp
+				},
+				keyword: s,
+				"class-name": {
+					pattern: RegExp(_),
+					greedy: !0,
+					inside: v
+				},
+				punctuation: /[,()]/
+			}
+		},
+		preprocessor: {
+			pattern: /(^[\t ]*)#.*/m,
+			lookbehind: !0,
+			alias: "property",
+			inside: { directive: {
+				pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
+				lookbehind: !0,
+				alias: "keyword"
+			} }
+		}
+	});
+	var S = b + "|" + y, C = t("\\/(?![*/])|\\/\\/[^\\r\\n]*[\\r\\n]|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|<<0>>", [S]), w = r(t("[^\"'/()]|<<0>>|\\(<<self>>*\\)", [C]), 2), T = "\\b(?:assembly|event|field|method|module|param|property|return|type)\\b", E = t("<<0>>(?:\\s*\\(<<1>>*\\))?", [m, w]);
+	e.languages.insertBefore("csharp", "class-name", { attribute: {
+		pattern: n("((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<<0>>\\s*:\\s*)?<<1>>(?:\\s*,\\s*<<1>>)*(?=\\s*\\])", [T, E]),
+		lookbehind: !0,
+		greedy: !0,
+		inside: {
+			target: {
+				pattern: n("^<<0>>(?=\\s*:)", [T]),
+				alias: "keyword"
+			},
+			"attribute-arguments": {
+				pattern: n("\\(<<0>>*\\)", [w]),
+				inside: e.languages.csharp
+			},
+			"class-name": {
+				pattern: RegExp(m),
+				inside: { punctuation: /\./ }
+			},
+			punctuation: /[:,]/
+		}
+	} });
+	var D = ":[^}\\r\\n]+", O = r(t("[^\"'/()]|<<0>>|\\(<<self>>*\\)", [C]), 2), k = t("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [O, D]), A = r(t("[^\"'/()]|\\/(?!\\*)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|<<0>>|\\(<<self>>*\\)", [S]), 2), j = t("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [A, D]);
+	function M(t, r) {
+		return {
+			interpolation: {
+				pattern: n("((?:^|[^{])(?:\\{\\{)*)<<0>>", [t]),
+				lookbehind: !0,
+				inside: {
+					"format-string": {
+						pattern: n("(^\\{(?:(?![}:])<<0>>)*)<<1>>(?=\\}$)", [r, D]),
+						lookbehind: !0,
+						inside: { punctuation: /^:/ }
+					},
+					punctuation: /^\{|\}$/,
+					expression: {
+						pattern: /[\s\S]+/,
+						alias: "language-csharp",
+						inside: e.languages.csharp
+					}
+				}
+			},
+			string: /[\s\S]+/
+		};
+	}
+	e.languages.insertBefore("csharp", "string", {
+		"interpolation-string": [{
+			pattern: n("(^|[^\\\\])(?:\\$@|@\\$)\"(?:\"\"|\\\\[\\s\\S]|\\{\\{|<<0>>|[^\\\\{\"])*\"", [k]),
+			lookbehind: !0,
+			greedy: !0,
+			inside: M(k, O)
+		}, {
+			pattern: n("(^|[^@\\\\])\\$\"(?:\\\\.|\\{\\{|<<0>>|[^\\\\\"{])*\"", [j]),
+			lookbehind: !0,
+			greedy: !0,
+			inside: M(j, A)
+		}],
+		char: {
+			pattern: RegExp(y),
+			greedy: !0
+		}
+	}), e.languages.dotnet = e.languages.cs = e.languages.csharp;
+})(Prism), (function(e) {
+	e.languages.ruby = e.languages.extend("clike", {
+		comment: {
+			pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
+			greedy: !0
+		},
+		"class-name": {
+			pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
+			lookbehind: !0,
+			inside: { punctuation: /[.\\]/ }
+		},
+		keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
+		operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
+		punctuation: /[(){}[\].,;]/
+	}), e.languages.insertBefore("ruby", "operator", { "double-colon": {
+		pattern: /::/,
+		alias: "punctuation"
+	} });
+	var t = {
+		pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
+		lookbehind: !0,
+		inside: {
+			content: {
+				pattern: /^(#\{)[\s\S]+(?=\}$)/,
+				lookbehind: !0,
+				inside: e.languages.ruby
+			},
+			delimiter: {
+				pattern: /^#\{|\}$/,
+				alias: "punctuation"
+			}
+		}
+	};
+	delete e.languages.ruby.function;
+	var n = "(?:" + [
+		"([^a-zA-Z0-9\\s{(\\[<=])(?:(?!\\1)[^\\\\]|\\\\[\\s\\S])*\\1",
+		"\\((?:[^()\\\\]|\\\\[\\s\\S]|\\((?:[^()\\\\]|\\\\[\\s\\S])*\\))*\\)",
+		"\\{(?:[^{}\\\\]|\\\\[\\s\\S]|\\{(?:[^{}\\\\]|\\\\[\\s\\S])*\\})*\\}",
+		"\\[(?:[^\\[\\]\\\\]|\\\\[\\s\\S]|\\[(?:[^\\[\\]\\\\]|\\\\[\\s\\S])*\\])*\\]",
+		"<(?:[^<>\\\\]|\\\\[\\s\\S]|<(?:[^<>\\\\]|\\\\[\\s\\S])*>)*>"
+	].join("|") + ")", r = "(?:\"(?:\\\\.|[^\"\\\\\\r\\n])*\"|(?:\\b[a-zA-Z_]\\w*|[^\\s\\0-\\x7F]+)[?!]?|\\$.)";
+	e.languages.insertBefore("ruby", "keyword", {
+		"regex-literal": [{
+			pattern: RegExp("%r" + n + "[egimnosux]{0,6}"),
+			greedy: !0,
+			inside: {
+				interpolation: t,
+				regex: /[\s\S]+/
+			}
+		}, {
+			pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				interpolation: t,
+				regex: /[\s\S]+/
+			}
+		}],
+		variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
+		symbol: [{
+			pattern: RegExp("(^|[^:]):" + r),
+			lookbehind: !0,
+			greedy: !0
+		}, {
+			pattern: RegExp("([\\r\\n{(,][ \\t]*)" + r + "(?=:(?!:))"),
+			lookbehind: !0,
+			greedy: !0
+		}],
+		"method-definition": {
+			pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
+			lookbehind: !0,
+			inside: {
+				function: /\b\w+$/,
+				keyword: /^self\b/,
+				"class-name": /^\w+/,
+				punctuation: /\./
+			}
+		}
+	}), e.languages.insertBefore("ruby", "string", {
+		"string-literal": [
+			{
+				pattern: RegExp("%[qQiIwWs]?" + n),
+				greedy: !0,
+				inside: {
+					interpolation: t,
+					string: /[\s\S]+/
+				}
+			},
+			{
+				pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
+				greedy: !0,
+				inside: {
+					interpolation: t,
+					string: /[\s\S]+/
+				}
+			},
+			{
+				pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+				alias: "heredoc-string",
+				greedy: !0,
+				inside: {
+					delimiter: {
+						pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
+						inside: {
+							symbol: /\b\w+/,
+							punctuation: /^<<[-~]?/
+						}
+					},
+					interpolation: t,
+					string: /[\s\S]+/
+				}
+			},
+			{
+				pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+				alias: "heredoc-string",
+				greedy: !0,
+				inside: {
+					delimiter: {
+						pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
+						inside: {
+							symbol: /\b\w+/,
+							punctuation: /^<<[-~]?'|'$/
+						}
+					},
+					string: /[\s\S]+/
+				}
+			}
+		],
+		"command-literal": [{
+			pattern: RegExp("%x" + n),
+			greedy: !0,
+			inside: {
+				interpolation: t,
+				command: {
+					pattern: /[\s\S]+/,
+					alias: "string"
+				}
+			}
+		}, {
+			pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
+			greedy: !0,
+			inside: {
+				interpolation: t,
+				command: {
+					pattern: /[\s\S]+/,
+					alias: "string"
+				}
+			}
+		}]
+	}), delete e.languages.ruby.string, e.languages.insertBefore("ruby", "number", {
+		builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
+		constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
+	}), e.languages.rb = e.languages.ruby;
+})(Prism), (function(e) {
+	var t = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/, n = [
+		{
+			pattern: /\b(?:false|true)\b/i,
+			alias: "boolean"
+		},
+		{
+			pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
+			greedy: !0,
+			lookbehind: !0
+		},
+		{
+			pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
+			greedy: !0,
+			lookbehind: !0
+		},
+		/\b(?:null)\b/i,
+		/\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/
+	], r = /\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[\da-f]+(?:_[\da-f]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i, i = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/, a = /[{}\[\](),:;]/;
+	e.languages.php = {
+		delimiter: {
+			pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
+			alias: "important"
+		},
+		comment: t,
+		variable: /\$+(?:\w+\b|(?=\{))/,
+		package: {
+			pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+			lookbehind: !0,
+			inside: { punctuation: /\\/ }
+		},
+		"class-name-definition": {
+			pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
+			lookbehind: !0,
+			alias: "class-name"
+		},
+		"function-definition": {
+			pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
+			lookbehind: !0,
+			alias: "function"
+		},
+		keyword: [
+			{
+				pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
+				alias: "type-casting",
+				greedy: !0,
+				lookbehind: !0
+			},
+			{
+				pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
+				alias: "type-hint",
+				greedy: !0,
+				lookbehind: !0
+			},
+			{
+				pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|never|object|self|static|string|void)\b/i,
+				alias: "return-type",
+				greedy: !0,
+				lookbehind: !0
+			},
+			{
+				pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
+				alias: "type-declaration",
+				greedy: !0
+			},
+			{
+				pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
+				alias: "type-declaration",
+				greedy: !0,
+				lookbehind: !0
+			},
+			{
+				pattern: /\b(?:parent|self|static)(?=\s*::)/i,
+				alias: "static-context",
+				greedy: !0
+			},
+			{
+				pattern: /(\byield\s+)from\b/i,
+				lookbehind: !0
+			},
+			/\bclass\b/i,
+			{
+				pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|never|new|or|parent|print|private|protected|public|readonly|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i,
+				lookbehind: !0
+			}
+		],
+		"argument-name": {
+			pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i,
+			lookbehind: !0
+		},
+		"class-name": [
+			{
+				pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
+				greedy: !0,
+				lookbehind: !0
+			},
+			{
+				pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
+				greedy: !0,
+				lookbehind: !0
+			},
+			{
+				pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
+				greedy: !0
+			},
+			{
+				pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
+				alias: "class-name-fully-qualified",
+				greedy: !0,
+				lookbehind: !0,
+				inside: { punctuation: /\\/ }
+			},
+			{
+				pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
+				alias: "class-name-fully-qualified",
+				greedy: !0,
+				inside: { punctuation: /\\/ }
+			},
+			{
+				pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+				alias: "class-name-fully-qualified",
+				greedy: !0,
+				lookbehind: !0,
+				inside: { punctuation: /\\/ }
+			},
+			{
+				pattern: /\b[a-z_]\w*(?=\s*\$)/i,
+				alias: "type-declaration",
+				greedy: !0
+			},
+			{
+				pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+				alias: ["class-name-fully-qualified", "type-declaration"],
+				greedy: !0,
+				inside: { punctuation: /\\/ }
+			},
+			{
+				pattern: /\b[a-z_]\w*(?=\s*::)/i,
+				alias: "static-context",
+				greedy: !0
+			},
+			{
+				pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
+				alias: ["class-name-fully-qualified", "static-context"],
+				greedy: !0,
+				inside: { punctuation: /\\/ }
+			},
+			{
+				pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
+				alias: "type-hint",
+				greedy: !0,
+				lookbehind: !0
+			},
+			{
+				pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+				alias: ["class-name-fully-qualified", "type-hint"],
+				greedy: !0,
+				lookbehind: !0,
+				inside: { punctuation: /\\/ }
+			},
+			{
+				pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
+				alias: "return-type",
+				greedy: !0,
+				lookbehind: !0
+			},
+			{
+				pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+				alias: ["class-name-fully-qualified", "return-type"],
+				greedy: !0,
+				lookbehind: !0,
+				inside: { punctuation: /\\/ }
+			}
+		],
+		constant: n,
+		function: {
+			pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
+			lookbehind: !0,
+			inside: { punctuation: /\\/ }
+		},
+		property: {
+			pattern: /(->\s*)\w+/,
+			lookbehind: !0
+		},
+		number: r,
+		operator: i,
+		punctuation: a
+	};
+	var o = {
+		pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
+		lookbehind: !0,
+		inside: e.languages.php
+	}, s = [
+		{
+			pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
+			alias: "nowdoc-string",
+			greedy: !0,
+			inside: { delimiter: {
+				pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
+				alias: "symbol",
+				inside: { punctuation: /^<<<'?|[';]$/ }
+			} }
+		},
+		{
+			pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
+			alias: "heredoc-string",
+			greedy: !0,
+			inside: {
+				delimiter: {
+					pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
+					alias: "symbol",
+					inside: { punctuation: /^<<<"?|[";]$/ }
+				},
+				interpolation: o
+			}
+		},
+		{
+			pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+			alias: "backtick-quoted-string",
+			greedy: !0
+		},
+		{
+			pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+			alias: "single-quoted-string",
+			greedy: !0
+		},
+		{
+			pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+			alias: "double-quoted-string",
+			greedy: !0,
+			inside: { interpolation: o }
+		}
+	];
+	e.languages.insertBefore("php", "variable", {
+		string: s,
+		attribute: {
+			pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
+			greedy: !0,
+			inside: {
+				"attribute-content": {
+					pattern: /^(#\[)[\s\S]+(?=\]$)/,
+					lookbehind: !0,
+					inside: {
+						comment: t,
+						string: s,
+						"attribute-class-name": [{
+							pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
+							alias: "class-name",
+							greedy: !0,
+							lookbehind: !0
+						}, {
+							pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
+							alias: ["class-name", "class-name-fully-qualified"],
+							greedy: !0,
+							lookbehind: !0,
+							inside: { punctuation: /\\/ }
+						}],
+						constant: n,
+						number: r,
+						operator: i,
+						punctuation: a
+					}
+				},
+				delimiter: {
+					pattern: /^#\[|\]$/,
+					alias: "punctuation"
+				}
+			}
+		}
+	}), e.hooks.add("before-tokenize", function(t) {
+		/<\?/.test(t.code) && e.languages["markup-templating"].buildPlaceholders(t, "php", /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g);
+	}), e.hooks.add("after-tokenize", function(t) {
+		e.languages["markup-templating"].tokenizePlaceholders(t, "php");
+	});
+})(Prism), Prism.languages.swift = {
+	comment: {
+		pattern: /(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/,
+		lookbehind: !0,
+		greedy: !0
+	},
+	"string-literal": [{
+		pattern: RegExp("(^|[^\"#])(?:\"(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|\\r\\n|[^(])|[^\\\\\\r\\n\"])*\"|\"\"\"(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|[^(])|[^\\\\\"]|\"(?!\"\"))*\"\"\")(?![\"#])"),
+		lookbehind: !0,
+		greedy: !0,
+		inside: {
+			interpolation: {
+				pattern: /(\\\()(?:[^()]|\([^()]*\))*(?=\))/,
+				lookbehind: !0,
+				inside: null
+			},
+			"interpolation-punctuation": {
+				pattern: /^\)|\\\($/,
+				alias: "punctuation"
+			},
+			punctuation: /\\(?=[\r\n])/,
+			string: /[\s\S]+/
+		}
+	}, {
+		pattern: RegExp("(^|[^\"#])(#+)(?:\"(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|\\r\\n|[^#])|[^\\\\\\r\\n])*?\"|\"\"\"(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|[^#])|[^\\\\])*?\"\"\")\\2"),
+		lookbehind: !0,
+		greedy: !0,
+		inside: {
+			interpolation: {
+				pattern: /(\\#+\()(?:[^()]|\([^()]*\))*(?=\))/,
+				lookbehind: !0,
+				inside: null
+			},
+			"interpolation-punctuation": {
+				pattern: /^\)|\\#+\($/,
+				alias: "punctuation"
+			},
+			string: /[\s\S]+/
+		}
+	}],
+	directive: {
+		pattern: RegExp("#(?:(?:elseif|if)\\b(?:[ 	]*(?:![ \\t]*)?(?:\\b\\w+\\b(?:[ \\t]*\\((?:[^()]|\\([^()]*\\))*\\))?|\\((?:[^()]|\\([^()]*\\))*\\))(?:[ \\t]*(?:&&|\\|\\|))?)+|(?:else|endif)\\b)"),
+		alias: "property",
+		inside: {
+			"directive-name": /^#\w+/,
+			boolean: /\b(?:false|true)\b/,
+			number: /\b\d+(?:\.\d+)*\b/,
+			operator: /!|&&|\|\||[<>]=?/,
+			punctuation: /[(),]/
+		}
+	},
+	literal: {
+		pattern: /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/,
+		alias: "constant"
+	},
+	"other-directive": {
+		pattern: /#\w+\b/,
+		alias: "property"
+	},
+	attribute: {
+		pattern: /@\w+/,
+		alias: "atrule"
+	},
+	"function-definition": {
+		pattern: /(\bfunc\s+)\w+/,
+		lookbehind: !0,
+		alias: "function"
+	},
+	label: {
+		pattern: /\b(break|continue)\s+\w+|\b[a-zA-Z_]\w*(?=\s*:\s*(?:for|repeat|while)\b)/,
+		lookbehind: !0,
+		alias: "important"
+	},
+	keyword: /\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/,
+	boolean: /\b(?:false|true)\b/,
+	nil: {
+		pattern: /\bnil\b/,
+		alias: "constant"
+	},
+	"short-argument": /\$\d+\b/,
+	omit: {
+		pattern: /\b_\b/,
+		alias: "keyword"
+	},
+	number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f0-9_]+(?:\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
+	"class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/,
+	function: /\b[a-z_]\w*(?=\s*\()/i,
+	constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
+	operator: /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/,
+	punctuation: /[{}[\]();,.:\\]/
+}, Prism.languages.swift["string-literal"].forEach(function(e) {
+	e.inside.interpolation.inside = Prism.languages.swift;
+}), (function(e) {
+	e.languages.kotlin = e.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: !0
+		},
+		function: [{
+			pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/,
+			greedy: !0
+		}, {
+			pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/,
+			lookbehind: !0,
+			greedy: !0
+		}],
+		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 e.languages.kotlin["class-name"];
+	var t = {
+		"interpolation-punctuation": {
+			pattern: /^\$\{?|\}$/,
+			alias: "punctuation"
+		},
+		expression: {
+			pattern: /[\s\S]+/,
+			inside: e.languages.kotlin
+		}
+	};
+	e.languages.insertBefore("kotlin", "string", {
+		"string-literal": [{
+			pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
+			alias: "multiline",
+			inside: {
+				interpolation: {
+					pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+					inside: t
+				},
+				string: /[\s\S]+/
+			}
+		}, {
+			pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/,
+			alias: "singleline",
+			inside: {
+				interpolation: {
+					pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+					lookbehind: !0,
+					inside: t
+				},
+				string: /[\s\S]+/
+			}
+		}],
+		char: {
+			pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/,
+			greedy: !0
+		}
+	}), delete e.languages.kotlin.string, e.languages.insertBefore("kotlin", "keyword", { annotation: {
+		pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
+		alias: "builtin"
+	} }), e.languages.insertBefore("kotlin", "function", { label: {
+		pattern: /\b\w+@|@\w+\b/,
+		alias: "symbol"
+	} }), e.languages.kt = e.languages.kotlin, e.languages.kts = e.languages.kotlin;
+})(Prism), (function(e) {
+	var t = [/\b(?:async|sync|yield)\*/, /\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|final|finally|for|get|hide|if|implements|import|in|interface|library|mixin|new|null|on|operator|part|rethrow|return|set|show|static|super|switch|sync|this|throw|try|typedef|var|void|while|with|yield)\b/], n = "(^|[^\\w.])(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*", r = {
+		pattern: RegExp(n + "[A-Z](?:[\\d_A-Z]*[a-z]\\w*)?\\b"),
+		lookbehind: !0,
+		inside: { namespace: {
+			pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+			inside: { punctuation: /\./ }
+		} }
+	};
+	e.languages.dart = e.languages.extend("clike", {
+		"class-name": [r, {
+			pattern: RegExp(n + "[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()])"),
+			lookbehind: !0,
+			inside: r.inside
+		}],
+		keyword: t,
+		operator: /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
+	}), e.languages.insertBefore("dart", "string", {
+		"string-literal": {
+			pattern: /r?(?:("""|''')[\s\S]*?\1|(["'])(?:\\.|(?!\2)[^\\\r\n])*\2(?!\2))/,
+			greedy: !0,
+			inside: {
+				interpolation: {
+					pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,
+					lookbehind: !0,
+					inside: {
+						punctuation: /^\$\{?|\}$/,
+						expression: {
+							pattern: /[\s\S]+/,
+							inside: e.languages.dart
+						}
+					}
+				},
+				string: /[\s\S]+/
+			}
+		},
+		string: void 0
+	}), e.languages.insertBefore("dart", "class-name", { metadata: {
+		pattern: /@\w+/,
+		alias: "function"
+	} }), e.languages.insertBefore("dart", "class-name", { generics: {
+		pattern: /<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/,
+		inside: {
+			"class-name": r,
+			keyword: t,
+			punctuation: /[<>(),.:]/,
+			operator: /[?&|]/
+		}
+	} });
+})(Prism), Prism.languages.markup = {
+	comment: {
+		pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+		greedy: !0
+	},
+	prolog: {
+		pattern: /<\?[\s\S]+?\?>/,
+		greedy: !0
+	},
+	doctype: {
+		pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+		greedy: !0,
+		inside: {
+			"internal-subset": {
+				pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+				lookbehind: !0,
+				greedy: !0,
+				inside: null
+			},
+			string: {
+				pattern: /"[^"]*"|'[^']*'/,
+				greedy: !0
+			},
+			punctuation: /^<!|>$|[[\]]/,
+			"doctype-tag": /^DOCTYPE/i,
+			name: /[^\s<>'"]+/
+		}
+	},
+	cdata: {
+		pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+		greedy: !0
+	},
+	tag: {
+		pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+		greedy: !0,
+		inside: {
+			tag: {
+				pattern: /^<\/?[^\s>\/]+/,
+				inside: {
+					punctuation: /^<\/?/,
+					namespace: /^[^\s>\/:]+:/
+				}
+			},
+			"special-attr": [],
+			"attr-value": {
+				pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+				inside: { punctuation: [{
+					pattern: /^=/,
+					alias: "attr-equals"
+				}, {
+					pattern: /^(\s*)["']|["']$/,
+					lookbehind: !0
+				}] }
+			},
+			punctuation: /\/?>/,
+			"attr-name": {
+				pattern: /[^\s>\/]+/,
+				inside: { namespace: /^[^\s>\/:]+:/ }
+			}
+		}
+	},
+	entity: [{
+		pattern: /&[\da-z]{1,8};/i,
+		alias: "named-entity"
+	}, /&#x?[\da-f]{1,8};/i]
+}, Prism.languages.markup.tag.inside["attr-value"].inside.entity = Prism.languages.markup.entity, Prism.languages.markup.doctype.inside["internal-subset"].inside = Prism.languages.markup, Prism.hooks.add("wrap", function(e) {
+	e.type === "entity" && (e.attributes.title = e.content.replace(/&amp;/, "&"));
+}), Object.defineProperty(Prism.languages.markup.tag, "addInlined", { value: function(e, t) {
+	var n = {};
+	n["language-" + t] = {
+		pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+		lookbehind: !0,
+		inside: Prism.languages[t]
+	}, n.cdata = /^<!\[CDATA\[|\]\]>$/i;
+	var r = { "included-cdata": {
+		pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+		inside: n
+	} };
+	r["language-" + t] = {
+		pattern: /[\s\S]+/,
+		inside: Prism.languages[t]
+	};
+	var i = {};
+	i[e] = {
+		pattern: RegExp("(<__[^>]*>)(?:<!\\[CDATA\\[(?:[^\\]]|\\](?!\\]>))*\\]\\]>|(?!<!\\[CDATA\\[)[\\s\\S])*?(?=<\\/__>)".replace(/__/g, function() {
+			return e;
+		}), "i"),
+		lookbehind: !0,
+		greedy: !0,
+		inside: r
+	}, Prism.languages.insertBefore("markup", "cdata", i);
+} }), Object.defineProperty(Prism.languages.markup.tag, "addAttribute", { value: function(e, t) {
+	Prism.languages.markup.tag.inside["special-attr"].push({
+		pattern: RegExp("(^|[\"'\\s])(?:" + e + ")\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+(?=[\\s>]))", "i"),
+		lookbehind: !0,
+		inside: {
+			"attr-name": /^[^\s=]+/,
+			"attr-value": {
+				pattern: /=[\s\S]+/,
+				inside: {
+					value: {
+						pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+						lookbehind: !0,
+						alias: [t, "language-" + t],
+						inside: Prism.languages[t]
+					},
+					punctuation: [{
+						pattern: /^=/,
+						alias: "attr-equals"
+					}, /"|'/]
+				}
+			}
+		}
+	});
+} }), Prism.languages.html = Prism.languages.markup, Prism.languages.mathml = Prism.languages.markup, Prism.languages.svg = Prism.languages.markup, Prism.languages.xml = Prism.languages.extend("markup", {}), Prism.languages.ssml = Prism.languages.xml, Prism.languages.atom = Prism.languages.xml, Prism.languages.rss = Prism.languages.xml;
+var LANG_ALIASES = {
+	js: "javascript",
+	ts: "typescript",
+	py: "python",
+	rb: "ruby",
+	sh: "bash",
+	shell: "bash",
+	zsh: "bash",
+	yml: "yaml",
+	html: "markup",
+	xml: "markup",
+	svg: "markup",
+	cs: "csharp",
+	"c++": "cpp",
+	"objective-c": "c",
+	objc: "c",
+	jsonc: "json"
+};
+function escapeHtml$1(e) {
+	return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function highlightCode(e, t) {
+	if (!t) return escapeHtml$1(e);
+	let n = t.toLowerCase().trim(), r = LANG_ALIASES[n] || n, i = import_prism.default.languages[r];
+	if (!i) return escapeHtml$1(e);
+	try {
+		return import_prism.default.highlight(e, i, r);
+	} catch {
+		return escapeHtml$1(e);
+	}
+}
+function getLanguageDisplayName(e) {
+	return {
+		javascript: "JavaScript",
+		typescript: "TypeScript",
+		python: "Python",
+		bash: "Bash",
+		json: "JSON",
+		css: "CSS",
+		html: "HTML",
+		jsx: "JSX",
+		tsx: "TSX",
+		sql: "SQL",
+		yaml: "YAML",
+		rust: "Rust",
+		go: "Go",
+		java: "Java",
+		c: "C",
+		cpp: "C++",
+		csharp: "C#",
+		ruby: "Ruby",
+		php: "PHP",
+		swift: "Swift",
+		kotlin: "Kotlin",
+		dart: "Dart",
+		markdown: "Markdown",
+		markup: "HTML"
+	}[LANG_ALIASES[e.toLowerCase()] || e.toLowerCase()] || e;
+}
+var COLORS = [
+	"#6366f1",
+	"#8b5cf6",
+	"#a855f7",
+	"#d946ef",
+	"#ec4899",
+	"#f43f5e",
+	"#ef4444",
+	"#f97316",
+	"#eab308",
+	"#84cc16",
+	"#22c55e",
+	"#14b8a6",
+	"#06b6d4",
+	"#3b82f6",
+	"#2563eb"
+], NODE_COLORS = {
+	fill: "#e0e7ff",
+	stroke: "#6366f1",
+	text: "#1e1b4b",
+	bg: "#f8fafc"
+};
+function escapeXml(e) {
+	return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function measureText(e, t = 14) {
+	return e.length * t * .6 + 20;
+}
+function parseFlowchart(e) {
+	let t = /* @__PURE__ */ new Map(), n = [], r = "TB", i = (e[0]?.trim() || "").match(/^(?:graph|flowchart)\s+(TB|BT|LR|RL)/i);
+	i && (r = i[1].toUpperCase());
+	let a = /^(\w+)(\[([^\]]*)\]|\(([^)]*)\)|\{([^}]*)\}|>([^\]]*)\]|\[\[([^\]]*)\]\]|\(\(([^)]*)\)\)|\[\/([^\]]*)\\\]|\[\(([^)]*)\)\])/;
+	function o(e, n, r) {
+		if (!t.has(e)) t.set(e, {
+			id: e,
+			label: n || e,
+			shape: r || "rect",
+			x: 0,
+			y: 0,
+			width: 0,
+			height: 0
+		});
+		else if (n) {
+			let i = t.get(e);
+			i.label = n, r && (i.shape = r);
+		}
+	}
+	function s(e) {
+		e = e.trim();
+		let t = e.match(a);
+		if (t) {
+			let e = t[1];
+			if (t[3] !== void 0) return {
+				id: e,
+				label: t[3],
+				shape: "rect"
+			};
+			if (t[4] !== void 0) return {
+				id: e,
+				label: t[4],
+				shape: "round"
+			};
+			if (t[5] !== void 0) return {
+				id: e,
+				label: t[5],
+				shape: "diamond"
+			};
+			if (t[6] !== void 0) return {
+				id: e,
+				label: t[6],
+				shape: "stadium"
+			};
+			if (t[7] !== void 0) return {
+				id: e,
+				label: t[7],
+				shape: "rect"
+			};
+			if (t[8] !== void 0) return {
+				id: e,
+				label: t[8],
+				shape: "circle"
+			};
+			if (t[9] !== void 0) return {
+				id: e,
+				label: t[9],
+				shape: "parallelogram"
+			};
+			if (t[10] !== void 0) return {
+				id: e,
+				label: t[10],
+				shape: "cylinder"
+			};
+		}
+		let n = e.replace(/\s+/g, "");
+		return {
+			id: n,
+			label: n,
+			shape: "rect"
+		};
+	}
+	for (let t = 1; t < e.length; t++) {
+		let r = e[t].trim();
+		if (!r || r.startsWith("%%") || r.startsWith("style") || r.startsWith("class") || r.startsWith("click")) continue;
+		let i = r.match(/^(.+?)\s*(-->|---|-\.->|-\.{2,}->|==>|-.->|--\>|--)\s*(?:\|([^|]*)\|)?\s*(.+?)$/);
+		if (i) {
+			let e = i[1].trim(), t = i[2], r = i[3]?.trim() || "", a = i[4].trim(), c = s(e), l = s(a);
+			o(c.id, c.label, c.shape), o(l.id, l.label, l.shape);
+			let u = "solid", d = !0;
+			t === "---" ? (d = !1, u = "solid") : t.includes("-.") || t.includes("..") ? u = "dotted" : t === "==>" && (u = "thick"), n.push({
+				from: c.id,
+				to: l.id,
+				label: r,
+				style: u,
+				arrow: d
+			});
+		} else {
+			let e = s(r);
+			e.id && o(e.id, e.label, e.shape);
+		}
+	}
+	return {
+		nodes: Array.from(t.values()),
+		edges: n,
+		direction: r
+	};
+}
+function layoutFlowchart(e, t, n) {
+	if (e.length === 0) return {
+		width: 200,
+		height: 100
+	};
+	let r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+	for (let t of e) r.set(t.id, []), i.set(t.id, 0);
+	for (let e of t) r.get(e.from)?.push(e.to), i.set(e.to, (i.get(e.to) || 0) + 1);
+	let a = [], o = /* @__PURE__ */ new Set(), s = [];
+	for (let t of e) (i.get(t.id) || 0) === 0 && s.push(t.id);
+	for (s.length === 0 && e.length > 0 && s.push(e[0].id); s.length > 0;) {
+		let e = [...s];
+		a.push(e), s.length = 0;
+		for (let t of e) {
+			o.add(t);
+			for (let e of r.get(t) || []) if (!o.has(e)) {
+				let t = (i.get(e) || 1) - 1;
+				i.set(e, t), t <= 0 && s.push(e);
+			}
+		}
+	}
+	for (let t of e) o.has(t.id) || a.push([t.id]);
+	let c = n === "LR" || n === "RL", l = new Map(e.map((e) => [e.id, e]));
+	for (let e = 0; e < a.length; e++) {
+		let t = a[e], n = t.length;
+		for (let r = 0; r < n; r++) {
+			let i = l.get(t[r]);
+			i && (i.width = Math.max(140, measureText(i.label)), i.height = 50, c ? (i.x = e * 200 + 40, i.y = r * 110 + 40 - (n - 1) * 110 / 2 + 200) : (i.x = r * 200 + 40 - (n - 1) * 200 / 2 + 400, i.y = e * 110 + 40));
+		}
+	}
+	let u = Infinity, d = Infinity, f = -Infinity, p = -Infinity;
+	for (let t of e) u = Math.min(u, t.x), d = Math.min(d, t.y), f = Math.max(f, t.x + t.width), p = Math.max(p, t.y + t.height);
+	for (let t of e) t.x -= u - 40, t.y -= d - 40;
+	return {
+		width: f - u + 80,
+		height: p - d + 80
+	};
+}
+function renderFlowchartSVG(e) {
+	let { nodes: t, edges: n, direction: r } = parseFlowchart(e.split("\n").filter((e) => e.trim())), { width: i, height: a } = layoutFlowchart(t, n, r), o = new Map(t.map((e) => [e.id, e])), s = "";
+	s += `<defs>
+    <marker id="arrowhead" markerWidth="10" markerHeight="7" refX="10" refY="3.5" orient="auto">
+      <polygon points="0 0, 10 3.5, 0 7" fill="${NODE_COLORS.stroke}" />
+    </marker>
+    <marker id="arrowhead-thick" markerWidth="10" markerHeight="7" refX="10" refY="3.5" orient="auto">
+      <polygon points="0 0, 10 3.5, 0 7" fill="${NODE_COLORS.stroke}" />
+    </marker>
+  </defs>`;
+	for (let e of n) {
+		let t = o.get(e.from), n = o.get(e.to);
+		if (!t || !n) continue;
+		let r = t.x + t.width / 2, i = t.y + t.height / 2, a = n.x + n.width / 2, c = n.y + n.height / 2, l = Math.atan2(c - i, a - r), u = r + Math.cos(l) * (t.width / 2), d = i + Math.sin(l) * (t.height / 2), f = a - Math.cos(l) * (n.width / 2), p = c - Math.sin(l) * (n.height / 2), m = e.style === "dotted" ? "stroke-dasharray=\"5,5\"" : "", h = e.style === "thick" ? "3" : "1.5", g = e.arrow ? "marker-end=\"url(#arrowhead)\"" : "";
+		if (s += `<line x1="${u}" y1="${d}" x2="${f}" y2="${p}"
+      stroke="${NODE_COLORS.stroke}" stroke-width="${h}" ${m} ${g} />`, e.label) {
+			let t = (u + f) / 2, n = (d + p) / 2;
+			s += `<rect x="${t - measureText(e.label, 11) / 2}" y="${n - 10}" width="${measureText(e.label, 11)}" height="20" fill="white" rx="3" />`, s += `<text x="${t}" y="${n + 4}" text-anchor="middle" font-size="11" fill="${NODE_COLORS.text}">${escapeXml(e.label)}</text>`;
+		}
+	}
+	for (let e of t) {
+		let t = e.x + e.width / 2, n = e.y + e.height / 2;
+		switch (e.shape) {
+			case "round":
+				s += `<rect x="${e.x}" y="${e.y}" width="${e.width}" height="${e.height}"
+          rx="15" ry="15" fill="${NODE_COLORS.fill}" stroke="${NODE_COLORS.stroke}" stroke-width="2" />`;
+				break;
+			case "diamond":
+				s += `<polygon points="${t},${e.y} ${e.x + e.width},${n} ${t},${e.y + e.height} ${e.x},${n}"
+          fill="${NODE_COLORS.fill}" stroke="${NODE_COLORS.stroke}" stroke-width="2" />`;
+				break;
+			case "circle":
+				let r = Math.max(e.width, e.height) / 2;
+				s += `<circle cx="${t}" cy="${n}" r="${r}" fill="${NODE_COLORS.fill}" stroke="${NODE_COLORS.stroke}" stroke-width="2" />`;
+				break;
+			case "stadium":
+				s += `<rect x="${e.x}" y="${e.y}" width="${e.width}" height="${e.height}"
+          rx="${e.height / 2}" ry="${e.height / 2}" fill="${NODE_COLORS.fill}" stroke="${NODE_COLORS.stroke}" stroke-width="2" />`;
+				break;
+			default: s += `<rect x="${e.x}" y="${e.y}" width="${e.width}" height="${e.height}"
+          rx="5" ry="5" fill="${NODE_COLORS.fill}" stroke="${NODE_COLORS.stroke}" stroke-width="2" />`;
+		}
+		s += `<text x="${t}" y="${n + 5}" text-anchor="middle" font-size="13" font-family="system-ui, sans-serif" fill="${NODE_COLORS.text}">${escapeXml(e.label)}</text>`;
+	}
+	return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${i} ${a}" width="100%" class="mermaid-svg" style="max-width:${i}px;">
+    <rect width="100%" height="100%" fill="${NODE_COLORS.bg}" rx="8" />
+    ${s}
+  </svg>`;
+}
+function renderSequenceDiagram(e) {
+	let t = e.split("\n").map((e) => e.trim()).filter((e) => e && !e.startsWith("%%")), n = [], r = [], i = /* @__PURE__ */ new Map();
+	function a(e, t) {
+		if (i.has(e)) t && (i.get(e).label = t);
+		else {
+			let r = {
+				id: e,
+				label: t || e,
+				x: 0
+			};
+			n.push(r), i.set(e, r);
+		}
+	}
+	for (let e = 1; e < t.length; e++) {
+		let n = t[e], i = n.match(/^participant\s+(\w+)(?:\s+as\s+(.+))?$/i);
+		if (i) {
+			a(i[1], i[2] || i[1]);
+			continue;
+		}
+		let o = n.match(/^actor\s+(\w+)(?:\s+as\s+(.+))?$/i);
+		if (o) {
+			a(o[1], o[2] || o[1]);
+			continue;
+		}
+		let s = n.match(/^(\w+)\s*(--?>>?|--?>>?-|->|-->)\s*(\w+)\s*:\s*(.*)$/);
+		if (s) {
+			let e = s[1], t = s[2], n = s[3], i = s[4];
+			a(e), a(n), r.push({
+				from: e,
+				to: n,
+				label: i,
+				style: t.startsWith("--") ? "dashed" : "solid",
+				arrow: t.includes(">>") ? "filled" : "open"
+			});
+		}
+	}
+	n.forEach((e, t) => {
+		e.x = 30 + t * 160 + 120 / 2;
+	});
+	let o = n.length * 160 + 30, s = 140 + r.length * 50 + 40, c = "";
+	for (let e of n) c += `<rect x="${e.x - 120 / 2}" y="30" width="120" height="40"
+      rx="5" fill="${NODE_COLORS.fill}" stroke="${NODE_COLORS.stroke}" stroke-width="2" />`, c += `<text x="${e.x}" y="55" text-anchor="middle" font-size="13" font-family="system-ui, sans-serif" fill="${NODE_COLORS.text}">${escapeXml(e.label)}</text>`;
+	let l = s - 30 - 40;
+	for (let e of n) c += `<line x1="${e.x}" y1="70" x2="${e.x}" y2="${l}"
+      stroke="#cbd5e1" stroke-width="1" stroke-dasharray="4,4" />`;
+	for (let e = 0; e < r.length; e++) {
+		let t = r[e], n = i.get(t.from), a = i.get(t.to);
+		if (!n || !a) continue;
+		let o = 100 + e * 50, s = n.x, l = a.x, u = t.style === "dashed" ? "stroke-dasharray=\"5,5\"" : "";
+		s === l ? c += `<path d="M ${s} ${o} C ${s + 40} ${o}, ${s + 40} ${o + 20}, ${s} ${o + 20}"
+        fill="none" stroke="${NODE_COLORS.stroke}" stroke-width="1.5" ${u} marker-end="url(#arrowhead)" />` : c += `<line x1="${s}" y1="${o}" x2="${l}" y2="${o}"
+        stroke="${NODE_COLORS.stroke}" stroke-width="1.5" ${u} marker-end="url(#arrowhead)" />`;
+		let d = (s + l) / 2;
+		c += `<text x="${d}" y="${o - 8}" text-anchor="middle" font-size="12" font-family="system-ui, sans-serif" fill="${NODE_COLORS.text}">${escapeXml(t.label)}</text>`;
+	}
+	for (let e of n) c += `<rect x="${e.x - 120 / 2}" y="${l}" width="120" height="40"
+      rx="5" fill="${NODE_COLORS.fill}" stroke="${NODE_COLORS.stroke}" stroke-width="2" />`, c += `<text x="${e.x}" y="${l + 40 / 2 + 5}" text-anchor="middle" font-size="13" font-family="system-ui, sans-serif" fill="${NODE_COLORS.text}">${escapeXml(e.label)}</text>`;
+	return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${o} ${s}" width="100%" class="mermaid-svg" style="max-width:${o}px;">
+    <defs>
+      <marker id="arrowhead" markerWidth="10" markerHeight="7" refX="10" refY="3.5" orient="auto">
+        <polygon points="0 0, 10 3.5, 0 7" fill="${NODE_COLORS.stroke}" />
+      </marker>
+    </defs>
+    <rect width="100%" height="100%" fill="${NODE_COLORS.bg}" rx="8" />
+    ${c}
+  </svg>`;
+}
+function renderPieChart(e) {
+	let t = e.split("\n").map((e) => e.trim()).filter((e) => e && !e.startsWith("%%")), n = [], r = "";
+	for (let e of t) {
+		if (e.toLowerCase().startsWith("pie")) continue;
+		let t = e.match(/^title\s+(.+)$/i);
+		if (t) {
+			r = t[1];
+			continue;
+		}
+		let i = e.match(/^"([^"]+)"\s*:\s*(\d+(?:\.\d+)?)$/);
+		i && n.push({
+			label: i[1],
+			value: parseFloat(i[2]),
+			color: COLORS[n.length % COLORS.length]
+		});
+	}
+	let i = n.reduce((e, t) => e + t.value, 0);
+	if (i === 0) return "<div class=\"mermaid-error\">No data for pie chart</div>";
+	let a = "";
+	r && (a += `<text x="150" y="20" text-anchor="middle" font-size="16" font-weight="bold" font-family="system-ui, sans-serif" fill="${NODE_COLORS.text}">${escapeXml(r)}</text>`);
+	let o = -Math.PI / 2;
+	for (let e of n) {
+		let t = e.value / i * 2 * Math.PI, n = 150 + 120 * Math.cos(o), r = 150 + 120 * Math.sin(o), s = 150 + 120 * Math.cos(o + t), c = 150 + 120 * Math.sin(o + t), l = t > Math.PI ? 1 : 0;
+		a += `<path d="M 150 150 L ${n} ${r} A 120 120 0 ${l} 1 ${s} ${c} Z"
+      fill="${e.color}" stroke="white" stroke-width="2" />`;
+		let u = o + t / 2, d = 150 + 78 * Math.cos(u), f = 150 + 78 * Math.sin(u), p = Math.round(e.value / i * 100);
+		p > 5 && (a += `<text x="${d}" y="${f + 4}" text-anchor="middle" font-size="12" font-weight="bold" font-family="system-ui, sans-serif" fill="white">${p}%</text>`), o += t;
+	}
+	for (let e = 0; e < n.length; e++) {
+		let t = 50 + e * 25;
+		a += `<rect x="320" y="${t - 8}" width="14" height="14" rx="3" fill="${n[e].color}" />`, a += `<text x="342" y="${t + 4}" font-size="12" font-family="system-ui, sans-serif" fill="${NODE_COLORS.text}">${escapeXml(n[e].label)} (${Math.round(n[e].value / i * 100)}%)</text>`;
+	}
+	return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 520 ${Math.max(300, n.length * 25 + 80)}" width="100%" class="mermaid-svg" style="max-width:520px;">
+    <rect width="100%" height="100%" fill="${NODE_COLORS.bg}" rx="8" />
+    ${a}
+  </svg>`;
+}
+function renderMermaid(e) {
+	let t = e.trim(), n = t.split("\n")[0].trim().toLowerCase();
+	try {
+		return n.startsWith("graph") || n.startsWith("flowchart") ? renderFlowchartSVG(t) : n.startsWith("sequencediagram") || n.startsWith("sequence") ? renderSequenceDiagram(t) : n.startsWith("pie") ? renderPieChart(t) : `<div class="mermaid-fallback">
+      <div style="padding:16px;background:#f8fafc;border:1px solid #e2e8f0;border-radius:8px;font-family:monospace;font-size:13px;white-space:pre-wrap;color:#475569;">
+        <div style="font-weight:600;margin-bottom:8px;color:#6366f1;">📊 Mermaid Diagram</div>
+        ${escapeXml(t)}
+      </div>
+    </div>`;
+	} catch {
+		return "<div class=\"mermaid-error\" style=\"padding:16px;background:#fef2f2;border:1px solid #fecaca;border-radius:8px;color:#991b1b;\">\n      Error rendering diagram\n    </div>";
+	}
+}
+var DEFAULT_OPTIONS = {
+	math: !0,
+	highlight: !0,
+	mermaid: !0,
+	tables: !0,
+	classPrefix: "sd",
+	onCodeBlock: () => {},
+	onUpdate: () => {},
+	streaming: !0,
+	cursor: "▋",
+	gfm: !0
+};
+function escapeHtml(e) {
+	return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function processInline(e, t) {
+	let n = e;
+	return n = n.replace(/`([^`]+)`/g, "<code class=\"sd-inline-code\">$1</code>"), t.math && !t.streaming && (n = n.replace(/(?<!\$)\$(?!\$)(.+?)(?<!\$)\$(?!\$)/g, (e, t) => renderInlineMath(t))), n = n.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, "<img src=\"$2\" alt=\"$1\" class=\"sd-image\" loading=\"lazy\" />"), n = n.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "<a href=\"$2\" class=\"sd-link\" target=\"_blank\" rel=\"noopener noreferrer\">$1</a>"), n = n.replace(/\*\*\*(.+?)\*\*\*/g, "<strong><em>$1</em></strong>"), n = n.replace(/___(.+?)___/g, "<strong><em>$1</em></strong>"), n = n.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>"), n = n.replace(/__(.+?)__/g, "<strong>$1</strong>"), n = n.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "<em>$1</em>"), n = n.replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, "<em>$1</em>"), t.gfm && (n = n.replace(/~~(.+?)~~/g, "<del>$1</del>")), n = n.replace(/\^([^\s^]+)\^/g, "<sup>$1</sup>"), n = n.replace(/==(.+?)==/g, "<mark>$1</mark>"), n;
+}
+function renderTable(e) {
+	if (e.length < 2) return "";
+	let t = (e) => e.replace(/^\|/, "").replace(/\|$/, "").split("|").map((e) => e.trim()), n = t(e[0]), r = t(e[1]).map((e) => e.startsWith(":") && e.endsWith(":") ? "center" : e.endsWith(":") ? "right" : "left"), i = "<div class=\"sd-table-wrapper\"><table class=\"sd-table\"><thead><tr>";
+	for (let e = 0; e < n.length; e++) i += `<th style="text-align:${r[e] || "left"}">${n[e]}</th>`;
+	i += "</tr></thead><tbody>";
+	for (let a = 2; a < e.length; a++) {
+		let o = t(e[a]);
+		i += "<tr>";
+		for (let e = 0; e < n.length; e++) i += `<td style="text-align:${r[e] || "left"}">${o[e] || ""}</td>`;
+		i += "</tr>";
+	}
+	return i += "</tbody></table></div>", i;
+}
+function render(e, t) {
+	let n = {
+		...DEFAULT_OPTIONS,
+		...t
+	}, r = e.split("\n"), i = [], a = 0, o = !1;
+	function s() {
+		o &&= (i.push("</p>"), !1);
+	}
+	for (; a < r.length;) {
+		let e = r[a], t = e.trimEnd();
+		if (t === "") {
+			s(), a++;
+			continue;
+		}
+		if (n.math && t.startsWith("$$")) {
+			s();
+			let e = [];
+			if (t.length > 2 && t.endsWith("$$") && t !== "$$") {
+				let e = t.slice(2, -2).trim();
+				i.push(`<div class="sd-math-display">${renderDisplayMath(e)}</div>`), a++;
+				continue;
+			}
+			for (a++; a < r.length && !r[a].trimEnd().startsWith("$$");) e.push(r[a]), a++;
+			a < r.length && a++;
+			let n = e.join("\n").trim();
+			i.push(`<div class="sd-math-display">${renderDisplayMath(n)}</div>`);
+			continue;
+		}
+		if (t.startsWith("```")) {
+			s();
+			let e = t.slice(3).trim(), o = [];
+			for (a++; a < r.length && !r[a].trimEnd().startsWith("```");) o.push(r[a]), a++;
+			a < r.length && a++;
+			let c = o.join("\n");
+			if (n.mermaid && e.toLowerCase() === "mermaid") {
+				i.push(`<div class="sd-mermaid">${renderMermaid(c)}</div>`);
+				continue;
+			}
+			let l = n.highlight ? highlightCode(c, e) : escapeHtml(c), u = e ? getLanguageDisplayName(e) : "", d = u ? `<div class="sd-code-lang">${escapeHtml(u)}</div>` : "";
+			i.push(`<div class="sd-code-block">${d}<pre class="sd-pre"><code class="language-${escapeHtml(e || "text")}">${l}</code></pre></div>`), e && c && n.onCodeBlock(e, c);
+			continue;
+		}
+		let c = t.match(/^(#{1,6})\s+(.+)$/);
+		if (c) {
+			s();
+			let e = c[1].length, t = processInline(c[2], n), r = c[2].toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+			i.push(`<h${e} id="${r}" class="sd-h${e}">${t}</h${e}>`), a++;
+			continue;
+		}
+		if (/^(-{3,}|\*{3,}|_{3,})$/.test(t)) {
+			s(), i.push("<hr class=\"sd-hr\" />"), a++;
+			continue;
+		}
+		if (t.startsWith(">")) {
+			s();
+			let e = [];
+			for (; a < r.length && (r[a].trimEnd().startsWith(">") || r[a].trim() !== "" && e.length > 0);) {
+				let t = r[a].trimEnd();
+				if (t.startsWith(">")) e.push(t.replace(/^>\s?/, ""));
+				else if (t.trim() === "") break;
+				else e.push(t);
+				a++;
+			}
+			let t = render(e.join("\n"), n), o = e[0]?.match(/^\[!(NOTE|TIP|WARNING|CAUTION|IMPORTANT)\]\s*(.*)$/i);
+			if (o) {
+				let t = o[1].toLowerCase(), r = o[2] || o[1], a = render(e.slice(1).join("\n"), n);
+				i.push(`<div class="sd-callout sd-callout-${t}"><div class="sd-callout-title">${{
+					note: "📝",
+					tip: "💡",
+					warning: "⚠️",
+					caution: "🔴",
+					important: "❗"
+				}[t] || "📌"} ${escapeHtml(r)}</div><div class="sd-callout-body">${a}</div></div>`);
+			} else i.push(`<blockquote class="sd-blockquote">${t}</blockquote>`);
+			continue;
+		}
+		if (n.tables && t.includes("|") && a + 1 < r.length && /^\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/.test(r[a + 1]?.trimEnd() || "")) {
+			s();
+			let e = [];
+			for (; a < r.length && r[a].trimEnd().includes("|");) e.push(r[a].trimEnd()), a++;
+			i.push(renderTable(e));
+			continue;
+		}
+		if (/^(\s*)([-*+])\s/.test(e)) {
+			s();
+			let e = [];
+			for (; a < r.length;) {
+				let t = r[a].match(/^(\s*)([-*+])\s(.*)$/);
+				if (t) {
+					let r = t[1].length, i = t[3], o;
+					if (n.gfm) {
+						let e = i.match(/^\[([ xX])\]\s(.*)/);
+						e && (o = e[1] !== " ", i = e[2]);
+					}
+					e.push({
+						indent: r,
+						content: i,
+						checked: o
+					}), a++;
+				} else if (r[a].trim() === "") {
+					a++;
+					break;
+				} else break;
+			}
+			i.push("<ul class=\"sd-list sd-ul\">");
+			for (let t of e) {
+				let e = t.indent > 0 ? ` style="margin-left:${t.indent * 10}px"` : "";
+				if (t.checked !== void 0) {
+					let r = t.checked ? "☑" : "☐";
+					i.push(`<li class="sd-li sd-task-item"${e}><span class="sd-checkbox">${r}</span> ${processInline(t.content, n)}</li>`);
+				} else i.push(`<li class="sd-li"${e}>${processInline(t.content, n)}</li>`);
+			}
+			i.push("</ul>");
+			continue;
+		}
+		if (/^(\s*)\d+\.\s/.test(e)) {
+			s();
+			let e = [];
+			for (; a < r.length;) {
+				let t = r[a].match(/^(\s*)\d+\.\s(.*)$/);
+				if (t) e.push({
+					indent: t[1].length,
+					content: t[2]
+				}), a++;
+				else if (r[a].trim() === "") {
+					a++;
+					break;
+				} else break;
+			}
+			i.push("<ol class=\"sd-list sd-ol\">");
+			for (let t of e) {
+				let e = t.indent > 0 ? ` style="margin-left:${t.indent * 10}px"` : "";
+				i.push(`<li class="sd-li"${e}>${processInline(t.content, n)}</li>`);
+			}
+			i.push("</ol>");
+			continue;
+		}
+		o ? i.push("<br />") : (i.push("<p class=\"sd-p\">"), o = !0), i.push(processInline(t, n)), a++;
+	}
+	return s(), i.join("\n");
+}
+var StreamdownRenderer = class {
+	buffer = "";
+	options;
+	listeners = [];
+	constructor(e) {
+		this.options = {
+			...DEFAULT_OPTIONS,
+			...e
+		};
+	}
+	push(e) {
+		this.buffer += e;
+		let t = this.render();
+		return this.notify(t), t;
+	}
+	render() {
+		let e = render(this.buffer, this.options);
+		return this.options.streaming && this.options.cursor && (e += `<span class="sd-cursor">${this.options.cursor}</span>`), e;
+	}
+	finish() {
+		let e = {
+			...this.options,
+			streaming: !1
+		}, t = render(this.buffer, e);
+		return this.notify(t), t;
+	}
+	reset() {
+		this.buffer = "", this.notify("");
+	}
+	getBuffer() {
+		return this.buffer;
+	}
+	onUpdate(e) {
+		return this.listeners.push(e), () => {
+			this.listeners = this.listeners.filter((t) => t !== e);
+		};
+	}
+	notify(e) {
+		for (let t of this.listeners) t(e);
+		this.options.onUpdate(e);
+	}
+};
+function useStreamdown(r) {
+	let [i, a] = useState(""), [o, s] = useState(!1), c = useRef(null), l = useRef(null);
+	return {
+		html: i,
+		isStreaming: o,
+		start: useCallback(() => {
+			l.current &&= (l.current(), null), c.current = new StreamdownRenderer(r), l.current = c.current.onUpdate(a), s(!0), a("");
+		}, [r]),
+		push: useCallback((e) => {
+			c.current && c.current.push(e);
+		}, []),
+		finish: useCallback(() => {
+			c.current && (a(c.current.finish()), s(!1));
+		}, []),
+		reset: useCallback(() => {
+			c.current && c.current.reset(), a(""), s(!1);
+		}, []),
+		render: useCallback((e) => {
+			let t = render(e, {
+				...r,
+				streaming: !1
+			});
+			return a(t), t;
+		}, [r])
+	};
+}
+export { StreamdownRenderer, getLanguageDisplayName, highlightCode, render, renderDisplayMath, renderInlineMath, renderMermaid, useStreamdown };