docmedown 0.1.7 → 0.9.0

package/dist/prism-CummdiZX.mjs

@@ -0,0 +1,1588 @@
+import { t as e } from "./rolldown-runtime-B0aSnxlc.mjs";
+//#region node_modules/prismjs/prism.js
+var t = /* @__PURE__ */ e(((e, t) => {
+	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);
+		};
+	})();
+}));
+Prism.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: /[{}[\];(),.:]/
+}, 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 = "\\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 = /[*&][^\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), (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), (function(e) {
+	function t(e) {
+		return e = e.replace(/<inner>/g, function() {
+			return "(?:\\\\.|[^\\\\\\n\\r]|(?:\\n|\\r\\n?)(?![\\r\\n]))";
+		}), RegExp("((?:^|[^\\\\])(?:\\\\{2})*)(?:" + e + ")");
+	}
+	var n = "(?:\\\\.|``(?:[^`\\r\\n]|`(?!`))+``|`[^`\\r\\n]+`|[^\\\\|\\r\\n`])+", r = "\\|?__(?:\\|__)+\\|?(?:(?:\\n|\\r\\n?)|(?![\\s\\S]))".replace(/__/g, function() {
+		return n;
+	}), i = "\\|?[ \\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("^" + r + i + "(?:" + r + ")*", "m"),
+			inside: {
+				"table-data-rows": {
+					pattern: RegExp("^(" + r + i + ")(?:" + r + ")*$"),
+					lookbehind: !0,
+					inside: {
+						"table-data": {
+							pattern: RegExp(n),
+							inside: e.languages.markdown
+						},
+						punctuation: /\|/
+					}
+				},
+				"table-line": {
+					pattern: RegExp("^(" + r + ")" + i + "$"),
+					lookbehind: !0,
+					inside: { punctuation: /\||:?-{3,}:?/ }
+				},
+				"table-header-row": {
+					pattern: RegExp("^" + r + "$"),
+					inside: {
+						"table-header": {
+							pattern: RegExp(n),
+							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: t("\\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\\b|\\*\\*(?:(?!\\*)<inner>|\\*(?:(?!\\*)<inner>)+\\*)+\\*\\*"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				content: {
+					pattern: /(^..)[\s\S]+(?=..$)/,
+					lookbehind: !0,
+					inside: {}
+				},
+				punctuation: /\*\*|__/
+			}
+		},
+		italic: {
+			pattern: t("\\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\\b|\\*(?:(?!\\*)<inner>|\\*\\*(?:(?!\\*)<inner>)+\\*\\*)+\\*"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				content: {
+					pattern: /(^.)[\s\S]+(?=.$)/,
+					lookbehind: !0,
+					inside: {}
+				},
+				punctuation: /[*_]/
+			}
+		},
+		strike: {
+			pattern: t("(~~?)(?:(?!~)<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: t("!?\\[(?:(?!\\])<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(c(t.content), s, n);
+			else if (n && n !== "none" && e.plugins.autoloader) {
+				var l = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 0x2386f26fc10000);
+				t.attributes.id = l, e.plugins.autoloader.loadLanguages(n, function() {
+					var t = document.getElementById(l);
+					t && (t.innerHTML = e.highlight(t.textContent, e.languages[n], n));
+				});
+			}
+		}
+	});
+	var a = RegExp(e.languages.markup.tag.pattern.source, "gi"), o = {
+		amp: "&",
+		lt: "<",
+		gt: ">",
+		quot: "\""
+	}, s = String.fromCodePoint || String.fromCharCode;
+	function c(e) {
+		var t = e.replace(a, "");
+		return t = t.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(e, t) {
+			return t = t.toLowerCase(), t[0] === "#" ? s(t[1] === "x" ? parseInt(t.slice(2), 16) : Number(t.slice(1))) : o[t] || e;
+		}), t;
+	}
+	e.languages.md = e.languages.markdown;
+})(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, 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;
+//#endregion
+export { t };